SpringIOC随笔（一）

首先SpringIOC是什么：
1. IOC(Inversion of Control)：意为控制反转。
2. 这是一种编程思想，不是一种技术！
3. 我们把创建对象和对象之间的装配交给容器来管理。我们不用自己创建和管理这些对象，只需要使用什么对象的时候直接get就ok。

先看看没有IOC代码会是什么亚子

java代码：

public class UserServiceImpl implements UserService {

            private UserDao userDao;
            public UserServiceImpl() {
                //this.userDao = new UserDaoHibernateImpl();
                this.userDao = new UserDaoMybatisImpl();
            }
            @Override
            public void addUser(User user) {
                userDao.addUser(user);
            }
        }
        public class UserDaoHibernateImpl implements UserDao {
            @Override
            public void addUser(User user) {
                System.out.println("Hibernate add:" + user);
            }
        }
        public class UserDaoMybatisImpl implements UserDao {
            @Override
            public void addUser(User user) {
                System.out.println("Mybatis add:" + user);
            }
        }
2.  代码没有扩展性。如果换一个实现类，我们需要把代码进行修改，而且对象也要我们自己new。
3.  我们先使用了工厂模式来创建UserDao类型的对象
4.      public class UserDaoFactory {
            public static UserDao createUserDao() {
                UserDao userDao = null;
                try {
                    Properties properties = new Properties();
                    properties.load(UserDaoFactory.class.getClassLoader().getResourceAsStream("daoConfig.properties"));
                    String userDaoClassName = properties.getProperty("UserDao");
                    if (StringUtils.isNotBlank(userDaoClassName)){
                        userDao = (UserDao) Class.forName(userDaoClassName).newInstance();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return userDao;
            }
        }
5.      daoConfig.properties
        UserDao = com.fxyh.spring.dao.impl.UserDaoHibernateImpl
        #UserDao = com.fxyh.spring.dao.impl.UserDaoMybatisImpl
6.      public UserServiceImpl() {
                // 代码没有扩展性。如果现在持久化策略编程mybatis实现，那么此时需要修改程序
                //this.userDao = new UserDaoHibernateImpl();
                //this.userDao = new UserDaoMybatisImpl();
                // 使用工厂来创建这个Dao,然后通过properties配置创建那个Dao实现不用该代码直接切换
                this.userDao = UserDaoFactory.createUserDao();
            }
        在上面Service的构造方法里面创建dao改成工厂创建。
7.      Test代码：
        public class UserServiceImplTest {
            private UserService userService;
            @Before
            public void setUp(){
                userService = new UserServiceImpl();
            }
            @Test
            public void addUser() {
                User user = new User();
                user.setName("zhangsan");
                user.setPassword("123456");
                userService.addUser(user);
            }
        }
8.  这个以及初步有点IOC的意思了，但是还是很繁琐，还得我们自己new，写工厂，那么我们就进入Spring的IOC吧。

利用Spring框架来实现

引入jar包

<properties>
          <spring.version>4.3.21.RELEASE</spring.version>
      </properties>
      <dependencies>
          <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-core</artifactId>
              <version>${spring.version}</version>
          </dependency>
          <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-context</artifactId>
              <version>${spring.version}</version>
          </dependency>
          <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-beans</artifactId>
              <version>${spring.version}</version>
          </dependency>
          <dependency>
              <groupId>org.apache.commons</groupId>
              <artifactId>commons-lang3</artifactId>
              <version>3.4</version>
          </dependency>
          <dependency>
              <groupId>commons-collections</groupId>
              <artifactId>commons-collections</artifactId>
              <version>3.2.1</version>
          </dependency>
          <dependency>
              <groupId>junit</groupId>
              <artifactId>junit</artifactId>
              <version>4.12</version>
              <scope>test</scope>
          </dependency>
      </dependencies>

在原来的基础上改动代码

把上面的代码Service实现类改动一下，去除构造方法，给userDao加一个set方法

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void addUser(User user) {
        userDao.addUser(user);
    }
}

编写Spring xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userDaoMybatisImpl" class="com.fxyh.spring.dao.impl.UserDaoMybatisImpl"/>
    <bean id="userDaoHibernateImpl" class="com.fxyh.spring.dao.impl.UserDaoHibernateImpl"/>
    <bean id="userService" class="com.fxyh.spring.service.impl.UserServiceImpl">
<!--        <property name="userDao" ref="userDaoHibernateImpl"/>-->
        <property name="userDao" ref="userDaoMybatisImpl"/>
    </bean>
</beans>

修改测试类
```
public class UserServiceImplTest {
```

            private ApplicationContext context;
            private UserService userService;
            @Before
            public void setUp() throws Exception {
                this.context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        //        this.userService = (UserService) this.context.getBean("userService");
                this.userService = this.context.getBean(UserService.class);
            }
            @Test
            public void addUser() {
                User user = new User();
                user.setName("zhangsan");
                user.setPassword("123456");
                userService.addUser(user);
            }
        }
5.  我们需要切换一个dao的实现类只需要在xml中改变property就可以实现，Spring中，我们不需要写工厂，我们直接配置一些便可以实现。
6.  其实这里的话，**property中的name就是调用了我们的setUserDao方法，把name的首字母大写，然后在前面拼上set**。