从零开始写javaweb框架笔记8-细节完善与代码优化

最新推荐文章于 2024-08-17 14:33:30 发布

修炼中的菜鸟

最新推荐文章于 2024-08-17 14:33:30 发布

阅读量3.3k

点赞数 1

分类专栏：从零开始写javaweb框架笔记文章标签： java serverlet mvc

本文链接：https://blog.csdn.net/j903829182/article/details/50190337

版权

从零开始写javaweb框架笔记专栏收录该内容

21 篇文章 1 订阅

订阅专栏

在前面我们搭建了一个客户管理模块的代码框架，在代码中有很大的to do something或者to do，这些就是要逐渐完善的细节，我们将分别完善服务层，控制层，视图层，并且对代码进行优化。

1 完善服务层

添加SLF4J用于提供日志API,使用Log4J作为实现，配置如下：

<!--SLF4J-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.7</version>
        </dependency>

为了让Log4J起作用，必须在main/resources目录下创建一个名为log4j.properties的文件，内容如下：

log4j.rootLogger=ERROR,console,file


log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%m%n


log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.File=${user.home}/logs/book.log
log4j.appender.file.DatePattern='_'yyyyMMDD
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{HH:mm:ss,SSS} %p %c (%L) -
%m%n


log4j.logger.org.jack=DEBUG

上面把日志级别设置为ERROR，并且提供了两种日志appender，分别是console与file。需要对这两种日志分别配置，然后指定只有org.jack包下的类才能输出DEBUG级别的日志。

添加MySQL依赖，用于提供JDBC实现，配置如下：

<!--Mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.33</version>
            <scope>runtime</scope>
        </dependency>

添加两个 Apache Commons 依赖 ，用于提供常用的工具类，配置如下：

<!--Apache Commons Lang-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.3.2</version>
        </dependency>

        <!--Apache Commons Collections-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.0</version>
        </dependency>

打开CustomerService，下面开始实现getCustomerList方法。

该方法需要获取List，也就是所有的客户信息（此时并没有考虑分页，后续会增加此特性），我们需要执行一条select语句（Statement），获取相应的结果集（ResultSet），然后将其放入一个List中。不过在查询之前，我们必须获取数据库连接（Connection）

我们可使用JDBC来完成以上的操作，为了让数据库信息可配置，我们在classpath下创建一个config.properties文件，该文件位于src/main/resources目录中（注意：对于Maven目录结构而言，classpath指的就是java与resources这两个根目录。）
config.properties文件的内容如下：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/demo
jdbc.username=root
jdbc.password=root

属性文件准备好了，那么我们还需要一个类来读取该属性文件，改名编写一个PropsUtil工具类来进行读取config.properties里面的内容，下面是PropsUtil工具类的代码：

package org.jack.com.util;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Created by jack on 2015/12/26.
 * 属性文件工具类
 */
public final class PropsUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(PropsUtil.class);

    /*
    * 加载属性文件
    *
    * */
    public static Properties loadProps(String fileName) {
        Properties properties = null;
        InputStream inputStream = null;
        try {
            inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(fileName);
            if (inputStream == null) {
                throw new FileNotFoundException(fileName + " file is not found!");
            }
            properties = new Properties();
            properties.load(inputStream);
        } catch (IOException e) {
            LOGGER.error("load properties file failure", e);
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    LOGGER.error("close input stream failure", e);
                }
            }
        }
        return properties;
    }

    /*
    * 获取字符型属性（默认为空字符串）
    *
    * */
    public static String getString(Properties props, String key) {
        return getString(props, key, "");
    }

    /*
    * 获取字符型属性（可指定默认值）
    * */
    public static String getString(Properties props, String key, String
            defaultValue) {
        String value = defaultValue;
        if (props.containsKey(key)) {
            value = props.getProperty(key);
        }
        return value;
    }

    /*
    * 获取数值类型属性（默认为0）
    * */
    public static int getInt(Properties props, String key) {
        return getInt(props, key, 0);
    }

    /*
    * 获取数值类型属性（可指定默认值）
    * */
    public static int getInt(Properties props, String key, int defaultValue) {
        int value = defaultValue;
        if (props.containsKey(key)) {
            value = CastUtil.castInt(props.getProperty(key));
        }
        return value;
    }

    /*
    * 获取布尔型属性（默认值为false）
    * */
    public static boolean getBoolean(Properties props, String key) {
        return getBoolean(props, key, false);
    }

    /*
    * 获取布尔型属性（可指定默认值）
    * */
    public static boolean getBoolean(Properties props, String key, Boolean defaultValue) {
        boolean value = defaultValue;
        if (props.containsKey(key)) {
            value = CastUtil.castBoolean(props.getProperty(key));
        }
        return value;
    }
}

上面的类中，最关键的是loadProps方法，我们只需传递属性文件的名称，即可返回一个Properties对象，然后再根据getString，getInt，getBoolean这些方法由key获取指定类型的value，同时也可指定defaultValue作为默认值。

在PropsUtil类中，我们用到了CastUtil类，该类是为处理一些数据转型操作而作准备的，代码如下：

<pre name="code" class="java">package org.jack.com.util;

import org.apache.commons.lang3.StringUtils;

/**
 * Created by jack on 2015/12/26.
 * 转型操作工具类
 */
public final class CastUtil {
    /*
    * 转为String型
    * */
    public static String castString(Object obj) {
        return CastUtil.castString(obj, "");
    }

    /*
    * 转为String型（提供默认值）
    * */
    public static String castString(Object obj, String defaultValue) {
        return obj != null ? String.valueOf(obj) : defaultValue;
    }

    /*
    * 转为double型
    * */
    public static double castDouble(Object obj) {
        return castDouble(obj, 0);
    }

    /*
    * 转为double型（提供默认值）
    * */
    public static double castDouble(Object obj, Double defaultValue) {
        double doubleValue = defaultValue;
        if (obj != null) {
            String strValue = castString(obj);
            if (StringUtils.isNotEmpty(strValue)) {
                try {
                    doubleValue = Double.parseDouble(strValue);
                } catch (NumberFormatException e) {
                    defaultValue = defaultValue;
                }

            }
        }
        return doubleValue;
    }

    /*
    * 转为long型
    * */
    public static long castLong(Object obj) {
        return castLong(obj, 0);
    }

    /*
     * 转为long型（提供默认值）
     * */
    public static long castLong(Object obj, long defaultValue) {
        long longValue = defaultValue;
        if (obj != null) {
            String strValue = castString(obj);
            if (StringUtils.isNotEmpty(strValue)) {
                try {
                    longValue = Long.parseLong(strValue);
                }catch (NumberFormatException e){
                    longValue=defaultValue;
                }

            }
        }
        return longValue;
    }

    /*
    * 转为int型
    * */
    public static int castInt(Object obj){
        return castInt(obj,0);
    }
    /*
    * 转为int型(提供默值)
    * */
    public static int castInt(Object obj,int defaultValue){
        int intValue=defaultValue;
        if (obj!=null){
            String strValue=castString(obj);
            if(StringUtils.isNotEmpty(strValue)){
                try {
                    intValue=Integer.parseInt(strValue);
                }catch (NumberFormatException e){
                    intValue=defaultValue;
                }

            }
        }
        return intValue;
    }

    /*
    * 转为boolean型
    * */
    public static boolean castBoolean(Object obj){
        return castBoolean(obj,false);
    }
    /*
    * 转为boolean型(提供默认值)
    * */
    public static boolean castBoolean(Object obj,boolean defaultValue){
        boolean booleanValue=defaultValue;
        if(obj!=null){
            booleanValue=Boolean.parseBoolean(castString(obj));
        }
        return booleanValue;
    }

}

在CastUtil类中，我们用到了StringUtil类，它用于提供一些字符串操作，代码如下：

package org.jack.com.util;

import org.apache.commons.lang3.StringUtils;

/**
 * Created by jack on 2015/12/26.
 * 字符串工具类
 */
public final class StringUtil {
    /*
    * 判断字符串是否为空
    * */
    public static boolean isEmpty(String str){
        if(str != null){
            str=str.trim();
        }
        return StringUtils.isEmpty(str);
    }
    /*
    * 判断字符串是否非空
    * */
    public static boolean isNotEmpty(String str){
        return !isEmpty(str);
    }
 }

上面只是对Apache Commons类库做了一个简单的封装。同理，我们可以做一个CollectionUtil，用于提供一些集合操作，代码如下：

package org.jack.com.util;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;

import java.util.Collection;
import java.util.Map;

/**
 * Created by jack on 2015/12/26.
 * 集合工具类
 */
public final class CollectionUtil {
    /**
     * 判断Collection是否为空
     */
    public static boolean isEmpty(Collection<?> collection){
        return CollectionUtils.isEmpty(collection);
    }
    /**
     *判断Collection是否非空
     */
    public static boolean isNotEmpty(Collection<?> collection){
        return !isEmpty(collection);
    }
    /**
     * 判断Map是否为空
     */
    public static boolean isEmpty(Map<?,?> map){
        return MapUtils.isEmpty(map);
    }
    /**
     * 判断Map是否非空
     */
    public static boolean isNotEmpty(Map<?,?> map){
        return !isEmpty(map);
    }
}

上面我们写了四个工具类，每个工具类的分工各不相同，它们在后面还会经常用到，并且会不断完善这些工具类。

现在回到CustomerService，我们需要在该类中执行数据库操作，也就是需要编写一些JDBC的代码，首先使用PropsUtil读取config.properties配置文件，获取与JDBC相关的配置项。

我们在CustomerService中为这些配置项定义一些常量，并提供一个“静态代码块”，来初始化这些常量，就像下面这样：

private static final String DRIVER;
    private static final String URL;
    private static final String USERNAME;
    private static final String PASSWORD;

    static {
        Properties conf= PropsUtil.loadProps("config.properties");
        DRIVER=conf.getProperty("jdbc:driver");
        URL=conf.getProperty("jdbc.url");
        USERNAME= conf.getProperty("jdbc.username");
        PASSWORD=conf.getProperty("jdbc.password");
    }

以getCustomerList为例，我们可以这样写JDBC代码：

<pre name="code" class="java"><pre name="code" class="java">package org.jack.com.service;

import org.jack.com.model.Customer;
import org.jack.com.util.PropsUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.*;
import java.util.*;

/**
 * Created by jack on 2015/11/29.
 * 提供客户数据服务
 */
public class CustomerService {
    private static final String DRIVER;
    private static final String URL;
    private static final String USERNAME;
    private static final String PASSWORD;
    private static final Logger LOGGER = LoggerFactory.getLogger(CustomerService.class);
    static {
        Properties conf= PropsUtil.loadProps("config.properties");
        DRIVER=conf.getProperty("jdbc.driver");
        URL=conf.getProperty("jdbc.url");
        USERNAME= conf.getProperty("jdbc.username");
        PASSWORD=conf.getProperty("jdbc.password");
        try{
            Class.forName(DRIVER);
        }catch (ClassNotFoundException e){
            LOGGER.error("can not load jdbc driver",e);
        }
    }

    /*
    * 获取客户列表
    * */
    public List<Customer> getCustomerList(String keyword){
        //to do something
        Connection conn=null;
        try{
            List<Customer> customerList=new ArrayList<Customer>();
            String sql="select * from customer";
            conn= DriverManager.getConnection(URL,USERNAME,PASSWORD);
            PreparedStatement pstmt=conn.prepareStatement(sql);
            ResultSet rs=pstmt.executeQuery();
            while(rs.next()){
                Customer customer=new Customer();
                customer.setId(rs.getLong("id"));
                customer.setName(rs.getString("name"));
                customer.setContact(rs.getString("contact"));
                customer.setTelephone(rs.getString("telephone"));
                customer.setEmail(rs.getString("email"));
                customer.setRemark(rs.getString("remark"));
                customerList.add(customer);
            }
            return customerList;
        }catch (SQLException e){
            LOGGER.error("execute sql failure",e);
        }finally {
            if (conn !=null){
                try {
                    conn.close();
                }catch (SQLException e){
                    LOGGER.error("close connection failure",e);
                }
            }
        }
        return  null;
    }

    /*
    * 获取客户
    * */
    public  Customer getCustomer(long id){
        //to do something
        return null;
    }

    /*
    * 创建客户
    * */
    public boolean createCustomer(Map<String,Object> fieldMap){
        //to do something
        return false;
    }

    /*
    * 更新客户
    * */
    public boolean updateCustomer(long id,Map<String,Object> fieldMap){
        //to do something
        return false;
    }

    /*
    * 删除客户
    * */
    public boolean deleteCustomer(long id){
        //to do something
        return false;
    }

   }

选中getCustomerList方法右击，选择run进行单元测试，如果没有错误的话，应该是“绿条”，表示可以测试通过，相反，如果出现“红条”就表示测试失败，我们可以查看控制台以了解具体的错误原因。正确的测试结果如下图：

虽然以上的代码可以运行，基本的功能是可以实现的，但是问题还很多，具体包括以下2个方面：

1）在CustomerService类中读取config.properties文件，这是不合理的，毕竟将来还有很多其他Service类需要做同样的事情，我们最好能将这些公共性的代码提起出来。

2）执行一条select语句需要编写一大堆代码，而且必须使用try........catch.....finally结构，开发效率明显不高。

那么问题来了，我们该如何解决这两个问题？首先我们来解决第一个问题。

创建一个org.jack.com.helper包，在该包中创建一个DatabaseHelper类，代码如下：

package org.jack.com.helper;

import org.jack.com.util.PropsUtil;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;

/**
 * Created by jack on 2015/12/26.
 * 数据库操作助手类
 */
public final class DatabaseHelper {
    private static final Logger LOGGER= LoggerFactory.getLogger(DatabaseHelper.class);
    private static final String DRIVER;
    private static final String URL;
    private static final String USERNAME;
    private static final String PASSWORD;

    static {
        Properties conf= PropsUtil.loadProps("config.properties");
        DRIVER=conf.getProperty("jdbc.driver");
        URL=conf.getProperty("jdbc.url");
        USERNAME=conf.getProperty("jdbc.username");
        PASSWORD=conf.getProperty("jdbc.password");
        try{
            Class.forName(DRIVER);
        }catch (ClassNotFoundException e){
            LOGGER.error("can not load jdbc driver",e);
        }
    }
    /**
     * 获取数据库连接
     */
    public static Connection getConnection(){
        Connection conn=null;
        try {
            conn= DriverManager.getConnection(URL,USERNAME,PASSWORD);
        }catch (SQLException e){
            LOGGER.error("get connection failure",e);
        }
        return conn;
    }

    /**
     * 关闭数据库连接
     */
    public static void closeConnection(Connection conn){
        if(conn != null){
            try {
                conn.close();
            }catch (SQLException e){
                LOGGER.error("close connection failure",e);
            }
        }
    }

}

在DatabaseHelper中包含一些静态方法，用它们来封装数据库的相关操作，目前提供了“获取数据库连接”与“关闭数据库连接”两个助手方法。

现在CustomerService可以稍微的简化下了：

package org.jack.com.service;

import org.jack.com.helper.DatabaseHelper;
import org.jack.com.model.Customer;
import org.jack.com.util.PropsUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.*;
import java.util.*;

/**
 * Created by jack on 2015/11/29.
 * 提供客户数据服务
 */
public class CustomerService {
    /*private static final String DRIVER;
    private static final String URL;
    private static final String USERNAME;
    private static final String PASSWORD;*/
    private static final Logger LOGGER = LoggerFactory.getLogger(CustomerService.class);
    /*static {
        Properties conf= PropsUtil.loadProps("config.properties");
        DRIVER=conf.getProperty("jdbc.driver");
        URL=conf.getProperty("jdbc.url");
        USERNAME= conf.getProperty("jdbc.username");
        PASSWORD=conf.getProperty("jdbc.password");
        try{
            Class.forName(DRIVER);
        }catch (ClassNotFoundException e){
            LOGGER.error("can not load jdbc driver",e);
        }
    }*/

    /*
    * 获取客户列表
    * */
    public List<Customer> getCustomerList(String keyword){
        //to do something
        Connection conn=null;
        try{
            List<Customer> customerList=new ArrayList<Customer>();
            String sql="select * from customer";
            conn= DatabaseHelper.getConnection();//1
            PreparedStatement pstmt=conn.prepareStatement(sql);
            ResultSet rs=pstmt.executeQuery();
            while(rs.next()){
                Customer customer=new Customer();
                customer.setId(rs.getLong("id"));
                customer.setName(rs.getString("name"));
                customer.setContact(rs.getString("contact"));
                customer.setTelephone(rs.getString("telephone"));
                customer.setEmail(rs.getString("email"));
                customer.setRemark(rs.getString("remark"));
                customerList.add(customer);
            }
            return customerList;
        }catch (SQLException e){
            LOGGER.error("execute sql failure",e);
        }finally {
            /*if (conn !=null){
                try {
                    conn.close();
                }catch (SQLException e){
                    LOGGER.error("close connection failure",e);
                }
            }*/
            DatabaseHelper.closeConnection(conn);//2
        }
        return null;
    }

    /*
    * 获取客户
    * */
    public  Customer getCustomer(long id){
        //to do something
        return null;
    }

    /*
    * 创建客户
    * */
    public boolean createCustomer(Map<String,Object> fieldMap){
        //to do something
        return false;
    }

    /*
    * 更新客户
    * */
    public boolean updateCustomer(long id,Map<String,Object> fieldMap){
        //to do something
        return false;
    }

    /*
    * 删除客户
    * */
    public boolean deleteCustomer(long id){
        //to do something
        return false;
    }

   }

注意以上代码1，2两处的修改，的确简化了一些，至少每个Service类不会出现那些静态变量与代码块了，公共的代码放到了DatabaseHelper中从而得到了重用。

下面我们来解决第二个问题，实际上就是如何使代码变得更加精简。

著名的Apache Common项目中有一款名为DbUtils的类库，为我们提供了一个JDBC的封装，下面我们就用这款工具来解决该问题。

首先，需要在pom.xml中添加一个DbUtils的依赖：

<!--Apache Commons DbUtils-->
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
        </dependency>

然后，在DatabaseHelper中添加如下代码：

package org.jack.com.helper;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.jack.com.util.PropsUtil;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import java.util.Properties;

/**
 * Created by jack on 2015/12/26.
 * 数据库操作助手类
 */
public final class DatabaseHelper {
    private static final Logger LOGGER= LoggerFactory.getLogger(DatabaseHelper.class);
    private static final String DRIVER;
    private static final String URL;
    private static final String USERNAME;
    private static final String PASSWORD;

    static {
        Properties conf= PropsUtil.loadProps("config.properties");
        DRIVER=conf.getProperty("jdbc.driver");
        URL=conf.getProperty("jdbc.url");
        USERNAME=conf.getProperty("jdbc.username");
        PASSWORD=conf.getProperty("jdbc.password");
        try{
            Class.forName(DRIVER);
        }catch (ClassNotFoundException e){
            LOGGER.error("can not load jdbc driver",e);
        }
    }

    private static final QueryRunner QUERY_RUNNER=new QueryRunner();

    /**
     * 获取数据库连接
     */
    public static Connection getConnection(){
        Connection conn=null;
        try {
            conn= DriverManager.getConnection(URL,USERNAME,PASSWORD);
        }catch (SQLException e){
            LOGGER.error("get connection failure",e);
        }
        return conn;
    }

    /**
     * 关闭数据库连接
     */
    public static void closeConnection(Connection conn){
        if(conn != null){
            try {
                conn.close();
            }catch (SQLException e){
                LOGGER.error("close connection failure",e);
            }
        }
    }

    /**
     * 查询实体列表
     */
    public static <T> List<T> queryEntityList(Class<T> entityClass,String sql,Object... params){
        List<T> entityList;
        Connection conn=getConnection();
        try{
            entityList=QUERY_RUNNER.query(conn,sql,new BeanListHandler<T>(entityClass),params);
        }catch (SQLException e){
            LOGGER.error("query entity list failure",e);
            throw new RuntimeException(e);
        }finally {
            closeConnection(conn);
        }
        return entityList;
    }

}

注意，上面的queryEntityList方法还有问题，在下面进行改进。使用DbUtils提供的QueryRunner对象可以面向实体（Entity）进行查询。

实际上，DbUtils首先执行SQL语句并返回一个ResultSet，随后通过反射去创建并初始化实体对象。由于我们需要返的是List，因此可以使用BeanListHandler。

最后，改写CustomerService的getCustomerList方法：

 /*
    * 获取客户列表
    * */
    public List<Customer> getCustomerList(){
        //to do something
        Connection conn=DatabaseHelper.getConnection();;
        try{

            String sql="select * from customer";

            return DatabaseHelper.queryEntityList(Customer.class,conn,sql);
        }catch (SQLException e){
            LOGGER.error("execute sql failure",e);
        }finally {

            DatabaseHelper.closeConnection(conn);//2
        }
        return null;
    }

上面的代码，有问题，下面会进行改进。

现在的代码简单了很多，我们不再面对PrepareStatement与ResultSet了，只需要使用DatabaseHelper就能执行数据库操作。我们每次都需要创建一个Connection，然后进行数据库操作，最后关闭Connection。

如何能让Connection对开发人员透明？也就是说，如何隐藏掉创建与关闭Connection的代码呢？

为了确保一个线程只有一个Connection，我们可以使用ThreadLocal来存放本地线程变量。也就是说，将当前线程中的Connection放入ThreadLocal中存起来，这些Connection一定不会出现不安全问题，可以将ThreadLocal理解为一个隔离线程的容器。

现在对DatabaseHelper进行调整，具体代码如下：

package org.jack.com.helper;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.jack.com.util.PropsUtil;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import java.util.Properties;

/**
 * Created by jack on 2015/12/26.
 * 数据库操作助手类
 */
public final class DatabaseHelper {
    private static final Logger LOGGER = LoggerFactory.getLogger(DatabaseHelper.class);
    private static final String DRIVER;
    private static final String URL;
    private static final String USERNAME;
    private static final String PASSWORD;

    static {
        Properties conf = PropsUtil.loadProps("config.properties");
        DRIVER = conf.getProperty("jdbc.driver");
        URL = conf.getProperty("jdbc.url");
        USERNAME = conf.getProperty("jdbc.username");
        PASSWORD = conf.getProperty("jdbc.password");
        try {
            Class.forName(DRIVER);
        } catch (ClassNotFoundException e) {
            LOGGER.error("can not load jdbc driver", e);
        }
    }

    private static final QueryRunner QUERY_RUNNER = new QueryRunner();
    private static final ThreadLocal<Connection> CONNECTION_HOLDER = new ThreadLocal<Connection>();

    /**
     * 获取数据库连接
     */
    public static Connection getConnection() {
        Connection conn = CONNECTION_HOLDER.get();//1
        if (conn == null) {
            try {
                conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
            } catch (SQLException e) {
                LOGGER.error("get connection failure", e);
            } finally {
                CONNECTION_HOLDER.set(conn);
            }
        }
        return conn;
    }

    /**
     * 关闭数据库连接
     */
    public static void closeConnection() {
        Connection conn=CONNECTION_HOLDER.get();//1
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                LOGGER.error("close connection failure", e);
                throw new RuntimeException(e);
            }finally {
                CONNECTION_HOLDER.remove();//3
            }
        }
    }

    /**
     * 查询实体列表
     */
    public static <T> List<T> queryEntityList(Class<T> entityClass, String sql, Object... params) {
        List<T> entityList;

        try {
            Connection conn = getConnection();
            entityList = QUERY_RUNNER.query(conn, sql, new BeanListHandler<T>(entityClass), params);
        } catch (SQLException e) {
            LOGGER.error("query entity list failure", e);
            throw new RuntimeException(e);
        } finally {
            closeConnection();
        }
        return entityList;
    }

}

每次获取Connection时，首先在ThreadLocal中寻找（见1），若不存在，则创建一个新的Connection，并将其放入ThreadLocal中（见2）。当Connection使用完毕后，需要移除ThreadLocal中持有的Connection（见3）
现在CustomerService的getCustomerList方法看起来更加简单了：

package org.jack.com.service;

import org.jack.com.helper.DatabaseHelper;
import org.jack.com.model.Customer;
import org.jack.com.util.PropsUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.*;
import java.util.*;

/**
 * Created by jack on 2015/11/29.
 * 提供客户数据服务
 */
public class CustomerService {
    private static final Logger LOGGER = LoggerFactory.getLogger(CustomerService.class);

    /*
    * 获取客户列表
    * */
    public List<Customer> getCustomerList(){
        //to do something
        String sql="select * from customer";
        return DatabaseHelper.queryEntityList(Customer.class,sql);

    }

    /*
    * 获取客户
    * */
    public  Customer getCustomer(long id){
        //to do something
        return null;
    }

    /*
    * 创建客户
    * */
    public boolean createCustomer(Map<String,Object> fieldMap){
        //to do something
        return false;
    }

    /*
    * 更新客户
    * */
    public boolean updateCustomer(long id,Map<String,Object> fieldMap){
        //to do something
        return false;
    }

    /*
    * 删除客户
    * */
    public boolean deleteCustomer(long id){
        //to do something
        return false;
    }

   }

使用同样的技巧，我们可以在DatabaseHelper中添加一个queryEntity方法，用户查询单个实体对象。

 /**
     * 查询实体
     */
    public static <T> T queryEntity(Class<T> entityClass,String sql,Object... params){
        T entity;
        try {
            Connection conn=getConnection();
            entity=QUERY_RUNNER.query(conn,sql,new BeanHandler<T>(entityClass),params);
        }catch (SQLException e){
            LOGGER.error("query entity failure",e);
            throw new RuntimeException(e);
        }finally {
            closeConnection();
        }
        return entity;
    }

需要注意的是，此时我们使用的BeanHandler，而不是BeanListHandler。实际上，DbUtils为我们提供了很多类似的Handler，包括：

BeanHandler-------------------------------返回Bean

BeanListHandler---------------------------返回List对象

BeanMapHandler--------------------------返回Map对象

ArrayHandler-----------------------------返回Object[]对象

ArrayListHandler---------------------------返回List对象

MapHandler--------------------------------返回Map对象

MapListHandler---------------------------返回List对象

ScalarHandler----------------------------返回某列的值

ColumnListHandler--------------------------返回某列的值列表

KeyedHandler-----------------------------------返回Map对象，需指定列名。

以上这些Handler都实现了ResultSetHandler。

查询并不一定是基于单表的，将来有可能连接多个表进行查询，因此我们有必要提供一个更为强大的查询方法，输入一个SQL与动态参数，输入一个List对象，其中的Map表示列名与列值得映射关系。

我们可以借助MapListHandler轻松实现：

   /**
     * 执行查询
     */
    public static List<Map<String,Object>> executeQuery(String sql,Object...params){
        List<Map<String,Object>> result;
        try {
            Connection conn=getConnection();
            result=QUERY_RUNNER.query(conn,sql,new MapListHandler(),params)
        }catch (Exception e){
            LOGGER.error("execute query failure",e);
            throw new RuntimeException(e);
        }
        return result;
    }

除了查询语句以外，还包括几种更新语句，例如update，insert，delete等，我们再提供一个通用的执行更新语句的方法。

/**
     * 执行更新语句（包括update，inert，delete）
     */
    public static int executeUpdate(String sql,Object... params){
        int rows=0;
        try {
            Connection conn=getConnection();
            rows=QUERY_RUNNER.update(conn,sql,params);
        }catch (SQLException e){
            LOGGER.error("execute update failure",e);
            throw new RuntimeException(e);
        }finally {
            closeConnection();
        }
        return rows;
    }

该方法返回执行后受影响的行数，也就是说，更新了多少条记录。根据这个通用的方法，我们可以分别提供三种具体的数据库更新操作：

package org.jack.com.helper;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.jack.com.util.CollectionUtil;
import org.jack.com.util.PropsUtil;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Properties;

/**
 * Created by jack on 2015/12/26.
 * 数据库操作助手类
 */
public final class DatabaseHelper {
    private static final Logger LOGGER = LoggerFactory.getLogger(DatabaseHelper.class);
    private static final String DRIVER;
    private static final String URL;
    private static final String USERNAME;
    private static final String PASSWORD;

    static {
        Properties conf = PropsUtil.loadProps("config.properties");
        DRIVER = conf.getProperty("jdbc.driver");
        URL = conf.getProperty("jdbc.url");
        USERNAME = conf.getProperty("jdbc.username");
        PASSWORD = conf.getProperty("jdbc.password");
        try {
            Class.forName(DRIVER);
        } catch (ClassNotFoundException e) {
            LOGGER.error("can not load jdbc driver", e);
        }
    }

    private static final QueryRunner QUERY_RUNNER = new QueryRunner();
    private static final ThreadLocal<Connection> CONNECTION_HOLDER = new ThreadLocal<Connection>();

    /**
     * 获取数据库连接
     */
    public static Connection getConnection() {
        Connection conn = CONNECTION_HOLDER.get();//1
        if (conn == null) {
            try {
                conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
            } catch (SQLException e) {
                LOGGER.error("get connection failure", e);
            } finally {
                CONNECTION_HOLDER.set(conn);
            }
        }
        return conn;
    }

    /**
     * 关闭数据库连接
     */
    public static void closeConnection() {
        Connection conn=CONNECTION_HOLDER.get();//1
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                LOGGER.error("close connection failure", e);
                throw new RuntimeException(e);
            }finally {
                CONNECTION_HOLDER.remove();
            }
        }
    }

    /**
     * 查询实体列表
     */
    public static <T> List<T> queryEntityList(Class<T> entityClass, String sql, Object... params) {
        List<T> entityList;

        try {
            Connection conn = getConnection();
            entityList = QUERY_RUNNER.query(conn, sql, new BeanListHandler<T>(entityClass), params);
        } catch (SQLException e) {
            LOGGER.error("query entity list failure", e);
            throw new RuntimeException(e);
        } finally {
            closeConnection();
        }
        return entityList;
    }

    /**
     * 查询实体
     */
    public static <T> T queryEntity(Class<T> entityClass,String sql,Object... params){
        T entity;
        try {
            Connection conn=getConnection();
            entity=QUERY_RUNNER.query(conn,sql,new BeanHandler<T>(entityClass),params);
        }catch (SQLException e){
            LOGGER.error("query entity failure",e);
            throw new RuntimeException(e);
        }finally {
            closeConnection();
        }
        return entity;
    }

    /**
     * 执行查询
     */
    public static List<Map<String,Object>> executeQuery(String sql,Object...params){
        List<Map<String,Object>> result;
        try {
            Connection conn=getConnection();
            result=QUERY_RUNNER.query(conn,sql,new MapListHandler(),params);
        }catch (Exception e){
            LOGGER.error("execute query failure",e);
            throw new RuntimeException(e);
        }
        return result;
    }

    /**
     * 执行更新语句（包括update，inert，delete）
     */
    public static int executeUpdate(String sql,Object... params){
        int rows=0;
        try {
            Connection conn=getConnection();
            rows=QUERY_RUNNER.update(conn,sql,params);
        }catch (SQLException e){
            LOGGER.error("execute update failure",e);
            throw new RuntimeException(e);
        }finally {
            closeConnection();
        }
        return rows;
    }
    /**
     * 插入实体
     */
    public static <T> boolean insertEntity(Class<T> entityClass,Map<String,Object> fieldMap){
        if(CollectionUtil.isEmpty(fieldMap)){
            LOGGER.error("can not insert entity:fieldMap is empty");
            return false;
        }
        String sql="INSERT INTO "+getTableName(entityClass);
        StringBuilder columns=new StringBuilder("(");
        StringBuilder values=new StringBuilder("(");
        for (String fieldName : fieldMap.keySet()){
            columns.append(fieldName).append(", ");
            values.append("?, ");
        }
        columns.replace(columns.lastIndexOf(", "),columns.length(),") ");
        values.replace(values.lastIndexOf(", "),values.length(),") ");
        sql +=columns + " VALUES " + values;

        Object[] params=fieldMap.values().toArray();
        return executeUpdate(sql,params) == 1;
    }

    /**
     * 更新实体
     * @param entityClass
     * @return boolean
     */
    public static <T> boolean updateEntity(Class<T> entityClass,long id,Map<String,Object> fieldMap){
        if (CollectionUtil.isEmpty(fieldMap)){
            LOGGER.error("can not update entity:fieldMap is empty");
            return false;
        }

        String sql="UPDATE " + getTableName(entityClass) + " SET ";
        StringBuilder columns=new StringBuilder();
        for (String fieldName : fieldMap.keySet()){
            columns.append(fieldName).append("=?, ");
        }
        sql += columns.substring(0,columns.lastIndexOf(", ")) +"WHERE id =?";
        List<Object> paramList =new ArrayList<Object>();
        paramList.addAll(fieldMap.values());
        paramList.add(id);
        Object[] params=paramList.toArray();
        return executeUpdate(sql,params) == 1;
    }

    /**
     * 删除实体
     * @param entityClass
     * @return
     */
    public static <T> boolean deleteEntity(Class<T> entityClass,long id){
        String sql="DELETE FROM "+getTableName(entityClass)+" WHERE id=?";
        return executeUpdate(sql,id) == 1;
    }

    private static String getTableName(Class<?> entityClass){
        return entityClass.getSimpleName();//返回类名
    }

}

有了insertEntity，updateEntity，deleteEntity后，我们可以快速完成CustomerService中剩下的几个方法：

package org.jack.com.service;

import org.jack.com.helper.DatabaseHelper;
import org.jack.com.model.Customer;
import org.jack.com.util.PropsUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.*;
import java.util.*;

/**
 * Created by jack on 2015/11/29.
 * 提供客户数据服务
 */
public class CustomerService {
    private static final Logger LOGGER = LoggerFactory.getLogger(CustomerService.class);

    /*
    * 获取客户列表
    * */
    public List<Customer> getCustomerList(){
        //to do something
        String sql="select * from customer";
        return DatabaseHelper.queryEntityList(Customer.class,sql);

    }

    /*
    * 获取客户
    * */
    public  Customer getCustomer(long id){
        //to do something
        String sql = "SELECT * FROM customer WHERE id = ?";
        return DatabaseHelper.queryEntity(Customer.class, sql, id);
    }

    /*
    * 创建客户
    * */
    public boolean createCustomer(Map<String,Object> fieldMap){
        //to do something

        return DatabaseHelper.insertEntity(Customer.class,fieldMap);
    }

    /*
    * 更新客户
    * */
    public boolean updateCustomer(long id,Map<String,Object> fieldMap){
        //to do something
        return DatabaseHelper.updateEntity(Customer.class,id,fieldMap);
    }

    /*
    * 删除客户
    * */
    public boolean deleteCustomer(long id){
        //to do something
        return DatabaseHelper.deleteEntity(Customer.class,id);
    }

   }

现在CustomerService的实现相当精简了，只需要一两行代码即可完成表单的“增删改查”操作。像上面这样，每次需要数据库连接时，就调用getConnection方法，在数据库操作完毕以后，还需要调用closeConnection方法关闭数据库连接。虽然关闭数据库这件事情已经被DatabaseHelper类给封装了，当考虑到如果频繁调用getConnection方式就会频繁创建数据库连接，这样做一定会造成大量的系统开销，毕竟数据库的连接数是有限的。因此，需要考虑一种解决方案，将这些数据库连接进行“池话”，也就是说我们需要弄一个“数据库连接池”出来。Apache DBCP是最好的数据库连接池之一，下面我们就使用这个数据库连接池。

首先，修改pom.xml文件，添加如下的Maven依赖：

<!--Apache DBCP数据库连接池依赖-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.0.1</version>
        </dependency>

然后修改DatabaseHelper的相关代码

package org.jack.com.helper;

import org.apache.commons.dbcp2.BasicDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.jack.com.util.CollectionUtil;
import org.jack.com.util.PropsUtil;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Properties;

/**
 * Created by jack on 2015/12/26.
 * 数据库操作助手类
 */
public final class DatabaseHelper {
    private static final Logger LOGGER = LoggerFactory.getLogger(DatabaseHelper.class);

    //查询
    private static final QueryRunner QUERY_RUNNER;
    //保证一个线程一个Connection，线程安全
    private static final ThreadLocal<Connection> CONNECTION_HOLDER ;
    //线程池
    private static final BasicDataSource DATA_SOURCE;

    static {
        CONNECTION_HOLDER = new ThreadLocal<Connection>();
        QUERY_RUNNER = new QueryRunner();

        Properties conf = PropsUtil.loadProps("config.properties");
        String driver = conf.getProperty("jdbc.driver");
        String url = conf.getProperty("jdbc.url");
        String username = conf.getProperty("jdbc.username");
        String passwrod = conf.getProperty("jdbc.password");

        DATA_SOURCE=new BasicDataSource();
        DATA_SOURCE.setDriverClassName(driver);
        DATA_SOURCE.setUrl(url);
        DATA_SOURCE.setUsername(username);
        DATA_SOURCE.setPassword(passwrod);
    }

    /**
     * 获取数据库连接
     */
    public static Connection getConnection() {
        Connection conn = CONNECTION_HOLDER.get();//1
        if (conn == null) {
            try {
                conn = DATA_SOURCE.getConnection();
            } catch (SQLException e) {
                LOGGER.error("get connection failure", e);
                throw new RuntimeException(e);
            } finally {
                CONNECTION_HOLDER.set(conn);
            }
        }
        return conn;
    }



    /**
     * 查询实体列表
     */
    public static <T> List<T> queryEntityList(Class<T> entityClass, String sql, Object... params) {
        List<T> entityList;

        try {
            Connection conn = getConnection();
            entityList = QUERY_RUNNER.query(conn, sql, new BeanListHandler<T>(entityClass), params);
        } catch (SQLException e) {
            LOGGER.error("query entity list failure", e);
            throw new RuntimeException(e);
        }
        return entityList;
    }

    /**
     * 查询实体
     */
    public static <T> T queryEntity(Class<T> entityClass,String sql,Object... params){
        T entity;
        try {
            Connection conn=getConnection();
            entity=QUERY_RUNNER.query(conn,sql,new BeanHandler<T>(entityClass),params);
        }catch (SQLException e){
            LOGGER.error("query entity failure",e);
            throw new RuntimeException(e);
        }
        return entity;
    }

    /**
     * 执行查询
     */
    public static List<Map<String,Object>> executeQuery(String sql,Object...params){
        List<Map<String,Object>> result;
        try {
            Connection conn=getConnection();
            result=QUERY_RUNNER.query(conn,sql,new MapListHandler(),params);
        }catch (Exception e){
            LOGGER.error("execute query failure",e);
            throw new RuntimeException(e);
        }
        return result;
    }

    /**
     * 执行更新语句（包括update，inert，delete）
     */
    public static int executeUpdate(String sql,Object... params){
        int rows=0;
        try {
            Connection conn=getConnection();
            rows=QUERY_RUNNER.update(conn,sql,params);
        }catch (SQLException e){
            LOGGER.error("execute update failure",e);
            throw new RuntimeException(e);
        }
        return rows;
    }
    /**
     * 插入实体
     */
    public static <T> boolean insertEntity(Class<T> entityClass,Map<String,Object> fieldMap){
        if(CollectionUtil.isEmpty(fieldMap)){
            LOGGER.error("can not insert entity:fieldMap is empty");
            return false;
        }
        String sql="INSERT INTO "+getTableName(entityClass);
        StringBuilder columns=new StringBuilder("(");
        StringBuilder values=new StringBuilder("(");
        for (String fieldName : fieldMap.keySet()){
            columns.append(fieldName).append(", ");
            values.append("?, ");
        }
        columns.replace(columns.lastIndexOf(", "),columns.length(),") ");
        values.replace(values.lastIndexOf(", "),values.length(),") ");
        sql +=columns + " VALUES " + values;

        Object[] params=fieldMap.values().toArray();
        return executeUpdate(sql,params) == 1;
    }

    /**
     * 更新实体
     * @param entityClass
     * @return boolean
     */
    public static <T> boolean updateEntity(Class<T> entityClass,long id,Map<String,Object> fieldMap){
        if (CollectionUtil.isEmpty(fieldMap)){
            LOGGER.error("can not update entity:fieldMap is empty");
            return false;
        }

        String sql="UPDATE " + getTableName(entityClass) + " SET ";
        StringBuilder columns=new StringBuilder();
        for (String fieldName : fieldMap.keySet()){
            columns.append(fieldName).append("=?, ");
        }
        sql += columns.substring(0,columns.lastIndexOf(", ")) +"WHERE id =?";
        List<Object> paramList =new ArrayList<Object>();
        paramList.addAll(fieldMap.values());
        paramList.add(id);
        Object[] params=paramList.toArray();
        return executeUpdate(sql,params) == 1;
    }

    /**
     * 删除实体
     * @param entityClass
     * @return
     */
    public static <T> boolean deleteEntity(Class<T> entityClass,long id){
        String sql="DELETE FROM "+getTableName(entityClass)+" WHERE id=?";
        return executeUpdate(sql,id) == 1;
    }

    private static String getTableName(Class<?> entityClass){
        return entityClass.getSimpleName();//返回类名
    }

}

我们使用Apache DBCP的org.apache.commons.dbcp2.BasicDataSource来获取数据库连接，只需要保证该对象是静态的就行了，通过设置driver,url,username,password来初始化BasicDataSource，并调用其getConnection方法即可获取数据库连接。

最后，删除以前的closeConnection方法，同时去掉所有closeConnection的finally代码块。

我们可以运行CustomerServiceTest单元测试类的相关测试方法来验证以上代码的正确性。现在的单元测试存在一个非常严重的问题，比如执行完deleteCustomerTest方法，就不能继续执行getCustomerTest方法了，原因很简单，在测试之前数据库的数据无法自动还原为初始状态。

JUnit在调用每个@Test方法前，都会调用@Before方法，也就是我们在单元测试类里定义的init，目前在该方法中预留一个to do something，需要在这里初始化数据库，为我们准备一个便于测试的数据库环境。

此外，为了测试数据库与开发数据库分离，也就是，应该是两个数据库，只是表结构相同而已。我们需要为单元测试单独创建一个数据库，不妨命名为demo_test，需要将demo数据库的customer表复制到demo_test数据库中。

在Navicat premium中创建demo_test数据库，具体的创建过程前面的笔记有讲解过。然后我们在进行如下具体操作：

1）进入demo数据库，选中customer表，使用ctr+c复制表。

2）进入demo_test数据库，使用ctrl+v键粘贴表，即可复制数据表。

3）在demo_test数据库中，选中customer表，单击右键，单击Truncate Table（或者清空表）菜单项，即可清空表中所有的数据（id将从1开始自增）

随后，我们需要准备一个customer_init.sql文件，用于存放所有的insert语句，该文件位于test/resources/sql目录下，具体内容如下：

<pre style="background-color:#2b2b2b;color:#a9b7c6;font-family:'Consolas';font-size:16pt;">TRUNCATE customer<span style="color:#cc7832;">;
</span><span style="color:#cc7832;"><strong>INSERT INTO </strong></span>customer (<span style="color:#cc7832;"><strong>name </strong></span><span style="color:#cc7832;">,</span>contact<span style="color:#cc7832;">,</span>telephone<span style="color:#cc7832;">,</span>email<span style="color:#cc7832;">,</span>remark) <span style="color:#cc7832;"><strong>VALUES </strong></span>(<span style="color:#a5c261;"><strong>'customer1'</strong></span><span style="color:#cc7832;">,</span><span style="color:#a5c261;"><strong>'jack'</strong></span><span style="color:#cc7832;">,</span><span style="color:#a5c261;"><strong>'13512345678'</strong></span><span style="color:#cc7832;">,</span><span style="color:#a5c261;"><strong>'jack@gmail.com'</strong></span><span style="color:#cc7832;">,</span><span style="color:#cc7832;"><strong>null</strong></span>)<span style="color:#cc7832;">;
</span><span style="color:#cc7832;"><strong>INSERT INTO </strong></span>customer (<span style="color:#cc7832;"><strong>name </strong></span><span style="color:#cc7832;">,</span>contact<span style="color:#cc7832;">,</span>telephone<span style="color:#cc7832;">,</span>email<span style="color:#cc7832;">,</span>remark) <span style="color:#cc7832;"><strong>VALUES </strong></span>(<span style="color:#a5c261;"><strong>'customer2'</strong></span><span style="color:#cc7832;">,</span><span style="color:#a5c261;"><strong>'rose'</strong></span><span style="color:#cc7832;">,</span><span style="color:#a5c261;"><strong>'13623456789'</strong></span><span style="color:#cc7832;">,</span><span style="color:#a5c261;"><strong>'rose@gmail.com'</strong></span><span style="color:#cc7832;">,</span><span style="color:#cc7832;"><strong>null</strong></span>)<span style="color:#cc7832;">;</span>

注意，上面的插入语句要全部在同一行，我们需要先执行TRUNCATE语句，清空左右数据，然后再执行INSERT语句，插入相关数据。这里并不需要提供id列，因为该列是自增的。

注意：默认情况下IDEA不会再test目录下自动创建resources目录，也就是我们需要手动创建，可使用Alt+Insert快捷键来完成。创建resources目录完毕后，需要右键单击该目录，单击Mark Directory As/Resources Root，将该目录设置为Maven的测试资源目录。需要注意的是，main/java, main/resources, test/java, test/resources这四个目录都是classpath的根目录，当运行单元测试时，遵循“就近原则”，即优先从test/java，test/resources加载类或读取文件。

现在test目录结构如下图：

既然已经为单元测试准备了独立的测试数据库，那么就有必要在test/resources目录下提供一个config.properties文件，用于提供测试数据库的相关配置：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/demo_test
jdbc.username=root
jdbc.password=root

这里使用的是demo_test数据库，而不是demo数据库。

下面我们利用DatabaseHelper的executeUpdate方法依次执行customer_init.sql中提供的SQL语句。

下面我们来完成CustomerServiceTest的init方法：

   @Before
    public void init() throws  Exception{
        //to do 初始化数据库
        String file="sql/customer_init.sql";
        InputStream is=Thread.currentThread().getContextClassLoader().getResourceAsStream(file);
        BufferedReader reader=new BufferedReader(new InputStreamReader(is));
        String sql;
        while ((sql=reader.readLine())!=null){
            DatabaseHelper.executeUpdate(sql);
        }
    }

从当前线程中获取线程上下文中的ClassLoader，通过classpath下的sql/customer_init.sql获取一个InputStream对象，通过该输入流来创建BufferedReader对象，循环读取其中的每一行，并调用DatabaseHelper的executeUpdate方法来执行每条SQL语句。

如果没有错误，测试CustomerServiceTest出现绿条结果如下：

但是没必要再所有单元测试类的init方法中都使用类似上面的代码init方法里面的代码，因此有必要将这些代码做一个封装。不妨在DatabaseHelper类中提供一个executeSqlFile方法，只需要提供filePath即可，如下：

/**
     * 执行sql文件
     */
    public static void executeSqlFile(String filePath){
        InputStream is=Thread.currentThread().getContextClassLoader().getResourceAsStream(filePath);
        BufferedReader reader=new BufferedReader(new InputStreamReader(is));
        try {
            String sql;
            while((sql=reader.readLine())!=null){
                executeUpdate(sql);
            }
        }catch (Exception e){
            LOGGER.error("execute sql file failure",e);
            throw new RuntimeException(e);
        }
    }

现在CustomerServiceTest的init方法如下：

@Before
    public void init() throws  Exception{
        //to do 初始化数据库
        DatabaseHelper.executeSqlFile("sql/customer_init.sql");
    }

再次运行测试所有的方法，观察单元测试是否全部通过。

小技巧：在IDEA中，将光标定位在测试方法外部，单击工具栏上的Run（Shift+f10）或Debug（Shift+f9）按钮，可执行所有的测试方法，如果只是将光标定位在某个测试方法内部，那么只能执行当前光标所在的方法。

到这里，服务层开发完毕了。这些服务会在控制器中得到应用，在下一步我们就来完善控制层。

总结：

在进行下一步控制器层完善之前，我们先来进行总结下。

private static final Logger LOGGER = LoggerFactory.getLogger(DatabaseHelper.class);

我使用LOGGER来进行写日志

private static final QueryRunner QUERY_RUNNER;

使用QueryRunner对象来简化sql语句的查询，把表和类对应起来

private static final ThreadLocal<Connection> CONNECTION_HOLDER ;

使用ThreadLocal本地线程对象，使每个线程只有一个Connection，保证线程安全

private static final BasicDataSource DATA_SOURCE;

使用BasicDataSource对象来管理线程池，简化数据库的连接操作。

DatabaseHelper的完整代码如下：

package org.jack.com.helper;

import org.apache.commons.dbcp2.BasicDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.jack.com.util.CollectionUtil;
import org.jack.com.util.PropsUtil;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Properties;

/**
 * Created by jack on 2015/12/26.
 * 数据库操作助手类
 */
public final class DatabaseHelper {
    private static final Logger LOGGER = LoggerFactory.getLogger(DatabaseHelper.class);

    //查询
    private static final QueryRunner QUERY_RUNNER;
    //保证一个线程一个Connection，线程安全
    private static final ThreadLocal<Connection> CONNECTION_HOLDER ;
    //线程池
    private static final BasicDataSource DATA_SOURCE;

    static {
        CONNECTION_HOLDER = new ThreadLocal<Connection>();
        QUERY_RUNNER = new QueryRunner();

        Properties conf = PropsUtil.loadProps("config.properties");
        String driver = conf.getProperty("jdbc.driver");
        String url = conf.getProperty("jdbc.url");
        String username = conf.getProperty("jdbc.username");
        String passwrod = conf.getProperty("jdbc.password");

        DATA_SOURCE=new BasicDataSource();
        DATA_SOURCE.setDriverClassName(driver);
        DATA_SOURCE.setUrl(url);
        DATA_SOURCE.setUsername(username);
        DATA_SOURCE.setPassword(passwrod);
    }

    /**
     * 获取数据库连接
     */
    public static Connection getConnection() {
        Connection conn = CONNECTION_HOLDER.get();//1
        if (conn == null) {
            try {
                conn = DATA_SOURCE.getConnection();
            } catch (SQLException e) {
                LOGGER.error("get connection failure", e);
                throw new RuntimeException(e);
            } finally {
                CONNECTION_HOLDER.set(conn);
            }
        }
        return conn;
    }



    /**
     * 查询实体列表
     */
    public static <T> List<T> queryEntityList(Class<T> entityClass, String sql, Object... params) {
        List<T> entityList;

        try {
            Connection conn = getConnection();
            entityList = QUERY_RUNNER.query(conn, sql, new BeanListHandler<T>(entityClass), params);
        } catch (SQLException e) {
            LOGGER.error("query entity list failure", e);
            throw new RuntimeException(e);
        }
        return entityList;
    }

    /**
     * 查询实体
     */
    public static <T> T queryEntity(Class<T> entityClass,String sql,Object... params){
        T entity;
        try {
            Connection conn=getConnection();
            entity=QUERY_RUNNER.query(conn,sql,new BeanHandler<T>(entityClass),params);
        }catch (SQLException e){
            LOGGER.error("query entity failure",e);
            throw new RuntimeException(e);
        }
        return entity;
    }

    /**
     * 执行查询
     */
    public static List<Map<String,Object>> executeQuery(String sql,Object...params){
        List<Map<String,Object>> result;
        try {
            Connection conn=getConnection();
            result=QUERY_RUNNER.query(conn,sql,new MapListHandler(),params);
        }catch (Exception e){
            LOGGER.error("execute query failure",e);
            throw new RuntimeException(e);
        }
        return result;
    }

    /**
     * 执行更新语句（包括update，inert，delete）
     */
    public static int executeUpdate(String sql,Object... params){
        int rows=0;
        try {
            Connection conn=getConnection();
            rows=QUERY_RUNNER.update(conn,sql,params);
        }catch (SQLException e){
            LOGGER.error("execute update failure",e);
            throw new RuntimeException(e);
        }
        return rows;
    }
    /**
     * 插入实体
     */
    public static <T> boolean insertEntity(Class<T> entityClass,Map<String,Object> fieldMap){
        if(CollectionUtil.isEmpty(fieldMap)){
            LOGGER.error("can not insert entity:fieldMap is empty");
            return false;
        }
        String sql="INSERT INTO "+getTableName(entityClass);
        StringBuilder columns=new StringBuilder("(");
        StringBuilder values=new StringBuilder("(");
        for (String fieldName : fieldMap.keySet()){
            columns.append(fieldName).append(", ");
            values.append("?, ");
        }
        columns.replace(columns.lastIndexOf(", "),columns.length(),") ");
        values.replace(values.lastIndexOf(", "),values.length(),") ");
        sql +=columns + " VALUES " + values;

        Object[] params=fieldMap.values().toArray();
        return executeUpdate(sql,params) == 1;
    }

    /**
     * 更新实体
     * @param entityClass
     * @return boolean
     */
    public static <T> boolean updateEntity(Class<T> entityClass,long id,Map<String,Object> fieldMap){
        if (CollectionUtil.isEmpty(fieldMap)){
            LOGGER.error("can not update entity:fieldMap is empty");
            return false;
        }

        String sql="UPDATE " + getTableName(entityClass) + " SET ";
        StringBuilder columns=new StringBuilder();
        for (String fieldName : fieldMap.keySet()){
            columns.append(fieldName).append("=?, ");
        }
        sql += columns.substring(0,columns.lastIndexOf(", ")) +"WHERE id =?";
        List<Object> paramList =new ArrayList<Object>();
        paramList.addAll(fieldMap.values());
        paramList.add(id);
        Object[] params=paramList.toArray();
        return executeUpdate(sql,params) == 1;
    }

    /**
     * 删除实体
     * @param entityClass
     * @return
     */
    public static <T> boolean deleteEntity(Class<T> entityClass,long id){
        String sql="DELETE FROM "+getTableName(entityClass)+" WHERE id=?";
        return executeUpdate(sql,id) == 1;
    }

    private static String getTableName(Class<?> entityClass){
        return entityClass.getSimpleName();//返回类名
    }

    /**
     * 执行sql文件
     */
    public static void executeSqlFile(String filePath){
        InputStream is=Thread.currentThread().getContextClassLoader().getResourceAsStream(filePath);
        BufferedReader reader=new BufferedReader(new InputStreamReader(is));
        try {
            String sql;
            while((sql=reader.readLine())!=null){
                executeUpdate(sql);
            }
        }catch (Exception e){
            LOGGER.error("execute sql file failure",e);
            throw new RuntimeException(e);
        }
    }

}

CustomerService

CustomerService的代码如下：

package org.jack.com.service;

import org.jack.com.helper.DatabaseHelper;
import org.jack.com.model.Customer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.*;

/**
 * Created by jack on 2015/11/29.
 * 提供客户数据服务
 */
public class CustomerService {
    /*
    * 获取客户列表
    * */
    public List<Customer> getCustomerList(){
        //to do something
        String sql="select * from customer";
        return DatabaseHelper.queryEntityList(Customer.class,sql);

    }

    /*
    * 获取客户
    * */
    public  Customer getCustomer(long id){
        //to do something
        String sql = "SELECT * FROM customer WHERE id = ?";
        return DatabaseHelper.queryEntity(Customer.class, sql, id);
    }

    /*
    * 创建客户
    * */
    public boolean createCustomer(Map<String,Object> fieldMap){
        //to do something

        return DatabaseHelper.insertEntity(Customer.class,fieldMap);
    }

    /*
    * 更新客户
    * */
    public boolean updateCustomer(long id,Map<String,Object> fieldMap){
        //to do something
        return DatabaseHelper.updateEntity(Customer.class,id,fieldMap);
    }

    /*
    * 删除客户
    * */
    public boolean deleteCustomer(long id){
        //to do something
        return DatabaseHelper.deleteEntity(Customer.class,id);
    }

   }

CustomerServiceTest的完整代码如下：

package org.jack.test;

import org.jack.com.helper.DatabaseHelper;
import org.jack.com.model.Customer;
import org.jack.com.service.CustomerService;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by jack on 2015/12/5.
 * 单元测试类CustomerServiceTest
 */
public class CustomerServiceTest {
    private final CustomerService customerService;
    public CustomerServiceTest(){
        customerService = new CustomerService();
    }

    @Before
    public void init() throws  Exception{
        //to do 初始化数据库
        DatabaseHelper.executeSqlFile("sql/customer_init.sql");
    }

    @Test
    public void getCustomerListTest() throws Exception{
        List<Customer> customerList = customerService.getCustomerList();
        Assert.assertEquals(2,customerList.size());
    }

    @Test
    public void getCustomerTest() throws Exception{
        long id = 1;
        Customer customer = customerService.getCustomer(id);
        Assert.assertNotNull(customer);
    }

    @Test
    public void createCustomerTest() throws Exception{
        Map<String,Object> fieldMap = new HashMap<String, Object>();
        fieldMap.put("name","customer100");
        fieldMap.put("contact","John");
        fieldMap.put("telephone","13512345678");
        boolean result = customerService.createCustomer(fieldMap);
        Assert.assertTrue(result);
    }

    @Test
    public void updateCustomerTest() throws  Exception{
        long id = 1;
        Map<String,Object> fieldMap = new HashMap<String, Object>();
        fieldMap.put("contact","Eric");
        boolean result = customerService.updateCustomer(id,fieldMap);
        Assert.assertTrue(result);
    }

    @Test
    public void deleteCustomerTest() throws Exception{
        long id = 1;
        boolean result = customerService.deleteCustomer(id);
        Assert.assertTrue(result);
    }

    /*public static void main(String args[]){
        CustomerServiceTest ct=new CustomerServiceTest();
        try {
            ct.getCustomerListTest();
        }catch (Exception e){
            e.printStackTrace();
        }

    }*/
}

Maven管理的pom.xml目前的代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.jack.com</groupId>
    <artifactId>chapter2</artifactId>
    <version>1.0.0</version>
    <packaging>war</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
    <!--Servlet-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <scope>provided</scope>
    </dependency>

        <!--JUnit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <!--<version>3.8.1</version>-->
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <!--SLF4J-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.7</version>
        </dependency>

        <!--Mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.33</version>
            <scope>runtime</scope>
        </dependency>

        <!--Apache Commons Lang-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.3.2</version>
        </dependency>

        <!--Apache Commons Collections-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.0</version>
        </dependency>


        <!--Apache Commons DbUtils-->
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
        </dependency>

        <!--Apache DBCP数据库连接池依赖-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.0.1</version>
        </dependency>


    </dependencies>

</project>

接下来进行控制器层的完善。