模拟泛型DAO增删改查--->jdbc实现

在我之前做的的jdbc项目，参数列表中传入的都是指定类型，一旦添加了实体类，又要重新写一个dao层的方法，但是功能基本都是一致的，导致代码大量冗余，可维护性极差，所以在这里引入泛型DAO来解决这个问题，规定泛型，传入的参数可以是任意实体类，而我们在控制层可以将方法返回的泛型类型的值强转为我们要使用的实体类型，注意！这里不要通过反射在控制层获取实体类，多此一举，我们要知道，使用泛型DAO的目的是去冗余，解耦，增加可维护性，我们在传入DAO层的时候，就已经知道了我们所传入的实体类，所以直接向下转型即可。

实体类News

public class News implements Entity {
    private Integer id;
    private String title;
    private String author;
    ......
}

实体类User

package com.test.entity;

public class User implements Entity{
    private Integer id;
    private String  name;
    private String  pwd;
    }

定义一个泛型类型的接口Entity

package com.test.entity;

public interface Entity<T> {

}

增加的方法

    public int insert(Entity entity)
            throws IntrospectionException, IllegalAccessException, InvocationTargetException, InstantiationException {

        String sql = "insert into ";
        // 获取类的全限定名称
        Class clazz = entity.getClass();
        String clazzName = clazz.getName();
        // 获取表名
        String tableName = clazzName.substring(clazzName.lastIndexOf(".") + 1, clazzName.length());
        sql = sql + tableName + "(";

        Field[] fields = clazz.getDeclaredFields();

        for (Field field : fields) {
            String fieldName = field.getName();
            System.out.println(fieldName);
//          fieldName = fieldName.substring(fieldName.lastIndexOf(".") + 1, fieldName.length());
            sql += fieldName + ",";
        }
        // 切割最后一个属性的逗号
        sql = sql.substring(0, sql.length() - 1);

        sql += ") values (";
        // 获取属性的数量(多少个？)
        int fieldLength = fields.length;
        for (int i = 1; i <= fieldLength; i++) {
            sql += "?,";
        }
        sql = sql.substring(0, sql.length() - 1);
        sql += ")";
        System.out.println(sql);

        // //获取全部的方法
        // Method[] methods = clazz.getMethods();
        // List<String> typeList = new ArrayList<String>();
        // for(Method methodName : methods){
        // Class type = methodName.getReturnType();
        // typeList.add(type.toString());
        // }

        Connection conn = ConnectionManager.getConnection();

        try {
            PreparedStatement ps = conn.prepareStatement(sql);
            //定义一个变量，目的是为了控制ps.setString(i, obj.toString());
中的i的值           int i = 0;
            Field[] field = clazz.getDeclaredFields();
            Field.setAccessible(field, true);
            //对属性遍历
            for (Field field1 : field) {
                i = i + 1;
                PropertyDescriptor pd = new PropertyDescriptor(field1.getName(), clazz);
                //根据属性拿到对应的set方法
                Method getMethod = pd.getReadMethod();
                //执行set方法
                Object obj = (Object) getMethod.invoke(entity);
                //判断属性的类型
                if (field1.getType() == String.class) {

                    ps.setString(i, obj.toString());
                } else if (field1.getType() == Integer.class) {
                    ps.setInt(i, Integer.parseInt(obj.toString()));
                }
            }

            ps.execute();

        } catch (SQLException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        }

        return 0;
    }

修改，因为是都是通过反射获取属性，方法等，千篇一律，注释只简略概要。

@Override
    public int update(Entity entity) {

        // "update user set name=? ,pwd=? where id = ?"

        String sql = "update ";
        Class clazz = entity.getClass();
        String clazzName = clazz.getName();
        String tableName = clazzName.substring(clazzName.lastIndexOf(".") + 1, clazzName.length());
        sql += tableName;
        String setString = " set ";
        sql += setString;

        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            String fieldName = field.getName();
            fieldName = fieldName.substring(fieldName.lastIndexOf(".") + 1, fieldName.length());
            // 如果属性名称为id，就跳出当前循环
            if (fieldName.equals("id")) {
                continue;
            }
            sql += fieldName + "=?,";

        }
        sql = sql.substring(0, sql.length() - 1);

        // 因为默认是根据id查询，所以直接这样拼接
        sql += " where id=?";

        Connection conn = ConnectionManager.getConnection();
        try {
            PreparedStatement ps = conn.prepareStatement(sql);
            int i = 0;
            int j = 0;
            Field[] field = clazz.getDeclaredFields();
            for (Field field1 : field) {
            //id值不允许修改，所以如果属性名为id，那么跳出本次循环
                if ("id".equals(field1.getName())) {
                    continue;
                }
                i = i + 1;
                PropertyDescriptor pd = new PropertyDescriptor(field1.getName(), clazz);
                Method getMethod = pd.getReadMethod();

                Object obj = (Object) getMethod.invoke(entity);

                if (field1.getType() == String.class) {

                    ps.setString(i, obj.toString());
                } else if (field1.getType() == Integer.class) {
                    ps.setInt(i, Integer.parseInt(obj.toString()));
                }
                j = i;

            }
            for (Field field1 : field) {
                //获取set方法
                PropertyDescriptor pd = new PropertyDescriptor(field1.getName(), clazz);
                Method getMethod = pd.getReadMethod();

                Object obj = (Object) getMethod.invoke(entity);
                ps.setInt(j + 1, Integer.parseInt(obj.toString()));
                break;
            }
            ps.executeUpdate();

        } catch (SQLException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IntrospectionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println(sql);
        return 0;

    }

删除

@Override
    public int delete(Entity entity) {
        // delete from user where id=?

        String sql = "delete from ";
        Class clazz = entity.getClass();
        String clazzName = clazz.getName();
        String tableName = clazzName.substring(clazzName.lastIndexOf(".") + 1, clazzName.length());
        sql += tableName;
        String setString = " where id = ?";
        sql += setString;
        Connection conn = ConnectionManager.getConnection();

        try {
            PreparedStatement ps = conn.prepareStatement(sql);

            Field[] field = clazz.getDeclaredFields();
            //为了获取id
            for (Field field1 : field) {

                PropertyDescriptor pd = new PropertyDescriptor(field1.getName(), clazz);
                Method getMethod = pd.getReadMethod();

                Object obj = (Object) getMethod.invoke(entity);
                ps.setInt(1, Integer.parseInt(obj.toString()));
                break;

            }
            ps.execute();
            System.out.println(sql);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

查询

@Override
    public List<Object> selectAll(Entity entity) {
        // select * from user

        String sql = "select * from ";
        Class clazz = entity.getClass();
        String clazzName = clazz.getName();
        String tableName = clazzName.substring(clazzName.lastIndexOf(".") + 1, clazzName.length());
        sql += tableName;
        System.out.println(sql);
        Connection conn = ConnectionManager.getConnection();
        List<Object> list = new ArrayList<Object>();
        Field[] field = clazz.getDeclaredFields();
        try {
            PreparedStatement ps = conn.prepareStatement(sql);

            ResultSet rs = ps.executeQuery();

            while (rs.next()) {
                Entity e = (Entity)clazz.newInstance();
                    for (int j = 1; j <=field.length; j++) {
                        for (Field field1 : field) {
                            PropertyDescriptor pd = new PropertyDescriptor(field1.getName(), clazz);
                            Method setMethod = pd.getWriteMethod();
                        if (field1.getType() == String.class) {

                            setMethod.invoke(e, rs.getString(j));
                            j+=1;
                        } else if (field1.getType() == Integer.class) {
                            setMethod.invoke(e, rs.getInt(j));
                            j+=1;
                        }
                    }
                }
                    list.add(e);

            }

        } catch (SQLException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IntrospectionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }



        return list;
    }

测试类

/*
     * 测试添加
     */
    @Test
    public void testInsert()
            throws IllegalAccessException, InvocationTargetException, IntrospectionException, InstantiationException {
        Dao dao = new DaoImpl();
        User user = new User();
        News news = new News();
        news.setId(5);
        news.setAuthor("liu");
        news.setTitle("liujiazhi");
        user.setId(120);
        user.setName("a");
        user.setPwd("a");
        int i = dao.insert(user);
    }

/*
     * 测试修改
     */
    @Test
    public void testUpdate() {
        Dao dao = new DaoImpl();
        User user = new User();
        user.setId(1);
        user.setName("修改后姓名");
        user.setPwd("修改后密码");
        int i = dao.update(user);
    }

/*
     * 测试删除
     */
    @Test
    public void testDelete() {
        Dao dao = new DaoImpl();
        User user = new User();
        user.setId(1);
        int i = dao.delete(user);
    }

@Test
    public void testSelectAll() {
        Dao dao = new DaoImpl();
        User user = new User();
        List list = dao.selectAll(user);
        for (int a = 1; a < list.size(); a++) {
            User user11 = (User) list.get(a);
            System.out.println("id="+user11.getId()+" name="+user11.getName()+" password="+user11.getPwd());

        }
    }