Intégration de Struts 2 et Hibernate
Hibernate est un service de persistance et de requête objet / relationnel hautes performances qui est sous licence open source GNU Lesser General Public License (LGPL) et est téléchargeable gratuitement. Dans ce chapitre. nous allons apprendre comment réaliser l'intégration de Struts 2 avec Hibernate. Si vous n'êtes pas familier avec Hibernate, vous pouvez consulter notre didacticiel Hibernate .
Configuration de la base de données
Pour ce tutoriel, je vais utiliser la base de données MySQL "struts2_tutorial". Je me connecte à cette base de données sur ma machine en utilisant le nom d'utilisateur "root" et aucun mot de passe. Tout d'abord, vous devez exécuter le script suivant. Ce script crée une nouvelle table appeléestudent et crée quelques enregistrements dans ce tableau -
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);Configuration de la mise en veille prolongée
Ensuite, créons le hibernate.cfg.xml qui est le fichier de configuration de l'hibernate.
<?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>Passons en revue le fichier de configuration d'hibernation. Tout d'abord, nous avons déclaré que nous utilisons le pilote MySQL. Ensuite, nous avons déclaré l'url jdbc pour la connexion à la base de données. Ensuite, nous avons déclaré le nom d'utilisateur, le mot de passe et la taille du pool de la connexion. Nous avons également indiqué que nous aimerions voir le SQL dans le fichier journal en activant "show_sql" sur true. Veuillez parcourir le didacticiel de mise en veille prolongée pour comprendre ce que signifient ces propriétés.
Enfin, nous définissons la classe de mappage sur com.tutorialspoint.hibernate.Student que nous créerons dans ce chapitre.
Configuration de l'environnement
Ensuite, vous avez besoin de beaucoup de pots pour ce projet. Vous trouverez ci-joint une capture d'écran de la liste complète des fichiers JAR requis -
La plupart des fichiers JAR peuvent être obtenus dans le cadre de votre distribution struts. Si vous avez un serveur d'applications tel que glassfish, websphere ou jboss installé, vous pouvez obtenir la majorité des fichiers jar restants à partir du dossier lib du serveur d'applications. Sinon, vous pouvez télécharger les fichiers individuellement -
Fichiers JAR Hibernate - Hibernate.org
Plugin Hibernate Struts - Plugin Hibernate Struts
Fichiers JTA - fichiers JTA
Fichiers Dom4j - Dom4j
fichiers log4j - log4j
Reste des fichiers, vous devriez pouvoir obtenir de votre distribution Struts2.
Classes de mise en veille prolongée
Créons maintenant les classes Java requises pour l'intégration hibernate. Voici le contenu deStudent.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;
}
}Il s'agit d'une classe POJO qui représente le studenttable selon les spécifications Hibernate. Il a les propriétés id, firstName et lastName qui correspondent aux noms de colonne de la table Student. Ensuite, créonsStudentDAO.java fichier comme suit -
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);
}
}La classe StudentDAO est la couche d'accès aux données de la classe Student. Il a des méthodes pour lister tous les étudiants, puis pour sauvegarder un nouveau dossier étudiant.
Classe d'action
Fichier suivant AddStudentAction.javadéfinit notre classe d'action. Nous avons deux méthodes d'action ici - execute () et listStudents (). La méthode execute () est utilisée pour ajouter le nouvel enregistrement étudiant. Nous utilisons la méthode save () du dao pour y parvenir.
L'autre méthode, listStudents () est utilisée pour lister les étudiants. Nous utilisons la méthode de liste de dao pour obtenir la liste de tous les élèves.
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;
}
}Vous remarquerez que nous implémentons l'interface ModelDriven. Ceci est utilisé lorsque votre classe d'action traite une classe de modèle concrète (telle que Student) par opposition à des propriétés individuelles (telles que firstName, lastName). L'interface ModelAware nécessite que vous implémentiez une méthode pour renvoyer le modèle. Dans notre cas, nous retournons l'objet "étudiant".
Créer des fichiers de vue
Créons maintenant le student.jsp afficher le fichier avec le contenu suivant -
<%@ 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>Le fichier student.jsp est assez simple. Dans la section supérieure, nous avons un formulaire qui se soumet à "addStudent.action". Il prend firstName, lastName et les marques. Étant donné que l'action addStudent est liée à ModelAware "AddSudentAction", un bean étudiant sera automatiquement créé avec les valeurs de firstName, lastName et les marques remplies automatiquement.
Dans la partie inférieure, nous parcourons la liste des étudiants (voir AddStudentAction.java). Nous parcourons la liste et affichons les valeurs du prénom, du nom et des marques dans un tableau.
Configuration des jambes de force
Mettons tout cela ensemble en utilisant 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>La chose importante à noter ici est que notre paquet "myhibernate" étend le paquetage par défaut struts2 appelé "hibernate-default". Nous déclarons ensuite deux actions - addStudent et listStudents. addStudent appelle la méthode execute () sur la classe AddStudentAction, puis en cas de succès, il appelle la méthode d'action listStudents.
La méthode d'action listStudent appelle le listStudents () sur la classe AddStudentAction et utilise le student.jsp comme vue.
Maintenant, faites un clic droit sur le nom du projet et cliquez sur Export > WAR Filepour créer un fichier War. Déployez ensuite ce WAR dans le répertoire webapps de Tomcat. Enfin, démarrez le serveur Tomcat et essayez d'accéder à l'URLhttp://localhost:8080/HelloWorldStruts2/student.jsp. Cela produira l'écran suivant -
Dans la section supérieure, nous obtenons un formulaire pour saisir les valeurs d'un nouvel enregistrement d'étudiant et la section inférieure répertorie les étudiants dans la base de données. Allez-y, ajoutez un nouveau dossier d'étudiant et appuyez sur Soumettre. L'écran s'actualisera et vous montrera une liste mise à jour chaque fois que vous cliquez sur Soumettre.