java 利用注解实现BaseDao 增删查改

第一步，编写两个注解类，用于表明实体类对应的表名及字段。

TableInfo.java    此注解用于标注表名及主键名

import static java.lang.annotation.ElementType.TYPE;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/*
 * TableName对应表名称
 * PrimaryKey对应主键字段名
 */
@Target({TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface TableInfo {

    public String TableName();
    public String PrimaryKey();
    
}

ColumnInfo.java  此注解用于标注实体类字段对应表字段

import static java.lang.annotation.ElementType.FIELD;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/*
 * 用于标识表字段名
 */
@Target({FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ColumnInfo {
    String columnName(); 
}

第二步：编写一个实体类，并注明好注解

import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.Date;

import annotation.ColumnInfo;
import annotation.TableInfo;


/*
 * 
 */
@TableInfo(TableName = "student", PrimaryKey = "id")
public class Student {
    @ColumnInfo(columnName="id")
    private int sid;
    @ColumnInfo(columnName="sname")
    private String sname;
    @ColumnInfo(columnName="sclass")
    private int sclass;
    @ColumnInfo(columnName="startdate")
    private Date startdate;
    @ColumnInfo(columnName="stopdate")
    private Date stopdate;
    
    public Date getStopdate() {
        return stopdate;
    }
    public void setStopdate(Date stopdate) {
        this.stopdate = stopdate;
    }
    public Date getStartdate() {
        return startdate;
    }
    public void setStartdate(Date startdate) {
        this.startdate = startdate;
    }
    
    public int getSid() {
        return sid;
    }
    public void setSid(int sid) {
        this.sid = sid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
    public int getSclass() {
        return sclass;
    }
    public void setSclass(int sclass) {
        this.sclass = sclass;
    }
    @Override
    public String toString() {
        return "Student [id=" + sid + ", sname=" + sname + ", sclass=" + sclass
                + ", startdate=" + startdate + ", stopdate=" + stopdate + "]
";
    }
}

第三部：编写BaseDao.java（对数据库的操作基于c3p0组件）

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;

import annotation.ColumnInfo;
import annotation.TableInfo;

import fnz.utils.JdbcUtil2;

public class BaseDao<T> {
    
    private Class clazz; //类的字节码文件
    private String tableName;//表明
    private String primaryKey;//主键
    private Field[] fields;//所有的字段
    public BaseDao(){
        Type type = this.getClass().getGenericSuperclass();//当前运行类的父类，即为“BaseDao<实体类>”，其实就是“参数化类型”ParameterizedType
        ParameterizedType pt = (ParameterizedType)type;// 强制转换为“参数化类型”  BaseDao<实体类>
        Type types[] = pt.getActualTypeArguments(); // 获取“参数化类型”中的实体类
        clazz = (Class)types[0];
        //tableName = clazz.getSimpleName();//获取类名（不带包名）
        TableInfo tab = (TableInfo)clazz.getAnnotation(TableInfo.class);
        tableName = tab.TableName();
        primaryKey = tab.PrimaryKey();
        fields = clazz.getDeclaredFields();
    }
    
    
    /**
     * 主键查询
     * @param id    主键值
     * @return      返回封装后的对象
     * @throws SQLException 
     */
    public T getOne(Object id){
        try {
            return JdbcUtil2.getQueryRunner().query("select * from "+tableName+" where "+ primaryKey+" = ?", new MBeanHandler<T>(clazz,mMethod.SELECT),id);
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    
    /**
     * 查询全部
     * @return 返回所有记录，封装成List<T>
     * @throws SQLException 
     */
    public List<T> getAll(){
        try {
            return JdbcUtil2.getQueryRunner().query("select * from "+tableName, new MBeanListHandler<T>(clazz));
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    /**
     * 保存
     * @param t 要保存的实体对象
     * @return 保存后的对象
     */
    public T baseSave(T t){
        try{
            List<Object> params = new ArrayList<Object>();
            for (int i = 0; i < fields.length; i++) {
                fields[i].setAccessible(true);//强制是有字段也可以访问
                params.add(fields[i].get(t));
            }
            //sql拼接
            StringBuilder sql = new StringBuilder();
            sql.append("insert into "+tableName+"(");
            for (int j = 0; j < fields.length; j++) {
                String fieldName = fields[j].getAnnotation(ColumnInfo.class).columnName();//获取表字段名
                if(j == fields.length-1){
                    sql.append(fieldName+")");
                }else{
                    sql.append(fieldName+",");
                }
            }
            sql.append(" values(");
            for (int k = 0; k < fields.length; k++) {
                if(k == fields.length-1){
                    sql.append("?)");
                }else{
                    sql.append("?,");
                }
            }
            
            JdbcUtil2.getQueryRunner().insert(sql.toString()
                    ,new MBeanHandler<T>(clazz,mMethod.INSERT)
                    ,params.toArray());
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
        return t;
    }
    
    /**
     * 执行更新
     * @param t 更新对象
     * @return
     */
    public T baseUpdate(T t){
        try{
            List<Object> params = new ArrayList<Object>();
            Object idParam = null;
            for (int i = 0; i < fields.length; i++) {
                fields[i].setAccessible(true);//强制是有字段也可以访问
                if(!primaryKey.equals(fields[i].getAnnotation(ColumnInfo.class).columnName())){
                    params.add(fields[i].get(t));
                }else{
                    idParam = fields[i].get(t);
                }
            }
            params.add(idParam);//id为最后一个参数
            //sql拼接
            StringBuilder sql = new StringBuilder();
            sql.append("update "+tableName+" set");
            String strWhere = "";
            for (int j = 0; j < fields.length; j++) {
                String fieldName = fields[j].getAnnotation(ColumnInfo.class).columnName();//获取表字段名
                if(!fieldName.equals(primaryKey)){
                    sql.append(" "+fieldName+"=?,");
                }else if(fieldName.equals(primaryKey)){
                    strWhere = " where "+primaryKey+"=?";
                }
            }
            int idx = sql.lastIndexOf(",");
            sql = sql.replace(idx, idx+1, "");
            sql.append(strWhere);
            
            JdbcUtil2.getQueryRunner().update(sql.toString(),params.toArray());
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
        return t;
    }
    
    /**
     * 根据主键删除
     * @param id 主键id
     * @return
     */
    public Boolean baseDelete(Object id){
        try{
            JdbcUtil2.getQueryRunner().update("delete from "+tableName+" where "+primaryKey+"=?",id);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
        return true;
    }
    
}

enum mMethod{
    SELECT,
    INSERT,
    UPDATE
}
/**
 * 自定义结果集：封装单个Bean对象
 * @author fnz
 *
 * @param <T>
 */
class MBeanHandler<T> implements ResultSetHandler<T>{
    private mMethod method;
    private Class<T> clazz;
    public MBeanHandler(Class<T> clazz,mMethod method){
        this.clazz = clazz;
        this.method = method;
    }
    
    public T handle(ResultSet rs) throws SQLException {
        try {
            if(this.method == mMethod.SELECT){
                if(rs.next()){
                    T tobj = clazz.newInstance();
                    Field[] fields = clazz.getDeclaredFields();//获取到所有的
                    for (Field field : fields) {
                        ColumnInfo col = field.getAnnotation(ColumnInfo.class);//获取实体类字段上的注解ColumnInfo
                        String colName = col.columnName();//得到 实体类字段 对应 表的字段名
                        //获取表字段的值
                        rs.findColumn(colName);
                        Object value = rs.getObject(colName);
                        //封装对象
                        field.setAccessible(true);
                        field.set(tobj, value);
                    }
                    return tobj;
                }
            }else{
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
        return null;
    }
}
/**
 * 自定义结果集：封装多个Bean对象
 * @author fnz
 *
 * @param <T>
 */
class MBeanListHandler<T> implements ResultSetHandler<List<T>>{
    // 保存传入的要封装的类的字节码
    private Class<T> clazz;
    public MBeanListHandler(Class<T> clazz) {
        this.clazz = clazz;
    }
    // 封装结果集的方法
    public List<T> handle(ResultSet rs) throws SQLException {
        try {
            List<T> list = new ArrayList<T>();
            // 向下读一行
            while(rs.next()){
                T tobj = clazz.newInstance();
                Field[] fields = clazz.getDeclaredFields();//获取到所有的
                for (Field field : fields) {
                    ColumnInfo col = field.getAnnotation(ColumnInfo.class);//获取实体类字段上的注解ColumnInfo
                    String colName = col.columnName();//得到 实体类字段 对应 表的字段名
                    //获取表字段的值
                    Object value = rs.getObject(colName);
                    //封装对象
                    field.setAccessible(true);
                    field.set(tobj, value);
                }
                list.add(tobj);
            }
            return list;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

C3P0配置文件

<c3p0-config>
  <!-- 默认加载配置 -->
  <default-config>
     <property name="driverClass">com.mysql.jdbc.Driver</property> 
     <property name="jdbcUrl">jdbc:mysql://localhost:3306/test01</property> 
     <property name="user">root</property> 
     <property name="password">123456</property> 
     <property name="initialPoolSize">5</property> 
     <property name="maxPoolSize">10</property> 
  </default-config>
  <!-- 指定名称加载配置 -->
  <named-config name="C3P0TestName">
    <property name="driverClass">com.mysql.jdbc.Driver</property> 
     <property name="jdbcUrl">jdbc:mysql://localhost:3306/test01</property> 
     <property name="user">root</property> 
     <property name="password">123456</property> 
     <property name="initialPoolSize">5</property> 
     <property name="maxPoolSize">10</property> 
  </named-config>
  
</c3p0-config>

JdbcUtil2.java（上面的BaseDao.java用到的工具类）

import java.sql.Connection;
import org.apache.commons.dbutils.QueryRunner;

import com.mchange.v2.c3p0.ComboPooledDataSource;


public class JdbcUtil2 {
    private static ComboPooledDataSource dataSource = null;
    static{
        //初始化操作
        // 自动加载src目录下c3p0的配置文件【c3p0-config.xml】
        dataSource = new ComboPooledDataSource();// 使用默认的配置
        //使用c3p0-config.xml配置文件中named-config的name属性为C3P0TestName的配置
        //dataSource = new ComboPooledDataSource("C3P0TestName");
    }
    
    //获取QueryRunner对象
    public static QueryRunner getQueryRunner(){
        return new QueryRunner(dataSource);
    }
    //获取连接 通过c3p0核心类对象获取(此例子没用到该方法)
    public static Connection getConnection(){
        try {
            return dataSource.getConnection();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
}

最后：简单编写一下测试类

StudentDao继承BaseDao

　　@Test
    public void test6(){
        StudentDao dao = new StudentDao();
        Student s = dao.getOne(1);
        System.out.println(s);
    }

输出结果：Student [id=1, sname=张三, sclass=1, startdate=2016-09-22 00:00:00.0, stopdate=2016-09-23]

over