Spring-data-jpa的使用

一，spring-data-jpa的简单介绍

SpringData：Spring 的一个子项目。用于简化数据库访问，支持NoSQL 和关系数据存储。其主要目标是使数据库的访问变得方便快捷。

SpringData的主要模块(子项目)

Spring Data JPA：是springData的子项目，致力于减少数据访问层 (DAO) 的开发量， 开发者唯一要做的就只是声明持久层的接口，并继承Repository(或Repository的子接口即可),其他都交给 Spring Data JPA 来帮你完成！

二，spring-data-jpa的快速入门

创建一个maven java项目

导入的依赖：
spring-data-jpa
Hibernate相关依赖
mysql驱动
c3p0连接池
junit测试

pom.xml文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>cn.xiaogui.example</groupId><artifactId>springdatajpa-example</artifactId><version>0.0.1-SNAPSHOT</version><name>springdatajpa-example</name><description>spring-data-jpa的简单使用</description><!-- 全局属性配置  --><properties><project.source.encoding>utf-8</project.source.encoding><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><!-- 防止控制输出台中文乱码 --><argLine>-Dfile.encoding=UTF-8</argLine> <spring-data-jpa.version>1.10.4.RELEASE</spring-data-jpa.version><hibernate.version>5.0.11.Final</hibernate.version><junit.version>4.12</junit.version><mysql.version>5.1.41</mysql.version><c3p0.version>0.9.1.2</c3p0.version></properties><dependencies><!-- spring-data-jpa相关依赖 (这个依赖自动把一堆spring的东西依赖进来了，所有可以不需要再引入spring的包)--><dependency><groupId>org.springframework.data</groupId><artifactId>spring-data-jpa</artifactId><version>${spring-data-jpa.version}</version></dependency><dependency><!-- 做测试使用 --><groupId>junit</groupId><artifactId>junit</artifactId><version>${junit.version}</version><!-- 这个包只在测试使用 --><scope>test</scope></dependency><!-- hibernate相关依赖 --><dependency><groupId>org.hibernate</groupId><artifactId>hibernate-core</artifactId><version>${hibernate.version}</version></dependency><dependency><groupId>org.hibernate</groupId><artifactId>hibernate-entitymanager</artifactId><version>${hibernate.version}</version></dependency><!-- mysql驱动 --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>${mysql.version}</version></dependency><!--c3p0连接池  --><dependency><groupId>c3p0</groupId><artifactId>c3p0</artifactId><version>${c3p0.version}</version></dependency></dependencies><build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.5.1</version><configuration><!--源码1.7  --><source>1.7</source><!-- 打包1.7 --><target>1.7</target><encoding>UTF-8</encoding></configuration></plugin></plugins></build>
</project>

由于spring-data-jpa依赖了一堆spring相关的依赖，会自动导入spring相关的一些依赖，所以在pom.xml中不需要引入spring相关的依赖

Spring整合springDataJpa，applicationContext.xml配置

1.首先新建db.properties文件，配置数据库相关的信息

jdbcUrl=jdbc:mysql://localhost:3306/springdatajpa?characterEncoding=utf8
driverClass=com.mysql.jdbc.Driver
user=root
password=root
initialPoolSize=10
maxPoolSize=30

2.创建applicationContext.xml文件，配置内容如下：

2.2配置包扫描，扫描@Service，@Contorller @Repository
2.3加载springdb.properties文件
2.4配置数据源dataSource

2.5配置JPA的EntityManagerFactory，这里面配置主要包括：
(1)需要配置数据源dataSource；
(2)配置包扫描packagesToScan，扫描实体类，找到实体类上有关JPA的注解；
(3)配置持久化提供者persistenceProvider；
(4)配置jpa网络适配器jpaVendorAdapter，这个里面主要是关于是否自动建表generateDdl，使用的数据库database，数据库方言databasePlatform，在控制台上显示sql语句showSql等配置

2.6配置事务管理器 transactionManager
2.7配置支持注解的事务
2.8配置SpringData这里包扫描是扫描dao层，扫描那些定义的接口

<?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:tx="http://www.springframework.org/schema/tx"xmlns:jpa="http://www.springframework.org/schema/data/jpa"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsdhttp://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsdhttp://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd"><!-- 配置自动扫描的包,扫描@service @controller @Repository注解--><context:component-scan base-package="cn.xiaogui"/><!-- 1. 配置数据源 --><context:property-placeholder location="classpath:db.properties"/><bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"><property name="jdbcUrl" value="${jdbcUrl}"/><property name="driverClass" value="${driverClass}"/><property name="user" value="${user}"/><property name="password" value="${password}"/><property name="initialPoolSize" value="${initialPoolSize}"/><property name="maxPoolSize" value="${maxPoolSize}"/></bean><!-- 2. 配置 JPA 的 EntityManagerFactory --><bean id="entityManagerFactory"   class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"><!-- 配置数据源 --> <property name="dataSource" ref="dataSource"/><!-- 配置包扫描，扫描实体 --><property name="packagesToScan" value="cn.xiaogui.entity"/><!-- 配置持久化提供者 --><property name="persistenceProvider"><bean class="org.hibernate.ejb.HibernatePersistence" /></property><!-- 配置jpa网络适配器 --><property name="jpaVendorAdapter"><bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"><!-- 是否自动建表 --><property name="generateDdl" value="true" /><!-- 使用的数据库 --><property name="database" value="MYSQL" /><!--数据库方言  --><property name="databasePlatform" value="org.hibernate.dialect.MySQL5InnoDBDialect" /><!-- 在控制台打印sql语句 --><property name="showSql" value="true" /></bean></property><!--配置jpa方言  --><property name="jpaDialect"><bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" /></property></bean><!-- 3. 配置事务管理器 --><bean id="transactionManager"class="org.springframework.orm.jpa.JpaTransactionManager"><property name="entityManagerFactory" ref="entityManagerFactory"/>  </bean><!-- 4. 配置支持注解的事务 --><tx:annotation-driven transaction-manager="transactionManager"/><!-- 5. 配置 SpringData,需要加入  jpa 的命名空间 --><!-- base-package: 扫描 Repository Bean 所在的 package --><jpa:repositories base-package="cn.xiaogui.dao" entity-manager-factory-ref="entityManagerFactory" />
</beans>

3.测试整合

3.1先测试spring容器是否整合成功
在cn.xiaogui.test包下，创建ConfigTest测试类，编写单元测试代码，主要内容：
通过静态代码块创建ClassPathXmlApplicationContext对象，加载applicationContext.xml文件，启动spring容器。通过Spring容器获取dataSource对象，如果成功获取，并且说明整合成功了。

测试代码

package cn.xiaogui.test;import java.sql.SQLException;import javax.sql.DataSource;import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;import cn.xiaogui.dao.UserRepository;
/*** * @author xiaogui* *  Spring整合测试**/
public class ConfigTest {private static ApplicationContext applicationContext;static{//使用静态代码块,让程序来加载spring配置文件applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");}/** 测试spring容器是否实例化了数据源 。如果实例化了，说明Spring容器整合没问题 */@Testpublic void testDataSouce() throws SQLException {DataSource dataSouce = (DataSource) applicationContext.getBean("dataSource");System.out.println("数据源："+ dataSouce);System.out.println("连接："+ dataSouce.getConnection());}}

输出结果：

说明spring整合成功

3.2测试spring整合JPA

整合JPA是否成功主要是看entityManagerFactory这个对象是否起作用，这个会起作用就会去扫描cn.xiaogui.entity包下的实体类，测试方法：

  (1)数据库提前创建出来，使用到的数据库springdatajpa我已经创建(2) 给实体类加上注解，然后开启Hibernate自动建表功能，启动Spring容器；

如果数据库自动建表成功，那就整合成功

实体类相对简单，只贴入关键部分

User类

@Entity   //表明这个一个实体
@Table(name="t_user")  //数据库中实体对应的表名
public class User {@Id    //id主键标识符@GeneratedValue(strategy=GenerationType.IDENTITY)  //主键生成策略，自动增长private Integer id;@Column    //对应数据表中的字段名，不写默认与实体类的属性名一致private String username;@Columnprivate String city;@OneToMany(mappedBy="users",fetch=FetchType.EAGER)  //一对多，mappedBy：表示放弃主键维护，交给多的一方管理,一的一方fetch默认为FetchType.LAZY懒加载private List<Car> cars = new ArrayList<Car>();

Car类

@Entity   //表明这个一个实体
@Table(name="t_car")  //数据库中实体对应的表名
public class Car {@Id  //id主键标识符@GeneratedValue(strategy=GenerationType.IDENTITY)//主键生成策略，自动增长@Column //对应数据表中的字段名，不写默认与实体类的属性名一致private Integer id;@Columnprivate String carName;@Columnprivate Double price;@ManyToOne //多对一@JoinColumn(name="user_id") //外键在数据表中的字段private User users;

再次执行ConfigTest类中的测试代码，如果数据库中创建了User和Car两张数据表，表明整合JPA成功！

4.在dao层声明接口

在cn.xiaogui.dao包下创建UserRepository接口，并继承Repository接口或者Repository的子接口，由于Repository是一个空接口，博主选择继承Repository的子接口JpaRepository，在这个接口中提供了一些常规CRUD的操作。而JpaRepository的实现类SimpleJpaRepository对这些CRUD的操作进行了具体的实现，所以我们编写的UserRepository接口可以直接使用这些方法，而不需要进行具体的实现。

JpaRepository定义的规范：

SimpleJpaRepository对JpaRepository的实现

UserRepository接口代码

package cn.xiaogui.dao;import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;import cn.xiaogui.entity.User;public interface UserRepository extends JpaRepository<User, Integer> {}

在cn.xiaogui.test包下创建UserRepositoryTest测试类，通过这个类，我们进行springData的学习。

package cn.xiaogui.test;import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;import cn.xiaogui.dao.UserRepository;
import cn.xiaogui.entity.User;
/*** * @author xiaogui* *  Spring整合测试**/
public class UserRepositoryTest {private static ApplicationContext applicationContext;private static UserRepository userRepository;static{applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");  //使用静态代码块,让程序来加载spring配置文件userRepository = applicationContext.getBean(UserRepository.class);   //通过反射获取到UserRepository接口对象}/*** 向t_user数据表中添加一条数据,并查询这条记录*/@Testpublic void insertUser() {User user = new User();user.setUsername("张三");user.setCity("北京");//向数据表中保存一条数据userRepository.save(user);//通过用户名，查询用户的信息user = userRepository.findOne(1);System.out.println(user);}}

执行结果如下图所示，我们dao层接口UserReository接口只继承了JpaRepository接口，就可以完成数据添加到数据库，从数据库中查询数据操作，这就是SpringData的魅力所在，大大简化了我们持久层的开发

三，spring-data-jpa原理分析

springData 出现的目的：为了简化，统一持久层各种实现技术API，所以，springData 提供了一套标准的API 和不同持久层整合技术的实现。

spring-data-commons ：一套标准的API

spring-data-jpa：基于整合jpa实现，还对spring-data-commons的一套标准API进行了扩展

画图表示上述接口间的继承关系

对上述接口中的API进行讲解，其中Repository是空接口，不作讲解

CrudRepository接口API

PagingAndSortingRepository接口API

JpaRepository接口API

JpaSpecificationExecutor接口API(当需要进行带条件分页查询，多条件查询实体时，Dao层继承这个接口)

由于SimpleJpaRepository这个类对上述的这些API进行了具体的实现，所以我们dao层接口只要继承这些接口即可直接使用这些API。

画图简单分析调用方法的执行流程

四、spring data Query使用实现条件查询

第一种方式：基于方法命名规则，自动生成JPQL查询语句

上图是对方法命名规则的说明

在cn.xiaogui.test包下创建UserRepositoryCriteriaQuery类，完成条件查询。

案例说明

基于一列的等值查询 findBy列名例如：findByUsername(String name)

package cn.xiaogui.test;import java.util.List;import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;import cn.xiaogui.dao.UserRepository;
import cn.xiaogui.entity.User;public class UserRepositoryCriteriaQuery {private static ApplicationContext applicationContext;private static UserRepository userRepository; //UserRepository接口的代理对象static{//读取spring配置文件，加载spring容器applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");userRepository = applicationContext.getBean(UserRepository.class);}/*** 基于一列的等值查询*/@Testpublic void findByUsername() {List<User> list = userRepository.findByUsername("张三");System.out.println(list);}
}

dao层UserRepository接口只需要创建这个方法，不需要进行具体实现

package cn.xiaogui.dao;import java.util.List;import org.springframework.data.jpa.repository.JpaRepository;import cn.xiaogui.entity.User;public interface UserRepository extends JpaRepository<User, Integer> {/*** 基于一列的等值查询，不需要进行实现* @param string* @return*/List<User> findByUsername(String string);}

控制台查询结果如下：

基于一列的模糊查询 findBy列名Like 例如：findByUsernameLike(String name)

由于在条件查询测试类UserRepositoryCriteriaQuery中，加载spring的配置文件，创建UserRepository接口的代理对象代码相同，以下的代码不再重复，只粘贴关键部分

UserRepositoryCriteriaQuery代码片段

 @Testpublic void findByUsernameLike() {List<User> list = userRepository.findByUsernameLike("%张%");  //注意：传入参数  %参数%System.out.println(list);}

UserRepository接口代码片段，同样这个方法也不需要具体实现

/*** 基于一列的模糊查询* @param string* @return*/List<User> findByUsernameLike(String string);

控制台输出结果

方法命名规则过多，自己可以尝试，不做过多赘述

第二种方式：不按命名规则我们自定义的查询方法，可以在dao层接口的执行方法上配置@Query注解，绑定JPQL语句或SQL语句

在UserRepository接口，自定义一个查询方法，由于没有按照方法命名规则，直接报错

可以在方法上配置@Query注解，表明这是一个查询方法，value绑定的是JPQL语句或SQL语句，这个有nativeQuery参数决定。默认为false，表示绑定的是JPQL语句，设置为true，绑定的是SQL语句

/*** 自定义方法，基于两列的等值查询* @param city* @param username* @return*/@Query(value="from User where username = ? and city = ?",nativeQuery=false)User queryUsernameAndCity(String city,String username);

UserRepositoryCriteriaQuery代码片段

/*** 自定义的查询方法，基于两列的等值查询*/@Testpublic void queryUsernameAndCity() {User user = userRepository.queryUsernameAndCity("北京", "张三");System.out.println(user);}

控制台输出结果：

数据表中存在这条记录，却没有查询出来。检查UserRepository接口中定义的这个查询方法，原来传入的参数与绑定的JPQL语句中的占位符没有对应上。

解决方法：
(1) 在占位符后面添加标注，与传入的参数进行对应

 /*** 自定义方法，基于两列的等值查询* @param city* @param username* @return*/@Query(value="from User where username = ?2 and city = ?1",nativeQuery=false)User queryUsernameAndCity(String city,String username);

(2)在该方法传入的参数前面配置@param注解，@param中的参数名称要和value中的：后面的名字对应

 /*** 自定义方法，基于两列的等值查询* @param city* @param username* @return*/@Query(value="from User where username = :userName and city = :city",nativeQuery=false)  //@param中的参数名称要和value中的 ：后面的名字对应User queryUsernameAndCity(@Param("city") String city,@Param("userName") String username);

使用第二种解决方案，再次执行UserRepositoryCriteriaQuery中这个方法，查询到数据

第三种方式：不按命名规则我们自定义的查询方法，可以在dao层接口的执行方法上配置@Query注解，将JPQL语句或SQL语句绑定到实体类上

UserRepository接口代码片段

/*** 自定义方法，基于两列的等值查询* @param city* @param username* @return*/@QueryUser queryUsernameAndCity2(@Param("city")String city, @Param("username")String username);

User实体类代码片段

@NamedQueries({@NamedQuery(name="User.queryUsernameAndCity2", query = "from User where username = :username and city = :city")})
public class User {@Id@GeneratedValue(strategy=GenerationType.IDENTITY)private Integer id;@Columnprivate String username;@Columnprivate String city;

UserRepositoryCriteriaQuery条件查询测试类调用方法，可以查询到结果数据

上述三种条件查询方式，推荐使用第一种方法命名规则查询，不建议使用第三种，过于繁琐

五，带条件的修改和删除操作

使用@Query注解，搭配@Modifying注解完成带条件的修改，删除操作

案例说明：根据id修改用户名

在UserRepository接口代码片段

 /*** 自定义修改操作，根据id修改用户名* UPDATE 或 DELETE 操作需要使用事务, 此时需要定义 Service 层. 在 Service 层的方法上添加事务操作. * 默认情况下, SpringData 的每个方法上有事务, 但都是一个只读事务. 他们不能完成修改操作!*/@Query(value="update User set username= ?2 where id = ?1") @Modifying //表示更新操作(修改或删除)void updateUsername(Integer id,String username);

由于修改和删除都是更新操作，只读事务是不能实现的，因此新建UserService类，在Service方法中添加事务注解

UserService代码片段

package cn.xiaogui.service;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;import cn.xiaogui.dao.UserRepository;@Service
public class UserService {@Autowiredprivate UserRepository userRepository; //注入dao层接口对象/*** 根据id修改用户名*/public void updateUsername() {userRepository.updateUsername(1, "小鬼");}
}

在UserRepositoryCriteriaUpdate测试类中调用UserService中的这个方法测试

package cn.xiaogui.test;import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;import cn.xiaogui.service.UserService;public class UserRepositoryCriteriaUpdate {private static ApplicationContext applicationContext;private static UserService userService;static{//读取spring配置文件，加载spring容器applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");userService = applicationContext.getBean(UserService.class);}/*** 根据id修改用户名*/@Testpublic void updateUsername() {userService.updateUsername();}}

控制台输出

根据控制台报出的错误，我们需要在UserService中设置事物

/*** 根据id修改用户名*/@Transactionalpublic void updateUsername() {userRepository.updateUsername(1, "小鬼");}

再次在UserRepositoryCriteriaUpdate测试类中调用UserService中的这个方法测试，数据修改成功

查询数据表

删除操作不再赘述，大家可以自己进行尝试！

六，带条件的分页查询

首先在数据表t_user中添加数据

实现带条件的分页查询，主要使用到前面提到的JpaSpecificationExecutor接口中定义的API，这个接口的主要作用就是进行带条件的查询

进行带条件的分页查询，使用的API是这个接口中的
Page findAll(Specification spec, Pageable pageable);

参数：
spec：构造Specification对象条件查询对象(类似hibernate的QBC查询)，由于这个参数是一个接口对象，通过匿名对象创建

pageable：封装了请求分页的信息: page，size，sort三个参数，其中page索引从0开始，表示第一页

PageRequest类实现了Pageable接口

由于JpaSpecificationExecutor接口不属于Repository体系，所以我们要使用带条件的分页查询，dao层接口需要同时继承JpaRepository，JpaSpecificationExecutor这两个接口

在UserRepositoryCriteriaQuery测试类中编写带条件的分页查询代码

   /*** 实现带条件的分页查询*/@Testpublic void  findPageData() {// 目标：查询id<5 并且city为北京的 的第1页的数据，每页显示为5条记录//创建pageable对象  Pageable pageable = new PageRequest(1-1, 5);  //0 表示从第一页开始  5 表示每页显示多少条数据//根据查询条件，构造Specification对象条件查询对象(类似hibernate的QBC查询)Specification<User> spec = new Specification<User>() {/*** 构造条件查询方法,如果返回值为null，表示无条件查询,查询所有* * root参数：代表查询的实体类,用来 获取条件表达式  username = ？ city =？ 等* query参数：可以从中可到 Root 对象, 即告知 JPA Criteria 查询要查询哪一个实体类. 还可以* 来添加查询条件, 还可以结合 EntityManager 对象得到最终查询的 TypedQuery 对象 * cb参数：构造Predicate对象 条件对象,构造复杂查询效果* @return: Predicate 类型, 代表一个查询条件. */@Overridepublic Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {//在开发过程中，一般使用root和cb这两个参数//定义一个list集合,用于存放多个条件List<Predicate> predicates = new ArrayList<Predicate>();//查询id小于5的数据Predicate p1 = cb.lt(root.get("id").as(Integer.class), 5);predicates.add(p1);Predicate p2 = cb.equal(root.get("city"), "北京");predicates.add(p2);//当predicates中没有元素时，表示无条件查询return cb.and(predicates.toArray(new Predicate[predicates.size()]));}};//得到分页对象Page<User> page = userRepository.findAll(spec , pageable);//输出查询到的结果System.out.println(page.getContent());}

在控制台输出结果

小结：
主要对springdatajpa的常用操作进行了简单的说明介绍。

1.如何使用springdata自带的API及springdatajpa自身扩展的API

2.根据方法命名规则进行条件查询，以及通过@query注解，进行自定义方法进行条件查询

3.使用@query ，@modifying注解完成修改或删除的更新操作

4.最后使用JpaSpecificationExecutor接口中的Page findAll(Specification spec, Pageable pageable)方法，完成带条件的分页查询

分享示例项目在码云上的地址：https://gitee.com/xiaoguixiaogege/springdatajpa

Spring-data-jpa的使用相关推荐

Spring Boot整合Spring Data JPA操作数据
一. Sping Data JPA 简介 Spring Data JPA 是 Spring 基于 ORM 框架.JPA 规范的基础上封装的一套 JPA 应用框架,底层使用了 Hibernate 的 J ...
Spring Data JPA 五分钟快速入门和实践
Spring Data JPA(类似于Java Web 中的 DAO) 操作声明持久层的接口(Repository) 三个核心接口: CrudRepository PagingAndSortingRe ...
Spring Data JPA(官方文档翻译)
关于本书介绍关于这本指南第一章前言第二章新增及注意点第三章项目依赖第四章使用Spring Data Repositories 4.1 核心概念 4.2 查询方法 4.3 定义rep ...
Hibernate、JPA、Spring Data JPA，傻傻分不清
国庆假期接近尾声,明天最后一天了,要开始收收心啦- 今天讲讲一个初学者(或许一些老手)可能没去搞懂的几个概念:Hibernate.JPA.Spring Data JPA 之间的关联. 嘿嘿,前段时间有 ...
Spring Data JPA 与 MyBatis 对比，你喜欢用哪个？
来源:jianshu.com/p/3927c2b6acc0 概述 Spring Data JPA是Spring Data的子模块.使用Spring Data,使得基于"repositorie ...
Spring Boot 、Spring Data JPA、Hibernate集成
###什么是JPA JPA是用于管理Java EE 和Java SE环境中的持久化,以及对象/关系映射的JAVA API 最新规范为"JSR 338:Java Persistence 2.1 ...
Spring Data JPA例子[基于Spring Boot、Mysql]
关于Spring Data Spring社区的一个顶级工程,主要用于简化数据(关系型&非关系型)访问,如果我们使用Spring Data来开发程序的话,那么可以省去很多低级别的数据访问操作,如 ...
springdatajpa命名规则_简单了解下spring data jpa
公司准备搭建一个通用框架,以后项目就用统一一套框架了以前只是听过jpa,但是没有实际用过今天就来学习下一些简单的知识什么是JPA 全称Java Persistence API,可以通过注解或者X ...
Spring Data JPA
1. 概述 Spring JPA通过为用户统一创建和销毁EntityManager,进行事务管理,简化JPA的配置等使用户的开发更加简便. Spring Data JPA是在Spring JPA ...
spring data jpa从入门到精通_Spring Data JPA的简单入门
前言 spring data JPA是spring团队打造的sping生态全家桶的一部分,本身内核使用的是hibernate核心源码,用来作为了解java持久层框架基本构成的样本是再好不过的选择.最近 ...

Spring-data-jpa的使用

Spring-data-jpa的使用相关推荐

最新文章

热门文章