面向对象的设计原则（2）——依赖注入

面向对象的设计原则（1）中提到的设计方法都是一种数据组织的一种方式，这几种都是 主动依赖（主动去索取对象）  业务的东西都需要依赖框架的东西

 

1、如果依赖的框架坏了

2、或者要由静态工厂 改为 环境变量   这两种情况都需要改变

 

为了解决上述问题，引入  对象注入（依赖注入——电视依赖面板、依赖反转——框架的东西依赖于业务的东西）

 

例1：

package objectoriented.coupling5;

import java.util.HashMap;
import java.util.Map;


public class Example {
    public static void main(String[] args) {
        Context context = new Context();
        Television tv = (Television) context.getService("tv"); //取出来的电视剧这个对象，它所需要的部件已经被装配好并且已经被实例化好了
        
        tv.play();
    }
}

/*1、上下文的类（框架类），框架类依赖于业务类
 * 2、该框架类包含一全局注册表（全局map）
 * 3、框架类的构造方法完成对象的注入（比如电视需要用面板拼装）：
 *     前提：电视类需要有一个设置面板类的方法，void setPanel(Panel panel)
 *     （1）new一个面板实例，注册到map
 *  （2）new一个电视实例，调用setPanel方法完成面板拼装——这一个过程就称为对象注入，然后也注册到map
 * 4、调用的地方（比如main方法）从全局map取出电视对象，就可以操作电视了
 * 
 */


/*上下文*/
class Context {
    private final Map<String, Object> services = new HashMap<String, Object>();  //类似于全局注册表
    
    /*表达了不同组价是如何构造起来的一种关系*/
    // 框架类依赖于业务类，但业务类不依赖于框架类：依赖反转
    // Spring就用xml文件来表示，然后利用反射
    public Context() {
        // 此部分为各个组价的装配方式，可以使用配置文件实现，然后再用反射加载类
        LcdPanel panel = new LcdPanel();
        registerService("panel", panel);
        
        /*new, 然后马上调用set方法完成对象注入；如果new之后把这个对象放入全局中，
         * 还未对象注入时就被另一个线程调用(或者忘了调用对象注入了)会报空指针；*/
        Television tv = new Television();
        tv.setPanel(panel);    //主动的装配过程，完成了电视和面板的组装——对象的注入
        registerService("tv", tv);
    }
    
    public Object getService(String serviceName) {
        return services.get(serviceName);
    }
    
    private void registerService(String serviceName, Object service) {
        services.put(serviceName, service);
    }
}



/*没有从框架中进行任何索取我们需要的资源，而是有一个set方法，这个方法
 * 任何人包括框架都能调用
 * 
 * 电视剧没有任何框架代码存在*/
class Television {
    private Panel panel;  //没有new及其它任何的初始化
                          // 使用组合比使用继承好，电视机使用组合的方式拼装了一个面板，面板可以在运行时很灵活的改变
    
    void setPanel(Panel panel) { //每一个属性，都需要一个set方法，让它能够被注入进来，使得面板能够被真正装配起来 
                                //运行时传入一个lcd外的其他面板，下次播放时，可以无缝切换
        this.panel = panel;
    }
    
    void play() {
        panel.display();
    }
}


interface Panel {
    abstract public void display();
}

class LcdPanel implements Panel {
    int size = 32;
    
    LcdPanel() {
    }
    
    LcdPanel(int size) {
        this.size = size;
    }
    
    public void display() {
        System.out.println("尺寸=" + size + "，LcdPanel现在开始播放...");
    }
}

class CrtPanel implements Panel {
    int size = 32;
    
    CrtPanel() {
    }
    
    CrtPanel(int size) {
        this.size = size;
    }
    
    public void display() {
        System.out.println("尺寸=" + size + "，CrtPanel现在开始播放...");
    }
}

原理与实现：

/*1、上下文的类（框架类），框架类依赖于业务类
 * 2、该框架类包含一全局注册表（全局map）
 * 3、框架类的构造方法完成对象的注入（比如电视需要用面板拼装）：
 *     前提：电视类需要有一个设置面板类的方法，void setPanel(Panel panel)
 *     （1）new一个面板实例，注册到map
 *  （2）new一个电视实例，调用setPanel方法完成面板拼装——这一个过程就称为对象注入，然后也注册到map
 * 4、调用的地方（比如main方法）从全局map取出电视对象，就可以操作电视了
 */

对象注入：

  1、依赖注入（Dependency Injection）——对象通过注入的方式组织起来

  2、控制反转（Inversion of Contorl）——框架对业务代码无侵入，即业务代码不依赖于框架代码，反过来框架代码依赖于业务代码

 

Spring的对象注入方式：

1、Setter Injection（类似于上面的例子）

　　（1）每个依赖都有setter方法，简单直观

       （2）可以在运行时手动改变依赖——// 此部分为各个组价的装配方式，可以使用配置文件实现，然后再用反射加载类
                                                               LcdPanel panel = new LcdPanel();

　　（3）不足：对象的创建和依赖注入是两个步骤

/*new, 然后马上调用set方法完成对象注入；如果new之后把这个对象放入全局中，
         * 还未对象注入时就被另一个线程调用(或者忘了调用对象注入了)会报空指针；*/

2、Construction Injection

　　（1）对象的创建和注入是原子操作——new的时候  必须一起提供需要的所有属性

　　（2）不足：构造器参数过多

　　（3）不足：依赖不能修改——当应用本身就要求不能修改时，用构造器注入比较安全

3、Interface Injection——用的不多

例2：google-guice ： 基于Java5的轻型依赖注入框架

package guiceexample;

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;

//如下两个不引入编译不报错，运行时Exception in thread "main" java.lang.NoClassDefFoundError: javax/inject/Provider等
import javax.inject.Provider;
import org.aopalliance.intercept.MethodInterceptor;


public class Example {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new MyModule());
        Television tv = injector.getInstance(Television.class); //类似于全局注册表
        tv.play();
    }
}


//这个Module掌管了三个东西(configure方法里面)，具体面板如何装配电视是不需要在这里体现的，只要在Television里面的Panel对象前加入@Inject
class MyModule extends AbstractModule {
    @Override  
    protected void configure() {  //说明这些对象之间是如何进行装配的
        bind(Panel.class).to(LcdPanel.class);  //接口和实现类关联起来
    //    bind(Panel.class).to(CrtPanel.class);
        bind(Television.class);
    }
    
}


class Television {
    @Inject  
    private Panel panel; //使用的时候只要加上@Inject注解，guice自然知道电视是需要注入一个面板的，它就会自动帮你完成注入
                         //业务代码中，这里需要装配的代码多半都是抽象的
    void play() {
        panel.display();
    }
}



interface Panel {
    abstract public void display();
}

class LcdPanel implements Panel {
    int size = 32;
    
    LcdPanel() {
    }
    
    LcdPanel(int size) {
        this.size = size;
    }
    
    public void display() {
        System.out.println("尺寸=" + size + "，LcdPanel现在开始播放...");
    }
}

class CrtPanel implements Panel {
    int size = 32;
    
    CrtPanel() {
    }
    
    CrtPanel(int size) {
        this.size = size;
    }
    
    public void display() {
        System.out.println("尺寸=" + size + "，CrtPanel现在开始播放...");
    }
}

注意1：下载guice-3.0，工程里需要引入guice-3.0.jar、javax.inject.jar、aopalliance.jar

注意2：如果放开第27行，会报如下的错误——A binding to guiceexample.Panel was already configured at guiceexample.MyModule.configure

 

Guice与Spring的不同：

1、专注于依赖注入

2、性能号称是Spring的10倍

3、无配置文件、类型安全，支持编译器重构

4、简单

Spring：做了很多跟框架的粘合，跟Structs、跟持久化框架（hibernate）粘合

Spring3也在做很多无配置文件的注入

 

总结：

1、依赖抽象，而不是依赖实现

2、业务不依赖于框架，框架服务业务

 

Televsion与Panle等装配方之间降低耦合

也使得业务代码与框架代码的依赖方式发生转变，我们通常说的是依赖抽象，而不是依赖于具体的实现

class Television {

@Inject  

private Panel panel; 

                     //业务代码中，这里需要装配的代码多半都是抽象的；具体的面板发生升级的时候，电视机这个类不需要变更