Struts 2 e Hibernate Integration

Hibernate è un servizio di query e persistenza oggetto / relazionale ad alte prestazioni concesso in licenza in base alla GNU Lesser General Public License (LGPL) open source ed è scaricabile gratuitamente. In questo capitolo. impareremo come ottenere l'integrazione di Struts 2 con Hibernate. Se non hai familiarità con Hibernate, puoi controllare il nostro tutorial Hibernate .

Configurazione del database

Per questo tutorial, userò il database MySQL "struts2_tutorial". Mi collego a questo database sulla mia macchina utilizzando il nome utente "root" e nessuna password. Prima di tutto, devi eseguire il seguente script. Questo script crea una nuova tabella chiamatastudent e crea pochi record in questa tabella -

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);

Configurazione di ibernazione

Quindi creiamo hibernate.cfg.xml che è il file di configurazione di 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>

Esaminiamo il file di configurazione di ibernazione. Innanzitutto, abbiamo dichiarato che stiamo utilizzando il driver MySQL. Quindi abbiamo dichiarato l'URL jdbc per la connessione al database. Quindi abbiamo dichiarato il nome utente, la password e la dimensione del pool della connessione. Abbiamo anche indicato che vorremmo vedere l'SQL nel file di registro attivando "show_sql" su true. Segui il tutorial di ibernazione per capire cosa significano queste proprietà.

Infine, impostiamo la classe di mappatura com.tutorialspoint.hibernate.Student che creeremo in questo capitolo.

Configurazione dell'ambiente

Successivamente hai bisogno di un sacco di barattoli per questo progetto. In allegato è uno screenshot dell'elenco completo dei file JAR richiesti -

La maggior parte dei file JAR può essere ottenuta come parte della distribuzione di struts. Se è installato un server delle applicazioni come glassfish, websphere o jboss, è possibile ottenere la maggior parte dei file jar rimanenti dalla cartella lib del server delle applicazioni. In caso contrario, puoi scaricare i file individualmente -

File jar di ibernazione - Hibernate.org
Plugin di ibernazione di Struts - Plugin di ibernazione di Struts
File JTA: file JTA
File dom4j - Dom4j
file log4j - log4j

Il resto dei file, dovresti essere in grado di ottenerlo dalla tua distribuzione Struts2.

Classi di ibernazione

Creiamo ora le classi java richieste per l'integrazione di ibernazione. Di seguito è riportato il contenuto diStudent.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;
   }
}

Questa è una classe POJO che rappresenta il file studenttabella secondo le specifiche di Hibernate. Ha proprietà id, firstName e lastName che corrispondono ai nomi delle colonne della tabella degli studenti. Quindi creiamoStudentDAO.java file come segue -

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 è il livello di accesso ai dati per la classe Student. Ha metodi per elencare tutti gli studenti e quindi per salvare un nuovo record studente.

Classe di azione

File seguente AddStudentAction.javadefinisce la nostra classe di azione. Abbiamo due metodi di azione qui: execute () e listStudents (). Il metodo execute () viene utilizzato per aggiungere il nuovo record dello studente. Usiamo il metodo save () di dao per ottenere questo risultato.

L'altro metodo, listStudents () viene utilizzato per elencare gli studenti. Usiamo il metodo dell'elenco di dao per ottenere l'elenco di tutti gli studenti.

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;
   }
	
}

Noterai che stiamo implementando l'interfaccia ModelDriven. Viene utilizzato quando la classe di azione ha a che fare con una classe modello concreta (come Student) anziché con proprietà individuali (come firstName, lastName). L'interfaccia ModelAware richiede di implementare un metodo per restituire il modello. Nel nostro caso restituiamo l'oggetto "studente".

Crea file di visualizzazione

Creiamo ora il file student.jsp visualizza file con il seguente contenuto -

<%@ 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>

Student.jsp è piuttosto semplice. Nella sezione superiore, abbiamo un modulo che invia a "addStudent.action". Accetta firstName, lastName e mark. Poiché l'azione addStudent è collegata a ModelAware "AddSudentAction", automaticamente verrà creato un bean studente con i valori per firstName, lastName e contrassegni popolati automaticamente.

Nella sezione inferiore, esaminiamo l'elenco degli studenti (vedi AddStudentAction.java). Scorriamo l'elenco e visualizziamo i valori per nome, cognome e contrassegni in una tabella.

Configurazione Struts

Mettiamo tutto insieme usando 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 cosa importante da notare qui è che il nostro pacchetto "myhibernate" estende il pacchetto predefinito di struts2 chiamato "hibernate-default". Dichiariamo quindi due azioni: addStudent e listStudents. addStudent chiama execute () sulla classe AddStudentAction e quindi, in caso di esito positivo, chiama il metodo di azione listStudents.

Il metodo di azione listStudent chiama listStudents () sulla classe AddStudentAction e utilizza student.jsp come vista.

Ora, fai clic con il pulsante destro del mouse sul nome del progetto e fai clic Export > WAR Fileper creare un file War. Quindi distribuire questo WAR nella directory webapps di Tomcat. Infine, avvia il server Tomcat e prova ad accedere all'URLhttp://localhost:8080/HelloWorldStruts2/student.jsp. Questo produrrà la seguente schermata:

Nella sezione superiore, otteniamo un modulo per inserire i valori per un nuovo record studente e la sezione inferiore elenca gli studenti nel database. Vai avanti e aggiungi un nuovo record studente e premi Invia. La schermata si aggiornerà e ti mostrerà un elenco aggiornato ogni volta che fai clic su Invia.

↰ Previous page Next page ↱

Struts 2 e Hibernate Integration

Configurazione del database

Configurazione di ibernazione

Configurazione dell'ambiente

Classi di ibernazione

Classe di azione

Crea file di visualizzazione

Configurazione Struts

Integrazioni di Struts 2

Struts 2 Tag

Tutorial su Struts 2

Struts 2 Risorse utili