Spring数据库访问（HSQL）（二）

    上一篇我们介绍了HSQL数据库的基本概念和操作，我们现在从HSQL的服务器模式开始，使用Spring来操作JDBC。HSQL内嵌了服务器模式的启动方式，不过需要使用java命令来运行，可以参考官方文档。为了演示的方便，我们使用程序启动服务器，做法也很简单。如下：

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组件来实现最简单的连接池，如下配置即可：

	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
	<property name="driverClassName" value="org.hsqldb.jdbcDriver" />
		<property name="url"
			value="jdbc:hsqldb:hsql://localhost:2011/vehicle;shutdown=true" />
		<property name="username" value="ROOT" />
		<property name="password" value="123" />
	</bean>

    下面先从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，这也很简单：

	<bean id="vehicleDAO" class="org.ourpioneer.vehicle.dao.VehicleDAOImpl">
		<property name="dataSource" ref="dataSource" />
	</bean>

    下面就是测试了，用主函数进行测试：

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模板的使用，希望对使用者有用，欢迎交流。（未完待续）