public interface TransactionDefinition {
　　 //事务传播行为类型：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。
    int PROPAGATION_REQUIRED = 0;
    //事务传播行为类型：支持当前事务，如果当前没有事务，就以非事务方式执行。 
    int PROPAGATION_SUPPORTS = 1;
    //事务传播行为类型：当前如果有事务，Spring就会使用该事务；否则会抛出异常
    int PROPAGATION_MANDATORY = 2;
    //事务传播行为类型：新建事务，如果当前存在事务，把当前事务挂起。 
    int PROPAGATION_REQUIRES_NEW = 3;
    //事务传播行为类型：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 
    int PROPAGATION_NOT_SUPPORTED = 4;
    //事务传播行为类型：即使当前有事务，Spring也会在非事务环境下执行。如果当前有事务，则抛出异常
    int PROPAGATION_NEVER = 5;
    //事务传播行为类型：如果当前存在事务，则在嵌套事务内执行。
    int PROPAGATION_NESTED = 6;

　　 //隔离级别：默认的隔离级别（对mysql数据库来说就是ISOLATION_ READ_COMMITTED，可以重复读）
    int ISOLATION_DEFAULT = -1;
    //隔离级别：读未提交(最低)
    int ISOLATION_READ_UNCOMMITTED = Connection.TRANSACTION_READ_UNCOMMITTED;
    //隔离级别：读提交
    int ISOLATION_READ_COMMITTED = Connection.TRANSACTION_READ_COMMITTED;
    //隔离级别：可重复度
    int ISOLATION_REPEATABLE_READ = Connection.TRANSACTION_REPEATABLE_READ;
    //隔离级别：序列化操作（最高）
    int ISOLATION_SERIALIZABLE = Connection.TRANSACTION_SERIALIZABLE;

    //默认事务的超时时间
    int TIMEOUT_DEFAULT = -1;

    //获取事务的传播行为
    int getPropagationBehavior();
    //获取事务的隔离级别
    int getIsolationLevel();
    //获取超时时间
    int getTimeout();
    
    //是否只读
    boolean isReadOnly();
    //事务名称
    String getName();
}

public class Student {
    private int sid;            //主键id
    private String sname;       //姓名
    private String ssex;        //性别
    private int sage;           //年龄
    private double scredit;     //学分
    private double smoney;      //零花钱
    private String saddress;    //住址
    private String senrol;      //入学时间
    //因为简单的单表CRUD就不涉及到外键
    //private int fid;            //外键 连接家庭表信息学生对家庭，一对一
    //private int tid;            //外键 连接老师信息 学生对老师，一对一
    //创建构造器/get/set/toString就不展示了
}

    <dependencies>
        <!--Spring核心包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--Spring的操作数据库坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--Spring的事务-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--用于解析切面表达式坐标   只有用到AOP切面就必须导入-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
        <!--Spring测试坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--Mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.32</version>
        </dependency>
        <!--测试包-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

#####StudentDao接口

/**
 * Student接口数据操作
 * @author ant
 */
public interface StudentDao {
    //根据姓名查询
    Student findByName(String name);
    //更新学生
   void update(Student student);
}

+++++++++++++++++++++++++++++++++++++++++

#####StudentDaoImpl实现类
/**
 * Student数据操作实现类
 * @author ant
 */
public class StudentDaoImpl extends JdbcDaoSupport implements StudentDao {
    //根据姓名查询学生
    public Student findByName(String name) {
        List<Student> students = getJdbcTemplate().query("select * from student where sname=?",new BeanPropertyRowMapper<Student>(Student.class) , name);
        if (students == null || students.size() < 0) {
            return null;
        }
        return students.get(0);
    }
    //更新学生零花钱Money
    public void update(Student student) {
        String sql = "update student set smoney=? where sid=?";
        int isNo = getJdbcTemplate().update(sql, student.getSmoney(), student.getSid());
    }
}

#####StudentService接口
/**
 * Student业务处理接口
 * @author ant
 */
public interface StudentService {
    //转账
    void transfer(String currentName,String targetName,double money);
}

++++++++++++++++++++++++++++++++++++++++++

#####StudentServiceImpl实现类

/**
 * Student业务处理实现类
 * @author ant
 */
public class StudentServiceImpl implements StudentService {
    //聚合StudentDao 通过后面set后期注入
    private StudentDao studentDao;
    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
    }

    //转账
    public void transfer(String currentName, String targetName, double money) {
        
        /*为了演示 我就不做那么细致的数据判断等等操作*/
        //①：查询学生
        Student currentStudent = studentDao.findByName(currentName);
        Student targetStudent = studentDao.findByName(targetName);
        //打印最初结果
        System.out.println("转账前： 当前学生姓名和余额：" + currentStudent.getSname() + "  " + currentStudent.getSmoney());
        System.out.println("转账前： 目标学生姓名和余额：" + targetStudent.getSname() + "  " + targetStudent.getSmoney());
        //②：开始转账
        currentStudent.setSmoney(currentStudent.getSmoney() - money);
        targetStudent.setSmoney(targetStudent.getSmoney() + money);

        //③：调用更新
        studentDao.update(currentStudent);
//        int a=1/0;
        studentDao.update(targetStudent);

        //打印最终结果
        Student currentStudentEnd = studentDao.findByName(currentName);
        Student targetStudentEnd = studentDao.findByName(targetName);
        System.out.println("转账后： 当前学生姓名和余额：" + currentStudentEnd.getSname() + "  " + currentStudentEnd.getSmoney());
        System.out.println("转账后： 目标学生姓名和余额：" + targetStudentEnd.getSname() + "  " + targetStudentEnd.getSmoney());
    }
}

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--开启注解扫描-->
    <context:component-scan base-package="cn.xw"></context:component-scan>
    <!--DriverManagerDataSource放入容器-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///demo_school"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123"></property>
    </bean>
    <!--JdbcTemplate放入容器-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--StudentDao放入容器-->
    <bean id="studentDao" class="cn.xw.dao.impl.StudentDaoImpl">
       <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
    <!--StudentService放入容器-->
    <bean id="studentService" class="cn.xw.service.impl.StudentServiceImpl">
        <property name="studentDao" ref="studentDao"></property>
    </bean>
</beans>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class Client {
    @Autowired
    @Qualifier(value="studentService")
    private StudentService ss;

    @Test
    public void transfer() {
        ss.transfer("王生安","李鑫灏",10);
    }
}

public class Student {
    private int sid;            //主键id
    private String sname;       //姓名
    private String ssex;        //性别
    private int sage;           //年龄
    private double scredit;     //学分
    private double smoney;      //零花钱
    private String saddress;    //住址
    private String senrol;      //入学时间
    //因为简单的单表CRUD就不涉及到外键
    //private int fid;            //外键 连接家庭表信息学生对家庭，一对一
    //private int tid;            //外键 连接老师信息 学生对老师，一对一
    //创建构造器/get/set/toString就不展示了
}

#####StudentDao接口

/**
 * 学生数据操作Dao接口
 * @author ant
 */
public interface StudentDao {
    //根据姓名查询
    Student findByName(String name);
    //修改金额
    void update(Student student);
}

+++++++++++++++++++++++++++++++++++++++++
#####StudentDaoImpl实现类
/**
 * 学生数据操作Dao实现类
 * @author ant
 */
@Repository("studentDao")
public class StudentDaoImpl implements StudentDao {
    @Autowired
    @Qualifier("jdbcTemplate")
    private JdbcTemplate jdbcTemplate;
    //根据姓名查询学生
    public Student findByName(String name) {
        String sql="select * from student where sname=?";
        Student student = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Student>(Student.class), name);
        return student;
    }
    //更改money金额
    public void update(Student student) {
        String sql="update student set smoney=? where sid=?";
        jdbcTemplate.update(sql,student.getSmoney(),student.getSid());
    }
}

#####StudentService接口
/**
 * 学生业务层Service 接口
 * @author ant
 */
public interface StudentService {
    //转账
    void transfer(String currentName, String targetName, double money);
}

++++++++++++++++++++++++++++++++++++++++++

#####StudentServiceImpl接口实现类

/**
 * 业务接口实现类 学生ServiceStudent
 * @author ant
 */
@Service("studentService")
@Transactional(readOnly = true,propagation = Propagation.SUPPORTS)
public class StudentServiceImpl implements StudentService {

    @Autowired
    @Qualifier("studentDao")
    private StudentDao studentDao;
    @Transactional(readOnly = false,propagation = Propagation.REQUIRED)
    public void transfer(String currentName, String targetName, double money) {
        /*为了演示 我就不做那么细致的数据判断等等操作*/
        //①：查询学生
        Student currentStudent = studentDao.findByName(currentName);
        Student targetStudent = studentDao.findByName(targetName);
        //打印最初结果
        System.out.println("转账前： 当前学生姓名和余额：" + currentStudent.getSname() + "  " + currentStudent.getSmoney());
        System.out.println("转账前： 目标学生姓名和余额：" + targetStudent.getSname() + "  " + targetStudent.getSmoney());
        //②：开始转账
        currentStudent.setSmoney(currentStudent.getSmoney() - money);
        targetStudent.setSmoney(targetStudent.getSmoney() + money);
        //③：调用更新
        studentDao.update(currentStudent);
        studentDao.update(targetStudent);
        //打印最终结果
        Student currentStudentEnd = studentDao.findByName(currentName);
        Student targetStudentEnd = studentDao.findByName(targetName);
        System.out.println("转账后： 当前学生姓名和余额：" + currentStudentEnd.getSname() + "  " + currentStudentEnd.getSmoney());
        System.out.println("转账后： 目标学生姓名和余额：" + targetStudentEnd.getSname() + "  " + targetStudentEnd.getSmoney());
    }
}

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/demo_school
jdbc.user=root
jdbc.password=123

/**
 * 本类为了使操作方法的时候打印日志准备，在这里我使用了环绕通知，因为注解使用环绕通知可以避免顺序问题
 */
@Component("springAopLog")
@Aspect     //设置这个类为通知类
public class SpringAopLog {

    @Pointcut(value = "execution(* cn.xw.service.impl.*.*(..))")
    public void pointcut() {
    }
    //@Before("pointcut()")
    public void beforeLog() {
        System.out.println(Thread.currentThread().getName() + " log:方法执行开始");
    }

    //@AfterReturning("pointcut()")
    public void afterReturnLog() {
        System.out.println(Thread.currentThread().getName() + " log:方法执行成功");
    }

    //@AfterThrowing("pointcut()")
    public void afterThrowingLog() {
        System.out.println(Thread.currentThread().getName() + " log:方法执行异常");
    }

    //@After("pointcut()")
    public void afterLog() {
        System.out.println(Thread.currentThread().getName() + " log:完成方法操作");
    }

    @Around("pointcut()")
    public Object aroundPrint(ProceedingJoinPoint pp) {
        Object obj = null;
        try {
            beforeLog();
            Object[] args = pp.getArgs();
            obj = pp.proceed(args);
            afterReturnLog();
        } catch (Throwable e) {
            afterThrowingLog();
            throw new RuntimeException("运行错误");
        } finally {
            afterLog();
        }
        return obj;
    }
}

/**
 * 该类用于获取数据库连接的数据源
 */
@PropertySource(value ="classpath:db.properties" )
public class SpringDataSource {

    @Value(value = "${jdbc.driver}")
    private String driver;
    @Value(value = "${jdbc.url}")
    private String url;
    @Value(value = "${jdbc.user}")
    private String user;
    @Value(value = "${jdbc.password}")
    private String password;

    /**
     * 在容器中创建了一个 DriverManagerDataSource的数据源
     * @return
     */
    @Bean(value="dataSource")
    public DataSource createDataSource(){
        DriverManagerDataSource dataSource=new DriverManagerDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(user);
        dataSource.setPassword(password);
        return dataSource;
    }
}

/**
 * 主配置文件
 */
@Configuration
@ComponentScan(basePackages = {"cn.xw"})
@Import(value = {SpringDataSource.class})
@EnableTransactionManagement //开启注解事务支持
@EnableAspectJAutoProxy //开启切面通知支持
public class SpringConfig {

    /**
     * 把JdbcTemplate放入容器
     * @param dataSource
     * @return
     */
    @Bean("jdbcTemplate")
    public JdbcTemplate createJdbcTemplate(@Qualifier(value="dataSource") DataSource dataSource){
        return new JdbcTemplate(dataSource);
    }

    /**
     * 配置事务管理器
     * @param dataSource
     * @return
     */
    @Bean("transactionManager")
    public DataSourceTransactionManager createTransactionManager(@Qualifier("dataSource") DataSource dataSource){
        DataSourceTransactionManager transactionManager=new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class Client {
    @Autowired
    @Qualifier("studentService")
    private StudentService ss;
    @Test
    public void transfer(){
        ss.transfer("王生安","李鑫灏",10);
    }
}