基于ejb3,对JDBC进行封装,让使用JDBC时能像hibernate使用annotation注解一样简便,而且更加轻巧

　　为了方便阅读,必须对Java的泛型和反射有一定的了解,以及hibernate的annotation注解使用有一定的了解,因为这个封装就是对hibernate的部分功能的模仿,虽然性能不像hibernate那样齐全,但至少能让JDBC的使用变得十分简便,而且让项目跑起来变得十分轻巧,开发变得更加的简便,少去的市面上部分半自动的ORM框架还要配置文件的烦恼

　　ejb3的sun后期根据市面上多种多样的框架的出现后提供的一个标准导致后来许多的框架都是基于这个标准更新和编写的,像我们常用的三大框架,所以我们现在也基于ejb3提供的注解,对JDBC进行简单的封装,下面就是对封装的步骤的说明和使用的演示

　　首先模仿hibernate通过annotation注解让实体类和数据库的表和字段进行映射:

　　这是一个User的实体类代码,通过@Table 注解让其对数据库的一张名字为TEST_USER形成映射,@Id 注解表明此成员变量与TEST_USER的主键形成映,@Column 注解表明此成员变量与TEST_USER表对应哪个字段

package com.po;

import java.util.Date;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;


/**
 * @author LinBingcheng<494410479@qq.com>
 * @date 2014年7月31日
 * @CopyRight 2014 Topview Inc
 * @version v1.0
 */
@Table(name = "TEST_USER")
public class User {

    private String id;
    private String name;
    private Date date;
    private Info info;
    private List<Book> books;
    private List<Role> roles;

    @Id
    @Column(name = "ID")
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Column(name = "USERNAME")
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Column(name = "DATE")
    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    @OneToOne(targetEntity = Info.class, mappedBy = "USER_ID")
    // 关联的表的实体类,主键所对应的外键的名字
    public Info getInfo() {
        return info;
    }

    public void setInfo(Info info) {
        this.info = info;
    }

    @OneToMany(targetEntity = Book.class, mappedBy = "USER_ID")
    //关联的表的实体类,主键所对应的外键的名字
    public List<Book> getBooks() {
        return books;
    }

    public void setBooks(List<Book> books) {
        this.books = books;
    }
    
    @ManyToMany(targetEntity=Role.class)
    @JoinTable(name="USER_ROLE",
    joinColumns={@JoinColumn(name="USER_ID")},
    inverseJoinColumns={@JoinColumn(name="ROLE_ID")})
    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", date=" + date
                + ", info=" + info + ", books=" + books + ", roles=" + roles
                + "]";
    }


}

　　这是一个Info的实体类,通过上面可以看出他与数据库的TEST_INFO表形成映射了,在这里有@OneToOne 注解,这个说明了这张表与数据库的另外一张表形成一对一的关联关系,同样在上面的Uer表也存在一个@OneToOne 注解,而且这两个注解的 targetEntity 属性是相互对应的,说明这两张表两两关联,形成一对一的关联关系,mappedBy属性著名相互关联的外键,标有@JoinColumn 注解的是副表 没有这个@JoinColumn注解的是主表,@JoinColumn里面是副表关联主表的字段

package com.po;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;

@Table(name = "TEST_INFO")
public class Info {

    private String id;
    private String info;
    private User user;

    @Id
    @Column(name = "ID")
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Column(name = "INFO")
    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    @OneToOne(targetEntity = User.class, mappedBy = "ID")//外键的表和外键在另外一张表的字段
    @JoinColumn(name = "USER_ID")
    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    @Override
    public String toString() {
        return "Info [id=" + id + ", info=" + info + ", user=" + user + "]";
    }
    

}

　　这个类里面有个@ManyToOne 的注解,与这个对应的是User表里面的@OneToMany的注解,标志这个注解,说明这两张表是多对一关联的,这两个注解的 targetEntity 属性也是是相互对应的

package com.po;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Table(name = "TEST_BOOK")
public class Book {

    private String id;
    private String bookName;
    private User user;

    @Id
    @Column(name = "ID")
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Column(name = "BOOK_NAME")
    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    @ManyToOne(targetEntity=User.class)//关联的表的名字
    @JoinColumn(name="USER_ID")
    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    @Override
    public String toString() {
        return "Book [id=" + id + ", bookName=" + bookName + ", user=" + user
                + "]";
    }
    
    

}

　　这个实体类里面有个@ManyToMany 的注解,对应的User实体类也有,targetEntity 属性是相互对应的,表明这两张表相互之间是多对多是关系,@JoinTable 注解是中间表解释,利用这个注解内部可以实现多对多关联查询,name 属性是中间关联表的名字,joinColumns 是此表在关联表中对应的字段 inverseJoinColumns 是关联的另一张表对应在中间表的字段

package com.po;

import java.util.List;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Table(name="TEST_ROLE")
public class Role {

    private int id;
    private String role;
    private List<User> users;
    
    public Role() {
    }
    
    public Role(int id,String role) {
        this.id = id;
        this.role = role;
    }

    @Id
    @Column(name="ID")
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Column(name="ROLE")
    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }

    @ManyToMany(targetEntity=User.class)
    @JoinTable(name="USER_ROLE",
    joinColumns={@JoinColumn(name="ROLE_ID")},
    inverseJoinColumns={@JoinColumn(name="USER_ID")})
    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }

    @Override
    public String toString() {
        return "Role [id=" + id + ", role=" + role + ", users=" + users + "]";
    }

}

以上这些注解都是由ejb3-persistence.jar提供

　　以上是在实体类中的对ejb3提供的注释的用法,接下来就是对JDBC的封装了,利用泛型和反射我们要做的就是实现一个基类BaseDao.Java,让所有继承了这个基类的导出类都能拥有对应的增删查改,下面这个基类就是我针对JDBC结合ejb3做的封装,目地就是为了让JDBC的使用变得更加简便,不再只是面向过程,代码中已经提供了对外接口的注释

package com.topview.dao;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;


/**
 * Dao层的抽象父类，已对JDBC进行了一定的封装
 * @author LinBingcheng<494410479@qq.com>
 * @date 2014年7月29日
 * @CopyRight 2014 Topview Inc
 * @version v2.0
 */
public class BaseDao<T> {

    private Connection connection;
    
    
    /**
     * 数据添加,删除,修改
     * @param sql 需要执行的SQL语句
     * @param params SQL语句对应的参数
     * @return 操作成功：true<br/>
     *         操作失败：false
     * @throws Exception
     */
    public boolean executeUpdate(String sql, Object... params) throws Exception {
        PreparedStatement pstmt = null;
        pstmt = connection.prepareStatement(sql);
        for (int i = 0; i < params.length; i++) {
            pstmt.setObject(i + 1, params[i]);
        }
        pstmt.executeUpdate();
        pstmt.close();
        return true;
    }
    
    /**
     * 数据添加
     * @param entity 泛型的实体类对象
     * @return 添加成功：true<br/>
     *         添加失败：false
     * @throws Exception 
     */
    public boolean add(T entity) throws Exception {
        int i = 1;
        PreparedStatement pstmt = null;
        String insetSql = "INSERT INTO " + getTableName(entity) + " (";
        String valueSql = "VALUES (";
        Map<String, Object> name_value = new HashMap<String, Object>();
        name_value.putAll(getName_ValuesOfColumn(entity));
        name_value.putAll(getName_EntityIdOfJoinColumn(entity));
        for (String name : name_value.keySet()) {
            insetSql = insetSql + name + ",";
            valueSql = valueSql + "?,";
        }
        insetSql = insetSql.substring(0, insetSql.length() - 1) + ")"
                + valueSql.substring(0, valueSql.length() - 1) + ")";
        System.out.println("insetSql:" + insetSql);
        pstmt = connection.prepareStatement(insetSql);
        for (String name : name_value.keySet()) {
            pstmt.setObject(i++, name_value.get(name));
        }
        pstmt.executeUpdate();
        pstmt.close();
        insetJoinTable(entity);
        return true;
    }
    
    /**
     * 数据删除
     * @param entity 实体类对象,内部存放着需要进行删除匹配的数据,其他的不用
     * @return 删除成功：true<br/>
     *         删除失败：false
     * @throws Exception 
     */
    public boolean delete(T entity) throws Exception {
        int i = 0;
        String deleteSql = "DELETE FROM " + getTableName(entity);
        String where = " WHERE";
        PreparedStatement pstmt = null;
        Map<String, Object> name_value = new HashMap<String, Object>();
        Object entityId = getEntityId(entity);
        name_value.putAll(getName_ValuesOfColumn(entity));
        name_value.putAll(getName_EntityIdOfJoinColumn(entity));
        for (String name : name_value.keySet()) {
            if (name_value.get(name).equals(entityId) && entityId != null) {
                where = where + " " + name + " = ?";
                i = 1;
                break;
            }
        }
        if (i == 0) {
            for (String name : name_value.keySet()) {
                if (name_value.get(name) != null) {
                    where = where + " " + name + " = ? AND";
                }
            }
            where = where.substring(0, where.length() - 3);
        }
        deleteSql = deleteSql + where;
        System.out.println("deleteSql:" + deleteSql);
        pstmt = connection.prepareStatement(deleteSql);
        if (i == 1) {
            pstmt.setObject(i, entityId);
        } else {
            i = 1;
            for (String name : name_value.keySet()) {
                pstmt.setObject(i++, name_value.get(name));
            }
        }
        pstmt.executeUpdate();
        pstmt.close();
        return true;
    }
    
    /**
     * 数据修改
     * @param entity 实体类对象
     * @return    修改成功：true<br/>
     *          修改失败：false
     * @throws Exception
     */
    public boolean update(T entity) throws Exception {
        int i = 1;
        String updateSql = "UPDATE " + getTableName(entity) + " SET ";
        String where = " WHERE";
        PreparedStatement pstmt = null;
        Map<String, Object> name_value = new HashMap<String, Object>();

        Object entityId = getEntityId(entity);
        name_value.putAll(getName_ValuesOfColumn(entity));
        name_value.putAll(getName_EntityIdOfJoinColumn(entity));
        for (String name : name_value.keySet()) {
            if (name_value.get(name).equals(entityId)) {
                where = where + " " + name + " = ?";
            } else {
                updateSql = updateSql + " " + name + " = ? ,";
            }
        }
        updateSql = updateSql.substring(0, updateSql.length() - 1);
        updateSql = updateSql + where;
        System.out.println("updateSql:" + updateSql);
        pstmt = connection.prepareStatement(updateSql);
        for (String name : name_value.keySet()) {
            if (!name_value.get(name).equals(entityId)) {
                pstmt.setObject(i++, name_value.get(name));
            }
        }
        pstmt.setObject(i, entityId);
        pstmt.executeUpdate();
        pstmt.close();

        return true;
    }


    /**
     * 数据查询
     * @param object 实体类对象
     * @return 查询到的List
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    public List<T> find(T object) throws Exception {
        int i = 1;
        List<T> list = new ArrayList<T>();
        PreparedStatement pstmt = null;
        ResultSet re = null;
        String findSql = "SELECT * FROM " + getTableName(object) + " WHERE";
        String where = "";
        Map<String, Object> name_value = new HashMap<String, Object>();
        Map<String, Object> name_entityId = getName_EntityIdOfJoinColumn(object);
        name_value.putAll(getName_ValuesOfColumn(object));
        name_value.putAll(name_entityId);
        for (String name : name_value.keySet()) {
            if (name_value.get(name) != null) {
                where = where + " " + name + " = ? AND";
            }
        }
        if (where.length() != 0) {
            where = where.substring(0, where.length() - 3);
            findSql = findSql + where;
        } else {
            findSql = findSql.substring(0, findSql.length() - 5);
        }
        System.out.println("findSql:" + findSql);
        pstmt = connection.prepareStatement(findSql);
        for (String name : name_value.keySet()) {
            if (name_value.get(name) != null) {
                pstmt.setObject(i++, name_value.get(name));
            }
        }
        re = pstmt.executeQuery();
        while (re.next()) {
            Object o = object.getClass().newInstance();
            Map<String, Field> name_fields = getName_FieldsOfColumn(o);
            for (String name : name_fields.keySet()) {
                Field field = name_fields.get(name);
                field.setAccessible(true);
                field.set(o, re.getObject(name));
            }
            setOneToManyMap(o);
            for (String cloumnName : name_entityId.keySet()) {
                setOneToOneMap(o, cloumnName, re.getObject(cloumnName));
                setManyToOneMap(o, cloumnName, re.getObject(cloumnName));
            }
            setManyToManyMap(o);
            list.add((T) o);
        }
        re.close();
        pstmt.close();
        return list;
    }
    
    
    /**
     * 数据查询,可添加模糊,分页查询操作
     * @param object 实体类对象
     * @param conditionSQL 进行模糊查询和分页操作的的SQL语句,
     * @param params 进行模糊查询和分页操作的参数
     * @return 查询到的List
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    public List<T> SQLQuery(T object, String conditionSQL, Object... params)
            throws Exception {
        int i = 1;
        List<T> list = new ArrayList<T>();
        PreparedStatement pstmt = null;
        ResultSet re = null;
        String findSql = "SELECT * FROM " + getTableName(object) + " WHERE";
        String where = "";
        Map<String, Object> name_value = new HashMap<String, Object>();
        Map<String, Object> name_entityId = getName_EntityIdOfJoinColumn(object);
        name_value.putAll(getName_ValuesOfColumn(object));
        name_value.putAll(name_entityId);
        for (String name : name_value.keySet()) {
            if (name_value.get(name) != null) {
                where = where + " " + name + " = ? AND";
            }
        }
        if (where.length() != 0) {
            where = where.substring(0, where.length() - 3);
            findSql = findSql + where;
        } else {
            findSql = findSql.substring(0, findSql.length() - 5);
        }
        findSql = findSql + conditionSQL;
        System.out.println("findSql" + findSql);
        pstmt = connection.prepareStatement(findSql);
        for (String name : name_value.keySet()) {
            if (name_value.get(name) != null) {
                pstmt.setObject(i++, name_value.get(name));
            }
        }

        for (Object o : params) {
            pstmt.setObject(i++, o);
        }

        re = pstmt.executeQuery();
        while (re.next()) {
            Object o = object.getClass().newInstance();
            Map<String, Field> name_fields = getName_FieldsOfColumn(o);
            for (String name : name_fields.keySet()) {
                Field field = name_fields.get(name);
                field.setAccessible(true);
                field.set(o, re.getObject(name));
            }
            setOneToManyMap(o);
            for (String cloumnName : name_entityId.keySet()) {
                setOneToOneMap(o, cloumnName, re.getObject(cloumnName));
                setManyToOneMap(o, cloumnName, re.getObject(cloumnName));
            }
            setManyToManyMap(o);
            list.add((T) o);
        }
        re.close();
        pstmt.close();
        return list;
    }

    private List<Object> query(Class<?> clazz, String findSql, Object... params)
            throws InstantiationException, IllegalAccessException,
            SQLException, NoSuchFieldException, SecurityException {
        int i = 1;
        List<Object> list = new ArrayList<Object>();
        PreparedStatement pstmt = null;
        ResultSet re = null;
        pstmt = connection.prepareStatement(findSql);
        for (Object object : params) {
            pstmt.setObject(i++, object);
        }
        re = pstmt.executeQuery();
        while (re.next()) {
            Object o = clazz.newInstance();
            Map<String, Field> name_fields = getName_FieldsOfColumn(o);
            for (String name : name_fields.keySet()) {
                Field field = name_fields.get(name);
                field.setAccessible(true);
                field.set(o, re.getObject(name));
            }
            list.add(o);
        }
        re.close();
        params.clone();
        return list;
    }
    
    private void setOneToOneMap(Object object, String cloumnName, Object value)
            throws NoSuchFieldException, SecurityException,
            InstantiationException, IllegalAccessException, SQLException,
            IllegalArgumentException, InvocationTargetException {
        Method[] methods = object.getClass().getDeclaredMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(OneToOne.class)
                    && !method.isAnnotationPresent(JoinColumn.class)) {
                OneToOne oneToOne = method.getAnnotation(OneToOne.class);
                Class<?> clazz = oneToOne.targetEntity();
                String mappedBy = oneToOne.mappedBy();
                Object o = clazz.newInstance();
                String findSql = "SELECT * FROM " + getTableName(o) + " WHERE "
                        + mappedBy + " = ?";
                // System.out.println("findSql" + findSql);
                List<?> list = query(clazz, findSql, getEntityId(object));
                if (!list.isEmpty() && list != null) {
                    o = query(clazz, findSql, getEntityId(object)).get(0);
                    StringBuffer s = new StringBuffer(method.getName()
                            .toString());
                    String fieldsName = s.substring(3).toLowerCase();
                    Field field = object.getClass()
                            .getDeclaredField(fieldsName);
                    field.setAccessible(true);
                    field.set(object, o);
                }
            }
            if (method.isAnnotationPresent(OneToOne.class)
                    && method.getAnnotation(JoinColumn.class).name()
                            .equals(cloumnName)) {
                OneToOne oneToOne = method.getAnnotation(OneToOne.class);
                Class<?> clazz = oneToOne.targetEntity();
                String mappedBy = oneToOne.mappedBy();
                Object o = clazz.newInstance();
                String findSql = "SELECT * FROM " + getTableName(o) + " WHERE "
                        + mappedBy + " = ?";
                // System.out.println("findSql:" + findSql);
                List<?> list = query(clazz, findSql, value);
                if (!list.isEmpty() && list != null) {
                    o = list.get(0);
                    StringBuffer s = new StringBuffer(method.getName()
                            .toString());
                    String fieldsName = s.substring(3).toLowerCase();
                    Field field = object.getClass()
                            .getDeclaredField(fieldsName);
                    field.setAccessible(true);
                    field.set(object, o);
                }
            }
        }
    }

    private void setOneToManyMap(Object object) throws InstantiationException,
            IllegalAccessException, NoSuchFieldException, SecurityException,
            SQLException, IllegalArgumentException, InvocationTargetException {
        Method[] methods = object.getClass().getDeclaredMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(OneToMany.class)
                    && !method.isAnnotationPresent(JoinColumn.class)) {
                OneToMany oneToMany = method.getAnnotation(OneToMany.class);
                Class<?> clazz = oneToMany.targetEntity();
                String mappedBy = oneToMany.mappedBy();
                Object o = clazz.newInstance();
                String findSql = "SELECT * FROM " + getTableName(o) + " WHERE "
                        + mappedBy + " = ?";
                // System.out.println("findSql:" + findSql);
                o = query(clazz, findSql, getEntityId(object));
                StringBuffer s = new StringBuffer(method.getName().toString());
                String fieldsName = s.substring(3).toLowerCase();
                Field field = object.getClass().getDeclaredField(fieldsName);
                field.setAccessible(true);
                field.set(object, o);
            }
        }
    }
    
    private void setManyToOneMap(Object object, String cloumnName, Object value)
            throws InstantiationException, IllegalAccessException,
            NoSuchFieldException, SecurityException, SQLException {
        Method[] methods = object.getClass().getDeclaredMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(ManyToOne.class)
                    && method.isAnnotationPresent(JoinColumn.class)
                    && method.getAnnotation(JoinColumn.class).name()
                            .equals(cloumnName)) {
                ManyToOne manyToOne = method.getAnnotation(ManyToOne.class);
                Class<?> clazz = manyToOne.targetEntity();
                Object o = clazz.newInstance();
                String mappedByColumn = getEntityIdColumn(object);
                String findSql = "SELECT * FROM " + getTableName(o) + " WHERE "
                        + mappedByColumn + " = ?";
//                System.out.println("findSql:" + findSql);
                o = query(clazz, findSql, value).get(0);
                StringBuffer s = new StringBuffer(method.getName().toString());
                String fieldsName = s.substring(3).toLowerCase();
                Field field = object.getClass().getDeclaredField(fieldsName);
                field.setAccessible(true);
                field.set(object, o);
            }
        }
    }


    private void setManyToManyMap(Object object) throws SQLException,
            InstantiationException, IllegalAccessException,
            NoSuchFieldException, SecurityException, IllegalArgumentException,
            InvocationTargetException {
        Method[] methods = object.getClass().getDeclaredMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(ManyToMany.class)
                    && method.isAnnotationPresent(JoinTable.class)) {
                ManyToMany manyToMany = method.getAnnotation(ManyToMany.class);
                JoinTable joinTable = method.getAnnotation(JoinTable.class);
                List<Object> list = new ArrayList<Object>();
                Class<?> clazz = manyToMany.targetEntity();
                Object o = clazz.newInstance();
                String joinTableName = joinTable.name();
                String JoinColumnName = joinTable.joinColumns()[0].name();
                String inverseJoinColumnsName = joinTable.inverseJoinColumns()[0]
                        .name();
                Object JoinColumnValue = getEntityId(object);
                String findMapSql = "SELECT * FROM " + joinTableName
                        + " WHERE " + JoinColumnName + " = ?";
                // System.out.println("findMapSql" + findMapSql);
                String findSql = "SELECT * FROM " + getTableName(o) + " WHERE "
                        + getEntityIdColumn(o) + " = ?";
                // System.out.println("findSql:" + findSql);
                PreparedStatement pstmt = connection
                        .prepareStatement(findMapSql);
                pstmt.setObject(1, JoinColumnValue);
                ResultSet re = pstmt.executeQuery();
                while (re.next()) {
                    list.add(query(clazz, findSql,
                            re.getObject(inverseJoinColumnsName)));
                }
                StringBuffer s = new StringBuffer(method.getName().toString());
                String fieldsName = s.substring(3).toLowerCase();
                Field field = object.getClass().getDeclaredField(fieldsName);
                field.setAccessible(true);
                field.set(object, list);
                re.close();
                pstmt.close();
            }
        }
    }

    @SuppressWarnings("unchecked")
    private void insetJoinTable(Object object) throws SQLException,
            IllegalAccessException, IllegalArgumentException,
            InvocationTargetException {
        Object JoinColumnValue = getEntityId(object);
        Method[] methods = object.getClass().getDeclaredMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(JoinTable.class)) {
                if (method.invoke(object) != null) {
                    JoinTable joinTable = method.getAnnotation(JoinTable.class);
                    String joinTableName = joinTable.name();
                    String JoinColumnName = joinTable.joinColumns()[0].name();
                    String inverseJoinColumnsName = joinTable
                            .inverseJoinColumns()[0].name();
                    String insertSql = "INSERT INTO " + joinTableName + " ("
                            + JoinColumnName + ", " + inverseJoinColumnsName
                            + ")" + "VALUES (?, ?)";
//                    System.out.println("insertSql:" + insertSql);
                    Collection<Object> collection = (Collection<Object>) method
                            .invoke(object);
                    for (Object o : collection) {
                        PreparedStatement pstmt = connection
                                .prepareStatement(insertSql);
                        Object inverseJoinColumnsValue = getEntityId(o);
                        pstmt.setObject(1, JoinColumnValue);
                        pstmt.setObject(2, inverseJoinColumnsValue);
                        pstmt.executeUpdate();
                        pstmt.close();
                    }
                }
            }
        }
    }
    
    


    private String getEntityIdColumn(Object object){
        Method[] methods = object.getClass().getDeclaredMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(Id.class)) {
                Column column = method.getAnnotation(Column.class);
                return column.name();
            }
        }
        return null;
    }
    
    

    private Map<String, Object> getName_EntityIdOfJoinColumn(Object object)
            throws IllegalAccessException, IllegalArgumentException,
            InvocationTargetException {
        Map<String, Object> name_id = new HashMap<String, Object>();
        Method[] methods = object.getClass().getDeclaredMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(JoinColumn.class)) {
                JoinColumn joinColumn = method.getAnnotation(JoinColumn.class);
                String column = joinColumn.name();
                Object entity = method.invoke(object);
                Object entityId = getEntityId(entity);
                name_id.put(column, entityId);
            }
        }
        return name_id;
    }
    
    private Map<String, Field> getName_FieldsOfColumn(Object object)
            throws NoSuchFieldException, SecurityException {
        Map<String, Field> name_fields = new HashMap<String, Field>();
        Method[] methods = object.getClass().getDeclaredMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(Column.class)) {
                Column column = method.getAnnotation(Column.class);
                String name = column.name();
                StringBuffer s = new StringBuffer(method.getName().toString());
                String fieldsName = s.substring(3, 4).toLowerCase()
                        + s.substring(4);
                Field field = object.getClass().getDeclaredField(fieldsName);
                name_fields.put(name, field);
            }
        }
        return name_fields;
    }
    
    private Map<String, Object> getName_ValuesOfColumn(Object object)
            throws IllegalAccessException, IllegalArgumentException,
            InvocationTargetException {
        Map<String, Object> name_value = new HashMap<String, Object>();
        Method[] methods = object.getClass().getDeclaredMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(Column.class)) {
                Column column = method.getAnnotation(Column.class);
                String columnName = column.name();
                Object columnValue = method.invoke(object);
                name_value.put(columnName, columnValue);
            }
        }
        return name_value;
    }
    
    private Object getEntityId(Object object) throws IllegalAccessException,
            IllegalArgumentException, InvocationTargetException {
        if (object != null) {
            Method[] methods = object.getClass().getDeclaredMethods();
            for (Method method : methods) {
                if (method.isAnnotationPresent(Id.class)) {
                    return method.invoke(object);
                }
            }
        }
        return null;
    }
    
    private String getTableName(Object object) {
        String name = null;
        if (object.getClass().isAnnotationPresent(Table.class)) {
            Table table = object.getClass().getAnnotation(Table.class);
            name = table.name();
        }
        if (name == null) {//此乃默认
            name = object.getClass().getName();
            int i = name.lastIndexOf(".");
            name = name.substring(i + 1).toUpperCase();
        }
        return name;
    }

    public Connection getConnection() {
        return connection;
    }

    public void setConnection(Connection connection) {
        this.connection = connection;
    }

}

        下面说明这个封装类的用法,数据库持久层的所有实现类只要直接继承这个BaseDao.java,泛型用对应是实体类代替,就算完成了,改类就已经有了相应的增删查改的功能,我们还可以根据需要继续对相应是实现类对已有的方法进行组合增加自己的对象都有的方法

　　下面就是我根据上面实体类添加的类的方法

package com.dao;

import java.util.List;

import com.po.User;

public class UserDao extends BaseDao<User> {

    /**
     * 查询一个用户
     * @param user 拥有对应的查询必备的条件
     * @return User对象
     * @throws Exception
     */
    public User getUser(User user) throws Exception {
        List<User> users = find(user);
        if (users == null || users.isEmpty())
            return null;
        return find(user).get(0);
    }

}

package com.dao;

import com.po.Info;

public class InfoDao extends BaseDao<Info> {

}

package com.dao;

import com.po.Book;

public class BookDao extends BaseDao<Book> {

}

package com.dao;

import com.po.Role;

public class RoleDao extends BaseDao<Role> {

}

　　下面是方法的测试演示

package com.test;

import java.lang.reflect.InvocationTargetException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Date;
import java.util.List;

import org.junit.Test;

import com.dao.BookDao;
import com.dao.InfoDao;
import com.dao.RoleDao;
import com.dao.UserDao;
import com.po.Book;
import com.po.Info;
import com.po.Role;
import com.po.User;
import com.service.UserService;
import com.service.impl.UserServiceImpl;
import com.util.DBManager;
import com.util.UUIDUtil;

public class MyTest {

    @Test
    public void testAddUser() throws SQLException {
        //测试添加
        try {
            Connection conn = DBManager.getConnection();
            UserDao userDao = new UserDao();
            userDao.setConnection(conn);
            User user = new User();
            for (int i = 0; i < 10; i++) {
                user.setId(UUIDUtil.getUUID());
                user.setName("测试" + i);
                user.setDate(new Date());
                userDao.add(user);
            }
            DBManager.close(conn);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Test
    public void testUpdateAndFindUser() {
        //测试修改和查找
        try {
            Connection conn = DBManager.getConnection();
            UserDao userDao = new UserDao();
            userDao.setConnection(conn);
            List<User> users = userDao.find(new User());//传空对象会全部查出来的,可任意set查找条件进去
            for (User user : users) {
                user.setName("ceshi");
                userDao.update(user);
            }
            DBManager.close(conn);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    
    @Test
    public void testDeleteAndGetUser(){
        //测试删除和查找
        try {
            Connection conn = DBManager.getConnection();
            UserDao userDao = new UserDao();
            userDao.setConnection(conn);
            User user = userDao.getUser(new User());
            userDao.delete(user);
            DBManager.close(conn);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    @Test
    public void testRelevanceInset(){
        // 测试一对一,多对一,多对多关联插入
        try {
            Connection conn = DBManager.getConnection();
            UserDao userDao = new UserDao();
            InfoDao infoDao = new InfoDao();
            RoleDao roleDao = new RoleDao();
            BookDao bookDao = new BookDao();
            userDao.setConnection(conn);
            infoDao.setConnection(conn);
            roleDao.setConnection(conn);
            bookDao.setConnection(conn);
            Info info = new Info();
            List<User> users = userDao.find(new User());//一对一关联插入
            for (User user : users) {
                info.setUser(user);
                info.setInfo("info");
                info.setId(UUIDUtil.getUUID());
                infoDao.add(info);
            }
            User user = userDao.getUser(new User());
            for (int i = 0; i < 10; i++) {//多对一关联插入
                Book book = new Book();
                book.setId(UUIDUtil.getUUID());
                book.setBookName("书名");
                book.setUser(user);
                bookDao.add(book);
            }
            List<Role> roles = roleDao.find(new Role(1,null));//多对多关联插入
            user.setId(UUIDUtil.getUUID());//主键不能一样
            user.setRoles(roles);
            userDao.add(user);
            DBManager.close(conn);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    @Test
    public void testRelevanceFind(){
        try {
            Connection conn = DBManager.getConnection();
            UserDao userDao = new UserDao();
            InfoDao infoDao = new InfoDao();
            RoleDao roleDao = new RoleDao();
            BookDao bookDao = new BookDao();
            userDao.setConnection(conn);
            infoDao.setConnection(conn);
            roleDao.setConnection(conn);
            bookDao.setConnection(conn);
            List<User> users = userDao.find(new User());
            for (User user : users) {
                System.out.println(user);
            }
            List<Info> infos = infoDao.find(new Info());
            for (Info info : infos) {
                System.out.println(info);
            }
            List<Role> roles = roleDao.find(new Role(1,null));
            for (Role role : roles) {
                System.out.println(role);
            }
            List<Book> books = bookDao.find(new Book());
            for (Book book : books) {
                System.out.println(book);
            }
            DBManager.close(conn);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

另外还有提供模糊查询和分页操作的接口,提供给使用扩展