深入分析JavaWeb Item34 -- DBUtils框架学习

2401_84433974

于 2024-07-12 18:40:09 发布

阅读量761

点赞数 18

分类专栏：程序员文章标签：学习数据库

本文链接：https://blog.csdn.net/2401_84433974/article/details/140386529

版权

程序员专栏收录该内容

189 篇文章 0 订阅

订阅专栏

public class AccountDao {

//接收service层传递过来的Connection对象
private Connection conn = null;

public AccountDao(Connection conn){
    this.conn = conn;
}

public AccountDao(){

}

/\*\*

* @Method: update
* @Description:更新
* @Anthor:孤傲苍狼
*
* @param account
* @throws SQLException
*/
public void update(Account account) throws SQLException{

    QueryRunner qr = new QueryRunner();
    String sql = "update account set name=?,money=? where id=?";
    Object params[] = {account.getName(),account.getMoney(),account.getId()};
    //使用service层传递过来的Connection对象操作数据库
    qr.update(conn,sql, params);

}

/\*\*

* @Method: find
* @Description:查找
* @Anthor:孤傲苍狼
*
* @param id
* @return
* @throws SQLException
*/
public Account find(int id) throws SQLException{
QueryRunner qr = new QueryRunner();
String sql = “select * from account where id=?”;
//使用service层传递过来的Connection对象操作数据库
return (Account) qr.query(conn,sql, id, new BeanHandler(Account.class));
}
}


　　接着对AccountService(业务层)中的transfer方法的改造，在业务层(BusinessService)中处理事务

package me.gacl.service;

import java.sql.Connection;
import java.sql.SQLException;
import me.gacl.dao.AccountDao;
import me.gacl.domain.Account;
import me.gacl.util.JdbcUtils;

/**
* @ClassName: AccountService
* @Description: 业务逻辑处理层
* @author: 孤傲苍狼
* @date: 2014-10-6 下午5:30:15
*
*/
public class AccountService {

/\*\*

* @Method: transfer
* @Description:这个方法是用来处理两个用户之间的转账业务
* @Anthor:孤傲苍狼
*
* @param sourceid
* @param tartgetid
* @param money
* @throws SQLException
*/
public void transfer(int sourceid,int tartgetid,float money) throws SQLException{
Connection conn = null;
try{
//获取数据库连接
conn = JdbcUtils.getConnection();
//开启事务
conn.setAutoCommit(false);
//将获取到的Connection传递给AccountDao，保证dao层使用的是同一个Connection对象操作数据库
AccountDao dao = new AccountDao(conn);
Account source = dao.find(sourceid);
Account target = dao.find(tartgetid);

        source.setMoney(source.getMoney()-money);
        target.setMoney(target.getMoney()+money);

        dao.update(source);
        //模拟程序出现异常让事务回滚
        int x = 1/0;
        dao.update(target);
        //提交事务
        conn.commit();
    }catch (Exception e) {
        e.printStackTrace();
        //出现异常之后就回滚事务
        conn.rollback();
    }finally{
        conn.close();
    }
}

}


　　程序经过这样改造之后就比刚才好多了，AccountDao只负责CRUD，里面没有具体的业务处理方法了，职责就单一了，而AccountService则负责具体的业务逻辑和事务的处理，需要操作数据库时，就调用AccountDao层提供的CRUD方法操作数据库。


##### **4.3、使用ThreadLocal进行更加优雅的事务处理**


　　上面的在businessService层这种处理事务的方式依然不够优雅，为了能够让事务处理更加优雅，我们使用ThreadLocal类进行改造，**ThreadLocal一个容器，向这个容器存储的对象，在当前线程范围内都可以取得出来，向ThreadLocal里面存东西就是向它里面的Map存东西的，然后ThreadLocal把这个Map挂到当前的线程底下，这样Map就只属于这个线程了**


　　ThreadLocal类的使用范例如下：

package me.gacl.test;

public class ThreadLocalTest {

public static void main(String[] args) {
    //得到程序运行时的当前线程
    Thread currentThread = Thread.currentThread();
    System.out.println(currentThread);
    //ThreadLocal一个容器，向这个容器存储的对象，在当前线程范围内都可以取得出来
    ThreadLocal<String> t = new ThreadLocal<String>();
    //把某个对象绑定到当前线程上 对象以键值对的形式存储到一个Map集合中，对象的的key是当前的线程，如： map(currentThread,"aaa")
    t.set("aaa");
    //获取绑定到当前线程中的对象
    String value = t.get();
    //输出value的值是aaa
    System.out.println(value);
}

}


　　使用使用ThreadLocal类进行改造数据库连接工具类JdbcUtils，改造后的代码如下：

package me.gacl.util;

import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;

/**
* @ClassName: JdbcUtils2
* @Description: 数据库连接工具类
* @author: 孤傲苍狼
* @date: 2014-10-4 下午6:04:36
*
*/
public class JdbcUtils2 {

private static ComboPooledDataSource ds = null;
//使用ThreadLocal存储当前线程中的Connection对象
private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();

//在静态代码块中创建数据库连接池
static{
    try{
        //通过代码创建C3P0数据库连接池
        /\*ds = new ComboPooledDataSource();

ds.setDriverClass(“com.mysql.jdbc.Driver”);
ds.setJdbcUrl(“jdbc:mysql://localhost:3306/jdbcstudy”);
ds.setUser(“root”);
ds.setPassword(“XDP”);
ds.setInitialPoolSize(10);
ds.setMinPoolSize(5);
ds.setMaxPoolSize(20);*/

        //通过读取C3P0的xml配置

真题解析、进阶学习笔记、最新讲解视频、实战项目源码、学习路线大纲
详情关注公中号【编程进阶路】

文件创建数据源，C3P0的xml配置文件c3p0-config.xml必须放在src目录下
//ds = new ComboPooledDataSource();//使用C3P0的默认配置来创建数据源
ds = new ComboPooledDataSource(“MySQL”);//使用C3P0的命名配置来创建数据源

    }catch (Exception e) {
        throw new ExceptionInInitializerError(e);
    }
}

/\*\*

* @Method: getConnection
* @Description: 从数据源中获取数据库连接
* @Anthor:孤傲苍狼
* @return Connection
* @throws SQLException
*/
public static Connection getConnection() throws SQLException{
//从当前线程中获取Connection
Connection conn = threadLocal.get();
if(conn==null){
//从数据源中获取数据库连接
conn = getDataSource().getConnection();
//将conn绑定到当前线程
threadLocal.set(conn);
}
return conn;
}

/\*\*

* @Method: startTransaction
* @Description: 开启事务
* @Anthor:孤傲苍狼
*
*/
public static void startTransaction(){
try{
Connection conn = threadLocal.get();
if(conn==null){
conn = getConnection();
//把 conn绑定到当前线程上
threadLocal.set(conn);
}
//开启事务
conn.setAutoCommit(false);
}catch (Exception e) {
throw new RuntimeException(e);
}
}

/\*\*

* @Method: rollback
* @Description:回滚事务
* @Anthor:孤傲苍狼
*
*/
public static void rollback(){
try{
//从当前线程中获取Connection
Connection conn = threadLocal.get();
if(conn!=null){
//回滚事务
conn.rollback();
}
}catch (Exception e) {
throw new RuntimeException(e);
}
}

/\*\*

* @Method: commit
* @Description:提交事务
* @Anthor:孤傲苍狼
*
*/
public static void commit(){
try{
//从当前线程中获取Connection
Connection conn = threadLocal.get();
if(conn!=null){
//提交事务
conn.commit();
}
}catch (Exception e) {
throw new RuntimeException(e);
}
}

/\*\*

* @Method: close
* @Description:关闭数据库连接(注意，并不是真的关闭，而是把连接还给数据库连接池)
* @Anthor:孤傲苍狼
*
*/
public static void close(){
try{
//从当前线程中获取Connection
Connection conn = threadLocal.get();
if(conn!=null){
conn.close();
//解除当前线程上绑定conn
threadLocal.remove();
}
}catch (Exception e) {
throw new RuntimeException(e);
}
}

/\*\*

* @Method: getDataSource
* @Description: 获取数据源
* @Anthor:孤傲苍狼
* @return DataSource
*/
public static DataSource getDataSource(){
//从数据源中获取数据库连接
return ds;
}
}


　　对AccountDao进行改造，数据库连接对象不再需要service层传递过来，而是直接从JdbcUtils2提供的getConnection方法去获取，改造后的AccountDao如下：

package me.gacl.dao;

import java.sql.Connection;
import java.sql.SQLException;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import me.gacl.domain.Account;
import me.gacl.util.JdbcUtils;
import me.gacl.util.JdbcUtils2;

/*
create table account(
id int primary key auto_increment,
name varchar(40),
money float
)character set utf8 collate utf8_general_ci;

insert into account(name,money) values(‘A’,1000);
insert into account(name,money) values(‘B’,1000);
insert into account(name,money) values(‘C’,1000);

/**
* @ClassName: AccountDao
* @Description: 针对Account对象的CRUD
* @author: 孤傲苍狼
* @date: 2014-10-6 下午4:00:42
*
*/
public class AccountDao2 {

public void update(Account account) throws SQLException{

    QueryRunner qr = new QueryRunner();
    String sql = "update account set name=?,money=? where id=?";
    Object params[] = {account.getName(),account.getMoney(),account.getId()};
    //JdbcUtils2.getConnection()获取当前线程中的Connection对象
    qr.update(JdbcUtils2.getConnection(),sql, params);

}

public Account find(int id) throws SQLException{
    QueryRunner qr = new QueryRunner();
    String sql = "select \* from account where id=?";
    //JdbcUtils2.getConnection()获取当前线程中的Connection对象
    return (Account) qr.query(JdbcUtils2.getConnection(),sql, id, new BeanHandler(Account.class));
}

}


　　对AccountService进行改造，service层不再需要传递数据库连接Connection给Dao层，改造后的AccountService如下：

package me.gacl.service;

import java.sql.SQLException;
import me.gacl.dao.AccountDao2;
import me.gacl.domain.Account;
import me.gacl.util.JdbcUtils2;

public class AccountService2 {

/\*\*

* @Method: transfer
* @Description:在业务层处理两个账户之间的转账问题
* @Anthor:孤傲苍狼
*
* @param sourceid
* @param tartgetid
* @param money
* @throws SQLException
*/
public void transfer(int sourceid,int tartgetid,float money) throws SQLException{
try{
//开启事务，在业务层处理事务，保证dao层的多个操作在同一个事务中进行
JdbcUtils2.startTransaction();
AccountDao2 dao = new AccountDao2();

        Account source = dao.find(sourceid);
        Account target = dao.find(tartgetid);
        source.setMoney(source.getMoney()-money);
        target.setMoney(target.getMoney()+money);

        dao.update(source);
        //模拟程序出现异常让事务回滚
        int x = 1/0;
        dao.update(target);

        //SQL正常执行之后提交事务
        JdbcUtils2.commit();
    }catch (Exception e) {
        e.printStackTrace();
        //出现异常之后就回滚事务
        JdbcUtils2.rollback();
    }finally{
        //关闭数据库连接
        JdbcUtils2.close();
    }
}

}


　　这样在service层对事务的处理看起来就更加优雅了。ThreadLocal类在开发中使用得是比较多的，**程序运行中产生的数据要想在一个线程范围内共享，只需要把数据使用ThreadLocal进行存储即可。**


##### **4.4、ThreadLocal + Filter 处理事务**


　　上面介绍了JDBC开发中事务处理的3种方式，下面再介绍的一种使用ThreadLocal + Filter进行统一的事务处理，这种方式主要是使用过滤器进行统一的事务处理，如下图所示：


　![这里写图片描述](https://img-blog.csdn.net/20151228130525970)


**1、编写一个事务过滤器TransactionFilter**


代码如下：

package me.gac.web.filter;

import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import me.gacl.util.JdbcUtils;

/**
* @ClassName: TransactionFilter
* @Description:ThreadLocal + Filter 统一处理数据库事务
* @author: 孤傲苍狼
* @date: 2014-10-6 下午11:36:58
*
*/
public class TransactionFilter implements Filter {

@Override
public void init(FilterConfig filterConfig) throws ServletException {

}

@Override
public void doFilter(ServletRequest request, ServletResponse response,
        FilterChain chain) throws IOException, ServletException {

    Connection connection = null;
    try {
        //1、获取数据库连接对象Connection
        connection = JdbcUtils.getConnection();
        //2、开启事务
        connection.setAutoCommit(false);
        //3、利用ThreadLocal把获取数据库连接对象Connection和当前线程绑定
        ConnectionContext.getInstance().bind(connection);
        //4、把请求转发给目标Servlet
        chain.doFilter(request, response);
        //5、提交事务
        connection.commit();
    } catch (Exception e) {
        e.printStackTrace();
        //6、回滚事务
        try {
            connection.rollback();
        } catch (SQLException e1) {
            e1.printStackTrace();
        }
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse res = (HttpServletResponse) response;
        //req.setAttribute("errMsg", e.getMessage());
        //req.getRequestDispatcher("/error.jsp").forward(req, res);
        //出现异常之后跳转到错误页面
        res.sendRedirect(req.getContextPath()+"/error.jsp");
    }finally{
        //7、解除绑定
        ConnectionContext.getInstance().remove();
        //8、关闭数据库连接
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

@Override
public void destroy() {

}

}


　　我们在TransactionFilter中把获取到的数据库连接使用ThreadLocal绑定到当前线程之后，在DAO层还需要从ThreadLocal中取出数据库连接来操作数据库，因此需要编写一个ConnectionContext类来存储ThreadLocal，ConnectionContext类的代码如下：

package me.gac.web.filter;

import java.sql.Connection;

/**
* @ClassName: ConnectionContext
* @Description:数据库连接上下文
* @author: 孤傲苍狼
* @date: 2014-10-7 上午8:36:01
*
*/
public class ConnectionContext {

/\*\*

* 构造方法私有化，将ConnectionContext设计成单例
*/
private ConnectionContext(){

}
//创建ConnectionContext实例对象
private static ConnectionContext connectionContext = new ConnectionContext();

/\*\*

* @Method: getInstance
* @Description:获取ConnectionContext实例对象
* @Anthor:孤傲苍狼
*
* @return
*/
public static ConnectionContext getInstance(){
return connectionContext;
}

/\*\*

* @Field: connectionThreadLocal
* 使用ThreadLocal存储数据库连接对象
*/
private ThreadLocal connectionThreadLocal = new ThreadLocal();

/\*\*

* @Method: bind
* @Description:利用ThreadLocal把获取数据库连接对象Connection和当前线程绑定
* @Anthor:孤傲苍狼
*
* @param connection
*/
public void bind(Connection connection){
connectionThreadLocal.set(connection);
}

/\*\*

* @Method: getConnection
* @Description:从当前线程中取出Connection对象
* @Anthor:孤傲苍狼
*
* @return
*/
public Connection getConnection(){
return connectionThreadLocal.get();
}

/\*\*

* @Method: remove
* @Description: 解除当前线程上绑定Connection
* @Anthor:孤傲苍狼
*
*/
public void remove(){
connectionThreadLocal.remove();
}
}


　　在DAO层想获取数据库连接时，就可以使用ConnectionContext.getInstance().getConnection()来获取，如下所示：

package me.gacl.dao;

import java.sql.SQLException;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;

import me.gac.web.filter.ConnectionContext;
import me.gacl.domain.Account;

/*
create table account(
id int primary key auto_increment,
name varchar(40),
money float
)character set utf8 collate utf8_general_ci;

insert into account(name,money) values(‘A’,1000);
insert into account(name,money) values(‘B’,1000);
insert into account(name,money) values(‘C’,1000);

/**
* @ClassName: AccountDao
* @Description: 针对Account对象的CRUD
* @author: 孤傲苍狼
* @date: 2014-10-6 下午4:00:42
*
*/
public class AccountDao3 {

public void update(Account account) throws SQLException{

    QueryRunner qr = new QueryRunner();
    String sql = "update account set name=?,money=? where id=?";
    Object params[] = {account.getName(),account.getMoney(),account.getId()};
    //ConnectionContext.getInstance().getConnection()获取当前线程中的Connection对象
    qr.update(ConnectionContext.getInstance().getConnection(),sql, params);

}

public Account find(int id) throws SQLException{
    QueryRunner qr = new QueryRunner();
    String sql = "select \* from account where id=?";
    //ConnectionContext.getInstance().getConnection()获取当前线程中的Connection对象
    return (Account) qr.query(ConnectionContext.getInstance().getConnection(),sql, id, new BeanHandler(Account.class));
}

}


　　businessService层也不用处理事务和数据库连接问题了，这些统一在TransactionFilter中统一管理了，businessService层只需要专注业务逻辑的处理即可，如下所示：

package me.gacl.service;

import java.sql.SQLException;
import me.gacl.dao.AccountDao3;
import me.gacl.domain.Account;

public class AccountService3 {

/\*\*

* @Method: transfer
* @Description:在业务层处理两个账户之间的转账问题
* @Anthor:孤傲苍狼
*
* @param sourceid
* @param tartgetid
* @param money
* @throws SQLException
*/
public void transfer(int sourceid, int tartgetid, float money)
throws SQLException {
AccountDao3 dao = new AccountDao3();
Account source = dao.find(sourceid);
Account target = dao.find(tartgetid);
source.setMoney(source.getMoney() - money);
target.setMoney(target.getMoney() + money);
dao.update(source);
// 模拟程序出现异常让事务回滚
int x = 1 / 0;
dao.update(target);
}
}


　　Web层的Servlet调用businessService层的业务方法处理用户请求，需要注意的是：调用businessService层的方法出异常之后，继续将异常抛出，这样在TransactionFilter就能捕获到抛出的异常，继而执行事务回滚操作，如下所示：

package me.gacl.web.controller;

import java.io.IOException;
import java.sql.SQLException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import me.gacl.service.AccountService3;

public class AccountServlet extends HttpServlet {

最后

编程基础的初级开发者，计算机科学专业的学生，以及平时没怎么利用过数据结构与算法的开发人员希望复习这些概念为下次技术面试做准备。或者想学习一些计算机科学的基本概念，以优化代码，提高编程技能。这份笔记都是可以作为参考的。

名不虚传！字节技术官甩出的"保姆级"数据结构与算法笔记太香了

2401_84433974

关注

18
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
深入分析JavaWeb Item34 -- DBUtils框架学习

编程基础的初级开发者，计算机科学专业的学生，以及平时没怎么利用过数据结构与算法的开发人员希望复习这些概念为下次技术面试做准备。或者想学习一些计算机科学的基本概念，以优化代码，提高编程技能。这份笔记都是可以作为参考的。
复制链接

扫一扫