Spring第四天

Spring第四天
1、spring中的JdbcTemplate

JdbcTemplate的作用:
    它就是用于和数据库交互的,实现对表的CRUD操作
如何创建该对象:
对象中的常用方法:

2、作业:

spring基于AOP的事务控制

3、spring中的事务控制

基于XML的
基于注解的

image.png

jdbctemplate

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.itheima</groupId>
<artifactId>day04_eesy_01jdbctemplate</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-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>5.1.6</version>
    </dependency>
</dependencies>

</project>

bean.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"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">

<!-- 配置账户的持久层使用继承support->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
    <!--<property name="jdbcTemplate" ref="jdbcTemplate"></property>-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

<!-- 配置账户的持久层-->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>

<!--配置JdbcTemplate
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"></property>
</bean>-->

<!-- 配置数据源-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
    <property name="username" value="root"></property>
    <property name="password" value="1234"></property>
</bean>

</beans>

IAccountDao.java

package com.itheima.dao;

import com.itheima.domain.Account;

/**

  • 账户的持久层接口

*/
public interface IAccountDao {

/**
 * 根据Id查询账户
 * @param accountId
 * @return
 */
Account findAccountById(Integer accountId);

/**
 * 根据名称查询账户
 * @param accountName
 * @return
 */
Account findAccountByName(String accountName);

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

}

Account.java

package com.itheima.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 +
            '}';
}

}

AccountDaoImpl.java

package com.itheima.dao.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import java.util.List;

/**

  • 账户的持久层实现类

*/
public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {

@Override
public Account findAccountById(Integer accountId) {
    List<Account> accounts = super.getJdbcTemplate().query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
    return accounts.isEmpty()?null:accounts.get(0);
}

@Override
public Account findAccountByName(String accountName) {
    List<Account> accounts = super.getJdbcTemplate().query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
    if(accounts.isEmpty()){
        return null;
    }
    if(accounts.size()>1){
        throw new RuntimeException("结果集不唯一");
    }
    return accounts.get(0);
}

@Override
public void updateAccount(Account account) {
    super.getJdbcTemplate().update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
}

}

AccountDaoImpl2.java

package com.itheima.dao.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

/**

  • 账户的持久层实现类

*/
@Repository
public class AccountDaoImpl2 implements IAccountDao {

@Autowired
private JdbcTemplate jdbcTemplate;


@Override
public Account findAccountById(Integer accountId) {
    List<Account> accounts = jdbcTemplate.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
    return accounts.isEmpty()?null:accounts.get(0);
}

@Override
public Account findAccountByName(String accountName) {
    List<Account> accounts = jdbcTemplate.query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
    if(accounts.isEmpty()){
        return null;
    }
    if(accounts.size()>1){
        throw new RuntimeException("结果集不唯一");
    }
    return accounts.get(0);
}

@Override
public void updateAccount(Account account) {
    jdbcTemplate.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
}

}

JdbcDaoSupport.java

package com.itheima.dao.impl;

/**

  • 此类用于抽取dao中的重复代码

public class JdbcDaoSupport {

private JdbcTemplate jdbcTemplate;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
    this.jdbcTemplate = jdbcTemplate;
}

public JdbcTemplate getJdbcTemplate() {
    return jdbcTemplate;
}


public void setDataSource(DataSource dataSource) {
    if(jdbcTemplate == null){
        jdbcTemplate = createJdbcTemplate(dataSource);
    }
}

private JdbcTemplate createJdbcTemplate(DataSource dataSource){
    return new JdbcTemplate(dataSource);
}

}
*/

JdbcTemplateDemo1.java

package com.itheima.jdbctemplate;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

/**

  • JdbcTemplate的最基本用法

*/
public class JdbcTemplateDemo1 {

public static void main(String[] args) {
    //准备数据源:spring的内置数据源
    DriverManagerDataSource ds = new DriverManagerDataSource();
    ds.setDriverClassName("com.mysql.jdbc.Driver");
    ds.setUrl("jdbc:mysql://localhost:3306/eesy");
    ds.setUsername("root");
    ds.setPassword("1234");

    //1.创建JdbcTemplate对象
    JdbcTemplate jt = new JdbcTemplate();
    //给jt设置数据源
    jt.setDataSource(ds);
    //2.执行操作
    jt.execute("insert into account(name,money)values('ccc',1000)");
}

}

JdbcTemplateDemo2.java

package com.itheima.jdbctemplate;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

/**

  • JdbcTemplate的最基本用法

*/
public class JdbcTemplateDemo2 {

public static void main(String[] args) {
    //1.获取容器
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    //2.获取对象
    JdbcTemplate jt = ac.getBean("jdbcTemplate",JdbcTemplate.class);
    //3.执行操作
    jt.execute("insert into account(name,money)values('ddd',2222)");


 /*   //准备数据源:spring的内置数据源
    DriverManagerDataSource ds = new DriverManagerDataSource();
    ds.setDriverClassName("com.mysql.jdbc.Driver");
    ds.setUrl("jdbc:mysql://localhost:3306/eesy");
    ds.setUsername("root");
    ds.setPassword("1234");

    //1.创建JdbcTemplate对象
    JdbcTemplate jt = new JdbcTemplate();
    //给jt设置数据源
    jt.setDataSource(ds);
    //2.执行操作
    jt.execute("insert into account(name,money)values('ccc',1000)");*/
}

}

JdbcTemplateDemo3.java

package com.itheima.jdbctemplate;

import com.itheima.domain.Account;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.sql.ResultSet;
import java.sql.SQLException;

/**

  • JdbcTemplate的CRUD操作

*/
public class JdbcTemplateDemo3 {

public static void main(String[] args) {
    //1.获取容器
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    //2.获取对象
    JdbcTemplate jt = ac.getBean("jdbcTemplate",JdbcTemplate.class);
    //3.执行操作
    //保存

// jt.update("insert into account(name,money)values(?,?)","eee",3333f);

    //更新

// jt.update("update account set name=?,money=? where id=?","test",4567,7);

    //删除

// jt.update("delete from account where id=?",8);

    //查询所有

// List<Account> accounts = jt.query("select * from account where money > ?",new AccountRowMapper(),1000f);
// List<Account> accounts = jt.query("select * from account where money > ?",new BeanPropertyRowMapper<Account>(Account.class),1000f);
// for(Account account : accounts){
// System.out.println(account);
// }

    //查询一个

// List<Account> accounts = jt.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),1);
// System.out.println(accounts.isEmpty()?"没有内容":accounts.get(0));

    //查询返回一行一列(使用聚合函数,但不加group by子句)
    Long count = jt.queryForObject("select count(*) from account where money > ?",Long.class,1000f);
    System.out.println(count);


}

}

/**

  • 定义Account的封装策略

*/
class AccountRowMapper implements RowMapper<Account>{

/**
 * 把结果集中的数据封装到Account中,然后由spring把每个Account加到集合中
 * @param rs
 * @param rowNum
 * @return
 * @throws SQLException
 */
@Override
public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
    Account account = new Account();
    account.setId(rs.getInt("id"));
    account.setName(rs.getString("name"));
    account.setMoney(rs.getFloat("money"));
    return account;
}

}

JdbcTemplateDemo4.java

package com.itheima.jdbctemplate;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**

  • JdbcTemplate的最基本用法

*/
public class JdbcTemplateDemo4 {

public static void main(String[] args) {
    //1.获取容器
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    //2.获取对象
    IAccountDao accountDao = ac.getBean("accountDao",IAccountDao.class);

    Account account = accountDao.findAccountById(1);
    System.out.println(account);

    account.setMoney(30000f);
    accountDao.updateAccount(account);
}

}

Spring中的事务控制

1 基于XML的AOP实现事务控制

预留代码

2 基于注解的AOP实现事务控制及问题分析上

image.png

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.itheima</groupId>
<artifactId>day04_eesy_03account_aoptx_anno</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>commons-dbutils</groupId>
        <artifactId>commons-dbutils</artifactId>
        <version>1.4</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</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.12</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.7</version>
    </dependency>
</dependencies>

</project>

bean.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:aop="http://www.springframework.org/schema/aop"
   xmlns:context="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/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">

<!--配置spring创建容器时要扫描的包-->
<context:component-scan base-package="com.itheima"></context:component-scan>


<!--配置QueryRunner-->
<bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype"></bean>

<!-- 配置数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <!--连接数据库的必备信息-->
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/eesy"></property>
    <property name="user" value="root"></property>
    <property name="password" value="1234"></property>
</bean>


<!--开启spring对注解AOP的支持-->

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

AccountDaoImpl.xml

package com.itheima.dao.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.utils.ConnectionUtils;
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.util.List;

/**

  • 账户的持久层实现类

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

@Autowired
private QueryRunner runner;

@Autowired
private ConnectionUtils connectionUtils;


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

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

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

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

@Override
public void deleteAccount(Integer accountId) {
    try{
        runner.update(connectionUtils.getThreadConnection(),"delete from account where id=?",accountId);
    }catch (Exception e) {
        throw new RuntimeException(e);
    }
}

@Override
public Account findAccountByName(String accountName) {
    try{
        List<Account> accounts = runner.query(connectionUtils.getThreadConnection(),"select * from account where name = ? ",new BeanListHandler<Account>(Account.class),accountName);
        if(accounts == null || accounts.size() == 0){
            return null;
        }
        if(accounts.size() > 1){
            throw new RuntimeException("结果集不唯一,数据有问题");
        }
        return accounts.get(0);
    }catch (Exception e) {
        throw new RuntimeException(e);
    }
}

}

IAccountDao.java

package com.itheima.dao;

import com.itheima.domain.Account;

import java.util.List;

/**

  • 账户的持久层接口

*/
public interface IAccountDao {

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

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

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

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

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

/**
 * 根据名称查询账户
 * @param accountName
 * @return  如果有唯一的一个结果就返回,如果没有结果就返回null
 *          如果结果集超过一个就抛异常
 */
Account findAccountByName(String accountName);

}

AccountServiceImpl.java

package com.itheima.service.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.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;


@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 acccountId) {
    accountDao.deleteAccount(acccountId);
}

@Override
public void transfer(String sourceName, String targetName, Float money) {
    System.out.println("transfer....");
        //2.1根据名称查询转出账户
        Account source = accountDao.findAccountByName(sourceName);
        //2.2根据名称查询转入账户
        Account target = accountDao.findAccountByName(targetName);
        //2.3转出账户减钱
        source.setMoney(source.getMoney()-money);
        //2.4转入账户加钱
        target.setMoney(target.getMoney()+money);
        //2.5更新转出账户
        accountDao.updateAccount(source);

        int i=1/0;

        //2.6更新转入账户
        accountDao.updateAccount(target);
}

}

IAccountService.java

package com.itheima.service;

import com.itheima.domain.Account;

import java.util.List;

/**

  • 账户的业务层接口

*/
public interface IAccountService {

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

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

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

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

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

/**
 * 转账
 * @param sourceName        转出账户名称
 * @param targetName        转入账户名称
 * @param money             转账金额
 */
void transfer(String sourceName,String targetName,Float money);

//void test();//它只是连接点,但不是切入点,因为没有被增强

}

ConnectionUtils.java

package com.itheima.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

/**

  • 连接的工具类,它用于从数据源中获取一个连接,并且实现和线程的绑定

*/
@Component("connectionUtils")
public class ConnectionUtils {

private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();

@Autowired
private DataSource dataSource;


/**
 * 获取当前线程上的连接
 * @return
 */
public Connection getThreadConnection() {
    try{
        //1.先从ThreadLocal上获取
        Connection conn = tl.get();
        //2.判断当前线程上是否有连接
        if (conn == null) {
            //3.从数据源中获取一个连接,并且存入ThreadLocal中
            conn = dataSource.getConnection();
            tl.set(conn);
        }
        //4.返回当前线程上的连接
        return conn;
    }catch (Exception e){
        throw new RuntimeException(e);
    }
}

/**
 * 把连接和线程解绑
 */
public void removeConnection(){
    tl.remove();
}

}

TransactionManager.java

package com.itheima.utils;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**

  • 和事务管理相关的工具类,它包含了,开启事务,提交事务,回滚事务和释放连接

*/
@Component("txManager")
@Aspect
public class TransactionManager {

@Autowired
private ConnectionUtils connectionUtils;

@Pointcut("execution(* com.itheima.service.impl.*.*(..))")
private void pt1(){}


/**
 * 开启事务
 */
@Before("pt1()")
public  void beginTransaction(){
    try {
        connectionUtils.getThreadConnection().setAutoCommit(false);
    }catch (Exception e){
        e.printStackTrace();
    }
}

/**
 * 提交事务
 */
@AfterReturning("pt1()")
public  void commit(){
    try {
        connectionUtils.getThreadConnection().commit();
    }catch (Exception e){
        e.printStackTrace();
    }
}

/**
 * 回滚事务
 */
@AfterThrowing("pt1()")
public  void rollback(){
    try {
        connectionUtils.getThreadConnection().rollback();
    }catch (Exception e){
        e.printStackTrace();
    }
}


/**
 * 释放连接
 */
@After("pt1()")
public  void release(){
    try {
        connectionUtils.getThreadConnection().close();//还回连接池中
        connectionUtils.removeConnection();
    }catch (Exception e){
        e.printStackTrace();
    }
}

}

AccountServiceTest.java

package com.itheima.test;

import com.itheima.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;

/**

  • 使用Junit单元测试:测试我们的配置

*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {

@Autowired
private  IAccountService as;

@Test
public  void testTransfer(){
    as.transfer("aaa","bbb",100f);
}

}

3 作业-基于注解的AOP实现事务控制及问题分析_下

改成环绕通知
package com.itheima.utils;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**

  • 和事务管理相关的工具类,它包含了,开启事务,提交事务,回滚事务和释放连接

*/
@Component("txManager")
@Aspect
public class TransactionManager {

@Autowired
private ConnectionUtils connectionUtils;

@Pointcut("execution(* com.itheima.service.impl.*.*(..))")
private void pt1(){}


/**
 * 开启事务
 */
public  void beginTransaction(){
    try {
        connectionUtils.getThreadConnection().setAutoCommit(false);
    }catch (Exception e){
        e.printStackTrace();
    }
}

/**
 * 提交事务
 */
public  void commit(){
    try {
        connectionUtils.getThreadConnection().commit();
    }catch (Exception e){
        e.printStackTrace();
    }
}

/**
 * 回滚事务
 */
public  void rollback(){
    try {
        connectionUtils.getThreadConnection().rollback();
    }catch (Exception e){
        e.printStackTrace();
    }
}


/**
 * 释放连接
 */
public  void release(){
    try {
        connectionUtils.getThreadConnection().close();//还回连接池中
        connectionUtils.removeConnection();
    }catch (Exception e){
        e.printStackTrace();
    }
}

@Around("pt1()")
public Object aroundAdvice(ProceedingJoinPoint pjp){
    Object rtValue = null;
    try {
        //1.获取参数
        Object[] args = pjp.getArgs();
        //2.开启事务
        this.beginTransaction();
        //3.执行方法
        rtValue = pjp.proceed(args);
        //4.提交事务
        this.commit();

        //返回结果
        return  rtValue;

    }catch (Throwable e){ //Exception是无法控制的
        //5.回滚事务
        this.rollback();
        throw new RuntimeException(e);
    }finally {
        //6.释放资源
        this.release();
    }
}

}
因为那四个通知的顺序有问题
注解AOP控制事务的问题分析.png

4 spring中事务控制的一组API

5 spring事务控制的代码准备

image.png

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.itheima</groupId>
<artifactId>day04_eesy_04tx</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-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>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.7</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

</project>

bean.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"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">

<!-- 配置业务层-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
    <property name="accountDao" ref="accountDao"></property>
</bean>

<!-- 配置账户的持久层-->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
    <property name="dataSource" ref="dataSource"></property>
</bean>


<!-- 配置数据源-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
    <property name="username" value="root"></property>
    <property name="password" value="1234"></property>
</bean>

</beans>

Account.java

package com.itheima.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 +
            '}';
}

}

IAccountDao.java

package com.itheima.dao;

import com.itheima.domain.Account;

/**

  • 账户的持久层接口

*/
public interface IAccountDao {

/**
 * 根据Id查询账户
 * @param accountId
 * @return
 */
Account findAccountById(Integer accountId);

/**
 * 根据名称查询账户
 * @param accountName
 * @return
 */
Account findAccountByName(String accountName);

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

}

AccountDaoImpl.java

package com.itheima.dao.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import java.util.List;

/**

  • 账户的持久层实现类

*/
public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {

@Override
public Account findAccountById(Integer accountId) {
    List<Account> accounts = super.getJdbcTemplate().query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
    return accounts.isEmpty()?null:accounts.get(0);
}

@Override
public Account findAccountByName(String accountName) {
    List<Account> accounts = super.getJdbcTemplate().query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
    if(accounts.isEmpty()){
        return null;
    }
    if(accounts.size()>1){
        throw new RuntimeException("结果集不唯一");
    }
    return accounts.get(0);
}

@Override
public void updateAccount(Account account) {
    super.getJdbcTemplate().update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
}

}

IAccountService.java

package com.itheima.service;

import com.itheima.domain.Account;

/**

  • 账户的业务层接口

*/
public interface IAccountService {

/**
 * 根据id查询账户信息
 * @param accountId
 * @return
 */
Account findAccountById(Integer accountId);

/**
 * 转账
 * @param sourceName    转成账户名称
 * @param targetName    转入账户名称
 * @param money         转账金额
 */
void transfer(String sourceName,String targetName,Float money);

}

AccountServiceImpl.java

package com.itheima.service.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.service.IAccountService;

/**

  • 账户的业务层实现类

*

  • 事务控制应该都是在业务层

*/
public class AccountServiceImpl implements IAccountService{

private IAccountDao accountDao;

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

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

}



@Override
public void transfer(String sourceName, String targetName, Float money) {
    System.out.println("transfer....");
        //2.1根据名称查询转出账户
        Account source = accountDao.findAccountByName(sourceName);
        //2.2根据名称查询转入账户
        Account target = accountDao.findAccountByName(targetName);
        //2.3转出账户减钱
        source.setMoney(source.getMoney()-money);
        //2.4转入账户加钱
        target.setMoney(target.getMoney()+money);
        //2.5更新转出账户
        accountDao.updateAccount(source);

        int i=1/0;

        //2.6更新转入账户
        accountDao.updateAccount(target);
}

}

6 spring基于XML的声明式事务控制-配置步骤

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.itheima</groupId>
<artifactId>day04_eesy_05tx_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-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>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.7</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

</project>

bean.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:aop="http://www.springframework.org/schema/aop"
   xmlns:tx="http://www.springframework.org/schema/tx"
   xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd">

<!-- 配置业务层-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
    <property name="accountDao" ref="accountDao"></property>
</bean>

<!-- 配置账户的持久层-->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
    <property name="dataSource" ref="dataSource"></property>
</bean>


<!-- 配置数据源-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
    <property name="username" value="root"></property>
    <property name="password" value="1234"></property>
</bean>

<!-- spring中基于XML的声明式事务控制配置步骤
    1、配置事务管理器
    2、配置事务的通知
            此时我们需要导入事务的约束 tx名称空间和约束,同时也需要aop的
            使用tx:advice标签配置事务通知
                属性:
                    id:给事务通知起一个唯一标识
                    transaction-manager:给事务通知提供一个事务管理器引用
    3、配置AOP中的通用切入点表达式
    4、建立事务通知和切入点表达式的对应关系
    5、配置事务的属性
           是在事务的通知tx:advice标签的内部

 -->
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>

<!-- 配置事务的通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!-- 配置事务的属性
            isolation:用于指定事务的隔离级别。默认值是DEFAULT,表示使用数据库的默认隔离级别。
            propagation:用于指定事务的传播行为。默认值是REQUIRED,表示一定会有事务,增删改的选择。查询方法可以选择SUPPORTS。
            read-only:用于指定事务是否只读。只有查询方法才能设置为true。默认值是false,表示读写。
            timeout:用于指定事务的超时时间,默认值是-1,表示永不超时。如果指定了数值,以秒为单位。
            rollback-for:用于指定一个异常,当产生该异常时,事务回滚,产生其他异常时,事务不回滚。没有默认值。表示任何异常都回滚。
            no-rollback-for:用于指定一个异常,当产生该异常时,事务不回滚,产生其他异常时事务回滚。没有默认值。表示任何异常都回滚。
    -->
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED" read-only="false"/>
        <tx:method name="find*" propagation="SUPPORTS" read-only="true"></tx:method>
    </tx:attributes>
</tx:advice>

<!-- 配置aop-->
<aop:config>
    <!-- 配置切入点表达式-->
    <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>
    <!--建立切入点表达式和事务通知的对应关系 -->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
</aop:config>

</beans>

Account.java

package com.itheima.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 +
            '}';
}

}

IAccountDao.java

package com.itheima.dao;

import com.itheima.domain.Account;

/**

  • 账户的持久层接口

*/
public interface IAccountDao {

/**
 * 根据Id查询账户
 * @param accountId
 * @return
 */
Account findAccountById(Integer accountId);

/**
 * 根据名称查询账户
 * @param accountName
 * @return
 */
Account findAccountByName(String accountName);

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

}

AccountDaoImpl.java

package com.itheima.dao.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import java.util.List;

/**

  • 账户的持久层实现类

*/
public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {

@Override
public Account findAccountById(Integer accountId) {
    List<Account> accounts = super.getJdbcTemplate().query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
    return accounts.isEmpty()?null:accounts.get(0);
}

@Override
public Account findAccountByName(String accountName) {
    List<Account> accounts = super.getJdbcTemplate().query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
    if(accounts.isEmpty()){
        return null;
    }
    if(accounts.size()>1){
        throw new RuntimeException("结果集不唯一");
    }
    return accounts.get(0);
}

@Override
public void updateAccount(Account account) {
    super.getJdbcTemplate().update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
}

}

IAccountService.java

package com.itheima.service;

import com.itheima.domain.Account;

/**

  • 账户的业务层接口

*/
public interface IAccountService {

/**
 * 根据id查询账户信息
 * @param accountId
 * @return
 */
Account findAccountById(Integer accountId);

/**
 * 转账
 * @param sourceName    转成账户名称
 * @param targetName    转入账户名称
 * @param money         转账金额
 */
void transfer(String sourceName,String targetName,Float money);

}

AccountServiceImpl.java

package com.itheima.service.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.service.IAccountService;

/**

  • 账户的业务层实现类

*

  • 事务控制应该都是在业务层

*/
public class AccountServiceImpl implements IAccountService{

private IAccountDao accountDao;

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

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

}



@Override
public void transfer(String sourceName, String targetName, Float money) {
    System.out.println("transfer....");
        //2.1根据名称查询转出账户
        Account source = accountDao.findAccountByName(sourceName);
        //2.2根据名称查询转入账户
        Account target = accountDao.findAccountByName(targetName);
        //2.3转出账户减钱
        source.setMoney(source.getMoney()-money);
        //2.4转入账户加钱
        target.setMoney(target.getMoney()+money);
        //2.5更新转出账户
        accountDao.updateAccount(source);

        int i=1/0;

        //2.6更新转入账户
        accountDao.updateAccount(target);
}

}

AccountServiceTest.java

package com.itheima.test;

import com.itheima.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;

/**

  • 使用Junit单元测试:测试我们的配置

*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {

@Autowired
private  IAccountService as;

@Test
public  void testTransfer(){
    as.transfer("aaa","bbb",100f);

}

}

7 spring基于注解的声明式事务控制

image.png

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.itheima</groupId>
<artifactId>day04_eesy_06tx_anno</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-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>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.7</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

</project>

bean.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:aop="http://www.springframework.org/schema/aop"
   xmlns:tx="http://www.springframework.org/schema/tx"
   xmlns:context="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/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">

<!-- 配置spring创建容器时要扫描的包-->
<context:component-scan base-package="com.itheima"></context:component-scan>

<!-- 配置JdbcTemplate-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"></property>
</bean>



<!-- 配置数据源-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
    <property name="username" value="root"></property>
    <property name="password" value="1234"></property>
</bean>

<!-- spring中基于注解 的声明式事务控制配置步骤
    1、配置事务管理器
    2、开启spring对注解事务的支持
    3、在需要事务支持的地方使用@Transactional注解


 -->
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>



<!-- 开启spring对注解事务的支持-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

</beans>

AccountServiceTest.java

package com.itheima.test;

import com.itheima.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;

/**

  • 使用Junit单元测试:测试我们的配置

*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {

@Autowired
private  IAccountService as;

@Test
public  void testTransfer(){
    as.transfer("aaa","bbb",100f);

}

}

Account.java

package com.itheima.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 +
            '}';
}

}

IAccountDao.java

package com.itheima.dao;

import com.itheima.domain.Account;

/**

  • 账户的持久层接口

*/
public interface IAccountDao {

/**
 * 根据Id查询账户
 * @param accountId
 * @return
 */
Account findAccountById(Integer accountId);

/**
 * 根据名称查询账户
 * @param accountName
 * @return
 */
Account findAccountByName(String accountName);

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

}

AccountDaoImpl.java

package com.itheima.dao.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

/**

  • 账户的持久层实现类

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

@Autowired
private JdbcTemplate jdbcTemplate;

@Override
public Account findAccountById(Integer accountId) {
    List<Account> accounts = jdbcTemplate.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
    return accounts.isEmpty()?null:accounts.get(0);
}

@Override
public Account findAccountByName(String accountName) {
    List<Account> accounts = jdbcTemplate.query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
    if(accounts.isEmpty()){
        return null;
    }
    if(accounts.size()>1){
        throw new RuntimeException("结果集不唯一");
    }
    return accounts.get(0);
}

@Override
public void updateAccount(Account account) {
    jdbcTemplate.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
}

}

IAccountService.java

package com.itheima.service;

import com.itheima.domain.Account;

/**

  • 账户的业务层接口

*/
public interface IAccountService {

/**
 * 根据id查询账户信息
 * @param accountId
 * @return
 */
Account findAccountById(Integer accountId);

/**
 * 转账
 * @param sourceName    转成账户名称
 * @param targetName    转入账户名称
 * @param money         转账金额
 */
void transfer(String sourceName,String targetName,Float money);

}

AccountServiceImpl.java

package com.itheima.service.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/**

  • 账户的业务层实现类

*

  • 事务控制应该都是在业务层

*/
@Service("accountService")
@Transactional(propagation= Propagation.SUPPORTS,readOnly=true)//只读型事务的配置
public class AccountServiceImpl implements IAccountService{

@Autowired
private IAccountDao accountDao;


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

}


//需要的是读写型事务配置
@Transactional(propagation= Propagation.REQUIRED,readOnly=false)
@Override
public void transfer(String sourceName, String targetName, Float money) {
    System.out.println("transfer....");
        //2.1根据名称查询转出账户
        Account source = accountDao.findAccountByName(sourceName);
        //2.2根据名称查询转入账户
        Account target = accountDao.findAccountByName(targetName);
        //2.3转出账户减钱
        source.setMoney(source.getMoney()-money);
        //2.4转入账户加钱
        target.setMoney(target.getMoney()+money);
        //2.5更新转出账户
        accountDao.updateAccount(source);

        int i=1/0;

        //2.6更新转入账户
        accountDao.updateAccount(target);
}

}

8 spring基于纯注解的声明式事务控制

image.png

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.itheima</groupId>
<artifactId>day04_eesy_07anno_tx_withoutxml</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-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>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.7</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

</project>

AccountServiceTest.java

package com.itheima.test;

import com.itheima.service.IAccountService;
import config.SpringConfiguration;
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;

/**

  • 使用Junit单元测试:测试我们的配置

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

@Autowired
private  IAccountService as;

@Test
public  void testTransfer(){
    as.transfer("aaa","bbb",100f);

}

}

JdbcConfig.java

package config;

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;

/**

  • 和连接数据库相关的配置类

*/
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;

/**
 * 创建JdbcTemplate
 * @param dataSource
 * @return
 */
@Bean(name="jdbcTemplate")
public JdbcTemplate createJdbcTemplate(DataSource dataSource){
    return new JdbcTemplate(dataSource);
}

/**
 * 创建数据源对象
 * @return
 */
@Bean(name="dataSource")
public DataSource createDataSource(){
    DriverManagerDataSource ds = new DriverManagerDataSource();
    ds.setDriverClassName(driver);
    ds.setUrl(url);
    ds.setUsername(username);
    ds.setPassword(password);
    return ds;
}

}

SpringConfiguration.java

package 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;
import org.springframework.transaction.annotation.EnableTransactionManagement;

/**

  • spring的配置类,相当于bean.xml

*/
@Configuration
@ComponentScan("com.itheima")
@Import({JdbcConfig.class,TransactionConfig.class})
@PropertySource("jdbcConfig.properties")
@EnableTransactionManagement
public class SpringConfiguration {
}

TransactionConfig.java

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

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

Account.java

package com.itheima.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 +
            '}';
}

}

IAccountDao.java

package com.itheima.dao;

import com.itheima.domain.Account;

/**

  • 账户的持久层接口

*/
public interface IAccountDao {

/**
 * 根据Id查询账户
 * @param accountId
 * @return
 */
Account findAccountById(Integer accountId);

/**
 * 根据名称查询账户
 * @param accountName
 * @return
 */
Account findAccountByName(String accountName);

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

}

AccountDaoImpl.java

package com.itheima.dao.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

/**

  • 账户的持久层实现类

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

@Autowired
private JdbcTemplate jdbcTemplate;

@Override
public Account findAccountById(Integer accountId) {
    List<Account> accounts = jdbcTemplate.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
    return accounts.isEmpty()?null:accounts.get(0);
}

@Override
public Account findAccountByName(String accountName) {
    List<Account> accounts = jdbcTemplate.query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
    if(accounts.isEmpty()){
        return null;
    }
    if(accounts.size()>1){
        throw new RuntimeException("结果集不唯一");
    }
    return accounts.get(0);
}

@Override
public void updateAccount(Account account) {
    jdbcTemplate.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
}

}

IAccountService.java

package com.itheima.service;

import com.itheima.domain.Account;

/**

  • 账户的业务层接口

*/
public interface IAccountService {

/**
 * 根据id查询账户信息
 * @param accountId
 * @return
 */
Account findAccountById(Integer accountId);

/**
 * 转账
 * @param sourceName    转成账户名称
 * @param targetName    转入账户名称
 * @param money         转账金额
 */
void transfer(String sourceName,String targetName,Float money);

}

AccountServiceImpl.java

package com.itheima.service.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/**

  • 账户的业务层实现类

*

  • 事务控制应该都是在业务层

*/
@Service("accountService")
@Transactional(propagation= Propagation.SUPPORTS,readOnly=true)//只读型事务的配置
public class AccountServiceImpl implements IAccountService{

@Autowired
private IAccountDao accountDao;


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

}


//需要的是读写型事务配置
@Transactional(propagation= Propagation.REQUIRED,readOnly=false)
@Override
public void transfer(String sourceName, String targetName, Float money) {
    System.out.println("transfer....");
        //2.1根据名称查询转出账户
        Account source = accountDao.findAccountByName(sourceName);
        //2.2根据名称查询转入账户
        Account target = accountDao.findAccountByName(targetName);
        //2.3转出账户减钱
        source.setMoney(source.getMoney()-money);
        //2.4转入账户加钱
        target.setMoney(target.getMoney()+money);
        //2.5更新转出账户
        accountDao.updateAccount(source);

// int i=1/0;

        //2.6更新转入账户
        accountDao.updateAccount(target);
}

}

9 spring编程式事务控制1-了解

10spring编程式事务控制2-了解

11 spring5新特性的介绍

评论

暂无评论