Cloud-Lösungen der Zukunft - Testen!

Revolutionäre Cloud-Technologie, ganz ohne versteckte Kosten. Profitieren Sie von unserer Testphase und entdecken Sie umfassende Funktionen. Der Anmeldeprozess ist transparent und unkompliziert. Starten Sie jetzt Ihre Reise in die Cloud - Kostenfrei!

Mit E-Mail anmeldenMit Google anmeldenMit GitHub anmelden

Spring MVC Hibernate MySQL Integration CRUD Beispiel

Wir haben im letzten Tutorial gelernt, wie man Spring und Hibernate integriert. Heute werden wir weitermachen und die Spring MVC und Hibernate Frameworks in einem Webanwendungs-CRUD-Beispiel integrieren. Unsere finale Projektstruktur sieht aus wie das untenstehende Bild, wir werden uns jedes der Komponenten einzeln ansehen.

Beachten Sie, dass ich Spring 4.0.3.Release und Hibernate 4.3.5.Final Versionen für unser Beispiel verwende, das gleiche Programm ist auch kompatibel für Spring 4 und Hibernate 3, jedoch müssen Sie kleine Änderungen in der Spring Bean Konfigurationsdatei vornehmen.

Maven Abhängigkeiten

Lassen Sie uns alle Maven-Abhängigkeiten betrachten, die für die Integration von Hibernate und Spring MVC Framework benötigt werden.

Copy Code


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.journaldev.spring</groupId>
    <artifactId>SpringMVCHibernate</artifactId>
    <name>SpringMVCHibernate</name>
    <packaging>war</packaging>
    <version>1.0.0-BUILD-SNAPSHOT</version>
    <properties>
        <java-version>1.6</java-version>
        <org.springframework-version>4.0.3.RELEASE</org.springframework-version>
        <org.aspectj-version>1.7.4</org.aspectj-version>
        <org.slf4j-version>1.7.5</org.slf4j-version>
        <hibernate.version>4.3.5.Final</hibernate.version>
    </properties>
    <dependencies>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${org.springframework-version}</version>
            <exclusions>
                <!-- Exclude Commons Logging in favor of SLF4j -->
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                 </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${org.springframework-version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${org.springframework-version}</version>
        </dependency>
        <!-- Hibernate -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!-- Apache Commons DBCP -->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <!-- Spring ORM -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${org.springframework-version}</version>
        </dependency>
        <!-- AspectJ -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>${org.aspectj-version}</version>
        </dependency>	
        <!-- Logging -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${org.slf4j-version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>${org.slf4j-version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${org.slf4j-version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.15</version>
            <exclusions>
                <exclusion>
                    <groupId>javax.mail</groupId>
                    <artifactId>mail</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>javax.jms</groupId>
                    <artifactId>jms</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.sun.jdmk</groupId>
                    <artifactId>jmxtools</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.sun.jmx</groupId>
                    <artifactId>jmxri</artifactId>
                </exclusion>
            </exclusions>
            <scope>runtime</scope>
        </dependency>
        <!-- @Inject -->
        <dependency>
            <groupId>javax.inject</groupId>
            <artifactId>javax.inject</artifactId>
            <version>1</version>
        </dependency>
        <!-- Servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- Test -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.7</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-eclipse-plugin</artifactId>
                <version>2.9</version>
                <configuration>
                    <additionalProjectnatures>
                        <projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
                    </additionalProjectnatures>
<additionalBuildcommands>
                        <buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
                    </additionalBuildcommands>
                    <downloadSources>true</downloadSources>
                    <downloadJavadocs>true</downloadJavadocs>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.5.1</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <compilerArgument>-Xlint:all</compilerArgument>
                    <showWarnings>true</showWarnings>
                    <showDeprecation>true</showDeprecation>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.2.1</version>
                <configuration>
                    <mainClass>org.test.int1.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
        <finalName>${project.artifactId}</finalName>
    </build>
</project>

Einige der Abhängigkeiten oben werden von STS (Spring Tool Suite) eingefügt, wenn ich ein Spring MVC-Projekt erstelle. Wichtige Abhängigkeiten oben sind spring-context, spring-webmvc, spring-tx, hibernate-core, hibernate-entitymanager und spring-orm. Ich verwende Apache Commons DBCP für das Connection Pooling, aber in realen Situationen wird das Connection Pooling meistens vom Container durchgeführt und alles, was wir tun müssen, ist, die JNDI-Referenzdetails bereitzustellen, um es zu nutzen. ANMERKUNG: Ich habe bemerkt, dass einige der Leser Datenbankverbindungsprobleme haben. Beachten Sie, dass in meiner pom.xml kein Datenbanktreiber vorhanden ist. Das funktioniert für mich, weil ich den MySQL-Treiber im Tomcat lib-Verzeichnis habe und einige DataSource-Verbindungen damit konfiguriert sind. Für alle datenbankbezogenen Verbindungsprobleme, setzen Sie entweder den Datenbanktreiber in die Container lib oder fügen Sie diesen in die pom.xml-Abhängigkeiten ein.

Bereitstellungsbeschreibung

Wir müssen das Spring Framework in unserer Webanwendung einbinden, was durch die Konfiguration des Spring Framework DispatcherServlet als Front Controller erfolgt. Unsere web.xml-Datei sieht wie unten aus.

Copy Code


<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="https://java.sun.com/xml/ns/javaee"
    xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

    <!-- The definition of the Root Spring Container shared by all Servlets and Filters -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring/root-context.xml</param-value>
    </context-param>
    
    <!-- Creates the Spring Container shared by all Servlets and Filters -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- Processes application requests -->
    <servlet>
        <servlet-name>appServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
        
    <servlet-mapping>
        <servlet-name>appServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

Der größte Teil ist Boilerplate-Code, der wichtigste Teil ist der Speicherort der Spring-Kontextdatei, wo wir unsere Spring-Beans und -Dienste konfigurieren werden. Wenn Sie möchten, können Sie diese entsprechend den Anforderungen Ihres Projekts ändern.

Hibernate-Entity-Bean

Wir verwenden JPA-Annotationen in unserer Entity-Bean-Klasse, jedoch können wir auch eine einfache Java-Bean und Mapping-Details in der XML-Datei haben. In diesem Fall müssen wir die Details der Mapping-Datei angeben, während wir die Hibernate SessionFactory in den Spring-Bean-Konfigurationen konfigurieren.

Copy Code


package com.journaldev.spring.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * Entity bean with JPA annotations
 * Hibernate provides JPA implementation
 * @author pankaj
 *
 */
@Entity
@Table(name="PERSON")
public class Person {

    @Id
    @Column(name="id")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int id;
    
    private String name;
    
    private String country;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }
    
    @Override
    public String toString(){
        return "id="+id+", name="+name+", country="+country;
    }
}

MySQL Tabellenerstellungsskript

Unsere Entity-Bean wird auf die PERSON-Tabelle in der MySQL-Datenbank abgebildet. Beachten Sie, dass ich die Felder „name“ und „country“ nicht mit der Annotation @Column versehen habe, da sie denselben Namen haben. Das untenstehende SQL-Skript zeigt die Details der Tabelle.

Copy Code


CREATE TABLE `Person` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL DEFAULT '',
  `country` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

PersonDAO Interface

Copy Code


package com.journaldev.spring.dao;

import java.util.List;
import com.journaldev.spring.model.Person;

public interface PersonDAO {

    public void addPerson(Person p);
    public void updatePerson(Person p);
    public List<Person> listPersons();
    public Person getPersonById(int id);
    public void removePerson(int id);
}

Hibernate-spezifische DAO-Implementierung

Copy Code


package com.journaldev.spring.dao;

import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Repository;
import com.journaldev.spring.model.Person;

@Repository
public class PersonDAOImpl implements PersonDAO {
    
    private static final Logger logger = LoggerFactory.getLogger(PersonDAOImpl.class);

    private SessionFactory sessionFactory;
    
    public void setSessionFactory(SessionFactory sf){
        this.sessionFactory = sf;
    }

    @Override
    public void addPerson(Person p) {
        Session session = this.sessionFactory.getCurrentSession();
        session.persist(p);
        logger.info("Person saved successfully, Person Details="+p);
    }

    @Override
    public void updatePerson(Person p) {
        Session session = this.sessionFactory.getCurrentSession();
        session.update(p);
        logger.info("Person updated successfully, Person Details="+p);
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<Person> listPersons() {
        Session session = this.sessionFactory.getCurrentSession();
        List<Person> personsList = session.createQuery("from Person").list();
        for(Person p : personsList){
            logger.info("Person List::"+p);
        }
        return personsList;
    }

    @Override
    public Person getPersonById(int id) {
        Session session = this.sessionFactory.getCurrentSession();		
        Person p = (Person) session.load(Person.class, new Integer(id));
        logger.info("Person loaded successfully, Person details="+p);
        return p;
    }

    @Override
    public void removePerson(int id) {
        Session session = this.sessionFactory.getCurrentSession();
        Person p = (Person) session.load(Person.class, new Integer(id));
        if(null != p){
            session.delete(p);
        }
        logger.info("Person deleted successfully, person details="+p);
    }

}

Beachten Sie, dass ich keine Hibernate-Transaktion verwende, da diese vom Spring Framework übernommen wird.

Spring-Serviceklassen

Copy Code


package com.journaldev.spring.service;

import java.util.List;
import com.journaldev.spring.model.Person;

public interface PersonService {

    public void addPerson(Person p);
    public void updatePerson(Person p);
    public List<Person> listPersons();
    public Person getPersonById(int id);
    public void removePerson(int id);
    
}

Copy Code


package com.journaldev.spring.service;

import java.util.List;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.journaldev.spring.dao.PersonDAO;
import com.journaldev.spring.model.Person;

@Service
public class PersonServiceImpl implements PersonService {
    
    private PersonDAO personDAO;

    public void setPersonDAO(PersonDAO personDAO) {
        this.personDAO = personDAO;
    }

    @Override
    @Transactional
    public void addPerson(Person p) {
        this.personDAO.addPerson(p);
    }

    @Override
    @Transactional
    public void updatePerson(Person p) {
        this.personDAO.updatePerson(p);
    }

    @Override
    @Transactional
    public List<Person> listPersons() {
        return this.personDAO.listPersons();
    }

    @Override
    @Transactional
    public Person getPersonById(int id) {
        return this.personDAO.getPersonById(id);
    }

    @Override
    @Transactional
    public void removePerson(int id) {
        this.personDAO.removePerson(id);
    }

}

Beachten Sie, dass die deklarative Transaktionsverwaltung von Spring durch Verwendung der Annotation @Transactional angewendet wird.

Spring-Controller-Klasse

Unsere DAO- und Serviceklassen sind fertig, es ist an der Zeit, unsere Controller-Klasse zu schreiben, die sich um die Clientanfragen kümmert, die Serviceklassen verwendet, um datenbankspezifische Operationen durchzuführen und dann die Ansichtsseiten zurückgibt.

Copy Code


package com.journaldev.spring;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.journaldev.spring.model.Person;
import com.journaldev.spring.service.PersonService;

@Controller
public class PersonController {
    
    private PersonService personService;
    
    @Autowired(required=true)
    @Qualifier(value="personService")
    public void setPersonService(PersonService ps){
        this.personService = ps;
    }
    
    @RequestMapping(value = "/persons", method = RequestMethod.GET)
    public String listPersons(Model model) {
        model.addAttribute("person", new Person());
        model.addAttribute("listPersons", this.personService.listPersons());
        return "person";
    }
    
    //For add and update person both
    @RequestMapping(value= "/person/add", method = RequestMethod.POST)
    public String addPerson(@ModelAttribute("person") Person p){
        
        if(p.getId() == 0){
            //new person, add it
            this.personService.addPerson(p);
        }else{
            //existing person, call update
            this.personService.updatePerson(p);
        }
        
        return "redirect:/persons";
        
    }
    
    @RequestMapping("/remove/{id}")
    public String removePerson(@PathVariable("id") int id){
        
        this.personService.removePerson(id);
        return "redirect:/persons";
    }
 
    @RequestMapping("/edit/{id}")
    public String editPerson(@PathVariable("id") int id, Model model){
        model.addAttribute("person", this.personService.getPersonById(id));
        model.addAttribute("listPersons", this.personService.listPersons());
        return "person";
    }
    
}

Beachten Sie, dass ich die Annotation @Controller verwende, damit das Spring Framework sie als Controller-Klasse zur Behandlung von Clientanfragen behandelt. Außerdem verwende ich die Annotationen @Autowired und @Qualifier für das Einbinden von PersonService, das hätten wir auch in der Spring-Kontext-XML-Datei machen können.

Spring-Bean-Konfiguration

Unsere Dienste sind bereit, alles, was wir tun müssen, ist sie durch Spring-Bean-Konfigurationen zu verdrahten. Unsere root-context.xml-Datei ist leer, daher werden wir uns nur die servlet-context.xml-Datei ansehen.

Copy Code


<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="https://www.springframework.org/schema/mvc"
    xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:beans="https://www.springframework.org/schema/beans"
    xmlns:context="https://www.springframework.org/schema/context" xmlns:tx="https://www.springframework.org/schema/tx"
    xsi:schemaLocation="https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
        https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
        https://www.springframework.org/schema/tx https://www.springframework.org/schema/tx/spring-tx-4.0.xsd">

    <!-- DispatcherServlet Context: defines this servlet's request-processing 
        infrastructure -->

    <!-- Enables the Spring MVC @Controller programming model -->
    <annotation-driven />

    <!-- Handles HTTP GET requests for /resources/** by efficiently serving 
        up static resources in the ${webappRoot}/resources directory -->
    <resources mapping="/resources/**" location="/resources/" />

    <!-- Resolves views selected for rendering by @Controllers to .jsp resources 
        in the /WEB-INF/views directory -->
    <beans:bean
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <beans:property name="prefix" value="/WEB-INF/views/" />
        <beans:property name="suffix" value=".jsp" />
    </beans:bean>

    <beans:bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <beans:property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <beans:property name="url"
            value="jdbc:mysql://localhost:3306/TestDB" />
        <beans:property name="username" value="pankaj" />
        <beans:property name="password" value="pankaj123" />
    </beans:bean>

    <!-- Hibernate 4 SessionFactory Bean definition -->
    <beans:bean id="hibernate4AnnotatedSessionFactory"
        class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <beans:property name="dataSource" ref="dataSource" />
        <beans:property name="annotatedClasses">
            <beans:list>
                <beans:value>com.journaldev.spring.model.Person</beans:value>
            </beans:list>
        </beans:property>
        <beans:property name="hibernateProperties">
            <beans:props>
                <beans:prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect
                </beans:prop>
                <beans:prop key="hibernate.show_sql">true</beans:prop>
            </beans:props>
        </beans:property>
    </beans:bean>
    
    <beans:bean id="personDAO" class="com.journaldev.spring.dao.PersonDAOImpl">
        <beans:property name="sessionFactory" ref="hibernate4AnnotatedSessionFactory" />
    </beans:bean>
    <beans:bean id="personService" class="com.journaldev.spring.service.PersonServiceImpl">
        <beans:property name="personDAO" ref="personDAO"></beans:property>
    </beans:bean>
    <context:component-scan base-package="com.journaldev.spring" />
    
    <tx:annotation-driven transaction-manager="transactionManager"/>
    
    <beans:bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <beans:property name="sessionFactory" ref="hibernate4AnnotatedSessionFactory" />
    </beans:bean>

</beans:beans>

Der dataSource-Bean ist für die Klasse org.apache.commons.dbcp.BasicDataSource für grundlegendes Connection Pooling definiert. Der Bean org.springframework.orm.hibernate4.LocalSessionFactoryBean wird für Hibernate 4 SessionFactory verwendet. Für Hibernate 3 finden Sie ähnliche Klassen wie org.springframework.orm.hibernate3.LocalSessionFactoryBean und org.springframework.orm.hibernate3.AnnotationSessionFactoryBean.

Ein wichtiger Punkt ist, dass wenn wir auf das Spring Framework für das Hibernate-Sitzungsmanagement angewiesen sind, sollten wir hibernate.current_session_context_class nicht definieren, sonst werden Sie viele transaktionsbezogene Sitzungsprobleme bekommen. Die Beans personDAO und personService sind selbsterklärend.

Die transactionManager-Bean-Definition für org.springframework.orm.hibernate4.HibernateTransactionManager ist erforderlich, damit Spring ORM die Transaktionsverwaltung der Hibernate-Sitzung unterstützt. Für Hibernate 3 finden Sie eine ähnliche Klasse als org.springframework.orm.hibernate3.HibernateTransactionManager. Spring verwendet AOP für die Transaktionsverwaltung, dies können Sie jetzt mit der Annotation @Transactional in Verbindung bringen.

Ansichtsseite

Der letzte Teil unserer Anwendung ist die Ansichtsseite. Beachten Sie die Attribute, die in den Controller-Handlermethoden zum Modell hinzugefügt wurden, wir werden sie verwenden, um unsere Ansichtsseite zu erstellen. Wir werden auch JSTL-Tags, Spring-Core- und Spring-Form-Tags verwenden.

Copy Code


<%@ taglib uri="https://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="https://www.springframework.org/tags" prefix="spring" %>
<%@ taglib uri="https://www.springframework.org/tags/form" prefix="form" %>
<%@ page session="false" %>
<html>
<head>
    <title>Person Page</title>
    <style type="text/css">
        .tg  {border-collapse:collapse;border-spacing:0;border-color:#ccc;}
        .tg td{font-family:Arial, sans-serif;font-size:14px;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:#ccc;color:#333;background-color:#fff;}
        .tg th{font-family:Arial, sans-serif;font-size:14px;font-weight:normal;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:#ccc;color:#333;background-color:#f0f0f0;}
        .tg .tg-4eph{background-color:#f9f9f9}
    </style>
</head>
<body>
<h1>
    Add a Person
</h1>

<c:url var="addAction" value="/person/add" ></c:url>

<form:form action="${addAction}" commandName="person">
<table>
    <c:if test="${!empty person.name}">
    <tr>
        <td>
            <form:label path="id">
                <spring:message text="ID"/>
            </form:label>
        </td>
        <td>
            <form:input path="id" readonly="true" size="8"  disabled="true" />
            <form:hidden path="id" />
        </td> 
    </tr>
    </c:if>
    <tr>
        <td>
            <form:label path="name">
                <spring:message text="Name"/>
            </form:label>
        </td>
        <td>
            <form:input path="name" />
        </td> 
    </tr>
    <tr>
        <td>
            <form:label path="country">
                <spring:message text="Country"/>
            </form:label>
        </td>
        <td>
            <form:input path="country" />
        </td>
    </tr>
    <tr>
        <td colspan="2">
            <c:if test="${!empty person.name}">
                <input type="submit"
                    value="<spring:message text="Edit Person"/>" />
            </c:if>
            <c:if test="${empty person.name}">
                <input type="submit"
                    value="<spring:message text="Add Person"/>" />
            </c:if>
        </td>
    </tr>
</table>    
</form:form>
<br>
<h3>Persons List</h3>
<c:if test="${!empty listPersons}">
    <table class="tg">
    <tr>
        <th width="80">Person ID</th>
        <th width="120">Person Name</th>
        <th width="120">Person Country</th>
        <th width="60">Edit</th>
        <th width="60">Delete</th>
    </tr>
    <c:forEach items="${listPersons}" var="person">
        <tr>
            <td>${person.id}</td>
            <td>${person.name}</td>
            <td>${person.country}</td>
            <td><a href="<c:url value='/edit/${person.id}' />" >Edit</a></td>
            <td><a href="<c:url value='/remove/${person.id}' />" >Delete</a></td>
        </tr>
    </c:forEach>
    </table>
</c:if>
</body>
</html>

Testen der Spring MVC Hibernate-Anwendung

Bauen Sie einfach das Projekt und setzen Sie es in einen Servlet-Container Ihrer Wahl, zum Beispiel Tomcat, ein. Die folgenden Screenshots zeigen die Ansichtsseiten unserer Anwendung.

Sie werden auch ähnliche Logs in der Server-Logdatei finden.

Copy Code


Hibernate: insert into PERSON (country, name) values (?, ?)
INFO : com.journaldev.spring.dao.PersonDAOImpl - Person saved successfully, Person Details=id=15, name=Pankaj, country=USA
Hibernate: select person0_.id as id1_0_, person0_.country as country2_0_, person0_.name as name3_0_ from PERSON person0_
INFO : com.journaldev.spring.dao.PersonDAOImpl - Person List::id=10, name=Raman, country=UK2
INFO : com.journaldev.spring.dao.PersonDAOImpl - Person List::id=11, name=Lisa, country=France
INFO : com.journaldev.spring.dao.PersonDAOImpl - Person List::id=15, name=Pankaj, country=USA

Zusammenfassung

Dieses Tutorial zielte darauf ab, ausreichend Details bereitzustellen, um Ihnen den Einstieg in die Integration von Spring MVC und Hibernate zu ermöglichen. Ich hoffe, Sie finden es nützlich.

Starten Sie Ihre kostenlose Testversion: Maximieren Sie Ihre Effizienz mit Spring MVC Hibernate MySQL Integration

Möchten Sie die Leistungsfähigkeit Ihrer Webentwicklung mit unserer Cloud-Lösung für Spring MVC Hibernate MySQL Integration steigern? Registrieren Sie sich jetzt für eine kostenlose Testversion.

Try for free!

You might be interested in:

https://www.centron.de/tutorial/verwendung-der-funktion-puts-in-c-c/

https://www.centron.de/en/tutorial/container-an-introduction/

Kubernetes

ccloud³

Managed Server

Cloud GPU

S3 Object Storage

Enterprise

Saas-Hosting

Startup

Linux-Hosting

VMware Migration

Docker Hosting

Help Center

Trust Center

Glossar

Tutorials

Kubernetes

ccloud³

Managed Server

Cloud GPU

S3 Object Storage

Enterprise

Saas-Hosting

Startup

Linux-Hosting

VMware Migration

Docker Hosting

Help Center

Trust Center

Glossar

Tutorials

Kategorien

Spring MVC Hibernate MySQL Integration CRUD Beispiel

Maven Abhängigkeiten

Bereitstellungsbeschreibung

Hibernate-Entity-Bean

MySQL Tabellenerstellungsskript

PersonDAO Interface

Hibernate-spezifische DAO-Implementierung

Spring-Serviceklassen

Spring-Controller-Klasse

Spring-Bean-Konfiguration

Ansichtsseite

Testen der Spring MVC Hibernate-Anwendung

Zusammenfassung

Kostenlosen Account erstellen

Aktuelle Beiträge

Starten Sie Ihre kostenlose Testversion: Maximieren Sie Ihre Effizienz mit Spring MVC Hibernate MySQL Integration

You might be interested in:

Haben Sie Fragen, einen besonderen Use Case oder spezielle Anforderungen?

Starten Sie noch heute Ihre Cloud Infrastruktur

Jetzt kostenlos anfangen

Produkte

Mehr centron

Service & Support