导入jpa,spring需要的jar包
domain:
package com.lmning.po;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="people")
public class User implements Serializable{
private static final long serialVersionUID = -7373249707516981319L;
@Id
@GeneratedValue
private int id;
@Column(name="name")
private String name;
@Column(name="password")
private String password;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String toString(){
return id+":"+name+"---"+password;
}
}
dao接口:
public interface UserDao {
public abstract void save(User user);
public abstract void update(User user);
@Transactional(readOnly = true, propagation = Propagation.NOT_SUPPORTED)
public abstract User getUser(Integer id);
@SuppressWarnings("unchecked")
@Transactional(readOnly = true, propagation = Propagation.NOT_SUPPORTED)
public abstract List<User> getAllUsers();
public abstract void delete(Integer id);
}
dao实现
package com.lmning.dao.bean;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.lmning.po.User;
@Transactional
public class UserDaoBean implements UserDao {
@PersistenceContext(unitName="people")
EntityManager em;
public void save(User user){
em.persist(user);
}
public void update(User user){
em.merge(user);
}
@Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
public User getUser(Integer id){
return em.find(User.class, id);
}
@SuppressWarnings("unchecked")
@Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
public List<User> getAllUsers(){
List<User> users =
em.createQuery("select u from User u").getResultList();
return users;
}
public void delete(Integer id){
em.remove(em.getReference(User.class, id));
}
}
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: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: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}"/>
<property name="maxIdle" value="${maxIdle}"/>
<property name="minIdle" value="${minIdle}"/>
</bean>
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="persistenceXmlLocation" value="classpath:META-INF/persistence.xml" />
<property name="loadTimeWeaver">
<bean class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver"/>
</property>
</bean>
-->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
<property name="persistenceUnitName" value="people"/>
</bean>
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory">
<ref local="entityManagerFactory"/>
</property>
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/>
<bean id="userDao" class="com.lmning.dao.bean.UserDaoBean"></bean>
</beans>
META-INF下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="people" transaction-type="RESOURCE_LOCAL">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<!--<jta-data-source>java:/MySqlDS3</jta-data-source> -->
<properties>
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />
<property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
<property name="hibernate.connection.username" value="root" />
<property name="hibernate.connection.password" value="1234" />
<property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/test" />
<property name="hibernate.max_fetch_depth" value="5" />
<property name="hibernate.jdbc.fetch_size" value="20" />
<property name="hibernate.jdbc.batch_size" value="10" />
<property name="hibernate.hbm2ddl.auto" value="update" />
<property name="hibernate.show_sql" value="true" />
<property name="hibernate.format_sql" value="false" />
</properties>
</persistence-unit>
</persistence>
测试,ok!
分享到:
相关推荐
这篇博客“简单的spring整合JPA”将向我们展示如何将这两个强大的工具结合在一起,以便更高效地进行数据库操作。 首先,我们需要理解Spring与JPA整合的基本概念。Spring框架提供了一个名为Spring Data JPA的模块,...
Spring整合JPA与MySQL是现代Java企业级应用中常见的数据持久化方案,它结合了Spring框架的灵活性和Java Persistence API(JPA)的强大功能,同时利用MySQL作为关系型数据库,提供高效、便捷的数据存储和查询能力。...
**Spring 整合 JPA 知识点详解** Spring 框架是 Java 开发中最常用的轻量级框架之一,它提供了丰富的功能,包括依赖注入、面向切面编程以及多种数据访问集成。JPA(Java Persistence API)是 Java 平台上的一个标准...
在Spring整合JPA的过程中,首先需要在项目中添加相关的依赖。如果使用Maven,我们需要在pom.xml文件中加入Spring、Spring Data JPA和Hibernate的相关依赖。例如: ```xml <!-- Spring framework --> <groupId>...
**Spring整合JPA详解** Spring框架是Java领域中极为重要的一个组件,它为开发者提供了丰富的功能,包括依赖注入、AOP(面向切面编程)、事务管理等。而JPA(Java Persistence API)则是Java世界中用于对象关系映射...
Spring整合JPA(Java Persistence API)是现代Java应用程序中常见的数据访问技术,它提供了ORM(对象关系映射)的功能,使得开发者可以使用面向对象的方式来操作数据库,而无需关心底层的SQL语句。本整合教程将深入...
Spring整合JPA(Java Persistence API)是现代Java开发中常用的一种技术栈,它允许开发者以声明式的方式管理数据库操作,极大地简化了数据访问层的代码。Spring Data JPA是Spring框架的一部分,它提供了对JPA的高级...
Spring Data JPA 是一个强大的框架,它简化了Java应用程序与数据库之间的交互,是Spring生态中的重要组成部分。通过使用Spring Data JPA,开发者可以避免编写大量的JPA(Java Persistence API)和SQL代码,专注于...
Struts2整合Spring和JPA是企业级Java应用开发中常见的技术组合,它们分别负责不同的职责:Struts2作为一款成熟的MVC框架,主要用于处理Web层的请求与响应;Spring作为一个全面的轻量级框架,提供了依赖注入(DI)和...
前几天单独做了jpa操作数据的demo,今天把spring整合了进来用spring+jpa的方式重新做了一套案例;期间各种jar包不完整报错;错误分析受益匪浅,终整合成功、以上是我整理的代码。基本的功能都已实现,想拓展的同学...
本教程将深入探讨如何在Spring Boot项目中整合Spring Data JPA,实现高效且简洁的数据持久化。 首先,Spring Boot整合Spring Data JPA的基础是引入相关的依赖。在`pom.xml`或`build.gradle`文件中,我们需要添加...
**SpringBoot整合SpringData JPA** 是一个现代Java开发中的常见技术栈,它结合了Spring Boot的便捷性和Spring Data JPA的数据访问效率。Spring Boot简化了应用的初始搭建以及配置,而Spring Data JPA则是Spring ...
**SpringData、Spring和JPA整合详解** 在Java企业级开发中,Spring框架因其强大的功能和灵活的架构设计,已经成为主流的开发选择。SpringData和JPA(Java Persistence API)则是Spring框架的重要扩展,用于简化数据...
Spring Boot 整合 Spring Data JPA** - **环境搭建**:在 Maven 项目中添加相关依赖,包括 `spring-boot-starter-data-jpa`、数据库驱动(如 MySQL)、连接池(如 Druid),以及 Spring Boot 的父依赖 `spring-...
在现代Java Web开发中,"Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA"是一个常见的架构组合,被广泛应用于构建企业级应用程序。这个组合通常被称为"SSM",其中"M"代表Maven,"S"代表Spring,包括Spring核心...
这是整合SpringMVC+Spring+SpringDataJPA+Hibernate简单的实现登录的功能,用的是mysql数据库,这是一个web Project 如果你用的是JavaEE6那么你要注意bean-validator.jar和weld-osgi-bundle.jar与slf4j的jar包冲突。...
在本项目中,我们探索的是一个基于2017年技术栈的Java Web应用程序实例,主要涉及Spring Data JPA、Spring 4.2、Spring MVC和Hibernate 4.3。这些技术是Java开发中的核心组件,尤其在企业级应用开发中广泛使用。下面...
在SpringBoot项目中整合SpringDataJPA,首先要导入必要的Maven依赖。在项目中,需要引入SpringBoot的启动器(Starter)依赖,如`spring-boot-starter-web`用于开发web应用,`spring-boot-starter-data-jpa`用于数据...
总之,这个项目提供了一个完整的Spring MVC应用示例,其中整合了Spring Data JPA进行数据库操作,并使用JSON进行数据交换,对于学习Spring框架和JPA的初学者来说,是一个很好的实践平台。通过深入研究和运行这个项目...
Spring 2.5整合JPA使得开发者能够在享受Spring框架带来的便利的同时,充分利用JPA的ORM能力。这种整合不仅简化了数据库访问,还提高了代码的可维护性和测试性。随着Spring和JPA的不断更新,现在的整合方式可能与...