Java程序猿必学第二十九篇——JDBC的事务

//1. 事务(重点)
  //案例: 转账功能

   //发送方减钱
int result = accountDao.update(sendAccount);

//完成一个功能后,后面的接收方操作无法完成,数据出现问题,如何处理

//接收方加钱
result = accountDao.update(recvAccount);

/*
事务:将转账功能的多条SQL语句放入事务中,要么都成功,则提交;要么都失败,则回滚

事务如何加?在哪个层次加,为什么?
service层,如果只完成一个SQL语句,则回滚;都完成了则提交;例如
*/

   try{
      //开启事务
   //发送方减钱
int result = accountDao.update(sendAccount);

//异常

//接收方加钱
result = accountDao.update(recvAccount);
//提交事务
}catch(Exception e){
   //回滚
}

/*
问题1:出现异常后,无法进行回滚
原因:处理事务的连接对象和SQL操作的连接对象不是同一个
解决方案:
1.将事务处理的连接对象传入到dao层,共SQL操作使用--不推荐,容易造成接口污染
2.通过ThreadLocal来确保service和dao层操作同一对象--推荐

ThreadLocal的用法类似Map集合,通过键值对存储;
可以在service和dao层中操作同一个共享值,这个共享值就是连接对象

问题2:执行完一个SQL,关闭了连接对象;再次执行SQL会报错
解决方案:统一在提交或回滚事务时,才关闭连接对象

*/
==============DBUtils工具类==============
public class DBUtils {
    private static Properties p = new Properties();
    private static  ThreadLocal<Connection> th = new ThreadLocal<>();
    //静态代码块:只加载一次
    static{
        //反射对象调用getResourceAsStream
        //从src目录下获取到db.properties的资源
        try {
            InputStream is = DBUtils.class.getResourceAsStream("/db.properties");
            p.load(is);
            Class.forName(p.getProperty("driver"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection(){
        Connection conn = null;
        try {
            conn = th.get();  //从ThreadLocal中获取连接对象
            if(conn==null){
                conn = DriverManager.getConnection(p.getProperty("url"), p.getProperty("username"), p.getProperty("password"));
                th.set(conn); //将连接对象存储到ThreadLocal
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }

    public static void begin() throws SQLException {
        Connection conn = getConnection();
        conn.setAutoCommit(false);  //开启事务
    }

    public static void commit() throws SQLException {
        Connection conn = getConnection();
        conn.commit();
        closeAll(conn);  //关闭资源
    }

    public static void rollback(){
        Connection conn = getConnection();
        try {
            conn.rollback();
            closeAll(conn);  //关闭资源
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void closeAll(AutoCloseable...cs){
        for(AutoCloseable c : cs){
            if(c!=null){
                try {
                    c.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        th.remove();  //移除th对象
    }
}


//==========转账业务层代码=========
try {
    //开启事务
    DBUtils.begin();  //开启事务
    sendAccount.setMoney(sendAccount.getMoney()-money);
    int result = accountDao.update(sendAccount);
    System.out.println("发送方修改:"+result);

    //int i=1/0;  //模拟异常

    recvAccount.setMoney(recvAccount.getMoney()+money);
    result = accountDao.update(recvAccount);
    System.out.println("发送方修改:"+result);

    DBUtils.commit();  //提交事务
}catch (Exception e){
    System.out.println("事务回滚了");
    DBUtils.rollback();  //事务回滚
    return "转账失败~~!";
}

return "转账成功~~!";


/*
2. 三层架构
什么是三层架构?
与数据库操作的功能,划分了三个层次,分别是:表示层(main),业务层,数据访问层
表示层:
将准备的参数传给业务层,并接收业务层反馈(main)

业务层:(接口与实现类)
业务逻辑处理,调用dao层方法,并接收返回结果

数据访问层:(接口与实现类)
与数据库的交互操作
*/

 

//完整的三层架构的操作步骤:
//1.创建实体类
//2.DBUtils的工具类
//3.dao层的接口与实现类
//4.service层的接口与实现类
//5.通过测试类进行测试,具体结果反馈,返回到测试类中
//注意:此处加了接口与实现类,方便后续的扩展与维护
public class UserTest {
    public static void main(String[] args) {
        //面向接口编程:
        UserService userService = new UserServiceImpl();
        List<User> list = userService.selectAll(); //查询所有
    }
}


/*
3. DaoUtils(重点)
dao层的jdbc操作有太多的冗余代码
DaoUtils就是针对dao层代码进行封装,这样可以进行增删改查的复用
*/
//----------DaoUtils封装---------
//对dao层的增删改查的jdbc进行优化
public class DaoUtils {
    //增删改的封装
    //返回值--int(与数据库返回相关)
    //参数:增删改中编号的数据抽取到参数-sql,传入数据
    public static int commonUpdate(String sql,Object... objs) {
        Connection conn = null;
        PreparedStatement prst = null;
        try {
            conn = DBUtils.getConnection();
            prst = conn.prepareStatement(sql);
            //有多少个参数,就有多少个Object
            for (int i = 0; i < objs.length; i++) {
                prst.setObject(i + 1, objs[i]);
            }
            return prst.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBUtils.closeAll(prst, conn);
        }
        return 0;
    }

    //DQL的封装:
    //返回值:集合的泛型
    //参数:sql, 反射对象,所有参数
    public static <T> List<T> commonQuery(String sql,Class<T> clazz,Object...objs){
        Connection conn = null;
        PreparedStatement prst = null;
        ResultSet rs = null;
        List<T> list = new ArrayList<>();
        try {
            conn = DBUtils.getConnection();
            prst = conn.prepareStatement(sql);
            for(int i=0;i<objs.length;i++){
                prst.setObject(i+1,objs[i]);
            }
            rs = prst.executeQuery();
            Field[] fields = clazz.getDeclaredFields();
            while(rs.next()){
                //如何将数据进行ORM
                //rs.getObject传字段名(未知)-->已知属性名,只要属性名和字段名匹配,则可以注入值
                //获取属性名的数组:
                //循环遍历取出属性名,并通过属性名充当字段,得到字段内容
                T t = clazz.newInstance();
                for(Field f:fields){  //获取field对象
                    Object value = rs.getObject(f.getName()); //字段名一定要与属性名一致
                    f.setAccessible(true);  //开启权限
                    f.set(t,value);        //赋值
                }
                list.add(t);  //将实体对象存入List
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            DBUtils.closeAll(rs,prst,conn);
        }
        return list;
    }

}

//----------PersonDaoImpl---------
//dao层--数据访问层(用于做jdbc操作)
public class PersonDaoImpl {

    public int insert(Person p) {
        String sql = "insert into person(name,age,bornDate,email,address) values(?,?,?,?,?)";
        return DaoUtils.commonUpdate(sql,p.getName(),p.getAge(),p.getBornDate(),p.getEmail(),p.getAddress());
    }

    public int update(Person p) {
        String sql = "update person set name=?,age=? where id=?";
        return  DaoUtils.commonUpdate(sql,p.getName(),p.getAge(),p.getId());
    }

    public int delete(int id) {
       String sql = "delete from person where id=?";
       return DaoUtils.commonUpdate(sql,id);
    }

    public Person selectById(int id) {
        String sql = "select * from person where id=?";
        List<Person> list = DaoUtils.commonQuery(sql,Person.class,id);
        if(list.size()>0){
            return list.get(0);
        }
        return null;
    }

    public List<Person> selectAll() {
        String sql = "select * from person";
        return DaoUtils.commonQuery(sql,Person.class);
    }
}

//1.Druid连接池(重点)
//连接池:
//概述:在池中预先放入多个连接对象,当用户使用连接对象,从池子中取出;用完了回收到池子中
//好处:减少创建和销毁连接对象的数目,提高了性能
//原理:(复用机制)
// 在集合中放入10个连接对象
// 如果有用户使用连接对象,则从集合中获取,并删除集合中的对象
// 如果执行完毕,调用close,回收资源(将连接对象,重新添加到集合,给另一个用户复用)


//Druid连接池: 是阿里巴巴提供的,公认的性能最好的一款连接池产品;其它-c3p0,dbcp

//使用步骤:
//1.导入Druid连接池的jar包
//2.编写Druid的配置文件db.properties;(注意:key固定,值可变更)
//3.加载配置文件,获取数据源,从而得到连接对象
//4.close已经变为了回收(连接池里面有重写)


---------------db.properties配置---------------
#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mydb1
username=root
password=123
#<!-- 初始化连接 -->
initialSize=10
#最大连接数量
maxActive=50
#<!-- 最小空闲连接 -->
minIdle=5
#<!-- 超时等待时间以毫秒为单位 60000毫秒/1000等于60秒 -->
maxWait=5000


------------DBUtils连接池工具类-------------
public class DBUtils {
    private static DataSource dataSource;
    private static Properties p = new Properties();
    //静态代码块:只加载一次
    static{
        //反射对象调用getResourceAsStream
        //从src目录下获取到db.properties的资源
        try {
            InputStream is = DBUtils.class.getResourceAsStream("/db.properties");
            p.load(is);  //加载连接池配置
            //根据传入的配置,获取数据源,数据源中包含了连接池的操作
            dataSource = DruidDataSourceFactory.createDataSource(p);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static DataSource getDataSource(){
        return dataSource;  //获取数据源
    }

    public static Connection getConnection(){
        Connection conn = null;
        try { //从连接池中获取连接对象
           conn = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }
}



//2.DaoUtils的第三方jar
//DaoUtils第三方jar包引入
//内部实现:和我们自己写的DaoUtils是类似的,提供了,我们就不用自己写了
//第三方的jar做了除级别crud之外的其他sql语句的封装;例如:聚合,连接查询
//步骤:
//1.导入dbutils的jar包(DaoUtils的实现)
//2. 通过QueryRunner调用update和query方法实现增删改查

public class PersonDaoImpl {
    //使用QueryRunner实现增删改查功能
    private QueryRunner queryRunner = new QueryRunner(DBUtils.getDataSource());

    public int insert(Person p) {
        String sql = "insert into person(name,age,bornDate,email,address) values(?,?,?,?,?)";
        try {
            return queryRunner.update(sql,p.getName(),p.getAge(),p.getBornDate(),p.getEmail(),p.getAddress());
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int update(Person p) {
        String sql = "update person set name=?,age=? where id=?";
        try {
            return queryRunner.update(sql,p.getName(),p.getAge(),p.getId());
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int delete(int id) {
       String sql = "delete from person where id=?";
        try {
            return queryRunner.update(sql,id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
    }

    public Person selectById(int id) {
        String sql = "select * from person where id=?";
        try {
           return queryRunner.query(sql, new BeanHandler<>(Person.class), id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    public List<Person> selectAll() {
        String sql = "select * from person";
        try {
            return queryRunner.query(sql,new BeanListHandler<>(Person.class));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值