• MVC架构模式实现银行转账

     MVC架构模式

     对Model进一步细化

     Controller+View等于Web层/表现层 

     第一步：定义Account类

    1. package com.huhu.bank.mvc;
    2.  
    3. /**
    4.  * 账户实体类，封装账户信息
    5.  */
    6. public class Account {
    7.     //一般属性不建议设计为基本数据类型，建议使用包装类，防止null带来问题
    8.     private Long id;
    9.     private String actno;
    10.     private Double balance;
    11.  
    12.     public Account(Long id, String actno, Double balance) {
    13.         this.id = id;
    14.         this.actno = actno;
    15.         this.balance = balance;
    16.     }
    17.  
    18.     public Account() {
    19.     }
    20.  
    21.     @Override
    22.     public String toString() {
    23.         return "Account{" +
    24.                 "id=" + id +
    25.                 ", actno='" + actno + '\'' +
    26.                 ", balance=" + balance +
    27.                 '}';
    28.     }
    29.  
    30.     public Long getId() {
    31.         return id;
    32.     }
    33.  
    34.     public void setId(Long id) {
    35.         this.id = id;
    36.     }
    37.  
    38.     public String getActno() {
    39.         return actno;
    40.     }
    41.  
    42.     public void setActno(String actno) {
    43.         this.actno = actno;
    44.     }
    45.  
    46.     public Double getBalance() {
    47.         return balance;
    48.     }
    49.  
    50.     public void setBalance(Double balance) {
    51.         this.balance = balance;
    52.     }
    53. }

    第二步：定义Dao层

    1. package com.huhu.bank.mvc;
    2.  
    3. import com.huhu.bank.utils.DBUtil;
    4.  
    5. import java.sql.*;
    6. import java.util.*;
    7.  
    8. /**
    9.  * 负责Account数据的增删改查
    10.  * DAO数据访问对象
    11.  * 只负责数据库的CRUD，没有任何业务逻辑在里面
    12.  */
    13. public class AccountDao {
    14.     public int insert(Account act) {
    15.         Connection con = null;
    16.         PreparedStatement ps = null;
    17.         int count = 0;
    18.         try {
    19.             con = DBUtil.getConnection();
    20.             String sql = "insert into t_act(actno,balance) values(?,?)";
    21.             ps = con.prepareStatement(sql);
    22.             ps.setString(1, act.getActno());
    23.             ps.setDouble(2, act.getBalance());
    24.             count = ps.executeUpdate();
    25.         } catch (SQLException e) {
    26.             throw new RuntimeException(e);
    27.         } finally {
    28.             DBUtil.close(con, ps, null);
    29.         }
    30.         return count;
    31.     }
    32.  
    33.     public int deleteById(String id) {
    34.         Connection con = null;
    35.         PreparedStatement ps = null;
    36.         int count = 0;
    37.         try {
    38.             con = DBUtil.getConnection();
    39.             String sql = "delete from t_act where id=?";
    40.             ps = con.prepareStatement(sql);
    41.             ps.setString(1, id);
    42.             count = ps.executeUpdate();
    43.         } catch (SQLException e) {
    44.             throw new RuntimeException(e);
    45.         } finally {
    46.             DBUtil.close(con, ps, null);
    47.         }
    48.         return count;
    49.     }
    50.  
    51.     public int update(Account act) {
    52.         Connection con = null;
    53.         PreparedStatement ps = null;
    54.         int count = 0;
    55.         try {
    56.             con = DBUtil.getConnection();
    57.             String sql = "update t_act set balance=?,actno=? where id=? ";
    58.             ps = con.prepareStatement(sql);
    59.             ps.setDouble(1, act.getBalance());
    60.             ps.setString(2, act.getActno());
    61.             ps.setLong(3, act.getId());
    62.             count = ps.executeUpdate();
    63.         } catch (SQLException e) {
    64.             throw new RuntimeException(e);
    65.         } finally {
    66.             DBUtil.close(con, ps, null);
    67.         }
    68.         return count;
    69.     }
    70.  
    71.     public Account selectByActno(String actno) {
    72.         Connection con = null;
    73.         PreparedStatement ps = null;
    74.         ResultSet rs = null;
    75.         Account act = null;
    76.         try {
    77.             con = DBUtil.getConnection();
    78.             String sql = "select id,actno,balance from t_act where actno=?";
    79.             ps = con.prepareStatement(sql);
    80.             ps.setString(1, actno);
    81.             rs = ps.executeQuery();
    82.             if (rs.next()) {
    83.                 Long id = rs.getLong("id");
    84.                 double balance = rs.getDouble("balance");
    85.                 //将结果集封装成对象
    86.                 act = new Account();
    87.                 act.setId(id);
    88.                 act.setActno(actno);
    89.                 act.setBalance(balance);
    90.             }
    91.         } catch (SQLException e) {
    92.             throw new RuntimeException(e);
    93.         } finally {
    94.             DBUtil.close(con, ps, null);
    95.         }
    96.         return act;
    97.     }
    98.  
    99.     public List selectAll() {
    100.         Connection con = null;
    101.         PreparedStatement ps = null;
    102.         ResultSet rs = null;
    103.         List list = new ArrayList<>();
    104.         try {
    105.             con = DBUtil.getConnection();
    106.             String sql = "select id,actno,balance from t_act";
    107.             ps = con.prepareStatement(sql);
    108.             rs = ps.executeQuery();
    109.             while (rs.next()) {
    110.                 //取出数据
    111.                 Long id = rs.getLong("id");
    112.                 String actno = rs.getString("actno");
    113.                 double balance = rs.getDouble("balance");
    114.                 //封装对象
    115.                 Account account = new Account();
    116.                 account.setId(id);
    117.                 account.setActno(actno);
    118.                 account.setBalance(balance);
    119.                 //加到List集合
    120.                 list.add(account);
    121.             }
    122.         } catch (SQLException e) {
    123.             throw new RuntimeException(e);
    124.         } finally {
    125.             DBUtil.close(con, ps, null);
    126.         }
    127.         return list;
    128.     }
    129. }

    第三步：定义业务层

    1. package com.huhu.bank.mvc;
    2.  
    3. import com.huhu.bank.exceptions.AppException;
    4. import com.huhu.bank.exceptions.MoneyNotEnoughException;
    5.  
    6. public class AccountService {
    7.  
    8.     private AccountDao accountDao=new AccountDao();
    9.  
    10.     /**
    11.      * 完成转账业务逻辑
    12.      *
    13.      * @param fromActno
    14.      * @param toActno
    15.      * @param money
    16.      */
    17.     public void transfer(String fromActno, String toActno, double money) throws MoneyNotEnoughException, AppException {
    18.         //查询余额是否充足
    19.         Account fromAct = accountDao.selectByActno(fromActno);
    20.         if (fromAct.getBalance() < money) {
    21.             throw new MoneyNotEnoughException("对不起，余额不足！");
    22.         }
    23.         //余额充足
    24.         Account toAct = accountDao.selectByActno(toActno);
    25.         fromAct.setBalance(fromAct.getBalance() - money);
    26.         toAct.setBalance(toAct.getBalance() + money);
    27.         //更新数据库中余额
    28.         int count = accountDao.update(fromAct);
    29.         count += accountDao.update(toAct);
    30.         if (count!=2){
    31.             throw new AppException("账户转账异常！！！");
    32.         }
    33.     }
    34. }

    第四步：定义表现层 

    1. package com.huhu.bank.mvc;
    2.  
    3. import com.huhu.bank.exceptions.MoneyNotEnoughException;
    4.  
    5. import javax.servlet.*;
    6. import javax.servlet.annotation.WebServlet;
    7. import javax.servlet.http.*;
    8. import java.io.*;
    9.  
    10. /**
    11.  * 账户小程序
    12.  * 司令官。负责调度其他组件完成任务
    13.  */
    14. @WebServlet("/transfer")
    15. public class AccountServlet extends HttpServlet {
    16.  
    17.     private AccountService accountService = new AccountService();
    18.  
    19.     @Override
    20.     protected void doPost(HttpServletRequest request, HttpServletResponse response)
    21.             throws ServletException, IOException {
    22.         //接收数据
    23.         String fromActno = request.getParameter("fromActno");
    24.         String toActno = request.getParameter("toActno");
    25.         Double money = Double.parseDouble(request.getParameter("money"));
    26.         //调用业务方法处理业务（调用model处理业务）
    27.  
    28.         try {
    29.             accountService.transfer(fromActno, toActno, money);
    30.             //转账成功
    31.             //展示处理结果（调用view作页面展示）
    32.             response.sendRedirect(request.getContextPath() + "/success.jsp");
    33.         } catch (MoneyNotEnoughException e) {
    34.             //余额不足
    35.             //展示处理结果（调用view作页面展示）
    36.             response.sendRedirect(request.getContextPath() + "/moneyNotEnough.jsp");
    37.         } catch (Exception e) {
    38.             //转账失败
    39.             //展示处理结果（调用view作页面展示）
    40.             response.sendRedirect(request.getContextPath() + "/error.jsp");
    41.         }
    42.  
    43.  
    44.     }
    45. }

    工具类

    1. package com.huhu.bank.utils;
    2. import java.sql.*;
    3. import java.util.*;
    4. import static java.util.ResourceBundle.*;
    5.  
    6. /**
    7.  * JDBC工具类封装
    8.  */
    9. public class DBUtil {
    10.  
    11.     private static ResourceBundle bundle = getBundle("resources/jdbc");
    12.     private static String driver = bundle.getString("driver");
    13.     private static String url = bundle.getString("url");
    14.     private static String user = bundle.getString("user");
    15.     private static String password = bundle.getString("password");
    16.  
    17.     /**
    18.      * 私有构造方法
    19.      * 不让创建对象，因为工具类中方法都是静态的，不需要创建对象
    20.      * 为了防止创建对象，因此将方法私有化
    21.      */
    22.     private DBUtil() {}
    23.  
    24.     //DBUtil类加载注册驱动
    25.     static {
    26.         try {
    27.             Class.forName(driver);
    28.         }catch (ClassNotFoundException e){
    29.             e.printStackTrace();
    30.         }
    31.     }
    32.  
    33.     /**
    34.      * 这里没有使用数据库连接池，直接创建连接对象
    35.      * @return 连接对象
    36.      * @throws SQLException
    37.      */
    38.     public static Connection getConnection() throws SQLException {
    39.         Connection con=DriverManager.getConnection(url,user,password);
    40.         return con;
    41.     }
    42.  
    43.     /**
    44.      * 关闭资源
    45.      * @param con 连接对象
    46.      * @param stmt 数据库操作对象
    47.      * @param rs 结果集对象
    48.      */
    49.     public static void close(Connection con,Statement stmt,ResultSet rs){
    50.         if (rs!=null){
    51.             try {
    52.                 rs.close();
    53.             }catch (SQLException e){
    54.                 throw new RuntimeException(e);
    55.             }
    56.         }
    57.         if (stmt!=null){
    58.             try {
    59.                 stmt.close();
    60.             }catch (SQLException e){
    61.                 throw new RuntimeException(e);
    62.             }
    63.         }
    64.         if (con!=null){
    65.             try {
    66.                 con.close();
    67.             }catch (SQLException e){
    68.                 throw new RuntimeException(e);
    69.             }
    70.         }
    71.     }
    72. }

    事务银行转账优化篇 

    工具类

    1. private static ThreadLocal local=new ThreadLocal<>();
    2.     /**
    3.      * 这里没有使用数据库连接池，直接创建连接对象
    4.      * @return 连接对象
    5.      * @throws SQLException
    6.      */
    7.     public static Connection getConnection() throws SQLException {
    8.         Connection con = local.get();
    9.         if (con==null){
    10.             con=DriverManager.getConnection(url,user,password);
    11.             local.set(con);
    12.         }
    13.         return con;
    14.     }
    1.         if (con!=null){
    2.             try {
    3.                 con.close();
    4.                 //根本原因：Tomcat支持线程池的，一个人使用过t1线程，不移除的话可能会被其他人使用
    5.                 local.remove();
    6.             }catch (SQLException e){
    7.                 throw new RuntimeException(e);
    8.             }
    9.         }

     Service层类

    1. package com.huhu.bank.mvc;
    2.  
    3. import com.huhu.bank.exceptions.AppException;
    4. import com.huhu.bank.exceptions.MoneyNotEnoughException;
    5. import com.huhu.bank.utils.DBUtil;
    6.  
    7. import java.sql.Connection;
    8. import java.sql.DriverManager;
    9. import java.sql.SQLException;
    10.  
    11. public class AccountService {
    12.  
    13.     private AccountDao accountDao=new AccountDao();
    14.  
    15.     /**
    16.      * 完成转账业务逻辑
    17.      *
    18.      * @param fromActno
    19.      * @param toActno
    20.      * @param money
    21.      */
    22.     public void transfer(String fromActno, String toActno, double money) throws MoneyNotEnoughException, AppException {
    23.         //Service层控制事务
    24.         try(Connection con= DBUtil.getConnection()){
    25.             System.out.println(con);
    26.             con.setAutoCommit(false);
    27.             //查询余额是否充足
    28.             Account fromAct = accountDao.selectByActno(fromActno);
    29.             if (fromAct.getBalance() < money) {
    30.                 throw new MoneyNotEnoughException("对不起，余额不足！");
    31.             }
    32.             //余额充足
    33.             Account toAct = accountDao.selectByActno(toActno);
    34.             fromAct.setBalance(fromAct.getBalance() - money);
    35.             toAct.setBalance(toAct.getBalance() + money);
    36.             //更新数据库中余额
    37.             int count = accountDao.update(fromAct);
    38.             count += accountDao.update(toAct);
    39.  
    40.             //模拟异常
    41.             String s=null;
    42.             s.toString();
    43.  
    44.             if (count!=2){
    45.                 throw new AppException("账户转账异常！！！");
    46.             }
    47.             con.commit();
    48.         }catch (SQLException e){
    49.             throw new AppException("账户转账异常！！！");
    50.         }
    51.  
    52.     }
    53. }

    Dao类 

    1. package com.huhu.bank.mvc;
    2.  
    3. import com.huhu.bank.utils.DBUtil;
    4.  
    5. import java.sql.*;
    6. import java.util.*;
    7.  
    8. /**
    9.  * 负责Account数据的增删改查
    10.  * DAO数据访问对象
    11.  * 只负责数据库的CRUD，没有任何业务逻辑在里面
    12.  */
    13. public class AccountDao {
    14.     public int insert(Account act) {
    15.         PreparedStatement ps = null;
    16.         int count = 0;
    17.         try {
    18.             Connection con = DBUtil.getConnection();
    19.             String sql = "insert into t_act(actno,balance) values(?,?)";
    20.             ps = con.prepareStatement(sql);
    21.             ps.setString(1, act.getActno());
    22.             ps.setDouble(2, act.getBalance());
    23.             count = ps.executeUpdate();
    24.         } catch (SQLException e) {
    25.             throw new RuntimeException(e);
    26.         } finally {
    27.             DBUtil.close(null, ps, null);
    28.         }
    29.         return count;
    30.     }
    31.  
    32.     public int deleteById(String id) {
    33.         PreparedStatement ps = null;
    34.         int count = 0;
    35.         try {
    36.             Connection con = DBUtil.getConnection();
    37.             String sql = "delete from t_act where id=?";
    38.             ps = con.prepareStatement(sql);
    39.             ps.setString(1, id);
    40.             count = ps.executeUpdate();
    41.         } catch (SQLException e) {
    42.             throw new RuntimeException(e);
    43.         } finally {
    44.             DBUtil.close(null, ps, null);
    45.         }
    46.         return count;
    47.     }
    48.  
    49.     public int update(Account act) {
    50.         PreparedStatement ps = null;
    51.         int count = 0;
    52.         try {
    53.             Connection con = DBUtil.getConnection();
    54.             String sql = "update t_act set balance=?,actno=? where id=? ";
    55.             ps = con.prepareStatement(sql);
    56.             ps.setDouble(1, act.getBalance());
    57.             ps.setString(2, act.getActno());
    58.             ps.setLong(3, act.getId());
    59.             count = ps.executeUpdate();
    60.         } catch (SQLException e) {
    61.             throw new RuntimeException(e);
    62.         } finally {
    63.             DBUtil.close(null, ps, null);
    64.         }
    65.         return count;
    66.     }
    67.  
    68.     public Account selectByActno(String actno) {
    69.         PreparedStatement ps = null;
    70.         ResultSet rs = null;
    71.         Account act = null;
    72.         try {
    73.             Connection con = DBUtil.getConnection();
    74.             String sql = "select id,actno,balance from t_act where actno=?";
    75.             ps = con.prepareStatement(sql);
    76.             ps.setString(1, actno);
    77.             rs = ps.executeQuery();
    78.             if (rs.next()) {
    79.                 Long id = rs.getLong("id");
    80.                 double balance = rs.getDouble("balance");
    81.                 //将结果集封装成对象
    82.                 act = new Account();
    83.                 act.setId(id);
    84.                 act.setActno(actno);
    85.                 act.setBalance(balance);
    86.             }
    87.         } catch (SQLException e) {
    88.             throw new RuntimeException(e);
    89.         } finally {
    90.             DBUtil.close(null, ps, rs);
    91.         }
    92.         return act;
    93.     }
    94.  
    95.     public List selectAll() {
    96.         PreparedStatement ps = null;
    97.         ResultSet rs = null;
    98.         List list = new ArrayList<>();
    99.         try {
    100.             Connection con = DBUtil.getConnection();
    101.             String sql = "select id,actno,balance from t_act";
    102.             ps = con.prepareStatement(sql);
    103.             rs = ps.executeQuery();
    104.             while (rs.next()) {
    105.                 //取出数据
    106.                 Long id = rs.getLong("id");
    107.                 String actno = rs.getString("actno");
    108.                 double balance = rs.getDouble("balance");
    109.                 //封装对象
    110.                 Account account = new Account();
    111.                 account.setId(id);
    112.                 account.setActno(actno);
    113.                 account.setBalance(balance);
    114.                 //加到List集合
    115.                 list.add(account);
    116.             }
    117.         } catch (SQLException e) {
    118.             throw new RuntimeException(e);
    119.         } finally {
    120.             DBUtil.close(null, ps, rs);
    121.         }
    122.         return list;
    123.     }
    124. }

  • 相关阅读:
    uniapp项目+SSM实现的安卓的掌上校园系统
    病毒攻防原理
    基于 JuiceFS 构建高校 AI 存储方案：高并发、系统稳定、运维简单
    SpringMVC篇
    rpc通信的实现方式(以grpc为例)
    基础线段树
    TC8：UDP_USER_INTERFACE_01-08
    Kubectl 的使用——k8s陈述式资源管理
    云原生周刊 | 波音公司允许员工给开源项目做贡献
    Java 性能基准测试：从 OpenJDK 8 到 OpenJDK 19
  • 原文地址：https://blog.csdn.net/bubbleJessica/article/details/128189777