动起手来学Hibernate（一）

JDBC回顾

1. 开发步骤

• 搭建开发环境，导入对应数据库的驱动包
  MySQL数据库对应的驱动包是mysql-connector-java-x.jar
• 注册驱动

String driver = "com.mysql.jdbc.Driver"    //MySQL数据库对应的驱动
Class.forName(driver ); //加载驱动

• 获取与数据库的链接

Stirng url = "jdbc:mysql://localhost:3306/mydb";//注意每一中数据库的URL写法是不同的
String username = "root";    //数据库角色名
String password = "root";    //数据库密码
Connection conn = DriverManager.getConnection(url, username, password);//获取链接

• 创建代表sql语句的对象

Statement statement = conn.createStatement();

• 执行sql

String sql = "selct 1 from";
ResultSet resultSet = statement.execute();

• 释放资源

resultSet.close();
statement.close();
conn.close();

2. JDBC中常用的规范类或接口

① DriverManager

• 注册驱动
  方式一

DriverManager.registerDriver(new com.mysql.jdbc.Driver());

方式二

Class.forName("com.mysql.jdbc.Driver");

• 获取数据库的链接
  方式一

Connection conn = DriverManager.getConnection(url, username, password);

方式二

Connection conn = DriverManaget.getConnection("url?user=&password=")

② Connection
交互使用的链接，所有的数据库交互都是基于它
③ Statement
代表sql语句的对象，常用方法如下

ResultSet excuteQuery(String sql);    //执行查询，返回结果集
int excuteUpdate(String sql); //执行dml语句，返回影响的记录条数

④ ResultSet
结果集的封装

3. 一个简单的实例

• 链接池
  访问数据库的时候，不同使用者每一次的访问都需要经过加载驱动、获取链接、执行sql、处理结果集、关闭链接资源这几步，这样是会耗费大量的资源的去进行的。我们可以这样去做，将不同的使用者自己创建的链接保存起来，让他下一次访问的时候不需要再去重新创建，这样的话可以减少数据的负担。

链接池的实现

/**
 * 链接池
 */
public class ConnectionPool {
    
    /**
     *  池子
     */
    private static List<Connection> connPool;
    
    /**
     * 池子的容量
     */
    private static final int POOLSIZE = 20;
    
    /**
     * 链接驱动
     */
    private static final String DRIVER = "com.mysql.jdbc.Driver";
    
    /**
     * 链接的URL
     */
    private static final String URL = "jdbc:mysql://localhost:3306/mydb";
    
    /**
     * 数据库名
     */
    private static final String USERNAME = "root"; 
    
    /**
     * 数据库密码
     */
    private static final String PASSWORD = "root";
    
    /**
     * 创建数据链接
     * @return conn
     */
    private Connection createDBConnection() {
        Connection conn = null;
        try {
            Class.forName(DRIVER);    //加载驱动
            conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);   //获取链接
        } catch (ClassNotFoundException e) {
            System.out.println("ClassNotFound when loading dirver.");
        } catch (SQLException e) {
            System.out.println("SQLException when loading driver");
        }
        return conn;
    }
    
    /**
     * 获取数据库链接
     * @return
     */
    public synchronized Connection getDBConnection() {
        Connection conn = null;
        //初始化链接池
        if(null == connPool) {
            connPool = new LinkedList<Connection>();
        }
        //池是空的时候
        if(connPool.isEmpty()) {
            conn = createDBConnection();
        }else {
            //池中存在链接
            int lastIndex = connPool.size() - 1;
            conn = connPool.get(lastIndex);
            connPool.remove(connPool.get(lastIndex));
        }
        return conn;
    }
    
    /**
     * 回收connection
     * @param conn
     */
    public synchronized void releaseConnection(Connection conn) {
        //当池中存储的链接数据大于定义的容量的时候，关掉链接
        if(connPool.size() > POOLSIZE) {
            try {
                conn.close();
            } catch (SQLException e) {
                System.out.println("SQLException when close connection;");
            }
        }else {
            //池中还有空间，将链接加入池
            connPool.add(conn);
        }
    }
}

上边的代码实现了一个简单的链接池，但是我们在开发的时候经常还是会使用链接的close方法，所以我们需要通过一些手段将其换成我们的releaseConnection方法。

• 动态代理
  我们需要通过动态代理将close进行转化，使其变成我们需要的样子
  实现代码如下

/**
 * 为链接绑定代理
 */
public class ConnectionHandle implements InvocationHandler {

    private Connection conn;
    private ConnectionPool connPool;
    
    public ConnectionHandle(ConnectionPool connPool) {
        this.connPool = connPool;
    }
    
    /**
     * 绑定动态代理
     * @param conn
     * @return
     */
    public Connection bind(Connection conn) {
        this.conn = conn;
        //代理绑定
        Connection proxyConn = (Connection) Proxy.newProxyInstance(conn.getClass().getClassLoader(), new Class[]{Connection.class}, this);
        return proxyConn;
    }
    
    /**
     * 方法拦截器
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object obj = null;
        //如果是close方法，进行拦截，使其变成自定义的releaseConnection方法
        if("close".equals(method.getName())) {
            connPool.releaseConnection(conn);
        }else {
            obj = method.invoke(conn, args);
        }
        return obj;
    }

}

加入动态代理后，我们还需要将我们创建连接的代码修改下，修改结果如下

     /**
     * 创建数据链接
     * @return conn
     */
    private Connection createDBConnection() {
        Connection conn = null;
        try {
            Class.forName(DRIVER);    //加载驱动
            conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);   //获取链接
        } catch (ClassNotFoundException e) {
            System.out.println("ClassNotFound when loading dirver.");
        } catch (SQLException e) {
            System.out.println("SQLException when loading driver");
        }
        ConnectionHandle connHandle = new ConnectionHandle(this);
        return connHandle.bind(conn);
    }

经过上边的这些，一个可以进行数据库链接的简单链接池已经完成了，但是它没有很多的功能只能进行数据库链接的展示。

4. 总结

ORM技术使得关系型数据中的数据表映射到了Java的对象中，Hibernate就是一种ORM框架，目前发展的也很成熟，让我们动起手来学习吧。