Spring学习心得（9）-- IOC和DI的意义

引入

现在我这里有一个文档接口，里面有读和写的方法。现在有3个类实现了这个接口，分别是word,excel,pdf。然后有一个文档管理类，在文档管理类里面调用文档的读和写的方法。代码实现如下：

public interface Document {
    public void read();
    public void write();
}

public class ExcelDocument implements Document {

    @Override
    public void read() {
        System.out.println("excelRead");
    }

    @Override
    public void write() {
        System.out.println("excelWrite");

    }

}


public class PDFDocument implements Document {

    @Override
    public void read() {
        System.out.println("pdfRead");
    }

    @Override
    public void write() {
        System.out.println("pdfWrite");

    }

}


public class WordDocument implements Document {

    @Override
    public void read() {
        System.out.println("wordRead");
    }

    @Override
    public void write() {
        System.out.println("wordWrite");

    }

}

管理类：

public class DocumentManager {
    //创建document的引用
    private Document document;
    //使用该管理类的时候，把对应的document传进来
    public DocumentManager(Document document) {
        this.document = document;
    }
    //调用接口的方法
    public void read(){
        document.read();
    }
    public void write(){
        document.write();
    }
}

原始的测试方法

public class testDocumentOriginal {
    @Test
    public void testOriginalWay(){
        //首先，我们得自己创建document的实现类。要具体到用哪个类来实现document接口
        Document document=new WordDocument();
        //然后再新建管理类documentManager的实例
        DocumentManager documentManager=new DocumentManager(document);
        //然后调用其中的方法
        documentManager.read();
        documentManager.write();
    }
}
在这里，我们需要考虑到要用哪个类来实现，然后再调用相应类的相应方法

下面来看看利用springIOC和DI对程序进行重写

其中document和word、pdf、excel这四个类的代码不用修改，我们把相应的类配置到applicationContext.xml中

 <bean class="cn.ansel.document.WordDocument" id="wordDocument"></bean>
    <bean class="cn.ansel.document.PDFDocument" id="pdfDocument"></bean>
    <bean class="cn.ansel.document.ExcelDocument" id="excelDocument"></bean>
    <!--
        在这里给document赋值它的实现类，然后再客户端就可以直接调用了
    -->
    <bean class="cn.ansel.document.DocumentManager" id="documentManager">
        <constructor-arg index="0" ref="wordDocument"></constructor-arg>
    </bean>

修改之后的 测试 类：

public class testDoucment {
    @Test
    public void testDOucment(){
    ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
    //在这里直接得到管理类即可
    DocumentManager documentManager=(DocumentManager) applicationContext.getBean("documentManager");
    documentManager.read();
    documentManager.write();
    }
}

spring在Mvc中的应用

在action中调用的是service层，在service层调用的是Dao层。代码如下：

public class StudentAction {
    //调用service层
    private StudentServiceDAO service=new StudentServiceImpl();
    public void saveStudent(){
        service.saveStudent();
    }
}

public class StudentServiceImpl implements StudentServiceDAO {
    private StudentDAO dao=new StudentDAOImpl();
    @Override
    public void saveStudent() {
        dao.saveStudent();
    }

}


public class StudentDAOImpl implements StudentDAO {

    @Override
    public void saveStudent() {
        System.out.println("save student dao");
    }

}

每一层调用下一层的时候，都要创建一个新的实力，但是我们使用springIOC和Di的时候，把它们配置的 spring 容器中，然后只需要给它们的赋值（两种方法），然后直接就可以调用接口来完成调用：

配置文件：
     <!-- 
        在上层的调用下层的，这时候，如果Dao出错，全部出错
      -->
    <bean class="cn.ansel.MVC.StudentAction" id="studentAction">
        <property name="service" ref="studentServiceImpl"></property>
    </bean>
    <bean class="cn.ansel.MVC.StudentServiceImpl" id="studentServiceImpl">
        <property name="dao" ref="studentDAOImpl"></property>
    </bean>
    <bean class="cn.ansel.MVC.StudentDAOImpl" id="studentDAOImpl"></bean>
</beans>


public class StudentAction {
    //调用service层
    private StudentServiceDAO service;

    public StudentServiceDAO getService() {
        return service;
    }
    public void setService(StudentServiceDAO service) {
        this.service = service;
    }
    public void saveStudent(){
        service.saveStudent();
    }
}


public class StudentServiceImpl implements StudentServiceDAO {
    //调用dao
    private StudentDAO dao;
    public StudentDAO getDao() {
        return dao;
    }
    public void setDao(StudentDAO dao) {
        this.dao = dao;
    }
    @Override
    public void saveStudent() {
        dao.saveStudent();
    }

}

//操作数据库
public class StudentDAOImpl implements StudentDAO {

    @Override
    public void saveStudent() {
        System.out.println("save student dao");
    }

}



测试类：


public class testMVC {
    @Test
    public void testMVC(){
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        StudentAction action=(StudentAction) applicationContext.getBean("studentAction");
        action.saveStudent();
    }
}

运行结果： 

总结：

由上面两个例子可以看到，都是在调用接口来完成操作。 
springIOC和DI实现了完全的面向接口编程，我们只需要从客户端拿到实现类，并且调用接口的方法，就可以使用，而不用担心它怎样实现