详解spring boot jpa整合QueryDSL来简化复杂操作

前言

使用过spring data jpa的同学,都很清楚,对于复杂的sql查询,处理起来还是比较复杂的,而本文中的QueryDSL就是用来简化JPA操作的。

Querydsl定义了一种常用的静态类型语法,用于在持久域模型数据之上进行查询。JDO和JPA是Querydsl的主要集成技术。本文旨在介绍如何使用Querydsl与JPA组合使用。JPA的Querydsl是JPQL和Criteria查询的替代方法。QueryDSL仅仅是一个通用的查询框架,专注于通过Java API构建类型安全的SQL查询。

要想使用QueryDSL,需要做两个前提操作:

1、pom文件中,加入依赖

<!--query dsl -->
  <dependency>
   <groupId>com.querydsl</groupId>
   <artifactId>querydsl-jpa</artifactId>
  </dependency>
  <dependency>
   <groupId>com.querydsl</groupId>
   <artifactId>querydsl-apt</artifactId>
   <scope>provided</scope>
  </dependency>

2、pom文件中,加入编译插件

<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>

该插件会查找使用javax.persistence.Entity注解的域类型,并为它们生成对应的查询类型。下面以User实体类来说明,生成的查询类型如下:

package com.chhliu.springboot.jpa.entity;
import static com.querydsl.core.types.PathMetadataFactory.*;
import com.querydsl.core.types.dsl.*;
import com.querydsl.core.types.PathMetadata;
import javax.annotation.Generated;
import com.querydsl.core.types.Path;
/**
 * QUser is a Querydsl query type for User
 */
@Generated("com.querydsl.codegen.EntitySerializer")
public class QUser extends EntityPathBase<User> {
 private static final long serialVersionUID = 1153899872L;
 public static final QUser user = new QUser("user");
 public final StringPath address = createString("address");
 public final NumberPath<Integer> age = createNumber("age", Integer.class);
 public final NumberPath<Integer> id = createNumber("id", Integer.class);
 public final StringPath name = createString("name");
 public QUser(String variable) {
  super(User.class, forVariable(variable));
 } 

 public QUser(Path<? extends User> path) {
  super(path.getType(), path.getMetadata());
 } 

 public QUser(PathMetadata metadata) {
  super(User.class, metadata);
 }
}

我们建立好实体类之后,然后运行mvn clean complie命令,就会在

<outputDirectory>target/generated-sources/java</outputDirectory> 

目录下生成对应的查询类型。然后将生成的类都拷贝到项目中,即可。

本文涉及到的Entity如下:

package com.chhliu.springboot.jpa.entity;
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="t_user")
public class User implements Serializable{
  /**
  *
  */
 private static final long serialVersionUID = 1L;
 @Id()
 @GeneratedValue(strategy = GenerationType.AUTO)
 private int id;
 private String name;
 private String address;
 private int age;
 …………省略getter,setter方法…………
 /**
  * attention:
  * Details:方便查看测试结果
  * @author chhliu
  */
 @Override
 public String toString() {
  return "User [id=" + id + ", name=" + name + ", address=" + address + ", age=" + age + "]";
 }
}

上面的这个实体类,主要用于单表操作。

package com.chhliu.springboot.jpa.entity;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;
/**
 * 描述:TODO
 * @author chhliu
 */
@Entity
@Table(name="PERSON")
public class Person {
 @Id
 @GeneratedValue
 private Integer id;
 private String name;
 private String address; 

 @OneToOne(mappedBy="person", cascade={CascadeType.PERSIST, CascadeType.REMOVE, CascadeType.MERGE})
 private IDCard idCard;
  …………省略getter,setter方法…………
 @Override
 public String toString() {
  return "Person [id=" + id + ", name=" + name + ", address=" + address + ", idCard=" + idCard + "]";
 }
} 
package com.chhliu.springboot.jpa.entity;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;
/**
 * 描述:
 * @author chhliu
 */
@Entity
@Table(name="IDCARD")
public class IDCard {
 @Id
 @GeneratedValue
 private Integer id;
 private String idNo;
 @OneToOne(cascade={CascadeType.MERGE, CascadeType.REMOVE, CascadeType.PERSIST}, fetch=FetchType.EAGER)
 private Person person;
  …………省略getter,setter方法…………
 @Override
 public String toString() {
  return "IDCard [id=" + id + ", idNo=" + idNo + ", person=" + person + "]";
 }
} 

上面两个Entity主要用于一对一关系的示例操作

package com.chhliu.springboot.jpa.entity;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
/**
 * 描述:Order实体类
 * @author chhliu
 */
@Entity
@Table(name="ORDER_C")
public class Order {
 @Id
 @GeneratedValue
 @Column(name="ID")
 private Integer id; 

 @Column(length=20, name="ORDER_NAME")
 private String orderName; 

 @Column(name="COUNT")
 private Integer count; 

 @OneToMany(mappedBy = "order",cascade={CascadeType.PERSIST,CascadeType.REMOVE},fetch = FetchType.EAGER)
 private List<OrderItem> orderItems; 

  …………省略getter,setter方法…………
}
package com.chhliu.springboot.jpa.entity;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table; 

/**
 * 描述:OrderItem实体类
 * @author chhliu
 */
@Entity
@Table(name="ORDER_ITEM")
public class OrderItem {
 @Id
 @GeneratedValue
 @Column(name="ID", nullable=false)
 private Integer id; 

 @Column(name="ITEM_NAME", length=20)
 private String itemName; 

 @Column(name="PRICE")
 private Integer price; 

 @ManyToOne(cascade={CascadeType.PERSIST,CascadeType.REMOVE, CascadeType.MERGE}, fetch=FetchType.EAGER)
 @JoinColumn(name = "ORDER_ID")
 private Order order; 

  …………省略getter,setter方法…………
}

上面两个Entity用于展示一对多关系的示例操作。

首先,我们来看单表操作

1、使用spring data jpa

要想使用spring data jpa提供的QueryDSL功能,很简单,直接继承接口即可。Spring Data JPA中提供了QueryDslPredicateExecutor接口,用于支持QueryDSL的查询操作接口,如下:

package com.chhliu.springboot.jpa.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.querydsl.QueryDslPredicateExecutor;
import com.chhliu.springboot.jpa.entity.User;
public interface UserRepositoryDls extends JpaRepository<User, Integer>, QueryDslPredicateExecutor<User>{
// 继承接口
}

QueryDslPredicateExecutor接口提供了如下方法:

public interface QueryDslPredicateExecutor<T> {
 T findOne(Predicate predicate);
 Iterable<T> findAll(Predicate predicate);
 Iterable<T> findAll(Predicate predicate, Sort sort);
 Iterable<T> findAll(Predicate predicate, OrderSpecifier<?>... orders);
 Iterable<T> findAll(OrderSpecifier<?>... orders);
 Page<T> findAll(Predicate predicate, Pageable pageable);
 long count(Predicate predicate);
 boolean exists(Predicate predicate);
}

以上方法的使用和spring data jpa中的其他接口使用方法类似,详情请参考:http://www.jb51.net/article/137757.htm

测试如下:

public User findUserByUserName(final String userName){
  /**
   * 该例是使用spring data QueryDSL实现
   */
  QUser quser = QUser.user;
  Predicate predicate = quser.name.eq(userName);// 根据用户名,查询user表
  return repository.findOne(predicate);
 }

对应的sql如下:

代码如下:

select user0_.id as id1_5_, user0_.address as address2_5_, user0_.age as age3_5_, user0_.name as name4_5_ from t_user user0_ where  user0_.name=?

单表操作示例代码如下:

package com.chhliu.springboot.jpa.repository;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import javax.transaction.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Component;
import com.chhliu.springboot.jpa.entity.QUser;
import com.chhliu.springboot.jpa.entity.User;
import com.querydsl.core.types.Predicate;
import com.querydsl.jpa.impl.JPAQueryFactory; 

/**
 * 描述:QueryDSL JPA
 * @author chhliu
 */
@Component
@Transactional
public class UserRepositoryManagerDsl {
 @Autowired
 private UserRepositoryDls repository; 

 @Autowired
 @PersistenceContext
 private EntityManager entityManager; 

  private JPAQueryFactory queryFactory; 

  @PostConstruct
  public void init() {
  queryFactory = new JPAQueryFactory(entityManager);
  } 

  public User findUserByUserName(final String userName){
  /**
   * 该例是使用spring data QueryDSL实现
   */
  QUser quser = QUser.user;
  Predicate predicate = quser.name.eq(userName);
  return repository.findOne(predicate);
 } 

 /**
  * attention:
  * Details:查询user表中的所有记录
  */
 public List<User> findAll(){
  QUser quser = QUser.user;
  return queryFactory.selectFrom(quser)
     .fetch();
 } 

 /**
  * Details:单条件查询
  */
 public User findOneByUserName(final String userName){
  QUser quser = QUser.user;
  return queryFactory.selectFrom(quser)
   .where(quser.name.eq(userName))
   .fetchOne();
 } 

 /**
  * Details:单表多条件查询
  */
 public User findOneByUserNameAndAddress(final String userName, final String address){
  QUser quser = QUser.user;
  return queryFactory.select(quser)
   .from(quser) // 上面两句代码等价与selectFrom
   .where(quser.name.eq(userName).and(quser.address.eq(address)))// 这句代码等同于where(quser.name.eq(userName), quser.address.eq(address))
   .fetchOne();
 } 

 /**
  * Details:使用join查询
  */
 public List<User> findUsersByJoin(){
  QUser quser = QUser.user;
  QUser userName = new QUser("name");
  return queryFactory.selectFrom(quser)
   .innerJoin(quser)
   .on(quser.id.intValue().eq(userName.id.intValue()))
   .fetch();
 } 

 /**
  * Details:将查询结果排序
  */
 public List<User> findUserAndOrder(){
  QUser quser = QUser.user;
  return queryFactory.selectFrom(quser)
   .orderBy(quser.id.desc())
   .fetch();
 } 

 /**
  * Details:Group By使用
  */
 public List<String> findUserByGroup(){
  QUser quser = QUser.user;
  return queryFactory.select(quser.name)
     .from(quser)
     .groupBy(quser.name)
     .fetch();
 } 

 /**
  * Details:删除用户
  */
 public long deleteUser(String userName){
  QUser quser = QUser.user;
  return queryFactory.delete(quser).where(quser.name.eq(userName)).execute();
 } 

 /**
  * Details:更新记录
  */
 public long updateUser(final User u, final String userName){
  QUser quser = QUser.user;
  return queryFactory.update(quser).where(quser.name.eq(userName))
   .set(quser.name, u.getName())
   .set(quser.age, u.getAge())
   .set(quser.address, u.getAddress())
   .execute();
 } 

 /**
  * Details:使用原生Query
  */
 public User findOneUserByOriginalSql(final String userName){
  QUser quser = QUser.user;
  Query query = queryFactory.selectFrom(quser)
    .where(quser.name.eq(userName)).createQuery();
  return (User) query.getSingleResult();
 } 

 /**
  * Details:分页查询单表
  */
 public Page<User> findAllAndPager(final int offset, final int pageSize){
  Predicate predicate = QUser.user.id.lt(10);
  Sort sort = new Sort(new Sort.Order(Sort.Direction.DESC, "id"));
  PageRequest pr = new PageRequest(offset, pageSize, sort);
  return repository.findAll(predicate, pr);
 }
}

多表操作示例(一对一)如下:

package com.chhliu.springboot.jpa.repository;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.chhliu.springboot.jpa.dto.PersonIDCardDto;
import com.chhliu.springboot.jpa.entity.QIDCard;
import com.chhliu.springboot.jpa.entity.QPerson;
import com.querydsl.core.QueryResults;
import com.querydsl.core.Tuple;
import com.querydsl.core.types.Predicate;
import com.querydsl.jpa.impl.JPAQuery;
import com.querydsl.jpa.impl.JPAQueryFactory; 

@Component
public class PersonAndIDCardManager {
 @Autowired
 @PersistenceContext
 private EntityManager entityManager; 

 private JPAQueryFactory queryFactory; 

 @PostConstruct
 public void init() {
  queryFactory = new JPAQueryFactory(entityManager);
 } 

 /**
  * Details:多表动态查询
  */
 public List<Tuple> findAllPersonAndIdCard(){
  Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  JPAQuery<Tuple> jpaQuery = queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)
    .from(QIDCard.iDCard, QPerson.person)
    .where(predicate);
  return jpaQuery.fetch();
 } 

 /**
  * Details:将查询结果以DTO的方式输出
  */
 public List<PersonIDCardDto> findByDTO(){
  Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  JPAQuery<Tuple> jpaQuery = queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)
    .from(QIDCard.iDCard, QPerson.person)
    .where(predicate);
  List<Tuple> tuples = jpaQuery.fetch();
  List<PersonIDCardDto> dtos = new ArrayList<PersonIDCardDto>();
  if(null != tuples && !tuples.isEmpty()){
   for(Tuple tuple:tuples){
    String address = tuple.get(QPerson.person.address);
    String name = tuple.get(QPerson.person.name);
    String idCard = tuple.get(QIDCard.iDCard.idNo);
    PersonIDCardDto dto = new PersonIDCardDto();
    dto.setAddress(address);
    dto.setIdNo(idCard);
    dto.setName(name);
    dtos.add(dto);
   }
  }
  return dtos;
 } 

 /**
  * Details:多表动态查询,并分页
  */
 public QueryResults<Tuple> findByDtoAndPager(int offset, int pageSize){
  Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  return queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)
    .from(QIDCard.iDCard, QPerson.person)
    .where(predicate)
    .offset(offset)
    .limit(pageSize)
    .fetchResults();
 }
}

上面将查询结果以DTO的方式输出的示例中,在查询结束后,将查询结果手动的转换成了DTO对象,这种方式其实不太优雅,QueryDSL给我们提供了更好的方式,见下面的示例:

/**
  * Details:方式一:使用Bean投影
  */
 public List<PersonIDCardDto> findByDTOUseBean(){
  Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  return queryFactory.select(
    Projections.bean(PersonIDCardDto.class, QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name))
    .from(QIDCard.iDCard, QPerson.person)
    .where(predicate)
    .fetch();
 } 

 /**
  * Details:方式二:使用fields来代替setter
  */
 public List<PersonIDCardDto> findByDTOUseFields(){
  Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  return queryFactory.select(
    Projections.fields(PersonIDCardDto.class, QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name))
    .from(QIDCard.iDCard, QPerson.person)
    .where(predicate)
    .fetch();
 } 

 /**
  * Details:方式三:使用构造方法,注意构造方法中属性的顺序必须和构造器中的顺序一致
  */
 public List<PersonIDCardDto> findByDTOUseConstructor(){
  Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  return queryFactory.select(
    Projections.constructor(PersonIDCardDto.class, QPerson.person.name, QPerson.person.address, QIDCard.iDCard.idNo))
    .from(QIDCard.iDCard, QPerson.person)
    .where(predicate)
    .fetch();
 }

上面只是提供了几种思路,当然,还可以使用@QueryProjection来实现,非常灵活。

一对多示例:

package com.chhliu.springboot.jpa.repository;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.chhliu.springboot.jpa.entity.QOrder;
import com.chhliu.springboot.jpa.entity.QOrderItem;
import com.querydsl.core.Tuple;
import com.querydsl.core.types.Predicate;
import com.querydsl.jpa.impl.JPAQuery;
import com.querydsl.jpa.impl.JPAQueryFactory;
@Component
public class OrderAndOrderItemManager { 

 @Autowired
 @PersistenceContext
 private EntityManager entityManager; 

 private JPAQueryFactory queryFactory; 

 @PostConstruct
 public void init() {
  queryFactory = new JPAQueryFactory(entityManager);
 } 

 /**
  * Details:一对多,条件查询
  */
 public List<Tuple> findOrderAndOrderItemByOrderName(String orderName){
  //添加查询条件
  Predicate predicate = QOrder.order.orderName.eq(orderName);
  JPAQuery<Tuple> jpaQuery = queryFactory.select(QOrder.order, QOrderItem.orderItem)
          .from(QOrder.order, QOrderItem.orderItem)
          .where(QOrderItem.orderItem.order.id.intValue().eq(QOrder.order.id.intValue()), predicate); 

  //拿到结果
  return jpaQuery.fetch();
 } 

 /**
  * Details:多表连接查询
  */
 public List<Tuple> findAllByOrderName(String orderName){
  //添加查询条件
  Predicate predicate = QOrder.order.orderName.eq(orderName);
  JPAQuery<Tuple> jpaQuery = queryFactory.select(QOrder.order, QOrderItem.orderItem)
          .from(QOrder.order, QOrderItem.orderItem)
          .rightJoin(QOrder.order)
          .on(QOrderItem.orderItem.order.id.intValue().eq(QOrder.order.id.intValue()));
  jpaQuery.where(predicate);
  //拿到结果
  return jpaQuery.fetch();
 }
}

从上面的示例中,我们可以看出,QueryDSL大大的简化了我们的操作

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

您可能感兴趣的文章:

  • Spring Boot中使用Spring-data-jpa实现数据库增删查改
  • SpringBoot集成Spring Data JPA及读写分离
  • SpringBoot JPA 表关联查询实例
  • SpringBoot JPA实现增删改查、分页、排序、事务操作等功能示例
  • Spring Boot + Jpa(Hibernate) 架构基本配置详解
  • 详解基于Spring Boot与Spring Data JPA的多数据源配置
  • 基于spring boot 1.5.4 集成 jpa+hibernate+jdbcTemplate(详解)
  • Spring Boot 添加MySQL数据库及JPA实例
  • 在Spring Boot中使用Spring-data-jpa实现分页查询
(0)

相关推荐

  • SpringBoot JPA 表关联查询实例

    今天给大家介绍一下如何利用JPA实现表关联查询. 今天给大家举一个一对多的关联查询,并且是使用JPA原生的findBy语句实现的. 例子中总共有两个实体类,一个是Floor(商品楼层类),另一个是FloorContent(商品楼层内容表).下面看两张表的源代码: Floor类: package cms.model; import cms.model.base.BaseDomain; import org.hibernate.annotations.GenericGenerator; import

  • Spring Boot + Jpa(Hibernate) 架构基本配置详解

    1.基于springboot-1.4.0.RELEASE版本测试 2.springBoot + hibernate + Druid + MySQL + servlet(jsp) 不废话,直接上代码 一.maven的pom文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi=&qu

  • Spring Boot中使用Spring-data-jpa实现数据库增删查改

    在实际开发过程中,对数据库的操作无非就"增删改查".就最为普遍的单表操作而言,除了表和字段不同外,语句都是类似的,开发人员需要写大量类似而枯燥的语句来完成业务逻辑. 为了解决这些大量枯燥的数据操作语句,我们第一个想到的是使用ORM框架,比如:Hibernate.通过整合Hibernate之后,我们以操作Java实体的方式最终将数据改变映射到数据库表中. 为了解决抽象各个Java实体基本的"增删改查"操作,我们通常会以泛型的方式封装一个模板Dao来进行抽象简化,但是这

  • SpringBoot JPA实现增删改查、分页、排序、事务操作等功能示例

    今天给大家介绍一下SpringBoot中JPA的一些常用操作,例如:增删改查.分页.排序.事务操作等功能. 下面先来介绍一下JPA中一些常用的查询操作: //And --- 等价于 SQL 中的 and 关键字,比如 findByHeightAndSex(int height,char sex): public List<User> findByHeightAndSex(int height,char sex); // Or --- 等价于 SQL 中的 or 关键字,比如 findByHei

  • Spring Boot 添加MySQL数据库及JPA实例

    最近在学习Spring Boot,继续前面的学习,这一次我们加入MySQL数据库和JPA. 配置: pom.xml文件 <!-- 添加Mysql和JPA--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dep

  • 在Spring Boot中使用Spring-data-jpa实现分页查询

    在我们平时的工作中,查询列表在我们的系统中基本随处可见,那么我们如何使用jpa进行多条件查询以及查询列表分页呢?下面我将介绍两种多条件查询方式. 1.引入起步依赖   <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency&

  • 详解基于Spring Boot与Spring Data JPA的多数据源配置

    由于项目需要,最近研究了一下基于spring Boot与Spring Data JPA的多数据源配置问题.以下是传统的单数据源配置代码.这里使用的是Spring的Annotation在代码内部直接配置的方式,没有使用任何XML文件. @Configuration @EnableJpaRepositories(basePackages = "org.lyndon.repository") @EnableTransactionManagement @PropertySource("

  • SpringBoot集成Spring Data JPA及读写分离

    相关代码: github OSCchina JPA是什么 JPA(Java Persistence API)是Sun官方提出的Java持久化规范,它为Java开发人员提供了一种对象/关联映射工具 来管理Java应用中的关系数据.它包括以下几方面的内容: 1.ORM映射 支持xml和注解方式建立实体与表之间的映射. 2.Java持久化API 定义了一些常用的CRUD接口,我们只需直接调用,而不需要考虑底层JDBC和SQL的细节. 3.JPQL查询语言 这是持久化操作中很重要的一个方面,通过面向对象

  • 基于spring boot 1.5.4 集成 jpa+hibernate+jdbcTemplate(详解)

    1.pom添加依赖 <!-- spring data jpa,会注入tomcat jdbc pool/hibernate等 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <

  • 详解spring boot jpa整合QueryDSL来简化复杂操作

    前言 使用过spring data jpa的同学,都很清楚,对于复杂的sql查询,处理起来还是比较复杂的,而本文中的QueryDSL就是用来简化JPA操作的. Querydsl定义了一种常用的静态类型语法,用于在持久域模型数据之上进行查询.JDO和JPA是Querydsl的主要集成技术.本文旨在介绍如何使用Querydsl与JPA组合使用.JPA的Querydsl是JPQL和Criteria查询的替代方法.QueryDSL仅仅是一个通用的查询框架,专注于通过Java API构建类型安全的SQL查

  • 详解Spring Boot中整合Sharding-JDBC读写分离示例

    在我<Spring Cloud微服务-全栈技术与案例解析>书中,第18章节分库分表解决方案里有对Sharding-JDBC的使用进行详细的讲解. 之前是通过XML方式来配置数据源,读写分离策略,分库分表策略等,之前有朋友也问过我,有没有Spring Boot的方式来配置,既然已经用Spring Boot还用XML来配置感觉有点不协调. 其实吧我个人觉得只要能用,方便看,看的懂就行了,mybatis的SQL不也是写在XML中嘛. 今天就给大家介绍下Spring Boot方式的使用,主要讲解读写分

  • 详解Spring Boot中使用Flyway来管理数据库版本

    如果没有读过上面内容的读者,有兴趣的可以一阅.在上面的使用JdbcTemplate一文中,主要通过spring提供的JdbcTemplate实现对用户表的增删改查操作.在实现这个例子的时候,我们事先在MySQL中创建了用户表.创建表的过程我们在实际开发系统的时候会经常使用,但是一直有一个问题存在,由于一个系统的程序版本通过git得到了很好的版本控制,而数据库结构并没有,即使我们通过Git进行了语句的版本化,那么在各个环境的数据库中如何做好版本管理呢?下面我们就通过本文来学习一下在Spring B

  • 详解spring boot starter redis配置文件

    spring-boot-starter-Redis主要是通过配置RedisConnectionFactory中的相关参数去实现连接redis service. RedisConnectionFactory是一个接口,有如下4个具体的实现类,我们通常使用的是JedisConnectionFactory. 在spring boot的配置文件中redis的基本配置如下: # Redis服务器地址 spring.redis.host=192.168.0.58 # Redis服务器连接端口 spring.

  • 实例详解Spring Boot实战之Redis缓存登录验证码

    本章简单介绍redis的配置及使用方法,本文示例代码在前面代码的基础上进行修改添加,实现了使用redis进行缓存验证码,以及校验验证码的过程. 1.添加依赖库(添加redis库,以及第三方的验证码库) <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-redis</artifactId> </dependency&

  • 详解Spring boot Admin 使用eureka监控服务

    前言 最近刚好有空,来学习一下如何搭建spring boot admin环境.其中遇到很多的坑. 网上大多都是使用admin-url的方式直接来监控的,感觉一点也不灵活,这不是我想要的结果,所以本篇介绍借助eureka服务注册和发现功能来灵活监控程序. 本文主要记录spring boot admin的搭建过程,希望能有所帮助.其实非常的简单,不要被使用常规方式的误导! 环境介绍 IDE:intellij idea jdk: java8 maven:3.3.9 spring boot:1.5.6

  • 详解spring boot rest例子

    简介:本文将帮助您使用 Spring Boot 创建简单的 REST 服务. 你将学习 什么是 REST 服务? 如何使用 Spring Initializr 引导创建 Rest 服务应用程序? 如何创建获取 REST 服务以检索学生注册的课程? 如何为学生注册课程创建 Post REST 服务? 如何利用 postman 执行 rest 服务? 本教程使用的 rest 服务 在本教程中,我们将使用适当的 URI 和 HTTP 方法创建三个服务: @GetMapping("/ students

  • 详解Spring与Mybatis整合方法(基于IDEA中的Maven整合)

    项目结构 项目路径可以自己定义,只要路径映射正确就可以 pom.xml <properties> <spring.version>5.1.5.RELEASE</spring.version> <mybatis.version>3.4.6</mybatis.version> <log4j.version>1.2.17</log4j.version> </properties> <dependencies&g

  • 详解Spring Boot 中实现定时任务的两种方式

    在 Spring + SpringMVC 环境中,一般来说,要实现定时任务,我们有两中方案,一种是使用 Spring 自带的定时任务处理器 @Scheduled 注解,另一种就是使用第三方框架 Quartz ,Spring Boot 源自 Spring+SpringMVC ,因此天然具备这两个 Spring 中的定时任务实现策略,当然也支持 Quartz,本文我们就来看下 Spring Boot 中两种定时任务的实现方式. @Scheduled 使用 @Scheduled 非常容易,直接创建一个

  • 详解spring cloud config整合gitlab搭建分布式的配置中心

    在前面的博客中,我们都是将配置文件放在各自的服务中,但是这样做有一个缺点,一旦配置修改了,那么我们就必须停机,然后修改配置文件后再进行上线,服务少的话,这样做还无可厚非,但是如果是成百上千的服务了,这个时候,就需要用到分布式的配置管理了.而spring cloud config正是用来解决这个问题而生的.下面就结合gitlab来实现分布式配置中心的搭建.spring cloud config配置中心由server端和client端组成, 前提:在gitlab中的工程下新建一个配置文件config

随机推荐

其他