JPA joindre au printemps de démarrage de l'application

J'ai lu des exemples, mais ont ma question personnelle pour vous.
J'ai 2 tables:

Role: id, name User: id, login, name, role_id

Rôle de l'entité

@Entity
@Table(name = "role")
public class Role {

@Id
@Column(name = "id")
private long id;

@Column(name = "name", length = 45)
private String name;

@OneToMany(cascade = CascadeType.ALL, mappedBy = "role")
private Set<User> user = new HashSet<>();

//getters and setters

Entité utilisateur

@Entity
@Table(name = "user")
public class User {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "id",insertable = false, updatable = false)
private long id;

@Column(name = "login")
private String login;

@Column(name = "user_name")
private String userName;

@ManyToOne(fetch = FetchType.LAZY)
private Role role;

//getters and setters

Et référentiel:

public interface UserRepository extends JpaRepository<User, Long> {

String Q_GET_ALL_USERS = "from User u left join Role r on u.role_id=r.id";

@Query(Q_GET_ALL_USERS)
Collection<User> getAllUsers();

Ce code montre: Caused by: java.lang.IllegalArgumentException: org.hibernate.hql.internal.ast.QuerySyntaxException: Path expected for join! [from com.example.jpa.model.User u left join Role r on u.role_id=r.id]

Comment je comprends l'entité ne peut pas contient 'id' (dans mon cas en Role) pour les références et, devrais-je supprimer ce champ. Mais l'entité qui devrait avoir "@Id".

Dans ce cas, je devrais créer une nouvelle colonne dans le "Rôle"? ou je peux utiliser plus belle décision?

J'ai mis tout projet de bb

vous avez oublié les "SÉLECTIONNEZ u" dès le début de votre JPQL.
Oui, j'ai oublié select u

OriginalL'auteur qizer | 2016-02-02

7

Utiliser jointure dans les requêtes HQL (JPQL) vous n'avez pas besoin on clause
```
String Q_GET_ALL_USERS = "select u from User u left join u.role";
```
Cette requête n'a pas aucun sens parce que vous n'utilisez pas role dans la clause where.

Si vous souhaitez obtenir des utilisateurs avec un récupérés rôle que vous pouvez utiliser join fetch
```
String Q_GET_ALL_USERS = "select u from User u left join fetch u.role";
```
Mise à jour

Votre schéma pour User et Role n'est pas couramment utilisé. J'ai des conseils à vous faire @ManyToMany association de l'utilisateur de rôles et de supprimer toute user association de la Role
```
@Entity
@Table(name = "user")
public class User {

    @ManyToMany(fetch = FetchType.LAZY)
    private Set<Role> roles;

}

@Entity
@Table(name = "role")
public class Role {

    @Id
    @Column(name = "id")
    private long id;

    @Column(name = "name", length = 45)
    private String name;

}
```
Salut, Merci pour la réponse. Dans ma situation, les deux requêtes est correct, mais vos réponses m'ont fourni de l'information utile.
Vous êtes les bienvenus 🙂
Aussi j'ai une question à propos de "rôle" de l'entité. J'ai lu que @OneToMany doit s'agir d'un ensemble (Set). Je peux faire toutes les modifications dans le code et, au lieu de Set<User> user utilisation User user (sans collection)?
Pas de. Vous avez besoin d'une collection pour la @OneToMany association — Set ou List. - Je mettre à jour ma réponse.
pour le conseiller d'utiliser @ManyToMany association. Mais pourquoi le Role dans User classe n'est pas une List ou Set ?

OriginalL'auteur v.ladynev
2

Non, vous devez créer une nouvelle colonne dans User.
```
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "role_id")
private Role role;
```
Juste une remarque, Si nous utilisons @OneToMany avec mappedBy Hibernate utilise @JoinColumn par défaut.
Merci Romain, pour l'aide 🙂
C'est un rappel que vous devez accepter la réponse qui vous a aidé.

OriginalL'auteur Roman C

Merci à vous tous pour les réponses. Droit des entités et à la requête ci-dessous (plus tableaux de schéma).

Tables (requêtes)

CREATE TABLE role (
  id   INT         NOT NULL PRIMARY KEY,
  name VARCHAR(45) NOT NULL
);

CREATE TABLE user (
  id        INT         NOT NULL PRIMARY KEY IDENTITY,
  login     VARCHAR(45) NOT NULL,
  user_name VARCHAR(45) NOT NULL,
  role_id   INT         NOT NULL,
  FOREIGN KEY (role_id) REFERENCES role (id)
);

Entités:

@Entity
@Table(name = "user")
public class User {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "id",insertable = false, updatable = false)
private long id;

@Column(name = "login")
private String login;

@Column(name = "user_name")
private String userName;

@ManyToOne(fetch = FetchType.LAZY)
private Role role;

//getters and setters
}

@Entity
@Table(name = "role")
public class Role {

@Id
@Column(name = "id")
private long id;

@Column(name = "name", length = 45)
private String name;

@OneToMany(cascade = CascadeType.ALL, mappedBy = "role")
private Set<User> user = new HashSet<>();

//getters and setters
}

Référentiel

public interface UserRepository extends JpaRepository<User, Long> {

String Q_GET_ALL_USERS = "select u from User u left join u.role";

@Query(Q_GET_ALL_USERS)
Collection<User> getAllUsers();
}

@v-ladynev alternative proposée décision(à utiliser uniquement @ManyToMany dans User). Plus de détails vous pouvez trouver dans les commentaires sous cette réponse.
Quand je vérifie cette décision, je mettrai à jour cette réponse (j'espère que je n'oublie pas :-))

OriginalL'auteur qizer

Modèles

@Entity
@Table(name = "sys_std_user")
public class StdUser {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "class_id")
    public int classId;
    @Column(name = "user_name")
    public String userName;
}

@Entity
@Table(name = "sys_std_profile")
public class StdProfile {
    @Id
    @Column(name = "pro_id")
    public int proId;
    @Column(name = "full_name")
    public String fullName;
}

Contrôleurs

@PersistenceUnit
private EntityManagerFactory emf;

@GetMapping("/join")
    public List actionJoinTable() {
        EntityManager em = emf.createEntityManager();
        List arr_cust = em
                .createQuery("SELECT u.classId, u.userName, p.fullName FROM StdUser u, StdProfile p WHERE u.classId=p.proId")
                .getResultList();
        return arr_cust;
    }

Résultat:

[
    [
        1,
        "Ram",
        "Ram Pukar Chaudhary"
    ],
    [
        2,
        "Raja",
        "Raja Kishor Shah"
    ]
]

je ne recommanderais pas cette approche, en plus, il n'est pas à l'aide de jointures.

OriginalL'auteur Ram Pukar

Vous devez vous connecter pour publier un commentaire.