SpringBoot整合SpringDataJPA,不用写SQ语句
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实现安全通信在前后端分离的架构中,系统的安全性是至关重要的。
springboot多数据源的实现(最简单的整合方式)
springboot多数据源的实现(最简单的整合⽅式)简介相信⼤家有配置过多数据源,或者即将配置多数据的朋友们,会发现⽹上⼤概有以下⼏种⽅案:1. 使⽤ AOP 切⽚进⾏动态数据源切换2. 使⽤ MapperScan 的 basePackages 配置不同的 mapper ⽬录以及 template3. 数据库代理中间件这两种⽅式都能实现多数据源但是各有缺点:1. ⽆法实现多数据源 XA 事物(全局事物管理 |JTA)这个缺点⾮常致命,配了多数据源但是没有全局事物那有什么⽤纯属坑爹,⽹上还有很多帖⼦教程使⽤这种虽然配置稍微简单但是如果你要⽤到全局事物根本没有⽤。
2. 这种⽅式是可以结合 JTA 实现全局事物,⽬前本⼈在业务中也采⽤这种⽅式在线上跑,经过多次调试以及线上运维有⼀点问题不可置疑就是⿇烦!你会遇到需要整合 druid 连接池,还有全局事物如果你找⽹上帖⼦跟着流程⾛配完多多少少可能还是有些⼩问题。
3. 数据源代理可能是很好的⼀种⽅式,⼤多巨头公司都是采⽤这种⽅式,⽽且开发业务⼈员不⽤再考虑这些问题,使⽤代理进⾏切割以及连接池等都能实现,但是有⼀个很尴尬的问题就是开源的不好⽤,因为很多不适合⾃⾝的业务,⽽且⾃⼰开发也不现实成本过⾼。
这时候我在考虑⼀个问题,为什么不可以像其他语⾔框架⼀样直接引⼊⼀个依赖在 yml ⽂件中配置就可以了呢,所有就有了现在的最简⽅案。
源码地址开始版本:springboot:2.0+引⼊依赖:Maven<dependency><groupId>com.louislivi.fastdep</groupId><artifactId>fastdep-datasource</artifactId><version>1.0.0</version></dependency>Gradlecompile group: 'com.louislivi.fastdep', name: 'fastdep-datasource', version: '1.0.0'application.yml 配置⽂件:fastdep:datasource:test: #数据源名称可随意取mapper: com.louislivi.fastdep.test.mapper.test #当前数据源对应的mapper⽬录不能多个数据源相同password: 123456url: jdbc:mysql://127.0.0.1:3306/douyin?serverTimezone=Asia/Chongqing&useLegacyDatetimeCode=false&nullNamePatternMatchesAll=true&zeroDateTimeBehavior=CONVERT_TO_NULL&tinyInt1isBit=false&autoReconnect=true&useSSL=false&pinGlobalT driverClassName: com.mysql.cj.jdbc.Driverusername: root# # 下⾯为druid连接池的补充设置# initialSize: 10# minIdle: 5# maxActive: 100# connectionInitSqls: 'set names utf8mb4;'test2: #数据源名称可随意取mapper: com.louislivi.fastdep.test.mapper.test2 #当前数据源对应的mapper⽬录不能多个数据源相同password: 123456url: jdbc:mysql://127.0.0.1:3306/test2?serverTimezone=Asia/Chongqing&useLegacyDatetimeCode=false&nullNamePatternMatchesAll=true&zeroDateTimeBehavior=CONVERT_TO_NULL&tinyInt1isBit=false&autoReconnect=true&useSSL=false&pinGlobalTxT driverClassName: com.mysql.cj.jdbc.Driverusername: root# # 下⾯为druid连接池的补充设置# initialSize: 10# minIdle: 5# maxActive: 100# connectionInitSqls: 'set names utf8mb4;'这就结束了?没错就是这么简单。
jparepository接口用法 -回复
jparepository接口用法-回复使用JpaRepository接口是一种方便快捷的方式来简化与数据库交互的操作。
在本文中,我们将探讨JpaRepository接口的用法,并逐步回答相关问题。
JpaRepository是Spring Data JPA 提供的一个通用接口,它继承自PagingAndSortingRepository和CrudRepository接口。
JpaRepository接口提供了一组简化的数据访问方法,可以用来执行常见的数据库操作,如增加、删除、更新和查询数据。
通过继承这个接口,我们可以轻松地完成对数据库的操作,而无需编写复杂的SQL语句。
首先,我们需要在项目的pom.xml文件中添加Spring Data JPA的依赖。
在<dependencies>标签下添加以下代码:<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency>接下来,我们需要创建一个继承自JpaRepository的Repository接口。
如果我们有一个名为User的实体类,我们可以创建一个名为UserRepository的接口,如下所示:@Repositorypublic interface UserRepository extends JpaRepository<User, Long> {}在上述代码中,@Repository注解用于标识这个接口为一个仓库(Repository)组件。
JpaRepository的泛型参数分别是实体类和主键类型(此处假设User的主键类型为Long)。
通过继承JpaRepository接口,我们不仅可以获得通用的数据访问方法,还可以使用一些特定的查询方法。
SpringBoot中使用SpringDataJPA
SpringBoot中使⽤SpringDataJPASpringDataJPA的使⽤JPA是什么?JPA(Java Persistence API)是Sun官⽅提出的Java持久化规范. 为Java开发⼈员提供了⼀种对象/关联映射⼯具来管理Java应⽤中的关系数据.它的出现是为了简化现有的持久化开发⼯作和整合ORM技术. 结束各个ORM框架各⾃为营的局⾯.JPA仅仅是⼀套规范,不是⼀套产品, 也就是说Hibernate, TopLink等是实现了JPA规范的⼀套产品.Spring Data JPASpring Data JPA是Spring基于ORM框架、JPA规范的基础上封装的⼀套JPA应⽤框架,是基于Hibernate之上构建的JPA使⽤解决⽅案,⽤极简的代码实现了对数据库的访问和操作,包括了增、删、改、查等在内的常⽤功能.实践1. 引⼊依赖<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency>2. 添加配置⽂件spring:datasource:driver-class-name: com.mysql.cj.jdbc.Driverurl: jdbc:mysql://39.105.167.131:3306/smile_boot?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=trueusername: rootpassword: Nrblwbb7$jpa:properties:hibernate:hbm2ddl:auto: createdialect: org.hibernate.dialect.MySQL5InnoDBDialectformat_sql: trueshow-sql: truehibernate.hbm2ddl.auto 参数的作⽤主要⽤于:⾃动创建、更新、验证数据库表结构,有四个值。
SpringBoot整合JPA数据源方法及配置解析
SpringBoot整合JPA数据源⽅法及配置解析⼀、创建项⽬并导⼊依赖<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId><version>1.1.10</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope><version>5.1.27</version></dependency>⼆、相关配置Application.proteriesspring.datasource.one.type=com.alibaba.druid.pool.DruidDataSourceername=rootspring.datasource.one.password=123spring.datasource.one.url=jdbc:mysql://127.0.0.1:3306/jpa?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=GMT spring.datasource.two.type=com.alibaba.druid.pool.DruidDataSourceername=rootspring.datasource.two.password=123spring.datasource.two.url=jdbc:mysql://127.0.0.1:3306/jpa2?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=GMT spring.jpa.properties.show-sql=truespring.jpa.properties.database=mysqlspring.jpa.properties.database-platform=mysqlspring.jpa.properties.hibernate.ddl-auto=updatespring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL57DialectDataSourceConfig.class注:必须指定⼀个@PrimaryJpaConfigOne.class@Primary表⽰当某⼀个类存在多个实例时,优先使⽤哪个实例。
springboot整合JPA过程解析
springboot整合JPA过程解析这篇⽂章主要介绍了springboot整合JPA过程解析,⽂中通过⽰例代码介绍的⾮常详细,对⼤家的学习或者⼯作具有⼀定的参考学习价值,需要的朋友可以参考下接下来具体看看是怎么弄的。
1、新建⼀个springboot项⽬,选择web、data jdbc、data jpa、mysql driver。
2、建⽴以下⽬录及结构:pom.xml<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance" xsi:schemaLocation="/POM/4.0.0 https:///xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.2.4.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.gong</groupId><artifactId>springbootjpa</artifactId><version>0.0.1-SNAPSHOT</version><name>springbootjpa</name><description>Demo project for Spring Boot</description><properties><java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jdbc</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.41</version><scope>runtime</scope></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></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>3、在application.yml中配置连接数据库和jpa相关配置spring:datasource:url: jdbc:mysql://192.168.124.22:3306/jpausername: rootpassword: 123456driver-class-name: com.mysql.jdbc.Driverjpa:hibernate:#更新或者创建数据表结构ddl-auto: update#控制台显⽰SQLshow-sql: true4、新建⼀个entity包,新建实体类User.javapackage com.gong.springbootjpa.entity;import com.fasterxml.jackson.annotation.JsonIgnoreProperties;import javax.persistence.*;//使⽤JPA注解配置映射关系@Entity //告诉JPA这是⼀个实体类(和数据表映射的类)@Table(name = "tbl_user") //@Table来指定和哪个数据表对应;如果省略默认表名就是user;@JsonIgnoreProperties(value = {"hibernateLazyInitializer","handler"})public class User {@Id //这是⼀个主键@GeneratedValue(strategy = GenerationType.IDENTITY)//⾃增主键private Integer id;@Column(name = "last_name",length = 50) //这是和数据表对应的⼀个列private String lastName;@Column //省略默认列名就是属性名private String email;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getLastName() {return lastName;}public void setLastName(String lastName) {stName = lastName;}public String getEmail() {return email;}public void setEmail(String email) {this.email = email;}}5、新建⼀个repository包,新建⼀个UserRepository.javapackage com.gong.springbootjpa.repository;import er;import org.springframework.data.jpa.repository.JpaRepository;//继承JpaRepository来完成对数据库的操作,在JdbcRepository中指定实体类,数据库中主键对应的java类型public interface UserRepository extends JpaRepository<User,Integer> {}6、新建⼀个controller包,新建⼀个UserController.java经过上述配置之后,我们就可以直接利⽤UserRepository中的⼀些⽅法进⾏数据库的操作啦,是不是很⽅便。
SpringDataJPA的基本用法
SpringDataJPA的基本⽤法Spring Data JPA 介绍JPA 是 Java Persistence API 的简称,中⽂名为 Java 持久层 API。
可以理解为 JPA 规范的再次封装抽象,底层还是使⽤了 Hibernate 的 JPA 技术实现,引⽤ JPQL(Java Persistence Query Language)查询语⾔,属于 Spring 整个⽣态体系的⼀部分。
简单⽰例1. 导⼊依赖<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><!-- 使⽤嵌⼊式 H2 数据库 --><dependency><groupId>com.h2database</groupId><artifactId>h2</artifactId><scope>runtime</scope></dependency>2、创建实体类@Data@Entitypublic class Book {@Id@GeneratedValue(strategy = GenerationType.AUTO)private Long id;private String reader;private String isbn;private String title;private String author;private String description;}注解 @Data 出⾃依赖 lombok ,它会⾃动⽣成 setting/getting ⽅法。
SpringBoot+Jpa动态切换多数据源配置及实现
SpringBoot+Jpa动态切换多数据源配置及实现数据源配置⽂件:conf.propertiesspring.datasource.primary.key=huituspring.datasource.primary.type=com.alibaba.druid.pool.DruidDataSourcespring.datasource.primary.driverClassName=com.mysql.jdbc.Driverspring.datasource.primary.url=jdbc:mysql://:3306/tuoying?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false ername=rootspring.datasource.primary.password=tuoying678spring.datasource.secondary.key=dzzwspring.datasource.secondary.type=com.alibaba.druid.pool.DruidDataSourcespring.datasource.secondary.driverClassName=com.mysql.jdbc.Driverspring.datasource.secondary.url=jdbc:mysql://192.168.0.18:3306/dzzw?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false ername=rootspring.datasource.secondary.password=123456spring.datasource.skdd.key=skddspring.datasource.skdd.type=com.alibaba.druid.pool.DruidDataSourcespring.datasource.skdd.driverClassName=com.mysql.jdbc.Driverspring.datasource.skdd.url=jdbc:mysql://192.168.0.18:3306/skdd?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false ername=rootspring.datasource.skdd.password=123456创建包prop,该包下放多数据源的注册类,配置类和⾃定义注解类⾃定义注解类:DSpackage com.codecat.portal.prop;import ng.annotation.*;/*** 1* ⾃定义注解:DS*/@Documented@Retention(RetentionPolicy.RUNTIME)@Target({ElementType.METHOD})@Inheritedpublic @interface DS {String value() default "huitu";}数据源信息类:DynamicDataSourceContextHolderpackage com.codecat.portal.prop;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.util.ArrayList;import java.util.List;/*** 创建存储数据源信息的类,并⾃定义实现AbstractRoutingDataSource*/public class DynamicDataSourceContextHolder {private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);/** 当使⽤ThreadLocal维护变量时,ThreadLocal为每个使⽤该变量的线程提供独⽴的变量副本,* 所以每⼀个线程都可以独⽴地改变⾃⼰的副本,⽽不会影响其它线程所对应的副本。
springboot集成mybatis控制打印sql语句,不打印执行结果集
springboot集成mybatis控制打印sql语句,不打印执⾏结果集解决办法mapper 包⽇志级别设置为DEBUG原因:Mybatis是⽤Mapper类的全路径名,作为logger的名称的。
Mybatis中,打印SQL语句的⽇志级别是DEBUG,⽽打印SQL执⾏结果集的⽇志级别是TRACE。
下边是笔者的打印⽇志1 [INFO ] [17:47:14] com.fx.interceptors.ScreenHostInterceptor.preHandle - Request Method Is:public ng.Object com.fx.controller.LoginController.showCurrentUser(javax.servlet.http.HttpServletRequest)2 [INFO ] [17:47:14] com.fx.interceptors.ScreenHostInterceptor.preHandle - The Request Method Is:GET3[DEBUG] [17:47:18] com.fx.mapper.MyTestMapper.findAll.debug - ==> Preparing: select * from my_test;4[DEBUG] [17:47:19] com.fx.mapper.MyTestMapper.findAll.debug - ==> Parameters:5[TRACE] [17:47:19] com.fx.mapper.MyTestMapper.findAll.trace - <== Columns: id, name, age, gender6[TRACE] [17:47:19] com.fx.mapper.MyTestMapper.findAll.trace - <== Row: 1, 测试事务mybatis, null, male7[TRACE] [17:47:19] com.fx.mapper.MyTestMapper.findAll.trace - <== Row: 2, 测试事务jpa, null, female8[TRACE] [17:47:19] com.fx.mapper.MyTestMapper.findAll.trace - <== Row: 4, tom, 4, male9[TRACE] [17:47:19] com.fx.mapper.MyTestMapper.findAll.trace - <== Row: 5, hony, 5, male10[DEBUG] [17:47:19] com.fx.mapper.MyTestMapper.findAll.debug - <== Total: 4第3,4⾏为DEBUG级别⽇志 6到10⾏为TRACE级别⽇志⽐如mapper类所在包名为com.fx.mapper如果只是想输出sql语句则在log4j.properties⽂件⾥配置.fx.mapper=DEBUG如果既需要打印sql语句也需要打印sql执⾏结果集则修改⽇志级别为TRACE.fx.mapper=TRACE参考资源。
SpringBoot集成JPA用法笔记
SpringBoot集成JPA用法笔记今天给大家整理SpringBoot集成JPA用法。
希望对大家能有所帮助!1.搭建SpringBoot项目2.新建配置文件 application.yml•••••••••••••••••••••server:port: 8090spring:#通用的数据源配置datasource:driverClassName: com.mysql.jdbc.Driverurl: jdbc:mysql://localhost:3306/test?useSSL=false&useUnicode=tru e&characterEncoding=utf8username: rootpassword: rootjpa:#将默认的存储引擎切换为InnoDB database-platform: org.hibernate.dialect.MySQL5InnoDBDialect#配置在日志中打印出执行的 SQL 语句信息。
show-sql: true hibernate:#配置指明在程序启动的时候要删除并且创建实体类对应的表# validate 加载Hibernate 时,验证创建数据库表结构# create 每次加载Hibernate ,重新创建数据库表结构,这就是导致数据库表数据丢失的原因。
# create-drop 加载 Hibernate 时创建,退出是删除表结构(退出是指退出sessionFactory) # update 加载 Hibernate 自动更新数据库结构 # none 不启用 ddl-auto: none3、新建用户实体类 UserInfoDAO.java•••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••package my.springboot.jpa.entity;import javax.persistence.*;import java.util.Date;/** * 用户表实体***/@Entity@Table(name = "userinfo")public class UserInfoDAO {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Integer id;@Column private String userName;@Column private Integer age;@Column(length = 500)private String address;@Column(name = "create_date")private Date createDate;@Column(name = "create_user")private String createUser;public Integer getId() {return id; }public void setId(Integer id) {this.id = id; }public String getUserName() {return userName; }public void setUserName(String userName) {erName = userName; }public Integer getAge() {return age; }public void setAge(Integer age) {this.age = age; }public String getAddress() {return address; }public void setAddress(String address) {this.address = address; }public Date getCreateDate() {return createDate; }public void setCreateDate(Date createDate) {this.createDate = createDate; }public String getCreateUser() {return createUser; }public void setCreateUser(String createUser) {this.createUser = createUser; }}4、仓库接口类 UserIfoRepository••••••••••package my.springboot.jpa.dao;import erInfoDAO;importorg.springframework.data.jpa.repository.JpaRepository;import org.springframework.stereotype.Repository;/** * 仓库接口类UserIfoRepository **/@Repository public interface UserIfoRepository extends JpaRepository<UserInfoDAO, Integer> {}5、新建测试用户类 UserInfoTest.java••••••••••••••••••••••••••••••••••••••••••••••••••••••••package my.springboot.jpa;import erIfoRepository;import erInfoDAO;importorg.junit.T est;import org.junit.runner.RunWith;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.boot.test.context.SpringBootTest;import org.springframework.test.context.junit4.SpringRunner;import java.util.Date;import java.util.List;import java.util.Optional;/** * 测试UserInfo用法**/@RunWith(SpringRunner.class)@SpringBootT est public class UserInfoTest {@Autowired UserIfoRepository userIfoRepository;@Test public void test() {//插入用户测试 UserInfoDAO dao = new UserInfoDAO(); dao.setUserName("小明"); dao.setAge(32); dao.setCreateDate(new Date()); dao.setCreateUser("管理员"); dao.setAddress("苏州");userIfoRepository.save(dao); UserInfoDAO dao2 = newUserInfoDAO(); dao2.setUserName("小张"); dao2.setAge(35); dao2.setCreateDate(new Date()); dao2.setCreateUser("管理员"); dao2.setAddress("南京");userIfoRepository.save(dao2);// 查询多条记录打印List<UserInfoDAO> list = userIfoRepository.findAll();for (UserInfoDAO item : list) {System.out.println("姓名:" + item.getUserName() + " 年龄:" + item.getAge()); }// 查询单个记录Optional<UserInfoDAO> mo = userIfoRepository.findById(2); System.out.println(mo.get().getUserName());//更新操作mo.get().setUserName("小明123");userIfoRepository.save(mo.get());System.out.println(mo.get().getUserName());//删除记录userIfoRepository.delete(mo.get()); }}6、配置生成数据表••••••••••••••••••••package my.springboot.jpa;import org.springframework.boot.SpringApplication;importorg.springframework.boot.autoconfigure.SpringBootApplication ;importorg.springframework.boot.autoconfigure.domain.EntityScan;imp ortorg.springframework.data.jpa.repository.config.EnableJpaReposi tories;@SpringBootApplication@EntityScan(basePackages = {"my.springboot.jpa.entity"})@EnableJpaRepositories(basePacka ges = {"my.springboot.jpa.dao"})public class JpaApplication {public static void main(String[] args) { SpringApplication.run(JpaApplication.class, args); }}@EntityScan(basePackages = {"my.springboot.jpa.entity"})@EnableJpaRepositories(basePacka ges = {"my.springboot.jpa.dao"})7、项目结构图IT技术分享社区个人博客网站:。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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 #无参构造的注解
欢迎大家一起交流学习...。