使用Spring的Hibernate构建Java Web应用程序

这篇文章将展示如何在Spring环境中使用带有Hibernate ORM的MYSQL DB创建学生注册应用程序。 这是一个简单的应用程序，旨在在注册期间从用户收集输入详细信息，将详细信息保存在MYSQL DB中，并在登录期间对它们进行身份验证。

1.使用Maven模板创建Java Web应用程序项目

首先，在IDE中，通过为项目的GroupId和Artifact Id提供适当的值，使用maven-archetype-webapp模板创建Java Maven项目（基于字符串“ webapp”过滤目录）。 下面显示了示例Web应用程序目录结构，其中包含标准部署描述符web.xml和Maven pom.xml。

使用Spring的Hibernate构建Java Web应用程序

2.更新pom.xml

为了使上述Maven Java Web Application项目在Spring框架中支持Hibernate ORM，请将以下依赖项添加到现有pom.xml中

  • jstl，spring-webmvc和servlet-api（用于Spring支持）
  • mysql-connector-java（用于MYSQL支持）
  • spring-jdbc（用于通过JDBC Spring进行数据访问）
  • spring-orm（用于使用Spring进行ORM数据访问）
  • spring-data-jpa（用于JPA支持）
  • hibernate-validator和hibernate-entitymanager（用于Hibernate支持）
  • jta（用于事务支持） 
<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>3.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.21</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>4.2.0.Final</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-entitymanager</artifactId>
      <version>4.1.9.Final</version>
    </dependency>
    <dependency>
      <groupId>javax.transaction</groupId>
      <artifactId>jta</artifactId>
      <version>1.1</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>3.2.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>3.2.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-jpa</artifactId>
      <version>1.3.0.RELEASE</version>
      <exclusions>
          <exclusion>
              <groupId>org.springframework</groupId>
              <artifactId>spring-aop</artifactId>
          </exclusion>
      </exclusions>
    </dependency>

3.修改web.xml

修改web.xml的内容以包括以下内容：

  • 一个servlet，并为其指定配置文件的位置。 在此示例中，在项目布局的WEB-INF / config文件夹下创建了一个名为springConfig.xml的配置文件。
  • Servlet映射，以映射在上一步中创建的servlet，当客户端指定与url模式匹配的url时应调用该servlet。
  • 一个ContextLoaderListener，用于将spring与Web应用程序集成，并提供contextConfigLocation用于JPA的上下文文件。 
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

<servlet>
  <servlet-name>studentHibernateServlet</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/config/servletConfig.xml</param-value>
  </init-param>
</servlet>

<servlet-mapping>
  <servlet-name>studentHibernateServlet</servlet-name>
  <url-pattern>*.html</url-pattern>
</servlet-mapping>

<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath:/jpaContext.xml</param-value>
</context-param>

<listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

  <display-name>Archetype Created Web Application</display-name>
</web-app>

4.创建Spring配置文件

在文件夹WEB-INF / config下创建一个Spring Bean配置文件。 如果STS（Spring Tool Suite）是IDE，请继续并启用上下文和mvc命名空间。 servletConfig.xml将如下所示 

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

</beans>

启用所需的名称空间后，包括以下内容（在<beans>和</ beans>标记之间），以指示该应用程序是注释驱动的，并且是上下文组件扫描的基本包。 

<mvc:annotation-driven />

<context:component-scan base-package="com.github.elizabetht" />

包括Spring的bean InternalResourceViewResolver以查找jsp文件 

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  <property name="prefix" value="/WEB-INF/jsp/" />
  <property name="suffix" value=".jsp" />
</bean>

包括用于指定属性文件的Bean（稍后将对此进行详细介绍），该文件将用于存储自定义消息或属性。 通过以下配置，可以在项目的src / main / resources文件夹下创建一个名为messages.properties的属性文件。 

<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
  <property name="basename" value="messages" />
</bean>

5.创建persistence.xml

在项目的src / main / resources / META-INF文件夹下创建一个名为persistence.xml的文件，以定义JPA所需的持久性单元。 将以下内容添加到persistence.xml中，以定义名为punit的持久性单元。 

<persistence xmlns="http://java.sun.com/xml/ns/persistence"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="{http://java.sun.com/xml/ns/persistence} {http://java.sun.com/xml/ns/persistence_2_0.xsd}"
  version="2.0">

  <persistence-unit name="punit">
  </persistence-unit>

</persistence>

6.创建jpaContext.xml

按照web.xml中的定义，在项目的src / main / resources文件夹下创建一个名为jpaContext.xml的文件，以定义JPA和Hibernate相关的配置。 请注意，在Maven项目中src / main / resources文件夹下创建的任何文件都会由Maven自动添加到类路径中。 如果STS（Spring Tool Suite）是IDE，请继续启用context，jpa和tx命名空间。 jpaContext.xml将如下所示 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:tx="http://www.springframework.org/schema/tx"
  xmlns:context="http://www.springframework.org/schema/context"
  xmlns:jpa="http://www.springframework.org/schema/data/jpa"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
      http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">

<beans>

启用所需的名称空间后，包括以下内容（在<beans>和</ beans>标记之间），以指示该应用程序是注释驱动的，并且是jpa存储库扫描的基本包。 

<context:annotation-config />

<jpa:repositories base-package="com.github.elizabetht.repository" />

接下来，包括bean PersistenceAnnotationBeanPostProcessor。 这对于处理持久性单元，持久性上下文注释以及注入与JPA相关的资源是必需的。 

<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />

包括EntityManagerFactory的bean，该bean列出了各种与JPA相关的属性/资源。 

<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
      <property name="persistenceUnitName" value="punit" />
      <property name="dataSource" ref="dataSource" />
      <property name="jpaVendorAdapter">
          <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
              <property name="showSql" value="true" />
          </bean>
      </property>
      <property name="jpaPropertyMap">
          <map>
              <entry key="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
              <entry key="hibernate.hbm2ddl.auto" value="validate" />
              <entry key="hibernate.format_sql" value="true" />
          </map>
      </property>
  </bean>

包括用于数据源的bean，可以在其中指定MYSQL DB的属性，例如url，用户名和密码。 将<include connection url>替换为用于连接到MYSQL DB的实际连接URL。 同样，将<include username>和<include password>替换为实际的用户名和密码值。 

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
      <property name="driverClassName" value="com.mysql.jdbc.Driver" />
      <property name="url" value="jdbc:mysql//<include connection url>:3306/studentEnrollment?autoReconnect=true&createDatabaseIfNotExist=true&" />
      <property name="username" value="<include username>" />
      <property name="password" value="<include password>" />
</bean>

包括用于事务管理器的Bean，用于范围/控制事务。 

<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
      <property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>

<tx:annotation-driven transaction-manager="transactionManager" />

从而结束了jpaContext.xml中的长配置

7.创建用于学生注册/登录的JSP文件

在WEB-INF下创建一个名为“ jsp”的文件夹（在该文件夹中，如InternalResourceViewResolver bean的servletConfig.xml中所示，在其中创建jsp文件）。

创建一个文件signup.jsp以包含一个表单，以获取输入详细信息，例如学生的UserName，Password，FirstName，LastName，DateOfBirth和EmailAddress。 注册页面的快照如下：

使用Spring的Hibernate构建Java Web应用程序

接下来，创建一个文件login.jsp以包含带有用户名和密码的表单。 登录页面的快照如下：

使用Spring的Hibernate构建Java Web应用程序

还要创建success.jsp来指示登录成功，并创建failure.jsp来指示登录失败（这些只是用于显示内容的页面-不涉及处理逻辑）。

此应用程序使用twitter bootstrap http://getbootstrap.com/和http://bootswatch.com/united/作为样式表。 它还使用日期选择器样式表在“学生注册”页面（ http://www.eyecon.ro/bootstrap-datepicker/ ）中为DateOfBirth字段弹出日历。

可以在https://github.com/elizabetht/StudentEnrollmentWithSpring/tree/master/src/main/webapp中找到此应用程序的webapp文件夹下的文件的参考链接。

8.为Controller，Model，Repository和Service层类创建包

在src / main / java文件夹下为Spring Controller，Model，Repository和Service类分别创建软件包。

包创建后的项目示例快照如下所示：

使用Spring的Hibernate构建Java Web应用程序

9.创建模型层的类

在包com.github.elizabetht.model内创建一个名为Student.java的POJO类，以在注册过程中包含Student模型实体的详细信息。 在同一个包com.github.elizabetht.model中创建另一个名为StudentLogin.java的POJO类，以包含Student Login详细信息。

可以在https://github.com/elizabetht/StudentEnrollmentWithSpring/tree/master/src/main/java/com/github/elizabetht/model中找到到Model类文件的参考链接。

10.为存储库层创建类

在com.github.elizabetht.repository包内创建一个名为StudentRepository.java的接口类，以支持存储库层数据库操作。

为了应用程序的目的，需要两种接口方法。

  • 将学生注册详细信息插入数据库
  • 从数据库验证学生登录详细信息 
@Repository("studentRepository")
public interface StudentRepository extends JpaRepository<Student, Long> {

  @Query("select s from Student s where s.userName = :userName")
  Student findByUserName(@Param("userName") String userName);

}

Hibernate实现支持save（）方法，因此数据插入不需要单独的SQL语句。

11.创建服务层的类

在包com.github.elizabetht.service中创建一个名为StudentService.java的接口类，以支持服务层操作。 

public interface StudentService {
  Student save(Student student);
  boolean findByLogin(String userName, String password);
  boolean findByUserName(String userName);
}

在包com.github.elizabetht.service中创建一个名为StudentServiceImpl.java的服务层实现类（实际上是POJO）。 这就是应用程序逻辑的用途–将学生的详细信息保存到数据库中，或者从数据库中验证学生的（已保存）详细信息。 

@Service("studentService")
public class StudentServiceImpl implements StudentService {

  @Autowired
  private StudentRepository studentRepository;

  @Transactional
  public Student save(Student student) {
      return studentRepository.save(student);
  }

  public boolean findByLogin(String userName, String password) {  
      Student stud = studentRepository.findByUserName(userName);

      if(stud != null && stud.getPassword().equals(password)) {
          return true;
      } 

      return false;       
  }

  public boolean findByUserName(String userName) {
      Student stud = studentRepository.findByUserName(userName);

      if(stud != null) {
          return true;
      }

      return false;
  }

}

12.创建控制器层的类

在包com.github.elizabetht.controller中创建一个名为StudentController.java的控制器层POJO类。 这就是应用程序的路由逻辑的去向–无论是调用注册还是登录操作。 

@Controller
@SessionAttributes("student")
public class StudentController {

  @Autowired
  private StudentService studentService;

  @RequestMapping(value="/signup", method=RequestMethod.GET)
  public String signup(Model model) {
      Student student = new Student();        
      model.addAttribute("student", student);     
      return "signup";
  }

  @RequestMapping(value="/signup", method=RequestMethod.POST)
  public String signup(@Valid @ModelAttribute("student") Student student, BindingResult result, Model model) {        
      if(result.hasErrors()) {
          return "signup";
      } else if(studentService.findByUserName(student.getUserName())) {
          model.addAttribute("message", "User Name exists. Try another user name");
          return "signup";
      } else {
          studentService.save(student);
          model.addAttribute("message", "Saved student details");
          return "redirect:login.html";
      }
  }

  @RequestMapping(value="/login", method=RequestMethod.GET)
  public String login(Model model) {          
      StudentLogin studentLogin = new StudentLogin();     
      model.addAttribute("studentLogin", studentLogin);
      return "login";
  }

  @RequestMapping(value="/login", method=RequestMethod.POST)
  public String login(@Valid @ModelAttribute("studentLogin") StudentLogin studentLogin, BindingResult result) {
      if (result.hasErrors()) {
          return "login";
      } else {
          boolean found = studentService.findByLogin(studentLogin.getUserName(), studentLogin.getPassword());
          if (found) {                
              return "success";
          } else {                
              return "failure";
          }
      }

  }
}

13.创建messages.properties文件

如上所示，@ Valid批注用于验证到达方法的表单的输入参数，并将验证结果存储在BindingResult对象中。 为了验证特定字段（请参阅为模型层创建的类– https://github.com/elizabetht/StudentEnrollmentWithSpring/tree/master/src/main/java/com/github/elizabetht/model ），请使用注释像@ NotEmpty，@ Size，@ Email和@NotNull，它们来自Hibernate Validator的各种验证。

在messages.properties文件中指定了当上述任何一个验证器失败时应显示的定制消息。 在src / main / resources文件夹下创建一个名为messages.properties的文件，并包含以下内容 

NotEmpty=Field cannot be blank
NotNull=Field cannot be blank

Email=Email Address not valid/well-formed
Past=Date of Birth must be in the past 

Size={0} must be between {2} and {1} characters long
typeMismatch=Invalid format

14.在MYSQL数据库中创建数据库模式

连接到将用于此应用程序的MySQL数据库，并使用MySQL Workbench创建一个名为StudentEnrollment的新数据库架构。 这是必需的，因为在jpaContext.xml的dataSource bean中指定了StudentEnrollment的数据库模式名称。

一旦创建了StudentEnrollment DB Schema，就可以使用CREATE TABLE语句在DB Schema中创建一个名为Student的表，如下所示： 

CREATE TABLE `student` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `dateOfBirth` datetime NOT NULL,
  `emailAddress` varchar(255) NOT NULL,
  `firstName` varchar(255) NOT NULL,
  `lastName` varchar(255) NOT NULL,
  `password` varchar(8) NOT NULL,
  `userName` varchar(20) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=43 DEFAULT CHARSET=latin1;

15.在Tomcat服务器上部署应用程序

完成上述步骤并成功构建项目后，即可准备将Java Web应用程序部署在Tomcat Server 7上。

右键单击项目，然后选择“运行方式->在服务器上运行”选项，可以将Java Web应用程序本地部署。

通过将WAR文件（右键单击项目并选择“导出为WAR文件”选项）复制到/ var / lib / tomcat7文件夹（或适当的tomcat目录），然后重新启动tomcat，可以在支持Tomcat的任何本机服务器上远程部署该文件。服务器。

此应用程序可在此处进行演示： http : //ec2-23-20-137-135.compute-1.amazonaws.com : 8080/StudentEnrollmentWithSpring/

16.克隆或下载代码

如果使用git，请在此处克隆该项目的副本： https : //github.com/elizabetht/StudentEnrollmentWithSpring.git

如果不使用git，请在此处以ZIP或tar.gz文件下载项目： https ： //github.com/elizabetht/StudentEnrollmentWithSpring/releases/tag/1.6

参考： “ 我的实验与技术”博客中的JCG合作伙伴伊丽莎白·托马斯（Elizabeth Thomas） 使用Hibernate With Spring构建Java Web应用 。

翻译自: https://www.javacodegeeks.com/2014/03/building-java-web-application-using-hibernate-with-spring.html

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode