DAO和增删改查通用方法--BasicDao

标签：BasicDao DAO -- dao connection stulzl import com public

1. 先分析一个问题 852

apache-dbutils+ Druid简化了JDBC开发，但还有不足:

1. SQL 语句是固定，不能通过参数传入，通用性不好，需要进行改进，更方便执行增删改查

2.对于select 操作，如果有返回值，返回类型不能固定，需要使用泛型

3.将来的表很多，业务需求复杂，不可能只靠一个Java类完成

4.引出=》BasicDAO画出示意图，看看在实际开发中，应该如何处理

DAO和增删改查通用方法--BasicDao_System

2. 基本说明 852

1. DAO: data access object数据访问对象

2.这样的通用类，称为BasicDao，是专门和数据库交互的，即完成对数据库(表)的crud操作。

3.在BaiscDao 的基础上，实现一张表对应一个Dao，更好的完成功能，比如Customer表-

Customer.java类(javabean)-CustomerDao.java

3. BasicDAO 应用实例 853-855

完成一个简单设计

com.stulzl.dao_

1. com.stulzl.dao_.utils//工具类

2. com.stulzl.dao_.domain//javabean

3. com.stulzl.dao_.dao//XxxDAO和BasicDAO

4. com.stulzl.dao_.test//写测试类

代码在 com.stulzl.dao_

com.stulzl.dao_.test; 测试TestDAO

package com.stulzl.dao_.test;


import com.stulzl.dao_.dao.ActorDAO;
import com.stulzl.dao_.domain.Actor;
import org.junit.jupiter.api.Test;

import java.util.List;

//测试Actor对actor表的crud操作  855
public class TestDAO {
    @Test
    public void testActorDAO(){
        ActorDAO actorDAO = new ActorDAO();
        //查询多行数据
        List actors =
                actorDAO.queryMulti("select * from actor where id >=?", Actor.class, 1);
        System.out.println("===查询结果===");
        for (Actor actor : actors) {
            System.out.println(actor);
        }

        //查询单行数据
        Actor actor =
                actorDAO.querySingle("select * from actor where id =?", Actor.class, 4);
        System.out.println("===查询单行数据=== ");
        System.out.println(actor);

        //查询单行单列（即一个数据）
        Object o = actorDAO.queryScalar("select name from actor where id =?", 4);
        System.out.println("===查询单行单列===");
        System.out.println(o);

        //演示dml操作insert，update，delete
        int update =
                actorDAO.update("insert into actor values(null, ?, ?, ?, ?)",
                        "张无忌", "男", "2000-11-11", "999");
        System.out.println(update > 0 ? "执行成功" : "执行没有影响表");
    }

}

com.stulzl.dao_.dao. 父类BasicDAO

package com.stulzl.dao_.dao;

import com.stulzl.jdbcutils_druid.JDBCUtils_Druid;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

//开发BasicDAO，是其他DAO的父类   854
public class BasicDAO {//泛型指定具体的类型

    private QueryRunner qr = new QueryRunner();

    //开发通用的dml方法，针对任意的表
    public int update(String sql,Object... parameters){//Object... parameters可变形参
        Connection connection = null;
        try {
            connection = JDBCUtils_Druid.getConnection();
            int update = qr.update(connection, sql, parameters);
            return update;//返回收影响行数
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            //关闭连接
            JDBCUtils_Druid.close(null,null,connection);
        }
    }

    //返回多个对象（即查询的结果是多行），这么对任意表
    /**
     *
     * @param sql sql 语句，可以有 ?
     * @param clazz 传入一个类的 Class 对象 比如 Actor.class
     * @param parameters 传入 ? 的具体的值，可以是多个
     * @return 根据 Actor.class 返回对应的 ArrayList 集合
     */
    public List queryMulti(String sql, Class clazz, Object...parameters){
        Connection connection = null;
        try {
            connection = JDBCUtils_Druid.getConnection();
            return qr.query(connection, sql, new BeanListHandler(clazz), parameters);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            //关闭连接
            JDBCUtils_Druid.close(null,null,connection);
        }

    }

    //查询单行结果的通用方法
    public T querySingle(String sql, Class clazz, Object... parameters) {
        Connection connection = null;
        try {
            connection = JDBCUtils_Druid.getConnection();
            return qr.query(connection, sql, new BeanHandler(clazz), parameters);
        } catch (SQLException e) {
            throw new RuntimeException(e); //将编译异常->运行异常 ,抛出
        } finally {
            JDBCUtils_Druid.close(null, null, connection);
        }
    }

    //查询单行单列的方法,即返回单值的方法
    public Object queryScalar(String sql, Object... parameters){
        Connection connection = null;
        try {
            connection = JDBCUtils_Druid.getConnection();
            return qr.query(connection, sql, new ScalarHandler(), parameters);
        } catch (SQLException e) {
            throw new RuntimeException(e); //将编译异常->运行异常 ,抛出
        } finally {
            JDBCUtils_Druid.close(null, null, connection);
        }
    }
}

com.stulzl.dao_.dao; 子类ActorDAO

package com.stulzl.dao_.dao;

import com.stulzl.dao_.domain.Actor;

//让ActorDAO去继承BasicDAO并指定特有的对象类    855
public class ActorDAO extends BasicDAO{
    //1. 就有 BasicDAO 的方法
    //2. 根据业务需求，可以编写特有的方法.
}

com.stulzl.dao_.domain; Actor类

package com.stulzl.dao_.domain;

import java.util.Date;

//Actor对象和actor表记录对应   847
public class Actor {
    private Integer id;
    private String name;
    private String sex;
    private Date borndate;
    private String phone;

    //无参构造器
    public Actor() {
    }

    //有参构造器
    public Actor(Integer id, String name, String sex, Date borndate, String phone) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.borndate = borndate;
        this.phone = phone;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getBorndate() {
        return borndate;
    }

    public void setBorndate(Date borndate) {
        this.borndate = borndate;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "\nActor{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", borndate=" + borndate +
                ", phone='" + phone + '\'' +
                '}';
    }
}

com.stulzl.dao_.utils; 工具类JDBCUtils_Druid

package com.stulzl.dao_.utils;


import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

//这是一个基于druid的数据库连接池的工具类  845
//将 JDBCUtils 工具类改成 Druid(德鲁伊)实现
public class JDBCUtils_Druid {
    private static DataSource ds;

    //在静态代码块完成ds的初始化
    static{
        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream("src\\druid.properties"));

            ds = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //编写getConnection方法
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }
    //关闭连接, 再次强调： 在数据库连接池技术中，close 不是真的断掉连接
    //而是把使用的 Connection 对象放回连接池
    public static void close(ResultSet resultSet, Statement statement, Connection connection){
        try {
            if (resultSet != null) {
                resultSet.close();
            }
            if (statement != null) {
                statement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

标签：BasicDao,DAO,--,dao,connection,stulzl,import,com,public
From： https://blog.51cto.com/u_15784725/6365076