Langage de requête REST avec prise en charge de Querydsl Web

1. Vue d'ensemble

Dans ce rapide didacticiel, nous aborderons le support Web de Spring Data Querydsl.

C'est certainement une alternative intéressante à toutes les autres façons sur lesquelles nous nous sommes concentrés dansthe main REST Query Language series.

2. La configuration Maven

Commençons par notre configuration maven:


    org.springframework.boot
    spring-boot-starter-parent
    1.3.0.RELEASE



    
        org.springframework.boot
        spring-boot-starter-web
    
    
        org.springframework.data
        spring-data-commons
    
    
        com.mysema.querydsl
        querydsl-apt
        ${querydsl.version}
    
    
        com.mysema.querydsl
        querydsl-jpa
        ${querydsl.version}
    
...

Notez que la prise en charge Web de Querydsl est disponible dansspring-data-commons depuis1.11

3. Le référentiel d'utilisateurs

Jetons ensuite un œil à notre référentiel:

public interface UserRepository extends
  JpaRepository, QueryDslPredicateExecutor, QuerydslBinderCustomizer {
    @Override
    default public void customize(QuerydslBindings bindings, QUser root) {
        bindings.bind(String.class).first(
          (StringPath path, String value) -> path.containsIgnoreCase(value));
        bindings.excluding(root.email);
    }
}

Notez que:

Nous remplaçonsQuerydslBinderCustomizercustomize() pour personnaliser la liaison par défaut
Nous personnalisons la liaison par défautequals pour ignorer la casse pour toutes les propriétésString
Nous excluons également l'e-mail de l'utilisateur de la résolutionPredicate

Consultez la documentation complètehere.

4. Le contrôleur utilisateur

Voyons maintenant le contrôleur:

@RequestMapping(method = RequestMethod.GET, value = "/users")
@ResponseBody
public Iterable findAllByWebQuerydsl(
  @QuerydslPredicate(root = User.class) Predicate predicate) {
    return userRepository.findAll(predicate);
}

C'est la partie intéressante - remarquez commentwe’re obtaining a Predicate directly out of the HttpRequest, en utilisant l'annotation@QuerydslPredicate.

Voici à quoi ressemblerait une URL avec ce type de requête:

http://localhost:8080/users?firstName=john

Et voici comment une réponse potentielle serait structurée:

[
   {
      "id":1,
      "firstName":"john",
      "lastName":"doe",
      "email":"[email protected]",
      "age":11
   }
]

5. Test en direct

Enfin, testons le nouveau support Web Querydsl:

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = Application.class)
@WebAppConfiguration
public class UserLiveTest {

    private ObjectMapper mapper = new ObjectMapper();
    private User userJohn = new User("john", "doe", "[email protected]");
    private User userTom = new User("tom", "doe", "[email protected]");

    private static boolean setupDataCreated = false;

    @Before
    public void setupData() throws JsonProcessingException {
        if (!setupDataCreated) {
            givenAuth().contentType(MediaType.APPLICATION_JSON_VALUE)
                       .body(mapper.writeValueAsString(userJohn))
                       .post("http://localhost:8080/users");

            givenAuth().contentType(MediaType.APPLICATION_JSON_VALUE)
                       .body(mapper.writeValueAsString(userTom))
                       .post("http://localhost:8080/users");
            setupDataCreated = true;
        }
    }

    private RequestSpecification givenAuth() {
        return RestAssured.given().auth().preemptive().basic("user1", "user1Pass");
    }
}

Commençons par intégrer tous les utilisateurs du système:

@Test
public void whenGettingListOfUsers_thenCorrect() {
    Response response = givenAuth().get("http://localhost:8080/users");
    User[] result = response.as(User[].class);
    assertEquals(result.length, 2);
}

Ensuite, recherchons les utilisateurs parfirst name:

@Test
public void givenFirstName_whenGettingListOfUsers_thenCorrect() {
    Response response = givenAuth().get("http://localhost:8080/users?firstName=john");
    User[] result = response.as(User[].class);
    assertEquals(result.length, 1);
    assertEquals(result[0].getEmail(), userJohn.getEmail());
}

Ensuite, de peur de trouver des utilisateurs parpartial last name:

@Test
public void givenPartialLastName_whenGettingListOfUsers_thenCorrect() {
    Response response = givenAuth().get("http://localhost:8080/users?lastName=do");
    User[] result = response.as(User[].class);
    assertEquals(result.length, 2);
}

Maintenant, essayons de trouver des utilisateurs paremail:

@Test
public void givenEmail_whenGettingListOfUsers_thenIgnored() {
    Response response = givenAuth().get("http://localhost:8080/users?email=john");
    User[] result = response.as(User[].class);
    assertEquals(result.length, 2);
}

Remarque: lorsque nous essayons de trouver un utilisateur par e-mail, la requête a été ignorée, car nous avons exclu l'e-mail de l'utilisateur de la résolution dePredicate.

6. Conclusion

Dans cet article, nous avons eu une introduction rapide au support Web Spring Data Querydsl et un moyen simple et sympa d'obtenir unPredicate directement à partir de la requête HTTP et de l'utiliser pour récupérer des données.

TOC

Langage de requête REST avec prise en charge de Querydsl Web