第三章 Spring Data JPA
2017-08-06 00:00
429 查看
本章是《 Spring Boot 快速入门 》系列教程的第三章,若要查看本系列的全部章节,请点击 这里 。
源码下载
软件版本
JPA简介
在项目中配置JPA
编写实体类
编写 Repository 接口
使用原生SQL查询
总结说明
https://git.oschina.net/terran4j/springboot/tree/master/springboot-jpa
Java: 1.8
Maven: 3.3.9
MYSQL: 5.5
程序在以上版本均调试过,可以正常运行,其它版本仅作参考。
JPA技术可以极大的降低了对数据库编程的复杂性,一些简单的增删改查的操作,代码只需要操作对象就可以了,JPA自动的帮你映射成数据库的SQL操作。
不过 JPA 只是标准标准,而 Spring Boot 提供了它的技术实现: Spring Data JPA。不过 Spring Data JPA 也不是重复造轮子,它是基于一个非常著名的ORM框架——Hibernate——之上封装实现的。
Spring Data JPA 极大简化了数据库访问层代码,只要3步,就能搞定一切:
在pom.xml中配置
编写 Entity 类,依照 JPA 规范,定义实体。
编写 Repository 接口,依靠 Spring Data 规范,定义数据访问接口(注意,只要接口,不需要任何实现)
另外,如果有复杂的SQL查询,Spring Data JPA 也提供了编写原生 SQL 实现的方式。
注意新增的两个依赖,一个是
然后,我们要在
以
以
create:
每次程序启动时,都会删除上一次的生成的表,然后根据你的实体类再重新来生成新表,哪怕两次没有任何改变也要这样执行。
这种策略适合于执行自动化测试的环境下使用,其它环境请慎用。
create-drop :
每次程序启动时,根据实体类生成表,但是程序正常退出时,表就被删除了。
update:
最常用的属性,第一次程序启动时,根据实体类会自动建立起表的结构(前提是先建立好数据库),以后程序启动时会根据实体类自动更新表结构,即使表结构改变了,但表中的记录仍然存在,不会删除以前的记录。要注意的是当部署到服务器后,表结构是不会被马上建立起来的,是要等 第一次访问JPA时后才会建立。
validate :
每次程序启动时,验证创建数据库表结构,只会和数据库中的表进行比较,不会创建新表,但是会插入新值。
因此,建议大多数场景下用 update 就可以了,线上环境(或需要慎重的环境)中用 validate 会更保险一些,没有特殊情况下不建议用 create 及 create-drop 模式。
配置完成后,我们运行下 main 程序(代码如下):
结果控制台输入里多了一些东西:
如果控制台输出中没有报错,并且有这之类的输出,表示配置成功了。
下面是一个实体类的代码:
首先,我们看 User 类上两个注解 @Entity 和 @Table :
@Entity(name = "t_user") 注解 加在 User 上,表示它是一个实体类, 表名是 t_user 。
@Table 里面定义了这个表的索引,一个 @Index 注解定义了一个索引, name 属性表示数据库表中索引的名称, columnList 表示对应的 java 属性名称, unique = true 表示此索引是唯一索引。
比如上面的
columnList 中可以放多个java属性,中间用逗号隔开,表示联合索引,如:
注意: java 属性名都是驼峰命名法(如 loginName),而数据库表字段都是下划线命名法(如 login_name),JPA会自动根据java属性名的驼峰命名法映射成数据库表字段的下划线命名法,如 loginName 属性映射到数据库就是 login_name 字段。
这个 User 实体类写好后,我们再运行下之前的 main 程序,然后惊奇的发现:数据库里自动建了一个名为 "t_user"的表:
![](http://upload-images.jianshu.io/upload_images/4489584-f7cfd78b88901b01.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
表示JPA在启动时根据实体类,自动在数据库中创建了对应的表了。
注意: 实体类 User 一定要放在 HelloJPAApp 类所在包中或子包中,不然
HelloJPAApp 启动时 Spring Boot 可能扫描不到。
这样就写完了基本的增删改查的代码? 的确是这样,因为 JpaRepository 接口已经定义了很多方法,JpaRepository 的父类也定义了很多方法,如:
![](http://upload-images.jianshu.io/upload_images/4489584-239776761b84e7eb.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
而 Spring Boot JPA又帮你实现了这些方法,你只需要在继承 JpaRepository 时指定了实体类的类对象和 ID 属性的类对象就可以了,如
并且, Spring Boot JPA 扫描到 UserRepository 是 Repository 的子类后,会以动态代理的方式对 UserRepository 进行实现,并将实现的对象作为 Bean 注入到 Spring 容器中,而我们只需要像使用普通的 Spring Bean 一样,用 @Autowired 引入即可使用。
下面,我们编写一个 Controller 类来调用 UserRepository ,如下所示:
相关的 HelloService 的代码为:
代码中,
为了测试效果,我们先执行以下SQL在数据库中制造点数据:
然后启动程序,在浏览器中用以下URL访问:
![](http://upload-images.jianshu.io/upload_images/4489584-fdafab4be7c822cd.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
可以看到,
Spring Boot JAP 底层是 Hibernate 实现的, Hibernate 提供了 hql 的类SQL语法来编写复杂查询,不过我个人不建议用 HQL,因为毕竟 HQL 与SQL还是有较大不同的,需要学习成本(但这个成本其实是没必要投入的),另外就是一些场景下需要用数据库的特定优化机制时,HQL 实现不了。
所以,我的建议是使用原生 SQL 的方式实现,而 JPA 是提供了这个能力的,下面我介绍一种用在 orm.xml 中写原生 SQL的方法。
假如需求是这样的,我们要查询某一年龄段的 User(如 10岁 ~ 20岁的),SQL大概要这样写:
Spring Boot JAP 约定是把 SQL 写在类路径的 META-INF/orm.xml 文件中(如果 META-INF 文件夹没有就创建一个),文件路径如下:
![](http://upload-images.jianshu.io/upload_images/4489584-8374ff93115a003e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
orm.xml 文件的内容如下所示:
然后我们可以在 UserRepository 中添加一个
这个
最后,我们写一个 Controller 调用这个方法试,如下代码所示:
然后访问 URL:
![](http://upload-images.jianshu.io/upload_images/4489584-4d31bc994cdacf6a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
我们看到
这也是 JPA 底层实际执行的 SQL,也就是把我们写的 SQL 中 :minAge 和 :maxAge 两个变量换成“绑定变量”的方式。
点击 这里 可以查看本系列的全部章节。
(本系列的目标是帮助有 Java 开发经验的程序员们快速掌握使用 Spring Boot 开发的基本技巧,感受到 Spring Boot 的极简开发风格及超爽编程体验。)
另外,我们有一个名为 SpringBoot及微服务 的微信公众号,感兴趣的同学请扫描下面的二维码关注下吧,关注后就可以收到我们定期分享的技术干货哦!
目录
简介源码下载
软件版本
JPA简介
在项目中配置JPA
编写实体类
编写 Repository 接口
使用原生SQL查询
总结说明
简介
在上一章《 Spring Boot MVC 》中,我们了解了使用 Spring Boot MVC 来开发 Http Restful API的相关技术,但只处理HTTP请求是不够的,现在的应用程序大多使用了关系型数据库,因此本章我们会带着大家继续 Spring Boot 体验之旅,这次我们将采用 JPA 技术来访问数据库,给 Hello Spring Boot 程序添加带数据库访问演示代码。源码下载
本章的示例代码放在“码云”上,大家可以免费下载或浏览:https://git.oschina.net/terran4j/springboot/tree/master/springboot-jpa
软件版本
相关软件使用的版本:Java: 1.8
Maven: 3.3.9
MYSQL: 5.5
程序在以上版本均调试过,可以正常运行,其它版本仅作参考。
JPA简介
JPA是Java Persistence API的简称,中文名Java持久层API,是JDK 5.0注解或XML描述对象-关系表的映射关系,并将运行期的实体“对象持久化”到数据库中。JPA技术可以极大的降低了对数据库编程的复杂性,一些简单的增删改查的操作,代码只需要操作对象就可以了,JPA自动的帮你映射成数据库的SQL操作。
不过 JPA 只是标准标准,而 Spring Boot 提供了它的技术实现: Spring Data JPA。不过 Spring Data JPA 也不是重复造轮子,它是基于一个非常著名的ORM框架——Hibernate——之上封装实现的。
Spring Data JPA 极大简化了数据库访问层代码,只要3步,就能搞定一切:
在pom.xml中配置
spring-boot-starter-data-jpa,及在 application配置文件中配置数据库连接。
编写 Entity 类,依照 JPA 规范,定义实体。
编写 Repository 接口,依靠 Spring Data 规范,定义数据访问接口(注意,只要接口,不需要任何实现)
另外,如果有复杂的SQL查询,Spring Data JPA 也提供了编写原生 SQL 实现的方式。
在项目中配置JPA
首先,我们要在 pom.xml 文件中添加spring-boot-starter-data-jpa的依赖,代码如下:
<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>terran4j</groupId> <artifactId>springboot-jpa</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>springboot-jpa</name> <url>https://git.oschina.net/terran4j/springboot/tree/master/springboot-jpa</url> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.2.RELEASE</version> </parent> <properties> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- JPA --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> </dependencies> </project>
注意新增的两个依赖,一个是
spring-boot-starter-data-jpa,它集成了JPA相关的 jar 包;另一个是
mysql-connector-java, 因为本示例中我们要连MYSQL的数据库,所以 mysql jdbc 驱动(java) 是必不可少的。
然后,我们要在
application.properties配置文件中配置数据库连接及JPA配置,如下所示:
spring.datasource.driverClassName = com.mysql.jdbc.Driver spring.datasource.url = jdbc:mysql://127.0.0.1:3306/test spring.datasource.username = root spring.datasource.password = spring.jpa.hibernate.ddl-auto = update spring.jpa.show-sql = true
以
spring.datasource开头的是数据库连接的配置,请注意一定要保持对应的数据库是存在的,并且用户名密码都没错,不然待会程序运行时无法启动。
以
spring.jpa开发的是 JPA 的配置,
spring.jpa.hibernate.ddl-auto表示每次程序启动时对数据库表的处理策略,有以下可选值:
create:
每次程序启动时,都会删除上一次的生成的表,然后根据你的实体类再重新来生成新表,哪怕两次没有任何改变也要这样执行。
这种策略适合于执行自动化测试的环境下使用,其它环境请慎用。
create-drop :
每次程序启动时,根据实体类生成表,但是程序正常退出时,表就被删除了。
update:
最常用的属性,第一次程序启动时,根据实体类会自动建立起表的结构(前提是先建立好数据库),以后程序启动时会根据实体类自动更新表结构,即使表结构改变了,但表中的记录仍然存在,不会删除以前的记录。要注意的是当部署到服务器后,表结构是不会被马上建立起来的,是要等 第一次访问JPA时后才会建立。
validate :
每次程序启动时,验证创建数据库表结构,只会和数据库中的表进行比较,不会创建新表,但是会插入新值。
因此,建议大多数场景下用 update 就可以了,线上环境(或需要慎重的环境)中用 validate 会更保险一些,没有特殊情况下不建议用 create 及 create-drop 模式。
配置完成后,我们运行下 main 程序(代码如下):
@SpringBootApplication public class HelloJPAApp { public static void main(String[] args) { SpringApplication.run(HelloJPAApp.class, args); } }
结果控制台输入里多了一些东西:
...... 2017-08-04 15:51:27.017 INFO 20248 --- [ main] org.hibernate.Version : HHH000412: Hibernate Core {5.0.12.Final} 2017-08-04 15:51:27.018 INFO 20248 --- [ main] org.hibernate.cfg.Environment : HHH000206: hibernate.properties not found 2017-08-04 15:51:27.020 INFO 20248 --- [ main] org.hibernate.cfg.Environment : HHH000021: Bytecode provider name : javassist 2017-08-04 15:51:27.086 INFO 20248 --- [ main] o.hibernate.annotations.common.Version : HCANN000001: Hibernate Commons Annotations {5.0.1.Final} 2017-08-04 15:51:27.666 INFO 20248 --- [ main] org.hibernate.dialect.Dialect : HHH000400: Using dialect: org.hibernate.dialect.MySQL5Dialect 2017-08-04 15:51:28.230 INFO 20248 --- [ main] org.hibernate.tool.hbm2ddl.SchemaUpdate : HHH000228: Running hbm2ddl schema update 2017-08-04 15:51:28.424 INFO 20248 --- [ main] j.LocalContainerEntityManagerFactoryBean : Initialized JPA EntityManagerFactory for persistence unit 'default' ......
如果控制台输出中没有报错,并且有这之类的输出,表示配置成功了。
编写实体类
要操作数据库数据,首先得建表。然而 JPA 使用起来非常简单,简单得你只需要在Java的实体类上加上一些注解,就可以自动映射成数据库表。下面是一个实体类的代码:
package com.terran4j.springboot.jpa; import java.util.Date; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.EnumType; import javax.persistence.Enumerated; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.Index; import javax.persistence.Table; import javax.persistence.Temporal; import javax.persistence.TemporalType; @Entity(name = "t_user") // 定义数据库表名称。 @Table(indexes = { // 定义数据库索引。 // 唯一索引。 @Index(name = "ux_user_login_name", columnList = "loginName", unique = true), // // 非唯一索引。 @Index(name = "idx_user_age", columnList = "age"), // }) public class User { /** * id, 自增主键。 */ @Id @GeneratedValue @Column(length = 20) private Long id; /** * 用户的登录名。 */ @Column(length = 100, nullable = false) private String loginName; /** * 用户的年龄。 */ @Column(length = 3) private Integer age; /** * 用户的状态。 */ @Column(length = 16, nullable = false) @Enumerated(EnumType.STRING) private UserStatus status = UserStatus.enable; /** * 用户的注册时间。 */ @Temporal(TemporalType.TIMESTAMP) @Column(nullable = false) private Date registTime; public final Long getId() { return id; } public final void setId(Long id) { this.id = id; } public final String getLoginName() { return loginName; } public final void setLoginName(String loginName) { this.loginName = loginName; } public final Integer getAge() { return age; } public final void setAge(Integer age) { this.age = age; } public final UserStatus getStatus() { return status; } public final void setStatus(UserStatus status) { this.status = status; } public final Date getRegistTime() { return registTime; } public final void setRegistTime(Date registTime) { this.registTime = registTime; } }
首先,我们看 User 类上两个注解 @Entity 和 @Table :
@Entity(name = "t_user") 注解 加在 User 上,表示它是一个实体类, 表名是 t_user 。
@Table(indexes = { // 定义数据库索引。 // 唯一索引。 @Index(name = "ux_user_login_name", columnList = "loginName", unique = true), // // 非唯一索引。 @Index(name = "idx_user_age", columnList = "age"), // })
@Table 里面定义了这个表的索引,一个 @Index 注解定义了一个索引, name 属性表示数据库表中索引的名称, columnList 表示对应的 java 属性名称, unique = true 表示此索引是唯一索引。
比如上面的
@Index(name = "ux_user_login_name", columnList = "loginName", unique = true)表示对 loginName 属性所对应的字段(映射到数据库表中应该是 login_name 字段)建立唯一索引,索引名为ux_user_login_name。
columnList 中可以放多个java属性,中间用逗号隔开,表示联合索引,如:
@Index(name = "idx_user_age_name", columnList = "age,loginName")表示建立 age 与 login_name 字段的联合索引。
注意: java 属性名都是驼峰命名法(如 loginName),而数据库表字段都是下划线命名法(如 login_name),JPA会自动根据java属性名的驼峰命名法映射成数据库表字段的下划线命名法,如 loginName 属性映射到数据库就是 login_name 字段。
这个 User 实体类写好后,我们再运行下之前的 main 程序,然后惊奇的发现:数据库里自动建了一个名为 "t_user"的表:
![](http://upload-images.jianshu.io/upload_images/4489584-f7cfd78b88901b01.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
表示JPA在启动时根据实体类,自动在数据库中创建了对应的表了。
注意: 实体类 User 一定要放在 HelloJPAApp 类所在包中或子包中,不然
HelloJPAApp 启动时 Spring Boot 可能扫描不到。
编写 Repository 接口
有了表之后,我们要写对表进行增删改查的代码,用JPA干这事简直是简单到姥姥家了,只需要继续一个接口就搞定了,请看代码:package com.terran4j.springboot.jpa; import org.springframework.data.jpa.repository.JpaRepository; public interface UserRepository extends JpaRepository<User, Long> { }
这样就写完了基本的增删改查的代码? 的确是这样,因为 JpaRepository 接口已经定义了很多方法,JpaRepository 的父类也定义了很多方法,如:
![](http://upload-images.jianshu.io/upload_images/4489584-239776761b84e7eb.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
而 Spring Boot JPA又帮你实现了这些方法,你只需要在继承 JpaRepository 时指定了实体类的类对象和 ID 属性的类对象就可以了,如
public interface UserRepository extends JpaRepository<User, Long>表示实体类是 User, User 中 ID 属性是 Long 类型的。
并且, Spring Boot JPA 扫描到 UserRepository 是 Repository 的子类后,会以动态代理的方式对 UserRepository 进行实现,并将实现的对象作为 Bean 注入到 Spring 容器中,而我们只需要像使用普通的 Spring Bean 一样,用 @Autowired 引入即可使用。
下面,我们编写一个 Controller 类来调用 UserRepository ,如下所示:
package com.terran4j.springboot.jpa; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; @RestController public class HelloController { @Autowired private HelloService helloService; @Autowired private UserRepository userRepository; // URL示例: http://localhost:8080/hello/1 @RequestMapping(value = "/hello/{id}", method = RequestMethod.GET) public String sayHello(@PathVariable("id") Long id) { User user = userRepository.findOne(id); if (user == null) { return String.format("User NOT Found: %d", id); } String name = user.getLoginName(); return helloService.hello(name); } }
相关的 HelloService 的代码为:
package com.terran4j.springboot.jpa; import org.springframework.stereotype.Component; @Component public class HelloService { public String hello(String name) { return "Hello, " + name + "!"; } }
代码中,
User user = userRepository.findOne(id);表示根据 id 从表中查出一条记录,并映射成 User 对象。
为了测试效果,我们先执行以下SQL在数据库中制造点数据:
delete from `t_user`; insert into `t_user` (`id`, `login_name`, `age`, `regist_time`, `status`) values ('1','Jim','12','2017-07-26 09:29:47','enable'), ('2','Mike','23','2017-07-25 09:30:54','disable');
然后启动程序,在浏览器中用以下URL访问:
http://localhost:8080/hello/1
![](http://upload-images.jianshu.io/upload_images/4489584-fdafab4be7c822cd.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
可以看到,
userRepository.findOne(id)的确把数据给查出来了。
使用原生SQL查询
然而,JpaRepository 提供的仅是简单的增删查改方法,那遇到复杂的查询怎么办?Spring Boot JAP 底层是 Hibernate 实现的, Hibernate 提供了 hql 的类SQL语法来编写复杂查询,不过我个人不建议用 HQL,因为毕竟 HQL 与SQL还是有较大不同的,需要学习成本(但这个成本其实是没必要投入的),另外就是一些场景下需要用数据库的特定优化机制时,HQL 实现不了。
所以,我的建议是使用原生 SQL 的方式实现,而 JPA 是提供了这个能力的,下面我介绍一种用在 orm.xml 中写原生 SQL的方法。
假如需求是这样的,我们要查询某一年龄段的 User(如 10岁 ~ 20岁的),SQL大概要这样写:
SELECT * FROM t_user AS u WHERE u.age >= '10' AND u.age <= '20' ORDER BY u.regist_time DESC
Spring Boot JAP 约定是把 SQL 写在类路径的 META-INF/orm.xml 文件中(如果 META-INF 文件夹没有就创建一个),文件路径如下:
![](http://upload-images.jianshu.io/upload_images/4489584-8374ff93115a003e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
orm.xml 文件的内容如下所示:
<?xml version="1.0" encoding="UTF-8" ?> <entity-mappings xmlns="http://xmlns.jcp.org/xml/ns/persistence/orm" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence/orm http://xmlns.jcp.org/xml/ns/persistence/orm_2_0.xsd" version="2.1"> <named-native-query name="User.findByAgeRange" result-class="com.terran4j.springboot.jpa.User"> <query><![CDATA[ select * from t_user as u where u.age >= :minAge and u.age <= :maxAge order by u.regist_time desc ]]></query> </named-native-query> </entity-mappings>
<named-native-query>表示是一个“原生SQL查询”,
name="User.findByAgeRange"表示给这个查询起了一个名字叫“User.findByAgeRange”,后面代码中会根据这个名字来引用这个查询,
result-class="com.terran4j.springboot.jpa.User"表示SQL查询返回的结果集,每条记录转化成 User 对象。
<query>里面是原生的SQL语句,其中 : 开始的是变量,如上面的SQL,有两个变量 :minAge 和 :maxAge ,这些变量的值,会从外面传入进来。
然后我们可以在 UserRepository 中添加一个
findByAgeRange方法来使用这个原生SQL查询,如下代码所示:
package com.terran4j.springboot.jpa; import java.util.List; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.query.Param; public interface UserRepository extends JpaRepository<User, Long> { /** * 查询某年龄段范围之内的用户。 * * @param minAge * 最小年龄。 * @param maxAge * 最大年龄。 * @return */ @Query(nativeQuery = true, name = "User.findByAgeRange") List<User> findByAgeRange(@Param("minAge") int minAge, @Param("maxAge") int maxAge); }
这个
findByAgeRange方法上面有一个
@Query(nativeQuery = true, name = "User.findByAgeRange")注解,表示这个方法的实现使用名为
User.findByAgeRange的查询,此查询是用原生SQL写的;方法参数上有
@Param注解,表示将方法的参数值映射到查询中的变量。
最后,我们写一个 Controller 调用这个方法试,如下代码所示:
package com.terran4j.springboot.jpa; import java.util.List; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.ResponseBody; import org.springframework.web.bind.annotation.RestController; @RestController public class HelloController2 { @Autowired private UserRepository userRepository; // URL示例: http://localhost:8080/users @RequestMapping(value = "/users", method = RequestMethod.GET) @ResponseBody public List<User> findByAgeRange( @RequestParam(value = "minAge", defaultValue = "1") int minAge, @RequestParam(value = "maxAge", defaultValue = "999") int maxAge) { List<User> users = userRepository.findByAgeRange(minAge, maxAge); return users; } }
然后访问 URL:
http://localhost:8080/users,运行效果如下:
![](http://upload-images.jianshu.io/upload_images/4489584-4d31bc994cdacf6a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
我们看到
findByAgeRange方法把数据给查出来了,同时控制台有一行输出:
Hibernate: select * from t_user as u where u.age >= ? and u.age <= ? order by u.regist_time desc
这也是 JPA 底层实际执行的 SQL,也就是把我们写的 SQL 中 :minAge 和 :maxAge 两个变量换成“绑定变量”的方式。
总结说明
本文我们讲解了用 Spring Boot JPA 来访问数据库,是不是觉得用 Spring Boot 开发超级爽呢,本系列这三章就讲到这了,主要是带大家对 Spring Boot 快速上手,后面笔者会努力出更多关于 Spring Boot && Spring Cloud 的技术文章,敬请期待。点击 这里 可以查看本系列的全部章节。
(本系列的目标是帮助有 Java 开发经验的程序员们快速掌握使用 Spring Boot 开发的基本技巧,感受到 Spring Boot 的极简开发风格及超爽编程体验。)
另外,我们有一个名为 SpringBoot及微服务 的微信公众号,感兴趣的同学请扫描下面的二维码关注下吧,关注后就可以收到我们定期分享的技术干货哦!
![](http://upload-images.jianshu.io/upload_images/4489584-f4f91efb322bd92c.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
相关文章推荐
- Spring-Data-JPA 中的JpaRepository相关介绍
- Spring data jpa 分页技术
- Spring Data JPA 持久层开发
- Spring-data-jpa 的@modifying注解
- springdatajpa nativeSQL的分页用法和注意事项以及解决防范
- 在Spring Boot中使用Spring-data-jpa实现分页查询
- maven构建spring mvc + spring data jpa+ sql server 配置
- spring data实现自定义的repository实现类,实现跟jpa联通
- 使用 Spring Data JPA 简化 JPA 开发
- Spring ORM+Hibernate?Out!换 Spring Data JPA 吧!
- 使用 Spring Data JPA 简化 JPA 开发
- Update an entity using spring data JPA
- 从零开始学spring-boot(2)-集成spring-data-jpa
- spring-data-jpa 介绍 复杂查询,包括多表关联,分页,排序等
- spring data jpa的update操作
- Spring Data JPA 全局DAO的扩展
- spring DATA (jpa) @query 和JdbcTemplate
- 使用 Spring Data JPA 简化 JPA 开发
- spring data jpa方法命名规则
- SpringBoot开发案例之整合Spring-data-jpa进阶篇