Spring笔记整理——持久层的支持（jdbc,hibernate）

Spring强大的基于 JavaBeans 的采用控制反转（Inversion of Control，IoC）原则的配置管理，使得 应用程序的组件更加快捷简易。

是一个可用于从 applet 到 Java EE 等不同运行环境的核心 Bean 工厂。

使数据库事务的一般化抽象层，允许宣告式(Declarative)事务管理器，简化事务的划分使之与底层无关。

为JDBC 抽象层提供了有针对性的异常等级(不再从SQL异常中提取原始代码), 简化了错误处理, 大大减少了程序员的编码量。 再次利用JDBC时，你无需再写出另一个 '终止' (finally) 模块. 并且面向JDBC的异常与Spring 通用 数据访问对象 (Data Access Object) 异常等级相一致.以资源容器，DAO 实现和事务策略等形式与 Hibernate，JDO 和 iBATIS SQL Maps 集成。利用众多的反转控制方便特性来全面支持, 解决了许多典型的Hibernate集成问题. 所有这些全部遵从Spring通用事务处理和通用数据访问对象异常等级规范。

下面是整理Spring对jdbc和Hibernate的支持。

Spring对于JDBC的支持

Spring对于JDBC的支持提供一个对象  org.springframework.jdbc.core.JdbcTemplate

主要方法：

 update(String sql, Object[] args)  update方法处理SQL的insert,update,delete语句
    query(String sql, Object[] args, RowMapper<T> rowMapper) [查询多个对象]
    queryForObject(String sql, Object[] args, RowMapper<T> rowMapper) [查询单个对象]

下面来看一个例子

beans.xml里面的配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
	http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
	<!-- 定义Dao层 -->
	<bean id="userDao" class="com.spring.jdbc.dao.impl.UserDaoImpl">
		<!-- 需要注入jdbcTemplate -->
		<property name="template" ref="jdbcTemplate"></property>
	</bean>
	
	<!-- 通过Spring容器创建JdbcTemplate的实例 -->
	<bean id='jdbcTemplate'
		class="org.springframework.jdbc.core.JdbcTemplate">
		<!-- 为JdbcTemplate注入数据源DataSource,定义url,username ,password -->
		<property name="dataSource" ref="ds"></property>
	</bean>

	<!-- 通过Spring容器创建DataSource :以dbcp方式创建数据源-->
	<bean id="ds" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName"
			value="oracle.jdbc.OracleDriver">
		</property>
		<property name="url"
			value="jdbc:oracle:thin:@localhost:1521:XE">
		</property>
		<property name="username" value="hr"></property>
		<property name="password" value="111"></property>
	</bean>
</beans>

下面是  org.springframework.jdbc.core.JdbcTemplate对象主要方法调用

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import com.spring.dao.UserDao;
import com.spring.pojo.User;

public class UserDaoImpl implements UserDao {
	private JdbcTemplate template;// Impl层需要操作数据库，依赖JdbcTemplate的支持

	@Override
	public void delete(User u) {
		String sql = "delete from t_user where t_id=?";
		Object[] args = { u.getId() };
		template.update(sql, args);// 通过template的update方法执行sql语句

	}

	@Override
	public void insert(User u) {
		String sql = "insert into t_user(t_id,t_name,t_age,t_birthday) values(user_seq.nextval,?,?,?)";
		Object[] args = { u.getName(), u.getAge(), u.getBirthday() };
		template.update(sql, args);
	}

	@Override
	public void update(User u) {
		String sql = "update t_user set t_name=?,t_age=?,t_birthday=? where t_id=?";

		Object[] args = { u.getName(), u.getAge(), u.getBirthday(), u.getId() };

		template.update(sql, args);

	}

	@SuppressWarnings("unchecked")
	@Override
	public List<User> findAll() {
		String sql = "select t_id,t_name,t_age,t_birthday from t_user";
		// 匿名内部内 new 接口(){} 实际开发中如果一个接口需要实现的方法少于三个
		List<User> users = template.query(sql, new RowMapper() {
			// ResultSet不是将整个结果集进行封装，是每一次封装一行数据
			public Object mapRow(ResultSet rs, int rownum) throws SQLException {
				User u = new User();
				u.setAge(rs.getInt("t_age"));
				u.setName(rs.getString("t_name"));
				u.setBirthday(rs.getDate("t_birthday"));
				u.setId(rs.getInt("t_id"));
				return u;
			}
		});
		return users;
	}

	@SuppressWarnings("unchecked")
	@Override
	public User findById(Integer id) {
		String sql = "select t_id,t_name,t_age,t_birthday from t_user where t_id=?";
		Object[] args = { id };
		User user = (User) template.queryForObject(sql, args, new RowMapper() {
			@Override
			public Object mapRow(ResultSet rs, int rownum) throws SQLException {
				User u = new User();
				u.setAge(rs.getInt("t_age"));
				u.setName(rs.getString("t_name"));
				u.setBirthday(rs.getDate("t_birthday"));
				u.setId(rs.getInt("t_id"));
				return u;
			}
		});
		return user;
	}

	public JdbcTemplate getTemplate() {
		return template;
	}

	public void setTemplate(JdbcTemplate template) {
		this.template = template;
	}
}

Spring对于Hibernate的支持

提供了HbiernateTemplate,HibernateTemplate提供了很多和session同名的方法
      1.HibernateTemplate是线程安全的
      2.HibernateTemplate方便执行HQL
      3.HibernateTemplate内部控制事务

beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
	http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

	<!-- 使用c3p0创建数据源，效率比dbcp更好 -->
	<bean id="ds" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<!-- 配置数据库连接的相关数据 -->
		<property name="driverClass" value="oracle.jdbc.OracleDriver"></property>
		<property name="jdbcUrl"
			value="jdbc:oracle:thin:@localhost:1521:XE">
		</property>
		<property name="user" value="hr"></property>
		<property name="password" value="111"></property>
		<!-- 配置与连接池相关的数据 -->
		<!-- 配置数据库连接池的最大连接数 -->
		<property name="maxPoolSize" value="10"></property>
		<!-- 指定数据库连接的最小连接数 -->
		<property name="minPoolSize" value="1"></property>
		<!-- 指定初始化连接池时创建的连接数 -->
		<property name="initialPoolSize" value="1"></property>
		<!-- 指定数据库连接池连接的最大空闲时间 -->
		<property name="maxIdleTime" value="20"></property>
	</bean>
	<!-- HibernateTemplate封装了Session，Session对象由SessionFacotry提供，先定义SessionFacotry实例 -->
	<bean id="sf"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<!-- 获得数据库的连接信息，有DataSource提供 -->
		<property name="dataSource" ref="ds"></property>
		<!-- 设定Hibernate自身相关的属性，类型为Properties-->
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					org.hibernate.dialect.Oracle9iDialect
				</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.format_sql">true</prop>
				<!-- 对于线程安全的session可以省略 currect_session_context_class -->
			</props>
		</property>
		<!-- 映射文件的注册 -->
		<property name="mappingResources">
			<list>
				<value>com/spring/pojo/User.hbm.xml</value>
			</list>
		</property>
	</bean>
	<!-- Spring容器创建HibernateTemplate实例 -->
	<bean id="template"
		class="org.springframework.orm.hibernate3.HibernateTemplate">
		<property name="sessionFactory" ref="sf"></property>
	</bean>

	<bean id="ormDao" class="com.spring.orm.dao.impl.UserDaoImpl">
		<property name="template" ref="template"></property>
	</bean>

</beans>

对于Hibernate配置加载也可以直接引用一个已经存在的hibernate.cfg.xml配置

下面是部分代码

<bean id="sf"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<!-- 装载hibernate的配置文件 hibernate.cfg.xml -->
		<property name="configLocation" value="hibernate.cfg.xml"></property>
	</bean>

	<!-- Spring容器创建HibernateTemplate实例 -->
	<bean id="template"
		class="org.springframework.orm.hibernate3.HibernateTemplate">
		<property name="sessionFactory" ref="sf"></property>
	</bean>

	<bean id="ormDao" class="com.spring.orm.dao.impl.UserDaoImpl">
		<property name="template" ref="template"></property>
	</bean>

org.springframework.orm.hibernate3.HibernateTemplate的常用方法地调用

import java.sql.SQLException;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.HibernateTemplate;

import com.spring.dao.UserDao;
import com.spring.pojo.User;

/*对于Hibernate的支持*/
public class UserDaoImpl implements UserDao {
	private HibernateTemplate template;

	@Override
	public void delete(User u) {
		template.delete(u);// 删除用户

	}

	@Override
	public void insert(User u) {
		template.save(u);
	}

	@Override
	public void update(User u) {
		template.update(u);
	}

	@Override
	public List<User> findAll() {

		return template.find("from User");
	}

	@Override
	public User findByName(final String name) {
		/*
		 * String hql = "from User as u where u.name=?"; Object[] args = { name };
		 * List<User> users = template.find(hql, args); User u = null; if
		 * (users != null) { u = users.get(0); }
		 */
		User u = (User) template.execute(new HibernateCallback<Object>() {
			@Override
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query query = session
						.createQuery("from User as u where u.name=?");
				query.setString(0, name);

				return query.uniqueResult();
			}
		});
		return u;
	}

	@Override
	public User findById(Integer id) {

		return template.get(User.class, id);// get方法必须是依赖于主键
	}

	public HibernateTemplate getTemplate() {
		return template;
	}

	public void setTemplate(HibernateTemplate template) {
		this.template = template;
	}

	@Override
	// 分页查询
	public List<User> findByPage(final int first, final int size) {
		List<User> users = (List<User>) template
				.execute(new HibernateCallback<Object>() {
					@Override
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						Query query = session.createQuery("from User");
						query.setFirstResult(first);
						query.setMaxResults(size);
						return query.list();
					}
				});
		return users;
	}

}

Spring的分层架构，对一些优秀框架提供了很好的支持，对于jdbc、hibernate的集成，不仅简化了代码量，使程序结构更加清晰，也降低了程序之间的耦合度加强了子程序的独立性。