Spring进阶案例之注解和IoC案例

Spring进阶案例之注解和IoC案例

一、常见的注解分类及其作用

从此前的基于xml的IoC开发案例和依赖注入案例中，我们可以将xml配置归纳为：

<bean id="" class="" scope="" init-method = "" destroy-method = "">
  <property name = "" value = "" | ref = ""></property>
</bean>

注解按照作用可以分为四类：

1.用于创建对象的注解：相当于xml配置的bean标签

创建对象的注解有如下几个：

最后三个注解的作用和属性与Component注解一模一样，他们是Spring框架为我们提供明确三层架构的注解，可以使三层架构更加清晰。

如果我们在AccoutServiceImpl类上加上@Component(“accountService”)或者@Service(“accountService”)，都可以起到将AccountServiceImpl类的对象加入的IoC容器中的效果。此时，ui.Client类中的main方法还不能执行：

public static void main(String[] args) {
    //验证依赖注入
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
    IAccountService accountService = (IAccountService) applicationContext.getBean("accountService");
    System.out.println(accountService);
}

会显示No bean named ‘accountService’ ，这是因为我还没有对Spring要扫描的包进行配置，如果不配置，Spring是不知道哪些类需要扫描注解。

<!-- 配置Spring在创建容器时要扫描的包，在一个名为context名称空间的约束中进行配置-->
<context:component-scan base-package="service"></context:component-scan>
<context:component-scan base-package="dao"></context:component-scan>

此时，项目结构为：

dao包：
public interface IAccountDao
dao.impl包:
@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao

service包:
public interface IAccountService
service.impl包:
@Service("accountService")
public class AccountServiceImpl implements IAccountService

ui包:
public class Client

2.用于注入对象的注解：相当于xml配置的bean标签中property标签，使用注解进行注入时，不再需要set方法

如果我们需要调用accountService中的saveAccount方法，就需要对AccountServiceImpl类中的accountDao成员变量进行注入。同时需要在AccountDaoImpl类的accountDao变量上加上@Autowired(“accountDao”)注解。用于注入数据的注解有如下几个：前三个注解只能注入其他bean类型的注入，基本类型和String类型的注入无法通过它们来实现。集合类型的注入只能通过xml配置来实现，不能通过注解来实现。

这个时候，我们在ui.Client类的main方法中，就可以执行saveAccount方法了。

public static void main(String[] args) {
    //验证依赖注入
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
    IAccountService accountService = (IAccountService) applicationContext.getBean("accountService");
    System.out.println(accountService);
    IAccountDao accountDao = applicationContext.getBean("accountDao", IAccountDao.class);
    System.out.println(accountDao);
    //调用saveAccount方法
    accountService.saveAccounts();
}

在使用@Autowired注解时，需要注意的是：

1、 只要IoC容器中有唯一的一个bean对象和要注入的变量类型匹配，就可以注入成功。
2、 如果IoC容器中任何bean对象和要注入的变量类型都不匹配，就会报错。
3、 如果IoC容器中有多个bean对象和要注入的变量类型匹配，则按变量名称和bean类名进行匹配，若有唯一一个匹配，则注入成功，否则注入失败。

例如，在dao.impl包下，有两个IAccountDao接口的实现类，分别是是AccountDaoImpl1和AccountDaoImpl2，在这两个类上分别加入注解@Repository(“accountDao1”)和@Repository(“accountDao2”)。

此时，项目结构为：

dao包：
public interface IAccountDao
dao.impl包:
@Repository("accountDao1")
public class AccountDaoImpl1 implements IAccountDao
@Repository("accountDao2")
public class AccountDaoImpl2 implements IAccountDao

service包:
public interface IAccountService
service.impl包:
@Service("accountService")
public class AccountServiceImpl implements IAccountService

ui包:
public class Client

如果还使用Autowired注解对AccountServiceImpl类中的accountDao变量进行注入，就会报错。这个时候，有三种方式可以选择：

• 只使用@Autowired注解，并修改accountDao变量名为accountDao1，此时注入的是dao.impl.AccountDaoImpl1
• 同时使用@Autowired和@Qualifier(“accountDao2”)注解，变量名可以任意，注入的是dao.impl.AccountDaoImpl2
• 只使用@Resource(name = “accountDao1”)注解，变量名可以任意，注入的是dao.impl.AccountDaoImpl1

    //方法一
    @Autowired
    private IAccountDao accountDao1;

    //方法二
    @Autowired
    @Qualifier("accountDao2")
    private IAccountDao accountDao22;

    //方法三
    @Resource(name = "accountDao1")
    private IAccountDao accountDao;

为了看的更清楚，我们进行如下改造：

//AccountDaoImpl1和AccountDaoImpl2中的saveAccounts方法：
public void saveAccounts() {
    System.out.println(this.getClass());
    System.out.println("向数据库写入账户数据！！！");
}
//AccountServiceImpl中的saveAccounts方法：
public void saveAccounts() {
    System.out.println("执行保存账户操作");
    //调用持久层接口函数
    accountDao.saveAccounts();
    accountDao1.saveAccounts();
    accountDao22.saveAccounts();
}
//Client类中的main方法：
public static void main(String[] args) {
    //验证依赖注入
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
    IAccountService accountService = (IAccountService) applicationContext.getBean("accountService");
    //调用saveAccount方法
    accountService.saveAccounts();
}

输出为：

执行保存账户操作
class dao.impl.AccountDaoImpl1
向数据库写入账户数据！！！
class dao.impl.AccountDaoImpl1
向数据库写入账户数据！！！
class dao.impl.AccountDaoImpl2
向数据库写入账户数据！！！

3.用于改变对象作用范围的注解：相当于xml配置的bean标签中的scope属性

如果我们要改变bean的作用范围，就需要用到scope属性：

例如，我们在AccountServiceImpl2类上加上注解@Scope(“prototype”)，然后在main方法中执行：

IAccountDao accountDao11 = applicationContext.getBean("accountDao1", IAccountDao.class);
System.out.println(accountDao11);
IAccountDao accountDao12 = applicationContext.getBean("accountDao1", IAccountDao.class);
System.out.println(accountDao12);
IAccountDao accountDao21 = applicationContext.getBean("accountDao2", IAccountDao.class);
System.out.println(accountDao21);
IAccountDao accountDao22 = applicationContext.getBean("accountDao2", IAccountDao.class);
System.out.println(accountDao22);

可以看到输出中，前两个accountDao是同一个对象，后两个是不同对象：

4.用于改变对象生命周期的注解：相当于xml配置的bean标签中的init-method属性和destroy-method属性

注意：多例对象的销毁仍然由JVM执行，无法通过关闭容器来销毁

二、基于XML的IoC案例

1.准备工作

这个IoC案例，主要演示对数据库的crud操作，所以首先需要创建数据库，sql文件如下：

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);

整个项目的结构如下：

IAccountDao和IAccountService这两个接口类中的方法如下，因为只是演示，简单起见这两个接口中的方法一模一样：

    /** 查询所有 */
    List<Account> findAllAccounts();

    /** 根据id查询账户 */
    Account findAccountById(Integer id);

    /** 保存账户 */
    void saveAccount(Account account);

    /** 修改账户*/
    void updateAccount(Account account);

    /** 根据id删除账户 */
    void deleteAccountById(Integer id);

我们还需要一个实体类用于封装查询结果，简单起见，省略了get和set方法，以及toString方法：

public class Account implements Serializable {
    private Integer id;
    private String name;
    private float money;
  //还有set方法和get方法，以及toString方法没有显示
}

2.编写接口实现类

public class AccountDaoImpl implements IAccountDao {

    private QueryRunner queryRunner;

    //由于需要通过配置文件对QueryRunner进行注入，所以需要提供set方法
    public void setQueryRunner(QueryRunner queryRunner) {
        this.queryRunner = queryRunner;
    }

    @Override
    public List<Account> findAllAccounts() {
        try {
            return queryRunner.query("select * from account",
                    new BeanListHandler<>(Account.class));
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

    @Override
    public Account findAccountById(Integer id) {
        try {
            return queryRunner.query("select * from account where id = ?",
                    new BeanHandler<>(Account.class), id);
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

    @Override
    public void saveAccount(Account account) {
        try {
            queryRunner.update("insert into account(name, money) values (?,?)",
                    account.getName(), account.getMoney());
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

    @Override
    public void updateAccount(Account account) {
        try {
            queryRunner.update("update account set name=?, money=? where id = ?",
                    account.getName(), account.getMoney(), account.getId());
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

    @Override
    public void deleteAccountById(Integer id) {
        try {
            queryRunner.update("delete from account s where id = ?", id);
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }
}

public class AccountServiceImpl implements IAccountService {

    private IAccountDao accountDao;
        //set方法用于注入
    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public List<Account> findAllAccounts() {
        return accountDao.findAllAccounts();
    }

    @Override
    public Account findAccountById(Integer id) {
        return accountDao.findAccountById(id);
    }

    @Override
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    @Override
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    @Override
    public void deleteAccountById(Integer id) {
        accountDao.deleteAccountById(id);
    }
}

3.编写配置文件

前面的部分都不用太关心，只需要了解即可。QueryRunner是java编程中的数据库操作实用工具类DBUtils中的一个核心类，可以用于连接数据库执行SQL语句。beans.xml文件是Spring的配置文件，重点应该放在配置文件上。

<?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">
    <!-- 配置service -->
    <bean id = "accountService" class="com.crud.service.impl.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!-- 配置dao -->
    <bean id = "accountDao" class="com.crud.dao.impl.AccountDaoImpl">
        <!-- 注入queryRunner -->
        <property name="queryRunner" ref="queryRunner"></property>
    </bean>

    <!-- 配置queryRunner，必须是多例对象，否则会出现线程安全问题 -->
    <bean id = "queryRunner" 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/spring"></property>
        <property name="user" value="root"></property>
        <property name="password" value="12345678"></property>
    </bean>
</beans>

配置文件中需要注意的是，因为每一个连接都会用到QueryRunner对象，所以必须是多例模式，否则就会出现线程安全问题。此外，在配置数据源时，property中的value可以从其他文件中读取。该配置文件，基本上综合了之前讲的用xml进行依赖注入。

例如：

首先在src/main/resources目录下编写：jdbc.properties文件

jdbc.driver = com.mysql.cj.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/spring
jdbc.user = root
jdbc.password = 12345678

然后对beans.xml文件进行修改：

<context:property-placeholder location="classpath:jdbc.properties"/>

<!-- 配置数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <!-- 配置连接数据库的必备信息 -->
    <property name="driverClass" value="${jdbc.driver}"></property>
    <property name="jdbcUrl" value="${jdbc.url}"></property>
    <property name="user" value="${jdbc.user}"></property>
    <property name="password" value="${jdbc.password}"></property>
</bean>

对于maven的配置文件pom.xml，主要需要导入的包有：Spring、dbutils（用于执行sql语句）、mysql、c3p0（用于数据源）、junit（用于单元测试）

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.5.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>commons-dbutils</groupId>
        <artifactId>commons-dbutils</artifactId>
        <version>1.7</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.20</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.13</version>
        <scope>test</scope>
    </dependency>
</dependencies>

3.单元测试

编写AccountServiceTest测试类用于测试，只测试能否正常执行crud操作，这里只演示了测试查询所有方法：

public class AccountServiceTest {

    @Test
    public void testFinaAll() {
        //1.获取容器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        //2.从容器中获取业务层对象
        IAccountService accountService = applicationContext.getBean("accountService", IAccountService.class);
        //3.执行方法
        List<Account> accounts = accountService.findAllAccounts();
        for (Account account : accounts) {
            System.out.println(account);
        }
    }
}    

三、基于注解和xml的IoC案例

1.修改AccountServiceImpl和AccountDaoImpl类

在上述案例中，采用的xml进行依赖注入。本案例中，使用注解的方式进行依赖注入，所以不再需要main方法。这两个类仅进行如下修改，其余部分不变：

@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {

    @Autowired
    private QueryRunner queryRunner;
}

@Service("accountService")
public class AccountServiceImpl implements IAccountService {

    @Autowired
    private IAccountDao accountDao;
}

2.修改beans.xml配置文件

和之前一样，要告知Spring要扫描的包，所以约束空间要加入context名称空间，此外之前service和dao的xml配置就不再需要了，但是和连接数据库相关的QueryRunner的配置仍然需要。

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 配置Spring在创建容器时要扫描的包，在一个名为context名称空间的约束中进行配置-->
    <context:component-scan base-package="com.crud"></context:component-scan>

    <!-- 配置queryRunner，必须是多例对象，否则会出现线程安全问题 -->
    <bean id = "queryRunner" 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/spring"></property>
        <property name="user" value="root"></property>
        <property name="password" value="12345678"></property>
    </bean>
</beans>

3.测试执行

由于多个单元测试都需要用到accountService对象，所以这里抽取出来作类对象，这样就只需要初始化一次。

public class AccountServiceTest {

    private ApplicationContext applicationContext;
    private IAccountService accountService;

    //手动获取accountService对象
    @Before
    public void init(){
        //1.获取容器
        applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        //2.从容器中获取业务层对象
        accountService = applicationContext.getBean("accountService", IAccountService.class);
    }

    @Test
    public void testFinaAll() {
       //3.执行方法
        List<Account> accounts = accountService.findAllAccounts();
        for (Account account : accounts) {
            System.out.println(account);
        }
    }
}

四、基于纯注解的IoC案例

1.配置类

如果不写xml配置文件，我们如何去指定Spring的相关配置呢？这个时候就需要一个配置类来代替xml配置文件。在src目录下，新建com.crud.conf包，该包下新建配置类SpringConfig。依照前面注解结合xml配置文件的案例。我们需要解决的问题有：

1.告知Spring容器要扫描的包，对应<context:component-scan>标签
2.配置queryRunner
3.配置数据源

2.Spring新注解

3.新注解的使用

整个项目的结构如下：

接下来我们一个一个详细理解这些注解的作用：

1、 @Configuration注解用于指定配置类，一般所有的配置类都需要加上这个注解。但是也有例外：如果不写@Configuration注解，那么会将Spring的IoC容器会将AnnotationConfigApplicationContext构造方法中的参数作为配置类；因此，作为参数传入的配置类的@Configuration注解可用不写。
2、 @Import注解用于导入其他配置类。在实际开发过程中，可能不止一个配置类。例如和Spring相关的配置作为一个住配置类，和连接数据库相关的配置类作为一个子类。当使用@Import注解之后，使用@Import注解的配置类就是主配置类，导入的配置类就是子配置类。此时，子类就不需要再写@Configuration注解。
3、 @ComponentScan/@ComponentScans注解用于指定Spring在创建容器时要扫描的包，前者用于指定一个包，后者用于指定多个包。这就相当于xml配置文件中的中的basePackages属性。
4、 @Bean注解用于把当前方法的返回值作为Bean对象存入IoC容器。当方法上有@Bean注解时，Spring会在容器中查找有没有和参数对应的可用bean对象，查找方式和@Autowired注解的方式相同。这就相当于xml配置文件中的Bean标签。
5、 @PropertySource注解用于指定要使用的properties文件的位置。

最终这些注解在代码中的使用如下：

@Configuration
@ComponentScan("com.crud")
@Import(JdbcConfig.class)
/** 主配置类 */
public class SpringConfig { }

/** jdbc配置类 */
@PropertySource("classpath:jdbcConfig.properties")
public class JdbcConfig {

    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.user}")
    private String user;
    @Value("${jdbc.password}")
    private String password;

    /**  根据数据源创建QueryRunner对象，必须是多例的，否则会出现线程安全问题 */
    @Bean("queryRunner")
    @Scope("prototype")
    public QueryRunner createQueryRunner(DataSource dataSource){
        return new QueryRunner(dataSource);
    }

    /** 创建数据源对象 */
    @Bean("dataSource")
    public DataSource createDataSource(){
        try{
            ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
            comboPooledDataSource.setDriverClass(driver);
            comboPooledDataSource.setJdbcUrl(url);
            comboPooledDataSource.setUser(user);
            comboPooledDataSource.setPassword(password);
            return comboPooledDataSource;
        }catch (Exception e){
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
}

4.测试

有一点需要修改，就是在获取容器时，不能再使用ClassPathXmlApplicationContext类，而应该使用AnnotationConfigApplicationContext，如下：

//参数是类字节码，可以传入多个类的字节码，作为参数的配置类可以不写@Configuration注解
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);

5.@Bean注解的查找方式

@Bean创建Bean对象的方式后的查找方法和@Autowired注解相同，如果有多个名称匹配，就需要用到@Qualifier注解来指定用哪个匹配。例如，jdbcConfig类可以修改为如下：

/**
 * 根据数据源创建QueryRunner对象，必须是多例的，否则会出现线程安全问题
 * @Qualifier注解用于解决多个类型匹配时的问题
 * @param dataSource
 * @return
 */
@Bean("queryRunner")
@Scope("prototype")
public QueryRunner createQueryRunner(@Qualifier("ds2") DataSource dataSource){
    return new QueryRunner(dataSource);
}

/**
 * 创建数据源对象
 * @return
 */
@Bean("ds1")
public DataSource createDataSource(){
    try{
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        comboPooledDataSource.setDriverClass(driver);
        comboPooledDataSource.setJdbcUrl(url);
        comboPooledDataSource.setUser(user);
        comboPooledDataSource.setPassword(password);
        return comboPooledDataSource;
    }catch (Exception e){
        e.printStackTrace();
        throw new RuntimeException(e);
    }
}

@Bean("ds2")
public DataSource createDataSource1(){
    try{
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        comboPooledDataSource.setDriverClass(driver);
        comboPooledDataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        comboPooledDataSource.setUser(user);
        comboPooledDataSource.setPassword(password);
        return comboPooledDataSource;
    }catch (Exception e){
        e.printStackTrace();
        throw new RuntimeException(e);
    }
}

五、Spring整合Junit

在测试类中，获取Spring的IoC容器和AccountService对象时，我们一直都是手动获取。有没有办法让Spring为我们自动注入呢？当然是有的，但是如果直接没有在accountService成员变量之上，加上@Autowired注解，运行就会报错。这是因为：

1.Junit单元测试中，没有main方法也能执行。因为Junit集成了一个main方法，该方法会判断当前测试类中哪些方法有@Test注解，Junit就会执行有@Test注解的方法。
2.Junit不会管用户使用何种框架，因此在执行测试方法是，junit不知道用户是否使用Spring框架，所以也就不会读取配置文件/配置来创建Spring的IoC核心容器。因此在测试类中，就算写了@Autowired注解，也无法实现注入。

因此要在Junit中使用Spring，就要遵循一下步骤：

1.导入Spring整合junit的配置

在pom.xml配置文件中的导入：

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

2.使用Junit提供的@RunWith注解，将原有的main方法替换为Spring提供的main方法

在AccountServiceTest类之上加上@RunWith(SpringJUnit4ClassRunner.class)注解

3.告知Spring的运行器，是基于xml还是注解进行配置，并说明位置

在AccountServiceTest类之上加上@ContextConfiguration(classes = SpringConfig.class)注解。对于@ContextConfiguration注解，属性locations用于指定xml配置文件的位置，要加上classpath关键字表示在类路径下，属性classes：指定配置类所在的位置。

4.注意事项

当Spring的版本是5.x时，junit的版本必须是4.12及以上版本。最终整个测试类代码如下：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {

    @Autowired
    private IAccountService accountService;

    @Test
    public void testFinaAll() {
       //3.执行方法
        List<Account> accounts = accountService.findAllAccounts();
        for (Account account : accounts) {
            System.out.println(account);
        }
    }
}

文章永久链接：https://tech.souyunku.com/?p=30461