Spring核心 IoC使用



Spring核心 IoC使用。

  上篇文章介绍了Ioc和他的作用，简单的来讲，就是由容器控制程序之间的关系，而不是由我们手动编写控制实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在：控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。

        下面通过添加用户的小例子具体来看，首先配置Spring的环境

        1、加入spring的依赖包

             (1).SPRING_HOME/dist/spring.jar

             (2).SPRING_HOME/lib/log4j/log4j-1.2.14.jar

             (3).SPRING_HOME/lib/jakarta-commons/commons-logging.jar

        2、提供spring配置文件applicationContext.xml，一个典型的Spring项目需要创建一个或多个Bean配置文件，这些配置文件用于在Spring IOC容器里配置Bean，这个配置文件最好放在classpath目录下。

        3、提供log4j.properties配置文件

创建项目，写Dao层接口IUserDao.java

  1. public interface IUserDao {
  2.           public void InsertUser(String username,String password);
  3. }

 

 

Dao接口的实现类 UserDaoImpl.java

  1. public class UserDaoImpl implements IUserDao{
  2.          @Override
  3.          public void InsertUser(String username, String password){
  4.               System.out.println(“—-UserDaoImpl –addUser—-”);
  5.          }
  6.  }

 

业务层接口IUserManager.java

  1. public interface IUserManager {
  2.           public void addUser(String username,String password);
  3. }

 

 

业务层接口的实现UserManagerImpl.java

  1. public class UserManagerImpl implements IUserManager {
  2.       private IUserDao  userDao;
  3.       @Override
  4.       public void addUser(String username, String password) {
  5.             userDao=new IUserDaoImpl();
  6.             userDao.InsertUser(username,password);
  7.       }
  8.  }

 

 

其实从这里就可以看出，业务层其实也是依赖了Dao层的具体实现，没有起到解耦的作用。

   Client.java

  1. public classClient {
  2.     public static void main(String[] args) {
  3.         IUserManager usermanager=new UserManagerImpl();
  4.         userManager.addUser(“wanghuan”,”password”);
  5.     }
  6. }

 

 


       从客户端的代码里，我们也可以看出，跟上篇文章的例子是一样的，客户端也还是依赖于业务层的具体实现。接下来我们使用IOC容器。

       使用IOC容器很简单，就是将我们的对象放到配置文件里，让Spring知道，从而由Spring来帮我们管理。

       Spring 框架的 IOC 容器常用两种方法实现：

         （一）【setter方法注入】：通过 JavaBean的属性分配依赖性。

         （二）【构造器注入】：依赖性以构造函数的形式提供，不以 JavaBean 属性的形式公开。

       首先看setter方法注入，是IOC通过set方法将需要的对象注入。需要提供被注入对象的set方法。

  1. Public  class  UserManagerImpl  implements  UserManager {
  2.     private  IUserDao  userDao;
  3.     //set方法
  4.     public void  setUserDao(IUserDao  userDao) {
  5.        this.userDao = userDao;
  6.     }
  7.     @Override
  8.     public void addUser(String username, String password) {
  9.       //不需要实例化，直接可以使用
  10.       userDao.InsertUser(username,password);
  11.   }
  12. }

 

        重点是配置Spring的核心配置文件applicationContext.xml，在配置文件中配置上userDao的信息，使得IOC容器自己将UserDao对象注入到UserManagerImpl中。

applicationContext.xml

  1. <?xml version=”1.0″encoding=”UTF-8″?>
  2. <beans xmlns=”http://www.springframework.org/schema/beans”
  3.          xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
  4.          xmlns:aop=”http://www.springframework.org/schema/aop”
  5.          xmlns:tx=”http://www.springframework.org/schema/tx”
  6.          xsi:schemaLocation=”http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.0.xsd
  7.           http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.0.xsd
  8.           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd”>
  9. <!–id名字自己取，class表示他代表的类，如果在包里的话需要加上包名–>
  10. <bean id=”userManager”  class=”UserManagerImpl” >
  11.     <!—property代表是通过set方法注入,ref的值表示注入的内容–>
  12.      <property  name=”userDao”  ref=”userDao”/>
  13.  </bean>
  14. <bean id=”userDao”  class=”UserDaoImpl”/>
  15. </beans>

 

 

        这样我们就可以看出，业务层里只出现了Dao层的接口，是依赖于接口，而没有依赖于真正的实现。客户端对业务层的依赖是同样道理，可以只依赖业务层接口，通过IOC注入解决。

        下面看另一种通过构造器注入。这种方法不需要提供set方法，但需要提供构造方法。看代码：

  1. Public  class  UserManagerImpl  implements  UserManager {
  2.     private  IUserDao  userDao;
  3.     //构造函数
  4.     public  UserManagerImpl(IUserDao  userDao) {
  5.        this.userDao = userDao;
  6.     }
  7.         @Override
  8.     public void addUser(String username, String password) {
  9.        userDao.InsertUser(username,password);
  10.     }
  11. }

 

配置文件也有不同：

applicationContext.xml

  1. <?xml version=”1.0″encoding=”UTF-8″?>
  2. <beans xmlns=”http://www.springframework.org/schema/beans”
  3.          xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
  4.          xmlns:aop=”http://www.springframework.org/schema/aop”
  5.          xmlns:tx=”http://www.springframework.org/schema/tx”
  6.          xsi:schemaLocation=”http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.0.xsd
  7.           http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.0.xsd
  8.           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd”>
  9. <bean id=”userManager” class=”UserManagerImpl” >
  10.     <!—constructor-arg代表是通过构造函数注入,ref的值表示注入的内容–>
  11.     <constructor-arg  ref=”userDao ”/>
  12.  </bean>
  13. <bean id=”userDao” class=”UserDaoImpl”/>
  14. </beans>

 

这两种注入方式，在客户端进行调用都是一样的。来看客户端代码：

  1. public  class  Client{
  2. public staticvoidmain(String[] args) {
  3.       /*这句话就不用出现了
  4.              IUserManager  usermanager=new UserManagerImpl();
  5.       */
  6.        //使用Spring的工厂将ioc容器中的对象取出
  7.        BeanFactory factory=newClassPathXmlApplicationContext(“applicationContext.xml”);
  8.        //依赖于接口，不会出现具体实现
  9.        IUserManager userManager=(IUserManager)factory.getBean(“userManager”);
  10.        userManager.addUser(“wanghuan”, ”password”);
  11.     }
  12. }

 

       上篇文章的解耦过程于上文相同，都是将对象交与IOC容器管理，避免在程序中出现具体实现。通过代码我们可以看出IOC依赖注入的好处:

       1.对象之间的依赖关系,不由对象自身来负责,而是由容器依据配置文件动态建立，这样就很灵活，可配。

       2.采用依赖注入,模块之间一定是松散耦合的

       3.代码易维护易测试

       如果不使用框架，我们传统的写法一般是自己建立工厂或者用单例来处理业务层与Dao层，而使用了Spring，这些工作我们就都不用管了，而且每层的代码都很清楚。这样就使得真正的业务流程更明确了。