Spring笔记（五）: spring 整合jdbc、hibernate、jpa

一、简介

（一）需要的jar包

1、需要的jar包：spring、hibernate、mysql、xml、apache-commons等等的jar包。

    

 

2、以上jar包，如spring、xml和commos都是冗余的。

（二）分析

1、涉及到的实体、service、dao接口、jdbc配置文件以及service实现类都可以通用，只需要实现不同的dao实现类、配置、测试类。

2、通用的源码如下：

1）实体：

<span style="font-size:18px;">@Entity
@Table(name="spring_person")
//@Cache(usage=CacheConcurrencyStrategy.READ_WRITE,region="main.java.com.spring.entity.PersonEntity")
// region用于设置单独的缓存机制，在ehcache.xml 中定义。
public class PersonEntity {

	@Id
	@Column(name="person_id",nullable=true )
	@GeneratedValue(strategy=GenerationType.AUTO)
	private int personId;

	private String name;

	public PersonEntity() {
	}

	public int getPersonId() {
		return personId;
	}
	public void setPersonId(int personId) {
		this.personId = personId;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
</span>

2）service接口：

<span style="font-size:18px;">/**
 * 业务接口
 * PersonService
 * @title
 * @desc
 * @author SAM-SHO
 * @Jan 17, 2015
 */
public interface PersonService {
	/**
	 * 保存用户实体
	 * @param name
	 */
	public void save(PersonEntity persionEntity);

	/**
	 * 删除用户实体
	 * @param id
	 */
	public void delete(int id);

	/**
	 * 查询编号为id的使用用户姓名
	 * @param id
	 */
	public String queryPersonName(int id);

	/**
	 * 查询编号为id的用户
	 * @param id
	 */
	public PersonEntity getPerson(int id);

	/**
	 * 查询所有的PersonEntity
	 * @return
	 */
	public List<PersonEntity> getAllPerson();

	/**
	 * 更新实体
	 * @param name
	 * @param id
	 */
	public void update(String name ,int id);
}
</span>

3）service实现类，注入dao的接口。

<span style="font-size:18px;">/**
 * 业务实现类
 * PersionServiceImpl
 * @title
 * @desc
 * @author SAM-SHO
 * @Jan 17, 2015
 */
@Service
@Transactional
public class PersonServiceImpl implements PersonService {

	@Resource
	private PersonDao personDao;//利用接口

	@Transactional(readOnly=true,timeout=100,isolation=Isolation.DEFAULT)
	@Override
	public void save(PersonEntity persionEntity) {
		personDao.save(persionEntity);
	}

	@Transactional(rollbackFor=Exception.class)//任何异常就回滚
	@Override
	public void delete(int id) {
		personDao.delete(id);
	}

	@Override
	public String queryPersonName(int id) {

		return personDao.queryPersonName(id);
	}

	@Transactional(noRollbackFor=RuntimeException.class)//运行异常就不会回滚
	@Override
	public void update(String name, int id) {
		personDao.update(name, id);
	}

	public PersonDao getPersonDao() {
		return personDao;
	}

	public void setPersonDao(PersonDao personDao) {
		this.personDao = personDao;
	}

	@Override
	public PersonEntity getPerson(int id) {
		return personDao.getPerson(id);

	}

	@Override
	public List<PersonEntity> getAllPerson() {

		return personDao.getAllPerson();
	}

}
</span>

4）dao接口

<span style="font-size:18px;">/**
 *
 * @Title:
 * @Description:
 * @Copyright: Copyright (c) 2015
 * @Company:
 *
 * @author: SAM-SHO
 * @version: 1.0
 * @CreateDate：Jan 21, 2015
 */
public interface PersonDao {
	/**
	 * 保存用户实体
	 * @param name
	 */
	public void save(PersonEntity persionEntity);

	/**
	 * 删除用户实体
	 * @param id
	 */
	public void delete(int id);

	/**
	 * 查询编号为id的使用用户姓名
	 * @param id
	 */
	public String queryPersonName(int id);

	/**
	 * 查询编号为id的用户
	 * @param id
	 */
	public PersonEntity getPerson(int id);

	/**
	 * 查询所有的PersonEntity
	 * @return
	 */
	public List<PersonEntity> getAllPerson();

	/**
	 * 更新实体
	 * @param name
	 * @param id
	 */
	public void update(String name ,int id);
}
</span>

5）jdbc配置文件：

<span style="font-size:18px;">driverClassName=com.mysql.jdbc.Driver
url=jdbc\:mysql\://localhost\:3306/spring?useUnicode\=true&characterEncoding\=UTF-8
username=root
password=root
initialSize=1
maxActive=500
maxIdle=2
minIdle=1
</span>

3、spring中Bean管理与注入，事务都采用注解。

二、spring 整合jdbc

（一）配置文件：

<span style="font-size:18px;"><?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

	<!-- 自动扫描 -->
	<context:component-scan base-package="main.java.com.spring.jdbc" />
	<!-- 打开aop 注解 -->
	<aop:aspectj-autoproxy />

	<!-- 配置数据源 -->
	<context:property-placeholder location="classpath:jdbc.properties" /><!-- location指向jdbc.properties配置 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName" value="${driverClassName}" />
		<property name="url" value="${url}" />
		<property name="username" value="${username}" />
		<property name="password" value="${password}" />
		<!-- 连接池启动时的初始值 -->
		<property name="initialSize" value="${initialSize}" />
		<!-- 连接池的最大值 -->
		<property name="maxActive" value="${maxActive}" />
		<!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
		<property name="maxIdle" value="${maxIdle}" />
		<!-- 最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
		<property name="minIdle" value="${minIdle}" />
	</bean>

	<!-- 需要把 dataSource 注入到jdbcTemplate-->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 配置JDBC的事物管理器：DataSourceTransactionManager -->
	<bean id="txManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 注解事物 -->
	<!-- <tx:annotation-driven transaction-manager="txManager" /> -->

	<!-- XML事物 -->
	<aop:config>
		<aop:pointcut id="transationPointCut" expression="execution(* main.java.com.spring.jdbc.service..*.*(..))" />
		<aop:advisor advice-ref="txAdvice" pointcut-ref="transationPointCut"/>
	</aop:config>

	<tx:advice id="txAdvice" transaction-manager="txManager">
		<tx:attributes>
			<tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
			<tx:method name="*"  propagation="REQUIRED" isolation="DEFAULT" />
		</tx:attributes>
	</tx:advice>

</beans>

</span>

1、JDBC的事务管理器为：DataSourceTransactionManager

（二）、dao实现类：使用 JdbcTemplate

<span style="font-size:18px;">/**
 *
 * PersonDaoImpl
 * @title
 * @desc
 * @author SAM-SHO
 * @Dec 28, 2014
 */

@Repository
public class PersonDaoImpl implements PersonDao {

	//使用JdbcTemplate，注意需要在配置中，把dataSource数据源注入到jdbcTemplate
	@Resource
	private JdbcTemplate jdbcTemplate;

	@Override
	public void save(PersonEntity persionEntity) {
		String sql = "insert into spring_person (person_id, name) values(?,?)";
		jdbcTemplate.update(sql, new Object[]{persionEntity.getPersonId(),persionEntity.getName()}, new int[]{Types.INTEGER,Types.VARCHAR});
	}

	@Override
	public void delete(int id) {
		String sql = "delete from spring_person  where person_id = ?";
		jdbcTemplate.update(sql, new Object[]{id}, new int[]{Types.INTEGER});

	}

	@Override
	public String queryPersonName(int id) {

		String sql = "select a.name from spring_person a where a.person_id = ?";
		String name = jdbcTemplate.queryForObject(sql, new Object[]{id}, String.class);
		return name;
	}

	public PersonEntity getPerson(int id) {

		String sql = "select a.* from spring_person a where a.person_id = ?";
		PersonEntity personEntity = jdbcTemplate.queryForObject(sql, new Object[]{id},new RowMapper<PersonEntity>(){

			@Override
			public PersonEntity mapRow(ResultSet rs, int index) throws SQLException {

				PersonEntity person = new PersonEntity();
				person.setPersonId(rs.getInt("person_id"));
				person.setName(rs.getString("name"));
				return person;
			}
		});

		return personEntity;
	}

	@Override
	public List<PersonEntity> getAllPerson() {

		String sql = "select a.* from spring_person a";
		List<PersonEntity> lists = jdbcTemplate.query(sql, new RowMapper<PersonEntity>(){

			@Override
			public PersonEntity mapRow(ResultSet rs, int index) throws SQLException {

				PersonEntity person = new PersonEntity();
				person.setPersonId(rs.getInt("person_id"));
				person.setName(rs.getString("name"));
				return person;
			}
		});

		return lists;
	}

	@Override
	public void update(String name, int id) {
		String sql = "update spring_person a set a.name = ? where a.person_id = ?";
		jdbcTemplate.update(sql, new Object[]{name,id}, new int[]{Types.VARCHAR,Types.INTEGER});

	}

}
</span>

1、使用JdbcTemplate，注意需要在配置中，把dataSource数据源注入到jdbcTemplate

（三）、测试

<span style="font-size:18px;">/**
 * SpringJdbcTest
 * @Title: spring整合jdbc测试
 * @Description:
 * @Copyright: Copyright (c) 2015
 * @Company:
 *
 * @author: SAM-SHO
 * @version: 1.0
 * @CreateDate：Jan 21, 2015
 */
public class SpringJdbcTest {

	private PersonService mPersonService;

	@Before
	public void init(){
		ApplicationContext cxt = new ClassPathXmlApplicationContext("application-Jdbc-Context.xml");
		mPersonService = (PersonService) cxt.getBean("personServiceImpl");

	}

	@Test
	public void save() {
		PersonEntity persionEntity = new  PersonEntity();
		persionEntity.setName("Sam-Sho-99");
		//增
		mPersonService.save(persionEntity); 

	}

	@Test
	public void delete() {

		//删除
		mPersonService.delete(5);

	}

	@Test
	public void update() {

		//修改
		mPersonService.update("蓝胖子", 6);

	}

	@Test
	public void query() {

		//查询一个实体
		PersonEntity persionEntity = mPersonService.getPerson(9);
		System.out.println(persionEntity.getPersonId());
		System.out.println(persionEntity.getName());

		// 查询名字
		String personName = mPersonService.queryPersonName(8);
		System.out.println(personName);

		//查询多个实体
		ArrayList<PersonEntity> lists = (ArrayList<PersonEntity>) mPersonService.getAllPerson();
		for (PersonEntity personEntity : lists) {
			System.out.println(personEntity.getPersonId());
			System.out.println(personEntity.getName());
		}
	}

}</span>

三、spring 整合hibernate

（一）配置

<span style="font-size:18px;"><?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

	<!-- 自动扫描 -->
	<context:component-scan base-package="main.java.com.spring.hibernate" />
	<!-- 打开aop 注解 -->
	<aop:aspectj-autoproxy />

	<!-- 配置数据源 -->
	<context:property-placeholder location="classpath:jdbc.properties" />
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName" value="${driverClassName}" />
		<property name="url" value="${url}" />
		<property name="username" value="${username}" />
		<property name="password" value="${password}" />
		<!-- 连接池启动时的初始值 -->
		<property name="initialSize" value="${initialSize}" />
		<!-- 连接池的最大值 -->
		<property name="maxActive" value="${maxActive}" />
		<!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
		<property name="maxIdle" value="${maxIdle}" />
		<!-- 最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
		<property name="minIdle" value="${minIdle}" />
	</bean>

	<!-- Hibernate 的 sessionFactory（使用注解） ，注入数据源和配置 -->
	<!-- <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean" hibernate4的配置-->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean" destroy-method="destroy">
		<property name="dataSource" ref="dataSource" />

		<!-- 自动扫描entity包下所有实体 -->
		<property name="packagesToScan">
			<list>
				<value>main.java.com.spring.entity</value>
			</list>
		</property>

		<property name="hibernateProperties">
			<value>
				hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
				hibernate.hbm2ddl.auto=update
				hibernate.show_sql=false
				hibernate.format_sql=false
				hibernate.cache.use_second_level_cache=true
				hibernate.cache.use_query_cache=false
				hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
		      </value>
		</property>

	</bean>

	<!-- 配置Hibernate的事物管理器 ：HibernateTransactionManager-->
	<bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"></property>
	</bean>

	<!-- 注解事物 -->
	<tx:annotation-driven transaction-manager="txManager" /> 

</beans>

</span>

1、启用hibernate的 二级缓存：EhCacheProvider

<span style="font-size:18px;">				hibernate.cache.use_second_level_cache=true
				hibernate.cache.use_query_cache=false
				hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider </span>

2、配置Hibernate的事物管理器 ：HibernateTransactionManager 。

（二）dao实现类

<span style="font-size:18px;">/**
 *
 * PersonDaoImpl
 * @title
 * @desc
 * @author SAM-SHO
 * @Dec 28, 2014
 */

@Repository
public class PersonDaoImpl implements PersonDao {

	@Resource
	private SessionFactory sessionFactory;

	private Session getSession(){
		return sessionFactory.getCurrentSession();
	}

	@Override
	public void save(PersonEntity persionEntity) {
		getSession().persist(persionEntity);
	}

	@Override
	public void delete(int id) {
		sessionFactory.getCurrentSession().delete(sessionFactory.getCurrentSession().load(PersonEntity.class, id));

	}

	@Override
	public String queryPersonName(int id) {

		String sql = "select a.name from spring_person a where a.person_id = ?";
		String name = (String) sessionFactory.getCurrentSession().createSQLQuery(sql).setParameter(0, id).uniqueResult();
		return name;
	}

	public PersonEntity getPerson(int id) {
		return (PersonEntity) sessionFactory.getCurrentSession().get(PersonEntity.class, id);

	}

	@SuppressWarnings("unchecked")
	@Override
	public List<PersonEntity> getAllPerson() {

		String hql = "from PersonEntity";
		return sessionFactory.getCurrentSession().createQuery(hql).list();//使用hql

	}

	@Override
	public void update(String name, int id) {
		String sql = "update spring_person a set a.name = ? where a.person_id = ?";
		sessionFactory.getCurrentSession().createSQLQuery(sql)//使用sql
		.setParameter(0, name)
		.setParameter(1, id)
		.executeUpdate();
	}

	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}
}
</span>

（三）测试

<span style="font-size:18px;">/**
 *
 * @Title:
 * @Description:
 * @Copyright: Copyright (c) 2015
 * @Company:
 *
 * @author: SAM-SHO
 * @version: 1.0
 * @CreateDate：Jan 21, 2015
 */
public class SpringHibernateTest {

	private PersonService mPersonService;

	@Before
	public void init(){
		ApplicationContext cxt = new ClassPathXmlApplicationContext("application-hibernate-Context.xml");
		mPersonService = (PersonService) cxt.getBean("personServiceImpl");

	}

	@Test
	public void save() {
		PersonEntity persionEntity = new  PersonEntity();
		persionEntity.setName("Sam-Sho-99");
		//增
		mPersonService.save(persionEntity); 

	}

	@Test
	public void delete() {

		//删除
		mPersonService.delete(16);

	}

	@Test
	public void update() {

		//修改
		mPersonService.update("蓝胖子", 13);

	}

	@Test
	public void query() {

		//查询一个实体
//		PersonEntity persionEntity = mPersonService.getPerson(9);
//		System.out.println(persionEntity.getPersonId());
//		System.out.println(persionEntity.getName());
//
//		// 查询名字
//		String personName = mPersonService.queryPersonName(8);
//		System.out.println(personName);

		//查询多个实体
		ArrayList<PersonEntity> lists = (ArrayList<PersonEntity>) mPersonService.getAllPerson();
		for (PersonEntity personEntity : lists) {
			System.out.println(personEntity.getPersonId());
			System.out.println(personEntity.getName());
		}
	}

}
</span>

（四）使用二级缓存 ehcache.xml

<span style="font-size:18px;"><?xml version="1.0" encoding="UTF-8"?>
<!--
    defaultCache节点为缺省的缓存策略
     maxElementsInMemory 内存中最大允许存在的对象数量
     eternal 设置缓存中的对象是否永远不过期 true
     overflowToDisk 把溢出的对象存放到硬盘上
     timeToIdleSeconds 指定缓存对象空闲多长时间就过期,过期的对象会被清除掉
     timeToLiveSeconds 指定缓存对象总的存活时间
     diskPersistent 当jvm结束是是否持久化对象
     diskExpiryThreadIntervalSeconds 指定专门用于清除过期对象的监听线程的轮询时间
 -->
<ehcache>
    <diskStore path="D:\cache"/>
    <defaultCache  maxElementsInMemory="1000" eternal="false" overflowToDisk="true"
        timeToIdleSeconds="120"
        timeToLiveSeconds="180"
        diskPersistent="false"
        diskExpiryThreadIntervalSeconds="60"/>
	<cache name="main.java.com.spring.entity.PersonEntity" maxElementsInMemory="100" eternal="false"
    overflowToDisk="true" timeToIdleSeconds="300" timeToLiveSeconds="600" diskPersistent="false"/>
    <!-- 使用自定义cache，需要在该entity中使用 Cache 的region属性指定-->
</ehcache>
</span>

（五）解决中文和懒加载问题：修改web.xml配置

<span style="font-size:18px;"><?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
	xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

	<welcome-file-list>
	  <welcome-file>index.jsp</welcome-file>
	</welcome-file-list>

    <!-- 加载Spring初始化容器对象的监听器 -->
	<listener>
	    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<!-- 设置Spring容器加载配置文件路径 -->
	<context-param>
	    <param-name>contextConfigLocation</param-name>
	    <param-value>classpath*:applicationContext.xml</param-value>
	</context-param>

	<!--中文过滤器     START   -->
	<filter>
		<filter-name>encodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>encodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	<!--中文过滤器			END  -->

	<!-- 解决懒加载 -->
	<filter>
		<filter-name>openSessionInView</filter-name>
		<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
		<init-param>
			<param-name>sessionFactoryBeanName</param-name>
			<param-value>sessionFactory</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>openSessionInView</filter-name>
		<url-pattern>*.action</url-pattern>
	</filter-mapping>

	<!-- 设置Struts2  START-->
	<filter>
		<filter-name>struts2</filter-name>
		<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
	</filter>

	<filter-mapping>
		<filter-name>struts2</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	<!-- Struts2  END-->

</web-app>
</span>

四、spring 整合jpa

（一）配置

<span style="font-size:18px;"><?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

	<!-- 自动扫描 -->
	<context:annotation-config/>
	<context:component-scan base-package="main.java.com.spring.jpa" />

  	<!-- JPA 当jpa底层使用hibernate实现，那么entityManagerFactory实际上就是sessionFactory-->
  	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
     	 <!-- 持久化单元的名称，value的值必须与persistence.xml文件中 persistence-unit标签中 name属性的值保持一致 -->
      	<property name="persistenceUnitName" value="springJpa"/>
  	</bean>  

	<!-- JPA的事物管理器： JpaTransactionManager-->
  	<bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">
  		<property name="entityManagerFactory" ref="entityManagerFactory"/>
 	 </bean>

  	<!-- 注解方式的事务 -->
  	<tx:annotation-driven transaction-manager="txManager"/>

</beans>

</span>

（二）Jpa持久化单元配置（代替jdbc.properties）

<span style="font-size:18px;"><?xml version="1.0"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0">
   <persistence-unit name="springJpa" transaction-type="RESOURCE_LOCAL"><!-- 本地事务 -->
      <properties>
         <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
         <property name="hibernate.connection.driver_class" value="org.gjt.mm.mysql.Driver"/>
         <property name="hibernate.connection.username" value="root"/>
         <property name="hibernate.connection.password" value="root"/>
         <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/spring?useUnicode=true&characterEncoding=UTF-8"/>
         <property name="hibernate.max_fetch_depth" value="3"/>
         <property name="hibernate.hbm2ddl.auto" value="update"/>
         <property name="hibernate.show_sql" value="false"/>
	     <property name="hibernate.format_sql" value="false"/>
      </properties>
   </persistence-unit>
</persistence>

<!--
1. persistence.xml名称不能更改 ，持久化单元名称
2. name="springJpa" 对应   beans.xml中的<property name="persistenceUnitName" value="springJpa"/>

--></span>

1、Jpa的实现使用的还是Hibernate 。

2、持久化单元的配置，一定要放在classpath下 META-INF/ 文件夹下。

（三）dao的实现类

<span style="font-size:18px;">/**
 *
 * @Title:
 * @Description:
 * @Copyright: Copyright (c) 2015
 * @Company:
 *
 * @author: SAM-SHO
 * @version: 1.0
 * @CreateDate：Jan 21, 2015
 */
@Repository
public class PersonDaoImpl implements PersonDao {

	//注入EntityManager
	@PersistenceContext
	EntityManager entityManager;

	@Override
	public void save(PersonEntity persionEntity) {

		entityManager.persist(persionEntity);
	}

	@Override
	public void delete(int id) {
		//getReference类似于sessionFactory的load方法
		entityManager.remove(entityManager.getReference(PersonEntity.class, id));
	}

	@Override
	public String queryPersonName(int id) {

		String sql = "select a.name from PersonEntity a where a.personId = ?";
		return (String) entityManager.createQuery(sql).setParameter(1, id).getSingleResult();
	}

	public PersonEntity getPerson(int id) {
		return entityManager.find(PersonEntity.class, id);
	}

	@SuppressWarnings("unchecked")
	@Override
	public List<PersonEntity> getAllPerson() {

		String hql = "select o from PersonEntity o";
		return entityManager.createQuery(hql).getResultList();
	}

	@Override
	public void update(String name, int id) {
		String sql = "update PersonEntity a set a.name = ? where a.personId = ?";
		entityManager.createQuery(sql)
		.setParameter(1, name)
		.setParameter(2, id)//这边的参数位置与sessionFaction的不同，从1开始
		.executeUpdate();

//		entityManager.merge(PersonEntity)

	}
}
</span>

（四）测试

<span style="font-size:18px;">/**
 *
 * @Title:
 * @Description:
 * @Copyright: Copyright (c) 2015
 * @Company:
 *
 * @author: SAM-SHO
 * @version: 1.0
 * @CreateDate：Jan 21, 2015
 */
public class SpringJpaTest {

	private PersonService mPersonService;

	@Before
	public void init(){
		ApplicationContext cxt = new ClassPathXmlApplicationContext("application-jpa-Context.xml");
		mPersonService = (PersonService) cxt.getBean("personServiceImpl");

	}

	@Test
	public void save() {
		PersonEntity persionEntity = new  PersonEntity();
		persionEntity.setName("Sam-Sho-JPA");
		//增
		mPersonService.save(persionEntity); 

	}

	@Test
	public void delete() {

		//删除
		mPersonService.delete(16);

	}

	@Test
	public void update() {

		//修改
		mPersonService.update("蓝胖子", 16);

	}

	@Test
	public void query() {

		//查询一个实体
//		PersonEntity persionEntity = mPersonService.getPerson(16);
//		System.out.println(persionEntity.getPersonId());
//		System.out.println(persionEntity.getName());
//
//		// 查询名字
		String personName = mPersonService.queryPersonName(16);
		System.out.println(personName);

		//查询多个实体
//		ArrayList<PersonEntity> lists = (ArrayList<PersonEntity>) mPersonService.getAllPerson();
//		for (PersonEntity personEntity : lists) {
//			System.out.println(personEntity.getPersonId());
//			System.out.println(personEntity.getName());
//		}
	}

}
</span>
时间： 2024-10-10 08:04:33

Spring笔记（五）: spring 整合jdbc、hibernate、jpa的相关文章

MyEclipse中自动整合Spring3+Hibernate/JPA

MyEclipse6.5中有这样一个功能,可以往项目中添加各种功能的支持,它可以自动为你把这些功能整合在一起. 这里以一个web project为例子说明. 一.新建数据库连接 首先要再Myeclipse中建立一个数据库连接,方便后面整合hibernate/JPA windows——show view——other选中DB Browser打开数据库连接窗口 在DB Browser窗口中右键new可以新建一个连接 点击finish完成 二. 整合Spring3.0.5+Hibernate3.6 首

Spring笔记1——Spring起源及其核心技术

Spring的作用 当我们使用一种技术时,需要思考为什么要使用这门技术.而我们为什么要使用Spring呢?从表面上面SSH这三大框架中,Struts是负责MVC责任的分离,并且提供为Web层提供诸如控制转发.数据校验,类型转换等功能.Hibernate负责将二维数据表抽象成实体类,让我们能够从面向数据表转向面向实体类开发即面向对象开发.而Spring在干什么呢?Spring似乎什么都没干,但好像少了它又不行.Spring究竟是做什么的呢?我们首先从Spring的起源来看. 提到Spring技术,

Spring笔记(五)--注解方式实现AOP

包:aspectjrt.jar.aspectjweaver.jar AOP:面向切面的编程 1.XML配置: 2.注解. 一.注解方式: 打开注解处理器: <aop:aspectj-autoproxy/> 接口: 1 package com.dwr.spring.proxy; 2 3 public interface UserManager { 4 public void addUser(String username,String password); 5 public void delet

Spring笔记2——Spring中Bean的装配

1.引言 Spring中,对象无需自己负责查找或创建与其关联的其他对象,而是由容器负责把需要相互协作的对象引用赋予各个对象.创建应用对象之间的协作关系的行为通常称为装配(Wiring),这也是依赖注入的本质. 2.声明Bean 配置Bean的方式主要有两种:基于XML文件的配置方式和基于Java注解的配置方式.传统的基于XML文件的配置方式在声明Bean时,Spring配置文件的根元素来源于Spring beans命名空间所定义的<beans>元素.除了beans命名空间外,Java自带了多种

Spring笔记——1.Spring简介

Spring是一种轻量级的架构,能够帮助我们更好地管理java类(Bean)之间的依赖关系,极大提高企业应用开发速率.我们可以使用MyEclipse自带的增加Spring Capacities工具来为项目增加Spring 功能.User Library里面需要有spring lib包下面的所有jar,以及一个名为common-logging的jar包(需要额外下载,web项目需要). 使用Spring管理Bean 我们可以使用applicationContext.xml文件更好地,无浸入地管理B

Spring Boot整合Spring MVC、Spring、Spring Data JPA(Hibernate)

一句话总结:Spring Boot不是新的功能框架,而是为了简化如SSH.SSM等等多个框架的搭建.整合及配置.使用Spring Boot 10分钟搭建起Spring MVC.Spring.Spring Data JPA(Hibernate)基础后台架构.基本零配置,全注解. 步骤一: 使用Spring Boot提供的网站生成maven项目及基础依赖.打开https://start.spring.io/网站,右侧输入想要的特性依赖.输入Web提供整合Spring MVC,输入JPA提供整合Spr

java框架整合例子（spring、spring mvc、spring data jpa、hibernate）

这是自己参考springside开源项目整合的框架,主要整合了spring.spring mvc.spring data jpa.hibernate这几个框架,对于这几个框架其中感觉比较舒服的还是spring data jpa这个框架,这个框架在写dao类的时候,只需要写一个接口声明,spring data jpa会自动的实现其实现类,使用起来比较方便,至于详细的使用方法还请自己百度吧,因为我也不清楚.个人感觉还有一个比较不错的地方就是能够打印sql语句,都知道hibernate打印的sql语句

mybatis学习笔记（五） -- maven+spring+mybatis从零开始搭建整合详细过程（附demo和搭建过程遇到的问题解决方法）

文章介绍结构一览 一.使用maven创建web项目 1.新建maven项目 2.修改jre版本 3.修改Project Facts,生成WebContent文件夾 4.将WebContent下的两个文件复制到src/main/webapp下,删掉WebContent 5.修改Deployment Assembly 6.测试 二.mybatis访问mysql 1.数据库准备 2.修改pom.xml 3.创建实体类 4.创建访问接口 5.添加映射文件 6.添加MyBatisCfg.xml配置文件,注

Spring知识点总结(五)Spring整合JDBC

 1. 回顾JDBC        a. java操作关系型数据的API.导入相关数据库的驱动包后可以通过JDBC提供的接口来操作数据库.        b. 实现JDBC的六个步骤            注册数据库驱动            获取数据库连接            获取传输器对象            传输sql执行获取结果集对象            遍历结果集获取信息            关闭资源        c. 数据库连接池(数据源) C3P0连接池 2.Spring