Java基于自定义注释和反射机制实现初级通用DAO

原创 2015年11月20日 18:06:38

public class SdnWareDao {

    /**
     * 线程池
     */
    private static final ExecutorService threadPools = Executors.newFixedThreadPool(4);

    /**
     * 获取Entity class注释的数据库表名
     *
     * @param clazz
     * @return table name
     */
    private static String getTableName(Class<?> clazz) {
        String tableName = null;
        if (clazz.isAnnotationPresent(Table.class)) {
            Table table = clazz.getAnnotation(Table.class);
            tableName = table.value();
        }
        if (tableName == null) {
            tableName = clazz.getSimpleName();
        }
        return tableName;
    }

    /**
     * 获取属性注释的列名
     *
     * @param field 属性
     * @return column name
     */
    private static String getColumnName(Field field) {
        String colName = null;
        if (field.isAnnotationPresent(Column.class)) {
            Column column = field.getAnnotation(Column.class);
            colName = column.value();
        }
        if (colName == null) {
            colName = field.getName();
        }
        return colName;
    }

    /**
     * 判断属性是否为id
     *
     * @param field 属性
     * @return boolean
     */
    private static boolean isId(Field field) {
        boolean flag = false;
        if (field.isAnnotationPresent(Id.class)) {
            flag = true;
        }
        return flag;
    }

    /**
     * 查询 <E> 对应数据库表所有数据
     * 
     * @param clazz Entity
     * @param sql queryString
     * @param args parameter
     * @return the result List
     */
    public static <E> List<E> getListBySome(Class<E> clazz, String sql, Object... args) {
        List<E> arrList = new ArrayList<>();
        Connection conn = DBHelper.getConnection();
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        Field[] fields = clazz.getDeclaredFields();
        try {
            pstmt = conn.prepareStatement(sql);
            int len = (args == null) ? 0 : args.length;
            for (int i = 0; i < len; ++i) {
                pstmt.setObject(i + 1, args[i]);
            }
            rs = pstmt.executeQuery();
            while (rs.next()) {
                E ob = clazz.newInstance();
                for (Field fi : fields) {
                    fi.setAccessible(true);
                    fi.set(ob, rs.getObject(getColumnName(fi)));
                }
                arrList.add(ob);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DBHelper.closeRes(conn, pstmt, rs);
        }
        return arrList;
    }

    /**
     * 查询所有<E>数据
     * @param clazz Entity
     * @return the result List
     */
    public static <E> List<E> getList(Class<E> clazz) {
        String sql = "select * from " + getTableName(clazz);
        return getListBySome(clazz, sql);
    }

    /**
     * 插入数据
     * 
     * @param object a persistent class
     */
    public static void persist(Object object) {
        PersistRunnable pr = new PersistRunnable(object);
        threadPools.submit(pr);
    }

    /**
     * 插入数据
     *
     * @param obj a persistent class
     * @return boolean
     */
    public static boolean save(Object obj) {
        boolean flag = false;
        Connection conn = DBHelper.getConnection();
        PreparedStatement pstmt = null;
        Class<?> clazz = obj.getClass();
        Field[] fields = clazz.getDeclaredFields();
        StringBuilder sb = new StringBuilder();
        sb.append("insert into ");
        sb.append(getTableName(clazz));
        sb.append(" (");
        int len = fields.length;
        int id = 0;
        for (int i = 0; i < len; ++i) {
            if (isId(fields[i])) {
                id = i;
                continue;
            }
            sb.append(getColumnName(fields[i]));
            if (i != len - 1) {
                sb.append(" , ");
            }
        }
        sb.append(") values (");
        for (int i = 1; i < len; ++i) {
            sb.append(" ? ");
            if (i != len - 1) {
                sb.append(" , ");
            }
        }
        sb.append(")");
        try {
            pstmt = conn.prepareStatement(sb.toString());
            for (int i = 0, j = 1; i < len; ++i) {
                if (i == id) {
                    continue;
                }
                fields[i].setAccessible(true);
                pstmt.setObject(j++, fields[i].get(obj));
            }
            int res = pstmt.executeUpdate();
            if (res > 0) {
                flag = true;
            }
        } catch (Exception sqle) {
            sqle.printStackTrace();
        } finally {
            DBHelper.closeRes(conn, pstmt);
        }
        return flag;
    }

    /**
     * 更新entity数据
     *
     * @param obj an entity class to update
     * @return boolean
     */
    public static boolean update(Object obj) {
        boolean flag = false;
        Connection conn = DBHelper.getConnection();
        PreparedStatement pstmt = null;
        Class<?> clazz = obj.getClass();
        Field[] fields = clazz.getDeclaredFields();
        StringBuilder sb = new StringBuilder();
        sb.append("update ");
        sb.append(getTableName(clazz));
        sb.append(" set ");
        int len = fields.length;
        String idName = "id";
        int id = 0;
        for (int i = 0; i < len; ++i) {
            if (isId(fields[i])) {
                id = i;
                idName = getColumnName(fields[i]);
                continue;
            }
            fields[i].setAccessible(true);
            sb.append(getColumnName(fields[i]));
            sb.append(" = ? ");
            if (i != len - 1) {
                sb.append(", ");
            }
        }
        sb.append(" where ");
        sb.append(idName);
        sb.append(" = ?");
        try {
            pstmt = conn.prepareStatement(sb.toString());
            for (int i = 0, j = 1; i < len; ++i) {
                if (i == id) {
                    continue;
                }
                fields[i].setAccessible(true);
                pstmt.setObject(j++, fields[i].get(obj));
            }
            fields[id].setAccessible(true);
            pstmt.setObject(len, fields[id].get(obj));
            int res = pstmt.executeUpdate();
            if (res > 0) {
                flag = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DBHelper.closeRes(conn, pstmt);
        }
        return flag;
    }

    /**
     * 更新数据库表某几项数据
     *
     * @param sql updateString
     * @param args values
     * @return boolean
     */
    public static boolean updateSome(String sql, Object... args) {
        boolean flag = false;
        Connection conn = DBHelper.getConnection();
        PreparedStatement pstmt = null;
        try {
            pstmt = conn.prepareStatement(sql);
            for (int i = 0, len = args.length; i < len; ++i) {
                pstmt.setObject(i + 1, args[i]);
            }
            int res = pstmt.executeUpdate();
            if (res > 0) {
                flag = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DBHelper.closeRes(conn, pstmt);
        }
        return flag;
    }

    /**
     * 删除数据库表某几条记录
     *
     * @param tableName 表名
     * @param name 属性名
     * @param value 属性值
     * @return boolean
     */
    public static boolean delete(String sql) {
        boolean flag = false;
        Connection conn = DBHelper.getConnection();
        PreparedStatement pstmt = null;
        try {
            pstmt = conn.prepareStatement(sql);
            int res = pstmt.executeUpdate();
            if (res > 0) {
                flag = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DBHelper.closeRes(conn, pstmt);
        }
        return flag;
    }

    private static class PersistRunnable implements Runnable {

        private Object obj;

        public PersistRunnable(Object obj) {
            this.obj = obj;
        }

        @Override
        public void run() {
            save(obj);
        }

    }
}




/**
 * 注释Entity对应的数据库表名
 * Created by lezg on 15/11/21.
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {
    String value();
}

/**
 * 注释Entity属性对应数据库的列名
 * Created by lezg on 15/11/21.
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
    String value();
}

/**
 * id标识
 * Created by lezg on 15/11/22.
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Id {
}


相关文章推荐

java反射机制和自定义注解原理分析和实例

1、概述熟悉android开发的都会了解到Android的xUtils框架的ViewUtils模块,简化了findViewById的编写,通过完全注解方式就可以进行UI,资源和事件绑定。实现基本原理就...

基于java反射机制调用自定义类导致service注入失败的经验浅谈

基于java反射机制调用自定义类导致service注入失败的经验浅谈 使用场景:最近在做一个保费计算的方法,涉及到不同险种的计算,根据三方传来的request请求进行相应的保费计算。最开始用的方法...

java利用反射机制获取实体类属性自定义注解说明

最近做项目,需要利用java反射机制,获取实体类自定义注解的说明信息 1.自定义注解 package com.bjhy.platform.criminal.search.core.annotati...

注解_Annotation_内置注解_自定义注解_反射机制读取注解JAVA208-210

一、S02E208_01注解_Annotation、内置注解二、S02E209_01自定义注解三、S02E210_01反射机制读取注解...

(小工具)Java反射机制实现任意对象集合按指定任意字段进行分组通用程序实践

在应用开发的时候,我们有时候会遇到需要对一个给定集合进行分组的情况。如果该集合的数据记录是从数据库的获取,通常我们最简单的方案是直接在sql层面select后group by完成。 但是,假如某些场景...

java自定义注解和运行时靠反射机制获取注解

java自定义注解:java注解是附加在代码上的一些元信息,用于一些工具在编译,运行时进行解析和使用,起到说明配置的功能。注解不会也不能影响代码的实际逻辑,只起到辅助的作用,包含在java.lang....

Java反射机制,Java注解,利用Java反射调用类方法,自定义Java注解

1、介绍Java反射机制和Java注解 2、利用Java反射调用类方法 3、实例讲解:自定义Java注解...

Android基于Java反射机制的简单ORM-Dao层

无需配置,但需要按照一定的规则写POJO。 规则: ①基础类型只能使用short,int,long,float,double,String。 ②表名需与类名相同。 ③表的属性名需与类成员变量名相同。 ...

java反射机制编写简单万能DAO类

由于在搭建编写万能DAO时,已经写了大量的代码 在此只给出部分的测试源码 如有需要完整项目或者有任何建议联系973639421 package com.oman.bean; public clas...

Java反射机制在DAO层的应用实例

用反射机制实现对数据库数据的增、查例子 基本原理;保存数据时,把需要保存的对象的属性值全部取出来再拼凑sql语句 查询时,将查询到的数据全部包装成一个java对象。 游戏规则:俗话说的好,...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java基于自定义注释和反射机制实现初级通用DAO
举报原因:
原因补充:

(最多只允许输入30个字)