SpringBoot整合SpringDataJPA,不用写SQ语句
SpringBoot整合SpringDataJPA,今天没啥事情就看了一下springboot整合springdataJPA,实在
SpringBoot整合SpringDataJPA
1、JPA概念
JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0
注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中.
JPA的总体思想和现有Hibernate、TopLink、JDO等ORM框架大体一致。
总的来说，JPA包括以下3方面的技术：
ORM映射元数据
JPA支持XML和JDK5.0注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象持久化到数据库表中；
API
用来操作实体对象，执行CRUD操作，框架在后台替代我们完成所有的事情，开发者从繁琐的JDBC和SQL代码中解脱出来。
查询语言
这是持久化操作中很重要的一个方面，通过面向对象而非面向数据库的查询语言查询数据，避免程序的SQL语句紧密耦合
创建maven工程并导入依赖:(这里用的是sprigcloud2.1.16的)
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.16.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<dependencies>
<dependency>
<groupId>org.sprin
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
2、配置文件application.yml
server:
port: 9090
spring:
application:
name: spring-data-jpa
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql:///user_db?serverTimezone=UTC
username: root
password: root
#jpa配置
jpa:
show-sql: true
hibernate:
ddl-auto: update
注意: url这里的配置必须要加入serverTimezone=UTC传递时区,不然操作数据库会抛异常的,///代表的是127.0.0.1:3306 本地的可以省略
ServerTimeZone时区的问题
在设定时区的时候，如果设定serverTimezone=UTC，会比中国时间早8个小时，如果在中国，可以选择Asia/Shanghai或者Asia/Hongkong，例如：
url:jdbc:mysql://localhost:3306/mango?serverTimezone=Asia/Shanghai&useU nicode=true&zeroDateTimeBehavior=convertToNull&autoReconnect=true&ch aracterEncoding=utf-8
解析：
ddl-auto表示对数据库进行自动化配置
值有三个选择：
create表示创建，如果说数据库中不管有没有这张表，都会先干掉，然后在重新创建，不适合生产环境
update表示更新，如果说数据库中有这张表，则执行进行更新表中的数据，如果没有这张表，则直接创建这张表，适合生产环境
none 没有任何操作
3、实体类
@Data
@Entity//表示当前类是实体类
@Table(name="tb_user",catalog = "user_db")
public class UserInfo {
/**
* 如果数据库表中的字段名称和实体类中的属性名称保持一致的话，可以不需要加@Column注解
* @GeneratedValue(strategy=GenerationType.IDENTITY)主键生成策略
* GenerationType.IDENTITY表示针对于mysql中有自增长的数据的生成策略* GenerationType.SEQUENCE表示针对于oracle数据中的主键生成策略
* GenerationType.AUTO是默认的选项，会根据数据库自动选择
@table 中的name值是指定数据库中的表名 catalog表示的是指定database 名
*/
@Id
@Column(name="id")
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
private String name;
private String gender;
private Integer age;
private String address;
private String qq;
private String email;
private String username;
private String password;
private String phone;
}
/**
* dao接口
*/
@Repository
public interface UserMapper extends JpaRepository<UserInfo,Integer> {
}
jpaRepository的泛型为userinfo 为实体类integer为实体类的id也就是数据库对应的主键
5、测试类
@RunWith(SpringRunner.class)
@SpringBootTest
public class JpaTest {
@Autowired
private UserMapper userMapper;
//查询方法
@Test
public void queryAll(){
List<UserInfo> infoList = userMapper.findAll();
System.out.println(infoList);
}
}
在实体类上要加入lombok的注解:
@AllArgsConstructor #有参构造的注解@NoArgsConstructor #无参构造的注解
欢迎大家一起交流学习...。
SpringBoot+springDataJpa实现单表字段动态部分更新
SpringBoot+springDataJpa实现单表字段动态部分更新写在前⾯所谓的动态部分更新是指：并⾮对数据记录的所有字段整体更新，⽽是知道运⾏时才确定哪个或者哪些字段需要被更新。
1）Spring Data Jpa对于Entity的更新，是对数据表中Entity对应的除主键外的数据记录的所有字段整体更新，⽽不是仅仅更新前端传⼊的字段或者那些发⽣了变化的字段；2）repository.save()的逻辑是：如果不存在Entity对应的数据记录则执⾏插⼊操作，否则则执⾏更新操作。
同时，在执⾏更新操作之前，此⽅法还会执⾏⼀步查询操作。
源码如下：@Transactional@Overridepublic <S extends T> S save(S entity) {if (entityInformation.isNew(entity)) {em.persist(entity);return entity;} else {return em.merge(entity);}}3）对于字段更新时，如果使⽤@Query注解，通过写原⽣SQL的⽅法，确实可以实现字段的部分更新，但是使⽤@Query注解⽆法很好地实现字段的动态部分更新。
4）使⽤@DynamicUpdate注解，通过在Entity实体类上添加此注解，再结合repository.save()⽅法进⾏字段更新，此⽅法的确具有可⾏性，但是仍存在⼀个问题：当字段值为null值时，Jpa会将null值与原值作⽐较，如果原值不为null，那么原值将会被覆盖为null。
针对此问题，如何解决呢，这⾥提供⼀种⽅法。
对于动态部分更新，可以在@DynamicUpdate注解的基础上，可以书写⼀个Jpa⼯具类来避免null值对于动态部分更新的影响。
这⾥给出⼀个⽰例代码：import org.springframework.beans.BeanUtils;import org.springframework.beans.BeanWrapperImpl;import java.beans.PropertyDescriptor;import java.util.stream.Stream;public class JpaUtil {public static void copyNotNullProperties(Object src,Object target){BeanUtils.copyProperties(src,target,getNullPropertyNames(src));}private static String[] getNullPropertyNames(Object object) {final BeanWrapperImpl wrapper = new BeanWrapperImpl(object);return Stream.of(wrapper.getPropertyDescriptors()).map(PropertyDescriptor::getName).filter(propertyName -> wrapper.getPropertyValue(propertyName) == null).toArray(String[]::new);}}下⾯根据⽰例代码进⾏整合。
springboot开发技术(习题卷2)
springboot开发技术(习题卷2)第1部分：单项选择题，共29题，每题只有一个正确答案,多选或少选均不得分。
1.[单选题]使用@Schedule注解定制表示每月的1日每一分钟都执行一次,以下写法正确的是()A)@Scheduled(cron = "0 ** 1 * ?")B)@Scheduled(cron = "0 * * 1 * *")C)@Scheduled(cron = "0 0 0 1 * *")D)@Scheduled(cron = "* * * 1 * ?")答案:A解析:2.[单选题]关于Spring Boot整合JSP模板技术的限制，以下说法错误的是( )A)Spring Boot默认的JAR包部署方式不支持JSP模板B)Undertow嵌入式容器部署Spring Boot项目，不支持JSP模板C)使用JSP模板时，无法对默认的错误处理器进行覆盖D)使用JSP模板时，无法自定义错误页面答案:D解析:3.[单选题]RabbitMQ提供的工作模式不包括( )。
A)单点模式B)发布订阅模式C)路由模式D)Headers答案:A解析:4.[单选题]关于Spring Boot项目的打包部署相关说法错误的是（）A)使用IDEA快速方式创建的项目会自动导入项目打包插件B)Spring Boot项目默认以Jar包方式打包C)Spring Boot默认支持内嵌式Tomcat，在不添加任何依赖创建Spring Boot项目时，也会提供内嵌tomcatD)可以通过IDEA工具进行项目快速打包和部署答案:B解析:5.[单选题]以下关于Spring Data JPA映射实体类相关注解说法,正确的是()A)@Entity标注在类上,表示与数据表具有映射关系的实体类,必须使用name属性指定具体映射的表名B)@Id必须标注在类属性上,表示某一个属性对应表中的主键C)@Column标注在属性上,必须配合name属性表示类属性对应的表字段名D)@Transient表示该属性并非一个到数据库表的字段的映射答案:D解析:6.[单选题]下列关于springboot中Redis缓存注解相关属性的说法，错误的是( )A)value 和cacheNames属性作用相同，用于指定缓存的名称空间B)key 属性的作用就是指定缓存数据对应的唯一标识， 默认使用注解标记的方法参数值C)unless属性的作用是当指定的条件为true时，方法的返回值就会被缓存D)sync 属性表示数据缓存过程中是否使用异步模式，默认值为false答案:C解析:7.[单选题]下列关于 Spring Data JPA映射的实体类中相关注解的说法，正确的是( )A)使用Spring Data JPA进行数据查询映射时，需要在配置文件中开启驼峰命名映射B)使用@Entity注解时，还要使用name属性指定具体映射的表名C)@ld注解必须标注在类属性上，表示主键对应的属性D)@Transient注解表示指定属性不是到数据库表的字段的映射，ORM框架将忽略该属性答案:D解析:8.[单选题]启动Ribbon的类注解是：A)@RibbonClientB)@EnableClientC)@EnableDisscoveryClientD)@Ribbon答案:A解析:9.[单选题]下列关于Spring Boot的Profile多环境配置的说法，错误的是( )A)Spring Boot提供了两种多环境配置的方式: Profile 文件多环境配置和@Proflie注解多环境配置B)Profile配置文件的名必须满足application-{profile}.properties的格式C)可以在项目全局配置文件中配置spring poflis acive属性激活指定的多环境配置文件D)在多个自定义类上直接使用@Profile注解可以进行多环境配置答案:D解析:第三章填空题10.[单选题]下列关于Spring Boot自动配置原理的说法，错误的是( )A)@SpringBootApplication 只包含@SpringBooConfiguration、@EnableAutoConfiguration、@ComponentScan 3个注解B)@SpringBootConfiguration 注解表示当前类为-一个配置类并可以被组件扫描器扫描C)@EnableAutoConfiguration 的作用是启动自动配置，向容器中导入所有选中的自动配置类D)@ComponentScan注解的主要作用是扫描指定包及其子包下所有注解类文件作为Spring容器的组件使用答案:A解析:第二章填空题11.[单选题]spring 事件机制是使用（ ）A)订阅和发布模式B)只有订阅模式C)只有发布模式D)都错答案:A解析:12.[单选题]以下有关 Spring 中 Bean 的作用域说法正确的是（ ）。
SpringSpringBoot配置连接数据库的方法
SpringSpringBoot配置连接数据库的⽅法Spring配置连接数据库设置jdbc.propertiesjdbc.driverClassName=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://127.0.0.1:3306/SSMername=rootjdbc.password=root创建配置类/*** @Author: Promsing* @Date: 2021/5/30 - 14:52* @Description:连接数据库的配置类* @version： 1.0*/@Configuration//声明该类是⼀个java配置类，相当于⼀个xml配置⽂件@PropertySource("classpath:jdbc.properties") //读取资源⽂件public class JdbcConfiguration {@Value("${jdbc.driverClassName}")private String driverClassName;@Value("${jdbc.url}")private String url;@Value("${ername}")private String username;@Value("${jdbc.password}")private String password;@Bean //将返回值注⼊到IOC容器中public DataSource dataSource(){DruidDataSource dataSource=new DruidDataSource();//设置连接数据库的四⼤参数dataSource.setDriverClassName(this.driverClassName);dataSource.setUrl(this.url);dataSource.setUsername(ername);dataSource.setPassword(this.password);return dataSource;}}SpringBoot配置连接数据库设置application.propertiesjdbc.driverClassName=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://127.0.0.1:3306/SSMername=rootjdbc.password=root创建配置类-JdbcProperties/*** @Author: Promsing* @Date: 2021/5/30 - 15:41* @Description: 封装了读取出来的配置⽂件* @version： 1.0*/@ConfigurationProperties(prefix = "jdbc")public class JdbcProperties {private String driverClassName;private String url;private String username;private String password;public void setDriverClassName(String driverClassName) {this.driverClassName = driverClassName;}public void setUrl(String url) {this.url = url;}public void setUsername(String username) {ername = username;}public void setPassword(String password) {this.password = password;}public String getDriverClassName() {return driverClassName;}public String getUrl() {return url;}public String getUsername() {return username;}public String getPassword() {return password;}}创建配置类-JdbcConfiguration/*** @Author: Promsing* @Date: 2021/5/30 - 14:52* @Description: 连接数据库的Java配置类* @version： 1.0*/@Configuration//声明该类是⼀个java配置类，相当于⼀个西xml配置⽂件@EnableConfigurationProperties(JdbcProperties.class) //加载JDBC的配置类public class JdbcConfiguration {@Autowiredprivate JdbcProperties jdbcProperties;//⽅式⼀@Bean //将返回值注⼊到IOC容器中public DataSource dataSource(){DruidDataSource dataSource=new DruidDataSource();//设置连接数据库的四⼤参数dataSource.setDriverClassName(this.jdbcProperties.getDriverClassName()); dataSource.setUrl(this.jdbcProperties.getUrl());dataSource.setUsername(this.jdbcProperties.getUsername());dataSource.setPassword(this.jdbcProperties.getPassword());return dataSource;}/*//⽅式⼆：最优雅最简单--直接换掉⽅式⼀@Bean //将返回值注⼊到IOC容器中@ConfigurationProperties(prefix = "jdbc")public DataSource dataSource(){DruidDataSource dataSource=new DruidDataSource();return dataSource;}* *//*//⽅式三通过构造函数注⼊--在⽅式⼀上的⽅式修改public JdbcConfiguration(JdbcProperties jdbcProperties) {this.jdbcProperties = jdbcProperties;}* *//*//⽅式四通过⽅法的参数注⼊--直接换掉⽅式⼀public DataSource dataSource(dbcProperties jdbcProperties){DruidDataSource dataSource=new DruidDataSource();//设置连接数据库的四⼤参数dataSource.setDriverClassName(jdbcProperties.getDriverClassName());dataSource.setUrl(jdbcProperties.getUrl());dataSource.setUsername(jdbcProperties.getUsername());dataSource.setPassword(jdbcProperties.getPassword());return dataSource;// }* */}SpringBoot的四种属性注⼊⽅式1. Autowired注⼊2.直接在@Bean⽅法中使⽤@ConfigurationProperties(prefix = "jdbc")3.构造函数主语4.@Bean⽅法形参注⼊需要注意的是配置⽂件中的名称要与 JdbcProperties中的属性名称要⼀致。
Spring-data-jpa和mybatis的比较及两者的优缺点？
Spring-data-jpa和mybatis的⽐较及两者的优缺点？1. spring data jpa实现了jpa（java persistence api）功能，即可以实现pojo转换为关系型数据库记录的功能，通俗来讲就是可以不写任何的建表sql语句了。
jpa是spring data jpa功能的⼀个⼦集。
⽽mybatis并没有jpa功能，建表语句还是要⾃⼰写的。
2. spring data jpa是全⾃动框架，不需要写任何sql。
⽽mybatis是半⾃动框架，需要⾃⼰写sql，mybatis-plus为mybatis赋能，使其也可以基本上不需要写任何模板sql。
3. debug模式下看⽣成的sql，mybatis下的sql可读性很好，⽽spring data jpa下的查询sql可读性并不好。
如spring data jpa的findOne(id)⽅法，执⾏的sql如下，看起来很奇怪，不是很直接。
4. spring data jpa的insert与update都调⽤同⼀个⽅法save，如果带有主键id（如果启⽤了乐观锁，那么还有version字段），那么就是更新，否则就是新增，所以addOrUpdate是⼀个接⼝，⽽mybatis中提供insert⽅法和updateById⽅法。
由于spring data jpa调⽤同⼀个⽅法，所以其要执⾏两条sql，先执⾏查询，再执⾏插⼊/更新。
另外就是返回值，spring data jpa的返回值是Employee对象，⽽mybatis的返回值是影响的⾏数，当然mybatis也可以得到新增后的id，返回新增后的对象5. spring data jpa的dynamic sql是使⽤JpaSpecificationExecutor，⽽mybatis中是使⽤xml来构造dynamic sql。
当我执⾏分页查询的时候，spring data jpa实际上是调⽤了两个sql语句通过count获得总记录数，即当⽤到Pageable的时候会执⾏⼀条count语句，这可能是很昂贵的操作，因为count操作在innodb中要扫描所有的叶⼦节点通过limit来获得分页记录mybatis获得总记录数好像并不是通过执⾏count语句来获得的，可能是通过游标cursor的⽅式来获得的，通过druid监控，其只执⾏⼀条sql语句6. spring data jpa⽀持⾃⼰来写sql语句，有两种⽅式：1）@Query或@Modifying配合@Query2）通过entityManager但要注意的是：如果⾃⼰写sql语句，那么有些拦截器可能并不能起作⽤，如@PreUpdate相对来说，mybatis就⽐较简单，直接在mapper xml中写sql就可以了ORM框架使⽤中的常见需求1. 后管系统做查询的时候，多个条件通过⼀个接⼝进⾏查询，带了哪个字段就加⼀段sql过滤，通过mybatis如何实现？通过mybatis的dynamic sql是可以实现的，类似getEmpsByCondition，携带了哪个字段，查询条件就带上这个字段的值似乎只能通过写mapper xml来做逻辑判断spring data jpa是通过多个Predicate构造Specification创建where条件的，都是通过代码来控制逻辑的2⾃动设置创建时间/更新时间mybatis 也是使⽤metaObjectHandler来做？还是通过拦截器来做？还是只创建这两个字段，通过数据库语句来控制？spring data jpa中有entityListener，可以不操作数据库，来实现此功能3.字段⾃动加解密？不知道如何实现⾃动在mybatis中，查询出来之后做混淆处理在spring data jpa中，使⽤entityManager查询出来之后做混淆处理4. 乐观锁功能mybatis-plus提供了optimistic-lock pluginspring data jpa也提供了@version注解来做5. 逻辑删除mybatis-plus逻辑删除是放在DefaultSqlInjector中的spring data jpa要⾃⼰写sql来实现逻辑删除。
5-Spring-Boot(五)：spring data jpa的使用
在上篇文章springboot(二)：web综合开发中简单介绍了一下spring data jpa 的基础性使用，这篇文章将更加全面的介绍spring data jpa 常见用法以及注意事项使用spring data jpa 开发时，发现国内对spring boot jpa全面介绍的文章比较少案例也比较零碎，因此写文章总结一下。
本人也正在翻译Spring Data JPA 参考指南,有兴趣的同学欢迎联系我，一起加入翻译中！spring data jpa介绍首先了解JPA是什么？JPA(Java Persistence API)是Sun官方提出的Java持久化规范。
它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。
他的出现主要是为了简化现有的持久化开发工作和整合ORM技术，结束现在Hibernate，TopLink，JDO等ORM框架各自为营的局面。
值得注意的是，JPA是在充分吸收了现有Hibernate，TopLink，JDO等ORM框架的基础上发展而来的，具有易于使用，伸缩性强等优点。
从目前的开发社区的反应上看，JPA受到了极大的支持和赞扬，其中就包括了Spring与EJB3.0的开发团队。
注意:JPA是一套规范，不是一套产品，那么像Hibernate,TopLink,JDO他们是一套产品，如果说这些产品实现了这个JPA规范，那么我们就可以叫他们为JPA的实现产品。
spring data jpaSpring Data JPA 是Spring 基于ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据的访问和操作。
它提供了包括增删改查等在内的常用功能，且易于扩展！学习并使用Spring Data JPA 可以极大提高开发效率！spring data jpa让我们解脱了DAO层的操作，基本上所有CRUD都可以依赖于它来实现基本查询基本查询也分为两种，一种是spring data默认已经实现，一种是根据查询的方法来自动解析成SQL。
SpringBoot：阿里数据源配置、JPA显示sql语句、格式化JPA查询的sql语句
请问如果使用的前端是angular或者vue这个loginpage是不是应该指向的就是ip地址port接口
SpringBoot：阿里数据源配置、 JPA显示 sql语句、格式化 JPA查 询的 sql语句
1 数据源和 JPA配置
1.1 显 示 sql配 置 和 格 式 化 sql配 置
者两个配置都是属于hibernate的配置，但是springdatajpa给我们简化了；所有hibernate的配置都在jpa下面的properties中；若果直 接配置到jpa下面可能不会生效
eureka: client: service-url: defaultZone: http://localhost:8761/eureka/ # 注册中心 instance: hostname: productClient
ring: application: name: product
datasource: url: jdbc:mysql://xxxxx:3306/spring_cloud_sell?useUnicode=true&characterEncoding=UTF-8&useSSL=false
# url: jdbc:mysql://xxxxx:3306/dev?useUnicode=true&characterEncoding=UTF-8&&useSSL=false # url: jdbc:mysql://xxxxx:3306/qcbx?useUnicode=true&characterEncoding=UTF-8&&useSSL=false
driver-class-name: com.mysql.jdbc.Driver # username: root # password: uAiqwVwjJ8-i
SpringBoot高级教程之SpringBoot连接MySql数据库
SpringBoot⾼级教程之SpringBoot连接MySql数据库Spring Boot可以⼤⼤简化持久化任务，⼏乎不需要写SQL语句，在之前章节“Spring Boot 构建框架”中我们新建了⼀个Spring Boot应⽤程序，本章在原有的⼯程中与数据库建⽴连接。
Spring Boot有两种⽅法与数据库建⽴连接，⼀种是使⽤JdbcTemplate，另⼀种集成Mybatis，下⾯分别为⼤家介绍⼀下如何集成和使⽤这两种⽅式。
1. 使⽤JdbcTemplate<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency>在resource⽂件夹下添加application.properties配置⽂件并输⼊数据库参数，内容如下：spring.datasource.url=jdbc:mysql://127.0.0.1:3306/testername=rootspring.datasource.password=123456spring.datasource.driver-class-name=com.mysql.jdbc.Driverspring.datasource.max-idle=10spring.datasource.max-wait=1000spring.datasource.min-idle=5spring.datasource.initial-size=5server.port=8012server.session.timeout=10server.tomcat.uri-encoding=UTF-8新建Controller类测试数据库连接，实例如下：package com.example.demo;import java.util.Iterator;import java.util.List;import java.util.Map;import java.util.Map.Entry;import java.util.Set;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;@RestController@RequestMapping("/mydb")public class DBController {@Autowiredprivate JdbcTemplate jdbcTemplate;@RequestMapping("/getUsers")public List<Map<String, Object>> getDbType(){String sql = "select * from appuser";List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);for (Map<String, Object> map : list) {Set<Entry<String, Object>> entries = map.entrySet( );if(entries != null) {Iterator<Entry<String, Object>> iterator = entries.iterator( );while(iterator.hasNext( )) {Entry<String, Object> entry =(Entry<String, Object>) iterator.next( );Object key = entry.getKey( );Object value = entry.getValue();System.out.println(key+":"+value);}}}return list;}@RequestMapping("/user/{id}")public Map<String,Object> getUser(@PathVariable String id){Map<String,Object> map = null;List<Map<String, Object>> list = getDbType();for (Map<String, Object> dbmap : list) {Set<String> set = dbmap.keySet();for (String key : set) {if(key.equals("id")){if(dbmap.get(key).equals(id)){map = dbmap;}}}}if(map==null)map = list.get(0);return map;}}运⾏App输⼊地址输出数据库数据。
Querydsl与SpringBoot集成
Querydsl与SpringBoot集成Querydsl为⼤多数数据库提供了⼀种基于Java的类型安全，类SQL的查询⽅式。
相⽐JPA，Querydsl能提供更加强⼤的查询⽅式，⽐如关联查询。
相⽐MyBatis，Querydsl省去了XML⽂件或者注解SQL的⿇烦，直接通过流式API的⽅式进⾏调⽤。
除了⽀持关系型数据库之外，Querydsl同样⽀持⼀下存储MongoDBLuceneCollectionsSpatialJDO接下来通过H2+JPA的⽅式介绍Querydsl的基本使⽤（为了演⽰采⽤H2数据库）⼀、创建项⽬，添加依赖本⽂采⽤Spring Boot快速搭建项⽬，并在pom.xml中添加以下依赖<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>com.h2database</groupId><artifactId>h2</artifactId><scope>runtime</scope></dependency><dependency><groupId>com.querydsl</groupId><artifactId>querydsl-apt</artifactId><version>4.3.1</version></dependency><dependency><groupId>com.querydsl</groupId><artifactId>querydsl-jpa</artifactId><version>4.3.1</version></dependency><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin><plugin><groupId>com.mysema.maven</groupId><artifactId>apt-maven-plugin</artifactId><version>1.1.3</version><executions><execution><goals><goal>process</goal></goals><configuration><outputDirectory>target/generated-sources/java</outputDirectory><processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor></configuration></execution></executions></plugin></plugins></build>注意当在项⽬中使⽤的是JPA的注解（ javax.persistence.Entity）的时候，需要使⽤JPAAnnotationProcessor⽣成相关的查询类，如果使⽤的是Hibernate注解的时候，需要将JPAAnnotationProcessor替换成com.querydsl.apt.hibernate.HibernateAnnotationProcessor。
解决spring-data-jpa事物中修改属性自动更新update问题
解决spring-data-jpa事物中修改属性⾃动更新update问题问题还原项⽬orm层⽤的是spring-data-jpa，服务端接⼝实现的是树节点间的拖拽功能，测试环境联调发现异常问题，其中拖拽到⽬标⽬录后节点名称总会重名，重名规则是originName转化为originName(n)@Transactional(rollbackFor = Exception.class)public void move(MoveWorkSpaceDto moveWorkSpaceDto) {/**** 个⼈空间节点移动* 1、源节点移动到空⽬录，那么⽬标⽗节点必传，前置和后置节点都为空* 2、源节点移动到⾮空⽬录：* 2.1、移动到⽬标⽬录的第⼀个节点，那么后置节点必传，前置节点为空* 2.2、移动到⽬标⽬录的最后个节点，那么前置节点毕传，后置节点为空* 2.3、移动到⽬标⽬录的中间节点，那么前置节点和后置节点都要传⼊* 3、节点拖动到⽬录中，此时不知道⽬录是否⾮空，前置后置节点都不传，服务器追加到⽬录的最后个节点*/(">>>MoveParams: [{}]", JSONObject.toJSONString(moveWorkSpaceDto));WorkSpaceEntity sourceEntity = workSpaceRepository.findById(moveWorkSpaceDto.getSourceWorkId()).orElse(null);if (sourceEntity == null) {throw new PublicsException("源⼯作空间节点不存在！");}WorkSpaceEntity parentEntity = workSpaceRepository.findById(moveWorkSpaceDto.getDestParentId()).orElse(null);if (parentEntity == null) {throw new PublicsException("⽬标⽗⼯作空间节点不存在！");}(">>>>Noooooooo<<<<<");sourceEntity.setParentId(parentEntity.getId());(">>>>UpdateNow<<<<<");Long cnt = workSpaceRepository.countAllByParentIdAndSpaceName(parentEntity.getId(), sourceEntity.getSpaceName());("destParentId: [{}], spaceName: [{}], destCount: [{}]", parentEntity.getId(), sourceEntity.getSpaceName(), cnt);if (cnt > 0L) {String newName = RenameUtil.rename(sourceEntity.getSpaceName(), sourceEntity.getRunType(), cnt);sourceEntity.setSpaceName(newName);}if (moveWorkSpaceDto.getFrontWorkId() == null && moveWorkSpaceDto.getPostWorkId() == null) {List<WorkSpaceEntity> children = workSpaceRepository.findByParentIdOrderBySortIndexDesc(moveWorkSpaceDto.getDestParentId());if (CollectionUtils.isEmpty(children)) {sourceEntity.setSortIndex(sourceEntity.getId() * SORT_INDEX_STEP);} else {sourceEntity.setSortIndex(children.get(0).getSortIndex() + SORT_INDEX_STEP);}} else if (moveWorkSpaceDto.getFrontWorkId() != null && moveWorkSpaceDto.getPostWorkId() == null) {WorkSpaceEntity frontEntity = getFrontEntity(moveWorkSpaceDto);sourceEntity.setSortIndex(frontEntity.getSortIndex() + SORT_INDEX_STEP);} else if (moveWorkSpaceDto.getFrontWorkId() == null && moveWorkSpaceDto.getPostWorkId() != null) {WorkSpaceEntity postEntity = getPostEntity(moveWorkSpaceDto);sourceEntity.setSortIndex(postEntity.getSortIndex() - SORT_INDEX_STEP);} else {WorkSpaceEntity frontEntity = getFrontEntity(moveWorkSpaceDto);WorkSpaceEntity postEntity = getPostEntity(moveWorkSpaceDto);sourceEntity.setSortIndex((frontEntity.getSortIndex() + postEntity.getSortIndex()) / 2);}workSpaceRepository.save(sourceEntity);}排查后发现代码逻辑正常，于是加⽇志定位，果然在更新项⽬前多了update操作，具体位置如下：说明entity实体更新属性后，jpa⾃动执⾏了update属性，导致count判重始终⼤于0。
如何通过SpringBoot实现前后端分离的高效通信
如何通过SpringBoot实现前后端分离的高效通信Spring Boot是一个非常流行的Java应用程序框架，它可以帮助开发人员快速高效地构建基于Spring框架的生产级别的应用程序。
在当今互联网发展迅速的时代，前后端分离的架构被越来越多的公司所采用，因为它可以提高开发效率、降低系统耦合度、提升系统的灵活性和可维护性。
本文将详细介绍如何通过Spring Boot框架实现前后端分离的高效通信。
一、使用RESTful API实现前后端交互在前后端分离的架构中，前端和后端通过API进行数据交互是非常重要的。
而RESTful API是一种使用HTTP协议进行通信的API设计风格，它具有简单、灵活、易于理解和扩展的特点，非常适合用于前后端分离的架构中。
Spring Boot框架提供了丰富的功能和组件，可以帮助开发人员快速构建RESTful API，并实现前后端的高效通信。
二、使用Spring Data JPA实现数据持久化在前后端分离的架构中，数据持久化是非常重要的，而Spring Data JPA是Spring框架和JPA（Java Persistence API）的整合，它可以帮助开发人员快速、高效地实现数据持久化操作。
通过Spring Data JPA，开发人员可以使用面向对象的方式来操作数据库，而不需要编写复杂的SQL语句，极大地提高了开发效率。
同时，Spring Data JPA也提供了丰富的查询方法和功能，可以满足前后端通信中的各种数据需求。
三、使用WebSocket实现实时通信在某些场景下，前后端需要实现实时通信，比如在线聊天、实时数据展示等。
而WebSocket是一种在单个TCP连接上进行全双工通信的协议，它可以帮助前后端实现实时通信的需求。
Spring Boot框架提供了对WebSocket的支持，开发人员可以通过简单的配置和代码实现前后端的实时通信，极大地提升了系统的用户体验。
四、使用Spring Security实现安全通信在前后端分离的架构中，系统的安全性是至关重要的。