Java Predicate类代码示例

import com.querydsl.core.types.Predicate; //导入依赖的package包/类
/**
 * Retorna os Veiculos de acordo com o filtro.
 * 
 * @param placa
 *            Número da Placa do Veiculo. Busca com like à direita.
 * @return todos os Veiculos do Usuário paginado de 10 em 10.
 */
@RequestMapping(value = "/pesquisar", method = RequestMethod.GET)
@ApiOperation(value = "Pesquisa de Veículo")
public ResponseEntity<Page<Veiculo>> pesquisar(
		@RequestParam(name = "placa", required = true) String placa, 
		@PageableDefault(sort = { "placa" }, direction = Direction.ASC) Pageable pageable) {
	
	// Não permite caracteres especiais na busca
	Validate.isTrue(StringUtils.isAlphanumeric(placa));
	
	Predicate predicate = QVeiculo.veiculo.placa.like(placa.toUpperCase() + '%');

	Page<Veiculo> page = veiculoRepository.findAll(predicate, pageable);
	
	page.forEach(v -> v.getProprietario().getId()); // TODO buscar uma
													// forma de arrumar
													// no
													// QueryDslPredicateExecutor
	return new ResponseEntity<>(page, HttpStatus.OK);
}
 

import com.querydsl.core.types.Predicate; //导入依赖的package包/类
private Predicate buildTextQuery(TextQuery txt, StringPath txtfield) {

        if (txt.isEmpty()) {
            return null;
        }

        BooleanBuilder predicate = new BooleanBuilder();

        if (txt.getContains() != null) {
            predicate.and(txtfield.contains(txt.getContains()));
        }

        if (txt.getStartWith() != null) {
            predicate.and(txtfield.startsWith(txt.getStartWith()));
        }

        if (txt.getEndWith() != null) {
            predicate.and(txtfield.endsWith(txt.getEndWith()));
        }

        if (txt.getEquals() != null) {
            predicate.and(txtfield.endsWith(txt.getEquals()));
        }

        return predicate;
    }
 

import com.querydsl.core.types.Predicate; //导入依赖的package包/类
@RequestMapping(method = RequestMethod.POST, value = "/search")
@ApiOperation(value = "Search for device instances", notes = "", response = Device.class, nickname = "searchDevices")
@PreAuthorize("@raptorSecurity.can(principal, 'device', 'read')")
public ResponseEntity<?> searchDevices(
        @AuthenticationPrincipal User currentUser,
        @RequestParam MultiValueMap<String, String> parameters, 
        @RequestBody DeviceQuery query
) {

    if (query.isEmpty()) {
        return JsonErrorResponse.badRequest();
    }

    if (!currentUser.isAdmin()) {
        query.userId(currentUser.getId());
    }

    DeviceQueryBuilder qb = new DeviceQueryBuilder(query);
    Predicate predicate = qb.getPredicate();
    Pageable paging = qb.getPaging();

    Page<Device> pagedList = deviceService.search(predicate, paging);

    return ResponseEntity.ok(pagedList);
}
 

import com.querydsl.core.types.Predicate; //导入依赖的package包/类
private static Predicate noHolidayExistsSubSelect(final Expression<Long> userId,
    final DatePath<Date> date) {
  QPublicHoliday qPublicHoliday = new QPublicHoliday("exp_work_nh_ph");
  QUserHolidayScheme qUserHolidayScheme = new QUserHolidayScheme("exp_work_nh_uhsch");
  QDateRange qDateRange = new QDateRange("exp_work_nh_data_range");

  return new SQLQuery<>().select(qPublicHoliday.publicHolidayId).from(qPublicHoliday)
      .innerJoin(qUserHolidayScheme)
      .on(qUserHolidayScheme.holidaySchemeId.eq(qPublicHoliday.holidaySchemeId))
      .innerJoin(qDateRange).on(qDateRange.dateRangeId.eq(qUserHolidayScheme.dateRangeId))
      .where(qUserHolidayScheme.userId.eq(userId)
          .and(qDateRange.startDate.loe(date))
          .and(qDateRange.endDateExcluded.gt(date))
          .and(qPublicHoliday.date.eq(date)))
      .notExists();
}
 

import com.querydsl.core.types.Predicate; //导入依赖的package包/类
private boolean hasOverlapping(final Long userId, final Date startDate,
    final Date endDateExcluded, final Long userHolidayAmountIdToExclude) {
  Long count = querydslSupport.execute((connection, configuration) -> {
    QDateRange qDateRange = QDateRange.dateRange;
    QUserHolidayAmount qUserHolidayAmount = QUserHolidayAmount.userHolidayAmount;
    SQLQuery<Long> query = new SQLQuery<>(connection, configuration)
        .select(qDateRange.dateRangeId)
        .from(qDateRange)
        .innerJoin(qUserHolidayAmount)
        .on(qDateRange.dateRangeId.eq(qUserHolidayAmount.dateRangeId));

    List<Predicate> predicates = new ArrayList<>();
    predicates.add(qUserHolidayAmount.userId.eq(userId));

    if (userHolidayAmountIdToExclude != null) {
      predicates.add(qUserHolidayAmount.userHolidayAmountId.ne(userHolidayAmountIdToExclude));
    }

    predicates.add(rangeOverlaps(qDateRange, startDate, endDateExcluded));

    query.where(predicates.toArray(new Predicate[predicates.size()]));
    return query.fetchCount();
  });
  return count > 0;
}
 

import com.querydsl.core.types.Predicate; //导入依赖的package包/类
@RequestMapping(value = "/", method = RequestMethod.GET)
String index(Model model, //
		@QuerydslPredicate(root = User.class) Predicate predicate, //
		@PageableDefault(sort = { "lastname", "firstname" }) Pageable pageable, //
		@RequestParam MultiValueMap<String, String> parameters) {

	ServletUriComponentsBuilder builder = ServletUriComponentsBuilder.fromCurrentRequest();
	builder.replaceQueryParam("page", new Object[0]);

	model.addAttribute("baseUri", builder.build().toUri());
	model.addAttribute("users", repository.findAll(predicate, pageable));

	return "index";
}
 

import com.querydsl.core.types.Predicate; //导入依赖的package包/类
@RequestMapping(value = "search", method = RequestMethod.GET)
  public ModelAndView findDishes(@QuerydslPredicate(root = Dish.class) Predicate predicate, @PageableDefault(sort = {"date"}, direction = Sort.Direction.DESC) Pageable pageable, ModelAndView modelAndView) {
Sort realSort = pageable.getSort().and(new Sort(Sort.Direction.ASC, "id"));
PageRequest pageRequest = new PageRequest(pageable.getPageNumber(), pageable.getPageSize(), realSort);
Page<Dish> page = dishRepo.findAll(predicate, pageRequest);
List<DishWebDTO> dishes = page.getContent().stream().map(dishDtoFactory::create).collect(Collectors.toList());
modelAndView.addObject("page", page);
modelAndView.addObject("dishes", dishes);
modelAndView.addObject("labels", getLabelsFromDishes());
modelAndView.addObject("categories", getCategoriesFromDishes());
modelAndView.addObject("mensas", mensaRepo.findAllByOrderByName());
      modelAndView.setViewName("search");
      return modelAndView;
  }
 

import com.querydsl.core.types.Predicate; //导入依赖的package包/类
/**
 * Find the common type that should be used to compare the given two
 * expressions.
 *
 * @param other The type of the other that we should enforce on the json
 * type.
 * @return the extra predicate to enforce the type with.
 */
private Predicate createTypePredicate(CompareType other) {
    switch (other) {
        case NUMBER:
            return Expressions.stringTemplate("jsonb_typeof({0})", jsonExpression).eq("number");
        case BOOLEAN:
            return Expressions.stringTemplate("jsonb_typeof({0})", jsonExpression).eq("boolean");
        default:
            return null;
    }
}
 

import com.querydsl.core.types.Predicate; //导入依赖的package包/类
public Optional<Predicate> buildPredicate(final QAnnouncementSubscriber subscriber) {
    final Map<Organisation, Set<OccupationType>> childOccupationMapping = activeOccupations.stream()
            .flatMap(occupation -> occupation.getOrganisation().getAllParentsAndSelf().stream()
                    .map(parent -> new BasicOccupationItem(parent, occupation.getOccupationType())))
            .collect(groupingBy(BasicOccupationItem::getOrganisation,
                    mapping(BasicOccupationItem::getOccupationType, toSet())));

    final List<Predicate> predicateList = childOccupationMapping.entrySet().stream()
            .filter(entry -> organisationFilter == null || organisationFilter.contains(entry.getKey()))
            .map(entry -> {
                final Organisation organisation = entry.getKey();
                final Set<OccupationType> childOccupationTypes = entry.getValue();

                if (childOccupationTypes.contains(OccupationType.TOIMINNANOHJAAJA)) {
                    // Coordinator should see any message sent by parent organisations or self
                    return subscriber.organisation.eq(organisation);

                } else if (childOccupationTypes.contains(OccupationType.SEURAN_YHDYSHENKILO)) {
                    // Club contact person should see all club communication
                    return subscriber.organisation.eq(organisation)
                            .and(subscriber.occupationType.in(OccupationType.clubValues()));

                } else {
                    Preconditions.checkArgument(!childOccupationTypes.isEmpty(), "should not be empty");
                    return subscriber.organisation.eq(organisation)
                            .and(subscriber.occupationType.in(childOccupationTypes));
                }
            })
            .collect(Collectors.toList());

    return predicateList.isEmpty() ? Optional.empty() : Optional.ofNullable(ExpressionUtils.anyOf(predicateList));
}
 

import com.querydsl.core.types.Predicate; //导入依赖的package包/类
private static Predicate subscriberExists(final QAnnouncement announcement,
                                          final QAnnouncementSubscriber subscriber,
                                          final Predicate predicate) {
    return JPAExpressions.selectFrom(subscriber)
            .where(subscriber.announcement.eq(announcement), predicate)
            .exists();
}
 

import com.querydsl.core.types.Predicate; //导入依赖的package包/类
@Transactional(readOnly = true)
public List<HuntingClubAreaDTO> listByClubAndYear(final long clubId,
                                                  final Integer year,
                                                  final boolean activeOnly) {
    final HuntingClub club = requireEntityService.requireHuntingClub(clubId, EntityPermission.READ);

    final Predicate[] predicates = createPredicate(club, year, activeOnly);

    return huntingClubAreaDTOTransformer.apply(new JPAQuery<>(entityManager).from(QHuntingClubArea.huntingClubArea)
            .where(predicates)
            .select(QHuntingClubArea.huntingClubArea)
            .fetch());
}
 

import com.querydsl.core.types.Predicate; //导入依赖的package包/类
@Transactional
@Test
public void given_brand_eg_when_findpage_then_brand_should_be_loaded() {
  Page<Product> productPage =
      productRepository.findAll(
          (Predicate) null, new PageRequest(0, 10), EntityGraphUtils.fromName(Product.BRAND_EG));
  assertThat(productPage.getContent()).isNotEmpty();
  for (Product product : productPage.getContent()) {
    assertThat(Hibernate.isInitialized(product.getBrand())).isTrue();
  }
}
 

import com.querydsl.core.types.Predicate; //导入依赖的package包/类
private Predicate buildTextQuery(TextQuery txt, StringPath txtfield) {

        if (txt.isEmpty()) {
            return null;
        }

        BooleanBuilder predicate = new BooleanBuilder();

        if (txt.getContains() != null) {
            predicate.and(txtfield.contains(txt.getContains()));
        }

        if (txt.getStartWith() != null) {
            predicate.and(txtfield.startsWith(txt.getStartWith()));
        }

        if (txt.getEndWith() != null) {
            predicate.and(txtfield.endsWith(txt.getEndWith()));
        }

        if (txt.getEquals() != null) {
            predicate.and(txtfield.endsWith(txt.getEquals()));
        }

        if (!txt.getIn().isEmpty()) {
            predicate.and(txtfield.in(txt.getIn()));
        }

        return predicate;
    }
 

import com.querydsl.core.types.Predicate; //导入依赖的package包/类
public Predicate getPredicate() {
        throw new RuntimeException("querydsl geoquery is missing?");
//        QRecordSet record = new QRecordSet("record");
//
//        BooleanBuilder predicate = new BooleanBuilder();
//
//        if (query.getUserId() != null) {
//            predicate.and(record.userId.eq(query.getUserId()));
//        }
//        
//        if (!query.getTimestamp().isEmpty()) {
//            
//            // between
//            if(query.getTimestamp().getBetween().length > 0) {
//                Date t0 = Date.from(Instant.ofEpochMilli(query.getTimestamp().getBetween()[0].longValue()));
//                Date t1 = Date.from(Instant.ofEpochMilli(query.getTimestamp().getBetween()[1].longValue()));
//                predicate.and(record.timestamp.between(t0, t1));
//            }
//            
//        }
//        
//        if (!query.getLocation().isEmpty()) {
//            GeoQuery.Distance d = query.getLocation().getDistance();
//            if (d.center != null) {
//                predicate.and(MongodbExpressions.near(record.location, 0, 0));
//                NearQuery nearQuery = NearQuery
//                        .near(d.center)
//                        .maxDistance(new Distance(d.radius, Metrics.KILOMETERS));
//            }
//        }
//        
//        
//        return predicate;
    }
 

import com.querydsl.core.types.Predicate; //导入依赖的package包/类
public Predicate getPredicate() {

        QApp app = new QApp("app");

        BooleanBuilder predicate = new BooleanBuilder();

        if (query.getUserId() != null) {
            predicate.and(app.userId.eq(query.getUserId()));
        }

        // id
        Predicate pid = buildTextQuery(query.id, app.id);
        if (pid != null) {
            predicate.and(pid);
        }

        // name
        Predicate pname = buildTextQuery(query.name, app.name);
        if (pname != null) {
            predicate.and(pname);
        }

        // description
        Predicate pdesc = buildTextQuery(query.description, app.description);
        if (pdesc != null) {
            predicate.and(pdesc);
        }

        //users (id)
        Predicate users = buildAppUserListQuery(query.users, app.users);
        if (users != null) {
            predicate.and(users);
        }

        return predicate;
    }