Spring DATA mot clé

Bonjour tout le monde,

Je voudrais faire une requête avec les mots-clés de Spring Data, mais je n'y arrive pas.
Dans les grandes lignes, j'ai une classe user qui contient une liste de projet.
Et je voudrais récupérer une liste d'utilisateurs qui n'ont pas ce projet. Sachant bien sûr qu'un user peut avoir plusieurs projets.
Je suis partie sur quelque chose comme ça :

Code:

public Set<UserProjectionSkillProject> findByLstProjectUsersProjectIdNotContaining(Long pId);

ou encore

Code:

public Set<UserProjectionSkillProject> findByLstProjectUsersNotContainingProjectId(Long pId);

Mais ça ne fonctionne pas.
La requête sql qui fonctionne est :

Code:

@Query(value = "SELECT u.id, u.first_name FROM user u WHERE u.id NOT IN (SELECT u.id FROM project_user pu WHERE pu.project_id = ?1 AND pu.user_id = u.id", nativeQuery = true)

Mais j'aimerai (pour monter en compétence sur les mots clés de Spring data) ne pas la faire en sql.

Des idées, propositions ?

Merci d'avance ;)

Bonjour,

En faisant comme ceci :

Code:

1
2
3
4
5
6
7
8
9
10
package com.example.demo;
 
import org.springframework.data.jpa.repository.JpaRepository;
 
import java.util.List;
 
public interface UserRepository extends JpaRepository<UserEntity, String> {
 
    List<UserProjection> findAllByProjects_IdNotIn(List<String> projectIds);
}

ATTENTION que la requête générée en base de données fera un left outer join entre la table de UserEntity et de ProjectEntity ce qui aura pour conséquence de ne pas renvoyer les utilisateurs qui ne sont pas liés à un projet.

Explications :

findAll permet de dire que l'on fait une recherche (le mot clé all peut être omit)
By pour signaler que ce qui suit sera les différentes conditions (le where en SQL)
Projects_Id pour indiquer que l'on souhaite définir un filtre sur le champ id présent dans le type de l'objet du champ projects de l'entité UserEntity.
NotIn exactement comme le NOT IN en SQL
(List<String> projectIds) pour donner une liste d'identifiants de projets à exclure

Documentation : https://docs.spring.io/spring-data/j...ty-expressions

Et voici le code exemple que je me suis fait :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
package com.example.demo;
 
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Component;
 
import java.util.Collections;
import java.util.List;
 
@SpringBootApplication
public class DemoApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
 
    @Component
    public static class InitRunner implements ApplicationRunner {
 
        private final UserRepository userRepository;
        private final ProjectRepository projectRepository;
 
        public InitRunner(UserRepository userRepository, ProjectRepository projectRepository) {
            this.userRepository = userRepository;
            this.projectRepository = projectRepository;
        }
 
        @Override
        public void run(ApplicationArguments args) {
            ProjectEntity projectEntityA = new ProjectEntity();
            projectEntityA.setId("a");
            projectEntityA.setName("A");
            projectRepository.save(projectEntityA);
 
            ProjectEntity projectEntityB = new ProjectEntity();
            projectEntityB.setId("b");
            projectEntityB.setName("B");
            projectRepository.save(projectEntityB);
 
            UserEntity userEntityA = new UserEntity();
            userEntityA.setId("a");
            userEntityA.setFirstName("A");
            userEntityA.setProjects(Collections.singletonList(projectEntityA));
            userRepository.save(userEntityA);
 
            UserEntity userEntityB = new UserEntity();
            userEntityB.setId("b");
            userEntityB.setFirstName("B");
            userEntityB.setProjects(Collections.singletonList(projectEntityB));
            userRepository.save(userEntityB);
 
            UserEntity userEntityC = new UserEntity();
            userEntityC.setId("c");
            userEntityC.setFirstName("c");
            userEntityC.setProjects(Collections.singletonList(projectEntityB));
            userRepository.save(userEntityC);
 
            List<UserProjection> all = userRepository.findAllByProjects_IdNotIn(Collections.singletonList("b"));
 
            all.forEach(userProjection -> System.out.println(userProjection.getFirstName()));
        }
    }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.example.demo;
 
import javax.persistence.Entity;
import javax.persistence.Id;
 
@Entity
public class ProjectEntity {
 
    @Id
    private String id;
 
    private String name;
 
    public String getId() {
        return id;
    }
 
    public void setId(String id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}

Code:

1
2
3
4
5
6
package com.example.demo;
 
import org.springframework.data.jpa.repository.JpaRepository;
 
public interface ProjectRepository extends JpaRepository<ProjectEntity, String> {
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package com.example.demo;
 
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import java.util.List;
 
@Entity
public class UserEntity {
 
    @Id
    private String id;
 
    private String firstName;
 
    @ManyToMany
    private List<ProjectEntity> projects;
 
    public String getId() {
        return id;
    }
 
    public void setId(String id) {
        this.id = id;
    }
 
    public String getFirstName() {
        return firstName;
    }
 
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
 
    public List<ProjectEntity> getProjects() {
        return projects;
    }
 
    public void setProjects(List<ProjectEntity> projects) {
        this.projects = projects;
    }
}

Code:

1
2
3
4
5
6
package com.example.demo;
 
public interface UserProjection {
 
    String getFirstName();
}

Merci pour ta réponse :)
Après plusieurs tests et essais j'ai fini par repartir vers du SQL basique avec le nativeQuery , car les requêtes générées par SpringData via les mots clés etc sont loin d'être performantes ( plusieurs appels en BDD alors que un seul suffit ....).

les requêtes par mot clé c'est pratique quand la requête est simple autrement faut passer par l'annotation query et utiliser du jpql..