Gérer les paramètres facultatifs dans QueryDSL

Je suis en utilisant QueryDSL avec SpringData.
J'ai le Tableau dire, Employee et j'ai créé une entité de la classe de dire, EmployeeEntity
J'ai écrit à la suite d' service méthode

public EmployeeEntity getEmployees(String firstName, String lastName)
{
    QEmployeeEntity employee = QEmployeeEntity.employeeEntity;
    BooleanExpression query = null;
    if(firstName != null)
    {
        query = employee.firstName.eq(firstName);
    }
    if(lastName != null)
    {
        query = query.and(employee.lastName.eq(lastName)); //NPException if firstName is null as query will be NULL
    }
    return empployeeDAO.findAll(query);
}

Comme ci-dessus j'ai commenté la NPException. Comment utiliser QueryDSL pour les Paramètres facultatifs dans QueryDSL à l'aide de Données du Printemps?

Merci 🙂

OriginalL'auteur Prashant Shilimkar | 2014-05-20

BooleanBuilder peut être utilisé comme une dynamique constructeur pour les expressions booléennes:

public EmployeeEntity getEmployees(String firstName, String lastName) {
    QEmployeeEntity employee = QEmployeeEntity.employeeEntity;
    BooleanBuilder where = new BooleanBuilder();
    if (firstName != null) {
        where.and(employee.firstName.eq(firstName));
    }
    if (lastName != null) {
        where.and(employee.lastName.eq(lastName));
    }
    return empployeeDAO.findAll(where);
}

mais si nous avons rejoint ? pouvez-vous m'aider il y a stackoverflow.com/questions/24792778/dynamic-search-by-criteria

OriginalL'auteur Timo Westkämper

BooleanBuilder est bon. Vous pouvez également envelopper et d'ajouter "en option" méthodes afin d'éviter la si les conditions:

Par exemple, pour "et" vous pouvez écrire: (Java 8 lambdas sont utilisés)

public class WhereClauseBuilder implements Predicate, Cloneable
{
    private BooleanBuilder delegate;

    public WhereClauseBuilder()
    {
        this.delegate = new BooleanBuilder();
    }

    public WhereClauseBuilder(Predicate pPredicate)
    {
        this.delegate = new BooleanBuilder(pPredicate);
    }

    public WhereClauseBuilder and(Predicate right)
    {
        return new WhereClauseBuilder(delegate.and(right));
    }

    public <V> WhereClauseBuilder optionalAnd(@Nullable V pValue, LazyBooleanExpression pBooleanExpression)
    {
        return applyIfNotNull(pValue, this::and, pBooleanExpression);
    }

    private <V> WhereClauseBuilder applyIfNotNull(@Nullable V pValue, Function<Predicate, WhereClauseBuilder> pFunction, LazyBooleanExpression pBooleanExpression)
    {
        if (pValue != null)
        {
            return new WhereClauseBuilder(pFunction.apply(pBooleanExpression.get()));
        }

        return this;
    }
   }

    @FunctionalInterface
    public interface LazyBooleanExpression
    {
        BooleanExpression get();
    }

Et puis l'utilisation serait beaucoup plus propre:

public EmployeeEntity getEmployees(String firstName, String lastName) {
    QEmployeeEntity employee = QEmployeeEntity.employeeEntity;

    return empployeeDAO.findAll
    (
       new WhereClauseBuilder()
           .optionalAnd(firstName, () -> employee.firstName.eq(firstName))
           .optionalAnd(lastName, () -> employee.lastName.eq(lastName))
    );
}

Il est possible également d'utiliser le jdk est Optionnel classe

OriginalL'auteur aviad

3

C'est Java 101 en fait: vérifier null et initialisation de la requête au lieu de concaténer des prédicats. Ainsi, une méthode d'aide comme celle-ci pourrait faire l'affaire:
```
private BooleanExpression createOrAnd(BooleanExpression left, BooleanExpression right) {
  return left == null ? right : left.and(right);
}
```
Ensuite, vous pouvez tout simplement faire:
```
BooleanExpression query = null;

if (firstName != null) {
  query = createOrAnd(query, employee.firstName.eq(firstName));
}

if (lastName != null) {
  query = createOrAnd(query, employee.lastName.eq(lastName));
}

…
```
Remarque, que j'utilise createOrAnd(…) même dans le premier alinéa simplement pour des raisons de cohérence et de ne pas avoir à adapter ce code dans le cas où vous décidez d'ajouter un nouvel alinéa avant même l'un pour firstName.

vous avez sauvé mon temps 🙂

OriginalL'auteur Oliver Drotbohm

J'ai fait face à un même problème et voici une autre version de Timo Westkämper
's accepté de répondre à à l'aide de la Optional.

default Optional<Correlation> findOne(
        @Nonnull final String value, @Nullable final String environment,
        @Nullable final String application, @Nullable final String service) {
    final QSome Some = QSome.some;
    final BooleanBuilder builder = new BooleanBuilder();
    ofNullable(service).map(some.service::eq).map(builder::and);
    ofNullable(application).map(some.application::eq).map(builder::and);
    ofNullable(environment).map(some.environment::eq).map(builder::and);
    builder.and(some.value.eq(value));
    return findOne(builder);
}

OriginalL'auteur Jin Kwon

Base sur ce que je voudrais faire cela

public List<EmployeeEntity> getEmployees(Optional<String> firstName, Optional<String> lastName)
{
    BooleanExpression queryPredicate =  QEmployeeEntity.employeeEntity.firstName.containsIgnoreCase(firstName.orElse("")).and(QEmployeeEntity.employeeEntity.lastName.containsIgnoreCase(lastName.orElse(""))); 
    return empployeeDAO.findAll(queryPredicate);
}

Tout d'abord vous devez retourner un List de EmployeeEntity. La seconde, de son mieux pour l'utiliser en option que de vérifier si son null, et vous pouvez passer de Java 8 Optional valeurs obtenues à partir facultatif RequestParam comme ceci:

@RequestMapping(value = "/query", method = RequestMethod.GET)
public ModelAndView queryEmployee(@RequestParam(value = "firstName", required = false) Optional<String> firstName, @RequestParam(value = "lastName", required = false) Optional<String> lastName) 
{
       List<EmployeeEntity> result =  getEmployees(firstName, lastName);    
            ....
}

Et une chose très importante est l'utilisation de la containsIgnoreCase fonction dans le prédicat: "mieux qu'un like cause de ses insensible à la casse.

À mon avis, on devrait utiliser une approche comme ceci:

@Controller
class UserController {

  @Autowired UserRepository repository;

  @RequestMapping(value = "/", method = RequestMethod.GET)
  String index(Model model, @QuerydslPredicate(root = User.class) Predicate predicate,    
          Pageable pageable, @RequestParam MultiValueMap<String, String> parameters) {

    model.addAttribute("users", repository.findAll(predicate, pageable));

    return "index";
  }
}

regarder ici.

OriginalL'auteur EliuX

si vous cochez la QueryDSL mise en œuvre de null:

public BooleanExpression and(@Nullable Predicate right) {
    right = (Predicate) ExpressionUtils.extract(right);
    if (right != null) {
        return BooleanOperation.create(Ops.AND, mixin, right);
    } else {
        return this;
    }
}

qui est censé être ce que vous voulez.

OriginalL'auteur ameen

C'est un moyen très simple de traiter avec des paramètres optionnels, je l'utilise dans mon projet :

    public List<ResultEntity> findByOptionalsParams(String param1, Integer param2) {
    QResultEntity qResultEntity = QResultEntity.resultEntity;
    final JPQLQuery<ResultEntity> query = from(qResultEntity);
    if (!StringUtils.isEmpty(param1)) {
      query.where(qResultEntity.field1.like(Expressions.asString("%").concat(param1).concat("%")));
    }
    if (param2 != null) {
      query.where(qResultEntity.field2.eq(param2));
    }
    return query.fetch();
}

OriginalL'auteur MK-rou

Vous devez vous connecter pour publier un commentaire.