Comment puis-je écrire cette requête SQL dans Hibernate? J'aimerais utiliser Hibernate pour créer des requêtes, pas pour créer la base de données.
SELECT * FROM Employee e INNER JOIN Team t ON e.Id_team=t.Id_team
J'ai créé des classes d'entités dans SQLServer2008,
@Entity
@Table(name="EMPLOYEE")
public class Employee
{
@Id @GeneratedValue
@Column(name="ID_EMPLOYEE")
private int id_employee;
@Column(name="SURNAME")
private String surname;
@Column(name="FIRSTNAME")
private String firstname;
@Column(name="ID_PROFESSION")
private int id_profession;
@Column(name="ID_BOSS")
private int id_boss;
@Column(name="HIRED_DATE")
private Date hired;
@Column(name="SALARY")
private double salary;
@Column(name="SALARY_ADD")
private double salary_add;
@Column(name="ID_TEAM")
private int id_team;
//setters and getters
}
@Entity
@Table(name="TEAM")
public class Team
{
@Id @GeneratedValue
@Column(name="ID_TEAM")
private int id_team;
@Column(name="TEAMNAME")
private String teamname;
@Column(name="ADDRESS")
private String address;
//setters and getters
}
J'ai essayé de construire une requête de sélection de travail de plusieurs manières mais cela ne fonctionne toujours pas.
SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
Session session = sessionFactory.openSession();
session.beginTransaction();
String select = "FROM Employee e INNER JOIN Team t ON e.Id_team=t.Id_team";
Query query = session.createQuery(select);
List elist = query.list();
session.getTransaction().commit();
session.close();
Peut-être que quelque chose ne va pas avec les entités?
Les jointures ne peuvent être utilisées que s'il existe une association entre des entités. Votre entité Employé ne doit pas avoir un champ nommé id_team
, de type int
, mappé sur une colonne. Il doit avoir une association ManyToOne avec l'entité Team, mappée en tant que JoinColumn:
@ManyToOne
@JoinColumn(name="ID_TEAM")
private Team team;
Ensuite, la requête suivante fonctionnera parfaitement:
select e from Employee e inner join e.team
Ce qui chargera tous les employés, sauf ceux qui ne sont associés à aucune équipe.
Il en va de même pour tous les autres champs qui sont une clé étrangère vers une autre table mappée en tant qu’entité, bien sûr (id_boss
, id_profession
).
Il est temps pour vous de lire la documentation d'Hibernate, car vous avez oublié une partie extrêmement importante de son contenu et de son fonctionnement.
Vous pouvez le faire sans avoir à créer un véritable mappage Hibernate. Essaye ça:
SELECT * FROM Employee e, Team t WHERE e.Id_team=t.Id_team
import Java.io.Serializable;
import Java.util.ArrayList;
import Java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
@Entity
@Table(name="empTable")
public class Employee implements Serializable{
private static final long serialVersionUID = 1L;
private int id;
private String empName;
List<Address> addList=new ArrayList<Address>();
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="emp_id")
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getEmpName() {
return empName;
}
public void setEmpName(String empName) {
this.empName = empName;
}
@OneToMany(mappedBy="employee",cascade=CascadeType.ALL)
public List<Address> getAddList() {
return addList;
}
public void setAddList(List<Address> addList) {
this.addList = addList;
}
}
Nous avons deux entités Employé et Adresse avec une relation un à plusieurs.
import Java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
@Entity
@Table(name="address")
public class Address implements Serializable{
private static final long serialVersionUID = 1L;
private int address_id;
private String address;
Employee employee;
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
public int getAddress_id() {
return address_id;
}
public void setAddress_id(int address_id) {
this.address_id = address_id;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@ManyToOne
@JoinColumn(name="emp_id")
public Employee getEmployee() {
return employee;
}
public void setEmployee(Employee employee) {
this.employee = employee;
}
}
De cette façon, nous pouvons implémenter une jointure interne entre deux tables
import Java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
public class Main {
public static void main(String[] args) {
saveEmployee();
retrieveEmployee();
}
private static void saveEmployee() {
Employee employee=new Employee();
Employee employee1=new Employee();
Employee employee2=new Employee();
Employee employee3=new Employee();
Address address=new Address();
Address address1=new Address();
Address address2=new Address();
Address address3=new Address();
address.setAddress("1485,Sector 42 b");
address1.setAddress("1485,Sector 42 c");
address2.setAddress("1485,Sector 42 d");
address3.setAddress("1485,Sector 42 a");
employee.setEmpName("Varun");
employee1.setEmpName("Krishan");
employee2.setEmpName("Aasif");
employee3.setEmpName("Dut");
address.setEmployee(employee);
address1.setEmployee(employee1);
address2.setEmployee(employee2);
address3.setEmployee(employee3);
employee.getAddList().add(address);
employee1.getAddList().add(address1);
employee2.getAddList().add(address2);
employee3.getAddList().add(address3);
Session session=HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
session.save(employee);
session.save(employee1);
session.save(employee2);
session.save(employee3);
session.getTransaction().commit();
session.close();
}
private static void retrieveEmployee() {
try{
String sqlQuery="select e from Employee e inner join e.addList";
Session session=HibernateUtil.getSessionFactory().openSession();
Query query=session.createQuery(sqlQuery);
List<Employee> list=query.list();
list.stream().forEach((p)->{System.out.println(p.getEmpName());});
session.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
J'ai utilisé Java 8 pour la boucle pour noter les noms. Assurez-vous que vous avez jdk 1.8 avec Tomcat 8. Ajoutez également quelques enregistrements supplémentaires pour une meilleure compréhension.
public class HibernateUtil {
private static SessionFactory sessionFactory ;
static {
Configuration configuration = new Configuration();
configuration.addAnnotatedClass(Employee.class);
configuration.addAnnotatedClass(Address.class);
configuration.setProperty("connection.driver_class","com.mysql.jdbc.Driver");
configuration.setProperty("hibernate.connection.url", "jdbc:mysql://localhost:3306/hibernate");
configuration.setProperty("hibernate.connection.username", "root");
configuration.setProperty("hibernate.connection.password", "root");
configuration.setProperty("dialect", "org.hibernate.dialect.MySQLDialect");
configuration.setProperty("hibernate.hbm2ddl.auto", "update");
configuration.setProperty("hibernate.show_sql", "true");
configuration.setProperty(" hibernate.connection.pool_size", "10");
// configuration
StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties());
sessionFactory = configuration.buildSessionFactory(builder.build());
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}