Integración de Struts 2 e Hibernate

Hibernate es un servicio de consulta y persistencia de objetos / relacionales de alto rendimiento que tiene la licencia GNU Lesser General Public License (LGPL) de código abierto y se puede descargar gratis. En este capítulo. vamos a aprender cómo lograr la integración de Struts 2 con Hibernate. Si no está familiarizado con Hibernate, puede consultar nuestro tutorial de Hibernate .

Configuración de la base de datos

Para este tutorial, voy a utilizar la base de datos MySQL "struts2_tutorial". Me conecto a esta base de datos en mi máquina usando el nombre de usuario "root" y sin contraseña. En primer lugar, debe ejecutar el siguiente script. Este script crea una nueva tabla llamadastudent y crea pocos registros en esta tabla -

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

Configuración de hibernación

A continuación, creemos el archivo hibernate.cfg.xml, que es el archivo de configuración de 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>

Repasemos el archivo de configuración de hibernación. Primero, declaramos que estamos usando el controlador MySQL. Luego declaramos la url jdbc para conectarnos a la base de datos. Luego declaramos el nombre de usuario, la contraseña y el tamaño del grupo de la conexión. También indicamos que nos gustaría ver el SQL en el archivo de registro activando "show_sql" en verdadero. Consulte el tutorial de hibernación para comprender qué significan estas propiedades.

Finalmente, configuramos la clase de mapeo en com.tutorialspoint.hibernate.Student que crearemos en este capítulo.

Configuración ambiental

A continuación, necesita muchos frascos para este proyecto. Se adjunta una captura de pantalla de la lista completa de archivos JAR necesarios:

La mayoría de los archivos JAR se pueden obtener como parte de su distribución de struts. Si tiene un servidor de aplicaciones como glassfish, websphere o jboss instalado, entonces puede obtener la mayoría de los archivos jar restantes de la carpeta lib del servidor de aplicaciones. Si no, puede descargar los archivos individualmente -

Archivos jar de Hibernate - Hibernate.org
Complemento Struts hibernate - Complemento Struts hibernate
Archivos JTA - archivos JTA
Archivos Dom4j - Dom4j
archivos log4j - log4j

El resto de los archivos, debería poder obtenerlos de su distribución Struts2.

Clases de hibernación

Creemos ahora las clases java necesarias para la integración de hibernación. A continuación se muestra el contenido 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;
   }
}

Esta es una clase POJO que representa el studenttabla según la especificación de Hibernate. Tiene las propiedades id, firstName y lastName que corresponden a los nombres de columna de la tabla de estudiantes. Siguiente vamos a crearStudentDAO.java archivo de la siguiente manera:

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 clase StudentDAO es la capa de acceso a datos para la clase Student. Tiene métodos para listar todos los estudiantes y luego guardar un nuevo registro de estudiante.

Clase de acción

Siguiente archivo AddStudentAction.javadefine nuestra clase de acción. Tenemos dos métodos de acción aquí: execute () y listStudents (). El método execute () se usa para agregar el nuevo registro de estudiante. Usamos el método save () de dao para lograr esto.

El otro método, listStudents () se usa para listar los estudiantes. Usamos el método de lista de dao para obtener la lista de todos los estudiantes.

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

Notará que estamos implementando la interfaz ModelDriven. Esto se usa cuando su clase de acción se trata de una clase de modelo concreta (como Estudiante) en lugar de propiedades individuales (como nombre, apellido). La interfaz ModelAware requiere que implemente un método para devolver el modelo. En nuestro caso, estamos devolviendo el objeto "estudiante".

Crear archivos de vista

Creemos ahora el student.jsp ver archivo con el siguiente contenido -

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

El student.jsp es bastante sencillo. En la sección superior, tenemos un formulario que se envía a "addStudent.action". Toma nombre, apellido y marcas. Debido a que la acción addStudent está vinculada a la "AddSudentAction" de ModelAware, automáticamente se creará un bean de estudiante con los valores de firstName, lastName y las marcas autocompletadas.

En la sección inferior, revisamos la lista de estudiantes (ver AddStudentAction.java). Repetimos la lista y mostramos los valores de nombre, apellido y marcas en una tabla.

Configuración de puntales

Pongamos todo junto 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>

Lo importante a notar aquí es que nuestro paquete "myhibernate" extiende el paquete predeterminado de struts2 llamado "hibernate-default". Luego declaramos dos acciones: addStudent y listStudents. addStudent llama a execute () en la clase AddStudentAction y luego, cuando tiene éxito, llama al método de acción listStudents.

El método de acción listStudent llama a listStudents () en la clase AddStudentAction y usa student.jsp como vista.

Ahora, haga clic derecho en el nombre del proyecto y haga clic en Export > WAR Filepara crear un archivo War. Luego, implemente este WAR en el directorio de aplicaciones web de Tomcat. Finalmente, inicie el servidor Tomcat e intente acceder a la URLhttp://localhost:8080/HelloWorldStruts2/student.jsp. Esto producirá la siguiente pantalla:

En la sección superior, obtenemos un formulario para ingresar los valores para un nuevo registro de estudiante y la sección inferior enumera los estudiantes en la base de datos. Continúe y agregue un nuevo registro de estudiante y presione enviar. La pantalla se actualizará y le mostrará una lista actualizada cada vez que haga clic en Enviar.

↰ Previous page Next page ↱