模板和策略模式

在数据库查询中查询条件很多，我们怎么把不变共有的部分提出来达到代码重用了？
看下面代码：AbstractDao  是抽象方法。我们查询数据库时只有两部分是变的 1.sql语句  2.返回对结果的处理。
其中sql 语句可以通过参数传递，而返回结果要根据具体的类型，而AbstractDao 是不知道具体类型的所以把具体处理派给子类（因为子类知道）所以可以把此方法写成一个 abstract 方法，子类重写它，子类调用它时肯定调用的是自己已经是实现的方法如下面的rowMapper()。
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import cn.itcast.jdbc.JdbcUtils;
import cn.itcast.jdbc.dao.DaoException;

/**
 * 
 * 2008-12-13
 * 
 * @author <a href="mailto:liyongibm@gmail.com">liyong</a>
 * 
 */
public abstract class AbstractDao {
	public Object find(String sql, Object[] args) {
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			conn = JdbcUtils.getConnection();
			ps = conn.prepareStatement(sql);
			for (int i = 0; i < args.length; i++)
				ps.setObject(i + 1, args[i]);
			rs = ps.executeQuery();
			Object obj = null;
			if (rs.next()) {
				obj = rowMapper(rs);//抽象方法 等子类具体实现，就调用了子类自己的rowMapper()这就是多态。不可能在rowMapper 里调用写MappingUser();
			}
			return obj;
		} catch (SQLException e) {
			throw new DaoException(e.getMessage(), e);
		} finally {
			JdbcUtils.free(rs, ps, conn);
		}
	}

	abstract protected Object rowMapper(ResultSet rs) throws SQLException;
}

而具体子类怎么实现的呢？看下面UserDaoImpl

 在 findUser() 方法里怎么知道 user Object user 可以(User) user 强制转换为User 类呢？看下面rowMapper () 方法：它返回的是User 类对象，而rowMapper()方法怎么知道rs 有id name money birthday 四个参数呢？ 看findUser (){String sql="***"};看sql语句就知道了。 具体调用流程是 super.find();->(进入了AbstractDao.find())->执行到rowMapper()时由于多态执行UserDaoImpl  的rowMapper ()方法。而UserImpl()知道怎么处理rowMapper()。总结：1.一样的操作都放到超类里面来了是一种代码重用的方式 2.找出哪是不变的哪是变化的。3. 变化的用子类来做(重写)，在超类用（可用abstract 类。）写代码时是写的超类，运行时就会调用子类的（多态）。4.需要几个步骤 有几个不确定，把不确定方法抽象出来做成抽象方法让子类去做。子类知道怎么去处理。5.这是返回一个对象如果我要返回一个Name呢。就要修改 rowMapper();

public String findUserName(int id) {
		String sql = "select  name from user where id=?";
		Object[] args = new Object[] { id };
		Object user = super.find(sql, args);
		return ((User) user).getName();
	}

	protected Object rowMapper1(ResultSet rs) throws SQLException {
		return rs.getString("name");
	}

不灵活。

看到从新写一个rowMapper1方法，用继承这种方式不太好的地方。前面参数sql 使用参数传递的那么这个rowMapper 可以作为参数传递过来吗？java里不行。我们可以传递对象可以通过传递接口达到我们改变的目的。所以如public Object find(String sql, Object[] args, RowMapper rowMapper) {}；如下代码：

public class MyDaoTemplate {
	public Object find(String sql, Object[] args, RowMapper rowMapper) {
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			conn = JdbcUtils.getConnection();
			ps = conn.prepareStatement(sql);
			for (int i = 0; i < args.length; i++)
				ps.setObject(i + 1, args[i]);
			rs = ps.executeQuery();
			Object obj = null;
			if (rs.next()) {
				obj = rowMapper.mapRow(rs);//通过多态，来实现rowMapper的mapRow()方法可
			}
			return obj;
		} catch (SQLException e) {
			throw new DaoException(e.getMessage(), e);
		} finally {
			JdbcUtils.free(rs, ps, conn);
		}
	}
}

具体实现类：通过组合方式和匿名类就可以实现不同行映射。

public class UserDaoImpl2 {
	MyDaoTemplate template = new MyDaoTemplate(); //作为成员。而前面那种方法是 同通过集成abstractDao 来实现数据库查询的。
	public User findUser(String loginName, String password) {
		String sql = "select id, name, money, birthday  from user where name=?";
		Object[] args = new Object[] { loginName };
		RowMapper mapper = new UserRowMapper();
		Object user = this.template.find(sql, args, mapper);
		return (User) user;
	}
	public String findUserName(int id) {
		String sql = "select name from user where id=?";
		Object[] args = new Object[] { id };
		Object name = this.template.find(sql, args, new RowMapper() {//定义一个匿名内部类，如果只需要一个名字的话，就只返回一个名字。很灵活了。
			public Object mapRow(ResultSet rs) throws SQLException {
				return rs.getString("name");
			}
		});
		return (String) name;
	}
}

class UserRowMapper implements RowMapper { //实现RowMapper 接口，也可以写成匿名内部类。
	public Object mapRow(ResultSet rs) throws SQLException {
		User user = new User();
		user.setId(rs.getInt("id"));
		user.setName(rs.getString("name"));
		user.setMoney(rs.getFloat("money"));
		user.setBirthday(rs.getDate("birthday"));
		return user;
	}
}

在实现RowMapper接口的类中完成了映射。1.通过接口实现了参数传递 2.实现接口的类是有函数的，而不同类实现的函数不一样所以完成了不同的映射。 这叫做策略模式关于策略模式可以参考网页：http://www.cnblogs.com/justinw/archive/2007/02/06/641414.html （写得非常好，楼主关于各种模式总结都非常好）。其实spring JDBC template 就是按上面方式写的。如下图所示： 大家可以比较一下这两个代码。