银行转账案例

最新推荐文章于 2023-02-01 20:23:50 发布
最新推荐文章于 2023-02-01 20:23:50 发布
阅读量1.2k 收藏 8
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40055163/article/details/108538372
版权

银行转账案例

1 案例中添加转账方法并演示事务问题
1.打开IDEA工具如图所示的界面，点击Create New Project。在这里插入图片描述
2.选择Maven工程和JDK的版本，如图所示：并点击Next。在这里插入图片描述
3.填写项目名称和保存的地址，点击Finish。如图所示：在这里插入图片描述
4.导入相应的依赖jar包的代码如下：

<?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.txw</groupId>
    <artifactId>spring_01account</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--打包的方式 -->
    <packaging>jar</packaging>
    <dependencies>
        <!--导入spring-context的依赖jar包坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <!--导入lombok的依赖jar包坐标-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
        <!--导入mysql的依赖jar包坐标-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>6.0.6</version>
        </dependency>
        <!--导入commons-dbutils的依赖jar包坐标-->
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.7</version>
        </dependency>
        <!--导入spring-test的依赖jar包坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <!--导入c3p0的依赖jar包坐标-->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <!--导入junit的依赖jar包坐标-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>
        <!--导入junit的依赖jar包坐标-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>
</project>

5.编写账户实体类的代码如下：

package com.txw.domain;

import lombok.Data;
import lombok.ToString;
import java.io.Serializable;
/**
 * 账户的实体类
 * @author:Adair
 * @QQ:1578533828
 */
@Data     // 自动生成set和get方法
@ToString // 重写toString方法
@SuppressWarnings("all")      // 注解警告信息
public class Account implements Serializable {
    private Integer id;      // 账户的id
    private String name;     // 账户的名称
    private Float money;     // 账户的金额
}

6.编写账户的业务层接口代码如下：

package com.txw.service;

import com.txw.domain.Account;
import java.util.List;
/**
 *账户的业务层接口
 * @author:Adair
 * @QQ:1578533828
 */
@SuppressWarnings("all")      // 注解警告信息
public interface AccountService {
    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();
    /**
     * 根据id查询一个
     * @return
     */
    Account findAccountById(Integer accountId);
    /**
     * 保存账户
     * @param account
     */
    void saveAccount(Account account);
    /**
     * 更新账户
     * @param account
     */
    void updateAccount(Account account);
    /**
     * 根据id删除
     * @param acccountId
     */
    void deleteAccount(Integer accountId);
    /**
     * 转账
     * @param sourceName        转出账户名称
     * @param targetName        转入账户名称
     * @param money             转账金额
     */
    void transfer(String sourceName,String targetName,Float money);
}

7.编写账户的业务层实现类代码如下：

package com.txw.service.impl;

import com.txw.dao.AccountDao;
import com.txw.domain.Account;
import com.txw.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
 * 账户的业务层实现类
 * @author:Adair
 * @QQ:1578533828
 */
@Service("accountService")
@SuppressWarnings("all")      // 注解警告信息
public class AccountServiceImpl implements AccountService {
    // 声明AccountDao业务对象
    @Autowired
    private AccountDao accountDao;
    /**
     * 查询所有
     * @return
     */
    public List<Account> findAllAccount() {
        return accountDao.findAllAccount();
    }
    /**
     * 根据id查询一个
     * @return
     */
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }
    /**
     * 保存账户
     * @param account
     */
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }
    /**
     * 修改账户
     * @param account
     */
    public void updateAccount(Account account) {
    accountDao.updateAccount(account);
    }
    /**
     * 根据id删除
     * @param acccountId
     */
    public void deleteAccount(Integer accountId) {
        accountDao.deleteAccount(accountId);
    }

    /**
     * 转账
     * @param sourceName        转出账户名称
     * @param targetName        转入账户名称
     * @param money             转账金额
     */
    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.编写账户的持久层接口代码如下：

package com.txw.dao;

import com.txw.domain.Account;
import java.util.List;
/**
 * 账户的持久层接口
 * @author:Adair
 * @QQ:1578533828
 */
@SuppressWarnings("all")      // 注解警告信息
public interface AccountDao {
    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();
    /**
     * 根据id查询一个
     * @return
     */
    Account findAccountById(Integer accountId);
    /**
     * 保存账户
     * @param account
     */
    void saveAccount(Account account);
    /**
     * 更新账户
     * @param account
     */
    void updateAccount(Account account);
    /**
     * 根据id删除
     * @param acccountId
     */
    void deleteAccount(Integer accountId);
    /**
     * 根据名称查询账户
     * @param accountName
     * @return  如果有唯一的一个结果就返回，如果没有结果就返回null
     *          如果结果集超过一个就抛异常
     */
    Account findAccountByName(String accountName);
}

9.编写账户的持久层实现类代码如下：

package com.txw.dao.impl;

import com.txw.dao.AccountDao;
import com.txw.domain.Account;
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;
/**
 * 账户的持久层实现类
 * @author:Adair
 * @QQ:1578533828
 */
@Repository("accountDao")
@SuppressWarnings("all")      // 注解警告信息
public class AccountDaoImpl implements AccountDao {
    // 声明QueryRunner业务对象
    @Autowired
    private QueryRunner runner;
    /**
     * 查询所有
     * @return
     */
    public List<Account> findAllAccount() {
        try{
            return runner.query("select * from account",new BeanListHandler<Account>(Account.class));
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 根据id查询一个
     * @return
     */
    public Account findAccountById(Integer accountId) {
        try{
            return runner.query("select * from account where id = ? ",new BeanHandler<Account>(Account.class),accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 保存账户
     * @param account
     */
    public void saveAccount(Account account) {
        try{
            runner.update("insert into account(name,money)values(?,?)",account.getName(),account.getMoney());
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 修改账户
     * @param account
     */
    public void updateAccount(Account account) {
        try{
            runner.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 根据id删除
     * @param accountId
     */
    public void deleteAccount(Integer accountId) {
        try{
            runner.update("delete from account where id=?",accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 根据名称查询账户
     * @param accountName
     * @return
     */
    public Account findAccountByName(String accountName) {
        try{
            List<Account> accounts = runner.query("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);
        }
    }
}

10.在resources目录下创建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: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/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 告知spring在创建容器时要扫描的包 -->
    <context:component-scan base-package="com.txw"></context:component-scan>
    <!--配置QueryRunner-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!--注入数据源-->
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </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/spring?useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=UTC&amp;useSSL=false"/>
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
</beans

11.编写测试的代码如下：

package com.txw.test;

import com.txw.service.AccountService;
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单元测试：测试我们的配置
 * @author:Adair
 * @QQ:1578533828
 */
@SuppressWarnings("all")      // 注解警告信息
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {
    // 声明AccountService业务对象
    @Autowired
    private AccountService as;
    @Test
    public  void testTransfer(){
        as.transfer("aaa","bbb",100f);
    }
}

运行之前的数据库的数据如图所示：
在这里插入图片描述
运行结果如图所示：在这里插入图片描述
运行之后的数据库的数据如图所示：说明转账成功！在这里插入图片描述
如图所示，手动制造异常！在这里插入图片描述
运行结果如图所示：在这里插入图片描述
运行之后的数据库的数据如图所示：说明转账失败！不满足事务的一致性。在这里插入图片描述
2 分析事务的问题并编写ConnectionUtils
1.事务控制，如图所示：在这里插入图片描述
2.编写连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定代码如下：

package com.txw.utils;

import javax.sql.DataSource;
import java.sql.Connection;
/**
 * 连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定
 * @author:Adair
 * @QQ:1578533828
 */
@SuppressWarnings("all")      // 注解警告信息
public class ConnectionUtils {
    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    private DataSource dataSource;
    public void setDataSource(DataSource dataSource) {
        this.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();
    }
}

3 编写事务管理工具类并分析连接和线程解
1.编写和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接的代码如下：

package com.txw.utils;

/**
 * 和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接
 * @author:Adair
 * @QQ:1578533828
 */
@SuppressWarnings("all")      // 注解警告信息
public class TransactionManager {
    private ConnectionUtils connectionUtils;
    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }
    /**
     * 开启事务
     */
    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();
        }
    }
}

4 编写业务层和持久层事务控制代码并配置spring的ioc
1.修改业务层实现类的代码如下：

package com.txw.service.impl;

import com.txw.dao.AccountDao;
import com.txw.domain.Account;
import com.txw.service.AccountService;
import com.txw.utils.TransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
 * 账户的业务层实现类
 * 事务控制应该都是在业务层
 * @author:Adair
 * @QQ:1578533828
 */
@Service("accountService")
@SuppressWarnings("all")      // 注解警告信息
public class AccountServiceImpl implements AccountService {
    // 声明AccountDao业务对象
    @Autowired
    private AccountDao accountDao;
    @Autowired
    private TransactionManager transactionManager;
    /**
     * 查询所有
     * @return
     */
    public List<Account> findAllAccount() {
        try {
            // 1.开启事务
            transactionManager.beginTransaction();
            // 2.执行操作
            List<Account> accounts = accountDao.findAllAccount();
            // 3.提交事务
            transactionManager.commit();
            //4.返回结果
            return accounts;
        } catch (Exception e) {
            // 5.回滚操作
            transactionManager.rollback();
            throw new RuntimeException(e);
        } finally {
            // 6.释放连接
            transactionManager.release();
        }
    }
    /**
     * 根据id查询一个
     * @return
     */
    public Account findAccountById(Integer accountId) {
        try {
            // 1.开启事务
            transactionManager.beginTransaction();
            // 2.执行操作
            Account account = accountDao.findAccountById(accountId);
            // 3.提交事务
            transactionManager.commit();
            return account;
        }catch (Exception e){
            // 4.回滚操作
            transactionManager.rollback();
            throw new RuntimeException(e);
        }finally {
            // 5.释放连接
            transactionManager.release();
        }
    }
    /**
     * 保存账户
     * @param account
     */
    public void saveAccount(Account account) {
        try {
            // 1.开启事务
            transactionManager.beginTransaction();
            // 2.执行操作
            accountDao.saveAccount(account);
            // 3.提交事务
            transactionManager.commit();
        }catch (Exception e){
            // 4.回滚操作
            transactionManager.rollback();
        }finally {
            // 5.释放连接
            transactionManager.release();
        }
        accountDao.saveAccount(account);
    }
    /**
     * 修改账户
     * @param account
     */
    public void updateAccount(Account account) {
        try {
            // 1.开启事务
            transactionManager.beginTransaction();
            // 2.执行操作
            accountDao.updateAccount(account);
            // 3.提交事务
            transactionManager.commit();
        }catch (Exception e){
            // 4.回滚操作
            transactionManager.rollback();
        }finally {
            // 5.释放连接
            transactionManager.release();
        }
    }
    /**
     * 根据id删除
     * @param acccountId
     */
    public void deleteAccount(Integer accountId) {
        try {
            // 1.开启事务
            transactionManager.beginTransaction();
            // 2.执行操作
            accountDao.deleteAccount(accountId);
            // 3.提交事务
            transactionManager.commit();
        }catch (Exception e){
            // 4.回滚操作
            transactionManager.rollback();
        }finally {
            // 5.释放连接
            transactionManager.release();
        }
    }
    /**
     * 转账
     * @param sourceName        转出账户名称
     * @param targetName        转入账户名称
     * @param money             转账金额
     */
    public void transfer(String sourceName, String targetName, Float money) {
        try {
            // 1.开启事务
            transactionManager.beginTransaction();
            // 2.执行操作
            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);
            // 3.提交事务
            transactionManager.commit();
        }catch (Exception e){
            // 4.回滚操作
            transactionManager.rollback();
        }finally {
            // 5.释放连接
            transactionManager.release();
        }
    }
}

2.修改账户持久层实现类的代码如下：

package com.txw.dao.impl;

import com.txw.dao.AccountDao;
import com.txw.domain.Account;
import com.txw.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;
/**
 * 账户的持久层实现类
 * @author:Adair
 * @QQ:1578533828
 */
@Repository("accountDao")
@SuppressWarnings("all")      // 注解警告信息
public class AccountDaoImpl implements AccountDao {
    // 声明QueryRunner业务对象
    @Autowired
    private QueryRunner runner;
    @Autowired
    private ConnectionUtils connectionUtils;
    /**
     * 查询所有
     * @return
     */
    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);
        }
    }
    /**
     * 根据id查询一个
     * @return
     */
    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);
        }
    }
    /**
     * 保存账户
     * @param account
     */
    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);
        }
    }
    /**
     * 修改账户
     * @param account
     */
    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);
        }
    }
    /**
     * 根据id删除
     * @param accountId
     */
    public void deleteAccount(Integer accountId) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"delete from account where id=?",accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 根据名称查询账户
     * @param accountName
     * @return
     */
    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);
        }
    }
}

3.修改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: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/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 告知spring在创建容器时要扫描的包 -->
    <context:component-scan base-package="com.txw"></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/spring?useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=UTC&amp;useSSL=false"/>
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
    <!-- 配置Connection的工具类 ConnectionUtils -->
    <bean id="connectionUtils" class="com.txw.utils.ConnectionUtils">
        <!-- 注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置事务管理器-->
    <bean id="txManager" class="com.txw.utils.TransactionManager">
        <!-- 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>
</beans>

运行之前的数据库的数据如图所示：
在这里插入图片描述
运行结果如图所示：在这里插入图片描述
运行之后的数据库的数据如图所示：说明事务已经控制住！在这里插入图片描述
5 代理分析
1.打开IDEA工具如图所示的界面，点击Create New Project。在这里插入图片描述
2.选择Maven工程和JDK的版本，如图所示：并点击Next。在这里插入图片描述
3.填写项目名称和保存的地址，点击Finish。如图所示：在这里插入图片描述
4.导入相应的依赖jar包的代码如下：

<?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.txw</groupId>
    <artifactId>spring_02proxy</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--打包的方式-->
    <packaging>jar</packaging>
    <dependencies>
        <!--导入cglib的依赖jar包坐标-->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.1_3</version>
        </dependency>
    </dependencies>
</project>

5.代理分析如图所示：在这里插入图片描述
6 基于接口的动态代理回顾
1.编写对生产厂家要求的接口代码如下：

package com.txw.proxy;

/**
 * 对生产厂家要求的接口
 */
@SuppressWarnings("all")      // 注解警告信息
public interface IProducer {
    /**
     * 销售
     * @param money
     */
    public void saleProduct(float money);
    /**
     * 售后
     * @param money
     */
    public void afterService(float money);
}

2.编写一个生产者的代码如下：

package com.txw.proxy;

/**
 * 一个生产者
 */
@SuppressWarnings("all")      // 注解警告信息
public class Producer implements IProducer{
    /**
     * 销售
     * @param money
     */
    public void saleProduct(float money){
        System.out.println("销售产品，并拿到钱："+money);
    }
    /**
     * 售后
     * @param money
     */
    public void afterService(float money){
        System.out.println("提供售后服务，并拿到钱："+money);
    }
}

3.编写模拟一个消费者的代码如下：

package com.txw.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * 模拟一个消费者
 */
@SuppressWarnings("all")      // 注解警告信息
public class Client {
    public static void main(String[] args) {
        final Producer producer = new Producer();
        /**
         * 动态代理：
         *  特点：字节码随用随创建，随用随加载
         *  作用：不修改源码的基础上对方法增强
         *  分类：
         *      基于接口的动态代理
         *      基于子类的动态代理
         *  基于接口的动态代理：
         *      涉及的类：Proxy
         *      提供者：JDK官方
         *  如何创建代理对象：
         *      使用Proxy类中的newProxyInstance方法
         *  创建代理对象的要求：
         *      被代理类最少实现一个接口，如果没有则不能使用
         *  newProxyInstance方法的参数：
         *      ClassLoader：类加载器
         *          它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
         *      Class[]：字节码数组
         *          它是用于让代理对象和被代理对象有相同方法。固定写法。
         *      InvocationHandler：用于提供增强的代码
         *          它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
         *          此接口的实现类都是谁用谁写。
         */
       IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
                producer.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 作用：执行被代理对象的任何接口方法都会经过该方法
                     * 方法参数的含义
                     * @param proxy   代理对象的引用
                     * @param method  当前执行的方法
                     * @param args    当前执行方法所需的参数
                     * @return        和被代理对象方法有相同的返回值
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 提供增强的代码
                        Object returnValue = null;
                        // 1.获取方法执行的参数
                        Float money = (Float)args[0];
                        // 2.判断当前方法是不是销售
                        if("saleProduct".equals(method.getName())) {
                            returnValue = method.invoke(producer, money*0.8f);
                        }
                        return returnValue;
                    }
                });
        proxyProducer.saleProduct(10000f);
    }
}

运行结果如图所示：在这里插入图片描述
7 基于子类的动态代理
1.编写一个生产者的代码如下：

package com.txw.cglib;

/**
 * 一个生产者
 */
@SuppressWarnings("all")      // 注解警告信息
public class Producer {
    /**
     * 销售
     * @param money
     */
    public void saleProduct(float money){
        System.out.println("销售产品，并拿到钱："+money);
    }
    /**
     * 售后
     * @param money
     */
    public void afterService(float money){
        System.out.println("提供售后服务，并拿到钱："+money);
    }
}

2.编写一个消费者的代码如下：

package com.txw.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * 模拟一个消费者
 */
@SuppressWarnings("all")      // 注解警告信息
public class Client {
    public static void main(String[] args) {
        final Producer producer = new Producer();
        /**
         * 动态代理：
         *  特点：字节码随用随创建，随用随加载
         *  作用：不修改源码的基础上对方法增强
         *  分类：
         *      基于接口的动态代理
         *      基于子类的动态代理
         *  基于接口的动态代理：
         *      涉及的类：Proxy
         *      提供者：JDK官方
         *  如何创建代理对象：
         *      使用Proxy类中的newProxyInstance方法
         *  创建代理对象的要求：
         *      被代理类最少实现一个接口，如果没有则不能使用
         *  newProxyInstance方法的参数：
         *      ClassLoader：类加载器
         *          它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
         *      Class[]：字节码数组
         *          它是用于让代理对象和被代理对象有相同方法。固定写法。
         *      InvocationHandler：用于提供增强的代码
         *          它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
         *          此接口的实现类都是谁用谁写。
         */
       IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
                producer.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 作用：执行被代理对象的任何接口方法都会经过该方法
                     * 方法参数的含义
                     * @param proxy   代理对象的引用
                     * @param method  当前执行的方法
                     * @param args    当前执行方法所需的参数
                     * @return        和被代理对象方法有相同的返回值
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 提供增强的代码
                        Object returnValue = null;
                        // 1.获取方法执行的参数
                        Float money = (Float)args[0];
                        // 2.判断当前方法是不是销售
                        if("saleProduct".equals(method.getName())) {
                            returnValue = method.invoke(producer, money*0.8f);
                        }
                        return returnValue;
                    }
                });
        proxyProducer.saleProduct(10000f);
    }
}

8 使用动态代理实现事务控制
1.编写账户实体类的代码如下：

package com.txw.domain;

import lombok.Data;
import lombok.ToString;
import java.io.Serializable;
/**
 * 账户的实体类
 * @author:Adair
 * @QQ:1578533828
 */
@Data     // 自动生成set和get方法
@ToString // 重写toString方法
@SuppressWarnings("all")      // 注解警告信息
public class Account implements Serializable {
    private Integer id;      // 账户的id
    private String name;     // 账户的名称
    private Float money;     // 账户的金额
}

2.编写账户的业务层接口代码如下：

package com.txw.service;

import com.txw.domain.Account;
import java.util.List;
/**
 * 账户的业务层接口
 */
@SuppressWarnings("all")      // 注解警告信息
public interface IAccountService {
    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();
    /**
     * 根据id查询账户
     * @return
     */
    Account findAccountById(Integer accountId);
    /**
     * 保存账户
     * @param account
     */
    void saveAccount(Account account);
    /**
     * 更新账户
     * @param account
     */
    void updateAccount(Account account);
    /**
     * 根据id删除账户
     * @param acccountId
     */
    void deleteAccount(Integer acccountId);
    /**
     * 转账
     * @param sourceName        转出账户名称
     * @param targetName        转入账户名称
     * @param money             转账金额
     */
    void transfer(String sourceName,String targetName,Float money);
}

3.编写账户的业务层实现类代码如下：

package com.txw.service.impl;

import com.txw.dao.IAccountDao;
import com.txw.domain.Account;
import com.txw.service.IAccountService;
import java.util.List;
/**
 * 账户的业务层实现类
 * 事务控制应该都是在业务层
 */
@SuppressWarnings("all")      // 注解警告信息
public class AccountServiceImpl implements IAccountService{
    // 声明IAccountDao业务对象
    private IAccountDao accountDao;
    /**
     * set注入
     * @param accountDao
     */
    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }
    /**
     * 查询所有
     * @return
     */
    public List<Account> findAllAccount() {
       return accountDao.findAllAccount();
    }
    /**
     * 根据id查询账户
     * @param accountId
     * @return
     */
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);

    }
    /**
     * 保存账户
     * @param account
     */
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }
    /**
     * 修改账户
     * @param account
     */
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }
    /**
     * 根据id删除账户
     * @param acccountId
     */
    public void deleteAccount(Integer acccountId) {
        accountDao.deleteAccount(acccountId);
    }
    /**
     * 转账
     * @param sourceName        转出账户名称
     * @param targetName        转入账户名称
     * @param money             转账金额
     */
    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);
    }
}

4.编写账户的持久层接口代码如下：

package com.txw.dao;

import com.txw.domain.Account;
import java.util.List;
/**
 * 账户的持久层接口
 */
@SuppressWarnings("all")      // 注解警告信息
public interface IAccountDao {
    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();
    /**
     * 根据id查询账户
     * @return
     */
    Account findAccountById(Integer accountId);
    /**
     * 保存账户
     * @param account
     */
    void saveAccount(Account account);
    /**
     * 更新账户
     * @param account
     */
    void updateAccount(Account account);
    /**
     * 根据id删除账户
     * @param acccountId
     */
    void deleteAccount(Integer acccountId);
    /**
     * 根据名称查询账户
     * @param accountName
     * @return  如果有唯一的一个结果就返回，如果没有结果就返回null
     *          如果结果集超过一个就抛异常
     */
    Account findAccountByName(String accountName);
}

5.编写账户的持久层实现类代码如下：

package com.txw.dao.impl;

import com.txw.utils.ConnectionUtils;
import com.txw.dao.IAccountDao;
import com.txw.domain.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import java.util.List;
/**
 * 账户的持久层实现类
 */
@SuppressWarnings("all")      // 注解警告信息
public class AccountDaoImpl implements IAccountDao {
    // 声明QueryRunner业务对象
    private QueryRunner runner;
    // 声明ConnectionUtils业务对象
    private ConnectionUtils connectionUtils;
    /**
     * set注入
     * @param runner
     */
    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }
    /**
     *  set注入
     * @param connectionUtils
     */
    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }
    /**
     * 查询所有
     * @return
     */
    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);
        }
    }
    /**
     * 根据id查询账户
     * @param accountId
     * @return
     */
    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);
        }
    }
    /**
     * 保存账户
     * @param account
     */
    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);
        }
    }
    /**
     * 修改账户
     * @param account
     */
    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);
        }
    }
    /**
     * 根据id删除账户
     * @param accountId
     */
    public void deleteAccount(Integer accountId) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"delete from account where id=?",accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 根据名称查询账户
     * @param accountName
     * @return
     */
    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);
        }
    }
}

6.在resources目录下创建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">
    <!--配置代理的service-->
    <bean id="proxyAccountService" factory-bean="beanFactory" factory-method="getAccountService"></bean>
    <!--配置beanfactory-->
    <bean id="beanFactory" class="com.txw.factory.BeanFactory">
        <!-- 注入service -->
        <property name="accountService" ref="accountService"></property>
        <!-- 注入事务管理器 -->
        <property name="txManager" ref="txManager"></property>
    </bean>
     <!-- 配置Service -->
    <bean id="accountService" class="com.txw.service.impl.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao"></property>
    </bean>
    <!--配置Dao对象-->
    <bean id="accountDao" class="com.txw.dao.impl.AccountDaoImpl">
        <!-- 注入QueryRunner -->
        <property name="runner" ref="runner"></property>
        <!-- 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>
    <!--配置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/spring?useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=UTC"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
    <!-- 配置Connection的工具类 ConnectionUtils -->
    <bean id="connectionUtils" class="com.txw.utils.ConnectionUtils">
        <!-- 注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置事务管理器-->
    <bean id="txManager" class="com.txw.utils.TransactionManager">
        <!-- 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>
</beans>

7.编写用于创建Service的代理对象的工厂代码如下：

package com.txw.factory;

import com.txw.service.IAccountService;
import com.txw.utils.TransactionManager;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * 用于创建Service的代理对象的工厂
 */
@SuppressWarnings("all")      // 注解警告信息
public class BeanFactory {
    // 声明IAccountService业务对象
    private IAccountService accountService;
    // 声明TransactionManager业务对象
    private TransactionManager txManager;
    /**
     * set注入
     * @param txManager
     */
    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }
    /**
     * set注入
     * @param accountService
     */
    public final void setAccountService(IAccountService accountService) {
        this.accountService = accountService;
    }
    /**
     * 获取Service代理对象
     * @return
     */
    public IAccountService getAccountService() {
        return (IAccountService)Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 添加事务的支持
                     *
                     * @param proxy
                     * @param method
                     * @param args
                     * @return
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        if("test".equals(method.getName())){
                            return method.invoke(accountService,args);
                        }
                        Object rtValue = null;
                        try {
                            // 1.开启事务
                            txManager.beginTransaction();
                            // 2.执行操作
                            rtValue = method.invoke(accountService, args);
                            // 3.提交事务
                            txManager.commit();
                            // 4.返回结果
                            return rtValue;
                        } catch (Exception e) {
                            // 5.回滚操作
                            txManager.rollback();
                            throw new RuntimeException(e);
                        } finally {
                            // 6.释放连接
                            txManager.release();
                        }
                    }
                });
    }
}

8.连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定代码如下：

package com.txw.utils;

import javax.sql.DataSource;
import java.sql.Connection;
/**
 * 连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定
 */
@SuppressWarnings("all")      // 注解警告信息
public class ConnectionUtils {
    // 创建ThreadLocal实例对象t1
    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    // 声明DataSource业务对象
    private DataSource dataSource;
    /**
     * set注入
     * @param dataSource
     */
    public void setDataSource(DataSource dataSource) {
        this.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();
    }
}

9.编写和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接的代码如下：

package com.txw.utils;

/**
 * 和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接
 */
@SuppressWarnings("all")      // 注解警告信息
public class TransactionManager {
    // 声明ConnectionUtils业务对象
    private ConnectionUtils connectionUtils;
    /**
     * set注入
     * @param connectionUtils
     */
    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }
    /**
     * 开启事务
     */
    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();
        }
    }
}

10.编写测试的代码如下：

package com.txw.test;

import com.txw.service.IAccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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
    @Qualifier("proxyAccountService")
    private  IAccountService as;
    @Test
    public  void testTransfer(){
        as.transfer("aaa","bbb",100f);
    }
}

运行之前数据库的数据如图所示：
在这里插入图片描述
运行结果如图所示：在这里插入图片描述
运行之后数据库的数据如图所示：在这里插入图片描述

学无止路
关注
专栏目录
使用IntelliJ IDEA书写简单的多用户ATM取款机
colour2018的博客
02-08 849
JDK11 功能： 登录，用户只要三次机会，存款，取款，转账，查询余额，修改密码，退出 1.编写公共静态变量变量数组，用来作为登录用户，编写一个公共静态变量index来记录登录用户数组下标 //用户 public static String[] userArray = {"张三", "李四", "王麻子", "刘勇", "李白"}; //密码 public static String[] codeArray = {"张三", "李四", "王麻子", "刘勇", "
idea-转账案例2-java-Spring-AOP-service层
weixin_44939526的博客
10-13 266
接口 package cn.csy.account.service; import java.math.BigDecimal; public interface AccountService { public void transBalance(Long from, Long to, BigDecimal balance); } 使用注解的方式 实现类 import cn.csy.account.mapper.AccountMapper; import cn.csy.account.serv
Spring之银行转账案例(七)
12-20
文章目录 (一)案例中添加转账方法并演示事务问题 (二)分析事务的问题并编写ConnectionUtils (三)编写事务管理工具类并分析连接和线程解绑 (四)编写业务层和持久层事务控制代码并配置spring的ioc (五)测试转账并分析案例中的问题 (六)代理的分析 (七)基于接口的动态代理回顾 (八)基于子类的动态代理 (九)使用动态代理实现事务控制 (一)案例中添加转账方法并演示事务问题 我们创建一个新项目，并且把之前的基于xml配置的案例的代码全部复制过来 原创文章 195获赞 209访问量 1万+
Spring事务案例：模拟银行转账
最新发布
机械工程跑路哥
02-01 1617
Spring事务作用：在【数据层】或【业务层】保证一些列数据库的操作同时成功、失败；
怎么通过id和父id来获取id路径_通过一个银行转账的案例，手写实现IOC 和 AOP
weixin_39843078的博客
12-01 167
通过上一篇面试被问了几百遍的 IoC 和 AOP，还在傻傻搞不清楚？我们了解了 IOC 和 AOP 这两个思想，下面我们先不去考虑Spring是如何实现这两个思想的，先通过一个银行转账的案例，分析一下该案例在代码层面存在什么问题？分析之后使用我们已有的知识来解决这些问题(痛点)。其实这个过程就是在一步步分析并手动实现 IOC 和 AOP 。案例介绍银行转账：账户A向账户B转账(账户A减钱，账户B加...
idea-转账案例1-Java-Spring-AOP-Mapper层
weixin_44939526的博客
10-13 252
转账案例1 实体类层 ```java package cn.csy.account.entity; import lombok.Getter; import lombok.Setter; import java.math.BigDecimal; @Setter @Getter public class Account { private Long id; private BigDecimal balance; } ## 配置文件 (与数据库建立连接) ```java mysql.drive
银行转账java mysql_如何编写一个银行转账案例？
weixin_39824898的博客
01-21 853
今天是刘小爱自学Java的第70天。感谢你的观看，谢谢你。话不多说，开始今天的学习：转账，相信基本都接触过，无论是线下用银行卡转账还是线上用手机转账，本质上都是差不多的。一、转账案例需要两个账户：刘小爱账户和刘妈妈账户；刘小爱账户转出；刘妈妈账户转入。刘小爱要给刘妈妈转账，毕竟要攒着将来娶媳妇，emm……就转1000吧(看来是娶不到媳妇了……)在数据库中用sql语句编写一个账户信息表，同时也是对s...
Android数据库中事务操作方法之银行转账示例
08-29
Android数据库中事务操作方法之银行转账示例 Android数据库中事务操作方法是一种非常重要的技术， especialmente 在银行转账等涉及到多个表操作的场景下。事务操作可以保证数据库的一致性和 atomicity， 防止部分...
简单的银行转帐系统(含JUNIT测试)
03-05
博文链接：https://java1573.iteye.com/blog/178573
MUI图片上传+JAVA源码.zip
10-07
这是我工作研发APP使用到的MUI图片上传，前台+后台JAVA源码，供参考。
spring学习笔记(6)：银行转账案例、动态代理
超级无敌小胖头
10-12 972
文章目录一、Spring实现银行转账案例1.代码实现1.1 持久层1.2 业务层1.3测试类1.3.1结果2.缺乏事务控制带来的问题2.1问题现象2.2原因分析二、添加事务控制1创建获取连接工具类2.事务管理工具类3.为业务层方法提供事务控制4.修改bean.xml5.测试效果6.上述代码问题分析6.1代码冗余6.2方法依赖三、动态代理1.基于接口的动态代理1.1缺点2.基于子类的代理四、使用动态...
Intellij IDEA 快捷键整理（史上最全） （转）
dieshuoman6200的博客
04-24 102
【常规】 Ctrl+Shift + Enter，语句完成 “！”，否定完成，输入表达式时按 “！”键 Ctrl+E，最近的文件 Ctrl+Shift+E，最近更改的文件 Shift+Click，可以关闭文件 Ctrl+[OR ]，可以跑到大括号的开头与结尾 Ctrl+F12，可以显示当前文件的结构 Ctrl+F7，可以查询当前元素在当前文件中的引用，然后按 F3 可...
关于java中常用的千分位分隔且保留两位小数的处理
jwzoro的博客
10-13 2751
一直在csdn中借阅，没有自己写过也算是第一篇博客，以后多多记录下来遇到的问题！！ 对于项目中经常遇到金额的处理，如何优雅的展示金额提升可阅读性，有个好用的工具类分享给大家，下面看代码 千分位分隔符保留两位小数 import com.netfinworks.common.lang.StringUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.math.BigDecimal; import java.
JAVA 三个框架结合运用思路_SSM框架的整合与使用——实现简单的转账系统
weixin_34579167的博客
02-16 414
一、整合思路SSM框架即SpringMVC + Spring + MyBati框架集，是一种轻量级的Web开源框架。它们各自在JAVA三层架构中负责的模块如下图所示：其中，SpringMVC与Spring之间本就存在包含关系，所以它们之间并不需要整合，只需要在web.xml中配置使用即可。而SpringMVC并不和MyBatis直接交互，因此它们之间也不需要进行配置。只有Spring和MyBati...
python 简单的数据库操作之转账
TH226的专栏
08-03 662
介绍：本文是关于数据库的简单操作，实现转账（只是修改数据库中用户的账户金额）的功能 模块介绍：首先是入口主函数 主函数中实现转账方法  以及异常的处理：   if __name__ == "__main__": source_acctid = sys.argv[1] #获取命令行第一个参数 target_acctid = sys.argv[2] money = sys.
account表里有什么 银行_使用JUnit、AssertJ和Mockito编写单元测试 （一）什么是单元测试...
weixin_39882870的博客
12-10 158
If builders built buildings the way programmers wrote programs, then the first woodpecker that came along would destroy civilization.(如果建筑业者用程序员写程序的方式盖楼造桥，那么第一只飞来驻足的啄木鸟就足以毁灭人类文明) —Weinberg's second la...
模拟银行转账，可以实现存钱和取钱的功能取钱时候如果余额不够就抛出异常 MeiQianException
weixin_51369307的博客
08-04 495
public class Student { private Integer id; private String name; private Integer age; private String gender; public Student() { } public Student(Integer id, String name, Integer age, String gender) { this.id = id; .
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

学无止路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值