使用Spring+druid+mysql+junit 通过注解整合事务

柔光的暖阳◎ 2021-09-21 05:46 228阅读 0赞

这里使用Spring+druid+mysql+junit注解整合事务, 此demo完全使用spring注解的方式来实现spring的事务控制(spring-tx), 通过这篇文章你可以了解配置spring事务的注解有哪些, 以及不使用xml如何配置spring.

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

### 文章目录 ###

*   *  依赖配置pom.xml
     *  注解主要配置文件
     *  Service实现类
     *  Dao实现类
     *  domain
     *  测试

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

## 依赖配置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.qichun</groupId>
        <artifactId>spring_tx_xml</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>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>5.0.2.RELEASE</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>5.0.2.RELEASE</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>5.0.2.RELEASE</version>
            </dependency>
    
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.18</version>
            </dependency>
    
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.20</version>
            </dependency>
    
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
    
        </dependencies>
    </project>

## 注解主要配置文件 ##

**主配置类: BeanConfiguration.class**

package config;
    
    
    import org.springframework.context.annotation.*;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    
    /** * spring 配置类, 相当于bean.xml */
    //标明配置类
    @Configuration
    //配置扫描bean的范围
    @ComponentScan(value = "com.qichun")
    //导入其他配置类
    @Import({ JdbcConfig.class,TransactionConfig.class})
    //读取配置文件
    @PropertySource("jdbcConfig.properties")
    //开启spring事务管理
    @EnableTransactionManagement
    public class BeanConfiguration { 
    
    }

**jdbc配置类: JdbcConfig.java**  
可以使用**spring的数据源**, 也可以使用**druid的数据源.**

package config;
    
    import com.alibaba.druid.pool.DruidDataSource;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.jdbc.datasource.DriverManagerDataSource;
    
    import javax.sql.DataSource;
    import java.sql.SQLException;
    
    /** * 数据库配置类 */
    public class JdbcConfig { 
        //读取properties值
    	@Value("${jdbc.driver}")
    	private String driver;
    
    	@Value("${jdbc.url}")
    	private String url;
    
    	@Value("${jdbc.username}")
    	private String username;
    
    	@Value("${jdbc.password}")
    	private String password;
    //---------------------------------
    
    
    
    	/** * 根据DataSource对象创建JdbcTemplate */
    	@Bean(name = "jdbcTemplate")
    	@Qualifier("dataSource")
    	public JdbcTemplate createJdbcTemplate(DataSource dataSource) { 
    		return new JdbcTemplate(dataSource);
    	}
    
    	/** * 所使用的数据源 */
    	@Bean(name="dataSource")
    	public DataSource getDataSource(){ 
    		//当前使用的是Druid连接池
    		return createDruidDataSource();
    	}
    
    
    	/** * 配置Spring数据源对象 */
    	private DataSource createSpringDataSource() { 
    		DriverManagerDataSource ds = new DriverManagerDataSource();
    		ds.setDriverClassName(driver);
    		ds.setUrl(url);
    		ds.setUsername(username);
    		ds.setPassword(password);
    		return ds;
    	}
    
    	/** * 配置Druid数据源 */
    	private DataSource createDruidDataSource(){ 
    		DruidDataSource ds = new DruidDataSource();
    		ds.setDriverClassName(driver);
    		ds.setUrl(url);
    		ds.setUsername(username);
    		ds.setPassword(password);
    		//-----------------------
    		ds.setInitialSize(3);
    		ds.setMinIdle(3);
    		ds.setMaxActive(20);
    		ds.setMaxWait(60000);
    		ds.setTimeBetweenEvictionRunsMillis(60000);
    		ds.setMinEvictableIdleTimeMillis(300000);
    		ds.setValidationQuery("SELECT 'x'");
    		try { 
    			ds.setFilters("stat");
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		}
    		return ds;
    	}
    }

**spring事务管理配置类: TransactionConfig.class**

package config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.jdbc.datasource.DataSourceTransactionManager;
    import org.springframework.transaction.PlatformTransactionManager;
    
    import javax.sql.DataSource;
    
    public class TransactionConfig { 
    
    	/** * 用于创建事务管理的对象 * @param dataSource * @return */
    	@Bean(name="transactionManager")
    	public PlatformTransactionManager createTransactionManager(DataSource dataSource){ 
    		return new DataSourceTransactionManager(dataSource);
    	}
    
    }

**数据库配置文件: jdbcConfig.properties**

#mysql 8.0 driver 位置
    jdbc.driver=com.mysql.cj.jdbc.Driver
    jdbc.url=jdbc:mysql:///spring_db?serverTimezone=UTC
    jdbc.username=root
    jdbc.password=123456
    
    #special---druid---------------
    initialSize=3
    minIdle=3
    maxActive=20
    maxWait=60000
    timeBetweenEvictionRunsMillis=60000
    minEvictableIdleTimeMillis=300000
    validationQuery=SELECT 'x'
    testOnReturn=false
    filters=stat

## Service实现类 ##

package com.qichun.service.impl;
    
    import com.qichun.dao.AccountDao;
    import com.qichun.domain.Account;
    import com.qichun.service.AccountService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;
    
    //标明服务层组件
    @Service(value="accountService")
    //配置读写型事务 propagation为传播选项
    @Transactional(propagation = Propagation.SUPPORTS,readOnly = true)//只读型事务
    public class AccountServiceImpl implements AccountService { 
    
    	@Autowired
    	@Qualifier(value = "accountDao")
    	private AccountDao accountDao;
    
    //--------------------------------------------------------
    
    	@Override
    	//配置读写型事务 propagation为传播选项
    	@Transactional(propagation = Propagation.REQUIRED,readOnly = false)
    	public boolean transTo(int fromId, int toId, double money) { 
    		System.out.println("trans to ............");
    		//业务逻辑主体
    		try { 
    			Account from = accountDao.findById(fromId);
    			Account to = accountDao.findById(toId);
    
    			from.setMoney(from.getMoney() - money);
    
    // int n = 1/0;//test transaction
    
    			to.setMoney(to.getMoney() + money);
    
    			accountDao.update(from);
    			accountDao.update(to);
    			return true;
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    		return false;
    	}
    }

## Dao实现类 ##

package com.qichun.dao.impl;
    
    import com.qichun.dao.AccountDao;
    import com.qichun.domain.Account;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.jdbc.core.BeanPropertyRowMapper;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.jdbc.core.support.JdbcDaoSupport;
    import org.springframework.stereotype.Repository;
    
    /** * dao接口实现类 */
    @Repository(value = "accountDao")
    public class AccountDaoImpl implements AccountDao { 
    
    	@Autowired //自动注入对象
    	private JdbcTemplate jdbcTemplate;
    
    
    	//----------------------------------------------------
    	@Override
    	public Account findById(int id) { 
    		try { 
    			return jdbcTemplate.queryForObject("select * from account where id=?", new BeanPropertyRowMapper<Account>(Account.class), id);
    		} catch (Exception e) { 
    			e.printStackTrace();
    			throw new RuntimeException(e);
    		}
    	}
    
    	@Override
    	public void update(Account acc) { 
    		try { 
    			jdbcTemplate.update("update account set name=?,money=? where id=?", acc.getName(), acc.getMoney(), acc.getId());
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    	}
    }

## domain ##

package com.qichun.domain;
    
    import java.io.Serializable;
    
    public class Account implements Serializable { 
    	private Integer id;
    	private String name;
    	private Double 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 Double getMoney() { 
    		return money;
    	}
    
    	public void setMoney(Double money) { 
    		this.money = money;
    	}
    
    	@Override
    	public String toString() { 
    		return "Account{" +
    				"id=" + id +
    				", name='" + name + '\'' +
    				", money=" + money +
    				'}';
    	}
    }

## 测试 ##

package com.qichun;
    
    import com.qichun.service.AccountService;
    import config.BeanConfiguration;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    //使用spring-test整合junit--加载spring核心容器
    @RunWith(SpringJUnit4ClassRunner.class)
    //配置bean配置文件路径
    @ContextConfiguration(classes = { BeanConfiguration.class})
    
    public class AccountTest { 
    	@Autowired
    	AccountService accountService;
    
    	//测试事务
    	@Test
    	public void test__() { 
    		accountService.transTo(1, 2, 200);
    	}
    
    }

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

> **想了解作者更多，请移步我的个人网站，欢迎交流、留言~**  
> **极客技术空间：[https://elltor.com/][https_elltor.com]**

[https_elltor.com]: https://elltor.com/