正文 

当前位置： 首页 > java > java框架

spring07_纯注解实战及spring整合junit

CodeAction的博客      2022-04-05     725

关键词：

本教程源码请访问：tutorial_demo

在《Spring04_IOC和DI实战》当中，我们使用XML配置的方式结合Apache Commons DbUtils实现单表的CRUD操作，这篇教程我们使用纯注解方式结合Apache Commons DbUtils实现单表的CRUD操作。

一、需求和技术要求

1.1、需求

实现单表的CRUD

1.2、技术要求

  1. 使用Spring的IOC实现对象的管理；
  2. 使用Spring的DI实现属性的注入；
  3. 使用Apache Commons DbUtils进行持久层操作；
  4. 使用c3p0数据库连接池。

二、实现过程

2.1、建库建表

DROP DATABASE IF EXISTS springlearn;
CREATE DATABASE springlearn;
USE springlearn;


DROP TABLE IF EXISTS account;
CREATE TABLE account (
  id int(11) NOT NULL AUTO_INCREMENT,
  name varchar(40) DEFAULT NULL,
  money float DEFAULT NULL,
  PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8mb4;

INSERT INTO account VALUES (‘1‘, ‘aaa‘, ‘1000‘);
INSERT INTO account VALUES (‘2‘, ‘bbb‘, ‘1000‘);
INSERT INTO account VALUES (‘3‘, ‘ccc‘, ‘1000‘);
INSERT INTO account VALUES (‘5‘, ‘cc‘, ‘10000‘);
INSERT INTO account VALUES (‘6‘, ‘abc‘, ‘10000‘);
INSERT INTO account VALUES (‘7‘, ‘abc‘, ‘10000‘);

2.2、创建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.codeaction</groupId>
    <artifactId>account</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</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>
</project>

2.3、编写Account实体类

package org.codeaction.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 +
                ‘}‘;
    }
}

2.4、编写持久层接口IAccountDao

package org.codeaction.dao;

import org.codeaction.domain.Account;

import java.util.List;

public interface IAccountDao {
    List<Account> findAll();
    Account findById(Integer id);
    void save(Account account);
    void update(Account account);
    void delete(Integer id);
}

2.5、编写持久层实现类IAccountDaoImpl

package org.codeaction.dao.impl;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.codeaction.dao.IAccountDao;
import org.codeaction.domain.Account;
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 queryRunner;

    public void setQueryRunner(QueryRunner queryRunner) {
        this.queryRunner = queryRunner;
    }

    @Override
    public List<Account> findAll() {
        List<Account> list = null;
        try {
            list = queryRunner.query("select * from account", new BeanListHandler<Account>(Account.class));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return list;
    }

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

    @Override
    public void save(Account account) {
        Object[] params = {account.getName(), account.getMoney()};
        try {
            queryRunner.update("insert into account(name, money) values(?, ?)", params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void update(Account account) {
        Object[] params = {account.getName(), account.getMoney(), account.getId()};
        try {
            queryRunner.update("update account set name=?, money=? where id=?", params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void delete(Integer id) {
        Object[] params = {id};
        try {
            queryRunner.update("delete from account where id=?", id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

2.6、编写业务层接口IAccountService

package org.codeaction.service;

import org.codeaction.domain.Account;

import java.util.List;

public interface IAccountService {
    List<Account> findAll();
    Account findById(Integer id);
    void save(Account account);
    void update(Account account);
    void delete(Integer id);
}

2.7、编写业务层实现类IAccountServiceImpl

package org.codeaction.service.impl;

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

import java.util.List;

@Service("accountService")
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

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

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

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

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

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

2.8、编写JDBC配置类

这个配置类用来配置QueryRunner。

package org.codeaction.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class JdbcConfig {
    @Value("${jdbc.driverClass}")
    private String driverClass;
    @Value("${jdbc.jdbcUrl}")
    private String jdbcUrl;
    @Value("${jdbc.user}")
    private String user;
    @Value("${jdbc.password}")
    private String password;


    @Bean("queryRunner")
    public QueryRunner queryRunner(@Qualifier("dataSource") DataSource dataSource) {
        return new QueryRunner(dataSource);
    }

    @Bean("dataSource")
    public DataSource dataSource() {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        try {
            dataSource.setDriverClass(driverClass);
            dataSource.setJdbcUrl(jdbcUrl);
            dataSource.setUser(user);
            dataSource.setPassword(password);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return dataSource;
    }
}

2.9、编写主配置类

作用：

  • 扫描org.codeaction下的所有注解；
  • 加载jdbc的配置文件，后面会讲怎么写；
  • 导入上面写的JDBC的配置类。
package org.codeaction.config;

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

@Configuration
@ComponentScan(basePackages = "org.codeaction")
@PropertySource("classpath:jdbc.properties")
@Import(JdbcConfig.class)
public class MyConfig {

}

2.10、编写JDBC配置文件

这个文件在resource目录下，文件名：jdbc.properties

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/springlearn
jdbc.user=root
jdbc.password=123456

2.11、编写测试类

package org.codeaction.test;

import org.codeaction.config.MyConfig;
import org.codeaction.domain.Account;
import org.codeaction.service.IAccountService;
import org.codeaction.service.impl.AccountServiceImpl;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class MyTest {
    private IAccountService accountService;
    @Before
    public void init() {
        ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        accountService = context.getBean("accountService", AccountServiceImpl.class);
    }

    @Test
    public void testFindAll() {
        List<Account> accounts = accountService.findAll();
        for (Account account : accounts) {
            System.out.println(account);
        }
    }

    @Test
    public void testFindById() {
        Account account = accountService.findById(3);
        System.out.println(account);
    }

    @Test
    public void testSave() {
        Account account = new Account();
        account.setName("abc");
        account.setMoney(10000F);

        accountService.save(account);

        System.out.println(account);
    }

    @Test
    public void testDelete() {
        accountService.delete(4);
    }

    @Test
    public void testUpdate() {
        Account account = new Account();
        account.setId(5);
        account.setName("ab111111111c111");
        account.setMoney(10000F);
        accountService.update(account);
    }
}

运行测试方法进行测试。

以上就是纯注解方式结合Apache Commons DbUtils实现单表的CRUD操作。

三、Spring整合Junit

在上面的测试类中，有如下的代码

@Before
public void init() {
    ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
    accountService = context.getBean("accountService", AccountServiceImpl.class);
}

这段代码用来创建Spring容器，然后从Spring容器中获取Service对象。

在实际开发中，对于测试人员来讲可能不了解Spring，也不知道如何创建Spring容器，这段代码对测试人员来讲并不友好，有没有什么方式能在测试类中注入Service对象呢？针对上述问题，我们对项目进行进行如下修改。

3.1、在pom.xml中添加坐标

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

这个是Spring整合Junit的Jar包坐标。

3.2、修改测试类

package org.codeaction.test;

import org.codeaction.config.MyConfig;
import org.codeaction.domain.Account;
import org.codeaction.service.IAccountService;
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 java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = MyConfig.class)
public class MyTest {
    @Autowired
    private IAccountService accountService;

    @Test
    public void testFindAll() {
        List<Account> accounts = accountService.findAll();
        for (Account account : accounts) {
            System.out.println(account);
        }
    }

    @Test
    public void testFindById() {
        Account account = accountService.findById(3);
        System.out.println(account);
    }

    @Test
    public void testSave() {
        Account account = new Account();
        account.setName("abc");
        account.setMoney(10000F);

        accountService.save(account);

        System.out.println(account);
    }

    @Test
    public void testDelete() {
        accountService.delete(4);
    }

    @Test
    public void testUpdate() {
        Account account = new Account();
        account.setId(5);
        account.setName("ab111111111c111");
        account.setMoney(10000F);
        accountService.update(account);
    }
}

@RunWith：这个注解用来替换的原来的运行器。

@ContextConfiguration

作用：指定Spring配置文件的位置。

属性：

  • locations：指定XMl文件的位置，加上classpath关键字，表示在类路径下；
  • classes：指定配置类所在地位置。

运行测试方法进行测试。

spring学习5-spring整合jdbc及其事务处理（注解方式）

...:要对数据库执行任何的JDBC操作，需要有一个Connection.在Spring中，Connection对象是通过DataSource获得的。有几种方法可以得到DataSource,其中一种方法是使用Spring提供的轻量级org.springframework.jdbc.datasource.Drive 查看详情

spring纯注解开发模式简直就是spring中的spring(代码片段)

...f3f3;️‍🌈)3.简单数据注入4.读取properties配置文件六.Spring整合MyBatis前言Spring3.0引入了纯注解开发的模式，框架的诞生是为了简化开发，那注解开发 查看详情

redis实战_08_redis集群与spring整合

需要jar包1<dependency>2<groupId>redis.clients</groupId>3<artifactId>jedis</artifactId>4<version>2.8.0</version>5</dependency>spring-redis.xml配置文件：1<?xml 查看详情

太爽了，纯注解开发模式简直就是spring中的spring！(代码片段)

点击关注公众号，实用技术文章及时了解‍Spring3.0引入了纯注解开发的模式，框架的诞生是为了简化开发，那注解开发就是简化再简化。Spring的特性在整合MyBatis方面体现的淋漓尽致哦‍‍一.注解开发以前跟老韩学习S... 查看详情

太爽了，纯注解开发模式简直就是spring中的spring！(代码片段)

点击关注公众号，实用技术文章及时了解‍Spring3.0引入了纯注解开发的模式，框架的诞生是为了简化开发，那注解开发就是简化再简化。Spring的特性在整合MyBatis方面体现的淋漓尽致哦‍‍一.注解开发以前跟老韩学习S... 查看详情

深入浅出spring原理及实战「开发实战系列」spring-cache扩展自定义（注解失效时间+主动刷新缓存）(代码片段)

缓存失效时间支持在方法的注解上指定SpringCache默认是不支持在@Cacheable上添加过期时间的，可以在配置缓存容器时统一指定：@BeanpublicCacheManagercacheManager(@SuppressWarnings("rawtypes")RedisTemplateredisTemplate)Custo 查看详情

spring纯注解开发模式

1纯注解开发模式介绍Spring3.0开启了纯注解开发模式，使用Java类替代配置文件，开启了Spring快速开发赛道，Java类代替Spring核心配置文件@Configuration注解用于设定当前类为配置类@ComponentScan注解用于设定扫描路径，此注解只能添加... 查看详情

javaee开发之spring框架整合2(完结撒花)(代码片段)

...何式增长，开发难度也在不断递增，该如何解决?Spring可以简化开发，降低企业级开发的复杂性，使开发变得更简单快捷随着项目规模与功能的增长,遇到的问题就会增多，为了解决问题会引入更多的框架，... 查看详情

spring4-@postconstruct和@predestroy注解的使用

1.创建Maven项目,项目名称springdemo41,如图所示650)this.width=650;"src="https://s5.51cto.com/wyfs02/M01/8F/26/wKioL1jU6HCCzzeOAABAztI0By4255.png-wh_500x0-wm_3-wmp_4-s_1111367677.png"title="QQ截图20170324173450.png"al 查看详情

二java框架之spring注解开发(代码片段)

...ig类）引用类型的注入总结1.6XML配置和注解配置对比2.Spring整合MyBatis2.1mybatis写法回顾2.2整合：导入依赖：pom.xml2.3整合：环境准备2.4整合：Spring核心配置文件SpringConfig.javaJdbcConfig.javaMybatisConfig.java2.5运行和说明3.... 查看详情

spring(代码片段)

这里写目录标题spring中ioc的常用注解环境搭建常用注解spring的纯注解配置案例使用xml方式和注解方式实现单表的CRUD操作环境搭建配置步骤测试案例改造基于注解的ioc案例，使用纯注解的方式实现spring的新注解使用spring和Junit... 查看详情

spring(代码片段)

这里写目录标题spring中ioc的常用注解环境搭建常用注解spring的纯注解配置案例使用xml方式和注解方式实现单表的CRUD操作环境搭建配置步骤测试案例改造基于注解的ioc案例，使用纯注解的方式实现spring的新注解使用spring和Junit... 查看详情

项目一众筹网07_01_springsecurity框架简介和用法springsecurity负责的是权限验证spring的注解模式maven引入spring环境加入layui环境

项目一众筹网07_01_SpringSecurity文章目录项目一众筹网07_01_SpringSecurity01简介SpringSecurity负责的是权限验证02-SpringSecurity简介03-Spring的注解模式maven引入Spring环境04-准备测试环境05-加入SpringSecurity环境06-实验1-放行首页和静态资源（... 查看详情

spring的纯注解配置

...文件，是因为有一句很关键的配置：　　　　<!--告知spring框架在，读取配置文件，创建容器时，扫描注解，依据注解创建对象，并存入容器中-->　　　　<context:component-scanbase-package="com.fgy"></context:c 查看详情

深入浅出spring原理及实战「开发实战系列」springsecurity技术实战之通过注解表达式控制方法权限(代码片段)

SpringSecurity权限控制机制SpringSecurity中可以通过表达式控制方法权限，其中有四个支持使用表达式的注解，分别是@PreAuthorize、@PostAuthorize、@PreFilter和@PostFilter。其中前两者可以用来在方法调用前或者调用后进行... 查看详情

spring_代理

1.代理模式。 2.静态代理原理及实践。 3.动态代理原理及实践。 4.SpringAOP原理及实战。 静态代理原理及实践packagetest.staticProxy;//接口publicinterfaceIUserDao{voidsave();voidfind();}//目标对象classUserDaoimplementsIUserDao{@Overri 查看详情

spring整合ehcache管理缓存

...个成熟的缓存框架，你可以直接使用它来管理你的缓存。Spring提供了对缓存功能的抽象：即允许绑定不同的缓存解决方案（如Ehcache），但本身不直接提供缓存功能的实现。它支持注解方式使用缓存，非常方便。本文先通过Ehcache... 查看详情

学习笔记——spring中组件扫描（包含扫描排除扫描）spring中完全注解开发；spring整合junit4步骤(代码片段)

2023-01-18一、Spring中组件扫描1、默认使用的情况<context:component-scanbase-package="com.hh"></context:component-scan>2、包含扫描注：使用包含扫描之前，必须设置use-default-filters="false"（关闭当前包及其子包的扫描）type类型：①annotation... 查看详情