springData使用QueryDsl的示例代码

<project xmlns= "http://maven.apache.org/pom/4.0.0" xmlns:xsi= "http://HdhCmsTestw3.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>

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略

}

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

}

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;

   }

}

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

     }

   }

}

@bean

public jpaqueryfactory jpaqueryfactory(entitymanager entitymanager) {

   return new jpaqueryfactory( new hqltemplates(), entitymanager);

}

public class userdto {

   private string empname;

   private string deptname;

   private long salary;

   //setter,getter略

}

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

   }

}