浅谈JavaEE中的JDBC模板类的封装实现以及合理的建立项目包结构

 从今天开始我们一起来聊下有关，javaEE开发中的一些知识，JavaEE的开发用于企业级的开发，但是现在企业中一般也不会使用JDBC开发，大部分都是使用自己公司开发的一套的框架，但是这些框架的架构一般也是会模仿着有名JavaEE开源三大开发框架SSH(Struts2+Spring+Hibernate)或者现在也很流行的SSM开发框架(Spring+SpringMVC+MyBatis)

来进行深度定制以便于适合自己企业的实际开发需求。有的人曾说既然去公司又是重新学习一套框架，还有必要学习开源的三大框架，答案是肯定的。因为三大框架其实很多中小型公司还是在使用的，另一方面学好三大框架将非常有助于你理解和学习公司内部的框架。那有的人又说了，我直接学习三大框架SSH或SSM，还有学习一些JDBC、JSP、Servlet、EL表达式、JSTL标签等必要吗？答案是肯定的。实际上所谓的三大框架，只不过是高度封装了而已，使得开发变得更加简单、方便、高效而已，而实际的核心本质还是JDBC和Servlet等这些知识。Struts2实际上就是在Servlet的基础进行封装，而Hibernate就是对JDBC的一个高度封装，使得将面向关系的数据操作转换成面向对象的编程操作。说了这么多，总之一句话：学习好一些基础知识和一些内部的机制原理将有助于更好地学习和理解框架开发。码农和工程师的区别在于你是用框架还是造框架的。

       首先，大家应该对基于JDBC对数据库(这里以MySQL数据库为例)一些增删改查的操作都很清楚和熟悉吧，那么我们先来看下最原始的JDBC的操纵步骤：

          第一步：利用java反射原理注册数据库驱动

                            Class.forName(“com.mysql.jdbc.Driver”);

          第二步：获取Connection连接对象

                                Connection conn=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/cms","root","root")

          第三步:预处理SQL语句，并返回一个PreparedStatement预处理对象。

                                PreparedStatement pstmt=conn.prepareStatement(sql);

          第四步:如果有占位符使用预处理对象通过一些set方法给占位符赋值

                              pstmt.setString("name",username)

          第五步:执行SQL语句，执行SQL语句方法有两种一种是没有结果集返回(一般用于:增、删、改)，另一种是有结果集(查询)返回的

                             int executeUpdate();增 删  该
             Result executeQuery();查

          第六步:有结果ResultSet处理结果集

          第七步:释放资源主要需要关闭Connection连接对象，PreparedStatement预处理SQL语句对象，ResultSet结果集

                          注意关闭的顺序：先创建的后关闭

                             rs.close();

                             pstmt.close();

                             conn.close();

一般基本的JDBC对数据库操作都会经过以上几个步骤，可能实际步骤没那么多，自己细化了一下。现在我们可以来想一下，我们最原始的数据库JDBC的操作，每一次的增删改查都会涉及到以上步骤，有的人就说这还不简单把每一个操作定义一个方法，把代码粘贴复制改下就可以。这样我们会发现会有大量的代码重复和冗余。相信很多人都很容易想到将相同的代码抽取出来，然后下次使用的时候直接调用即可。好的就是这样我们需要把哪些代码抽取封装呢？其实很简单，我们不难发现无论是增删改查操作，都需要获取连接对象，然后最后都需要去释放资源，我们就不妨把这些代码给抽取出来然后在增删改查方法中去引用这些代码即可。我们就可以定义个ConnectionFactory类，然后在其中定义一个静态方法用于返回一个Connection对象，再定义一个close方法。

package com.mikyou.common;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class ConnectionFactory {
/**
* 获取连接
* */
private static String driver;
private static String url;
private static String user;
private static String password;
/**
* @Mikyou
* 使用静态代码块，来提前初始化一些参数，
* 我们都知道静态代码块中的代码是在ConnectionFactory类在方法区中加载的时候，就开始加载
* 所以可以起到一个预加载和与初始化的一个作用
* */
static{//为了扩展
driver="com.mysql.jdbc.Driver";
url="jdbc:mysql://127.0.0.1:3306/cms";
user="root";
password="root";
}
/**
* @Mikyou
* 获取连接对象
* */
public static Connection getConnection() throws Exception{
Class.forName(driver);
return DriverManager.getConnection(url,user,password);
}
/**
* @Mikyou
* 用于释放资源
* @param rs
* @param pstmt
* @param conn
* 首先需要判断这些参数是否为空，因为有些操作并且全都涉及这三个对象
* 例如增加操作就不涉及ResultSet rs
* */
public static void close(ResultSet rs,PreparedStatement pstmt,Connection conn) throws SQLException{
if (rs!=null) {
rs.close();
}
if (pstmt!=null) {
pstmt.close();
}
if (conn!=null) {
conn.close();
}
}
}


然而、我们通过上一步只是简化一部分而已，这只是封装的第一步，接下来才是真正的JDBC的封装。在封装之前我们先来思考几个问题，在使用JDBC对数据库一般基本常用几个方法是哪些，有的人说4个实际上在项目开发的时候至少都有5个方法:add  delete update queryOne  queryAll.好我们先明确了有5个方法那么接下来我们再来分析一下这5个方法有什么相同点和不同点，或者说哪些方法可以化为一类，哪些方法化为另一类。我很容易发现并可以很快分类：add,delete,update（无结果集）queryOne(有一个结果集)
queryAll(有不确定个数的结果集)，所以根据这三个分类我们就对应在JDBCTemplate模板类中的三个方法，用同一个方法处理同一类的问题。分别对应了模板类中的

update(无结果集) findOne(返回一个结果集) findAll(返回不确定个数结果集)。

  有了这三个方法的确立，我们再去深入这三个方法:

      第一个update方法，如何利用定义一个通用的update方法去统一add,delete,update三个操作呢。那就得看这三个操作方法的异同点，首先我们得出这三个方法的执行的sql语句是不一样的，所以sql语句需要通过外部调用传入，然后会发现在处理sql语句占位符也就是给占位符赋值的时候是不一样的，所以也需要外部调用的时候传入，但是随之而来的一个问题是给占位符赋值通过外部传入的话怎么传，因为我们知道处理占位符时的类型和占位符的个数是不一样的，那么就可以得出处理占位符的类型不确定以及个数不确定结论，所以相信大家到这里都应该猜到了怎么传？其实由多种方式可以传，可以使用集合加Object类型泛型List<Object>或者Object数组Object[],然后传进来就是需要给占位符赋值，我们可以去遍历这个集合或者数组然后利用setObject(key,value)来处理占位符,那么实际上第一个方法分析好了，封装也就很容易了。封装如下:

public void update(String sql, Object[] agrs){
try {
Connection conn=null;
PreparedStatement pstmt=null;
try {
conn=ConnectionFactory.getConnection();//获取连接对象
pstmt=conn.prepareStatement(sql);//预处理sql
for (int i = 0; i < agrs.length; i++) {//处理占位符
pstmt.setObject(i+1, agrs[i]);//注意：为什么是+1，JDBC中设置占位符序号是从1开始的，特例，以后Hibernate中都是从0开始的
}
pstmt.executeUpdate();//由于不需要返回结果集，所以直接使用executeUpdate
} finally {
ConnectionFactory.close(null, pstmt, conn);//关闭连接
}
} catch (Exception e) {
}
}

    第二个方法和第三个方法相对第一个方法稍微就要麻烦一些了，为什么呢？因为它有结果集返回呀，我们怎么去得到这些结果集并去处理这些结果集呢？如果学Android或者学过JavaSE中的GUI编程朋友就很容易想到利用自定义监听器的回调方法返回结果集并在回调方法中去处理这些结果集。因为在Android或者GUI对一些UI控件都会设有一个监听器里面会有回调方法，通过回调方法的参数就可以传值了，类似于Android中的OnClickListener接口。所以我们可以仿照这样的一个接口回调机制，将我们的结果集作为回调方法参数传递即可。但是这里还需做一点修改就是我们虽然可以传递结果集，但是我们结果集也分为两种情况:第一只返回一个结果集，第二则返回不确定个数的结果集，怎么解决这个问题呢？因为我们的定义的接口每次只返回一个对象，所以对于不确定结果集的话，可以通过循环多次返回得到多个对象，并且将多个对象放入到集合中去，
结果集返回的问题解决了，那么接下来再来思考一个问题就是query和queryAll方法的返回值的类型是什么？我们的这个模板方法应该是通用的，适用于不同的Bean类，所以我们很容易就想到了java中的泛型，利用泛型，就可以确定query返回值的类型为T，queryAll返回值的类型为List<T>,这样就可以适用所有的Bean类。

           第一步：自定义一个监听器OnIMapperListener

                         1、先定义一个接口:OnIMapperListener

package com.mikyou.common;

import java.sql.ResultSet;
/**
* 映射监听器接口
* */
public interface OnIMapperListener<T>{
public T mapper(ResultSet rs);//flag标记变量 rs返回的结果集 T表示处理完结果集返回值类型，一般返回值的类型是相应的Bean类型
}
                   2、再到JDBCTemplate模板类中去定义一个OnIMapperListener<T>接口类的引用listener，再去定义一个方法setOnIMapperListener()用于初始化这个OnIMapperListener<T>接口引用，这个是不是很类似Android中的setOnClickListener(),实际上意义是一样的。

private OnIMapperListener< T> listener;
public void setOnMapperListener(OnIMapperListener< T> mapper){//初始化映射监听器
this.listener=mapper;
}
       3、封装的queryOne和queryAll方法:

/**
* @Mikyou
* queryOne方法
*
* */

public T queryOne(String sql,Object[] agrs){
T obj=null;
try {
Connection conn=null;
PreparedStatement pstmt=null;
ResultSet rs=null;
try {
conn=ConnectionFactory.getConnection();
pstmt=conn.prepareStatement(sql);
for (int i = 0; i < agrs.length; i++) {
pstmt.setObject(i+1, agrs[i]);
}
rs=pstmt.executeQuery();
if (rs.next()) {
if (listener!=null) {//表示已经注册了映射监听器了，监听器对象不为空
obj=listener.mapper(rs);//结果集作为参数传入回调方法中
}

}
} finally {
ConnectionFactory.close(rs, pstmt, conn);
}
} catch (Exception e) {
}
return obj;
}
/**
* @MIkyou
* queryAll方法
* */
public List<T> queryAll(String sql,Object[] agrs){
List<T>list=new ArrayList<T>();
try {
Connection conn=null;
PreparedStatement pstmt=null;
ResultSet rs=null;
try {
conn=ConnectionFactory.getConnection();
pstmt=conn.prepareStatement(sql);
for (int i = 0; i < agrs.length; i++) {
pstmt.setObject(i+1, agrs[i]);
}
rs=pstmt.executeQuery();
while (rs.next()) {
if (listener!=null) {//表示已经注册了映射监听器了，监听器对象不为空
T obj=listener.mapper(rs);//结果集作为参数传入回调方法中
list.add(obj);
}

}
} finally {
ConnectionFactory.close(rs, pstmt, conn);
}
} catch (Exception e) {
}
return list;
}

最后附上完整的JDBCTemplate模板类以后可以直接拿到项目中使用:

package com.mikyou.common;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class JDBCTemplate<T> {
private OnIMapperListener< T> listener;
public void setOnMapperListener(OnIMapperListener< T> mapper){//初始化映射监听器
this.listener=mapper;
}
public void update(String sql, Object[] agrs){
try {
Connection conn=null;
PreparedStatement pstmt=null;
try {
conn=ConnectionFactory.getConnection();//获取连接对象
pstmt=conn.prepareStatement(sql);//预处理sql
for (int i = 0; i < agrs.length; i++) {//处理占位符
pstmt.setObject(i+1, agrs[i]);
}
pstmt.executeUpdate();//由于不需要返回结果集，所以直接使用executeUpdate
} finally {
ConnectionFactory.close(null, pstmt, conn);//关闭连接
}
} catch (Exception e) {
}
}
/**
* @Mikyou
* queryOne方法
*
* */

public T queryOne(String sql,Object[] agrs){
T obj=null;
try {
Connection conn=null;
PreparedStatement pstmt=null;
ResultSet rs=null;
try {
conn=ConnectionFactory.getConnection();
pstmt=conn.prepareStatement(sql);
for (int i = 0; i < agrs.length; i++) {
pstmt.setObject(i+1, agrs[i]);
}
rs=pstmt.executeQuery();
if (rs.next()) {
if (listener!=null) {//表示已经注册了映射监听器了，监听器对象不为空
obj=listener.mapper(rs);//结果集作为参数传入回调方法中
}

}
} finally {
ConnectionFactory.close(rs, pstmt, conn);
}
} catch (Exception e) {
}
return obj;
}
/**
* @MIkyou
* queryAll方法
* */
public List<T> queryAll(String sql,Object[] agrs){
List<T>list=new ArrayList<T>();
try {
Connection conn=null;
PreparedStatement pstmt=null;
ResultSet rs=null;
try {
conn=ConnectionFactory.getConnection();
pstmt=conn.prepareStatement(sql);
for (int i = 0; i < agrs.length; i++) {
pstmt.setObject(i+1, agrs[i]);
}
rs=pstmt.executeQuery();
while (rs.next()) {
if (listener!=null) {//表示已经注册了映射监听器了，监听器对象不为空
T obj=listener.mapper(rs);//结果集作为参数传入回调方法中
list.add(obj);
}

}
} finally {
ConnectionFactory.close(rs, pstmt, conn);
}
} catch (Exception e) {
}
return list;
}

}

我们终于把通用的JDBCTemplate模板给造好了，质量好不好我们得来检验检验，我们写了简单的测试来检验模板类封装成功还是失败。

我们一般在哪使用这个JDBCTemplate类呢？或者怎么使用去使用这个JDBCTemplate类呢？我们一般在DAO层使用，DAO一般是对数据库的各种增删改查操作，至于这个项目架构和封层等会即将讲解。我们就写一个CustomerDAO类去实现我们监听器，并重写回调方法mapper方法，该方法中的参数就是回调返回的结果集，并用Customer这个Bean类作为泛型类型。

package com.mikyou.dao;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import com.mikyou.bean.Customer;
import com.mikyou.common.JDBCTemplate;
import com.mikyou.common.OnIMapperListener;
/**
* @Mikyou
* JDBCTemplate：<--->JDBC模板类
*
* */
public class CustomerDAO implements OnIMapperListener<Customer>{
private JDBCTemplate<Customer>temp;
public CustomerDAO() {
temp=new JDBCTemplate<Customer>();
temp.setOnMapperListener(this);//给CustomerDAO注册映射监听器
}
/**
* 以下三个方法都有一个共同的特点就是无需带有返回结果集，所以直接在JDBCTemplate模板类中直接封装成一个update方法即可
* */
public void save(Customer customer) throws SQLException{
String sql="insert into tb1_customer(name,gender,telephone,address) values(?,?,?,?)";
Object[] agrs={customer.getName(),customer.getGender(),customer.getTelephone(),customer.getAddress()};
temp.update(sql, agrs);
}
public void update(Customer customer){
String sql="update tb1_customer set name=?,gender=?,telephone=?,address=? where id=?";
Object[] agrs={customer.getName(),customer.getGender(),customer.getTelephone(),customer.getAddress(),customer.getId()};
temp.update(sql, agrs);
}
public void delete(long id){
String sql="delete from tb1_customer where id=?";
Object[] agrs={id};
temp.update(sql, agrs);
}

public Customer findByName(String name){
String sql="select * from tb1_customer where name=?";
Object[] args={name};
Customer customer=temp.queryOne(sql, args);
return customer;
}
public List<Customer> findAll(){
String sql="select * from tb1_customer";
Object[] args={};
return temp.queryAll(sql, args);
}
/**
* @Mikyou
* 具体实现相应的回调方法
* @param rs 回调返回的结果集
* @deprecated:处理结果集 并且返回的类型是我们的Bean类型Customer
* */
@Override
public Customer mapper(ResultSet rs) {
Customer customer=null;
try {
Long id=rs.getLong("id");
String name=rs.getString("name");
String gender=rs.getString("gender");
String address=rs.getString("address");
String telephone=rs.getString("telephone");
customer=new Customer(id, name, gender, telephone, address);
} catch (SQLException e) {
e.printStackTrace();
}
return customer;
}
}
接下来我们写一个DaoTest测试类测试一下:

增加操作:

private void add() {
CustomerDAO customerDAO=new CustomerDAO();
try {
Customer customer=new Customer(1L, "Mikyou", "男", "123456789", "中国");
customerDAO.save(customer);
Customer customer2=new Customer(2L, "Alice", "女", "123456789", "美国");
customerDAO.save(customer2);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

运行结果:



更新操作:

private void update() {
// TODO Auto-generated method stub
CustomerDAO customerDAO=new CustomerDAO();
customerDAO.update(new Customer(2L, "Bob", "男", "123456789", "英国"));
}

运行结果:



查询确定某一个：

[java] view
plain copy

 print?





private void findOne() {  

        // TODO Auto-generated method stub  

        CustomerDAO customerDAO=new CustomerDAO();  

        Customer customer=customerDAO.findByName("Bob");  

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

    }  



查询多个:

[java] view
plain copy

 print?





private void findAll() {  

    // TODO Auto-generated method stub  

    CustomerDAO customerDAO=new CustomerDAO();  

    List<Customer> customers=customerDAO.findAll();  

    for (Customer customer : customers) {  

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

    }  

  

}  



删除操作:

[java] view
plain copy

 print?





private void delete() {  

    // TODO Auto-generated method stub  

    CustomerDAO customerDAO=new CustomerDAO();  

    customerDAO.delete(1L);  

}  



DaoTest测试类:

package com.mikyou.test;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.mikyou.bean.Customer;
import com.mikyou.dao.CustomerDAO;
import com.sun.org.apache.bcel.internal.util.SecuritySupport;

public class DaoTest {

public static void main(String[] args) {
//new DaoTest().add();//增
new DaoTest().delete();//删
// new DaoTest().update();//改
//new DaoTest().findOne();//查询具体某一个
// new DaoTest().findAll();//查询一个集合
}

private void findAll() {
// TODO Auto-generated method stub
CustomerDAO customerDAO=new CustomerDAO();
List<Customer> customers=customerDAO.findAll();
for (Customer customer : customers) {
System.out.println(customer.toString());
}

}

private void findOne() {
// TODO Auto-generated method stub
CustomerDAO customerDAO=new CustomerDAO();
Customer customer=customerDAO.findByName("Bob");
System.out.println(customer.toString());
}

private void update() {
// TODO Auto-generated method stub
CustomerDAO customerDAO=new CustomerDAO();
customerDAO.update(new Customer(2L, "Bob", "男", "123456789", "英国"));
}

private void delete() {
// TODO Auto-generated method stub
CustomerDAO customerDAO=new CustomerDAO();
customerDAO.delete(1L);
}

private void add() {
CustomerDAO customerDAO=new CustomerDAO();
try {
Customer customer=new Customer(1L, "Mikyou", "男", "123456789", "中国");
customerDAO.save(customer);
Customer customer2=new Customer(2L, "Alice", "女", "123456789", "美国");
customerDAO.save(customer2);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

}
到这里JDBCTemplate模板类简单封装就到这了，是不是感觉比以前直接写一大堆重复冗余的代码要好一点呢？

下面接着继续讲下我们JavaEE的包该如何建以及整个JavaEE项目的分层，其实分层每个人看起来多多少少有那么不一样，但是总体分类是一样的。

主要有Service层(抽象接口层和接口实现层)，DAO层(数据控制层)，Web层(表现层)通过这些分层降低代码之间耦合度，实现数据和视图和业务逻辑层分开。



到这里就结束了，下面将继续介绍SSH三大框架，初学JavaEE，上面博客难免出一些问题，还请多多指正。

本文转自： 

浅谈JavaEE中的JDBC模板类的封装实现以及合理的建立项目包结构