REST-Abfragesprache mit Querydsl Web Support

REST-Abfragesprache mit Querydsl-Webunterstützung

1. Überblick

In diesem kurzen Tutorial wird der Spring Data Querydsl-Web-Support erläutert.

Dies ist definitiv eine interessante Alternative zu allen anderen Methoden, auf die wir uns inthe main REST Query Language series konzentriert haben.

2. Die Maven-Konfiguration

Beginnen wir zunächst mit unserer Maven-Konfiguration:


    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}
    
...

Beachten Sie, dass die Querydsl-Webunterstützung inspring-data-commons seit1.11 verfügbar ist

3. Das Benutzer-Repository

Schauen wir uns als nächstes unser Repository an:

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

Beachten Sie, dass:

Wir überschreibenQuerydslBinderCustomizercustomize(), um die Standardbindung anzupassen
Wir passen die Standardbindung vonequalso an, dass Groß- und Kleinschreibung für alle Eigenschaften vonStringignoriert wird
Wir schließen auch die E-Mail des Benutzers von der Auflösung vonPredicateaus

Lesen Sie die vollständige Dokumentationhere.

4. Der User Controller

Schauen wir uns nun den Controller an:

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

Dies ist der interessante Teil - beachten Sie, wiewe’re obtaining a Predicate directly out of the HttpRequest ist, indem Sie die Annotation@QuerydslPredicate verwenden.

So würde eine URL mit dieser Art von Abfrage aussehen:

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

Und so wäre eine mögliche Antwort strukturiert:

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

5. Live-Test

Testen wir abschließend den neuen Querydsl-Web-Support:

@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");
    }
}

Lassen Sie uns zunächst alle Benutzer in das System einbeziehen:

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

Als nächstes suchen wir die Benutzer nachfirst 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());
}

Als nächstes, damit Benutzer nicht nachpartial last name gefunden werden:

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

Versuchen wir nun, Benutzer anhand vonemail zu finden:

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

Hinweis: Wenn wir versuchen, einen Benutzer per E-Mail zu finden, wurde die Abfrage ignoriert, da die E-Mail des Benutzers von der Auflösung vonPredicateausgeschlossen wurde.

6. Fazit

In diesem Artikel hatten wir eine kurze Einführung in den Spring Data Querydsl-Web-Support und eine coole, einfache Möglichkeit,Predicate direkt aus der HTTP-Anforderung abzurufen und diese zum Abrufen von Daten zu verwenden.

TOC