CustomerDAO及CustomerImpl的实现 & CustomerImpl的单元测试

BaseDAO:封装了针对于数据表的操作,提供通用的方法，完成后续针对具体表的逻辑

CustomerDAO：此接口用于规范 针对customers表的常用操作

CustomerDAOImpl：继承BaseDAO类  实现CustomerDAO接口的方法

文件目录

 

 BaseDAO<T>

package com.aff.dao;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.aff.util.JDBCUtils;

//封装了针对于数据表的操作
//DAO提供通用的方法，完成后续针对具体表的逻辑
//声明为抽象类，不能用来实例化，不能来造这个对象了
public abstract class BaseDAO<T> {
    private Class<T> clazz = null;

    {
        // 获取当前BaseDAO的子类继承的父类中的泛型
        // 这个this为子类对象，
        Type genericSuperclass = this.getClass().getGenericSuperclass();// 先获取当前对象的类，
        // 再获取这个类带泛型的父类
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;

        Type[] typeArguments = paramType.getActualTypeArguments();// 获取了父类的泛型参数
        clazz = (Class<T>) typeArguments[0];// 泛型的第一个参数，也就是把Customer拿到了
    }

    // 通用的增删改操作
    public int update(Connection conn, String sql, Object... args) {
        PreparedStatement ps = null;
        try {
            // 1.预编译sql语句，返回PreparedStatement的实例
            ps = conn.prepareStatement(sql);
            // 2.填充占位符
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);// 小心参数声明错误！！
            }
            // 3.执行
            return ps.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 4.资源的关闭，外面传进来的连接 不用关闭,设为null
            //   主要针对数据库连接池的使用
            try {
                conn.setAutoCommit(true);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            JDBCUtils.closeResource(null, ps);
        }
        return 0;
    }

    // 通用的查询操作，用于返回数据表中的一条记录 ============================

    public T getInstance(Connection conn, String sql, Object... args) {
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            // 执行,获取结果集
            ps = conn.prepareStatement(sql);
            // 填充占位符
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
            rs = ps.executeQuery();
            // 获取结果集的元数据
            ResultSetMetaData rsmd = rs.getMetaData();
            // 获取列数
            int columnCount = rsmd.getColumnCount();
            if (rs.next()) {
                T t = clazz.newInstance();

                for (int i = 0; i < columnCount; i++) {
                    // 获取每个列的列值
                    Object columnValue = rs.getObject(i + 1);

                    // 获取列的列名,列数 列名为元数据用来修饰ResultSet(结果集)的，
                    // String columnName = rsmd.getColumnName(i + 1);-- 不推荐使用
                    // 改为获取列的别名
                    String ColumnLabel = rsmd.getColumnLabel(i + 1);

                    // 通过反射将对象指定名columnName的属性赋给指定的值columnValue
                    // 先拿到class
                    Field field = clazz.getDeclaredField(ColumnLabel);
                    field.setAccessible(true);
                    field.set(t, columnValue);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(null, ps, rs);
        }
        return null;
    }

    // 通用查询操作返回数据表中的多条记录构成的集合，泛型集合方法加<T>List<T> ========
    public List<T> getForList(Connection conn, String sql, Object... args) {
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            // 执行,获取结果集
            ps = conn.prepareStatement(sql);
            // 填充占位符
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
            rs = ps.executeQuery();
            // 获取结果集的元数据
            ResultSetMetaData rsmd = rs.getMetaData();
            // 获取列数
            int columnCount = rsmd.getColumnCount();

            // 创建一个集合对象
            ArrayList<T> list = new ArrayList<>();
            while (rs.next()) {
                T t = clazz.newInstance();
                // 处理结果集一行数据的每一个列，给t对象指定的属性赋值
                for (int i = 0; i < columnCount; i++) {
                    // 获取每个列的列值
                    Object columnValue = rs.getObject(i + 1);

                    // 获取列的列名,列数 列名为元数据用来修饰ResultSet(结果集)的，
                    // 改为获取列的别名
                    String ColumnLabel = rsmd.getColumnLabel(i + 1);

                    // 通过反射将对象指定名columnName的属性赋给指定的值columnValue
                    // 先拿到class
                    Field field = clazz.getDeclaredField(ColumnLabel);
                    field.setAccessible(true);
                    field.set(t, columnValue);
                }
                // 理解成每遍历完一行就添加进list集合中
                list.add(t);
            }
            // while循环结束，再把添加过t对象的集合(理解为表中的每一行)返回
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(null, ps, rs);
        }
        return null;
    }

    // 用于查询特殊值的问题============================
    public <E> E getValue(Connection conn, String sql, Object... args) {
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
            rs = ps.executeQuery();
            if (rs.next()) {
                return (E) rs.getObject(1);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(null, ps, rs);
        }
        return null;
    }
}

 

CustomerDAO

package com.aff.dao;

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

import com.aff.bean.Customer;

//此接口用于规范针对customers表的常用操作
public interface CustomerDAO {
    // 将customer对象添加到数据库中
    void insert(Connection conn, Customer cust);

    // 针对指定的id删除表中的一条记录
    void deleteById(Connection conn, int id);

    // 针对内存中cust对象， 去修改数据表中指定的记录
    void updateById(Connection conn, Customer cust);

    // 针对指定id查询得到对应的Customer对象
    Customer getCustomerById(Connection conn, int id);

    // 查询表中的所有数据构成的集合
    List<Customer> getAll(Connection conn);

    // 返回数据表中数据的条目数
    Long getCount(Connection conn);

    // 返回数据表中最大的生日
    Date getMaxBrith(Connection conn);
}

 

CustomerDAOImpl

package com.aff.dao;

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

import com.aff.bean.Customer;
//指明操作Customer类 BaseDAO<Customer>
public class CustomerDAOImpl extends BaseDAO<Customer> implements CustomerDAO {

    @Override
    public void insert(Connection conn, Customer cust) {
        String sql = "insert into customers(name,email, birth ) values(?,?,?)";
        update(conn, sql, cust.getName(), cust.getEmail(), cust.getBirth());
    }

    @Override
    public void deleteById(Connection conn, int id) {
        String sql = "delete from customers where id = ?";
        update(conn, sql, id);
    }

    @Override
    public void updateById(Connection conn, Customer cust) {
        String sql = "update customers set name = ?, email = ?,birth = ? where id = ?";
        update(conn, sql, cust.getName(), cust.getEmail(), cust.getBirth(), cust.getId());
    }

    @Override
    public Customer getCustomerById(Connection conn, int id) {
        String sql = "select id,name, email,birth from customers where id = ? ";
        Customer customer = getInstance(conn,  sql, id);
        return customer;
    }

    @Override
    public List<Customer> getAll(Connection conn) {
        String sql = "select  id,name,email,birth from customers";
        List<Customer> list = getForList(conn, sql);// 查所有数据最后一个形参也就不要了
        return list;
    }

    // 调用的是getvalue()的方法
    // 返回记录数
    @Override
    public Long getCount(Connection conn) {
        String sql = "select count(*) from customers";
        long count = getValue(conn, sql);
        return count;
    }

    @Override
    public Date getMaxBrith(Connection conn) {
        String sql = "select max(birth) from customers";
        return getValue(conn, sql);
    }

}

 

CustomerDAOImplTest

package com.aff.dao.junit;
import java.sql.Connection;
import java.sql.Date;
import java.util.List;
import org.junit.Test;
import com.aff.bean.Customer;
import com.aff.dao.CustomerDAOImpl;
import com.aff.util.JDBCUtils;

public class CustomerDAOImplTest {

    private CustomerDAOImpl dao = new CustomerDAOImpl();

    @Test
    public void testInsert() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            Customer cust = new Customer(1, "雨洁", "yujie@163.com", new Date(465134648L));
            dao.insert(conn, cust);
            System.out.println("添加成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, null);
        }
    }

    @Test
    public void testDeleteById() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            dao.deleteById(conn, 22);
            System.out.println("删除成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, null);
        }
    }

    // 测试修改的
    @Test
    public void testUpdateById() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            Customer cust = new Customer(3, "雨洁", "yujie@163.com", new Date(232354354L));
            dao.updateById(conn, cust);
            System.out.println("修改成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, null);
        }
    }

    @Test
    public void testGetCustomerById() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            Customer customer = dao.getCustomerById(conn, 20);
            System.out.println(customer);
            System.out.println("获取成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, null);
        }
    }

    @Test
    public void testGetAll() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            List<Customer> list = dao.getAll(conn);
            list.forEach(System.out::println);
            // System.out.println(list);//获取的是上面的集合，没有遍历，
            // 所以会一行显示集合中的数据
            System.out.println("获取成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, null);
        }
    }

    @Test
    public void testGetCount() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            Long count = dao.getCount(conn);
            System.out.println(count);
            System.out.println("获取成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, null);
        }
    }

    @Test
    public void testGetMaxBrith() {
        Connection conn = null;
        try {
            conn = JDBCUtils.getConnection();
            Date maxBrith = dao.getMaxBrith(conn);
            System.out.println(maxBrith);
            System.out.println("获取成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, null);
        }
    }
}