DBUtils

最新推荐文章于 2022-10-06 15:16:38 发布
最新推荐文章于 2022-10-06 15:16:38 发布
阅读量108 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014449835/article/details/79996485
版权

类库

这里写图片描述

dbcpconfig.properties(src目录)

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test
username=root
password=sorry
initialSize=10
maxActive=50
maxIdle=20
minIdle=5
maxWait=60000
connectionProperties=useUnicode=true;characterEncoding=utf8
#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true
#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=
#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_COMMITTED

QueryRunner

private QueryRunner qr = new QueryRunner(DBCPUtil.getDataSource());
@Test
public void test1() throws SQLException {
    qr.update("insert into person values (?,?,?)",1,"zxn","1998-09-08");
}
@Test
public void test11() throws SQLException{
    qr.update("insert into person values(?,?,?)", 2,"zxnn",new Date());
}
@Test
public void test2() throws SQLException{
    qr.update("update person set name=? where id=?", "lxj",2);
}
@Test
public void test3() throws SQLException{
    qr.update("delete from person where id=?", 2);
}
//批处理
@Test
public void test4() throws SQLException{
    //高维：插入的记录条数    低维：每条记录的参数
    Object [][]params = new Object[10][];

    for(int i=0;i<10;i++){
        params[i] = new Object[]{i+1,"aaa"+(i+1),new Date()};
    }

    qr.batch("insert into person values(?,?,?)", params);
}

test1
这里写图片描述
test11
这里写图片描述
test2
这里写图片描述
test3
这里写图片描述
test4
这里写图片描述

ResultSetHandler
private QueryRunner qr = new QueryRunner(DBCPUtil.getDataSource());
//ArrayHandler:适合结果只有一条的情况。把记录中的每个字段的值封装到了一个Object[]中。
@Test
public void test1() throws SQLException{
    Object[] objs = qr.query("select * from person", new ArrayHandler());
    for(Object obj:objs)//每个元素就是列的值
        System.out.println(obj);
}
//ArrayListHandler:多条结果。把每条记录的列值封装到Object[]，再把Object[]封装到List中
@Test
public void test2() throws SQLException{
    List<Object[]> list = qr.query("select * from person", new ArrayListHandler());
    for(Object[] objs:list){
        System.out.println("----------------------");
        for(Object obj:objs)//每个元素就是列的值
            System.out.println(obj);
    }
}
//ColumnListHandler:封装某列的值。把取出的列值封装到List中。
@Test
public void test3() throws SQLException{
    List<Object> list = qr.query("select * from person", new ColumnListHandler("name"));
    for(Object obj:list){
        System.out.println(obj);
    }
}
//KeyedHandler:适合有多条记录的情况
@Test
public void test4() throws SQLException{
    Map<Object, Map<String,Object>> bmap = qr.query("select * from person", new KeyedHandler("id"));
    for(Map.Entry<Object, Map<String,Object>> bme:bmap.entrySet()){
        System.out.println("------------------");
        for(Map.Entry<String, Object> lme:bme.getValue().entrySet()){
            System.out.println(lme.getKey()+":"+lme.getValue());
        }
    }
}
//MapHandler:适合结果有一条的情况。把记录的列明作为key，列值作为value封装到一个Map中
@Test
public void test5() throws SQLException{
    Map<String,Object> map= qr.query("select * from person", new MapHandler());
    for(Map.Entry<String, Object> me:map.entrySet()){
        System.out.println(me.getKey()+":"+me.getValue());
    }
}
//MapListHandler:适合多条记录的结果。把记录的列明作为key，列值作为value封装到一个Map中。再把Map放到List中
@Test
public void test6() throws SQLException{
    List<Map<String,Object>> list= qr.query("select * from person", new MapListHandler());
    for(Map<String,Object> map:list){
        System.out.println("------------------");
        for(Map.Entry<String, Object> me:map.entrySet()){
            System.out.println(me.getKey()+":"+me.getValue());
        }
    }
}
//ScalarHandler:适合结果只有一条且只有一列情况。
@Test
public void test7() throws SQLException{
    Object obj = qr.query("select count(*) from person", new ScalarHandler(1));
    System.out.println(obj.getClass().getName());
    System.out.println(obj);
}

test1
这里写图片描述
test2
这里写图片描述
test3
这里写图片描述
test4
这里写图片描述
test5
这里写图片描述
test6
这里写图片描述
test7
这里写图片描述

ThreadLocal

  1. ThreadLocal是一个线程局部变量
模拟ThreadLocal
public ThreadLocal{
    private Map<Runnable,Object>map = new HashMap<Runnable,Object>();
    public void set(Object obj){
        map.put(Thread.currentThread(),obj);
    }
    public void remove(){
        map.remove(Thread.currentThread());
    }
    public Object get(){
        return map.get(Thread.currentThread())
    }
}
使用
public class Thread1 extends Thread {
    private ThreadLocal tl;
    public Thread1(ThreadLocal tl) {
        // TODO Auto-generated constructor stub
        this.tl = tl;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+":"+tl.get());
    }
}
public static void main(String[] args) {
    // TODO Auto-generated method stub
    ThreadLocal t1 = new ThreadLocal();
    t1.set("p");
    Object obj = t1.get();
    Thread1  tt =new Thread1(t1);
    tt.start();
    System.out.println(Thread.currentThread().getName()+":"+obj);
}

这里写图片描述

事务控制(第一版)

domain
public class Account implements Serializable {
    private int id;
    private String name;
    private float money;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public float getMoney() {
        return money;
    }
    public void setMoney(float money) {
        this.money = money;
    }
}
DAO
public interface AccountDao {
    void transfer(String sourceAccountName,String targetAccountName,float money);
}
//DAO:只负责CRUD。事务要求都是业务上有要求
public class AccountDaoImpl implements AccountDao {
    private QueryRunner qr = new QueryRunner();
    public void transfer(String sourceAccountName, String targetAccountName,
            float money) {
        Connection conn = null;
        try {
            conn = DBCPUtil.getConnection();
            conn.setAutoCommit(false);//开启事务
            qr.update(conn,"update account set money=money-? where name=?", money,sourceAccountName);
//          int i=1/0;
            qr.update(conn,"update account set money=money+? where name=?", money,targetAccountName);
            conn.commit();
        } catch (SQLException e) {
            if(conn!=null){
                try {
                    conn.rollback();
                } catch (SQLException e1) {
                    e1.printStackTrace();
                }
            }
            throw new RuntimeException(e);
        }finally{
            if(conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}
service
public interface BusinessService {
    /**
     * 转账
     * @param sourceAccountName 转出账户
     * @param targetAccountName 转入账户
     * @param money 涉及金额
     */
    void transfer(String sourceAccountName,String targetAccountName,float money);
}

public class BusinessServiceImpl implements BusinessService{
    private AccountDao dao = new AccountDaoImpl();
    public void transfer(String sourceAccountName, String targetAccountName,
            float money) {
        dao.transfer(sourceAccountName, targetAccountName, money);
    }
}
public static void main(String[] args) {
    BusinessService s = new BusinessServiceImpl();
    s.transfer("aaa", "bbb", 100);
}

第二版(分层)

DAO
//DAO:只负责CRUD。事务要求都是业务上有要求
public class AccountDaoImpl implements AccountDao {
    private Connection conn;

    public AccountDaoImpl(Connection conn){
        this.conn = conn;
    }
    private QueryRunner qr = new QueryRunner();

    public Account findAccountByName(String accountName) {
        try {
            return qr.query(conn,"select * from account where name=?", new BeanHandler<Account>(Account.class),accountName);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
    public void updateAccount(Account account) {
        try {
            qr.update(conn,"update account set money=? where id=?", account.getMoney(),account.getId());
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}
service
public class BusinessServiceImpl implements BusinessService{
    public void transfer(String sourceAccountName, String targetAccountName,
            float money) {
        Connection conn = null;
        try{
            conn = DBCPUtil.getConnection();
            conn.setAutoCommit(false);//开启事务
            AccountDao dao = new AccountDaoImpl(conn);
            Account sAccount = dao.findAccountByName(sourceAccountName);
            Account tAccount = dao.findAccountByName(targetAccountName);        
            sAccount.setMoney(sAccount.getMoney()-money);
            tAccount.setMoney(tAccount.getMoney()+money);   
            dao.updateAccount(sAccount);
//          int i=1/0;
            dao.updateAccount(tAccount);

            conn.commit();
        } catch (SQLException e) {
            if(conn!=null){
                try {
                    conn.rollback();
                } catch (SQLException e1) {
                    e1.printStackTrace();
                }
            }
            throw new RuntimeException(e);
        }finally{
            if(conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

第三版（ThreadLocal控制事务）

TransationManager
//事务管理器
public class TransationManager {
    private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    public static Connection getConnection(){
        Connection conn = tl.get();//从当前线程上获得链接
        if(conn==null){
            conn = DBCPUtil.getConnection();
            tl.set(conn);//把链接绑定到当前线程上
        }
        return conn;
    }
    public static void startTransaction(){
        Connection conn = getConnection();
        try {
            conn.setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public static void commit(){
        Connection conn = getConnection();
        try {
            conn.commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public static void rollback(){
        Connection conn = getConnection();
        try {
            conn.rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public static void release(){
        Connection conn = getConnection();
        try {
            conn.close();
            tl.remove();//与线程池有关，解除关系
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
DAO
//DAO:只负责CRUD。事务要求都是业务上有要求
public class AccountDaoImpl implements AccountDao {
    private QueryRunner qr = new QueryRunner();
    public Account findAccountByName(String accountName) {
        try {
            return qr.query(TransationManager.getConnection(),"select * from account where name=?", new BeanHandler<Account>(Account.class),accountName);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
    public void updateAccount(Account account) {
        try {
            qr.update(TransationManager.getConnection(),"update account set money=? where id=?", account.getMoney(),account.getId());
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

第四版（APO思想）

BeanFactory
public class BeanFactory {
    /**
     * 产生BusinessService的实例
     * @param isProxy ture，返回代理类。false，原来的类
     * @return
     */
    public static BusinessService getBusinessService(boolean isProxy){
        final BusinessService s = new BusinessServiceImpl();
        if(isProxy){
            //返回实现的代理类
            BusinessService proxyS = (BusinessService)Proxy.newProxyInstance(s.getClass().getClassLoader(), 
                    s.getClass().getInterfaces(), new InvocationHandler() { 
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args)
                                throws Throwable {
                            Object rtValue = null;
                            try{
                                long time = System.currentTimeMillis();
                                TransationManager.startTransaction();
                                rtValue = method.invoke(s, args);
                                TransationManager.commit();
                                System.out.println(method.getName()+" cost time "+(System.currentTimeMillis()-time) +" millis second");
                            } catch (Exception e) {
                                    TransationManager.rollback();
                                    throw new RuntimeException(e);
                            }finally{
                                    TransationManager.release();
                            }
                            return rtValue;
                        }
                    });
            return proxyS;
        }else{
            return s;
        }
    }
}
BusinessService s = BeanFactory.getBusinessService(true);
System.out.println(s.getClass().getName());
s.transfer("aaa", "bbb", 100);

多表操作

一对多
create table customers(
    id int primary key,
    name varchar(100),
    address varchar(255)
);
create table orders(
    ordernum int primary key,
    amount float(8,2),
    customerId int,
    constraint customer_id_fk foreign key(customerId) references customers(id)
);
public class Customer {
    private int id;
    private String name;
    private String address;
    //One2Many
    private List<Order> os = new ArrayList<Order>();    
}
public class Order {
    private int ordernum;
    private float amount;
    //Many2One
    private Customer customer;
}
public class CustomerDaoImpl implements CustomerDao {
    private QueryRunner qr = new QueryRunner(DBCPUtil.getDataSource());
    public void addCustomer(Customer c) {
        try {
            //保存客户的基本信息
            qr.update("insert into customers (id,name,address) values (?,?,?)", c.getId(),c.getName(),c.getAddress());
            //查看有没有订单，保存订单的信息
            List<Order> os = c.getOs();
            if(os.size()>0){
//          for(Order o:os){
//              qr.update("insert into orders (ordernum,amount,customerId) values (?,?,?)", o.getOrdernum(),o.getAmount(),c.getId());
//          }
                Object params[][] = new Object[os.size()][];
                for(int i=0;i<os.size();i++){
                    Order o = os.get(i);
                    params[i] = new Object[]{o.getOrdernum(),o.getAmount(),c.getId()};
                }
                qr.batch("insert into orders (ordernum,amount,customerId) values (?,?,?)", params);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
    //客户对应的订单要不要查？看需求
        //查询客户时，把订单查询出来，但订单中只有id的信息。延迟加载机制。懒
    public Customer findCustomer(int customerId) {
        //饿汉子：不懒的 lazy=false的
        try {
            Customer c = qr.query("select * from customers where id=?", new BeanHandler<Customer>(Customer.class), customerId);
            if(c!=null){
                //把定单查询出来
                List<Order> os = qr.query("select * from orders where customerId=?", new BeanListHandler<Order>(Order.class), customerId);
                c.setOs(os);
            }
            return c;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}
多对多
create table teachers(
    id int primary key,
    name varchar(100),
    salary float(8,2)
);
create table students(
    id int primary key,
    name varchar(100),
    grade varchar(10)
);

create table teachers_students(
    t_id int,
    s_id int,
    primary key(t_id,s_id),
    constraint teacher_id_fk foreign key(t_id) references teachers(id),
    constraint student_id_fk foreign key(s_id) references students(id)
);
public class Teacher {
    private int id;
    private String name;
    private float salary;
    //Many2Many
    private List<Student> students = new ArrayList<Student>();
}
public class Student {
    private int id;
    private String name;
    private String grade;
    //Many2Many
    private List<Teacher> teachers = new ArrayList<Teacher>();
}
public class TeacherDaoImpl implements TeacherDao {
    private QueryRunner qr = new QueryRunner(DBCPUtil.getDataSource());
    public void addTeacher(Teacher t) {
        try {
            //保存老师的基本信息
            qr.update("insert into teachers(id,name,salary) values (?,?,?)", t.getId(),t.getName(),t.getSalary());
            //看看老师有没有关联的学员：
            List<Student> students = t.getStudents();
            if(students.size()>0){
                //遍历学员：
                for(Student s:students){
                        //看看学员信息数据库有没有
                    Object obj = qr.query("select id from students where id=?", new ScalarHandler(1), s.getId());
                    if(obj==null){
                        //没有：插入学员的基本信息
                        qr.update("insert into students(id,name,grade) values (?,?,?)",s.getId(),s.getName(),s.getGrade());
                    }
                    //插入关系
                    qr.update("insert into teachers_students(t_id,s_id) values (?,?)", t.getId(),s.getId());
                }
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
    public Teacher findTeacher(int teacherId) {
        try {
            Teacher t = qr.query("select * from teachers where id=?", new BeanHandler<Teacher>(Teacher.class), teacherId);
            if(t!=null){
                //去查教过哪些学员
//              String sql = "select * from students where id in (select s_id from teachers_students where t_id=?)";
//              String sql = "select s.* from students s,teachers_students ts where s.id=ts.s_id and ts.t_id=?";
                String sql = "select s.* from students s inner join teachers_students ts on s.id=ts.s_id where ts.t_id=? ";
                List<Student> students = qr.query(sql, new BeanListHandler<Student>(Student.class), teacherId);
                t.setStudents(students);
            }   
            return t;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}
一对一
create table person(
    id int primary key,
    name varchar(100),
    date birthday
);

create table idcard(
    id int primary key,
    num varchar(18),
    constraint personId_fk foreign key(id) references person(id)
);


//按照外键关联：通过一对多模拟的一对一
create table idcard(
    id int primary key,
    num varchar(18),
    personId int unique,
    constraint personId_fk foreign key(personId) references person(id)
);
public class Person {
    private int id;
    private String name;
    private Date birthday;
    private IdCard idCard;
}
public class IdCard {
    private int id;
    private String num;
    private Person p;
}
public class PersonDaoImpl implements PersonDao {
    private QueryRunner qr = new QueryRunner(DBCPUtil.getDataSource());
    public void savePerson(Person p) {
        try {
            qr.update("insert into person (id,name,birthday) values (?,?,?)", p.getId(),p.getName(),p.getBirthday());
            IdCard idcard = p.getIdCard();
            if(idcard!=null){
                qr.update("insert into idcard (id,num) values (?,?)", p.getId(),idcard.getNum());
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
    public Person findPerson(int personId) {
        try {
            Person p = qr.query("select * from person where id=?",new BeanHandler<Person>(Person.class), personId);
            if(p!=null){
                IdCard idCard = qr.query("select * from idcard where id=?",new BeanHandler<IdCard>(IdCard.class), personId);
                p.setIdCard(idCard);
            }
            return p;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}
u014449835
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DButils 自定义位置存储
09-01
使用 Xutils的DButil 进行配置，数据库外置的一个demo，代码里有详细的调用说明方法。
commons-dbutils-1.3.zip
07-28
这里分享的是commons-dbutils-1.3，解压打开导入commons-dbutils-1.3.jar即可
DbUtils
JunChow
10-06 254
分类 说明 名称 DbUtils 全称 Commons DbUtils 功能 数据库操作组件 Common DbUtils是由Apache组织提供的用于封装JDBC简化DAO层开发的工具类，用于简化JDBC应用程序的开发。 数据表读操作后可将结果集转换为List、Array、Set等Java集合 数据表写操作仅需书写SQL语句 使用JNDI、数据库连接池等技术优化性能...
DButils
weixin_43775723的博客
07-22 379
111
DBUtils概述
The_Best_Hacker的博客
11-14 297
【一】概述 DBUtils是java编程中的数据库操作实用工具，小巧简单实用。 DBUtils封装了对JDBC的操作，简化了JDBC操作，可以少写代码。 Dbutils三个核心功能介绍 QueryRunner中提供对sql语句操作的API. ResultSetHandler接口，用于定义select操作后，怎样封装结果集. DbUtils类，它就是一个工具类,定义了关闭资源与事务处理...
Commons-dbutils1.7 jar包.rar
07-26
commons-dbutils包是Apache开源组织提供的用于操作数据库的工具包。简单来讲，这个工具包就是用来更加方便我们操作数据库的，最近工作中使用了一下，感觉确实方便很多，基本告别自己封装JDBC代码对数据库进行增删改...
commons-dbutils
06-20
commons-dbutils
C3P0和DButils
05-12
c3p0-0.9.1.2.jar、commons-dbutils-1.4.jar、mysql-connector-java-5.1.39-bin.jar
dbutils api
03-17
dbutils api
ChatGPT4.0知识问答、DALL-E生成AI图片、Code Copilot辅助编程，打开新世界的大门.txt
04-30
ChatGPT4.0知识问答、DALL-E生成AI图片、Code Copilot辅助编程，打开新世界的大门
基于matlab实现DOA 估计和自适应波束形成.rar
最新发布
04-30
基于matlab实现DOA 估计和自适应波束形成.rar
基于C++的线程安全容器。.zip
04-30
基于C++的线程安全容器。.zip
华为数字化转型实践28个精华问答glkm.pptx
04-30
华为数字化转型实践28个精华问答glkm.pptx
本周-综合案例.zip
04-30
本周-综合案例.zip
基于Swift简单易上手的iOS开发框架.zip
04-30
基于Swift简单易上手的iOS开发框架.zip
liba52-0-32bit-0.7.5+svn613-1.19.x86_64.rpm
04-30
liba52-0-32bit-0.7.5+svn613-1.19.x86_64
271ssm-mysql-jsp 动漫之家系统.zip（可运行源码+数据库文件+文档）
04-30
本次的设计主要是通过对动漫系统开发的背景、现状进行了分析，总结出了本次动漫之家系统开发的意义。根据此次开发的目的和意义，本次的系统开发选择了SSM框架、HTML5以及idea平台来进行动漫之家系统的开发，通过MySQL来进行数据库的开发。通过对整个动漫之家系统进行功能需求的调查研究，通过对此次的系统开发进行可行性的分析。通过实体图模型以及功能结构模型来对本次的系统开发进行了整体的开发。在整个系统开发完毕之后，通过截图说明的方式来进行系统功能的介绍，最后通过系统测试来对本次系统的完整性进行测试，最终通过本次的开发，整个动漫之家系统可以实现很好的运行，起到了为动漫爱好者提供动漫资讯的功能运行。 在前端的系统开发上，主要是为了给动漫爱好者们提供一个在线交流、在线观看动漫、在线购买动漫周边的综合性服务平台。通过这个平台，可以通过注册成为会员后，在动漫内容下进行留言互动来实现更好的动漫交流与观后感的分享，可以提高站内用户对于该网站的使用兴趣。而后台则主要为该动漫之家系统的管理员提供管理服务，后台的管理中，管理员能 关键词：动漫之家；论坛网站；SSM框架；MySQL数据库
基于matlab数字图像处理的黄豆数量识别(GUI界面).zip代码48
04-30
基于matlab数字图像处理的黄豆数量识别(GUI界面)，基于matlab数字图像处理的黄豆数量识别(GUI界面)，基于matlab数字图像处理的黄豆数量识别(GUI界面)
python dbutils
06-06
Python DBUtils 是一个轻量级的 Python 数据库连接池库，支持多个线程和多个进程，并可与各种数据库后端一起使用。DBUtils 是一个纯 Python 库，没有其他依赖项。 DBUtils 的主要目的是提供一个共享数据库连接池，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值