Struts 2 und Hibernate Integration
Hibernate ist ein leistungsstarker Objekt- / relationaler Persistenz- und Abfragedienst, der unter der Open-Source-Lizenz GNU Lesser General Public License (LGPL) lizenziert ist und kostenlos heruntergeladen werden kann. In diesem Kapitel. Wir werden lernen, wie man die Struts 2-Integration mit Hibernate erreicht. Wenn Sie mit Hibernate nicht vertraut sind, können Sie unser Hibernate-Tutorial lesen .
Datenbank-Setup
Für dieses Tutorial werde ich die MySQL-Datenbank "struts2_tutorial" verwenden. Ich verbinde mich mit dieser Datenbank auf meinem Computer mit dem Benutzernamen "root" und ohne Passwort. Zunächst müssen Sie das folgende Skript ausführen. Dieses Skript erstellt eine neue Tabelle mit dem Namenstudent und erstellt nur wenige Datensätze in dieser Tabelle -
CREATE TABLE IF NOT EXISTS `student` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`first_name` varchar(40) NOT NULL,
`last_name` varchar(40) NOT NULL,
`marks` int(11) NOT NULL,
PRIMARY KEY (`id`)
);
--
-- Dumping data for table `student`
--
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
VALUES(1, 'George', 'Kane', 20);
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
VALUES(2, 'Melissa', 'Michael', 91);
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
VALUES(3, 'Jessica', 'Drake', 21);
Konfiguration im Ruhezustand
Als nächstes erstellen wir die Datei hibernate.cfg.xml, die die Konfigurationsdatei des Ruhezustands ist.
<?xml version = '1.0' encoding = 'utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name = "hibernate.connection.driver_class">c
om.mysql.jdbc.Driver
</property>
<property name = "hibernate.connection.url">
jdbc:mysql://www.tutorialspoint.com/struts_tutorial
</property>
<property name = "hibernate.connection.username">root</property>
<property name = "hibernate.connection.password"></property>
<property name = "hibernate.connection.pool_size">10</property>
<property name = "show_sql">true</property>
<property name = "dialect">
org.hibernate.dialect.MySQLDialect
</property>
<property name = "hibernate.hbm2ddl.auto">update</property>
<mapping class = "com.tutorialspoint.hibernate.Student" />
</session-factory>
</hibernate-configuration>
Lassen Sie uns die Konfigurationsdatei für den Ruhezustand durchgehen. Zuerst haben wir erklärt, dass wir den MySQL-Treiber verwenden. Dann haben wir die jdbc-URL für die Verbindung zur Datenbank deklariert. Dann haben wir den Benutzernamen, das Passwort und die Poolgröße der Verbindung angegeben. Wir haben auch angegeben, dass wir die SQL in der Protokolldatei sehen möchten, indem wir "show_sql" auf true setzen. Bitte lesen Sie das Tutorial zum Ruhezustand, um zu verstehen, was diese Eigenschaften bedeuten.
Schließlich setzen wir die Mapping-Klasse auf com.tutorialspoint.hibernate.Student, die wir in diesem Kapitel erstellen werden.
Envrionment Setup
Als nächstes benötigen Sie eine ganze Menge Gläser für dieses Projekt. Im Anhang finden Sie einen Screenshot der vollständigen Liste der erforderlichen JAR-Dateien.
Die meisten JAR-Dateien können als Teil Ihrer Struts-Distribution abgerufen werden. Wenn Sie einen Anwendungsserver wie glassfish, websphere oder jboss installiert haben, können Sie den Großteil der verbleibenden JAR-Dateien aus dem lib-Ordner des Anwendungsservers abrufen. Wenn nicht, können Sie die Dateien einzeln herunterladen -
Jibernate-JAR-Dateien - Hibernate.org
Struts Hibernate Plugin - Struts Hibernate Plugin
JTA-Dateien - JTA-Dateien
Dom4j-Dateien - Dom4j
log4j-Dateien - log4j
Die restlichen Dateien sollten Sie von Ihrer Struts2-Distribution erhalten können.
Ruhezustand Klassen
Lassen Sie uns nun die erforderlichen Java-Klassen für die Integration in den Ruhezustand erstellen. Es folgt der Inhalt vonStudent.java - -
package com.tutorialspoint.hibernate;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "student")
public class Student {
@Id
@GeneratedValue
private int id;
@Column(name = "last_name")
private String lastName;
@Column(name = "first_name")
private String firstName;
private int marks;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public int getMarks() {
return marks;
}
public void setMarks(int marks) {
this.marks = marks;
}
}
Dies ist eine POJO-Klasse, die die studentTabelle gemäß Hibernate-Spezifikation. Es hat die Eigenschaften id, firstName und lastName, die den Spaltennamen der Schülertabelle entsprechen. Als nächstes lassen Sie uns erstellenStudentDAO.java Datei wie folgt -
package com.tutorialspoint.hibernate;
import java.util.ArrayList;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.googlecode.s2hibernate.struts2.plugin.\
annotations.SessionTarget;
import com.googlecode.s2hibernate.struts2.plugin.\
annotations.TransactionTarget;
public class StudentDAO {
@SessionTarget
Session session;
@TransactionTarget
Transaction transaction;
@SuppressWarnings("unchecked")
public List<Student> getStudents() {
List<Student> students = new ArrayList<Student>();
try {
students = session.createQuery("from Student").list();
} catch(Exception e) {
e.printStackTrace();
}
return students;
}
public void addStudent(Student student) {
session.save(student);
}
}
Die StudentDAO-Klasse ist die Datenzugriffsschicht für die Student-Klasse. Es gibt Methoden, um alle Schüler aufzulisten und dann einen neuen Schülerdatensatz zu speichern.
Aktionsklasse
Folgende Datei AddStudentAction.javadefiniert unsere Aktionsklasse. Wir haben hier zwei Aktionsmethoden - execute () und listStudents (). Die Methode execute () wird verwendet, um den neuen Schülerdatensatz hinzuzufügen. Wir verwenden die save () -Methode des Dao, um dies zu erreichen.
Die andere Methode, listStudents (), wird verwendet, um die Schüler aufzulisten. Wir verwenden die Listenmethode des Dao, um die Liste aller Schüler zu erhalten.
package com.tutorialspoint.struts2;
import java.util.ArrayList;
import java.util.List;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.tutorialspoint.hibernate.Student;
import com.tutorialspoint.hibernate.StudentDAO;
public class AddStudentAction extends ActionSupport implements ModelDriven<Student> {
Student student = new Student();
List<Student> students = new ArrayList<Student>();
StudentDAO dao = new StudentDAO();
@Override
public Student getModel() {
return student;
}
public String execute() {
dao.addStudent(student);
return "success";
}
public String listStudents() {
students = dao.getStudents();
return "success";
}
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
public List<Student> getStudents() {
return students;
}
public void setStudents(List<Student> students) {
this.students = students;
}
}
Sie werden feststellen, dass wir die ModelDriven-Schnittstelle implementieren. Dies wird verwendet, wenn Ihre Aktionsklasse eine konkrete Modellklasse (z. B. Student) im Gegensatz zu einzelnen Eigenschaften (z. B. Vorname, Nachname) verwendet. Für die ModelAware-Schnittstelle müssen Sie eine Methode implementieren, um das Modell zurückzugeben. In unserem Fall geben wir das Objekt "student" zurück.
Ansichtsdateien erstellen
Lassen Sie uns jetzt die erstellen student.jsp Datei mit folgendem Inhalt anzeigen -
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head />
</head>
<body>
<s:form action = "addStudent">
<s:textfield name = "firstName" label = "First Name"/>
<s:textfield name = "lastName" label = "Last Name"/>
<s:textfield name = "marks" label = "Marks"/>
<s:submit/>
<hr/>
<table>
<tr>
<td>First Name</td>
<td>Last Name</td>
<td>Marks</td>
</tr>
<s:iterator value = "students">
<tr>
<td><s:property value = "firstName"/></td>
<td><s:property value = "lastName"/></td>
<td><s:property value = "marks"/></td>
</tr>
</s:iterator>
</table>
</s:form>
</body>
</html>
Die student.jsp ist ziemlich einfach. Im oberen Bereich haben wir ein Formular, das an "addStudent.action" gesendet wird. Es nimmt Vorname, Nachname und Markierungen auf. Da die Aktion addStudent an die ModelAware "AddSudentAction" gebunden ist, wird automatisch eine Schüler-Bean mit den Werten für Vorname, Nachname und Markierungen erstellt, die automatisch ausgefüllt werden.
Im unteren Bereich gehen wir die Studentenliste durch (siehe AddStudentAction.java). Wir durchlaufen die Liste und zeigen die Werte für Vorname, Nachname und Markierungen in einer Tabelle an.
Strebenkonfiguration
Lassen Sie uns alles mit zusammenfügen struts.xml - -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "myhibernate" extends = "hibernate-default">
<action name = "addStudent" method = "execute"
class = "com.tutorialspoint.struts2.AddStudentAction">
<result name = "success" type = "redirect">
listStudents
</result>
</action>
<action name = "listStudents" method = "listStudents"
class = "com.tutorialspoint.struts2.AddStudentAction">
<result name = "success">/students.jsp</result>
</action>
</package>
</struts>
Wichtig hierbei ist, dass unser Paket "myhibernate" das struts2-Standardpaket "hibernate-default" erweitert. Wir deklarieren dann zwei Aktionen - addStudent und listStudents. addStudent ruft die execute () für die AddStudentAction-Klasse auf und ruft dann bei Erfolg die listStudents-Aktionsmethode auf.
Die Aktionsmethode listStudent ruft listStudents () in der AddStudentAction-Klasse auf und verwendet die Datei student.jsp als Ansicht.
Klicken Sie nun mit der rechten Maustaste auf den Projektnamen und klicken Sie auf Export > WAR Fileum eine War-Datei zu erstellen. Stellen Sie diese WAR dann im Webanwendungsverzeichnis von Tomcat bereit. Starten Sie abschließend den Tomcat-Server und versuchen Sie, auf die URL zuzugreifenhttp://localhost:8080/HelloWorldStruts2/student.jsp. Daraufhin wird der folgende Bildschirm angezeigt:
Im oberen Bereich erhalten wir ein Formular zur Eingabe der Werte für einen neuen Schülerdatensatz, und im unteren Bereich werden die Schüler in der Datenbank aufgelistet. Fügen Sie einen neuen Schülerdatensatz hinzu und klicken Sie auf Senden. Der Bildschirm wird aktualisiert und zeigt Ihnen jedes Mal eine aktualisierte Liste an, wenn Sie auf Senden klicken.