ORM及封装通用的BaseDao实现通用的查询方法

什么是ORM

//根据id去查询数据
    public Yang selectYang(int select_id){
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs =null;
        Yang table = null;
        try {
            conn = JdbcUtil.getConnection();
            String sql = "select * from yang where id=?";
            ps = conn.prepareStatement(sql);
            ps.setInt(1,select_id);
            rs = ps.executeQuery();
            while (rs.next()){
                table = new Yang();
                table.setId(rs.getInt("id"));
                table.setName(rs.getString("name"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.closeAll(ps,conn,rs);
        }
        return table;
    } 

比如上面这个查询操作，while循环里的内容称为ORM（对象关系映射），它的作用是在关系型数据库和业务实体对象之间作一个映射，这样，我们在具体的操作业务对象的时候，就不需要再去和复杂的SQL语句打交道，只需简单的操作对象的属性和方法。

上面的例子，我们是基于JDBC的方式去处理ORM的，下面，我们将其封装在通用的方法内

封装通用的BaseDao实现通用的查询方法

BaseDao接口

/**
 * 封装通用的BaseDao
 */
public interface BaseDao { 
    //封装一个查询操作
    /**
     *  <T> List<T>的两个T分别代表什么？
     *  第一个标志这个方法是泛型方法，第二个是List<T>是返回值。
     *  泛型方法返回值前必须带一个<T>，这是一种约定，表示该方法是泛型方法，否则报错。
     */
    //Class 是类的模板,不规定泛型是T，则默认会按照Object去执行
    public <T> List<T> executeFind(String sql, Object[] param,Class<T> clazz);
}

在BaseDaoImpl 接口实现类内实现查询方法

  /**
     * 完成通用查询的方法
     *
     *  注意：通用的查询方法内要求模型对象的属性名必须要和数据库中的列名相同
     */
    @Override
    public <T> List<T> executeFind(String sql, Object[] param, Class<T> clazz) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs =null;
        List<T> list = new ArrayList<>();
        try {
            conn = JDBC.bjsxt.JdbcUtil.getConnection();
            ps = conn.prepareStatement(sql);

            //得到参数的个数
            ParameterMetaData pmd = ps.getParameterMetaData();
            //绑定参数
            for (int i=0;i<pmd.getParameterCount();i++){
                ps.setObject(i+1,param[i]);
            }

            //处理结果集
            rs = ps.executeQuery();
            //获取结果集的信息
            ResultSetMetaData rsmd = rs.getMetaData();
            while (rs.next()){
                //完成ORM处理，通过jdk的反射
                T bean = clazz.newInstance();
                //通过循环处理结果集信息
                for (int i=0;i<rsmd.getColumnCount();i++){
                    /**
                     * 通过反射做值的处理 -- 使用阿帕奇的工具包commons-beanutils-1.7.0.jar,
                     * 该jar包同时依赖于commons-logging-1.2.jar包，需要同时导入
                     */
                    //先得到列名
                    String columnName = rsmd.getColumnName(i+1);
                    //获取列的值
                    Object value = rs.getObject(columnName);
                    //通过BeanUtil工具类将值放入到对象内
                    BeanUtils.setProperty(bean,columnName,value);
                }
                list.add(bean);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBC.bjsxt.JdbcUtil.closeAll(ps,conn,rs);
        }
        return list;
    }

在pojo包下创建Dept实体类

package JDBC.com.bjsxt.pojo;

public class Dept {
    private int id;
    private String name;
    public Dept(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public Dept() {
    }
    @Override
    public String toString() {
        return "Yang{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    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;
    }
} 

在Dao层的 DepartmentDao 接口内创建一个查询的抽象方法

 //查询方法
    public List<Dept> selectDeptAByLikeName(String deptName);

在DepartmentDaoImpl 接口实现类内实现查询抽象方法

    @Override
    public List<Dept> selectDeptAByLikeName(String deptName) {
        String sql = "select * from yang where name like ?";
        Object[] param = new Object[]{"%"+deptName+"%"};
        return this.executeFind(sql,param,Dept.class);
    }

在业务层，也就是service层，在DepartmentsSerivce接口内，创建一个抽象方法

public List<Dept> findDept(String deptName);

在DepartmentsServiceImpl接口实现类内，实现创建的抽象方法

    //查询信息
    @Override
    public List<Dept> findDept(String deptName) {
        DepartmentsDao deptDao = new DepartmentsDaoImpl();
        return deptDao.selectDeptAByLikeName(deptName);
    }

在Test测试类内进行测试

    public static void main(String[]args){ 
 
        DepartmentsSerivce ds = new DepartmentsServiceImpl();
        List<Dept> list = ds.findDept("n");
        for (Dept d:list){
            System.out.println(d.getId()+" "+d.getName());
        }
    }

输出结果：

这样，简化完成