Eclipse中搭建spring+jpa

Eclipse 中搭建spring+jpa

 

Spring JPA通过为用户统一创建和销毁EntityManager，进行事务管理，简化JPA的配置等使用户的开发更加简便。

 

1. 创建一个java项目或web项目

2. 添加jar包

antlr-2.7.7.jar
c3p0-0.9.2.1.jar
com.springsource.net.sf.cglib-2.2.0.jar
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
commons-logging-1.1.3.jar
dom4j-1.6.1.jar
hibernate-c3p0-4.2.4.Final.jar
hibernate-commons-annotations-4.0.2.Final.jar
hibernate-core-4.2.4.Final.jar
hibernate-entitymanager-4.2.4.Final.jar
hibernate-jpa-2.0-api-1.0.1.Final.jar
javassist-3.15.0-GA.jar
jboss-logging-3.1.0.GA.jar
jboss-transaction-api_1.1_spec-1.0.1.Final.jar
mchange-commons-java-0.2.3.4.jar
mysql-connector-java-5.1.7-bin.jar
ojdbc6.jar
spring-aop-4.0.0.RELEASE.jar
spring-aspects-4.0.0.RELEASE.jar
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELEASE.jar
spring-core-4.0.0.RELEASE.jar
spring-expression-4.0.0.RELEASE.jar
spring-jdbc-4.0.0.RELEASE.jar
spring-orm-4.0.0.RELEASE.jar
spring-tx-4.0.0.RELEASE.jar
spring-web-4.0.0.RELEASE.jar
spring-webmvc-4.0.0.RELEASE.jar

3. 创建包com.lhc.bean包，新建Dept6.java

package com.lhc.bean;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table
public class Dept6 {

	private int id;
	
	private String deptName;

	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getDeptName() {
		return deptName;
	}

	public void setDeptName(String deptName) {
		this.deptName = deptName;
	}
	
	
}

3. 新建com.lhc.dao包，创建DeptDao.java

package com.lhc.dao;
 
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
 
import org.springframework.stereotype.Repository;
 
@Repository
public class DeptDao {
 
@PersistenceContext//得到当前事务相关的EntityManager对象
private EntityManager manager;
public void save(Object obj) {
      manager.persist(obj);
}
}

5. 创建servcie接口和实现类

接口略

实现类如下：

package com.lhc.service;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import com.lhc.dao.DeptDao;
@Service
public class DeptService {
 
     @Autowired
     private DeptDao deptDao;
     @Transactional
      //这里传递了两个对象，分别进行保存，主要是为了测试事务
     public void addDept(Object obj1, Object obj1) {
          deptDao.save(obj1);
deptDao.save(obj2);
     }
}

6. src下创建db.properties，编写连接数据库的信息

jdbc.user=scott
jdbc.password=tiger
jdbc.driverClass=oracle.jdbc.OracleDriver
jdbc.jdbcUrl=jdbc:oracle:thin:@localhost:1521:orcl

 

7. src下创建applicationContext.xml，代码如下：

<?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:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
      http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
 
     <!—自动扫描，为这个包下面带有@Service等这些注解的类创建实例，在遇到@Autowired时进行自动注入-->
<context:component-scan base-package="com.lhc"></context:component-scan>
 
     <!—加载properties资源文件 --> 
<context:property-placeholder location="classpath:db.properties"/>
<bean id="dataSource"
      class="com.mchange.v2.c3p0.ComboPooledDataSource">
      <property name="user" value="${jdbc.user}"></property>
      <property name="password" value="${jdbc.password}"></property>
      <property name="driverClass" value="${jdbc.driverClass}"></property>
      <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
</bean>
<!-- 配置 EntityManagerFactory -->
<bean id="entityManagerFactory"
      class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
      <property name="dataSource" ref="dataSource"></property>
      <!-- 配置 JPA 提供商的适配器. 可以通过内部 bean 的方式来配置 -->
      <property name="jpaVendorAdapter">
           <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
      </property>  
      <!-- 配置实体类所在的包 -->
      <property name="packagesToScan" value="com.lhc.bean"></property>
      <!-- 配置 JPA 的基本属性. 例如 JPA 实现产品的属性 -->
      <property name="jpaProperties">
           <props>
               <prop key="hibernate.show_sql">true</prop>
               <prop key="hibernate.format_sql">true</prop>
               <prop key="hibernate.hbm2ddl.auto">update</prop>
           </props>
      </property>
</bean>
<!-- 配置 JPA 使用的事务管理器 -->
<bean id="transactionManager"
      class="org.springframework.orm.jpa.JpaTransactionManager">
      <property name="entityManagerFactory" ref="entityManagerFactory"></property>  
</bean>
<!-- 配置支持基于注解是事务配置 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

8. 创建一个测试包，在包下创建测试类：

public class SsspTest {
 
         public static void main(String[] args) {
                    ApplicationContext ctx =
new ClassPathXmlApplicationContext("applicationContext.xml");
                    DeptService deptService = ctx.getBean(DeptService.class);
                    Dept6 dept1=new Dept6();
                    dept1.setDeptName("test1");
                    Dept6 dept2=new Dept6();
                    dept2.setDeptName("test1");
          
//保存两个部门，service配置的有事务，如果保存时，有任何一个部门保存出错，则两个部门都添加失败，只有都添加成功时，两个部门添加才会成功
                    deptService.addDept(dept1, dept2);
         }
}

到此为止，spring+jpa 的整合就完成了，如果需要继续做修改查询删除等操作，只需要像以前dao 中写的jpa 代码操作一样就可以了