springboot + jpa（hibernate） + MySQL

最新推荐文章于 2024-05-15 11:23:04 发布
最新推荐文章于 2024-05-15 11:23:04 发布
阅读量736 收藏 2
点赞数
文章标签： spring boot jpa mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43935051/article/details/118884745
版权

文章目录

0、先导知识

（1）后端项目代码分三层，controller层是对外提供的接口层，service层是逻辑实现层，mapper是操作数据库的仓储层。domain层的实体类在以上三层中都会用到
在这里插入图片描述
（2）jpa简答介绍
JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

使用jpa的好处就是不用写sql语句，但是一般的企业项目中都不会用jpa，因为jpa的缺点就是不够灵活，不能够完全自定义sql语句，只能使用jpa提供的方法，实际企业项目中大多都用mybatis。

举例子感受一下使用 jpa 和 使用 mybatis 的区别

1）使用 jpa

User findByAccount(String account);

jpa中的查询语句都是find开头，在By后面添加查询条件，这里的Account是数据库表中的字段名称
在这里插入图片描述
可以多条件查询

User findByAccountAndPassword(String account,String password);

模糊查询

List<User> findAllByAccountLikeOrUsernameLike(String account, String username);

2）使用 mybatis

    <select id="findByAccount" resultType="com.example.springbootmybatismysql.domain.User">
		select * from springboot_demo.user
		where account=#{account}
	</select>

多条件查询

    <select id="findByAccountAndPassword" resultType="com.example.springbootmybatismysql.domain.User">
		select * from springboot_demo.user
		where account=#{account} and password=#{password}
	</select>

模糊查询

    <select id="findAllByAccountLikeOrUsernameLike" resultMap="userResultMap">
		select * from springboot_demo.user
		where account like concat('%',#{keywords},'%') or username like concat('%',#{keywords},'%')
	</select>

1、新建项目

这里有介绍，此处不赘述：springboot简单应用

2、新建基本目录

先创建基本目录：controller（控制器层）、service（逻辑层）、mapper（仓储层）、domain（领域层），result文件下是一些工具类
在这里插入图片描述

3、添加依赖

jpa的依赖

        <!-- jpa 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

mysql的依赖，mysql有5.0的版本和8.0的版本，这里我用的是5.0的版本

<!--        &lt;!&ndash;  mysql 8 &ndash;&gt;-->
<!--        <dependency>-->
<!--            <groupId>mysql</groupId>-->
<!--            <artifactId>mysql-connector-java</artifactId>-->
<!--            <version>8.0.15</version>-->
<!--        </dependency>-->

        <!--  mysql 5  -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.27</version>
        </dependency>

完整的pom文件，除了jpa的依赖和mysql的依赖，其他的依赖都是新建项目时自动生成的

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>springboot-jpa-mysql</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-jpa-mysql</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- jpa 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

<!--        &lt;!&ndash;  mysql 8 &ndash;&gt;-->
<!--        <dependency>-->
<!--            <groupId>mysql</groupId>-->
<!--            <artifactId>mysql-connector-java</artifactId>-->
<!--            <version>8.0.15</version>-->
<!--        </dependency>-->

        <!--  mysql 5  -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.27</version>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.7.RELEASE</version>
                <configuration>
                    <mainClass>com.example.springbootjpamysql.SpringbootJpaMysqlApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

4、添加配置文件

在application.properties文件中添加配置信息

# 应用名称
spring.application.name=springboot-jpa-mysql
# 应用服务 WEB 访问端口
server.port=8080

spring.datasource.url=jdbc:mysql://127.0.0.1:3306/springboot_demo?serverTimezone=UTC&useSSL=false&tinyInt1isBit=false&zeroDateTimeBehavior=round
spring.datasource.username=root
spring.datasource.password=root
#MySQL 8
#spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#MySQL 5
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.hibernate.ddl-auto = none

mysql 8.0 和mysql 5.0的驱动器是不一样的，我用的是5.0的。
数据库连接账号和密码我这里都是root

5、新建数据库

先新建数据库 springboot_demo，再执行下面的sql语句新建表

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `account` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL,
  `username` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `password` varchar(16) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Records of User
-- ----------------------------
INSERT INTO `user` VALUES (1, '1001', 'test1', '123456');
INSERT INTO `user` VALUES (2, '1002', 'test2', '123456');
INSERT INTO `user` VALUES (3, '1003', 'test3', '123456');
INSERT INTO `user` VALUES (4, '1004', 'test4', '123456');

6、新建类

（1）在domain目录下新建实体类 User

package com.example.springbootjpamysql.domain;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

import javax.persistence.*;

@Entity
@Table(name = "user")
@JsonIgnoreProperties({"handler","hibernateLazyInitializer"})
public class User {
    //主键定义，只能有一个，选择对应的列名
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    int id;
    String account;
    String username;
    String password;

    public int getId() {
        return id;
    }

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

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

（2）在mapper目录下新建接口 UserMapper

package com.example.springbootjpamysql.mapper;

import com.example.springbootjpamysql.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;

public interface UserMapper extends JpaRepository<User, Integer> {
    User findById(int id);
    User findByAccount(String account);
    User findByAccountAndPassword(String account,String password);
    List<User> findAllByUsernameLike(String username);
    List<User> findAllByAccountLikeOrUsernameLike(String account, String username);
}

（3）在result目录下新建类 Search

package com.example.springbootjpamysql.result;

public class Search {
    String keywords;

    public String getKeywords() {
        return keywords;
    }

    public void setKeywords(String keywords) {
        this.keywords = keywords;
    }
}

（4）在service目录下新建接口 UserService

package com.example.springbootjpamysql.service;

import com.example.springbootjpamysql.domain.User;

import java.util.List;

public interface UserService {
    List<User> getAllUser();
    User findById(int id);
    User findByAccount(String account);
    User findByAccountAndPassword(String account, String password);
    List<User> findAllByUsernameLike(String keywords);
    List<User> findAllByAccountLikeOrUsernameLike(String keywords);
    void deleteById(int id);
    User add(User user);
    User update(User user);

}

（5）在service->impl 目录下新建类 UserServiceImpl

package com.example.springbootjpamysql.service.impl;

import com.example.springbootjpamysql.domain.User;
import com.example.springbootjpamysql.mapper.UserMapper;
import com.example.springbootjpamysql.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    UserMapper userMapper;

    @Override
    public List<User> getAllUser() {
        return userMapper.findAll();
    }

    @Override
    public User findById(int id) {
        return userMapper.findById(id);
    }

    @Override
    public User findByAccount(String account) {
        return userMapper.findByAccount(account);
    }

    @Override
    public User findByAccountAndPassword(String account, String password) {
        return userMapper.findByAccountAndPassword(account,password);
    }

    @Override
    public List<User> findAllByUsernameLike(String keywords) {
        return userMapper.findAllByUsernameLike('%' + keywords + '%');
    }

    @Override
    public List<User> findAllByAccountLikeOrUsernameLike(String keywords) {
        return userMapper.findAllByAccountLikeOrUsernameLike('%' + keywords + '%','%' + keywords + '%');
    }

    @Override
    public void deleteById(int id) {
        userMapper.deleteById(id);
    }

    @Override
    public User add(User user) {
        return userMapper.save(user);
    }

    @Override
    public User update(User user) {
        return userMapper.save(user);
    }
}

（6）在controller目录下新建类 UserController

package com.example.springbootjpamysql.controller;

import com.example.springbootjpamysql.domain.User;
import com.example.springbootjpamysql.result.Search;
import com.example.springbootjpamysql.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {
    @Autowired
    UserService userService;

    @GetMapping("/api/getAllUser")
    public List<User> getAllUser() throws Exception {
        return userService.getAllUser();
    }

    @PostMapping("/api/findById")
    public User findById(int id) throws Exception {
        return userService.findById(id);
    }

    @PostMapping("/api/findByAccount")
    public User findByAccount(@RequestBody Search s) throws Exception {
        return userService.findByAccount(s.getKeywords());
    }

    @PostMapping("/api/findByAccountAndPassword")
    public User findByAccountAndPassword(@RequestBody User user) throws Exception {
        return userService.findByAccountAndPassword(user.getAccount(),user.getPassword());
    }

    @PostMapping("/api/findAllByUsernameLike")
    public  List<User> findAllByUsernameLike(@RequestBody Search s) throws Exception {
        return userService.findAllByUsernameLike(s.getKeywords());
    }

    @PostMapping("/api/findAllByAccountLikeOrUsernameLike")
    public List<User> findAllByAccountLikeOrUsernameLike(@RequestBody Search s) throws Exception {
        return userService.findAllByAccountLikeOrUsernameLike(s.getKeywords());
    }

    @PostMapping("/api/addUser")
    public User addUser(@RequestBody User user) throws Exception {
        User user1 = userService.findByAccount(user.getAccount());
        if (user1 != null){
            return null;
        }else {
            userService.add(user);
            return user;
        }
    }

    @PostMapping("/api/updateUser")
    public User updateUser(@RequestBody User user) throws Exception {
        User user1 = userService.findByAccount(user.getAccount());
        if (user1 != null){
            userService.update(user);
            return user;
        }else {
            return null;
        }
    }

    @PostMapping("/api/deleteUser")
    public User deleteUser(@RequestBody User user) throws Exception {
        User user1 = userService.findByAccount(user.getAccount());
        if (user1 != null){
            userService.deleteById(user.getId());
            return user;
        }else {
            return null;
        }
    }
}

（7）创建完毕后的目录结构是这样的

在这里插入图片描述

7、测试

启动项目，用postman测试

增删改
http://localhost:8080/api/addUser
http://localhost:8080/api/deleteUser
http://localhost:8080/api/updateUser

在这里插入图片描述

获取所有user
http://localhost:8080/api/getAllUser

在这里插入图片描述

模糊查询
findAllByAccountLikeOrUsernameLike
http://localhost:8080/api/findAllByAccountLikeOrUsernameLike

在这里插入图片描述

8、源码

springboot-jpa-mysql

物宇维
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
SpringBoot + JPA + Mysql
07-27
【SpringBoot + JPA + Mysql 整合详解】 在现代Web开发中，Spring Boot以其简洁的配置和快速启动的特点，成为了许多开发者的首选框架。而JPA（Java Persistence API）作为Java平台上的ORM（Object-Relational ...
springboot + jpa 批量存储示例
02-28
在JPA中，可以使用`@Transactional`注解控制事务边界，并通过设置`hibernate.jdbc.batch_size`配置批处理大小。 总结，通过Spring Boot和JPA，我们可以方便地进行数据库操作，包括批量存储。通过合理配置连接池如...
SpringBoot + SpringDataJPA + MySQL 实现简单的登录、注册功能
qq_42041870的博客
07-13 1320
最近在做一个前端的练习项目时需要用到后端服务，于是在学习了一些知识后，尝试用 SpringBoot + SpringDataJPA + MySQL 实现了简单的登录、注册功能，以及使用JJWT库进行Token的生成和解析。这篇文章用来记录我学习探索过程中的心得，同时也作为一篇适用于初学者的简单易懂的上手教程。
Springboot集成mysql+jpa实现增删改查示例
weixin_40764759的博客
06-08 540
Springboot集成mysql+jpa实现增删改查示例
jpa+springboot做mysql数据库操作
最新发布
m0_64889685的博客
05-15 551
然后需要创建一个类来定义数据类型并根据这个类来生成表，@Table那里可以换成你想要的表的名称，getter和setter的设置是必要的，否则获取过来的数据看不到内容，可以通过右键》生成》getter和setter快速添加，使用本方法添加的前提是写好了private的属性。然后需要配置相关的application.properties文件以方便链接数据库，其中要把test_user替换成你的数据库的名称，同时也要确保username和password是正确的。
避坑版：springboot+JPA如何配多种数据源（postgresql+mysql）
u013232219的博客
09-08 2755
注意： JPA和mybatis是不同的持久层，各自特点独特， 与mybatis相比，JPA需要考虑对数据源的映射和操作， 通常我们设置在项目启动时，JPA就会根据设置去创建或者更新表， 因此不能像mybayis那样等到调用时再去告诉方法用哪个数据源， JPA需要一开始就设定好repository和entity所对应的数据源， 在下列文件repository里你可以看到相关设置； 坑，请注意，网上有很多的JPA配多种数据源，但是他们都缺失一点，连方言都没有设置，有的压根不知道这回事，要知道，JPA
spring boot通过JPA访问Mysql
CREATE_17的博客
04-06 1832
本文主要介绍spring boot如何使用JPA来访问Mysql，对单表做简单的增删改查操作。 环境说明： IntelliJ IDEA JDK 1.8 spring boot 2.1.0 Maven 3.5.0 Mysql 一、初始化mysql 进入mysql，创建数据库，创建数据表，并生成一些测试数据。 CREATE DATABASE spring_boot_study; USE sp...
Springboot+JPA+Mysql的实践操作
未的博客
02-10 530
#1、什么是JPA? JPA全称为Java Persistence API ，Java持久化API是Sun公司在javaEE 5规范中提出的Java持久化接口。 JPA吸取了目前Java持久化技术的优点，旨在规范、简化Java对象的持久化工作。使用JPA持久化对象，并不是依赖于某一个ORM框架。 #2、作用是什么？ 通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久...
Springboot+jpa整合demo
04-19
spring.jpa.hibernate.ddl-auto=update ``` - **定义Entity类**：创建表示数据库表的实体类，使用`@Entity`注解标识。例如： ```java import javax.persistence.Entity; import javax.persistence.GeneratedValue; ...
Springboot+jpa+MySQL+HTML之简单的增删改查Demo
01-15
spring.jpa.hibernate.ddl-auto=update ``` 3. **定义实体类**：创建一个实体类，例如`User`，并使用JPA注解如`@Entity`、`@Table`、`@Id`等进行数据库表的映射。 ```java @Entity @Table(name = "users") ...
springboot+hibernate+maven+jpa
08-08
1. **创建SpringBoot项目**：首先，我们需要创建一个SpringBoot项目，并在`pom.xml`中添加SpringBoot的父POM依赖，以及Spring Data JPA、Hibernate和MySQL驱动等相关依赖。 2. **配置数据库连接**：在`application....
SpringBoot+MySQL+Jpa实现对数据库的增删改查和分页详解
08-25
主要介绍了SpringBoot+MySQL+Jpa实现对数据库的增删改查和分页详解,需要的朋友可以参考下
springboot+druid+jpa(hibernate)+mysql项目案例
06-22
这案例是spring boot+druid+jpa(hibernate)+mysql搭建的maven结构的基础案例
springBoot+swagger+Hibernate+Redis+Mysql Demo
02-05
springBoot整合swagger、Hibernate、Redis、Mysql一个demo
idea+springboot+jpa+mysql增删查改项目例子
04-19
idea+springboot+jpa+mysql增删查改项目例子，springboot入门参考 http://blog.csdn.net/peng_hong_fu/article/details/53691705
Spring boot +mysql+Hibernate整合
weixin_44870643的博客
09-22 209
步骤一：建立一个maven项目，然后在pom.xml中添加相关依赖: <!-- Spring-boot必加依赖 --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-par...
jpa mysql_（四）spring boot + jpa + mysql 后台管理系统
weixin_39932455的博客
01-18 241
上篇文章：https://www.jianshu.com/p/f062c9ff7b48这一篇主要是完成spring boot 与 mysql的连接，并使用jpa，来完成一个后台管理系统的增删改查功能。先来看最后的效果图：后台管理系统.png前后台分离后，每个人的习惯也不一样，有的喜欢从前台开始写，有的喜欢从后台开始写，而我习惯从后往前写。我们先来看后端代码结构：代码结构pom.xmlxsi:sch...
Spring Boot笔记-Java控制台程序及JPA映射Mysql
IT1995的博客
11-17 5174
目录 基本概念 代码与实例 项目打包下载 基本概念 因为公司用spring boot用得多，本人身为C++程序员，对Java研究并不是很多。 在独立构件风格的项目中，要使用某些进程，干一些计算方面的事情，在此要使用控制台程序。在此使用spring boot完成后控制台程序，用于后端运行。 在此特意做一个命令行后端操作MySQL数据库的实例（使用JPA） ...
SpringBoot+Hibernate+MySQL实现数据操作
一杯清泉
10-06 1487
待定
springboot+jpa2.2.10 QueryDSL写个详细案例，从配置到查询
04-24
好的，我会为你提供一个详细的案例来展示如何使用springboot jpa2.2.10和QueryDSL进行查询。 首先，我们需要在pom.xml文件中添加相关的依赖： ```xml <dependency> <groupId>com.querydsl</groupId> <artifactId>querydsl-jpa</artifactId> <version>4.2.2</version> </dependency> <dependency> <groupId>com.querydsl</groupId> <artifactId>querydsl-apt</artifactId> <version>4.2.2</version> <scope>provided</scope> </dependency> <dependency> <groupId>com.querydsl</groupId> <artifactId>querydsl-core</artifactId> <version>4.2.2</version> </dependency> ``` 接下来，我们需要创建一个实体类，假设我们的实体类是`User`，在这个实体类中，我们需要添加一些jpa注解，例如：`@Entity`、`@Table`、`@Id`和`@GeneratedValue`等。 User.java ```java @Entity @Table(name = "user") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private Integer age; // Getter and Setter methods } ``` 接下来，我们需要创建一个查询接口，用于定义查询方法。在这个接口中，我们需要继承`JpaRepository`接口，并且添加QueryDSL的相关注解。 UserQueryRepository.java ```java @Repository public interface UserQueryRepository extends JpaRepository<User,Long>,QuerydslPredicateExecutor<User>,QuerydslBinderCustomizer<QUser> { @Override default void customize(QuerydslBindings bindings, QUser root) { bindings.bind(String.class).first((StringPath path, String value) -> path.containsIgnoreCase(value)); } List<User> findAll(Predicate predicate); } ``` 在这个接口中，我们使用`QuerydslPredicateExecutor`接口来执行对实体类的谓语查询。同时，我们还需要实现`QuerydslBinderCustomizer<QUser>`接口来添加一些自定义的查询条件。 我们在这里添加了一个字符串类型的自定义查询条件，用于模糊查询。可以根据需要添加其他自定义查询条件。 接下来，我们需要创建一个Service类，用于调用查询接口进行数据库操作。在这个Service类中，我们需要注入这个查询接口，并且实现具体的查询方法。 UserService.java ```java @Service public class UserService { @Autowired UserQueryRepository userQueryRepository; public List<User> findAll(User user){ QUser qUser = QUser.user; BooleanBuilder builder = new BooleanBuilder(); if(user.getId()!=null){ builder.and(qUser.id.eq(user.getId())); } if(StringUtils.isNotEmpty(user.getName())){ builder.and(qUser.name.contains(user.getName())); } if(user.getAge()!=null){ builder.and(qUser.age.eq(user.getAge())); } List<User> list = userQueryRepository.findAll(builder.getValue()); return list; } } ``` 在这个Service类中，我们使用了`BooleanBuilder`来拼接查询条件。同时，我们也使用了`QUser`来代表我们的实体类。 最后，我们需要在SpringBoot的配置文件中配置JPA和QueryDSL。具体的配置内容如下： application.yaml ```yaml spring: datasource: driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC username: root password: root jpa: show-sql: true hibernate: ddl-auto: update properties: hibernate: dialect: org.hibernate.dialect.MySQL5Dialect querydsl: default-use-collection: true ``` 在这个配置文件中，我们添加了一些JPA和QueryDSL的相关配置。其中，`default-use-collection`用于将多个结果集合并成一个结果集。 到此，我们整个案例就完成了。我们可以使用类似下面的代码来测试我们的查询方法： TestUser.java ```java @SpringBootTest class TestUser { @Autowired private UserService userService; @Test void contextLoads() { User user = new User(); user.setAge(18); List<User> list = userService.findAll(user); System.out.println(list); } } ``` 通过这个案例，我相信您已经掌握了使用springboot jpa2.2.10和QueryDSL进行查询的方法。如果您还有任何疑问，可以随时向我提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值