package org.ourpioneer.vehicle.util;
import org.hsqldb.Server;
/**
* 启动HSQL服务器实例
*
* @author Nanlei
*
*/
public class HsqlServer {
private void startHsqlServer(String dbPath, String dbName, int port) {
Server server = new Server();
// 0表示第0个数据库，Server模式可以启动10个数据库
server.setDatabasePath(0, dbPath + dbName);
server.setDatabaseName(0, dbName);
server.setPort(port);
server.setSilent(true);
server.start();
System.out.println("HSQLDB Server started!");
}
public static void main(String[] args) {
// 源代码路径
System.out.println(System.getProperty("user.dir"));
// 类路径
System.out.println(Thread.currentThread().getContextClassLoader()
.getResource(".").getPath());
String base = System.getProperty("user.dir");
String dbPath = base
+ "\\src\\main\\resources\\org\\ourpioneer\\vehicle\\db\\";
String dbName = "vehicle";
int port = 2011;
new HsqlServer().startHsqlServer(dbPath, dbName, port);
}
}
这样我们就可以通过运行主函数来启动HSQL的服务器了，这里需要做些说明，就是路径的问题，因为我们开发时都是操作源文件路径下的文件，那么我们使用源文件路径，而部署后代码执行类路径下资源，那么需要切换到类路径下的文件，因为这里是使用主函数运行，所以路径的获取可能会和非主函数方式运行有所不同，这个就视具体环境来确定了，此时运行该主函数，就可以看到HSQL服务器的启动信息了。
这里我们指定了启动一个数据库vehicle，并启用端口号2011，路径是开发使用的源文件路径。点击运行，看到如下信息：
之后我们在Spring中配置数据源。这就很简单了，使用Commons的DBCP组件来实现最简单的连接池，如下配置即可：
下面先从DAO模式入手，逐步来看Spring对JDBC的简化操作和JDBC模板的优雅。为了操作车辆对象，编写一个VehicleDAO接口，封装对象数据操作的方法：
package org.ourpioneer.vehicle.dao;
import org.ourpioneer.vehicle.bean.Vehicle;
/**
* VehicleDAO:封装数据操作方法
*
* @author Nanlei
*
*/
public interface VehicleDAO {
public void insert(Vehicle vehicle);
public void update(Vehicle vehicle);
public void delete(Vehicle vehicle);
public Vehicle findById(int id);
}
DAO模式将数据交互完全封装，业务层面只需进行相关的逻辑操作并准备好封装的对象数据，DAO层就完成数据持久工作。写好接口，下面就是实现类，这里给出两个完整方法作为说明：
package org.ourpioneer.vehicle.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.ourpioneer.vehicle.bean.Vehicle;
/**
* VehicleDAO实现类
*
* @author Nanlei
*
*/
public class VehicleDAOImpl implements VehicleDAO {
private DataSource dataSource;
/**
* 注入数据源
*
* @param dataSource
*/
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
public Vehicle findById(int id) {
String sql = "select * from vehicle where ID=?";
Connection conn = null;
Vehicle vehicle = null;
try {
conn = dataSource.getConnection();
PreparedStatement pstat = conn.prepareStatement(sql);
pstat.setInt(1, id);
ResultSet rs = pstat.executeQuery();
if (rs.next()) {
vehicle = new Vehicle(rs.getString("PLATE"), rs
.getString("CHASSIS"), rs.getString("COLOR"), rs
.getInt("WHEEL"), rs.getInt("SEAT"));
vehicle.setId(rs.getInt("ID"));
}
rs.close();
pstat.close();
} catch (SQLException e) {
e.printStackTrace();
} finally {
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
return vehicle;
}
/**
* 添加Vehicle
*/
public void insert(Vehicle vehicle) {
String sql = "insert into vehicle(PLATE,CHASSIS,COLOR,WHEEL,SEAT) values(?,?,?,?,?)";
Connection conn = null;
try {
conn = dataSource.getConnection();
PreparedStatement pstat = conn.prepareStatement(sql);
pstat.setString(1, vehicle.getPlate());
pstat.setString(2, vehicle.getChassis());
pstat.setString(3, vehicle.getColor());
pstat.setInt(4, vehicle.getWheel());
pstat.setInt(5, vehicle.getSeat());
pstat.executeUpdate();
pstat.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
完成实现类，不要忘了在Spring中配置DAO，这也很简单：
下面就是测试了，用主函数进行测试：
package org.ourpioneer.vehicle;
import org.ourpioneer.vehicle.bean.Vehicle;
import org.ourpioneer.vehicle.dao.VehicleDAO;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Demo {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext(
"classpath:org/ourpioneer/vehicle/spring/applicationContext.xml");
VehicleDAO vehicleDAO = (VehicleDAO) ctx.getBean("vehicleDAO");
Vehicle vehicle = new Vehicle("辽B-000000", "1A00000001", "RED", 4, 4);
vehicleDAO.insert(vehicle);
vehicle = vehicleDAO.findById(1);
System.out.println(vehicle);
}
}
测试时直接运行，数据暂存内存中，看到不到数据库脚本文件的改变，之后关闭HSQL服务器，会在log文件中看到我们这次添加的内容，再次启动HSQL服务器，数据就写入到了脚本文件中。这个过程是由于HSQL的缓存策略导致的。
这是用JDBC实现的DAO，还是相当的繁杂的，那么引入JDBC模板，开始逐步简化操作，下面来看第一种使用JDBC模板的方式：
package org.ourpioneer.vehicle.jt;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import org.ourpioneer.vehicle.bean.Vehicle;
import org.springframework.jdbc.core.PreparedStatementCreator;
/**
* Vehicle插入语句创建器
*
* @author Nanlei
*
*/
public class InsertVehicleStatementCreator implements PreparedStatementCreator {
private Vehicle vehicle;
public InsertVehicleStatementCreator(Vehicle vehicle) {
this.vehicle = vehicle;
}
public PreparedStatement createPreparedStatement(Connection conn)
throws SQLException {
String sql = "insert into vehicle(PLATE,CHASSIS,COLOR,WHEEL,SEAT) values(?,?,?,?,?)";
PreparedStatement pstat = conn.prepareStatement(sql);
pstat.setString(1, vehicle.getPlate());
pstat.setString(2, vehicle.getChassis());
pstat.setString(3, vehicle.getColor());
pstat.setInt(4, vehicle.getWheel());
pstat.setInt(5, vehicle.getSeat());
return pstat;
}
}
之后改写DAO中的代码：
public void insert(Vehicle vehicle) {
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
jdbcTemplate.update(new InsertVehicleStatementCreator(vehicle));
}
这种方式是把语句单独分离出来，既然是实现了接口，那么也可以采用内部类的方式来写，不过写内部类时，要求方法参数为final类型，如下：
public void insert(final Vehicle vehicle) {
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
jdbcTemplate.update(new PreparedStatementCreator() {
public PreparedStatement createPreparedStatement(Connection conn) throws SQLException {
String sql = "insert into vehicle(PLATE,CHASSIS,COLOR,WHEEL,SEAT) values(?,?,?,?,?)";
PreparedStatement pstat = conn.prepareStatement(sql);
pstat.setString(1, vehicle.getPlate());
pstat.setString(2, vehicle.getChassis());
pstat.setString(3, vehicle.getColor());
pstat.setInt(4, vehicle.getWheel());
pstat.setInt(5, vehicle.getSeat());
return pstat;
}
});
}
第二种方式是使用StatementSetter来进行，具体做法和上面相似，如下：
public void insert(final Vehicle vehicle) {
String sql = "insert into vehicle(PLATE,CHASSIS,COLOR,WHEEL,SEAT) values(?,?,?,?,?)";
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
jdbcTemplate.update(sql, new PreparedStatementSetter() {
public void setValues(PreparedStatement pstat) throws SQLException {
pstat.setString(1, vehicle.getPlate());
pstat.setString(2, vehicle.getChassis());
pstat.setString(3, vehicle.getColor());
pstat.setInt(4, vehicle.getWheel());
pstat.setInt(5, vehicle.getSeat());
}
});
}
第三种方式则是最简洁的方法，使用直接使用参数，比如：
public void insert(final Vehicle vehicle) {
String sql = "insert into vehicle(PLATE,CHASSIS,COLOR,WHEEL,SEAT) values(?,?,?,?,?)";
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
jdbcTemplate.update(sql, new Object[] { vehicle.getPlate(),
vehicle.getChassis(), vehicle.getColor(), vehicle.getWheel(),
vehicle.getSeat() });
}
使用对象数组方式是Spring 2中的做法，也是比较经典的做法，将参数都装备到对象数组中，统一传递给jdbeTemplate，使得数据库操作代码明显减少，格式也高度统一，便于维护，若用于Web项目，request对象中会有getParameterMap()方法，结合该方法，直接从Map中将参数封装为对象数组传递给jdbcTemplate使用，那么就会更加简洁。这个工具方法也很简单：
public static Object[] getObjectArrayFromMap(Map map, String key) {
String[] keys = key.split(",");
Object[] tmp = new Object[keys.length];
for (int i = 0; i < keys.length; i++) {
tmp[i] = getObjectFromMap(map, keys[i].trim());
}
return tmp;
}
public static Object getObjectFromMap(Map map, String key) {
Object value = map.get(key);
if (value != null && (value instanceof Object[])) {
Object[] array = (Object[]) value;
if (array != null && array.length > 0) {
value = array[0];
}
}
return value;
}
使用时，直接调用，将map传入，后面紧跟键名组（"plate,chassis,color,wheel,seat”）即可，这样就能将参数值从Map中分离出来，数据库代码就会精简至几行。十分的方便。
而在Spring 3中，最后一种方式的jdbcTemplate调用参数变为可变参数形式。也就是说，上面的代码可以写为：
public void insert(final Vehicle vehicle) {
String sql = "insert into vehicle(PLATE,CHASSIS,COLOR,WHEEL,SEAT) values(?,?,?,?,?)";
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
jdbcTemplate.update(sql, vehicle.getPlate(), vehicle.getChassis(),
vehicle.getColor(), vehicle.getWheel(), vehicle.getSeat());
}
这样只要参数位置正确，有多少参数直接往后面放即可，简洁之简洁，方便之方便。
下一篇将继续详细介绍JDBC模板的使用，希望对使用者有用，欢迎交流。（未完待续）
- 查看图片附件