Spring注解开发&整合Junit测试

松儿松
469 阅读4分钟

1.新建maven项目导入依赖

<?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>org.example</groupId>
    <artifactId>ioc-annotation</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.32</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>

    </dependencies>
</project>

2.用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"
       xmlns:con="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
">
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>

</beans>

2.1新建spring配置文件applicationContext.xml

2.1.1传统的xml方式通过bean标签，注册数据源对象到spring容器中，通过properties标签进行依赖注入

2.1.2这里数据源的依赖注入也是通过set方法注入，查看源码如下

image.png

2.2在spring配置文件中导入jdbc.properties配置数据源对象

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root

2.2.1在applicationContext.xml文件中导入jdbc.properties配置需要引入context:property-placeholder标签

<?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"
       xmlns:con="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
">
<!--    导入jdbc.properties-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

2.3测试数据源对象是否正确配置

2.3.1创建Test测试类

package com.abchina.test;

import com.abchina.config.SpringConfiguration;
import com.abchina.dao.UserDao;
import com.abchina.service.UserService;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidPooledConnection;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

public class  TestDemo {
    @Test
    public void testC3P0() throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUser("root");
        dataSource.setPassword("root");
        Connection connection = dataSource.getConnection();
        System.out.println(connection);

    }
    @Test
    public void testC3P0_spring_di() throws Exception {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        ComboPooledDataSource dataSource = (ComboPooledDataSource) applicationContext.getBean("dataSource");
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
    }
    @Test
    public void testDruid() throws SQLException {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        DruidPooledConnection connection = dataSource.getConnection();
        System.out.println(connection);

    }
}

3.使用注解配置userDao对象和userService对象

3.0在applicationContext.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"
       xmlns:con="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
">
<!--    导入jdbc.properties-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
<!--    注解的组件扫描，加入要扫描的package路径-->
    <context:component-scan base-package="com.abchina"/>
</beans>

3.1新建userDao和userService接口以及实现类

package com.abchina.dao;

public interface UserDao {
    public void save();
}


package com.abchina.dao.impl;

import com.abchina.dao.UserDao;
import org.springframework.beans.factory.annotation.Value;

import org.springframework.stereotype.Repository;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Repository("userDao")
//@Component("userDao")
public class UserDaoImpl implements UserDao {
    @Value("注入普通数据")
    private String str;

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


    public void save() {
        System.out.println(str);
        System.out.println(driver);
        System.out.println("save running.....");
    }

    @PostConstruct
    public void init() {
        System.out.println("在创建userDao之前执行");
    }
    @PreDestroy
    public void destroy() {
        System.out.println("在销毁userDao之后执行");
    }
}


package com.abchina.service;

public interface UserService {
    public void save();
}

package com.abchina.service.impl;

import com.abchina.dao.UserDao;
import com.abchina.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service("userService")
public class UserServiceImpl implements UserService {

//    @Autowired
//    @Qualifier("userDao")
    @Resource(name = "userDao")
    private UserDao userDao;
    public void save() {
        userDao.save();
    }
}

3.2 几个类注解的含义

3.2.1 @Controller,@Service,@Repository,@Component四个注解都是作用在接口实现类上，用于将实现类对象注册到spring容器中

@Repository("userDao")
//@Component("userDao")
public class UserDaoImpl implements UserDao

@Service("userService")
public class UserServiceImpl implements UserService

3.3 几个依赖注入的注解含义

3.3.1 @Value,@Autowired,@Qualifier,@Resource四个注解的作用都是将对象的属性进行依赖注入，@Value注解一般用于基本类型值注入，@Autowired一般按照类型进行注入，可以结合@Qualifier注解按照名称注入属性，@Resource=@Autowired+@Qualifier，一般常用@Resource注解

    @Value("注入普通数据")
    private String str;

    @Value("${jdbc.driver}")
    private String driver;
    
//   @Autowired
//   @Qualifier("userDao")
    @Resource(name = "userDao")
    private UserDao userDao;

3.3.2 @PostConstruct和@PreDestroy注解

    @PostConstruct
    public void init() {
        System.out.println("初始化方法");
    }
    @PreDestroy
    public void destroy() {
        System.out.println("销毁方法");
    }

4.使用纯注解开发

4.1在上述配置中，对象的注册以及属性的注入都可以通过注解来实现了，但是在spring配置文件中还存在着导入jdbc.properties的配置项，和开启注解扫描package的配置项，和dataSource的注册以及属性注入无法通过注解来实现

使用上面的注解还不能全部替代xml配置文件，还需要使用注解替代的配置如下：

非自定义的Bean的配置：<bean>（数据源对象配置）
加载properties文件的配置：<context:property-placeholder>
组件扫描的配置：<context:component-scan>
引入其他文件：<import>

4.2@PropertySource用于导入properties配置文件

@PropertySource("classpath:jdbc.properties")
public class DataSourceConfiguration {}
注解等价于
<!--    导入jdbc.properties-->
<context:property-placeholder location="classpath:jdbc.properties"/>

4.3@ComponentScan导入注解配置要扫描的包名

@ComponentScan("com.abchina")
public class SpringConfiguration {}
注解等价于
<!--    注解的组件扫描，加入要扫描的package路径-->
<context:component-scan base-package="com.abchina"/>

4.4@Configuration注解是用于指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解

4.5@Import用于导入其他配置类

4.6@Bean用于将放回的返回值对象注册到spring容器中

4.7完整配置类代码如下

4.7.1数据源配置类

package com.abchina.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;

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

@PropertySource("classpath:jdbc.properties")
public class DataSourceConfiguration {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean(name = "dataSource")
    public DataSource getDataSource() throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

4.7.2spring配置类

package com.abchina.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@ComponentScan("com.abchina")
@Import({DataSourceConfiguration.class})
public class SpringConfiguration {
}


# 4.8测试类代码

```java
package com.abchina.test;

import com.abchina.config.SpringConfiguration;
import com.abchina.dao.UserDao;
import com.abchina.service.UserService;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidPooledConnection;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

public class  TestDemo {
    @Test
    public void testConfiguration() throws SQLException {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.save();
        DataSource dataSource = (DataSource) applicationContext.getBean("dataSource");
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
    }
    @Test
    public void test_userDao_Annotation() {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        userDao.save();
    }
    @Test
    public void test_userService_Annotation() {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userDao = (UserService) applicationContext.getBean("userService");
        userDao.save();
    }
    @Test
    public void testC3P0() throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUser("root");
        dataSource.setPassword("root");
        Connection connection = dataSource.getConnection();
        System.out.println(connection);

    }
    @Test
    public void testC3P0_spring_di() throws Exception {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        ComboPooledDataSource dataSource = (ComboPooledDataSource) applicationContext.getBean("dataSource");
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
    }

    @Test
    public void testDruid() throws SQLException {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        DruidPooledConnection connection = dataSource.getConnection();
        System.out.println(connection);

    }
}

5.spring整合junit

在测试类中，每个测试方法都有以下两行代码：

ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
IAccountService as = ac.getBean("accountService",IAccountService.class);

这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常。所以又不能轻易删掉

  • 让SpringJunit负责创建Spring容器，但是需要将配置文件的名称告诉它。将需要进行测试Bean直接在测试类中进行注入

5.1整合步骤

  • 1.导入spring集成Junit的坐标
  • 2.使用@Runwith注解替换原来的运行期
  • 3.使用@ContextConfiguration指定配置文件或配置类
  • 4.使用@Autowired注入需要测试的对象
  • 5.创建测试方法进行测试

5.2测试源码

package com.abchina.test;

import com.abchina.config.SpringConfiguration;
import com.abchina.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.sql.SQLException;


@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration("classpath:applicationContext.xml")
//加载spring核心配置类
@ContextConfiguration(classes = {SpringConfiguration.class})
public class SpringJunitTest {
    @Autowired
    private UserService userService;

    @Resource
    private DataSource dataSource;
    @Test
    public void test() throws SQLException {
        userService.save();
        System.out.println(dataSource.getConnection());
    }
}

6.遇到的问题及解决办法

6.1使用@Bean注解时没有加入name属性，导致找不到dataSource对象

image.png

6.2使用@RunWith(SpringJUnit4ClassRunner.class)一直无法导入SpringJUnit4ClassRunner.class，百度了一下说是junit版本和spring-test版本的原因，但是版本修改后也无法导入，最后将scope标签下的test去掉了重新reload依赖文件突然就好了，建议按照pom.xml文件版本来配置junit和spring-test

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.5.RELEASE</version>
            需要去掉test范围
<!--            <scope>test</scope>-->
        </dependency>

7.demo源码链接

avatar
文章
阅读
粉丝
相关推荐
SpringBoot整合Junit
764阅读
 · 
0点赞
Spring junit整合
271阅读
 · 
0点赞
使用JUnit进行单元测试
18k阅读
 · 
16点赞
Spring是如何整合JUnit的？JUnit源码关联延伸阅读
777阅读
 · 
1点赞
MyBatis的JUnit测试
4.7k阅读
 · 
5点赞
JUnit4 & TestNG 与 Spring 整合
2.0k阅读
 · 
8点赞
JUnit4教程+实践
8.5k阅读
 · 
29点赞
用JUnit 5进行Spring Boot测试的详细指南
5.2k阅读
 · 
0点赞
JUnit5的注解demo
364阅读
 · 
2点赞
androidJUnitRunner以及JUnit的学习和使用
3.3k阅读
 · 
0点赞

友情链接：