注：这是一个“重复造*”的过程，本文简单地实现了一个ORM框架

最近Android工作实在难找，考虑是不是该转行做Java了，今天开始，花几天的事件，研究一下JavaEE各层优化。

本文介绍的是Dao的优化，目前，像是Hibernate、Mybatis等框架都属于ORM框架，ORM是关系映射的意思；

在我们使用这些框架的时候，我们都需要去写配置文件，类名对应于哪个表，成员变量对应于哪个列等等；

在这些框架工作的时候，要先读取这些配置文件，然后根据文件中的映射关系，帮我们动态地去拼接SQL，或者自动地将数据打包成JavaBean。

增删改方法封装

使用PreparedStatement执行一条Sql语句的流程如下：

1. 首先，Sql语句通常会有这么几种情况：
   ①更新语句：UPDATE accounts SET pwd=? WHERE (id=?)，
   ②插入语句：INSERT INTO accounts ( pwd, account, addTime) VALUES (?,?,?)
   ③删除语句：DELETE FROM accounts WHERE (id=？)
2. 有了这些Sql语句之后，我们会调用Connection.prepareStatement(sql)方法;
3. 然后依次调用PreparedStatement的set方法；
4. 最后执行executeUpdate()方法。

这个流程有几个共同的特点：

1. 这几个查询语句的执行结果都可以使用Boolean值表示；
2. 参数的设置，都是调用PreparedStatement的set方法，查看API，可以看到PreparedStatement有一个setObject()方法，因为参数是Object，也就是说，PreparedStatement的set方法都可以使用setObject()替代；

代码封装

根据上面的说法，就可以实现下面这样的封装，一个能执行任何增删改Sql语句的方法：

    protected boolean executeUpdates(String sql, Object... params) throws SQLException {

        pstmt = conn.prepareStatement(sql);

        for (int i = 0; i < params.length; i++) {

            pstmt.setObject(i + 1, params[i]);

        }

        return pstmt.executeUpdate() > 0;

    }

查询方法封装

查询语句之所以不同于其它方法，原因是有一个ResultSet需要返回，ResultSet是一个需要被关闭的对象，怎么处理ResultSet？

• 思路一：对ResultSet进行二次封装（目前我已经实现，代码相对复杂，这里就不具体展开，有兴趣可以一起讨论）；
• 思路二：接口回调，或者方法回调。

这里就采用方法回调。

ResultSetParser接口设计

public interface ResultSetParser<T> {

    /**

     * 处理结果集

     *

     * @param rs

     *            ResultSet

     * @return List<T>

     */

    List<T> parse(ResultSet rs);

    /**

     * 处理结果集

     *

     * @param rs

     *            ResultSet

     * @return Object

     */

    Object simpleParse(ResultSet rs);

}

Parser方法回调实现类

这个类实现了ResultSetParser接口，但是方法都没真正实现，只是写了空方法，由真正的子类去实现

public abstract class Parser<T> implements ResultSetParser<T> {

    @Override

    public List<T> parse(ResultSet resultSet) {

        return null;

    }

    @Override

    public Object simpleParse(ResultSet resultSet) {

        return null;

    }

}

代码封装

于是，就有了下面这样的封装，一个能执行任何查询Sql语句的方法，其中参数ResultSetParser由调用者做具体的实现：

    protected List<T> executeQuerys(ResultSetParser<T> resultSetPaser, String sql, Object... params) throws Exception {

        pstmt = conn.prepareStatement(sql);

        for (int i = 0; i < params.length; i++) {

            pstmt.setObject(i + 1, params[i]);

        }

        rs = pstmt.executeQuery();

        return resultSetPaser.parse(rs);

    }

实现类BaseDao最终封装（源码）

实际取名是DBHelper，为什么不取名BaseDao，因为最初的思路，我是将其设计为工具类，并不是非得继承才可以使用。

public class DBHelper<T> {

    private Connection conn = null;

    private PreparedStatement pstmt = null;

    private ResultSet rs = null;

    // 开启事务标志

    private boolean autoCommit = true;

    /**

     * 核心方法，开启事务

     */

    public void beginTransaction() {

        autoCommit = false;

    }

    /**

     * 核心方法，提交事务

     */

    public void commit() {

        try {

            conn.commit();

            autoCommit = true;

        } catch (SQLException e) {

            e.printStackTrace();

        }

    }

    /**

     * 核心方法，获取数据库连接

     */

    private void begin() {

        try {

            conn = ConnectionPool.getConnection();

            if (autoCommit)

                return;

            conn.setAutoCommit(false);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    /**

     * 核心方法：释放资源

     */

    private void close(ResultSet resultSet, Statement statement, Connection connection) {

        try {

            if (resultSet != null)

                resultSet.close();

            if (statement != null)

                statement.close();

            if (connection != null)

                connection.close();

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    /**

     * 核心方法：为PreparedStatement设置参数

     *

     * @param pstmt

     *            PreparedStatement

     * @param params

     *            参数

     */

    private void setParams(PreparedStatement pstmt, Object... params) {

        try {

            for (int i = 0; i < params.length; i++) {

                pstmt.setObject(i + 1, params[i]);

            }

        } catch (SQLException e) {

            e.printStackTrace();

        }

    }

    /**

     * 增加、删除、修改的统一方法

     *

     * @param sql

     *            SQL语句

     * @param params

     *            参数

     */

    protected boolean executeUpdate(String sql, Object... params) {

        begin();

        try {

            pstmt = conn.prepareStatement(sql);

            setParams(pstmt, params);

            return pstmt.executeUpdate() > 0;

        } catch (SQLException e) {

            e.printStackTrace();

        } finally {

            close(rs, pstmt, conn);

        }

        return false;

    }

    /**

     * 查询的统一方法

     *

     * @param rsUtil

     *            处理结果集的接口

     * @param sql

     *            语句

     * @param params

     *            参数

     * @return List<T>

     */

    protected List<T> executeQuery(ResultSetParser<T> rsUtil, String sql, Object... params) {

        begin();

        try {

            pstmt = conn.prepareStatement(sql);

            setParams(pstmt, params);

            rs = pstmt.executeQuery();

            return rsUtil.parse(rs);

        } catch (SQLException e) {

            e.printStackTrace();

        } finally {

            close(rs, pstmt, conn);

        }

        return null;

    }

    /**

     * 查询的统一方法

     *

     * @param rsUtil

     *            处理结果集的接口

     * @param sql

     *            语句

     * @param params

     *            参数

     * @return List<T>

     */

    protected Object executeSimpleQuery(ResultSetParser<T> resultSetPaser, String sql, Object... params) {

        begin();

        try {

            pstmt = conn.prepareStatement(sql);

            setParams(pstmt, params);

            rs = pstmt.executeQuery();

            return resultSetPaser.simpleParse(rs);

        } catch (SQLException e) {

            e.printStackTrace();

        } finally {

            close(rs, pstmt, conn);

        }

        return null;

    }

}

BaseDao投入实战

我们需要一个AccountsDao，只要去继承BaseDao就好了，假如我们有个添加一个Accounts对象的需求，代码变得异常地简单，如下所示，仅仅只需要两行。

public class AccountsDao extends DBHelper<Accounts> {

    public void insert(Accounts accounts) {

        String sql = "INSERT INTO `accounts` (`integral`, `pwd`, `account`, `addTime`, `login`, `money`, `isEnable`) VALUES (?,?,?,?,?,?,?)";

        super.executeUpdate(sql, accounts.getIntegral(), accounts.getPassword(), accounts.getAccount(),

                accounts.getAddTime(), accounts.getLogin(), accounts.getMoney(), accounts.getIsEnable());

    }

}

利用反射机制设计万能Dao

其实看到上面这一串代码，可能还是略显蛋疼，假如说我们一张表有20列，这个时候去写一个Sql语句，那真的要疯了，你要写20个？号，如果有Where子句，还需要更多。

我的思路是采用反射机制来做，设计一个Javabean，他的类名和字段都和数据库的相匹配，利用反射拼出Sql语句。

因为算法的关系，这肯定会牺牲一定的查询效率，但是可以完成数据连接层的彻底封装。

注意：使用注解、反射、配置文件，都会浪费一定的时间去解析，因此，最好可以去考虑设计一个缓存域，用于缓存已经查询的数据，也可以考虑缓存反射生成的Sql语句。

测试用Javabean

public class Accounts {

    private long id;

    private long integral;

    private String pwd;

    private String account;

    private Timestamp addTime;

    private Timestamp login;

    private int money;

    private boolean isEnable;

    //方法补齐...

｝

数据库对应表

Dao实现

/**

 * 利用反射机制设计Dao

 *

 * @author CSS 2016/12/1

 * @version 1.0

 *

 */

public class EasyDao<T> extends DBHelper<T> {

    /**

     * 分页查询

     * @param begin 开始位置

     * @param count 取多少行记录

     * @return

     */

    public List<T> getList(Class<T> cl, int begin, int count) {

        StringBuffer sql = new StringBuffer(120);

        sql.append("select * from ").append(cl.getSimpleName());

        if (begin != -1)

            sql.append(" LIMIT ?");

        if (count != -1)

            sql.append(",?");

        System.out.println(sql.toString());

        return executeQuery(new Parser<T>() {

            @Override

            public List<T> parse(ResultSet resultSet) {

                return fillArrayList(cl, resultSet);

            }

        }, sql.toString(), begin, count);

    }

    protected List<T> fillArrayList(Class<T> clazz, ResultSet resultSet) {

        List<T> list = new ArrayList<T>();

        try {

            Field[] fields = clazz.getDeclaredFields();

            resultSet.beforeFirst();

            while (resultSet.next()) {

                T t = (T) clazz.newInstance();

                for (int i = 0; i < fields.length; i++) {

                    fields[i].setAccessible(true);

                    fields[i].set(t, resultSet.getObject(fields[i].getName()));

                }

                list.add(t);

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        return list;

    }

}

在万能Dao中引入注解的使用

设计注解接口

/**

 * 指明字段在数据库中对应的列名

 * @author ChenSS

 *

 */

@Target(ElementType.FIELD)

@Retention(RetentionPolicy.RUNTIME)

public @interface Column {

    String value();

}

在Javabean中使用注解

public class Accounts {

    @Column("id")

    private long id;

    @Column("integral")

    private long integral;

    @Column("pwd")

    private String pwd;

    @Column("account")

    private String account;

    @Column("addTime")

    private Timestamp addTime;

    @Column("login")

    private Timestamp login;

    @Column("money")

    private int money;

    @Column("isEnable")

    private boolean isEnable;

｝

Dao实现

曾经写过关于注解使用的文章，想使用参数注解设计，但是设计最终没完成，目前我依旧没能力去解决那些问题，这里换了个思路，使用字段注解。

/**

 * 利用注解设计Dao，解决了反射硬性要求数据库字段与Javabean对应的问题，比直接用反射更加灵活

 *

 * @author CSS 2016/12/1

 * @version 1.0

 *

 */

public class EasyDao2<T> extends DBHelper<T> {

    /**

     * 分页查询

     *

     * @param begin

     *            开始位置

     * @param count

     *            取多少行记录

     * @return

     */

    public List<T> getList(Class<T> cl, int begin, int count) {

        StringBuffer sql = new StringBuffer(120);

        sql.append("select * from ").append(cl.getSimpleName());

        if (begin != -1)

            sql.append(" LIMIT ?");

        if (count != -1)

            sql.append(",?");

        System.out.println(sql.toString());

        return executeQuery(new Parser<T>() {

            @Override

            public List<T> parse(ResultSet resultSet) {

                return fillArrayList(cl, resultSet);

            }

        }, sql.toString(), begin, count);

    }

    protected List<T> fillArrayList(Class<T> clazz, ResultSet resultSet) {

        List<T> list = new ArrayList<T>();

        try {

            Field[] fields = clazz.getDeclaredFields();

            resultSet.beforeFirst();

            while (resultSet.next()) {

                T t = (T) clazz.newInstance();

                for (int i = 0; i < fields.length; i++) {

                    //获取注解值

                    Column column = (Column) fields[i].getAnnotations()[0];

                    if (column == null)

                        continue;

                    fields[i].setAccessible(true);

                    fields[i].set(t, resultSet.getObject(column.value()));

                }

                list.add(t);

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        return list;

    }

}

测试类

public class Test {

    public static void main(String[] args) {

        EasyDao2<Accounts> accountDao=new EasyDao2<>();

        List<Accounts> list=accountDao.getList(Accounts.class, 0, 1);

        System.out.println(list.toString());

        AccountsDao accountsDao=new AccountsDao();

        accountsDao.insert(list.get(0));

    }

}

C3P0连接池配置

首先你需要一个C3P0的Jar包,c3p0-config.xml放在src根目录下，ConnectionPool位置任意。

连接池Java代码

/**

 * 数据库链接对象管理类

 *

 * @author CSS

 * @version 1.0

 *

 */

public class ConnectionPool {

    private static ComboPooledDataSource dpds = null;

    private ConnectionPool() {

    }

    static {

        if (dpds == null)

            createComboPooledDataSource();

    }

    private synchronized static void createComboPooledDataSource() {

        if (dpds == null)

            dpds = new ComboPooledDataSource("mysql");

    }

    public synchronized static Connection getConnection() {

        try {

            return dpds.getConnection();

        } catch (SQLException e) {

            e.printStackTrace();

        }

        return null;

    }

    @Override

    protected void finalize() throws Throwable {

        if (dpds != null)

            DataSources.destroy(dpds);

        super.finalize();

    }

}

c3p0-config.xml

<?xml version="1.0" encoding="UTF-8"?>

<c3p0-config>

    <named-config name="mysql">

        <!-- 配置数据库用户名 -->

        <property name="user">root</property>

        <!-- 配置数据库密码 -->

        <property name="password"></property>

        <!-- 配置数据库链接地址 -->

        <property name="jdbcUrl">jdbc:mysql://192.168.28.217:3307/medicine?useUnicode=true&amp;characterEncoding=UTF-8

        </property>

    <!--    <property name="jdbcUrl">jdbc:mysql://10.50.8.50:3307/medicine?useUnicode=true&amp;characterEncoding=UTF-8&amp;useSSL=false

        </property> -->

        <!-- 配置数据库驱动 -->

        <property name="driverClass">com.mysql.jdbc.Driver</property>

        <!-- 数据库连接池一次性向数据库要多少个连接对象 -->

        <property name="acquireIncrement">40</property>

        <!-- 初始化连接数 -->

        <property name="initialPoolSize">20</property>

        <!-- 最小连接数 -->

        <property name="minPoolSize">5</property>

        <!--连接池中保留的最大连接数。Default: 15 -->

        <property name="maxPoolSize">30</property>

        <!--JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements 属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default:0 -->

        <property name="maxStatements">0</property>

        <!--maxStatementsPerConnection定义了连接池内单个连接所拥有的最大缓存statements数。Default: 0 -->

        <property name="maxStatementsPerConnection">0</property>

        <!--c3p0是异步操作的，缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能 通过多线程实现多个操作同时被执行。Default:3 -->

        <property name="numHelperThreads">3</property>

        <!--用户修改系统配置参数执行前最多等待300秒。Default: 300 -->

        <property name="propertyCycle">3</property>

        <!-- 获取连接超时设置 默认是一直等待单位毫秒 -->

        <property name="checkoutTimeout">1000</property>

        <!--每多少秒检查所有连接池中的空闲连接。Default: 0 -->

        <property name="idleConnectionTestPeriod">3</property>

        <!--最大空闲时间,多少秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->

        <property name="maxIdleTime">10</property>

        <!--配置连接的生存时间，超过这个时间的连接将由连接池自动断开丢弃掉。当然正在使用的连接不会马上断开，而是等待它close再断开。配置为0的时候则不会对连接的生存时间进行限制。 -->

        <property name="maxIdleTimeExcessConnections">5</property>

        <!--两次连接中间隔时间，单位毫秒。Default: 1000 -->

        <property name="acquireRetryDelay">1000</property>

        <!--c3p0将建一张名为Test的空表，并使用其自带的查询语句进行测试。如果定义了这个参数那么属性preferredTestQuery将被忽略。你不能在这张Test表上进行任何操作，它将只供c3p0测试使用。Default:

            null -->

        <property name="automaticTestTable">Test</property>

        <!-- 获取connnection时测试是否有效 -->

        <property name="testConnectionOnCheckin">true</property>

    </named-config>

</c3p0-config>