Integração com Struts 2 e Hibernate

O Hibernate é um serviço de consulta e persistência Objeto / Relacional de alto desempenho, licenciado sob a licença GNU Lesser General Public License (LGPL) e de download gratuito. Neste capítulo. vamos aprender como obter a integração do Struts 2 com o Hibernate. Se você não está familiarizado com o Hibernate, pode verificar nosso tutorial do Hibernate .

Configuração do banco de dados

Para este tutorial, vou usar o banco de dados MySQL "struts2_tutorial". Eu me conecto a este banco de dados na minha máquina usando o nome de usuário "root" e sem senha. Em primeiro lugar, você precisa executar o seguinte script. Este script cria uma nova tabela chamadastudent e cria poucos registros nesta tabela -

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

Configuração do Hibernate

Em seguida, vamos criar o hibernate.cfg.xml, que é o arquivo de configuração do 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>

Vamos examinar o arquivo de configuração de hibernação. Primeiro, declaramos que estamos usando o driver MySQL. Em seguida, declaramos o url jdbc para conexão com o banco de dados. Em seguida, declaramos o nome de usuário, a senha e o tamanho do pool da conexão. Também indicamos que gostaríamos de ver o SQL no arquivo de log ativando "show_sql" para true. Siga o tutorial de hibernação para entender o que essas propriedades significam.

Finalmente, definimos a classe de mapeamento como com.tutorialspoint.hibernate.Student, que criaremos neste capítulo.

Configuração de ambiente

Em seguida, você precisa de muitos frascos para este projeto. Em anexo está uma captura de tela da lista completa de arquivos JAR necessários -

A maioria dos arquivos JAR pode ser obtida como parte da distribuição do struts. Se você tiver um servidor de aplicativos como glassfish, websphere ou jboss instalado, poderá obter a maioria dos arquivos jar restantes da pasta lib do appserver. Se não, você pode baixar os arquivos individualmente -

Arquivos jar do Hibernate - Hibernate.org
Plugin de hibernação do Struts - plugin de hibernação do Struts
Arquivos JTA - arquivos JTA
Arquivos Dom4j - Dom4j
arquivos log4j - log4j

O restante dos arquivos, você deve conseguir obter na distribuição do Struts2.

Classes de Hibernate

Vamos agora criar as classes java necessárias para a integração do hibernate. A seguir está o conteúdo 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 é uma classe POJO que representa o studenttabela de acordo com as especificações do Hibernate. Possui as propriedades id, firstName e lastName que correspondem aos nomes das colunas da tabela do aluno. Em seguida, vamos criarStudentDAO.java arquivo da seguinte forma -

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

A classe StudentDAO é a camada de acesso aos dados da classe Student. Possui métodos para listar todos os alunos e, em seguida, salvar um novo registro do aluno.

Classe de Ação

Arquivo seguinte AddStudentAction.javadefine nossa classe de ação. Temos dois métodos de ação aqui - execute () e listStudents (). O método execute () é usado para adicionar o novo registro do aluno. Usamos o método save () do dao para fazer isso.

O outro método, listStudents (), é usado para listar os alunos. Usamos o método de lista do dao para obter a lista de todos os alunos.

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

Você notará que estamos implementando a interface ModelDriven. Isso é usado quando sua classe de ação está lidando com uma classe de modelo concreto (como Student), em oposição a propriedades individuais (como firstName, lastName). A interface ModelAware requer que você implemente um método para retornar o modelo. Em nosso caso, estamos retornando o objeto "aluno".

Criar arquivos de visualização

Vamos agora criar o student.jsp visualizar arquivo com o seguinte conteúdo -

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

O student.jsp é bastante direto. Na seção superior, temos um formulário enviado para "addStudent.action". Recebe firstName, lastName e marks. Como a ação addStudent está vinculada ao ModelAware "AddSudentAction", automaticamente um bean de aluno será criado com os valores de firstName, lastName e marcas preenchidas automaticamente.

Na seção inferior, examinamos a lista de alunos (consulte AddStudentAction.java). Nós iteramos pela lista e exibimos os valores de nome, sobrenome e marcas em uma tabela.

Configuração Struts

Vamos juntar tudo 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>

O importante a notar aqui é que nosso pacote "myhibernate" estende o pacote padrão struts2 chamado "hibernate-default". Em seguida, declaramos duas ações - addStudent e listStudents. addStudent chama execute () na classe AddStudentAction e, em caso de sucesso, chama o método de ação listStudents.

O método de ação listStudent chama listStudents () na classe AddStudentAction e usa student.jsp como visualização.

Agora, clique com o botão direito no nome do projeto e clique em Export > WAR Filepara criar um arquivo de guerra. Em seguida, implante esse WAR no diretório webapps do Tomcat. Finalmente, inicie o servidor Tomcat e tente acessar o URLhttp://localhost:8080/HelloWorldStruts2/student.jsp. Isso produzirá a seguinte tela -

Na seção superior, obtemos um formulário para inserir os valores de um novo registro de aluno e a seção inferior lista os alunos no banco de dados. Vá em frente e adicione um novo registro do aluno e pressione enviar. A tela será atualizada e mostrará uma lista atualizada sempre que você clicar em Enviar.

↰ Previous page Next page ↱