使用SpringJDBC的正确开启方式

轻量级的应用程序框架Spring所提供的JDBC有许多积极的方面使之在J2SE和 J2EE应用程序开发中占有重要地位。
我在工作中遇到Springjdbc使用的案例：

输入的参数为：

	Map<String, Object> map = new HashMap<String, Object>();
	map.put("msgId","msgId");
	map.put("userId","userId");
public int saveDeletedMessage(Map<String, Object> map) throws Exception {
	NamedParameterJdbcTemplate namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(jdbcTemplate);
	StringBuffer sql = new StringBuffer();
	sql.append("INSERT INTO BI_DELETED_INFO_T (MSGID,USERID) VALUES(:msgId, :userId)");
	return namedParameterJdbcTemplate.update(sql.toString(), map);
}
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:spring-config.xml" })
public class TestSpring {
	private Log logger = LogFactory.getLog(getClass());
	@Autowired
	private JdbcTemplate jdbcTemplate;
	@Autowired
	private NamedParameterJdbcTemplate namedJdbcTemplate;
	@Test
	// 无参数插入记录
	public void run() {
		String sql = "insert into user (name,age) values('张三',45)";
		int count = jdbcTemplate.update(sql);
		logger.info(count);
	}
	
	// 有参数插入记录
	public void run1() {
		User user = new User();
		user.setAge(10);
		user.setName("李四");
		Object[] obj = new Object[] { user.getName(), user.getAge() };
		String sql = "insert into user (name,age) values(?,?)";
		int count = jdbcTemplate.update(sql, obj);
		logger.info(count);
	}
	
	// 删除记录
	public void run2() {
		Integer id = 21;
		Object[] obj = new Object[] { id };
		String sql = "delete from user where id=?";
		int count = jdbcTemplate.update(sql, obj);
		logger.info(count);
	}
	
	// 有参数更新记录
	public void run3() {
		User user = new User();
		user.setAge(100);
		user.setName("李四光");
		user.setId(22);
		Object[] obj = new Object[] { user.getName(), user.getAge(), user.getId() };
		String sql = "update user set name=?,age=? where id=?";
		int count = jdbcTemplate.update(sql, obj);
		logger.info(count);
	}
	
	// 查询返回指定类型的列表
	public void run4() {
		String sql = "select id,name,age from user where id<?";
		Object[] obj = new Object[] { 100 };
		List<User> list = jdbcTemplate.query(sql, obj, new BeanPropertyRowMapper<>(User.class));
		for (User user : list) {
			logger.info(user);
		}
		logger.info(list);
	}
	
	// 查询返回指定类型的单个记录
	// queryForObject必须只能有一行记当时才能使用
	// 多了少了都会报错
	public void run5() {
		String sql = "select id,name,age from user where id=?";
		Object[] obj = new Object[] { 1 };
		User user = jdbcTemplate.queryForObject(sql, obj, new BeanPropertyRowMapper<>(User.class));
		logger.info(user);
	}
	
	// 查询返回Map<String, Object>类型的列表
	// Map<字段名, 字段值>
	public void run6() {
		String sql = "select id,name,age from user where id<?";
		Object[] obj = new Object[] { 100 };
		List<Map<String, Object>> list = jdbcTemplate.queryForList(sql, obj);
		for (Map<String, Object> map : list) {
			logger.info(map);
		}
		logger.info(list);
	}
	
	// 查询返回Map<String, Object>类型的单个记录
	// queryForMap必须只能有一行记当时才能使用
	// 多了少了都会报错
	// Map<字段名, 字段值>
	public void run7() {
		String sql = "select id,name,age from user where id=?";
		Object[] obj = new Object[] { 1 };
		Map<String, Object> map = jdbcTemplate.queryForMap(sql, obj);
		logger.info(map);
	}

	// 单行行列的string字符结果
	public void run8() {
		String sql = "select max(name) from user where id >?";
		Object[] obj = new Object[] { 0 };
		String name = jdbcTemplate.queryForObject(sql, obj, String.class);
		logger.info(name);
	}

	// 单行行列的数值型结果
	public void run9() {
		String sql = "select count(id) from user where id >?";
		Object[] obj = new Object[] { 0 };
		int count = jdbcTemplate.queryForObject(sql, obj, Integer.class);
		logger.info(count);
	}

	// 联合查询1有类型
	public void run10() {
		String sql = "select u.ID,u.NAME,u.AGE,d.name dept_name from user u join dept d on u.dept_id= d.id where u.id<?";
		Object[] obj = new Object[] { 100 };
		List<User> list = jdbcTemplate.query(sql, obj, new BeanPropertyRowMapper<>(User.class));
		for (User user : list) {
			logger.info(user);
		}
		logger.info(list);
	}
	
	// 联合查询2无类型
	public void run11() {
		String sql = "select u.ID,u.NAME,u.AGE,d.name dept_name from user u join dept d on u.dept_id= d.id where u.id<?";
		Object[] obj = new Object[] { 100 };
		List<Map<String, Object>> list = jdbcTemplate.queryForList(sql, obj);
		for (Map<String, Object> map : list) {
			logger.info(map);
		}
		logger.info(list);
	}
	
	// 联合查询2无类型:使用绑定参数的JdbcTemplate
	public void run12() {
		String sql = "select u.ID,u.NAME,u.AGE,d.name dept_name from user u join dept d on u.dept_id= d.id where u.id<:Id";
		Map<String,Object> paramMap=new HashMap<>();
		paramMap.put("Id", 100);
		List<Map<String, Object>> list = namedJdbcTemplate.queryForList(sql, paramMap);
		for (Map<String, Object> map : list) {
			logger.info(map);
		}
		logger.info(list);
	}	
}

然而，也有一些特征使其难于使用：
    1 . 开发者需要处理大量复杂的任务和基础结构，例如大量的try-catch-finally-try-catch块。
    2 . 应用程序需要处理大量复杂的错误处理以及确定连接在使用后被正确关闭，这样以来使得代码变得冗长，膨胀并且重复。
    3 . JDBC中使用了极不明确性的SQLException异常。
    4 . JDBC没有引入具体的异常子类层次机制。
任何一种错误，都是抛出SQLException异常，无论它来源于JDBC驱动程序还是来源于数据库，这使得程序员很难理解到底是哪里出现了错误。如果SQL对象无效或已经被锁定，将抛出一个SQLException异常，调试这样的异常需要一些时间来检查SQL状态值和错误代码。

希望对你有帮助，祝你有一个好心情，加油！

若有错误、不全、可优化的点，欢迎纠正与补充；转载请注明出处！