Spring Data JPA初探(开发与配置)

最新推荐文章于 2024-07-24 14:56:22 发布
置顶 最新推荐文章于 2024-07-24 14:56:22 发布
阅读量1.4w 收藏 8
点赞数
分类专栏： J2EE企业级开发 文章标签： jpa spring string user autowired 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haha_mingg/article/details/7498053
版权

1.开发准备
1.1 首先从官方下载例程，官方提拱了好多的例子借我们使用，它的下载地址为：
  https://github.com/ttrelle/spring-data-examples
（直接下载后解压）

1.2 里面的spring-data-example是用maven来管理的，不用多说，maven的优点在于规约优于配置。一开始定义所要用的jar包。
（关于maven这里就不多说了，详细的要去回顾一个maven的教程和官方文档。）

2.项目改造，里面之前的配置是用HSQL这个内嵌数据库的，内嵌数据库比较小，只是做例程demo时候用得着，其实真正在项目中用到的还得是myql,oracle等数据库，因此我这里将HSQL改造成mysql ，不但要改配置文件，还要改它的依赖的jar包。

3.详细介绍这个开源demo例程。
3.1 修改 pom.xml，这个文件直接拿里头的过来就可以了，如果jar包找不到，有可能是jar包版本的问题，只要更新一下它的版本即可。我添加了以下依赖，如下所示：

	<dependency>
			<groupId>commons-collections</groupId>
			<artifactId>commons-collections</artifactId>
			<version>3.2</version>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.18</version>
		</dependency>
	<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-jpa</artifactId>
			<version>1.0.3.RELEASE</version>
		</dependency>

其它的依赖其本没有发生变化。

3.2 在JpaRepoTest-context.xml文件中将内嵌HSQL数据库改成mysql数据库的dataSource，如下所示： 
<!-- 	<jdbc:embedded-database id="dataSource" type="HSQL" /> -->

 <bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="username" value="root" />
        <property name="password" value="123456" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost/vote" />
    </bean>

注意：vote数据库要先存在哦，还有就是数据库的帐号和密码要配置正确。

3.3  User实体，它的代码就跟早期的POJO相同，不过它里面使用了注解。代码如下所示： 
@Entity
@NamedQueries( {
	@NamedQuery( name="User.findByUser5", query = "SELECT u FROM User u where u.fullName = 'User 5'" ),
	@NamedQuery( name="User.classisQuery", query = "SELECT u FROM User u where u.fullName = :fullName" )
})
public class User {

	@Id private String id;
	
	private String fullName;
	
	private Date lastLogin;

	public User() {}
	
	public User(String id, String fullName) {
		this.id = id;
		this.fullName = fullName;
		this.lastLogin = new Date();
	}
	
	
	public String getId() {
		return id;
	}

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

	public String getFullName() {
		return fullName;
	}

	public void setFullName(String fullName) {
		this.fullName = fullName;
	}

	public Date getLastLogin() {
		return lastLogin;
	}

	public void setLastLogin(Date lastLogin) {
		this.lastLogin = lastLogin;
	}
.........................
......................
}

可以看到里面注入了一些查询语句，它就是JPA QUERY，据说比较牛B。很好用，等面会给出官文档。

3.4 Repository 这个类，它继承了 JpaRepository<User, String>,因而有非常牛的方法，我们几乎看不到实现，只要类似申明接口的方法，就可以给其他类使用。（而经典的Repository 就不说了。跟之前的框架内容的实现没两样，我不推荐使用。) 它的代码如下所示： 
public interface UserRepository extends JpaRepository<User, String> {

	List<User> findByFullName(String fullName);

	List<User> findByFullName(String fullName, Sort sort);

	List<User> findByFullName(String fullName, Pageable paging);
	
	List<User> findByUser5();

	List<User> findByOrm();
	
	@Transactional(timeout = 2, propagation = Propagation.REQUIRED)
	@Query("SELECT u FROM User u WHERE u.fullName = 'User 3'")
	List<User> findByGivenQuery();
	
	List<User> findByIdAndFullName(@Param("id") String id, @Param("fullName") String fullname);
	
}

都没有看到实现，其实底层框架已经帮我们实现了。唯一要做的就是继承这个JpaRepository类了，当然还可以继承CurdRepository类。

3.5 它们是如何工作的？
其实它们工作主要是通过配置文件来完成的，配置文件有两个，
persistence.xml： 
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" 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_2_0.xsd">
    <persistence-unit name="pu1">
    
    	<class>domain.User</class>
    	
    	<properties>
    		<property name="openjpa.RuntimeUnenhancedClasses" value="supported" />
    		<property name="openjpa.Log" value="DefaultLevel=WARN, Runtime=INFO, Tool=INFO, SQL=TRACE"/>
    		
    		<property name="openjpa.jdbc.TransactionIsolation" value="read-uncommitted"/>
    		<property name="openjpa.LockManager" value="none"/>
    		
    		<!-- 
    		<property name="" value="" />
    		 -->
    	</properties>
    	
    </persistence-unit>
</persistence>

里面配置了一些openJPA的属性.

JpaRepoTest-context.xml: 
<?xml version="1.0"?>
<beans
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns="http://www.springframework.org/schema/beans"
 	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xmlns:jee="http://www.springframework.org/schema/jee"	
	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
        http://www.springframework.org/schema/jdbc 
        http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
        http://www.springframework.org/schema/data/jpa 
        http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
        http://www.springframework.org/schema/jee 
        http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
        ">

	<!-- JNDI DS Example 
	<jee:jndi-lookup id="ds2" jndi-name="jdbc/monitoring" />
	-->

<!-- 	<jdbc:embedded-database id="dataSource" type="HSQL" /> -->

	<!-- 	
	<jpa:repositories base-package="jparepo" query-lookup-strategy="use-declared-query" />
	-->
	<jpa:repositories base-package="jpa" query-lookup-strategy="create-if-not-found" />



    <bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="username" value="root" />
        <property name="password" value="123456" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost/vote" />
    </bean>
 
 
    <bean id="emf1"
        class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!--
        <property name="persistenceUnitName" value="pu1" />
        -->
        <property name="dataSource" ref="dataSource" />
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.OpenJpaVendorAdapter">
                <property name="generateDdl" value="true" />
            </bean>
        </property>
    </bean>
 
    <context:component-scan base-package="jpa" />
    
    <context:annotation-config />

	<!--  TX Manager --> 
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    	<property name="entityManagerFactory"  ref="emf1" />
    </bean>
    <tx:annotation-driven />
	
</beans>


3.6最后通过测试类来检测之前的配置是否正确，如下所示： 
package jpa;

import java.util.List;

import junit.framework.Assert;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * Tests for Spring Data JPA.
 * 
 * @author tobias.trelle
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class JpaRepoTest {
	
	 @Autowired UserRepository repo;

	 @Autowired ClassicUserRepository classicRepo;
	  
	 @Before public void setUp() {
		 for ( int i = 0; i < 6; i++ ) {
			 repo.save( new User( String.format("user%02d", i), "User " + i ) );
		 }
	 }
	 
	 @Test public void shouldUseClassicRepository() {
		 List<User> users;

		 // when
		 users = classicRepo.findByFullName("User 1");
		 
		 // then
		 assertUserByFullName(users, "User 1");
	 }
	 
	 @Test public void shouldPageUsers() {
		 List<User> users;
		 
		 // when
		 Page<User> page = repo.findAll( new PageRequest(2, 2 ) );
		 users = page.getContent();
	 
		 // then
		 assertUserCount(users, 2);
	 }

	 @Test public void shouldFindByFullnameQuery() {
		 List<User> users;
		 
		 // when
		 users = repo.findByFullName("User 5");
		 
		 // then
		 assertUserByFullName(users, "User 5");
	 }

	 @Test public void shouldFindByFullnameQueryWithSort() {
		 List<User> users;
		 
		 // when
		 users = repo.findByFullName("User 5", new Sort( new Sort.Order(Sort.Direction.DESC,"fullName")));
		 
		 // then
		 assertUserByFullName(users, "User 5");
	 }
	 
	 @Test public void shouldUseExistingNamedQuery() {
		 List<User> users;
		 
		 // when
		 users = repo.findByUser5();
		 
		 // then
		 assertUserByFullName(users, "User 5");
	 }
	 
	 @Test public void shouldUseXmlNamedQuery() {
		 List<User> users;
		 
		 // when
		 users = repo.findByOrm();
		 
		 // then
		 assertUserByFullName(users, "User 2");
	 }	 

	 @Test public void shouldUseSpringDataQuery() {
		 List<User> users;
		 
		 // when
		 users = repo.findByGivenQuery();
		 
		 // then
		 assertUserByFullName(users, "User 3");
	 }	 
	 
	 @Test public void shouldIgnoreNullQueryParameters() {
		 List<User> usersById, usersByFullName;

		 // when
		 usersById = repo.findByIdAndFullName("user01", null);
		 usersByFullName = repo.findByIdAndFullName(null, "User 01");
		 
		 // then
		 assertUserCount(usersById, 0);
		 assertUserCount(usersByFullName, 0);
	 }
	 
	 @Test public void shouldSortByTwoCriteria() {
		 List<User> users;
		 
		 // when
		 users = repo.findAll( new Sort(
				 new Sort.Order(Sort.Direction.ASC, "id"),
				 new Sort.Order(Sort.Direction.DESC, "fullName")
				 )
		 );
		 
		 // then
		 assertUserCount(users, 6);
	 }
	 
	 private static void assertUserByFullName(List<User> users, String fullName)  {
		 assertUserCount(users, 1);
		 Assert.assertEquals( "Mismatch full name" , fullName, users.get(0).getFullName());
	 }

	 private static void assertUserCount(List<User> users, int expected) {
		 Assert.assertNotNull( users );
		 Assert.assertEquals( "Mismatch user count" , expected, users.size());
		 
	 }
	 
}

3.7 结果截图，如下所示：


3.8 参考网址：
Spring JPA DATA:
使用 Spring Data JPA 简化 JPA 开发
http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-jpa/index.html?ca=drs-

Spring Data JPA - Reference Documentation
http://static.springsource.org/spring-data/data-jpa/docs/current/reference/html/



spring tutorial:
http://www.petrikainulainen.net/programming/spring-framework/spring-data-jpa-tutorial-part-one-configuration/


spring 书籍：
http://my.safaribooksonline.com/book/-/9781430241072/pro-spring-3/chapter_10_data_access_in_spri


spring data jpa:
http://www.baeldung.com/2011/12/22/the-persistence-layer-with-spring-data-jpa/

haha_mingg
关注
专栏目录
Spring Data JPA配置
风起于青萍之末
10-23 671
简介自从Sun 推出JPA（Java Persistence API）以来，使用Jpa的越来越多了，再不是之前那种只使用Hibernate，MyBaits等等框架了。JPA的一个核心目的就是要整合ORM技术，实现天下归一。项目搭建本文就以一个简单的图书出版社为例，集成Spring和Hibernate技术，存储使用MySQL数据库，搭建一个Spring Data JPA项目。数据库设计对于Web项目来
Spring Data JPA 实战 - DataSource与JPA属性配置
最新发布
qq_33240556的博客
08-14 608
通过上述步骤，我们已经成功地配置了一个使用Spring Data JPA的Spring Boot应用，包括定义DataSource和JPA属性。这些配置使得Spring Boot能够自动创建数据库表，并为我们提供了数据访问层的基础功能。这对于快速开发基于数据库的应用程序非常有帮助。
Spring Data JPA 简单介绍
nhy520
08-26 359
背景 考虑到公司应用中数据库访问的多样性和复杂性，目前正在开发UDSL（统一数据访问层），开发到一半的时候，偶遇SpringData 工程。发现两者的思路惊人的一致。 于是就花了点时间了解SpringData，可能UDSL II期会基于SpringData做扩展SpringData相关资料 介绍：针对关系型数据库，KV数据库，Document数据库，Graph数...
SpringDataJpa配置
juruo111的博客
03-24 224
配置spring配置文件 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:aop="http://www.springframework.org/schema/a.
初探微服务与Spring Boot
08-09
【初探微服务与Spring Boot】 微服务架构是一种软件开发方法，它将应用程序设计为一组小型、独立的服务，每个服务都专注于一个特定的业务功能，且可以独立部署、扩展和维护。这种架构模式有助于提高软件的可伸缩性...
JPA初探：优雅使用Java持久化API的十大策略
[JPA初探：优雅使用Java持久化API的十大策略](https://s3.amazonaws.com/oodles-blogs/blog-images/2a1b1911-29f2-4ea6-9426-92e02c1e29d4.png) # 1. JPA简介与核心概念 JPA（Java Persistence API）是一个为Java...
基于计算机软件开发的JAVA编程应用初探.zip
10-16
而Spring Data则为与各种数据库交互提供了统一的接口，如JPA和MyBatis。 对于并发编程，Java提供了丰富的线程API，包括Thread类和Runnable接口，以及ExecutorService和Future等高级并发工具。通过合理使用这些工具...
Spring框架开发全面解析
随着版本的升级，指南还涵盖了Spring的持久层支持，这可能包括Spring对JDBC、ORM（Object-Relational Mapping）框架如Hibernate、MyBatis的整合，以及Spring Data JPA等，这些都是在企业级应用中处理数据存储和检索...
pring初探共18页.pdf.zip
10-30
6. **数据访问**：Spring对各种持久化技术的支持，如JDBC、ORM框架（Hibernate、MyBatis），以及Spring Data JPA和Spring Data MongoDB等。 7. **Spring Boot**：现代Spring应用的快速启动框架，介绍其特性，如自动...
持久层方案SpringDataJPA文件及配置
03-10
具有详细的SpringDataJPA配置及文档说明，让你更快的理解SpringDataJPA持久层方案
Spring Data Jpa配置
weixin_30345055的博客
07-25 138
Spring Data JPA提供的接口，也是Spring Data JPA的核心概念： 1：Repository：最顶层的接口，是一个空的接口，目的是为了统一所有Repository的类型，且能让组件扫描的时候自动识别。 2：CrudRepository ：是Repository的子接口，提供CRUD的功能 3：PagingAndSortingRepository：是CrudRepos...
springData Jpa配置文件
qq_42263473的博客
02-28 627
##springData Jpa的配置文件 <?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:jdbc="http://www.springframework.org/schema/jdbc" xml
SpringDataJPA相关配置
只为更懂'你'
06-21 229
pom.xml引入的依赖 <dependencies> <!--单元测试jar--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</s
配置和使用Spring Data JPA
weixin_44308200的博客
10-29 607
目录Spring DataSpring Data 特点Spring Data接口Spring Data与JPA在Spring Boot中使用JPA导入pom.xml编写一个实体类与数据库字段进行映射编写接口继承JpaRepository使用JPA配置文件配置自定义JPA接口JPA一对一查询外键方法配置主表实体类配置附表实体类关联表方法配置主表实体类JPA一对多查询一端实体类配置多端实体类配置 Spring Data Spring Data项目的目的是为了简化构建基于Spring框架应用的数据访问技术，包括非
SpringDataJpa学习记录----02三种配置方式
weixin_74294086的博客
07-24 1994
SpringDataJpa在xml、javaconfig、springboot三种方式的配置方法
Spring环境下配置SpringData JPA
JustinNeil的博客
08-11 203
Spring 环境下配置SpringData JPA前言基本环境搭建创建实体类创建配置文件测试 前言 在 Spring Boot 中，Spring Data JPA 官方封装了太多东西了，导致很多人用的时候不知道底层到底是怎么配置的，本文就和大伙来看看在手工的Spring环境下，Spring Data Jpa要怎么配置，配置完成后，用法和 Spring Boot 中的用法是一致的。 基本环境搭建 ...
spring data jpa常用配置
m0_54003569的博客
12-18 1255
spring data jpa 配置文件
Spring Data JPA入门与Maven配置详解
配置持久化单元是Spring Data JPA的核心步骤之一，它定义了应用程序如何与数据库进行交互。虽然具体代码未在提供的部分给出，但通常会涉及配置JPAEntityManagerFactory，设置数据源和实体管理器，以及映射实体类到...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值