第十八章 Spring整合jpa

框架搭建步骤

       1. 添加spring和jpa相关jar依赖

       2. 配置spring的xml文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mydb
jdbc.user=root
jdbc.password=

<?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:p="http://www.springframework.org/schema/p"
	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-3.0.xsd
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context-3.0.xsd
		http://www.springframework.org/schema/tx
		http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
	">
	
	<!-- 配置自动扫描包 -->
	<context:component-scan base-package="com" />
			
	<!-- 引入属性配置文件 -->
	<context:property-placeholder location="classpath:mysql.properties"/>
	<!-- 配置c3p0数据源 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driver}" />
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="user" value="${jdbc.user}" />
		<property name="password" value="${jdbc.password}" />
	</bean>
	
	<!-- 配置jpa核心EntityManager -->
	<bean id="entityManager" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<!-- 配置jpa的具体实现 -->
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
		</property>
		<!-- 配置实体类所在的包 -->
		<property name="packagesToScan" value="com.entity" />
		<!-- 配置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>
	
	<!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManager"></property>
	</bean>
	
	<!-- 配置支持基于注解的事务配置 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>
	
</beans>

       3. 创建持久化实体类

package com.entity;

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

/*
 * 	映射实体类
 */
@Entity
public class Student {
	private int stuno;
	private String sname;
	private int score;
	private String addr;
	public Student() {
		super();
	}
	public Student(int stuno, String sname, int score, String addr) {
		super();
		this.stuno = stuno;
		this.sname = sname;
		this.score = score;
		this.addr = addr;
	}
	@GeneratedValue(strategy=GenerationType.AUTO)
	@Id
	public int getStuno() {
		return stuno;
	}
	public void setStuno(int stuno) {
		this.stuno = stuno;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
	public String getAddr() {
		return addr;
	}
	public void setAddr(String addr) {
		this.addr = addr;
	}
}

       4. 编写dao层接口

package com.dao;

import com.entity.Student;

/*
 * 	dao层接口
 */
public interface IStudentDao {
	public void insert(Student student);
}

package com.dao;

import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.stereotype.Repository;

import com.entity.Student;
// 注解创建dao的实例对象
@Repository
public class StudentDaoImp implements IStudentDao{
	//注入的是实体管理器，执行持久化操作的，需要配置文件,配置与当前事务进行关联
	@PersistenceContext
	@Resource
	private EntityManager em;
	
	@Override
	public void insert(Student student) {
		// 对数据库进行插入数据
		em.persist(student);
	}
	
}

       4. 编写service层

package com.service;

import com.entity.Student;
/*
 * service层接口
 */
public interface IStudentService {
	public boolean insert(Student student);
}

package com.service;

import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.dao.IStudentDao;
import com.entity.Student;

// 注解指明service层的实现在spring注入时的名字
@Service("stuService")
public class StudentServiceImp implements IStudentService{
	@Resource
	private IStudentDao iStudentDao;
	
	/*
	 *  指定加载事务:方法中所有事务必须执行成功,才会提交事务
	 */
	@Transactional
	@Override
	public boolean insert(Student student) {
		boolean flag=false;
		try {
			iStudentDao.insert(student);
			flag=true;
		} catch (Exception e) {
			flag=false;
		}
		return flag;
	}

}

       5. 测试

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.entity.Student;
import com.service.IStudentService;

public class Test {
	public static void main(String[] args) {
		// 加载spring配置文件
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		// 获取spring容器bean:名字为service层注解的name
		IStudentService iss = (IStudentService) ac.getBean("stuService");
		// 插入数据
		boolean flag =  iss.insert(new Student(0, "Micro", 88, "NewYork"));
		System.out.println(flag ? "插入成功" : "插入失败");
	}
}