BlogJava-<h1>编程之道</h1>-随笔分类-设计模式http://www.blogjava.net/yuanhuaming/category/2607.html无论是批评的，赞扬的，指着的都请EMAIL给我，你的建议将是我前进的动力! <A href=mailto:yuanhuaming@56.com >联系我</A>zh-cnWed, 28 Feb 2007 03:40:03 GMTWed, 28 Feb 2007 03:40:03 GMT60依赖注入（Ioc）的3种实现方式（作者：夏昕）http://www.blogjava.net/yuanhuaming/archive/2006/02/14/30548.html疯流成性疯流成性Tue, 14 Feb 2006 02:16:00 GMThttp://www.blogjava.net/yuanhuaming/archive/2006/02/14/30548.htmlhttp://www.blogjava.net/yuanhuaming/comments/30548.htmlhttp://www.blogjava.net/yuanhuaming/archive/2006/02/14/30548.html#Feedback0http://www.blogjava.net/yuanhuaming/comments/commentRss/30548.htmlhttp://www.blogjava.net/yuanhuaming/services/trackbacks/30548.html                                                                                     Type1 接口注入
我们常常借助接口来将调用者与实现者分离。如:
    public class ClassA {
        private InterfaceB clzB;
        public doSomething() {
        Ojbect obj =
        Class.forName(Config.BImplementation).newInstance();
        clzB = (InterfaceB)obj;
        clzB.doIt();
        }
        ……
    }
上面的代码中，ClassA依赖于InterfaceB的实现，如何获得InterfaceB实现类的实例？传统的方法是在
代码中创建InterfaceB实现类的实例，并将起赋予clzB。
而这样一来，ClassA在编译期即依赖于InterfaceB的实现。为了将调用者与实现者在编译期分离，于是有
了上面的代码，我们根据预先在配置文件中设定的实现类的类名(Config.BImplementation)，动态
加载实现类，并通过InterfaceB强制转型后为ClassA所用。这就是接口注入的一个最原始的雏形。
而对于一个Type1型IOC容器而言，加载接口实现并创建其实例的工作由容器完成。
如下面这个类:
    public class ClassA {
        private InterfaceB clzB;
        public Object doSomething(InterfaceB b) {
        clzB = b;
        return clzB.doIt();
        }
        ……
    }
在运行期，InterfaceB实例将由容器提供。
Type1型IOC发展较早（有意或无意），在实际中得到了普遍应用，即使在IOC的概念尚未确立时，这样的
方法也已经频繁出现在我们的代码中。
下面的代码大家应该非常熟悉：
    public class MyServlet extends HttpServlet {
        public void doGet(
        HttpServletRequest request,
        HttpServletResponse response)
        throws ServletException, IOException {
        ……
        }
    }
这也是一个Type1 型注入，HttpServletRequest和HttpServletResponse实例由Servlet Container
在运行期动态注入。
另，Apache Avalon是一个较为典型的Type1型IOC容器。

                                                                                  Type2 设值注入
在各种类型的依赖注入模式中，设值注入模式在实际开发中得到了最广泛的应用（其中很大一部分得
力于Spring框架的影响）。
在笔者看来，基于设置模式的依赖注入机制更加直观、也更加自然。Quick Start中的示例，就是典
型的设置注入，即通过类的setter方法完成依赖关系的设置。


                                                                                  Type3 构造子注入
    public class DIByConstructor {
        private final DataSource dataSource;
        private final String message;
        public DIByConstructor(DataSource ds, String msg) {
        this.dataSource = ds;
        this.message = msg;
        }
        ……
    }
构造子注入，即通过构造函数完成依赖关系的设定，如：
可以看到，在Type3类型的依赖注入机制中，依赖关系是通过类构造函数建立，容器通过调用类的构
造方法，将其所需的依赖关系注入其中。
PicoContainer（另一种实现了依赖注入模式的轻量级容器）首先实现了Type3类型的依赖注入模式。


                                                                                几种依赖注入模式的对比总结
接口注入模式因为历史较为悠久，在很多容器中都已经得到应用。但由于其在灵活性、易用性上不如
其他两种注入模式，因而在IOC的专题世界内并不被看好。
Type2和Type3型的依赖注入实现则是目前主流的IOC实现模式。这两种实现方式各有特点，也各具
优势（一句经典废话J）。

Type2 设值注入的优势
1． 对于习惯了传统JavaBean开发的程序员而言，通过setter方法设定依赖关系显得更加直
观，更加自然。
2． 如果依赖关系（或继承关系）较为复杂，那么Type3模式的构造函数也会相当庞大（我们需
要在构造函数中设定所有依赖关系），此时Type2模式往往更为简洁。
3． 对于某些第三方类库而言，可能要求我们的组件必须提供一个默认的构造函数（如Struts
中的Action），此时Type3类型的依赖注入机制就体现出其局限性，难以完成我们期望的功
能。

Type3 构造子注入的优势：
1． “在构造期即创建一个完整、合法的对象”，对于这条Java设计原则，Type3无疑是最好的
响应者。
2． 避免了繁琐的setter方法的编写，所有依赖关系均在构造函数中设定，依赖关系集中呈现，
更加易读。
3． 由于没有setter方法，依赖关系在构造时由容器一次性设定，因此组件在被创建之后即处于
相对“不变”的稳定状态，无需担心上层代码在调用过程中执行setter方法对组件依赖关系
产生破坏，特别是对于Singleton模式的组件而言，这可能对整个系统产生重大的影响。
4． 同样，由于关联关系仅在构造函数中表达，只有组件创建者需要关心组件内部的依赖关系。
对调用者而言，组件中的依赖关系处于黑盒之中。对上层屏蔽不必要的信息，也为系统的
层次清晰性提供了保证。
5． 通过构造子注入，意味着我们可以在构造函数中决定依赖关系的注入顺序，对于一个大量
依赖外部服务的组件而言，依赖关系的获得顺序可能非常重要，比如某个依赖关系注入的
先决条件是组件的DataSource及相关资源已经被设定。



疯流成性 2006-02-14 10:16 发表评论
]]>工厂方法模式http://www.blogjava.net/yuanhuaming/archive/2005/08/08/9571.html疯流成性疯流成性Mon, 08 Aug 2005 06:45:00 GMThttp://www.blogjava.net/yuanhuaming/archive/2005/08/08/9571.htmlhttp://www.blogjava.net/yuanhuaming/comments/9571.htmlhttp://www.blogjava.net/yuanhuaming/archive/2005/08/08/9571.html#Feedback0http://www.blogjava.net/yuanhuaming/comments/commentRss/9571.htmlhttp://www.blogjava.net/yuanhuaming/services/trackbacks/9571.html它克服简单工厂模式的缺点（在不修改具体工厂角色的情况下扩展产品）。在工厂方法模式中，核心的工厂类不在负责所有产品的创建，而是将具体创建的工作交给了子类去做。它仅负责给出具体工厂子类必须实现的接口，而不清楚哪一个产品类应当被实例化。


－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

 

//抽象工厂角色
interface factory{
 public sharp Factory();
}
//---------------------------------------------------------------------------
//具体工厂角色
class circleFactory implements factory{
 public sharp Factory(){
  return new circle();
 }
}
class retangleFactory implements factory{
 public sharp Factory(){
  return new retangle();
 }
}
//--------------------------------------------
//main method
public class test{
 public static void main(String[] args){
  new circleFactory().Factory();
 }
}

//--------------------------------------------
//具体产品角色
class circle implements sharp{
 public circle(){
  this.draw();
 }
 public void draw(){
  System.out.println ("draw1");
 }
 public void del(){
  System.out.println ("del1");
 }
}

class retangle implements sharp{
 public retangle(){
 }
 public void draw(){
  System.out.println ("draw2");
 }
 public void del(){
  System.out.println ("del2");
 }
}

//抽象产品角色
interface sharp{
 public void draw();
 public void del();
 
}



 



疯流成性 2005-08-08 14:45 发表评论
]]>静态工厂模式http://www.blogjava.net/yuanhuaming/archive/2005/08/08/9570.html疯流成性疯流成性Mon, 08 Aug 2005 06:44:00 GMThttp://www.blogjava.net/yuanhuaming/archive/2005/08/08/9570.htmlhttp://www.blogjava.net/yuanhuaming/comments/9570.htmlhttp://www.blogjava.net/yuanhuaming/archive/2005/08/08/9570.html#Feedback0http://www.blogjava.net/yuanhuaming/comments/commentRss/9570.htmlhttp://www.blogjava.net/yuanhuaming/services/trackbacks/9570.html又称简单工厂模式。
它是由一个工厂类所根据传入的参量决定创建出哪一种产品类的实例。
它涉及到3个角色
1。工厂类角色（Creator）：这个角色时工厂模式的核心，工厂类再客户端的直接调用下创建产品对象，它往往由一个具体JAVA类实现。
2。抽象产品角色（Product）：担任这个角色的类是由工厂方法模式所创建的对象的父类或者接口。抽象产品角色可以用接口或者抽象类实现。
3。具体产品角色（Concrete Product）：工厂方法模式所创建的任何对象都是这个角色的实例，具体产品角色由一个具体JAVA类来实现。

    简单工厂模式的缺点是进行功能扩展比较困难。按下面例子来说，如果增加一个形状，那么就要修改工厂方法
的源代码，违背了“开闭”原则。
    开闭原则：就是在不修改代码的情况下扩展其功能。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
写了个静态工厂模式的例子

 

//工厂类
public class test{
 public static sharp factory(String s) throws badException
 {
  if(s.equals("circle")){ //当传入的参数＝＝circle时，return实例化的circle
   return new circle();
  }
  else if(s.equals("retangle"))
  {
   return new retangle();
  }
  else{
   throw new badException("error");//抛出异常，必须捕获异常
  }
 }
 public static void main(String[] args){
  try{
   test.factory("circle");//调用static method
  }
  catch(badException e){
   System.out.println (e);
  }
  
 }
}


class circle implements sharp{
 public circle(){
  this.draw();
 }
 public void draw(){
  System.out.println ("draw1");
 }
 public void del(){
  System.out.println ("del1");
 }
}

class retangle implements sharp{
 public void draw(){
  System.out.println ("draw2");
 }
 public void del(){
  System.out.println ("del2");
 }
}


class badException extends Exception{
 public badException(String s){
  super(s);
 }
}
//定义接口
interface sharp{
 public void draw();
 public void del();
 
}




 



疯流成性 2005-08-08 14:44 发表评论
]]>