Spring 框架学习7 - Spring 中的新注解

最新推荐文章于 2022-02-02 15:07:03 发布
最新推荐文章于 2022-02-02 15:07:03 发布
阅读量407 收藏
点赞数
分类专栏： spring 框架 文章标签： java spring 注解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41302594/article/details/101108169
版权

文章目录

Spring 中的新注解

首先，看一下上个案例所写的 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"
       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:component-scan base-package="com.selflearning.spring"></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/spring?serverTimezone=Asia/Shanghai"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
</beans>

这里有几个必须写的配置：

  1. 使用 context:component 标签告知 Spring 创建容器时必须扫描注解的包
  2. 由于 dbutils 框架是额外引入的，我们无法在其类上写上注解，所以必须在配置文件中写上创建 bean 的配置。
  3. 配置必须的数据源。

这就意味着，我们在使用 Spring 时，如果想要使用注解，必须要注解和配置文件同时使用。不能脱离 xml 配置文件。

那么我们怎么拿掉这些配置文件呢？我们就需要和配置文件中的这些内容有相同功能的注解。

1. Configuration 和 ComponentScan

Configuration 和 ComponentScan 可以解决以上必须配置 context:component-scan 标签

1.1 Configuration

首先，我们在源包下创建一个 config 类：

package config;


/**
 * 该类是一个配置类，它的作用和 bean.xml 是一样的
*/

public class SpringConfiguration {

}

这个类是一个配置类，我们想让它用于和 xml 文件一样的配置功能。此时，我们就需要 Configuration 注解。

这个注解，是 Spring 中的一个新的注解，它的作用是指定当前类为一个配置类。

package config;
import org.springframework.context.annotation.Configuration;

/**
 * 该类是一个配置类，它的作用和 bean.xml 是一样的
*/

@Configuration
public class SpringConfiguration {

}

这样，这个类，便是 Spring 的配置类了，它的功能应该和 Spring 中的 xml 配置文件一样。

这里有一个细节：当配置类作为 AnnotationConfigContext 对象创建的参数时，该注解可以不写。但并不绝对。

1.2 ComponentScan

ComponentScan 的作用：

通过注解注定 Spring 在创建容器时要扫描的包

属性：

  • value：它和 basePackage 的作用是一样的，都是用于指定创建容器时要扫描的包。我们使用次注解，就等同于在 xml 中配置了 context:component-scan 标签。

    /**
	 * Alias for {@link #basePackages}.
	 * <p>Allows for more concise annotation declarations if no other attributes
	 * are needed &mdash; for example, {@code @ComponentScan("org.my.pkg")}
	 * instead of {@code @ComponentScan(basePackages = "org.my.pkg")}.
	 */
	@AliasFor("basePackages")
	String[] value() default {};

	/**
	 * Base packages to scan for annotated components.
	 * <p>{@link #value} is an alias for (and mutually exclusive with) this
	 * attribute.
	 * <p>Use {@link #basePackageClasses} for a type-safe alternative to
	 * String-based package names.
	 */
	@AliasFor("value")
	String[] basePackages() default {};

    原因是因为，两者互为别名（AliasFor， 别名）

然后，我们在该类中使用这个注解就可以了：

package config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
/**
 * 该类是一个配置类，它的作用和 bean.xml 是一样的
*/
@Configuration
@ComponentScan(basePackages = {"com.selflearning"})
public class SpringConfiguration {

}

这样， 就相当于在配置文件中配置了 context:component-scan 标签。

2. Bean 注解

我们来看以下的 Spring 配置文件：

    <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/spring?serverTimezone=Asia/Shanghai"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

这里的 Spring 配置文件创建了两个 bean 对象，并放入了 Spring 的 ioc 容器中。分别是使用带参构造函数创建的 QueryRunner bean 对象和使用 set 构建方式创建的 ComboPooledDataSource 对象。

我们将这些配置信息抽取出来，可以得到以下的两个方法：

    public QueryRunner createQueryRunner(DataSource dataSource) {
        return new QueryRunner(dataSource);
    }
    public DataSource createDataSource() {
        ComboPooledDataSource ds = new ComboPooledDataSource();
        try {
            ds.setDriverClass("com.mysql.cj.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/spring?serverTimezone=Asia/Shanghai");
            ds.setUser("root");
            ds.setPassword("root");
            return ds;
        } catch (PropertyVetoException e) {
            throw new RuntimeException(e);
        }

    }

createQueryRunner 方法通过 QueryRunner 类的构造函数返回一个 QueryRunner 对象。而 createDataSource 方法通过 ComboPooledDataSource 对象的 set 方法创建一个ComboPooledDataSource 对象并返回。这两个方法看似和 Spring 配置文件的创建 bean 对象的过程相同，但实际上少了一步，将创建的 bean 对象翻入 Spring 的 ioc 容器。而这一步，正是 Bean 注解的工作。

2.1 Bean 的作用：

用于把当前方法的返回值作为 bean 对象，存入 Spring 的 IOC 容器中。

2.2 Bean 的属性：

  • name：用于指定 bean 的 id。默认值：当前方法的名称。

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

2.3 Bean 的使用：

	/**
     * 用于创建一个 QueryRunner 对象
     * @param dataSource
     * @return
     */
    @Bean(name = "runner")
    public QueryRunner createQueryRunner(DataSource dataSource) {
        return new QueryRunner(dataSource);
    }

    /**
     * 创建数据源对象
     * @return
     */
    @Bean(name = "dataSource")
    public DataSource createDataSource() {
        ComboPooledDataSource ds = new ComboPooledDataSource();
        try {
            ds.setDriverClass("com.mysql.cj.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/spring?serverTimezone=Asia/Shanghai");
            ds.setUser("root");
            ds.setPassword("root");
            return ds;
        } catch (PropertyVetoException e) {
            throw new RuntimeException(e);
        }

    }

3. AnnotationConfigApplicationContext 类

我们打开测试类：

package com.selflearning.test;

import com.selflearning.spring.domain.Account;
import com.selflearning.spring.service.IAccountService;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class AccountServiceTest {
    @Test
    public void testFindAll() {
        // 1. 获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2. 得到业务层对象
        IAccountService as = ac.getBean("accountService", IAccountService.class);
        // 3. 执行方法
        List<Account> list = as.findAllAccount();

        for(Account account : list) {
            System.out.println(account);
        }
    }
}

发现，所有的测试类，都是使用的配置文件的信息。

嗯？那么我们还使用注解干什么？而且，我已经将配置文件删除了，这样，就会报错。

所以，AnnotationConfigApplicationContext 这位兄弟出场了。它用来读取被 Configuration 注解注解过的配置类。

    @Test
    public void testFindAll() {
        // 1. 获取容器
        ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        // 2. 得到业务层对象
        IAccountService as = ac.getBean("accountService", IAccountService.class);
        // 3. 执行方法
        List<Account> list = as.findAllAccount();

        for(Account account : list) {
            System.out.println(account);
        }
    }

这样，就读取了配置类的信息，就可以正常使用了。

4. Import 注解

如果，我们有几个配置类，并且配置类之间是父子关系，我们已经怎么办呢？

这个时候 Import 注解就出现了。

  • 作用：用于导入其他的配置类

  • 属性

    • value：用于指定其他配置类的字节码

  • 细节：当我们使用 Import 注解之后，有 Import 注解的类就是父配置类，而导入的都是子配置类。

  • Import 注解的使用：

    • 首先是子配置类，用来配置 jdbc 的属性：

      package config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;

/**
 * 连接数据库
 */
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 ds = new ComboPooledDataSource();
        try {
            ds.setDriverClass("com.mysql.cj.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/spring?serverTimezone=Asia/Shanghai");
            ds.setUser("root");
            ds.setPassword("root");
            return ds;
        } catch (PropertyVetoException e) {
            throw new RuntimeException(e);
        }

    }

}

    • 然后是父配置类，这个里面放的应该是一些主要的配置：

      package config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.context.annotation.*;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;

/**
 * 该类是一个配置类，它的作用和 bean.xml 是一样的
 */

@Configuration
@ComponentScan(basePackages = {"com.selflearning"})
@Import(value = JdbcConfig.class)
public class SpringConfiguration {


}

    • 然后就是持久层的 dao 接口：

      package com.selflearning.spring.dao;

import com.selflearning.spring.domain.Account;

import java.util.List;

/**
 * 账户的持久层接口
 */
public interface IAccountDao {

    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();

    /**
     * 查询一个
     * @return accountId
     */
    Account findAccountById(Integer accountId);

    /**
     * 保存
     * @param account
     */
    void saveAccount(Account account);

    /**
     * 更新
     * @param account
     */
    void updateAccount(Account account);

    /**
     * 删除
     * @param accountId
     */
    void deleteAccount(Integer accountId);

}

    • 其实现类：

      package com.selflearning.spring.dao.impl;

import com.selflearning.spring.dao.IAccountDao;
import com.selflearning.spring.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;

/**
 * 账户的持久层实现类
 */
@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {

    @Autowired
    private QueryRunner runner;

    @Override
    public List<Account> findAllAccount() {
        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 from account where id = ?", accountId);
        }catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

    • 业务层 dao 接口代码：

      package com.selflearning.spring.service;

import com.selflearning.spring.domain.Account;

import java.util.List;

/**
 * 账户的业务层接口
 */
public interface IAccountService {

    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();

    /**
     * 查询一个
     * @return accountId
     */
    Account findAccountById(Integer accountId);

    /**
     * 保存
     * @param account
     */
    void saveAccount(Account account);

    /**
     * 更新
     * @param account
     */
    void updateAccount(Account account);

    /**
     * 删除
     * @param accountId
     */
    void deleteAccount(Integer accountId);
}

    • 业务层 dao 接口的实现类：

      package com.selflearning.spring.service.impl;

import com.selflearning.spring.domain.Account;
import com.selflearning.spring.service.IAccountService;
import com.selflearning.spring.dao.IAccountDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

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

    @Autowired
    private IAccountDao accountDao;

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

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

    • 最后就是测试类：

      @Test
    public void testFindAll() {
        // 1. 获取容器
        ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        // 2. 得到业务层对象
        IAccountService as = ac.getBean("accountService", IAccountService.class);
        // 3. 执行方法
        List<Account> list = as.findAllAccount();

        for(Account account : list) {
            System.out.println(account);
        }
    }

    • 运行结果：

      
Account{id=1, name='aaa', money=1000.0}
Account{id=2, name='bbb', money=1000.0}
Account{id=3, name='ccc', money=1000.0}
Account{id=5, name='test', money=2000.0}

当然，如果你使用的是并列关系的配置类，直接在 AnnotationConfigApplicationContext 将配置类的字节码传入即可。

5. PropertySource

我们来看一下之前的数据库配置类：

    /**
     * 创建数据源对象
     *
     * @return
     */
    @Bean(name = "dataSource")
    public DataSource createDataSource() {
        ComboPooledDataSource ds = new ComboPooledDataSource();
        try {
            ds.setDriverClass("com.mysql.cj.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/spring?serverTimezone=Asia/Shanghai");
            ds.setUser("root");
            ds.setPassword("root");
            return ds;
        } catch (PropertyVetoException e) {
            throw new RuntimeException(e);
        }

    }

我们发现，这里的属性，用字符串写死。如果如果数据库进行了迁移或者升级，数据库配置和以前不一样了，那么我们就要进入到 java 文件内部进行修改，这无疑是非常巨大的耦合。所以，Spring 提供了 PropertySource 和 PropertiesSources 这个两个注解来读取 Properties 配置文件。

PropertySource 注解：

  • 作用：用于指定 properties 文件的文职
  • 属性：
    • value：指定文件的名称和路径
    • 关键字：classpath：表示类路径下

PropertySource 注解的使用：

主配置类：

@Configuration
@ComponentScan(basePackages = {"com.selflearning"})
@Import(value = JdbcConfig.class)
// 读取 properties 文件
@PropertySource("classpath:jdbcConfig.properties")
public class SpringConfiguration {


}

数据库配置类：

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.Bean;
import org.springframework.context.annotation.Scope;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;

/**
 * 连接数据库
 */
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 ds = new ComboPooledDataSource();
        try {
            ds.setDriverClass("com.mysql.cj.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/spring?serverTimezone=Asia/Shanghai");
            ds.setUser("root");
            ds.setPassword("root");
            return ds;
        } catch (PropertyVetoException e) {
            throw new RuntimeException(e);
        }

    }

}

测试类结果：

Account{id=1, name='aaa', money=1000.0}
Account{id=2, name='bbb', money=1000.0}
Account{id=3, name='ccc', money=1000.0}
Account{id=5, name='test', money=2000.0}

我们发现，这样进行配置，好像比之前使用 xml 文件进行配置还要更加复杂一些：

    <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/spring?serverTimezone=Asia/Shanghai"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

所以，这里有一个原则：

我们在进行 Spring 的配置的时候，首先要根据企业的编写习惯，这个是没有办法更改的（除非你换个公司。。。）。然后，在自己有选择的时候，我建议，自己编写的类直接使用注解。而当时别人的写好的类或者框架的时候，我们最好还是选择 xml 文件进行配置。这两种进行搭配，应该是最好的。

6. Querylifier 注解的另一种用法

如果当一个对象有多个实现的情况，这种情况下应该怎么办呢？

这个时候，Querylifier 这个注解就又出现了。

我们知道，之前 Querylifier 是和 Autowired 进行搭配使用的。当一个 bean 对象有多个相同类型的注入 bean 时，可以使用 Autowired 和 Querylifier 的搭配来实现 bean 参数的注入。而这里的 Querylifier 是用来指定需注入的 bean 对象的对象名称。

这里的 Querylifier 也是这种用法，用来给参数进行注解。

我们来看以下的例子：

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.Bean;
import org.springframework.context.annotation.Scope;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;

/**
 * 连接数据库
 */
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 = "ds1")
    public DataSource createDataSource() {
        ComboPooledDataSource ds = new ComboPooledDataSource();
        try {
            ds.setDriverClass("com.mysql.cj.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/spring?serverTimezone=Asia/Shanghai");
            ds.setUser("root");
            ds.setPassword("root");
            return ds;
        } catch (PropertyVetoException e) {
            throw new RuntimeException(e);
        }

    }
    
    /**
     * 创建数据源对象
     *
     * @return
     */
    @Bean(name = "ds2")
    public DataSource createDataSource() {
        ComboPooledDataSource ds = new ComboPooledDataSource();
        try {
            ds.setDriverClass("com.mysql.cj.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/spring?serverTimezone=Asia/Shanghai");
            ds.setUser("root");
            ds.setPassword("root");
            return ds;
        } catch (PropertyVetoException e) {
            throw new RuntimeException(e);
        }

    }

}

这里有两个 DataSource 类型的 bean 对象。我们知道使用注解进行 bean 对象的创建，其中的 bean 类型的注入是自动注入。也就是首先通过类型进行判断注入变量是否和唯一一个 bean 对象的类型相同，如果相同注入。如果有两个或和注入变量相同类型的 bean 对象，会根据变量名称来进行注入。如果都没有，便会报错。

这个时候，我们可以使用 Querylifier 注解，给参数进行注解，通过 Bean 对象名称进行注入：

    @Bean(name = "runner")
    @Scope("prototype")
    public QueryRunner createQueryRunner(@Querylifier(
"d1") DataSource dataSource) {
        return new QueryRunner(dataSource);
    }

    /**
     * 创建数据源对象
     *
     * @return
     */
    @Bean(name = "ds1")
    public DataSource createDataSource() {
        ComboPooledDataSource ds = new ComboPooledDataSource();
        try {
            ds.setDriverClass("com.mysql.cj.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/spring?serverTimezone=Asia/Shanghai");
            ds.setUser("root");
            ds.setPassword("root");
            return ds;
        } catch (PropertyVetoException e) {
            throw new RuntimeException(e);
        }

    }

这样就可以了，Spring 就会根据 bean 的名称进行注入。

7. Spring 整合 junit

7.1 问题的分析

在之前编写的测试类中，会重复出现获取 Spring 容器，然后通过容器传进参数获取 bean 对象的操作。

 // 1. 获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2. 得到业务层对象
        IAccountService as = ac.getBean("accountService", IAccountService.class);

虽然可以通过使用 junit 中的 before 和 after 标签来确定一部分代码在测试代码执行前还是执行后执行：

     @Before
    public void init() {
        // 1. 获取容器
        ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2. 得到业务层对象
        as = ac.getBean("accountService", IAccountService.class);
    }

执行结果并没有发生变化。

但是，各位要清楚，测试和编写程序是两个部门或者说是两种程序员干的事，一个测试工程师，一个开发工程师。而这个测试工程师，有可能懂 Spring 框架，也有可能不懂 Spring 框架。所以，测试工程师有可能写不出来上面那一行代码。

测试工程师应该关注的是你的方法能不能通过，然后生成测试报告，不应该关系你的测试类的代码应该如何去写。

那么从哪里进行入手并且解决呢？

那么接下来我们进行分析：

  1. 应用程序的入口
    • main 方法
  2. junit 单元测试中，没有 main 方法也能执行
    • junit 继承了一个 main 方法，该方法就会判断当前测试类中哪些方法有 @Test 注解。如果有，junit 就会让有 test 注解的方法执行。
    • 执行，也就是调用一下 method.invoke
  3. junit 不会管我们是否采用 Spring 框架。
    • 在执行测试方法时，junit 根本不知道我们是不是使用了 Spring 框架。所以也就不会为我们读取配置文件或者配置类，创建核心容器。
  4. 由以上三点可知，当测试方法执行时，没有 ioc 容器，就算写了 Autowired 注解，也无法实现注入。

7.2 问题的解决

  1. 导入 Spring 整合 Junit 的 jar 包（坐标）：

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.1.9.RELEASE</version>
    <scope>test</scope>
</dependency>

  2. 使用 Junit 提供的一个注解，把原有的 main 方法替换，替换成 Spring 提供的 Runwith 注解：

    @RunWith(SpringJUnit4ClassRunner.class)
public class AccountServiceTest {

  3. 告知 Spring 的运行器，Spring 和 ioc 创建是 基于 xml 的，还是基于配置类的。

    • ContextConfiguration 注解:
      • Location 属性：指定 xml 文件的位置，加上 classpath 关键字，表示在类路径下
      • classes：指定类注解所在位置
    @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class AccountServiceTest {

  4. 当我们使用 Spring5 的时候，要求使用的 junit 的版本在 4.12 以上。

  5. 当进行以上操作的时候，我们就可以使用测试类了。

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


    @Resource(name = "accountService")
    private IAccountService as;


    @Test
    public void testFindAll() {

        // 3. 执行方法
        List<Account> list = as.findAllAccount();

        for(Account account : list) {
            System.out.println(account);
        }
    }

    @Test
    public void testFindOne() {
        // 3. 执行方法
        System.out.println(as.findAccountById(1));
    }

    @Test
    public void testSave() {
        // 3. 创建对象
        Account account = new Account();
        account.setMoney(2000.0f);
        account.setName("test");
        as.saveAccount(account);
    }

    @Test
    public void testUpdate() {
        // 3. 创建需要更新的对象
        Account account = new Account();
        account.setId(4);
        account.setName("Mr.Wang");
        account.setMoney(52580f);
        // 4. 调用方法
        as.updateAccount(account);
    }

    @Test
    public void testDelete() {
        // 3. 调用方法
        as.deleteAccount(4);
    }
}
qq_41302594
关注
专栏目录
【Spring框架】（六）Spring 新注解
Java
02-18 233
文章目录新注解说明@Configuration@ComponentScan@Bean@PropertySource@Import通过注解获取容器： 新注解说明 为了更多使用纯注解配置bean，脱离xml文件配置。我们使用更多的新注解。 @Configuration 作用： 用于指定当前类是一个 spring 配置类，当创建容器时会从该类上加载注解。 获取容器时需要使用 AnnotationApp...
Spring 新注解
Java_c#
01-07 119
1、jdbc.properties jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/permession2 jdbc.username=root jdbc.password=root 2、DataSourceConfiguration类 package com.lt.config; import com.mchange.v2.c3p0.ComboPooledDataSource; import org.
spring中常用的注解及其作用
liangweihao的博客
11-15 2416
spring中常用的注解及其作用
自学java中使用 QueryRunner 出现的Cannot create 问题
weixin_62848414的博客
02-02 1043
java中使用 QueryRunner 出现的Cannot create 问题(仅供自学记载，无任何技术含量） 在自学java途中，我想通过QueryRunner来提高效率，但却出现Cannot create这种问题 问题有可能在domain(javaBean)里的类没有设置无参构造器，导致报错，因为框架里创建对象都是用的无参构造器反射创建。 解决方案： ①.给对应的domain设置无参构造器。 [ 代码： public className(){}; ] (仅供自学记载...
typeorm中最简单的事务使用【typeorm系列】
狼丶宇先森的网络科技空间
11-06 2841
一、写在前面 喜欢nestjs的小伙伴在开发后台接口的时候可能会遇到同时给2个或者以上的表写入数据的情况，那么万一其中的某一张表失败了，那其它的表又成功了。这样就会导致一个很严重的问题，数据的一致性与准确性异常了。 很简单的一个例子，假如小明给小张转账10块钱，需要的操作如下： 1、小明的账户需要减去10块钱。 2、小张的账户需要加上10块钱。 3、给小明的转账记录表里面写入一条转出数据。 4、给小张的转账记录表里面写入一条转入数据。 上述的简介，你能想到这样的四个步骤是怎么样操作的吗？ 本系列文章，迟来
QueryRunner类实现对数据库表中数据的增删改查以及八种结果集
LrvingTc的博客
12-25 1万+
update（）方法实现增删改 &amp;amp;nbsp; &amp;amp;nbsp; &amp;amp;nbsp; &amp;amp;nbsp;QueryRunner的update方法 update(Connection conn, String sql, Object… params) 能够实现对表中数据的增删改，返回int类型的数值，表示对数据表影响的行数。conn为传入的Connection连接对象，sql为要执行的sql语句，Object… pa...
QueryRunner使用总结
热门推荐
qq_27869123的博客
07-20 6万+
    使用JDBC技术是一件繁琐的事情，为了使数据库更加高效，有一种简化jdbc技术的操作--DBUtils。DbUtils(org.apache.commons.dbutils.DbUtils)是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。DbUtils类主要负责装载驱动、关闭连接的常规工作。      Qr...
spring框架的学习--事务
11-08
本篇文章将重点围绕“Spring框架的学习--事务”这一主题，深入解析Spring中的事务管理机制。 首先，事务在数据库操作中扮演着至关重要的角色，确保数据的一致性和完整性。事务具有四大特性，通常被称作ACID（原子性...
spring注解 -----最简单的注解与自动装配例子
08-25
在Spring框架中，注解是实现依赖注入（Dependency Injection，DI）的一种重要方式，极大地简化了配置文件，提高了代码的可读性和可维护性。本篇文章将深入探讨Spring中的注解，以及如何通过注解进行自动装配。 首先...
spring5 框架 中文文档_spring-framework-5-doc-cn.zip
03-20
Spring框架是Java后端开发中的核心框架之一，它以其强大的依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）能力而著名。Spring5是该框架的一个重要版本，带来了许多新特性...
spring-demo10-注解-IOC.zip
08-08
"spring-demo10-注解-IOC.zip"这个压缩包文件很显然包含了关于Spring框架如何使用注解进行依赖注入的示例代码。接下来，我们将深入探讨Spring中的注解和依赖注入。 依赖注入（DI）是一种设计模式，它允许我们解耦...
spring_tx.zip_dividezgx_spring-tx_spring框架学习
最新发布
09-20
本文将深入探讨Spring框架中的事务管理，包括基本概念、配置方式以及如何在实际项目中进行事务控制。 首先，事务管理是数据库操作的核心部分，它确保了数据的一致性和完整性。在Spring框架中，事务管理分为编程式...
QueryRunner.query----使用时记得带参数
javadamn的博客
03-08 2671
UserBean org.apache.commons.dbutils.QueryRunner.query(String sql, ResultSetHandler rsh, Object… params) throws SQLException Note: This element neither has attached source nor attached Javadoc and ...
java中QueryRunner用法（增、删、改、查详解）
王树钰的博客
11-19 1万+
前言：使用C3P0连接池连接MySql 1.导入相应的JARs MySQL驱动jar包：mysql-connector-Java-5.1.28-bin.jar C3P0需要的jar包：c3p0-0.9.2-pre1.jar和mchange-commons-0.2.jar 2.在src下添加C3P0配置文件：c3p0-config.xml [html] vi
JDBC QueryRunner（开源框架）之查询 详解
xiongfeng
10-17 8110
QueryRunner查询数据库& QueryRunner如何封装起来的 一、简单描述JDBC获取连接Connection后能做什么？ 首先 查看相关API(一).使用类和方法 QueryRunner（接口的方法如下两个）： update(connection,sql,object…objs) //进行增删改方法 query(connection,sql,ResultSetHandler,objec
QueryRunner的两个构造方法
qq_34231226的博客
03-30 3081
第一种：不带参数的QueryRunner构造方法QueryRunner queryRunner = new QueryRunner();这种情况下，调用update或query方法时，需要传入对应的connection参数queryRunner.update(conn, sql,params);conn.close();DBUtils调用这种带connection参数的方法时，只会关闭prepar...
Spring MVC 框架学习1 - spring mvc 的入门
qq_41302594的博客
09-27 1223
文章目录Spring MVC 的入门1. 关于三层架构和MVC1.1 三层架构1.2 MVC 模型2. SpringMVC 概述2.1 SpringMVC 是什么2.2 SpringMVC 在三层架构的位置2.3 SpringMVC 的优势2.4 SpringMVC 和 Struts2 的优劣分析3. 入门案例3.1 入门案例的需求3.2 搭建开发环境3.3 案例编写的步骤4. 入门案例的流程总结...
Mybatis 框架学习10 - Mybatis中的事务原理和自动提交设置
qq_41302594的博客
08-30 1204
文章目录Mybatis中的事务原理和自动提交设置1. Mybatis 中的事务1.1 什么是事务：1.2 事务的四大特性1.3 不考虑隔离性可能会产生的三个问题1.4 Mybatis 中的事务原理1.5 Mybatis 事务的自动提交 Mybatis中的事务原理和自动提交设置 1. Mybatis 中的事务 1.1 什么是事务： 事务是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列...
Mybatis框架学习3 - 使用Mybatis框架实现CRUD（增删改查）
qq_41302594的博客
08-22 637
文章目录使用 Mybatis 完成 CRUD1. 使用 Mybatis 进行查询所有的操作2. 使用 Mybatis 进行插入数据的操作3.使用 Mybatis 进行更新的操作4.使用 Mybatis 进行删除的操作5.使用 Mybatis 进行查询一个操作6. 使用 Mybatis 框架进行模糊查询操作 使用 Mybatis 完成 CRUD 本节包括： curd 参数深入及结果集的深入 基于传...
Spring框架开发者指南-夏昕
"Spring开发指南-夏昕，V0.6预览版，作者夏昕，专注于Spring框架的开发者指南，包含对Spring框架的详细解释和使用指导，尤其在0.6版本中增加了‘持久层’的内容。文档鼓励开源文档分享精神，并设有严格的版权说明，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值