Spring（四）基于xml的IoC案例 && 使用注解进行改造 && Spring整合JUnit

港控/mmm° 2021-06-22 15:37 412阅读 1赞

### 目录 ###

*  基于xml的IoC案例
 *  一、准备
 *   *  1. 新建一个maven工程：
     *  2. 导入坐标
     *  3. 建立数据库，准备数据
     *  4. 创建账户实体类
     *  5. 业务层
     *   *  ① 接口\`IAccountService\`
         *  ② 业务层实现类\`AccountServiceImpl\`
     *  6. 持久层
     *   *  ① 接口\`IAccountDao\`
         *  ② 实现类\`AccountDaoImpl\`（重要）
 *  二、编写Spring的IoC配置
 *  三、测试类的测试方法
 *  四、基于注解的改造
 *   *  1. bean.xml
     *  2. 业务层实现类
     *  3. 持久层实现类
 *  五、Spring的纯注解配置
 *   *  1. 问题
     *  2. \`@Configuration\`
     *  3. \`@ComponentScan\`
     *  4. \`@Bean\`
     *  5. \`AnnotationConfigApplicationContext\`
     *  6. \`@Configuration\`的省略
     *  7. \`@Import\`
     *  8. \`@PropertySource\`
 *  六、Spring整合JUnit
 *   *  1. 问题
     *  2. 思路
     *  3. 操作过程
     *   *  ① 导入jar包
         *  ② 使用\`@RunWith\`注解替换原有运行器
         *  ③ 使用@ContextConfiguration 指定 spring 配置文件的位置

# 基于xml的IoC案例 #

# 一、准备 #

## 1. 新建一个maven工程： ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]

## 2. 导入坐标 ##

**pom.xml：**

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.veeja</groupId>
        <artifactId>spring_day02_02</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>jar</packaging>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.0.2.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.6</version>
            </dependency>
    
    		<dependency>
    		    <groupId>commons-dbutils</groupId>
    		    <artifactId>commons-dbutils</artifactId>
    		    <version>1.4</version>
    		</dependency>
    		
            <dependency>
                <groupId>c3p0</groupId>
                <artifactId>c3p0</artifactId>
                <version>0.9.1.2</version>
            </dependency>
    
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.10</version>
            </dependency>
    
        </dependencies>
    
    </project>

## 3. 建立数据库，准备数据 ##

create table account(
    	id int primary key auto_increment,
    	name varchar(40),
    	money float
    )character set utf8 collate utf8_general_ci;
    
    insert into account(name,money) values('aaa',1000);
    insert into account(name,money) values('bbb',1000);
    insert into account(name,money) values('ccc',1000);

## 4. 创建账户实体类 ##

package com.veeja.domain;
    
    import java.io.Serializable;
    
    /** * 账户的实体类 */
    public class Account implements Serializable { 
        private Integer id;
        private String name;
        private Float money;
    
        public Integer getId() { 
            return id;
        }
    
        public void setId(Integer id) { 
            this.id = id;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public Float getMoney() { 
            return money;
        }
    
        public void setMoney(Float money) { 
            this.money = money;
        }
    
    	@Override
        public String toString() { 
            return "Account{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", money=" + money +
                    '}';
        }
    }

## 5. 业务层 ##

### ① 接口`IAccountService` ###

package com.veeja.service;
    
    import com.veeja.domain.Account;
    
    import java.util.List;
    
    /** * 账户的业务层接口 * * @author veeja */
    public interface IAccountService { 
    
        /** * 查询所有用户的信息 * * @return */
        List<Account> findAllAccount();
    
    
        /** * 根据id查询一个用户 * * @param accountId * @return */
        Account findAccountById(Integer accountId);
    
    
        /** * 保存用户 * * @param account */
        void saveAccount(Account account);
    
    
        /** * 更新用户 * * @param account */
        void updateAccount(Account account);
    
        /** * 删除用户 * * @param accountId */
        void deleteAccount(Integer accountId);
    
    }

### ② 业务层实现类`AccountServiceImpl` ###

package com.veeja.service.impl;
    
    import com.veeja.dao.IAccountDao;
    import com.veeja.domain.Account;
    import com.veeja.service.IAccountService;
    
    import java.util.List;
    
    /** * 账户的业务层实现类 */
    public class AccountServiceImpl implements IAccountService { 
    
        private IAccountDao accountDao;
    
        public void setAccountDao(IAccountDao accountDao) { 
            this.accountDao = accountDao;
        }
    
        @Override
        public List<Account> findAllAccount() { 
            return accountDao.findAll();
        }
    
        @Override
        public Account findAccountById(Integer accountId) { 
            return accountDao.findAccountById(accountId);
        }
    
        @Override
        public void saveAccount(Account account) { 
            accountDao.saveAccount(account);
    
        }
    
        @Override
        public void updateAccount(Account account) { 
            accountDao.updateAccount(account);
        }
    
        @Override
        public void deleteAccount(Integer accountId) { 
            accountDao.deleteAccount(accountId);
        }
    }

## 6. 持久层 ##

### ① 接口`IAccountDao` ###

package com.veeja.dao;
    
    import com.veeja.domain.Account;
    
    import java.util.List;
    
    /** * 用户的持久层接口 * * @author veeja */
    public interface IAccountDao { 
    
        /** * 查询所有用户 * * @return */
        List<Account> findAll();
        
        /** * 通过id查询用户 * * @param accountId * @return */
        Account findAccountById(Integer accountId);
    
        /** * 保存一个用户 * * @param account */
        void saveAccount(Account account);
    
        /** * 更新用户 * * @param account */
        void updateAccount(Account account);
    
        /** * 删除用户 * * @param accountId */
        void deleteAccount(Integer accountId);
    }

### ② 实现类`AccountDaoImpl`（重要） ###

package com.veeja.dao.impl;
    
    import com.veeja.dao.IAccountDao;
    import com.veeja.domain.Account;
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.handlers.BeanHandler;
    import org.apache.commons.dbutils.handlers.BeanListHandler;
    
    import java.sql.SQLException;
    import java.util.List;
    
    /** * 账户的持久层实现类 */
    public class AccountDaoImpl implements IAccountDao { 
    
        private QueryRunner runner;
    
        public void setRunner(QueryRunner runner) { 
            this.runner = runner;
        }
    
        @Override
        public List<Account> findAll() { 
            try { 
                return runner.query("select * from account", new BeanListHandler<Account>(Account.class));
            } catch (SQLException e) { 
                throw new RuntimeException(e);
            }
        }
    
        @Override
        public Account findAccountById(Integer accountId) { 
            try { 
                return runner.query("select * from account where id = ?",
                        new BeanHandler<Account>(Account.class), accountId);
            } catch (SQLException e) { 
                throw new RuntimeException(e);
            }
        }
    
        @Override
        public void saveAccount(Account account) { 
            try { 
                runner.update("insert into account(name,money) values(?,?)",
                        account.getName(), account.getMoney());
            } catch (SQLException e) { 
                throw new RuntimeException(e);
            }
        }
    
        @Override
        public void updateAccount(Account account) { 
            try { 
                runner.update("update account set name=?,money=? where id = ?",
                        account.getName(), account.getMoney(), account.getId());
            } catch (SQLException e) { 
                throw new RuntimeException(e);
            }
        }
    
        @Override
        public void deleteAccount(Integer accountId) { 
            try { 
                runner.update("delete account where id = ?", accountId);
            } catch (SQLException e) { 
                throw new RuntimeException(e);
            }
        }
    }

# 二、编写Spring的IoC配置 #

**bean.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="accountService" class="com.veeja.service.impl.AccountServiceImpl">
            
            <property name="accountDao" ref="accountDao"></property>
        </bean>
    
        
        <bean id="accountDao" class="com.veeja.dao.impl.AccountDaoImpl">
            
            <property name="runner" ref="runner"></property>
        </bean>
    
        
        <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
            
            <constructor-arg name="ds" ref="dataSource"></constructor-arg>
        </bean>
    
        
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            
            <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
            <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mybatisdatabase?useUnicode=true&characterEncoding=utf8">
            </property>
            <property name="user" value="root"></property>
            <property name="password" value="0000"></property>
    
        </bean>
    </beans>

# 三、测试类的测试方法 #

package com.veeja.test;
    
    import com.veeja.domain.Account;
    import com.veeja.service.IAccountService;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import java.util.List;
    
    /** * 使用Junit单元测试，测试我们的配置 */
    public class AccountServiceTest { 
    
        @Test
        public void testFindAll() { 
    
            // 1.获取容器
            ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
            // 2.得到业务层对象
            IAccountService accountService = ac.getBean("accountService", IAccountService.class);
            // 3.执行方法
            List<Account> accounts = accountService.findAllAccount();
            for (Account account : accounts) { 
                System.out.println(account);
            }
        }
    
        @Test
        public void testFindOne() { 
    
            // 1.获取容器
            ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
            // 2.得到业务层对象
            IAccountService accountService = ac.getBean("accountService", IAccountService.class);
            // 3.执行方法
            Account account = accountService.findAccountById(1);
            System.out.println(account);
        }
    
        @Test
        public void testSave() { 
            // 1.获取容器
            ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
            // 2.得到业务层对象
            IAccountService accountService = ac.getBean("accountService", IAccountService.class);
    
            Account account = new Account();
            account.setMoney(500f);
            account.setName("veeja");
    
            // 3.执行方法
            accountService.saveAccount(account);
        }
    
        @Test
        public void testUpdate() { 
    
            // 1.获取容器
            ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
            // 2.得到业务层对象
            IAccountService accountService = ac.getBean("accountService", IAccountService.class);
            // 3.执行方法
            Account account = accountService.findAccountById(4);
            account.setMoney(500000f);
            accountService.updateAccount(account);
        }
    
        @Test
        public void testDelete() { 
            // 1.获取容器
            ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
            // 2.得到业务层对象
            IAccountService accountService = ac.getBean("accountService", IAccountService.class);
            // 3.执行方法
            accountService.deleteAccount(4);
        }
    
    }

--------------------

# 四、基于注解的改造 #

**接下来才是我们的重头戏，我们要对上面的demo进行改造，使用注解的方式来完成上面的功能。**

## 1. bean.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" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    
        
        <context:component-scan base-package="com.veeja"></context:component-scan>
    
    
        
        <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
            
            <constructor-arg name="ds" ref="dataSource"></constructor-arg>
        </bean>
    
        
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            
            <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
            <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/springdatabase?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC"/>
            <property name="user" value="root"></property>
            <property name="password" value="0000"></property>
    
        </bean>
    </beans>

## 2. 业务层实现类 ##

package com.veeja.service.impl;
    
    import com.veeja.dao.IAccountDao;
    import com.veeja.domain.Account;
    import com.veeja.service.IAccountService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    
    /** * 账户的业务层实现类 * * @author veeja */
    @Service("accountService")
    public class AccountServiceImpl implements IAccountService { 
    
        @Autowired
        private IAccountDao accountDao;
    
        @Override
        public List<Account> findAllAccount() { 
            System.out.println("AccountServiceImpl.findAllAccount()...");
            return accountDao.findAll();
        }
    
        @Override
        public Account findAccountById(Integer accountId) { 
            return accountDao.findAccountById(accountId);
        }
    
        @Override
        public void saveAccount(Account account) { 
            accountDao.saveAccount(account);
    
        }
    
        @Override
        public void updateAccount(Account account) { 
            accountDao.updateAccount(account);
        }
    
        @Override
        public void deleteAccount(Integer accountId) { 
            accountDao.deleteAccount(accountId);
        }
    }

## 3. 持久层实现类 ##

package com.veeja.dao.impl;
    
    import com.veeja.dao.IAccountDao;
    import com.veeja.domain.Account;
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.handlers.BeanHandler;
    import org.apache.commons.dbutils.handlers.BeanListHandler;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Repository;
    
    import java.sql.SQLException;
    import java.util.List;
    
    /** * 账户的持久层实现类 * * @author veeja */
    @Repository("accountDao")
    public class AccountDaoImpl implements IAccountDao { 
    
        @Autowired
        private QueryRunner runner;
    
        @Override
        public List<Account> findAll() { 
            System.out.println("AccountDaoImpl.findAll()...");
            try { 
                return runner.query("select * from account", new BeanListHandler<Account>(Account.class));
            } catch (Exception e) { 
                throw new RuntimeException(e);
            }
        }
    
        @Override
        public Account findAccountById(Integer accountId) { 
            try { 
                return runner.query("select * from account where id = ?",
                        new BeanHandler<Account>(Account.class), accountId);
            } catch (SQLException e) { 
                throw new RuntimeException(e);
            }
        }
    
        @Override
        public void saveAccount(Account account) { 
            try { 
                runner.update("insert into account(name,money) values(?,?)",
                        account.getName(), account.getMoney());
            } catch (SQLException e) { 
                throw new RuntimeException(e);
            }
        }
    
        @Override
        public void updateAccount(Account account) { 
            try { 
                runner.update("update account set name=?,money=? where id = ?",
                        account.getName(), account.getMoney(), account.getId());
            } catch (SQLException e) { 
                throw new RuntimeException(e);
            }
        }
    
        @Override
        public void deleteAccount(Integer accountId) { 
            try { 
                runner.update("delete from account where id = ?", accountId);
            } catch (SQLException e) { 
                throw new RuntimeException(e);
            }
        }
    }

# 五、Spring的纯注解配置 #

我们现在发现一个问题，那就是虽然我们进行了注解的改造，可是还是有bean.xml文件，文件里面还是有一堆配置，我们有没有办法把这些东西也给拿掉呢？？？  
当然，我们也需要注意一下，我们选择哪种配置的原则是简化开发和配置方便，而非追求某种技术。

## 1. 问题 ##

我们发现，之所以我们离不开XML配置文件，是因为我们有一句很关键的配置。

<context:component-scan base-package="com.veeja"></context:component-scan>

另外，数据源和JdbcTemplate的配置也需要靠注解来实现。

<bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>
    
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/springdatabase?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC"/>
        <property name="user" value="root"></property>
        <property name="password" value="0000"></property>
    </bean>

如果我能能把这两个配置都通过注解实现。这样就能使用纯注解的方式。

## 2. `@Configuration` ##

用于指定当前类是一个 spring 配置类，当创建容器时会从该类上加载注解。获取容器时需要使用 AnnotationApplicationContext(有@Configuration 注解的类.class)。

**属性：**  
`value`:用于指定配置类的字节码

例如，我们新建一个类，并加上注解：

package config;
    
    import org.springframework.context.annotation.Configuration;
    
    /** * 这个类是一个配置类，它的作用和bean.xml是一样的 */
    @Configuration
    public class SpringConfiguration { 
    
    }

我们已经把配置文件用类来代替了，但是如何配置创建容器时要扫描的包呢？

## 3. `@ComponentScan` ##

用于指定 spring 在初始化容器时要扫描的包。  
作用和在 spring 的 xml 配置文件中的： `<context:component-scan base-package="com.itheima"/>`是一样的。

**属性：**  
`basePackages`：用于指定要扫描的包。和该注解中的 value 属性作用一样。

例如：

/** * 这个类是一个配置类，它的作用和bean.xml是一样的 */
    @Configuration
    @ComponentScan("com.veeja")
    public class SpringConfiguration { 
    
    }

我们已经配置好了要扫描的包，接下来的问题就是数据源和 JdbcTemplate 对象如何从配置文件中移除。

## 4. `@Bean` ##

该注解只能写在方法上，表明使用此方法创建一个对象，并且放入 spring 容器。

**属性：**  
`name`：给当前@Bean 注解方法创建的对象指定一个名称(即 bean 的 id）。

例如：

/** * 这个类是一个配置类，它的作用和bean.xml是一样的 */
    @Configuration
    @ComponentScan(basePackages = "com.veeja")
    public class SpringConfiguration { 
        /** * 用于创建一个QueryRunner对象 * * @param dataSource * @return */
        @Bean(name = "runner")
        public QueryRunner createQueryRunner(DataSource dataSource) { 
            return new QueryRunner(dataSource);
        }
    
        /** * 创建数据源对象 * * @return */
        @Bean(name = "dataSource")
        public DataSource createDataSource() { 
            ComboPooledDataSource dataSource = new ComboPooledDataSource();
            try { 
                dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
                dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/springdatabase?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC");
                dataSource.setUser("root");
                dataSource.setPassword("0000");
            } catch (PropertyVetoException e) { 
                e.printStackTrace();
            }
            return dataSource;
        }
    }

当我们使用注解配置方法时，如果方法有参数，spring框架会去容器中查找有没有可用的bean对象。  
查找的方式和Autowired注解的作用是一样的

## 5. `AnnotationConfigApplicationContext` ##

这个时候我们可以把bean给删掉了，因为我们已经把xml中所有的配置都转移到我们的配置类中去了。  
可是我们打开测试类，忽然发现一个新的问题：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 1]  
小朋友你是否有很多的问号，我们是把bean.xml删除了啊，可是我们在测试类中还在读取它呢？

不过没关系，我们也有我们的解决方案：  
那就是使用我们超级长长长的`AnnotationConfigApplicationContext类`。  
例如：

@Test
    public void testFindAll() { 
    
        // 1.获取容器
        // ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        // 2.得到业务层对象
        IAccountService accountService = ac.getBean("accountService", IAccountService.class);
        // 3.执行方法
        List<Account> accounts = accountService.findAllAccount();
        for (Account account : accounts) { 
            System.out.println(account);
        }
    }

这样也是可以运行的。

## 6. `@Configuration`的省略 ##

我们如果把配置类上的注解@Configuration去掉，我们发现，程序还是可以运行的，那是因为我们在创建AnnotationConfigApplicationContext对象的时候，把配置类作为参数了，这个时候，注解是可以不写的。

如果我们这个时候新建另一个配置类：`JdbcConfig`  
我们把之前的配置都转移到这个里面来了：

/** * 和spring连接数据库相关的配置类 */
    public class JdbcConfig { 
        /** * 用于创建一个QueryRunner对象 * * @param dataSource * @return */
        @Bean(name = "runner")
        @Scope("prototype")
        public QueryRunner createQueryRunner(DataSource dataSource) { 
            return new QueryRunner(dataSource);
        }
    
        /** * 创建数据源对象 * * @return */
        @Bean(name = "dataSource")
        public DataSource createDataSource() { 
            ComboPooledDataSource dataSource = new ComboPooledDataSource();
            try { 
                dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
                dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/springdatabase?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC");
                dataSource.setUser("root");
                dataSource.setPassword("0000");
            } catch (PropertyVetoException e) { 
                e.printStackTrace();
            }
            return dataSource;
        }
    }

这个时候我们再运行测试方法，肯定是不行的了。

1.  可是我们可以这么改造，首先在SpringConfiguration的扫描的包里面，加上config这个包。
    
        /** * 这个类是一个配置类，它的作用和bean.xml是一样的 */
        @Configuration
        @ComponentScan(basePackages = { "com.veeja", "config"})
        public class SpringConfiguration { 
        
        }
    
    这个时候，JdbcConfig类上的注解@Configuration就没法再省略了！必须加上！
    
        /** * 和spring连接数据库相关的配置类 */
        @Configuration
        public class JdbcConfig { 
        	......
        }
2.  当然我们也可以这么改造：我们两个地方的注解都省略掉，但是我们在创建AnnotationConfigApplicationContext对象的时候，就要把这两个类都写上：
    
        // 1.获取容器
        // ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class, JdbcConfig.class);
    
    这样也是没有问题的。

## 7. `@Import` ##

可是这个时候我们发现，AnnotationConfigApplicationContext对象的创建变得有些臃肿，或者是SpringConfiguration上需要添加要扫描的包，这看上去都不是很好。  
这个时候我们就可以使用`@Import`注解了：

**作用：**  
用于导入其他配置类，在引入其他配置类时，可以不用再写@Configuration 注解。当然，写上也没问 题。  
**属性：**  
`value[]`：用于指定其他配置类的字节码。

例如上面的一些操作我们都可以这样的修改：  
**SpringConfiguration：** 省略了@SpringConfiguration，添加@Import注解

/** * 这个类是一个配置类，它的作用和bean.xml是一样的 */
    @ComponentScan(basePackages = { "com.veeja", "config"})
    @Import(JdbcConfig.class)
    public class SpringConfiguration { 
    
    }

**JdbcConfig：** 省略了@SpringConfiguration

/** * 和spring连接数据库相关的配置类 */
    public class JdbcConfig { 
    	...
    	...
    }

**测试类中，** 也不需要写JdbcConfig.class:

ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);

也是可以成功的。

## 8. `@PropertySource` ##

这里还是有个问题，我们辛苦这么半天，正如我们以前说的，我们做这些都是为了解耦。  
可是，jdbc的配置的四项好像又写死了：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 2]  
我们该怎么做呢？

**我们在resources文件夹下建立一个`jdbcConfig.properties`：**

jdbc.driver=com.mysql.cj.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/springdatabase
    jdbc.username=root
    jdbc.password=0000

**我们先介绍一下`@PropertySource`注解：**

**作用：**  
用于加载.properties 文件中的配置。例如我们配置数据源时，可以把连接数据库的信息写到 properties 配置文件中，就可以使用此注解指定 properties 配置文件的位置。

**属性：**  
value\[\]：用于指定 properties 文件位置。如果是在类路径下，需要写上 `classpath:` 。

接下来我们开始改造**JdbcConfig**：

package config;
    
    import com.mchange.v2.c3p0.ComboPooledDataSource;
    import org.apache.commons.dbutils.QueryRunner;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.*;
    
    import javax.sql.DataSource;
    import java.beans.PropertyVetoException;
    
    /** * 和spring连接数据库相关的配置类 */
    public class JdbcConfig { 
    
        @Value("${jdbc.driver}")
        private String driver;
        @Value("${jdbc.url}")
        private String url;
        @Value("${jdbc.username}")
        private String username;
        @Value("${jdbc.password}")
        private String password;
    
        /** * 用于创建一个QueryRunner对象 * * @param dataSource * @return */
        @Bean(name = "runner")
        @Scope("prototype")
        public QueryRunner createQueryRunner(DataSource dataSource) { 
            return new QueryRunner(dataSource);
        }
    
        /** * 创建数据源对象 * * @return */
        @Bean(name = "dataSource")
        public DataSource createDataSource() { 
            ComboPooledDataSource dataSource = new ComboPooledDataSource();
            try { 
                System.out.println("driver:" + driver);
                dataSource.setDriverClass(driver);
                dataSource.setJdbcUrl(url);
                dataSource.setUser(username);
                dataSource.setPassword(password);
            } catch (PropertyVetoException e) { 
                e.printStackTrace();
            }
            return dataSource;
        }
    }

然后我们在SpringConfiguration上使用新的注解：

/** * 这个类是一个配置类，它的作用和bean.xml是一样的 */
    @ComponentScan(basePackages = { "com.veeja", "config"})
    @Import(JdbcConfig.class)
    @PropertySource("classpath:jdbcConfig.properties")
    public class SpringConfiguration { 
    
    }

这样也是没有问题的。

--------------------

# 六、Spring整合JUnit #

## 1. 问题 ##

我们的测试类中，每个测试方法都会有下面两行代码：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 3]  
这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常。所以又不能轻易删掉。

## 2. 思路 ##

针对上述问题，我们需要的是程序能自动帮我们创建容器。一旦程序能自动为我们创建 spring 容器，我们就 无须手动创建了，问题也就解决了。

我们都知道，junit 单元测试的原理（在 web 阶段课程中讲过），但显然，junit 是无法实现的，因为它自 己都无法知晓我们是否使用了 spring 框架，更不用说帮我们创建 spring 容器了。不过好在，junit 给我们暴露 了一个注解，可以让我们替换掉它的运行器。  
![在这里插入图片描述][2020051122411415.png]

这时，我们需要依靠 spring 框架，因为它提供了一个运行器，可以读取配置文件（或注解）来创建容器。我 们只需要告诉它配置文件在哪就行了。

## 3. 操作过程 ##

**注意！！！**  
当我们使用Spring 5.x版本的时候，要求JUnit的版本必须是4.12及以上。

### ① 导入jar包 ###

我们要添加一个新的jar包，spring-test，坐标如下：

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>

### ② 使用`@RunWith`注解替换原有运行器 ###

在我们的测试类上添加：

/** * 使用Junit单元测试，测试我们的配置 */
    @RunWith(SpringJUnit4ClassRunner.class)
    public class AccountServiceTest { 
    	...
    }

### ③ 使用@ContextConfiguration 指定 spring 配置文件的位置 ###

我们要告知Spring的运行器，Spring和IoC的创建是基于xml还是注解的，并且说明位置。

**`@ContextConfiguration` 注解：**  
`locations` 属性：用于指定配置文件的位置。如果是类路径下，需要用 classpath:表明  
`classes` 属性：用于指定注解的类。当不使用 xml 配置时，需要用此属性指定注解类的位置。

例如：

/** * 使用Junit单元测试，测试我们的配置 */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes = SpringConfiguration.class)
    public class AccountServiceTest { 
    
        @Autowired
        private IAccountService accountService = null;
    
        @Test
        public void testFindAll() { 
            List<Account> accounts = accountService.findAllAccount();
            for (Account account : accounts) { 
                System.out.println(account);
            }
        }
    }

这样就可以了。

--------------------

![在这里插入图片描述][20200511230304867.gif]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]: /images/20210615/ac9bc233682e4bdda6f8ce7f815df676.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 1]: /images/20210615/d862f6fee2ea480ca1d2daf6c754a4ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 2]: /images/20210615/d575cada22094aa7ae51402637dd3d50.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 3]: /images/20210615/353f394f2353471baf3ce5814ee968e5.png
[2020051122411415.png]: /images/20210615/288063eddedf4aef8f38101cd164e7ff.png
[20200511230304867.gif]: /images/20210615/8e7d9c7f900045128e463b95e0c34956.png