jdbc实现转账操作

最新推荐文章于 2022-07-04 09:00:00 发布
最新推荐文章于 2022-07-04 09:00:00 发布
阅读量606 收藏 1
点赞数
分类专栏： 事物&MVC&反射补充
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/My_____Dream/article/details/79939571
版权

步骤分析:

    1.数据库和表

    2.新建一个项目
    3.导入jar包和工具类
        驱动 jdbcUtils
        c3p0及其配置文件和工具类
        dbutils

    4.新建一个account.jsp 表单

    5.accountservlet:

        接受三个参数
        调用accountservice.account方法完成转账操作
        打印信息

    6.account方法中:

        使用jdbc不考虑事务
        调用dao完成转出操作
        调用dao完成转入操作

    7.dao中         

    一旦出现异常,钱飞了.
    要想避免这事情,必须添加事务,在service添加事务.
    为了保证所有的操作在一个事务中,必须保证使用的是同一个连接
    在service层我们获取了连接,开启了事务.如何dao层使用此连接呢????
        方法1:
            向下传递参数.注意连接应该在service释放
        方法2:
            可以将connection对象绑定当前线程上
            jdk中有一个ThreadLocal类,
            ThreadLocal 实例通常是类中的 private static 字段，

            它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联

代码:

  account.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
         <form method="post"  action="${pageContext.request.contextPath }/account">
         <table>
           <tr>
                <td>转出方</td>
                <td><input type="text" name="fromuser"></td>
           </tr>
            <tr>
                <td>转入方</td>
                <td><input type="text" name="touser"></td>
           </tr>
            <tr>
                <td>转账金额</td>
                <td><input type="text" name="money"></td>
           </tr>
           
           <tr>
                <td><input type="submit"  value="转账"></td>
                 <td></td>
           </tr>
         
         </table>
         </form>
</body>
</html>

servlet：

 

package com.feizhu.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.feizhu.service.AccountService;
import com.feizhu.service.AccountService4DB;
import com.feizhu.service.AccountService4tl;

/**
 * 转账
 */
public class AccountServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
        //设置编码
           request.setCharacterEncoding("utf-8");
           response.setContentType("text/html;charset=utf-8");
           PrintWriter w=response.getWriter();
        //接受三个参数
            String  fromUser=request.getParameter("fromuser");
            String  toUser=request.getParameter("touser");
            String  money=request.getParameter("money");
        //调用accountservice.account(fromuser,touser,money)  
            try {
                //new AccountService4tl().account(fromUser,toUser,money);
                new AccountService4DB().account(fromUser, toUser, money);
                //打印信息
                w.print("转账成功");
            } catch (Exception e) {
                
                e.printStackTrace();
                 w.print("转账失败");
            }
            
        
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
        doGet(request, response);
    }
 

}

service:

package com.feizhu.service;

import java.sql.Connection;

import com.feizhu.dao.AccountDao;
import com.feizhu.utils.JdbcUtils;

public class AccountService {
    
    /**
     *
     * @param fromUser  转出方
     * @param toUser    转入方
     * @param money     金额
     * @throws Exception
     */

    public void account(String fromUser, String toUser, String money) throws Exception  {
        
           AccountDao dao =   new  AccountDao();
         //开启事物
           
          Connection conn=null;
        try {
            conn = JdbcUtils.getConnection();
              conn.setAutoCommit(false);
                
                //转出
                
              int i=1/0;
                   dao.accountOut(conn,fromUser,money);
                //转入
                   dao.accountIn(conn,toUser,money);
                 //事物提交
                  conn.commit();
                  JdbcUtils.closeConnect(conn);
                   
        } catch (Exception e) {
            e.printStackTrace();
            //事物回滚
            conn.rollback();
             JdbcUtils.closeConnect(conn);
            throw e;
            
        }

        
    }

}
 

dao

package com.feizhu.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import com.feizhu.utils.JdbcUtils;

public class AccountDao {

    /**
     * 转出钱
     * @param fromUser
     * @param money
     * @throws Exception
     */
    public void accountOut(Connection conn, String fromUser, String money) throws Exception {
       
            PreparedStatement st=null;
        
            
            try {
                //编写sql
                String sql="update account set money=money-? where user=?";
                //创建语句执行者
                st=conn.prepareStatement(sql);
                //设置参数
                st.setString(1, money);
                st.setString(2, fromUser);
                //执行sql
                  int i=st.executeUpdate();
                //处理
                  System.out.println("出:"+i);
            } catch (Exception e) {
                e.printStackTrace();
                throw e;
            }finally {
                //JdbcUtils.closeResource(conn, st, rs);
                JdbcUtils.closeStatement(st);
            }
           
    }


        /**
         * 转入钱
         * @param toUser
         * @param money
         * @throws Exception
         */
        public void accountIn(Connection conn,String toUser, String money) throws Exception {
           
                PreparedStatement st=null;
                ResultSet rs=null;
                
                try {
                    //编写sql
                    String sql="update account set money=money+? where user=?";
                    //创建语句执行者
                    st=conn.prepareStatement(sql);
                    //设置参数
                    st.setString(1, money);
                    st.setString(2, toUser);
                    //执行sql
                    int i=st.executeUpdate();
                    //处理
                      System.out.println("进:"+i);
                } catch (Exception e) {
                    e.printStackTrace();
                    throw e;
                }finally {
                    //JdbcUtils.closeResource(conn, st, rs);
                    JdbcUtils.closeStatement(st);
                }
        
    }
        
        
        
        public void accountOut_(String fromUser, String money) throws Exception {
               
            Connection  conn=null;
            PreparedStatement st=null;
            ResultSet rs=null;
            
            try {
                conn=JdbcUtils.getConnection();
                //编写sql
                String sql="update account set money=money-? where user=?";
                //创建语句执行者
                st=conn.prepareStatement(sql);
                //设置参数
                st.setString(1, money);
                st.setString(2, fromUser);
                //执行sql
                  int i=st.executeUpdate();
                //处理
                  System.out.println("出:"+i);
            } catch (Exception e) {
                e.printStackTrace();
                throw e;
            }finally {
                JdbcUtils.closeResource(conn, st, rs);
            }
           
    }


        /**
         * 转入钱
         * @param toUser
         * @param money
         * @throws Exception
         */
        public void accountIn_(String toUser, String money) throws Exception {
           
                Connection  conn=null;
                PreparedStatement st=null;
                ResultSet rs=null;
                
                try {
                    conn=JdbcUtils.getConnection();
                    //编写sql
                    String sql="update account set money=money+? where user=?";
                    //创建语句执行者
                    st=conn.prepareStatement(sql);
                    //设置参数
                    st.setString(1, money);
                    st.setString(2, toUser);
                    //执行sql
                    int i=st.executeUpdate();
                    //处理
                      System.out.println("进:"+i);
                } catch (Exception e) {
                    e.printStackTrace();
                    throw e;
                }finally {
                    JdbcUtils.closeResource(conn, st, rs);
                }
        
    }
 

}

工具类:

package com.feizhu.utils;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ResourceBundle;

public class JdbcUtils {
    
      static  final  String DRIVERCLASS;
      static  final  String URL;
      static  final  String USER;
      static  final  String PASSWORD;
    
    static {
          //获取ResourceBundle  ctrl+2 l
           ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
          //获取指定的内容
           DRIVERCLASS=bundle.getString("driverClass");
           URL=bundle.getString("url");
           USER=bundle.getString("user");
           PASSWORD=bundle.getString("password");    
    }
    
    static {
        
         //注册驱动
           try {
            Class.forName(DRIVERCLASS);
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
       //获取连接
       public static Connection getConnection() throws Exception {
                      
           //获取连接
           Connection conn=DriverManager.getConnection(URL,USER,PASSWORD);
           return conn;
       }
       /**
        * 释放资源
        *
        * @param conn
        *            连接
        * @param st
        *            语句执行者
        * @param rs
        *            结果集
        */
        public static void closeResource(Connection conn, PreparedStatement st, ResultSet rs) {
            closeConnect(conn);
            closeStatement(st);
            closeResult(rs);
        }


        /**
        * 释放连接
        *
        * @param conn
        *            连接
        */
        public static void closeConnect(Connection conn) {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                conn = null;
            }
        }


        /**
        * 释放语句执行者
        *
        * @param st
        *            语句执行者
        */
        public static void closeStatement(PreparedStatement st) {
            if (st != null) {
                try {
                    st.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                st = null;
            }
        }


        /**
        * 释放结果集
        *
        * @param rs
        *            结果集
        */
        public static void closeResult(ResultSet rs) {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                rs = null;
            }
        }

}

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

package com.feizhu.utils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class DataSourceUtils {
      
      private static ComboPooledDataSource ds=new ComboPooledDataSource();
      
      private static ThreadLocal<Connection> tl=new ThreadLocal<>();
      /**
       *获取数据源
       * @return 连接
       */
       public  static DataSource getDataSource() {
           return ds;
       }
      /**
       * 从 当前线程上获取连接
       * @return
       * @throws SQLException
       */
       public static Connection getConnection() throws SQLException {
           Connection conn=tl.get();
           
           if(conn==null) {
               //第一次获取  创建一个连接和当前的线程绑定
               conn=ds.getConnection();
               
               //绑定
               tl.set(conn);
           }
           return conn;
       }
       
       /**
        * 释放连接
        * @param conn 连接
        */
       
       public static void closeConn(Connection conn) {
           if(conn!=null) {
               try {
                conn.close();
                //和当前的线程解绑
            } catch (SQLException e) {
                
                e.printStackTrace();
            }
               conn=null;
           }
       }
       
       /**
        *释放语句执行者
        * @param st 执行者
        */
       public static void closeStatement(PreparedStatement st) {
           if(st!=null) {
               try {
                st.close();
            } catch (SQLException e) {
                
                e.printStackTrace();
            }
              st=null;
           }
       }
       
       
       /**
        *释放结果集
        * @param rs 结果集
        */
       public static void closeResultSet(ResultSet rs) {
           if(rs!=null) {
               try {
                   rs.close();
            } catch (SQLException e) {
                
                e.printStackTrace();
            }
               rs=null;
           }
       }
       
       /**
        *
        * @param conn
        * @param st
        * @param rs
        */
       public static void closeRouse(Connection conn,PreparedStatement st,ResultSet rs) {
           closeRouse(st,rs);
           closeConn(conn);
       }
       
       public static void closeRouse(PreparedStatement st,ResultSet rs) {
           closeResultSet(rs);
           closeStatement(st);
       }
       
       /**
        * 开启事物
        * @throws SQLException
        */
       public static void  startTransaction() throws SQLException {
           //获取连接//开启事物
           getConnection().setAutoCommit(false);
       }
       
       //事物提交
       public static void commitAndClose() {
            //获取连接
            try {
                Connection conn=getConnection();
           //提交事物
                conn.commit();
           //释放资源
                conn.close();  
           //解除绑定
                tl.remove();
            } catch (SQLException e) {
                
                e.printStackTrace();
            }

       }
       
       /**
        * 事物回滚
        * @throws SQLException
        */
       
       //事物提交
       public static void rollbackAndClose() {
            //获取连接
            try {
                Connection conn=getConnection();
           //事物回滚
                conn.rollback();
           //释放资源
                conn.close();  
           //解除绑定
                tl.remove();
            } catch (SQLException e) {
                
                e.printStackTrace();
            }

       }
}

备注：由于个人原因，本博客暂停更新。如有问题可联系本人，本人提供技术指导、学习方向、学习路线。本人微信wlp1156107728(添加注明来意)   QQ1156107728(添加注明来意)

 

My_____Dream
关注
专栏目录
jdbc写的模拟银行转账系统
07-30
create table bank ( bankId int primary key auto_increment, bankname varchar(13), bankareaId int, foreign key(bankareaId)references bankarea(bankareaId) ); insert into bank values(1,'中国农业银行',1),(2,'交通银行',2); ,(3,'中国农业银行',2),(4,'交通银行',1); create table bankarea ( bankareaId int primary key auto_increment, bankareaname varchar(20) ); insert into bankarea values(1,'南宁'),(2,'北京'); create table user( userId int primary key auto_increment, username varchar(13), bankId int, usermoney double, foreign key(bankId)references bank(bankId) ); insert into user values(1,'小明',1,100),(2,'张三',2,0);
Spring整合JDBC实现转账业务demo源代码
06-01
以上就是Spring整合JDBC实现转账业务的基本流程。实际应用中，可能还需要考虑更多的细节，比如异常处理、日志记录、性能优化等。这个demo源代码提供了学习和理解Spring JDBC集成以及事务管理的起点，有助于开发者更...
JDBC之转账操作（运用事务）
henulmh的博客
03-23 850
若是普通的转账操作我们能想到的就是运用两次update public static void transferAccounts(int id1,int id2,int money)//id为id1的人向id为id2的人转账money元 { Connection con=null; PreparedStatement pstmt1=null; PreparedStatement ps...
JDBC--转账操作
明月寄天涯的博客
03-21 245
转账操作： 转账操作之资源关闭： 之前的转账操作close方法只能关闭一个资源，但是上述有两个资源等待关闭 原来的方法： 改进的方法： 按照规则–后创建的先关闭，所以stmt2写在前面： 转账操作之事务操作（事务开启和提交） 假如转账过程中，中间出现了异常，这里假设为空指针异常： 解决办法：添加事务 只要两个事务操作有一个没有执行，则不会提交事务，事务就会回滚： ...
jdbc使用prepareStatement实现简单的转账功能
rocky_liutao的博客
08-26 1155
jdbc使用prepareStatement实现转账功能不足的地方请大神指点
使用JDBC实现查询和转账操作
Coder_Hello_World的博客
11-17 766
工具:Myeclipse(Eclipse): 知识点:如何防止SQL注入攻击和JDBC中的修改/删除操作 jar包: commons-collections4-4.0.jar commons-dbcp-1.4.jar commons-pool-1.6.jar Oracle 11g 11.2.0.1.0 JDBC_ojdbc6.jar 代码都是基于自己写的连接池技术,,已经分享过了
Spring整合JDBC实现转账业务-动态代理模式
06-01
在本示例中，我们将深入探讨如何利用Spring框架与JDBC的整合来实现转账业务，并通过动态代理模式来优化事务管理。动态代理模式是Java中一种强大的设计模式，它允许我们在运行时创建对象的代理，以拦截方法调用并执行...
Java基于JDBC实现事务，银行转账及货物进出库功能示例
08-28
1. 转账业务：转账操作需要执行两个SQL语句，更新账户余额和记录转账信息。事务操作需要保证这两个操作要么都成功，要么都不成功。 2. 一致性：事务操作需要保证数据库的数据一致性，避免出现数据不一致的情况。 3. ...
Java jdbc三层及事务（转账案例）
05-10
总结起来，通过Java JDBC实现的三层架构和事务管理，我们可以构建出健壮的数据库应用。同时，单例模式和ThreadLocal的应用，进一步提升了程序的效率和安全性。在实际开发中，理解这些概念并熟练应用，对于开发高质量...
银行的简单转账代码（java）
10-25
就是大二我们上讨论课用的简单代码，希望以后的学弟们能用的着
jdbc转账操作
weixin_30646315的博客
04-03 101
public class cs{ 　　public static void main(String[] args){ 　　　　try{ 　　　　　　Connection conn=JdbcUtils.getConnection(); 　　　　　　Conn.setAutoCommit(false);//设定开始阶段 　　　　　　PreparedStatement ps=conn.prepa...
JDBC（模拟银行转账）
supimitao的博客
05-06 1065
插件lib： 1.数据库连接 com.xiao.dbc.DBConnection.java package com.dbc; import java.sql.*; public class DBConnection { public final static String URL="jdbc:oracle:thin:127.0.0.1:1521:orcl"; public fin...
jdbc操作管理事务----用户转账操作
m0_59278919的博客
08-21 225
一、事务 种机制,某个业务中多次调用dao完成多个sql同时执行,要么同时执行成功/要么同时执行失败 否则,就出现数据紊乱! 使用事务管理(JDBC方式操作) 二、需求 用户发送请求,通过连接池获取Connection对象 Connection:管理事务的功能 void setAutoCommit(boolean autoCommit) throws SQLException 默认情况下,新创建的连接对象处于自动提交模式 参数为true,声明为false...
JDBC之事务案例——转账
技术小白
08-20 767
事务案例——转账 事务能够控制是否和何时更改应用于数据库，将单个SQL语句或一组SQL语句视为一个逻辑单元，如果任何语句失败，则整个事务将失败 转账问题中转入和转出两个账户的余额变化就是典型的事务案例，一个账户余额增加的同时，另一个转出的账户的余额必然随之减少，这可以看作是一整个事务 根据上述信息创建表money，userid和hold字段分别代表账户id和该id的余额，假设每个账户当前余额都为1000元 JDBC驱动程序默认使用自动提交模式，每个SQL语句在完成后都会提交到数据库，假设发生了异常，sq
【JDBC笔记】事务处理原则下的转账操作实现
lijibai_的博客
07-04 324
什么是事务处理原则下的转账操作实现，最直白的解释就是我转出的钱对方需要收到，事件是针对整体的，不能我的钱转出，对方不仅没有收到，我的钱还扣除了，这就是不符合事物逻辑的。所以如果我的钱转出，对方没有收到，需要把我转出的钱返还给我，这就是最经典的事务处理逻辑目录事务处理的原则导致数据不可回滚的操作代码实现事件转账保证所有事物都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。当在一个事物中执行多个操作时，要么所有的事物都被提交（commit），那么这些修改就永久地保存下来，要么数据库管理系统将放弃
JDBC 转账事务
Kunaly
08-22 511
分层和事务 使用mvc思想完成转账操作 需求: 在一个页面上有汇款人 收款人 转账金额.一旦转账之后,汇款人金额减少,收款人金额增多.使用事务控制起来. 技术分析: mvc思想 事务 首先我们先简单介绍一下mvc思想： servlet-->缺点:生成html内容太麻烦 | jsp--->缺点:阅读起来不方便,维护比较困难 | jsp+javabean: j
JDBC事务转账业务
weixin_38664181的博客
06-01 161
JDBC事务转账业务
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值