SpringIOC随笔（一）

布满荆棘的人生 2022-12-16 14:24 153阅读 0赞

# SpringIOC随笔（一） #

1.  ### 首先SpringIOC是什么： ###
    
    1.  IOC(Inversion of Control)：意为控制反转。
    2.  这是一种编程思想，不是一种技术！
    3.  我们把创建对象和对象之间的装配交给容器来管理。我们不用自己创建和管理这些对象，只需要使用什么对象的时候直接get就ok。
2.  ### 先看看没有IOC代码会是什么亚子 ###
    
    1.  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吧。
3.  ### 利用Spring框架来实现 ###
    
    1.  引入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>
    2.  在原来的基础上改动代码
        
        1.  把上面的代码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);
                    }
                }
    3.  编写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="userDaoMybatisImpl"/>
                </bean>
            
            </beans>
    4.  修改测试类
        
            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**。
4.  ### 这里我们先简单了解一下SpringIOC后续在详细介绍配置bean的方法。 ###