欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

springData使用QueryDsl的示例代码

程序员文章站 2024-02-24 09:41:10
经过多年,spring data jpa越来越完善,在版本迭代的过程中,会不断增加功能,今天看新的reference发现有querydsl.然后搜索到上面的参考资料2...

经过多年,spring data jpa越来越完善,在版本迭代的过程中,会不断增加功能,今天看新的reference发现有querydsl.然后搜索到上面的参考资料2

无论是jpaspecificationexecutor,还是querydslpredicateexecutor,它俩都提供了使用predicate(意义相同,都是构建where子句;类不同,javax.persistence.criteria.predicate,com.querydsl.core.types.predicate)去构建查询,使用比较方便.

关于两者的简单使用,上面的参考资料2有介绍.文末也有总结,从概括来看,我个人认为应倾向使用querydslpredicateexecutor,querydsl不仅适用于jpa repositories,还支持mongodb.

下面是个例子

1.pom.xml

<project xmlns="http://maven.apache.org/pom/4.0.0" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
     xsi:schemalocation="http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelversion>4.0.0</modelversion>
  <groupid>org.exam</groupid>
  <artifactid>testjava</artifactid>
  <version>1.0.0</version>
  <name>${project.artifactid}</name>
  <properties>
    <project.build.sourceencoding>utf-8</project.build.sourceencoding>
    <project.reporting.outputencoding>utf-8</project.reporting.outputencoding>
    <java.version>1.8</java.version>
    <spring.version>4.2.5.release</spring.version>
    <spring-data.version>hopper-sr1</spring-data.version>
    <querydsl.version>4.1.1</querydsl.version>
    <hibernate.version>5.1.0.final</hibernate.version>
    <tomcat.version>8.0.32</tomcat.version>
    <logback.version>1.1.7</logback.version>
    <mysql.version>5.1.33</mysql.version>
    <junit.version>4.12</junit.version>
  </properties>
  <dependencymanagement>
    <dependencies>
      <dependency>
        <groupid>org.springframework</groupid>
        <artifactid>spring-framework-bom</artifactid>
        <version>${spring.version}</version>
        <scope>import</scope>
        <type>pom</type>
      </dependency>
      <dependency>
        <groupid>org.springframework.data</groupid>
        <artifactid>spring-data-releasetrain</artifactid>
        <version>${spring-data.version}</version>
        <scope>import</scope>
        <type>pom</type>
      </dependency>
    </dependencies>
  </dependencymanagement>
  <build>
    <plugins>
      <plugin>
        <groupid>org.apache.maven.plugins</groupid>
        <artifactid>maven-compiler-plugin</artifactid>
        <version>3.1</version>
        <configuration>
          <source>${java.version}</source>
          <target>${java.version}</target>
        </configuration>
      </plugin>
      <plugin>
        <groupid>com.mysema.maven</groupid>
        <artifactid>maven-apt-plugin</artifactid>
        <version>1.0.4</version>
        <executions>
          <execution>
            <phase>generate-sources</phase>
            <goals>
              <goal>process</goal>
            </goals>
            <configuration>
              <outputdirectory>target/generated-sources</outputdirectory>
              <processor>com.querydsl.apt.jpa.jpaannotationprocessor</processor>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  <dependencies>
    <dependency>
      <groupid>org.springframework.data</groupid>
      <artifactid>spring-data-jpa</artifactid>
    </dependency>
    <dependency>
      <groupid>org.springframework.data</groupid>
      <artifactid>spring-data-mongodb</artifactid>
    </dependency>
    <dependency>
      <groupid>com.querydsl</groupid>
      <artifactid>querydsl-apt</artifactid>
      <version>${querydsl.version}</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupid>com.querydsl</groupid>
      <artifactid>querydsl-jpa</artifactid>
      <version>${querydsl.version}</version>
    </dependency>
    <dependency>
      <groupid>com.querydsl</groupid>
      <artifactid>querydsl-mongodb</artifactid>
      <version>${querydsl.version}</version>
    </dependency>
    <dependency>
      <groupid>org.hibernate</groupid>
      <artifactid>hibernate-entitymanager</artifactid>
      <version>${hibernate.version}</version>
    </dependency>
    <dependency>
      <groupid>org.apache.tomcat</groupid>
      <artifactid>tomcat-jdbc</artifactid>
      <version>${tomcat.version}</version>
    </dependency>
    <dependency>
      <groupid>org.springframework</groupid>
      <artifactid>spring-test</artifactid>
    </dependency>
    <dependency>
      <groupid>ch.qos.logback</groupid>
      <artifactid>logback-classic</artifactid>
      <version>${logback.version}</version>
    </dependency>
    <dependency>
      <groupid>mysql</groupid>
      <artifactid>mysql-connector-java</artifactid>
      <version>${mysql.version}</version>
    </dependency>
    <dependency>
      <groupid>junit</groupid>
      <artifactid>junit</artifactid>
      <version>${junit.version}</version>
    </dependency>
  </dependencies>

  <repositories>
    <repository>
      <id>central</id>
      <name>central repository</name>
      <url>http://repo1.maven.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>
</project>

2.domain类

package org.exam.domain;

import org.springframework.data.mongodb.core.mapping.document;
import javax.persistence.column;
import javax.persistence.entity;
import javax.persistence.id;
import java.io.serializable;

@entity
@document
public class employee implements serializable {
  @id
  @column(length = 38)
  private string id;
  @column(length = 32)
  private string name;
  private long salary;
  private long departmentid;
  //setter和getter略
}

3.repository类

package org.exam.repository.jpa;
import org.exam.domain.employee;
import org.springframework.data.querydsl.querydslpredicateexecutor;
import org.springframework.data.repository.pagingandsortingrepository;
import java.util.collection;
public interface jpaemployeerepository extends pagingandsortingrepository<employee,string>,querydslpredicateexecutor<employee>{
  collection<employee> findbyidin(collection<string> ids);
}
package org.exam.repository.mongo;

import org.exam.domain.employee;
import org.springframework.data.querydsl.querydslpredicateexecutor;
import org.springframework.data.repository.pagingandsortingrepository;
import java.util.collection;
public interface mongoemployeerepository extends pagingandsortingrepository<employee, string>, querydslpredicateexecutor<employee> {
  collection<employee> findbyidin(collection<string> ids);
}

jpa有jparepository,mongodb有mongorepository,它俩都继承pagingandsortingrepository

3.配置类

package org.exam.config;

import com.mongodb.mongoclient;
import com.mongodb.writeconcern;
import org.apache.tomcat.jdbc.pool.datasource;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import org.springframework.context.annotation.propertysource;
import org.springframework.core.env.environment;
import org.springframework.data.jpa.repository.config.enablejparepositories;
import org.springframework.data.mongodb.mongodbfactory;
import org.springframework.data.mongodb.core.mongotemplate;
import org.springframework.data.mongodb.core.simplemongodbfactory;
import org.springframework.data.mongodb.core.writeresultchecking;
import org.springframework.data.mongodb.repository.config.enablemongorepositories;
import org.springframework.orm.jpa.jpatransactionmanager;
import org.springframework.orm.jpa.localcontainerentitymanagerfactorybean;
import org.springframework.orm.jpa.vendor.database;
import org.springframework.orm.jpa.vendor.hibernatejpavendoradapter;
import org.springframework.transaction.platformtransactionmanager;
import org.springframework.transaction.annotation.enabletransactionmanagement;

import javax.annotation.resource;
import java.net.unknownhostexception;
import java.util.properties;

@configuration
@propertysource("classpath:config.properties")
@enabletransactionmanagement
@enablejparepositories(basepackages = "org.exam.repository.jpa")
@enablemongorepositories(basepackages = "org.exam.repository.mongo")
public class appconfig {
  @resource
  private environment env;

  @bean(destroymethod = "close")
  public datasource datasource() {
    datasource datasource = new datasource();
    datasource.setdriverclassname(env.getproperty("ds.driverclassname"));
    datasource.seturl(env.getproperty("ds.url"));
    datasource.setusername(env.getproperty("ds.username"));
    datasource.setpassword(env.getproperty("ds.password"));
    datasource.setinitialsize(env.getproperty("ds.initialsize", integer.class));
    datasource.setminidle(env.getproperty("ds.minidle", integer.class));
    datasource.setmaxidle(env.getproperty("ds.maxidle", integer.class));
    datasource.setmaxactive(env.getproperty("ds.maxactive", integer.class));
    return datasource;
  }

  @bean
  public localcontainerentitymanagerfactorybean entitymanagerfactory() {
    hibernatejpavendoradapter jpavendoradapter = new hibernatejpavendoradapter();
    jpavendoradapter.setdatabase(database.valueof(env.getproperty("jpa.database")));
    jpavendoradapter.setgenerateddl(env.getproperty("jpa.generateddl",boolean.class));
    jpavendoradapter.setshowsql(env.getproperty("jpa.showsql",boolean.class));
    localcontainerentitymanagerfactorybean emf = new localcontainerentitymanagerfactorybean();
    emf.setdatasource(datasource());
    emf.setpackagestoscan("org.exam.domain");
    emf.setjpavendoradapter(jpavendoradapter);
    properties properties = new properties();
    properties.setproperty("hibernate.default_schema", env.getproperty("jpa.defaultschema"));
    emf.setjpaproperties(properties);
    return emf;
  }

  @bean
  public platformtransactionmanager transactionmanager() {
    return new jpatransactionmanager(entitymanagerfactory().getobject());
  }

  @bean
  public mongodbfactory mongodbfactory() throws unknownhostexception {
    return new simplemongodbfactory(new mongoclient(env.getproperty("mongo.host"), env.getproperty("mongo.port", integer.class)), env.getproperty("mongo.db"));
  }

  @bean
  public mongotemplate mongotemplate() throws unknownhostexception {
    mongotemplate mongotemplate = new mongotemplate(mongodbfactory());
    mongotemplate.setwriteresultchecking(writeresultchecking.exception);
    mongotemplate.setwriteconcern(writeconcern.normal);
    return mongotemplate;
  }
}

4.测试类

package org.exam.repository.jpa;

import org.exam.config.appconfig;
import org.exam.domain.employee;
import org.junit.test;
import org.junit.runner.runwith;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.data.domain.page;
import org.springframework.data.domain.pagerequest;
import org.springframework.test.annotation.rollback;
import org.springframework.test.context.contextconfiguration;
import org.springframework.test.context.junit4.springjunit4classrunner;
import org.springframework.test.context.support.annotationconfigcontextloader;
import org.springframework.transaction.annotation.transactional;

import java.util.uuid;

@runwith(springjunit4classrunner.class)
@contextconfiguration(loader = annotationconfigcontextloader.class, classes = {appconfig.class})
@transactional(transactionmanager = "transactionmanager")//rollback默认为true
public class jpaemployeerepositorytest {
  @autowired
  private jpaemployeerepository jpaemployeerepository;

  @test
  @rollback(false)
  public void testsave() {
    for (int i = 0; i < 5; i++) {
      employee employee = new employee();
      employee.setid(uuid.randomuuid().tostring());
      employee.setname("name");
      employee.setdepartmentid(1 + i);
      employee.setsalary(6800 + i);
      jpaemployeerepository.save(employee);
    }
  }

  @test
  public void testfindall() {
    page<employee> all = jpaemployeerepository.findall(null, new pagerequest(0, 8));
    for (employee employee : all) {
      system.out.println("employee = " + employee);
    }
  }
}
package org.exam.repository.mongo;
import com.mongodb.mongoclient;
import org.exam.config.appconfig;
import org.exam.domain.employee;
import org.junit.test;
import org.junit.runner.runwith;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.data.domain.page;
import org.springframework.data.domain.pagerequest;
import org.springframework.data.geo.circle;
import org.springframework.data.mongodb.core.mongotemplate;
import org.springframework.test.context.contextconfiguration;
import org.springframework.test.context.junit4.springjunit4classrunner;
import org.springframework.test.context.support.annotationconfigcontextloader;
import java.net.unknownhostexception;
@runwith(springjunit4classrunner.class)
@contextconfiguration(loader = annotationconfigcontextloader.class, classes = {appconfig.class})
public class mongoemployeerepositorytest {
  @autowired
  private mongoemployeerepository mongoemployeerepository;

  public static void main(string[] args) throws unknownhostexception {
    mongotemplate template = new mongotemplate(new mongoclient("127.0.0.1", 27017), "test");
    circle circle = new circle(-73.99171, 40.738868, 0.01);

    system.out.println();
  }

  @test
  public void testfindall() {
    page<employee> all = mongoemployeerepository.findall(null, new pagerequest(0, 8));
    for (employee employee : all) {
      system.out.println("employee = " + employee);
    }
  }
}

5.其它config.properties,logback.xml文件不太重要,篇幅关系就省略.


再了解一下比较大的需求,从几张表来取几个字段的数据,返回分页排序数据.

1.在appconfig注册jpaqueryfactory bean

@bean
public jpaqueryfactory jpaqueryfactory(entitymanager entitymanager) {
  return new jpaqueryfactory(new hqltemplates(), entitymanager);
}

2.建一个dto(数据传输对象)

public class userdto {
  private string empname;
  private string deptname;
  private long salary;
  //setter,getter略
}

3.查询例子测试

private page<userdto> findall(string empname,pageable pageable) {
  qemployee qemp = qemployee.employee;
  qdepartment qdep = qdepartment.department;
  list<predicate> criteria = new arraylist<>();
  if (stringutils.hastext(empname)){
    criteria.add(qemp.name.eq(empname.trim()));
  }

  jpaquery<?> query = jpaqueryfactory.from(qemp).innerjoin(qdep).on(qemp.deptid.eq(qdep.id)).where(criteria.toarray(new predicate[criteria.size()]));
  long total = query.fetchcount();
  list<userdto> content;
  if (pageable == null || total > pageable.getoffset()) {
    map<string, simpleexpression<?>> map = new hashmap<>();
    map.put("deptname", qdep.name);
    map.put("empname", qemp.name);
    map.put("salary", qemp.salary);
    content = querydslutils.applypagination(pageable, query).select(projections.bean(userdto.class, map)).fetch();
  } else {
    content = collections.emptylist();
  }
  return new pageimpl<>(content, pageable, total);
}

@test
public void test() {
  pageable pageable = new pagerequest(0, 10, new qsort(new orderspecifier<>(order.desc, qemployee.employee.salary), new orderspecifier<>(order.asc, qdepartment.department.name)));
  page<userdto> page = findall("name", pageable);
  for (userdto userdto : page) {
    system.out.println("userdto = " + userdto);
  }
}

参考资料

1:

2:

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