[url]http://zmx.iteye.com/blog/556452
[/url]
最近转载学习的一个实验,项目在附件,所需要的jar包也是在下面,在导入项目后自己把包加进去吧。
实体类:
package com.entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class Student {
private Integer stu_id;
private String stu_name;
private String stu_sex;
private Integer stu_age;
private String stu_info;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
public Integer getStu_id() {
return stu_id;
}
public void setStu_id(Integer stu_id) {
this.stu_id = stu_id;
}
@Column(nullable = false)
public String getStu_name() {
return stu_name;
}
public void setStu_name(String stu_name) {
this.stu_name = stu_name;
}
public Integer getStu_age() {
return stu_age;
}
public void setStu_age(Integer stu_age) {
this.stu_age = stu_age;
}
public String getStu_info() {
return stu_info;
}
public void setStu_info(String stu_info) {
this.stu_info = stu_info;
}
public String getStu_sex() {
return stu_sex;
}
public void setStu_sex(String stu_sex) {
this.stu_sex = stu_sex;
}
@Override
public int hashCode() {
final int PRIME = 31;
int result = 1;
result = PRIME * result + ((stu_id == null) ? 0 : stu_id.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final Student other = (Student) obj;
if (stu_id == null) {
if (other.stu_id != null)
return false;
} else if (!stu_id.equals(other.stu_id))
return false;
return true;
}
}
DAO接口类:
package com.dao;
import java.util.List;
import com.entity.Student;
public interface StudentDao {
public void save(Student stu);
public void delete(Integer stu_id);
public void update(Student stu);
public Student getStudentByPK(Integer stu_id);
public List<Student> queryAll();
}
DAO接口实现类:
package com.impl;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import com.dao.StudentDao;
import com.entity.Student;
public class StudentDaoImpl implements StudentDao {
@PersistenceContext
EntityManager em;
public void save(Student stu) {
em.persist(stu);
}
public void delete(Integer stu_id) {
em.remove(em.getReference(Student.class, stu_id));
}
public void update(Student stu) {
em.merge(stu);
}
public Student getStudentByPK(Integer stu_id) {
return em.find(Student.class, stu_id);
}
public List<Student> queryAll() {
List resultList = em.createQuery("select s from Student s").getResultList();
return resultList;
}
}
服务接口类:
package com.service;
import java.util.List;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.entity.Student;
@Transactional
public interface StudentService {
public void save(Student stu);
public void delete(Integer stu_id);
public void update(Student stu);
@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
public Student getStudentByPK(Integer stu_id);
@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
public List<Student> queryAll();
}
服务实现类:
package com.serviceImpl;
import java.util.List;
import com.dao.StudentDao;
import com.entity.Student;
import com.service.StudentService;
public class StudentServiceImpl implements StudentService {
private StudentDao studao;
public void delete(Integer stu_id) {
studao.delete(stu_id);
}
public Student getStudentByPK(Integer stu_id) {
return studao.getStudentByPK(stu_id);
}
public List<Student> queryAll() {
return studao.queryAll();
}
public void save(Student stu) {
studao.save(stu);
}
public void update(Student stu) {
studao.update(stu);
}
public void setStudao(StudentDao studao) {
this.studao = studao;
}
}
服务测试类:
package com.test;
import java.util.List;
import junit.framework.TestCase;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.entity.Student;
import com.service.StudentService;
public class StudentServiceTest extends TestCase {
public void testSave() {
ApplicationContext context = new ClassPathXmlApplicationContext(
"beans.xml");
StudentService stuMght = (StudentService) context
.getBean("studentSerivce");
Student stu = new Student();
stu.setStu_name("xiaobo");
stu.setStu_age(22);
stu.setStu_sex("男");
stu.setStu_info("C++");
stuMght.save(stu);
System.out.println(stu);
}
public void testDelete() {
ApplicationContext context = new ClassPathXmlApplicationContext(
"beans.xml");
StudentService stuMght = (StudentService) context
.getBean("studentSerivce");
stuMght.delete(3);
}
public void testUpdate() {
ApplicationContext context = new ClassPathXmlApplicationContext(
"beans.xml");
StudentService stuMght = (StudentService) context
.getBean("studentSerivce");
Student stu = stuMght.getStudentByPK(4);
stu.setStu_age(23);
stuMght.update(stu);
}
public void testGetStudentByPK() {
ApplicationContext context = new ClassPathXmlApplicationContext(
"beans.xml");
StudentService stuMght = (StudentService) context
.getBean("studentSerivce");
Student stu = stuMght.getStudentByPK(5);
System.out.println(stu);
}
public void testQueryAll() {
ApplicationContext context = new ClassPathXmlApplicationContext(
"beans.xml");
StudentService stuMght = (StudentService) context
.getBean("studentSerivce");
List<Student> stuList = stuMght.queryAll();
for (Student stu : stuList) {
System.out.println(stu.getStu_name());
}
}
}
JPA配置文件persistence.xml:
<?xml version="1.0" encoding="UTF-8"?>
<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="panshao" transaction-type="RESOURCE_LOCAL">
<properties>
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />
<property name="hibernate.hbm2ddl.auto" value="update" />
<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/lee?useUnicode=true&characterEncoding=utf-8" />
</properties>
</persistence-unit>
</persistence>
spring配置文件beans.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: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 />
<bean id="entityManager"
class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
<property name="persistenceUnitName" value="panshao"></property>
</bean>
<bean id="JPATranManager"
class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManager"></property>
</bean>
<tx:annotation-driven transaction-manager="JPATranManager" />
<bean id="studentDAO"
class="com.impl.StudentDaoImpl">
</bean>
<bean id="studentSerivce"
class="com.serviceImpl.StudentServiceImpl">
<property name="studao" ref="studentDAO"></property>
</bean>
</beans>
分享到:
相关推荐
6. **Integration with Spring MVC**:Spring Data JPA 可以无缝集成到 Spring MVC 应用中,方便在 Web 层进行数据操作。通过 ModelMapper 和 Controller 方法,可以直接将 Repository 中的数据转换为视图模型并返回...
5. **事务管理**:Spring Data JPA集成Spring的事务管理,可以方便地在方法级别控制事务的开始、提交、回滚,确保数据一致性。 6. ** auditing**:Spring Data JPA还提供了审计功能,通过`@CreationTimestamp`和`@...
Spring整合JPA与MySQL是现代Java企业级应用中常见的数据持久化方案,它结合了Spring框架的灵活性和Java Persistence API(JPA)的强大功能,同时利用MySQL作为关系型数据库,提供高效、便捷的数据存储和查询能力。...
Spring Data JPA的主要优点在于其高度的开发效率、成熟的语法结构以及与Spring框架的紧密集成。 1. **开发效率极高**: - Spring Data JPA通过提供自动化的 Repository 实现,减少了大量手动编写SQL和DAO层代码的...
在IT行业中,Spring框架...在"Spring集成JPA和MyBatis简单例子-20170622"这个压缩包中,可能包含了示例代码,演示了如何在Spring项目中配置和使用这两种技术,这对于初学者理解和实践Spring的集成能力具有很大的帮助。
Struts2整合Spring和JPA是企业级Java应用开发中常见的技术组合,它们分别负责不同的职责:Struts2作为一款成熟的MVC框架,主要用于处理Web层的请求与响应;Spring作为一个全面的轻量级框架,提供了依赖注入(DI)和...
现在,一个简单的Spring整合JPA的实例就完成了。当用户向/users发送POST请求时,服务器会创建一个新的User对象并保存到数据库。通过这样的方式,我们可以利用Spring和JPA的强大功能,以简洁的代码实现复杂的数据库...
本教程将深入探讨如何在Spring Boot项目中整合Spring Data JPA,实现高效且简洁的数据持久化。 首先,Spring Boot整合Spring Data JPA的基础是引入相关的依赖。在`pom.xml`或`build.gradle`文件中,我们需要添加...
**Spring整合JPA详解** Spring框架是Java领域中极为重要的一个组件,它为开发者提供了丰富的功能,包括依赖注入、AOP(面向切面编程)、事务管理等。而JPA(Java Persistence API)则是Java世界中用于对象关系映射...
Spring Data JPA的另一个强大特性是其与Spring Data Repositories的集成,它允许我们自定义复杂的查询,甚至支持分页和排序。通过定义接口方法,Spring Data会自动为我们生成对应的查询方法。 最后,Spring Data ...
在本项目中,我们主要探讨如何手动构建一个基于SpringMVC、Spring Data JPA、Hibernate以及FreeMarker模板引擎的Maven工程,同时实现环境切换功能。这个基础框架为日常开发工作提供了必要的支持。 首先,SpringMVC...
这是整合SpringMVC+Spring+SpringDataJPA+Hibernate简单的实现登录的功能,用的是mysql数据库,这是一个web Project 如果你用的是JavaEE6那么你要注意bean-validator.jar和weld-osgi-bundle.jar与slf4j的jar包冲突。...
**SpringBoot整合SpringData JPA** 是一个现代Java开发中的常见技术栈,它结合了Spring Boot的便捷性和Spring Data JPA的数据访问效率。Spring Boot简化了应用的初始搭建以及配置,而Spring Data JPA则是Spring ...
**Spring 整合 JPA 知识点详解** Spring 框架是 Java 开发中最常用的轻量级框架之一,它提供了丰富的功能,包括依赖注入、面向切面编程以及多种数据访问集成。JPA(Java Persistence API)是 Java 平台上的一个标准...
- **强大的查询支持**:除了简单的 CRUD 方法,Spring Data JPA 还支持基于方法名的复杂查询,甚至可以使用 JPA Querydsl 或 Specification 进行更复杂的查询。 - **事务管理**:Spring Data JPA 结合 Spring 的事务...
1. **简介**:了解Spring Data JPA的目标,它是如何简化JPA的使用,以及它如何与其他Spring模块集成。 2. **快速入门**:包括设置项目依赖,配置数据源和JPA供应商(如Hibernate),以及创建第一个Repository接口。...
Spring Data JPA 集成了Spring 的事务管理,可以很方便地配置全局或方法级别的事务。`@Transactional` 注解用于标记需要进行事务处理的方法。 9. **测试** 使用Spring Boot 的测试框架,可以编写单元测试和集成...
Spring MVC与Spring其他模块紧密集成,如Spring Data JPA,提供了一种强大的、可扩展的Web开发解决方案。 **Hibernate 4.3** Hibernate是Java社区中最流行的ORM工具之一,它在4.3版本中提供了许多性能优化和新特性...
SpringBoot集成了SpringDataJPA之后,就可以利用SpringBoot的自动配置能力,让开发者能够快速搭建和运行使用SpringDataJPA的项目。 在SpringBoot项目中整合SpringDataJPA,首先要导入必要的Maven依赖。在项目中,...