JDBC自定义套件封装

一、背景
Java开发人员现在对数据库的操作一般会用到诸如像Hibernate,Mybatis,SpringJdbcTemplate等ORM组件,但是这些组件是怎样从原始的编码方式一步步封装过来的呢 ?

二、最原始的编码方式
如下面代码所示:
数据库的.
public class DBConnectionTest{

/**
 * 一个数据库的连接我们要具备三项条件  ，一个是数据库地址，
 * 一个是访问数据库的用户名和密码
 * 一个是数据库的类型
 * @Title: testDBConnection  
 * @Description: TODO
 */
public static void testDBConnection(){
    Connection con = null; //一个数据库连接
    PreparedStatement pre = null; //预编译对象
    ResultSet result = null; //结果集 
    try {   
        //加载MySQL的驱动程序
        Class.forName("com.mysql.jdbc.Driver");
        //连接数据库的路径(关键字+IP地址+数据库名称)
        String url = "jdbc:mysql://127.0.0.1/open";
        //数据库的用户名
        String user = "root";
        //数据库密码
        String password = "123456";
        System.out.println("现在开始连接MYSQL数据库");
        //获取连接
        con = DriverManager.getConnection(url,user,password);
        System.out.println("连接MYSQL数据库成功");
        String sql = "SELECT * FROM USER  ";
        //实例化预编译语句对象
        pre= con.prepareStatement(sql);
        //pre.setInt(1, deptId);
        //返回结果集
        result = pre.executeQuery();
        //将结果集放到我们的java对象            
        while(result.next()){
            System.out.println(result.getObject(1)+"----"+result.getObject(2)
            +"----"+result.getObject(3)+"----"+result.getObject(4)+"----"); 
        }           
    } catch (Exception e) {
        e.printStackTrace();
    }finally{    
        try {           
            if(result!=null){
                result.close();
            }
            if(pre!=null){
                pre.close();
            }
            if(con !=null){ 
                con.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public static void main(String[] args) {    
    DBConnectionTest.testDBConnection();        
}

}

三、封装的过程和思路
总得来说,Java组件封装的原则就是高内聚,低耦合,直白一点的解释就是 将重复性的代码提取出去作为工具类,尽量减少类与类之间的固定依赖.
1)DbUtil工具类
通过查看最原始编码方式的代码 ,我们可以看出,获取数据库的连接和关闭数据库连接的代码,在每一次操作中都需要,所以我们可以思考一下,将这部分代码提取出去.
* 新建DbUtil工具类 ,用于数据库的开连接和关连接

/**
* 类描述：封装第一步 我们把取得连接和关闭连接抽取出来成为独立的方法放入工具类里面
* 第二步：我们是否要考虑将我们的数据库连接的四要素（类型，用户名 密码 ，地址 抽取出来做成配置文件的方式）
* 创建人：keven
* @version V1.0
*/
public class DbUtil {

public static Connection getConnection() throws Exception {
    Connection con;
    //加载MySQL的驱动程序
    Class.forName("com.mysql.jdbc.Driver");
    //连接数据库的路径(关键字+IP地址+数据库名称)
    String url = "jdbc:mysql://127.0.0.1/open";
    //数据库的用户名
    String user = "root";
    //数据库密码
    String password = "123456";
    System.out.println("现在开始连接MYSQL数据库");
    //获取连接
    con = DriverManager.getConnection(url,user,password);
    return con;
}
/**
 * 关闭数据库连接
 * @Title: closeConnection  
 * @Description: TODO
 * @param con
 * @param pre
 * @param result
 */
public  static void closeConnection(Connection con, PreparedStatement pre,
        ResultSet result) {
    try {           
        if(result!=null){
            result.close();
        }
        if(pre!=null){
            pre.close();
        }
        if(con !=null){ 
            con.close();
        }
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}
}

通过工具类的封装,我们可以继续在工具类里面将数据库的信息通过配置文件加载,以及启用流行的连接池技术,在这里不在赘述.

2)增删改方法的封装
在封装了DbUtil工具类的基础上,我们试着做一个单表的增删改查,请看以下代码:

/**
* 关于用户表的增删改查方法
* @author keven
*/
public class UserDaoTest{
/**
* user表的增加方法
*/
public int addUser(User user){
int rows = 0;
Connection con = null; //一个数据库连接
PreparedStatement pre = null; //预编译对象
ResultSet result = null; //结果集
try{
con = DbUtil.getConnection();
String addSql = ” INSERT INTO USER(NAME,AGE,SEX)VALUES(?,?,?)”;
pre = con.prepareStatement(addSql);
pre.setString(1, user.getName());
pre.setInt(2, user.getAge());
pre.setString(3, user.getSex());
rows = pre.executeUpdate();
}catch(Exception e){
e.printStackTrace();
}finally{
DbUtil.closeConnection(con, pre, result);
}
return rows;
}

/**
 * user表的删除方法     
 */
public int delUser(int userId){
    int rows = 0;
    Connection con = null; //一个数据库连接
    PreparedStatement pre = null; //预编译对象
    ResultSet result = null; //结果集
    try{
        con = DbUtil.getConnection();
        String deleteSql = "DELETE FROM USER WHERE ID = ?";
        pre = con.prepareStatement(deleteSql);
        pre.setInt(1, userId);   
        rows = pre.executeUpdate();     
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        DbUtil.closeConnection(con, pre, result);
    }               
    return rows;        
}   
/**
 * user表的更新方法     
 */
public int updateEmp(User user){
    int rows = 0;
    Connection con = null; //一个数据库连接
    PreparedStatement pre = null; //预编译对象
    ResultSet result = null; //结果集
    try{
        con = DbUtil.getConnection();
        String updateSql = " UPDATE USER SET NAME =?, AGE=?,SEX=? WHERE ID =? ";
        pre = con.prepareStatement(updateSql);
        pre.setString(1, user.getName());
        pre.setInt(2, user.getAge());
        pre.setString(3, user.getSex());    
        pre.setInt(4, user.getId());
        rows = pre.executeUpdate();     
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        DbUtil.closeConnection(con, pre, result);
    }               
    return rows;    
}
/**
 * user表的查询方法  
 */
public  List getUserList(){
    Connection con = null; //一个数据库连接
    PreparedStatement pre = null; //预编译对象
    ResultSet result = null; //结果集
    List userList = new ArrayList();
    try {
        con = DbUtil.getConnection();
        String sql = "SELECT ID,NAME,AGE,SEX FROM USER ";
        //实例化预编译语句对象
        pre= con.prepareStatement(sql);
        //pre.setInt(1, deptNo);
        //返回结果集
        result = pre.executeQuery();
        //将结果集放到我们的java对象
        User user;
        while(result.next()){
            user = new User();
            user.setId(result.getInt("id"));
            user.setName(result.getString("name"));
            user.setAge(result.getInt("age"));
            user.setSex(result.getString("sex"));        
            userList.add(user); 
        }                       
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{
        //逐一将上面的对象全部关闭，因为如果不关闭的话会影响数据库的性能，并且占用资源
        //逐一关闭的顺序 最后使用的最先关闭
        DbUtil.closeConnection(con, pre, result);
    }
    return userList;

}
}
进一步观察增删改方法 ,除了Sql语句和参数传入的不同,其他代码其实也是重复的,我们是否可以考虑将这些公用的代码也提取出去呢?
伟大的Java程序员们都是”懒鬼”,一切都是为了少些一些重复的代码以提高工作效率.
我们可以新建一个模板类JdbcTemplate, 对增删改方法进行封装,外部只需要传入sql语句和sql语句需要用到的参数.
/**
* 类描述： jdbc dao模板类
* 通过参数的动态传入来简化dao类的代码
* 1：sql
* 2：sql需要传入的变量的值
* 创建人：keven
*/
public class JdbcTemplate{

/**
 * 封装增删改的模板方法
 * @Title: updateTemplate  
 * @Description: TODO
 * @param sql
 * @param params
 * @return
 */
public int updateTemplate(String sql,Object[] params){
    int rows = 0;
    Connection con = null; //一个数据库连接
    PreparedStatement pre = null; //预编译对象
    ResultSet result = null; //结果集
    try{
        con = DbUtil.getConnection();
        pre = con.prepareStatement(sql);
        //设置sql所需要的参数
        if(params!=null){
            for(int i=0;i

}

通过上面步骤的封装,我们再来看看让对单表增删改的操作是如何方便简单的,新建一个单表增删改的测试类,继承我们封装的模板类,代码如下:

/**
* 继承了模板类的单表增删改操作
* @author keven
*
*/
public class UserDaoTemplateTest extends JdbcTemplate {

/**
 * user表的增加方法
 * @Title: adduser  
 * @Description: TODO
 * @param user
 * @return
 */
public int addUser(User user){
    String addSql = " INSERT INTO USER(NAME,AGE,SEX)VALUES(?,?,?)";
    Object[] params = new Object[]{user.getName(),user.getAge(),user.getSex()};
     return this.updateTemplate(addSql, params);    
}

/**
 * user表的删除方法
 * @Title: deluser  
 * @Description: TODO
 * @param userNo
 * @return
 */
public int deluser(int userId){
    String deleteSql = "DELETE FROM USER WHERE ID=?"; 
    Object[] params = new Object[]{userId};
    return this.updateTemplate(deleteSql, params);

}
/**
 * user表的修改方法
 * @Title: updateuser  
 * @Description: TODO
 * @param user
 * @return
 */
public int updateUser(User user){
    String updateSql = " UPDATE USER SET NAME =?, AGE=?,SEX=? WHERE ID =? ";
    Object[] params = new Object[]{ user.getName(),user.getAge(),user.getSex(),user.getId()};
    return this.updateTemplate(updateSql, params);
}

}
回过头看看我们的封装过程和代码,是不是对于开发人员来讲 ,越来越简单,代码写的越来越少,这就是Java在实际开发过程中需要用到大量前辈们封装的组件的原因.

3)查询方法的封装
在增删改方法的封装过程当中,我们发现,增删改的操作,方法的返回值是固定的,但是查询方法的返回值是不固定的,查询不同的表,返回的是不同对象,也有可能是返回的其他类型的值.
通过以上分析,我们封装查询方法的时候,只能返回一个固定格式的对象或者列表,让执行查询的人来解析固定格式的结果得到自己想要的返回值.
两种方式:
a:返回一个List