开篇
本篇针对项目中的Server层进行优化介绍。先来看看Server层的目前情况。
image.png
可以看到由于业务简单。只有一个Server类。
以下是CustomerService类的静态代码块
image.png
以下是CustomerService类的其中一个方法
image.png
缺点：
- 将数据库的加载是一个公共代码块，应该提取出来，不应该写在某个类中。
- Service 层是对业务逻辑的处理，但是在方法中，对查询的结果进行了大量的操作。这样使业务层的代码太过浑浊。应该讲查询结果的处理封装起来。
代码实现
将Server层的对数据库操作的代码提取出来
要求：
- 建立一个DatabaseUtil类 封装对数据库的加载
- 再创建两个方法getConnection()获取数据库连接 和closeConnection() 关闭数据库连接。
- 对数据库操作的代码实现封装起来
实现：
- 为了能更好地封装JDBC的操作。这里还使用了Apache Common项目中的DbUtils类库，这个类库可以更好地帮我处理数据库数据。
- DatabaseUtil 类就实现了加载驱动，获取连接，和对数据库进行操作并对查询结果进行处理，然后结果给Server层的3个主要功能。
代码如下：
public class DatabaseUtil {
private static final String DRIVER;
private static final String URL;
private static final String USERNAME;
private static final String PASSWORD;
// 利用Apache的一个工具库DbUtils 对JDBC的封装
private static final QueryRunner QUERY_RUNNER = new QueryRunner();
private static final Logger logger = LoggerFactory.getLogger(DatabaseUtil.class);
static{
System.out.println("配置加载");
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");
//JDBC流程第一步 加载驱动
try {
Class.forName(DRIVER);
} catch (ClassNotFoundException e) {
logger.error("加载jdbc驱动失败",e);
e.printStackTrace();
}
}
public static Connection getConnection() {
try {
Connection connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
return connection;
} catch (SQLException e) {
logger.error("获取连接失败",e);
e.printStackTrace();
}
return null;
}
public static void closeConnection(Connection connection) {
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
logger.error("关闭连接失败",e);
e.printStackTrace();
}
}
}
/**
* 查询获取实体列表
* @param entityClass 返回对象
* @param sql 查询语句
* @param params 查询条件
*
*
*/
public static <T> List<T> queryEntityList(Class<T> entityClass,String sql, Object... params) {
List<T> entityList = null;
Connection con = null;
try {
con = getConnection();
entityList =
QUERY_RUNNER.query(con, sql, new BeanListHandler<T>(entityClass), params);
} catch (SQLException e) {
logger.error("查询失败",e);
e.printStackTrace();
}finally {
closeConnection(con);
}
return entityList;
}
/**
* 查询实体
* @param tClass
* @param sql
* @param params
* @param <T>
* @return
*/
public static <T> T queryEntity(Class<T> tClass, String sql, Object... params) {
T entity = null;
Connection con = null;
try {
con = getConnection();
entity =
QUERY_RUNNER.query(con, sql, new BeanHandler<T>(tClass), params);
} catch (SQLException e) {
logger.error("查询失败",e);
e.printStackTrace();
}finally {
closeConnection(con);
}
return entity;
}
/**
* 执行查询语句
* 返回一个List对象。Map 表示列名与列值得映射关系
* @param sql
* @param params
* @return
*/
public static List<Map<String, Object>> executeQuery(String sql, Object... params) {
List<Map<String,Object>> entity = null;
Connection con = null;
try {
con = getConnection();
entity =
QUERY_RUNNER.query(con, sql, new MapListHandler(), params);
} catch (SQLException e) {
logger.error("查询失败",e);
e.printStackTrace();
}finally {
closeConnection(con);
}
return entity;
}
/**
* 执行更新语句（update,insert,delete）
* @param sql
* @param params
* @return
*/
public static int executeUpdate(String sql, Object... params) {
int rows=0;
Connection con = null;
try {
con = getConnection();
rows =
QUERY_RUNNER.update(con, sql, new MapListHandler(), params);
} catch (SQLException e) {
logger.error("查询失败",e);
e.printStackTrace();
}finally {
closeConnection(con);
}
return rows;
}
/**
* 插入实体
* @param entityClass
* @param filedMap
* @param <T>
* @return
*/
public static <T> boolean insertEntity(Class<T> entityClass, Map<String, Object> filedMap) {
/*
* 1. 判断filedMap是否为空
* 2. 对Map遍历，拼接sql语句
* 3. 执行语句
* */
if (MapUtils.isEmpty(filedMap)) {
logger.error("插入实体失败,实体Map为空");
return false;
}
Iterator<String> iterator = filedMap.keySet().iterator();
StringBuffer columns = new StringBuffer("(");
StringBuffer values = new StringBuffer("(");
String sql=("insert into" + entityClass.getSimpleName());
while (iterator.hasNext()) {
String key = iterator.next();
columns.append(key).append(", ");
values.append("?, ");
}
// 删除最后一个 , 然后加上 )
columns.replace(columns.lastIndexOf(", "), columns.length(), ")");
values.replace(values.lastIndexOf(", "), values.length(), ")");
sql += columns + " values " + values;
Object[] params = filedMap.values().toArray();
return executeUpdate(sql,params)==1;
}
public static <T> boolean updateEntity(Class<T> entityClass, long id, Map<String, Object> fieldMap) {
//TODO
return false;
}
public static <T> boolean deleteEntity(Class<T> entityClass, long id) {
String sql = "Delete From " + entityClass.getSimpleName() + " Where id = ?";
return executeUpdate(sql, id) == 1;
}
}
重建Server层
在构建了DatabaseUtil类后，Server层的代码如下：
/*
* 提供客户数据服务
* */
public class CustomerService {
private static final Logger logger = LoggerFactory.getLogger(CustomerService.class);
/*
* 获取客户列表
* */
public List<Customer> getCustomerList() {
String sql = "select * from customer";
List<Customer> list = DatabaseUtil.queryEntityList(Customer.class, sql, null);
return list;
}
/*
* 获取客户
* */
public Customer getCustomer(long id) {
String sql = "select * from customer where id = ?";
return DatabaseUtil.queryEntity(Customer.class, sql, id);
}
/*
* 创建客户
* */
public boolean createCustomer(Map<String,Object> fieldMap) {
return DatabaseUtil.insertEntity(Customer.class,fieldMap);
}
/*
* 更新客户
* */
public boolean updateCustomer(long id,Map<String,Object> fieldMap) {
//TODO
return false;
}
/*
* 删除客户
* */
public boolean deleteCustomer(long id) {
return DatabaseUtil.deleteEntity(Customer.class, id);
}
}
可以看到Server层的代码非常简洁，这样就可以开心地写业务逻辑代码了。而不需要对数据库的操作操心了。
缺陷
虽然Server层是非常的简洁，舒服。但是相对地，又创建了一个数据层。在这个刚建立的数据层上，显然还是有很多不足的。
- 在getConnection()和closeConnection()上，每次调用数据库操作，都需要重新连接数据库和关闭数据库，这样的消耗很大。
总结
竟然我们已经把数据库处理这一块跨分到一个层了。那么我们就应该对这一块有一个更好地优化才行。比如数据库连接池 就是以后需要优化的一个点。
