Ruhezustand - Anmerkungen
Bisher haben Sie gesehen, wie Hibernate eine XML-Zuordnungsdatei für die Umwandlung von Daten von POJO in Datenbanktabellen und umgekehrt verwendet. Anmerkungen im Ruhezustand sind die neueste Methode zum Definieren von Zuordnungen ohne Verwendung einer XML-Datei. Sie können Anmerkungen zusätzlich zu oder als Ersatz für XML-Zuordnungsmetadaten verwenden.
Annotationen im Ruhezustand sind die leistungsstarke Methode, um die Metadaten für die Zuordnung von Objekten und relationalen Tabellen bereitzustellen. Alle Metadaten werden zusammen mit dem Code in die POJO-Java-Datei eingebettet. Dies hilft dem Benutzer, die Tabellenstruktur und POJO gleichzeitig während der Entwicklung zu verstehen.
Wenn Sie Ihre Anwendung auf andere EJB 3-kompatible ORM-Anwendungen portierbar machen möchten, müssen Sie Anmerkungen verwenden, um die Zuordnungsinformationen darzustellen. Wenn Sie jedoch eine größere Flexibilität wünschen, sollten Sie XML-basierte Zuordnungen verwenden.
Umgebungssetup für Annotation im Ruhezustand
Zunächst müssten Sie sicherstellen, dass Sie JDK 5.0 verwenden. Andernfalls müssen Sie Ihr JDK auf JDK 5.0 aktualisieren, um die native Unterstützung für Anmerkungen nutzen zu können.
Zweitens müssen Sie das Verteilungspaket für Hibernate 3.x-Annotationen installieren, das bei sourceforge erhältlich ist: ( Hibernate Annotation herunterladen ) und kopierenhibernate-annotations.jar, lib/hibernate-comons-annotations.jar und lib/ejb3-persistence.jar von der Hibernate Annotations-Distribution zu Ihrem CLASSPATH.
Beispiel für eine kommentierte Klasse
Wie oben erwähnt, werden bei der Arbeit mit Hibernate Annotation alle Metadaten zusammen mit dem Code in der POJO-Java-Datei zusammengefasst. Dies hilft dem Benutzer, die Tabellenstruktur und POJO gleichzeitig während der Entwicklung zu verstehen.
Bedenken Sie, dass wir die folgende EMPLOYEE-Tabelle zum Speichern unserer Objekte verwenden werden -
create table EMPLOYEE (
id INT NOT NULL auto_increment,
first_name VARCHAR(20) default NULL,
last_name VARCHAR(20) default NULL,
salary INT default NULL,
PRIMARY KEY (id)
);Es folgt die Zuordnung der Employee-Klasse mit Anmerkungen zum Zuordnen von Objekten mit der definierten EMPLOYEE-Tabelle.
import javax.persistence.*;
@Entity
@Table(name = "EMPLOYEE")
public class Employee {
@Id @GeneratedValue
@Column(name = "id")
private int id;
@Column(name = "first_name")
private String firstName;
@Column(name = "last_name")
private String lastName;
@Column(name = "salary")
private int salary;
public Employee() {}
public int getId() {
return id;
}
public void setId( int id ) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName( String first_name ) {
this.firstName = first_name;
}
public String getLastName() {
return lastName;
}
public void setLastName( String last_name ) {
this.lastName = last_name;
}
public int getSalary() {
return salary;
}
public void setSalary( int salary ) {
this.salary = salary;
}
}Der Ruhezustand erkennt, dass sich die Annotation @Id in einem Feld befindet, und geht davon aus, dass sie zur Laufzeit direkt über Felder auf Eigenschaften eines Objekts zugreifen soll. Wenn Sie die Annotation @Id in die Methode getId () einfügen, aktivieren Sie standardmäßig den Zugriff auf Eigenschaften über die Methoden getter und setter. Daher werden alle anderen Anmerkungen gemäß der ausgewählten Strategie auch entweder auf Feldern oder auf Getter-Methoden platziert.
Im folgenden Abschnitt werden die in der obigen Klasse verwendeten Anmerkungen erläutert.
@Entity Annotation
Die EJB 3-Standardanmerkungen sind in der enthalten javax.persistencePaket, also importieren wir dieses Paket als ersten Schritt. Zweitens haben wir die verwendet@Entity Annotation zur Employee-Klasse, die diese Klasse als Entity-Bean kennzeichnet. Daher muss sie einen Konstruktor ohne Argumente haben, der zumindest mit einem geschützten Bereich sichtbar ist.
@Table Annotation
Mit der Annotation @Table können Sie die Details der Tabelle angeben, mit denen die Entität in der Datenbank beibehalten wird.
Die Annotation @Table bietet vier Attribute, mit denen Sie den Namen der Tabelle, ihren Katalog und ihr Schema überschreiben und eindeutige Einschränkungen für Spalten in der Tabelle erzwingen können. Im Moment verwenden wir nur den Tabellennamen EMPLOYEE.
Anmerkungen zu @Id und @GeneratedValue
Jede Entity-Bean verfügt über einen Primärschlüssel, den Sie mit dem mit der Klasse versehen @IdAnmerkung. Der Primärschlüssel kann je nach Tabellenstruktur ein einzelnes Feld oder eine Kombination mehrerer Felder sein.
Standardmäßig bestimmt die @ ID-Annotation automatisch die am besten geeignete Strategie zur Generierung von Primärschlüsseln. Sie können diese jedoch überschreiben, indem Sie die anwenden @GeneratedValue Annotation, die zwei Parameter akzeptiert strategy und generatorDas werde ich hier nicht diskutieren. Verwenden wir also nur die Standardstrategie zur Schlüsselgenerierung. Wenn Sie den Ruhezustand bestimmen lassen, welcher Generatortyp verwendet werden soll, kann Ihr Code zwischen verschiedenen Datenbanken portiert werden.
@ Spaltenanmerkung
Die Annotation @Column wird verwendet, um die Details der Spalte anzugeben, der ein Feld oder eine Eigenschaft zugeordnet werden soll. Sie können Spaltenanmerkungen mit den folgenden am häufigsten verwendeten Attributen verwenden:
name Mit dem Attribut kann der Name der Spalte explizit angegeben werden.
length Das Attribut ermöglicht die Größe der Spalte, die zum Zuordnen eines Werts verwendet wird, insbesondere für einen Zeichenfolgenwert.
nullable Mit dem Attribut kann die Spalte beim Generieren des Schemas als NICHT NULL markiert werden.
unique Mit dem Attribut kann die Spalte so markiert werden, dass sie nur eindeutige Werte enthält.
Anwendungsklasse erstellen
Schließlich erstellen wir unsere Anwendungsklasse mit der main () -Methode, um die Anwendung auszuführen. Wir werden diese Anwendung verwenden, um einige Mitarbeiterdatensätze zu speichern, und dann werden wir CRUD-Operationen auf diese Datensätze anwenden.
import java.util.List;
import java.util.Date;
import java.util.Iterator;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class ManageEmployee {
private static SessionFactory factory;
public static void main(String[] args) {
try {
factory = new AnnotationConfiguration().
configure().
//addPackage("com.xyz") //add package if used.
addAnnotatedClass(Employee.class).
buildSessionFactory();
} catch (Throwable ex) {
System.err.println("Failed to create sessionFactory object." + ex);
throw new ExceptionInInitializerError(ex);
}
ManageEmployee ME = new ManageEmployee();
/* Add few employee records in database */
Integer empID1 = ME.addEmployee("Zara", "Ali", 1000);
Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
Integer empID3 = ME.addEmployee("John", "Paul", 10000);
/* List down all the employees */
ME.listEmployees();
/* Update employee's records */
ME.updateEmployee(empID1, 5000);
/* Delete an employee from the database */
ME.deleteEmployee(empID2);
/* List down new list of the employees */
ME.listEmployees();
}
/* Method to CREATE an employee in the database */
public Integer addEmployee(String fname, String lname, int salary){
Session session = factory.openSession();
Transaction tx = null;
Integer employeeID = null;
try {
tx = session.beginTransaction();
Employee employee = new Employee();
employee.setFirstName(fname);
employee.setLastName(lname);
employee.setSalary(salary);
employeeID = (Integer) session.save(employee);
tx.commit();
} catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
} finally {
session.close();
}
return employeeID;
}
/* Method to READ all the employees */
public void listEmployees( ){
Session session = factory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
List employees = session.createQuery("FROM Employee").list();
for (Iterator iterator = employees.iterator(); iterator.hasNext();){
Employee employee = (Employee) iterator.next();
System.out.print("First Name: " + employee.getFirstName());
System.out.print(" Last Name: " + employee.getLastName());
System.out.println(" Salary: " + employee.getSalary());
}
tx.commit();
} catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
} finally {
session.close();
}
}
/* Method to UPDATE salary for an employee */
public void updateEmployee(Integer EmployeeID, int salary ){
Session session = factory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
Employee employee = (Employee)session.get(Employee.class, EmployeeID);
employee.setSalary( salary );
session.update(employee);
tx.commit();
} catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
} finally {
session.close();
}
}
/* Method to DELETE an employee from the records */
public void deleteEmployee(Integer EmployeeID){
Session session = factory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
Employee employee = (Employee)session.get(Employee.class, EmployeeID);
session.delete(employee);
tx.commit();
} catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
} finally {
session.close();
}
}
}Datenbankkonfiguration
Lassen Sie uns jetzt erstellen hibernate.cfg.xml Konfigurationsdatei zum Definieren datenbankbezogener Parameter.
<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name = "hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</property>
<property name = "hibernate.connection.driver_class">
com.mysql.jdbc.Driver
</property>
<!-- Assume students is the database name -->
<property name = "hibernate.connection.url">
jdbc:mysql://localhost/test
</property>
<property name = "hibernate.connection.username">
root
</property>
<property name = "hibernate.connection.password">
cohondob
</property>
</session-factory>
</hibernate-configuration>Zusammenstellung und Ausführung
Hier sind die Schritte zum Kompilieren und Ausführen der oben genannten Anwendung. Stellen Sie sicher, dass Sie PATH und CLASSPATH entsprechend eingestellt haben, bevor Sie mit der Kompilierung und Ausführung fortfahren.
Löschen Sie die Zuordnungsdatei Employee.hbm.xml aus dem Pfad.
Erstellen Sie die Quelldatei Employee.java wie oben gezeigt und kompilieren Sie sie.
Erstellen Sie die Quelldatei ManageEmployee.java wie oben gezeigt und kompilieren Sie sie.
Führen Sie die ManageEmployee-Binärdatei aus, um das Programm auszuführen.
Sie würden das folgende Ergebnis erhalten und Datensätze würden in der Tabelle EMPLOYEE erstellt.
$java ManageEmployee
.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........
First Name: Zara Last Name: Ali Salary: 1000
First Name: Daisy Last Name: Das Salary: 5000
First Name: John Last Name: Paul Salary: 10000
First Name: Zara Last Name: Ali Salary: 5000
First Name: John Last Name: Paul Salary: 10000Wenn Sie Ihre EMPLOYEE-Tabelle überprüfen, sollte sie die folgenden Datensätze enthalten:
mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 29 | Zara | Ali | 5000 |
| 31 | John | Paul | 10000 |
+----+------------+-----------+--------+
2 rows in set (0.00 sec
mysql>