`
lmning
  • 浏览: 43717 次
  • 性别: Icon_minigender_1
  • 来自: 武汉
社区版块
存档分类
最新评论

spring 整合 jpa

阅读更多

导入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与JPA整合的基本概念。Spring框架提供了一个名为Spring Data JPA的模块,...

    spring整合jpa mysql

    Spring整合JPA与MySQL是现代Java企业级应用中常见的数据持久化方案,它结合了Spring框架的灵活性和Java Persistence API(JPA)的强大功能,同时利用MySQL作为关系型数据库,提供高效、便捷的数据存储和查询能力。...

    spring整合JPA

    **Spring 整合 JPA 知识点详解** Spring 框架是 Java 开发中最常用的轻量级框架之一,它提供了丰富的功能,包括依赖注入、面向切面编程以及多种数据访问集成。JPA(Java Persistence API)是 Java 平台上的一个标准...

    spring整合jpa简单实例

    在Spring整合JPA的过程中,首先需要在项目中添加相关的依赖。如果使用Maven,我们需要在pom.xml文件中加入Spring、Spring Data JPA和Hibernate的相关依赖。例如: ```xml &lt;!-- Spring framework --&gt; &lt;groupId&gt;...

    Spring整合JPA

    **Spring整合JPA详解** Spring框架是Java领域中极为重要的一个组件,它为开发者提供了丰富的功能,包括依赖注入、AOP(面向切面编程)、事务管理等。而JPA(Java Persistence API)则是Java世界中用于对象关系映射...

    spring整合jpa

    Spring整合JPA(Java Persistence API)是现代Java应用程序中常见的数据访问技术,它提供了ORM(对象关系映射)的功能,使得开发者可以使用面向对象的方式来操作数据库,而无需关心底层的SQL语句。本整合教程将深入...

    SPRING整合jpa

    Spring整合JPA(Java Persistence API)是现代Java开发中常用的一种技术栈,它允许开发者以声明式的方式管理数据库操作,极大地简化了数据访问层的代码。Spring Data JPA是Spring框架的一部分,它提供了对JPA的高级...

    Spring Data JPA 笔记

    Spring Data JPA 是一个强大的框架,它简化了Java应用程序与数据库之间的交互,是Spring生态中的重要组成部分。通过使用Spring Data JPA,开发者可以避免编写大量的JPA(Java Persistence API)和SQL代码,专注于...

    Struts2整合Spring、JPA

    Struts2整合Spring和JPA是企业级Java应用开发中常见的技术组合,它们分别负责不同的职责:Struts2作为一款成熟的MVC框架,主要用于处理Web层的请求与响应;Spring作为一个全面的轻量级框架,提供了依赖注入(DI)和...

    Spring整合jpa

    前几天单独做了jpa操作数据的demo,今天把spring整合了进来用spring+jpa的方式重新做了一套案例;期间各种jar包不完整报错;错误分析受益匪浅,终整合成功、以上是我整理的代码。基本的功能都已实现,想拓展的同学...

    Spring Boot整合SpringDataJPA

    本教程将深入探讨如何在Spring Boot项目中整合Spring Data JPA,实现高效且简洁的数据持久化。 首先,Spring Boot整合Spring Data JPA的基础是引入相关的依赖。在`pom.xml`或`build.gradle`文件中,我们需要添加...

    springBoot整合springData JPA

    **SpringBoot整合SpringData JPA** 是一个现代Java开发中的常见技术栈,它结合了Spring Boot的便捷性和Spring Data JPA的数据访问效率。Spring Boot简化了应用的初始搭建以及配置,而Spring Data JPA则是Spring ...

    SpringData和Spring和JPA的整合

    **SpringData、Spring和JPA整合详解** 在Java企业级开发中,Spring框架因其强大的功能和灵活的架构设计,已经成为主流的开发选择。SpringData和JPA(Java Persistence API)则是Spring框架的重要扩展,用于简化数据...

    整合Spring Data JPA1

    Spring Boot 整合 Spring Data JPA** - **环境搭建**:在 Maven 项目中添加相关依赖,包括 `spring-boot-starter-data-jpa`、数据库驱动(如 MySQL)、连接池(如 Druid),以及 Spring Boot 的父依赖 `spring-...

    Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA

    在现代Java Web开发中,"Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA"是一个常见的架构组合,被广泛应用于构建企业级应用程序。这个组合通常被称为"SSM",其中"M"代表Maven,"S"代表Spring,包括Spring核心...

    SpringMVC+Spring+SpringDataJPA+Hibernate整合登录的效果

    这是整合SpringMVC+Spring+SpringDataJPA+Hibernate简单的实现登录的功能,用的是mysql数据库,这是一个web Project 如果你用的是JavaEE6那么你要注意bean-validator.jar和weld-osgi-bundle.jar与slf4j的jar包冲突。...

    2017 spring data jpa+spring4.2+springmvc+hibernate4.3 maven环境intellij idea增删改查实例

    在本项目中,我们探索的是一个基于2017年技术栈的Java Web应用程序实例,主要涉及Spring Data JPA、Spring 4.2、Spring MVC和Hibernate 4.3。这些技术是Java开发中的核心组件,尤其在企业级应用开发中广泛使用。下面...

    springdatajpa.pdf

    在SpringBoot项目中整合SpringDataJPA,首先要导入必要的Maven依赖。在项目中,需要引入SpringBoot的启动器(Starter)依赖,如`spring-boot-starter-web`用于开发web应用,`spring-boot-starter-data-jpa`用于数据...

    spring data jpa + spring + json demo

    总之,这个项目提供了一个完整的Spring MVC应用示例,其中整合了Spring Data JPA进行数据库操作,并使用JSON进行数据交换,对于学习Spring框架和JPA的初学者来说,是一个很好的实践平台。通过深入研究和运行这个项目...

    Spring2.5整合JPA

    Spring 2.5整合JPA使得开发者能够在享受Spring框架带来的便利的同时,充分利用JPA的ORM能力。这种整合不仅简化了数据库访问,还提高了代码的可维护性和测试性。随着Spring和JPA的不断更新,现在的整合方式可能与...

Global site tag (gtag.js) - Google Analytics