笔记49 在Spittr应用中整合Hibernate

在前边构建的Spittr应用中整合Hibernate

由于最近所学的hibernate都是使用xml方式进行配置的，所以在与以Java方式配置的Spittr应用结合时就会出现一些小问题，在此进行总结。

一、读取上下文

　　因为原来的Spittr应用采用的是Java方式配置，没有用到xml。

　　DispatcherServlet是Spring MVC的核心。按照传统的方式，像DispatcherServlet这样的Servlet会配置在 web.xml文件中。但是在Spittr应用中，使用Java将DispatcherServlet配置在Servlet容器中，而没有使用web.xml文件。代码如下所示：

SpittrWebAppInitializer.java

 package myspittr.config;

 import javax.servlet.MultipartConfigElement;
 import javax.servlet.ServletRegistration.Dynamic;

 import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

 public class SpittrWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
     @Override
     protected Class<?>[] getRootConfigClasses() {
         // TODO Auto-generated method stub
         return new Class<?>[] { RootConfig.class };
     }

     @Override
     protected Class<?>[] getServletConfigClasses() {
         // TODO Auto-generated method stub
         return new Class<?>[] { WebConfig.class };
     }

     @Override
     protected String[] getServletMappings() {
         // TODO Auto-generated method stub
         return new String[] { "/" };
     }

     @Override
     protected void customizeRegistration(Dynamic registration) {
         // TODO Auto-generated method stub
         registration.setMultipartConfig(new MultipartConfigElement("/tmp/spittr/uploads", 2097152, 4194304, 0));
     }

 }

WebConfig.java

 package myspittr.config;

 import java.io.IOException;

 import org.springframework.context.MessageSource;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.support.ResourceBundleMessageSource;
 import org.springframework.web.multipart.MultipartResolver;
 import org.springframework.web.multipart.support.StandardServletMultipartResolver;
 import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
 import org.springframework.web.servlet.config.annotation.EnableWebMvc;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
 import org.springframework.web.servlet.view.InternalResourceViewResolver;

 @Configuration("WebConfig")
 @EnableWebMvc
 @ComponentScan({ "myspittr.web", "myspittr.data" })
 public class WebConfig extends WebMvcConfigurerAdapter {
     @Bean
     public InternalResourceViewResolver viewResolver() {
         InternalResourceViewResolver resolver = new InternalResourceViewResolver();
         resolver.setPrefix("/WEB-INF/views/");
         resolver.setSuffix(".jsp");
         resolver.setViewClass(org.springframework.web.servlet.view.JstlView.class);
         resolver.setExposeContextBeansAsAttributes(true);
         return resolver;
     }

     @Override
     public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
         // TODO Auto-generated method stub
         configurer.enable();
     }

     @Bean
     public MessageSource messageSource() {
         ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
         messageSource.setBasename("message");
         return messageSource;
     }

     @Bean
     public MultipartResolver multipartResolver() throws IOException {
         return new StandardServletMultipartResolver();
     }

     // @Bean
     // public MultipartResolver multipartResolver() throws IOException {
     // return new CommonsMultipartResolver();
     // }
 }

RootConfig.java

 package myspittr.config;

 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.ComponentScan.Filter;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.FilterType;
 import org.springframework.web.servlet.config.annotation.EnableWebMvc;

 @Configuration("RootConfig")
 @ComponentScan(basePackages = { "myspittr" }, excludeFilters = {
         @Filter(type = FilterType.ANNOTATION, value = EnableWebMvc.class) })
 public class RootConfig {

 }

　　AbstractAnnotationConfigDispatcherServletInitializer的任意类都会自动地配置Dispatcher-Servlet和Spring应用上下文，Spring的应用上下文会位于应用程序的Servlet上下文之中。

插入语：

　　在Servlet 3.0环境 中，容器会在类路径中查找实现 javax.servlet.ServletContainerInitializer接口的类， 如果能发现的话，就会用它来配置Servlet容器。 Spring提供了这个接口的实现，名 为SpringServletContainerInitializer，这个类反过来又会查找实现WebApplicationInitializer的类并将配置的任务交给 它们来完成。Spring 3.2引入了一个便利的 WebApplicationInitializer基础实现，也就是AbstractAnnotationConfigDispatcherServletInitializer 因为我们的Spittr-WebAppInitializer扩展了 AbstractAnnotationConfig DispatcherServletInitializer（同时也就实现了 WebApplicationInitializer），因此当部署到Servlet 3.0容器中的时候，容器会自动发现它，并用它来配置Servlet上下文。
　　尽管它的名字很长，但 是AbstractAnnotationConfigDispatcherServletInitializer使用起来很简便。在上述代码中，SpittrWebAppInitializer重写了三个方法。 第一个方法是getServletMappings()，它会将一个或多个路径映 射到DispatcherServlet上。在本例中，它映射的是“/”，这表示 它会是应用的默认Servlet。它会处理进入应用的所有请求。 为了理解其他的两个方法，我们首先要理解DispatcherServlet 和一个Servlet监听器（也就是ContextLoaderListener）的关系。

　　两个应用（Spring和SpringMVC）上下文之间的关系：

　　当DispatcherServlet启动的时候，它会创建Spring应用上下文，并加载配置文件或配置类中所声明的bean。在上述代码中的 getServletConfigClasses()方法中，我们要求DispatcherServlet加载应用上下文时，使用定义在WebConfig配置类（使用Java配置）中的bean。 但是在Spring Web应用中，通常还会有另外一个应用上下文。另外的这个应用上下文是由ContextLoaderListener创建的。 我们希望DispatcherServlet加载包含Web组件的bean，如控制器、视图解析器以及处理器映射，而ContextLoaderListener要加载应用中的其他bean。这些bean通常是驱动应用后端的中间层和数据层组件。

　　实际上，AbstractAnnotationConfigDispatcherServletInitializer 会同时创建DispatcherServlet和 ContextLoaderListener。GetServlet-ConfigClasses() 方法返回的带有@Configuration注解的类将会用来定 义DispatcherServlet应用上下文中的 bean。getRootConfigClasses()方法返回的带 有@Configuration注解的类将会用来配 置ContextLoaderListener创建的应用上下文中的bean。 在本例中，根配置定义在RootConfig中，DispatcherServlet 的配置声明在WebConfig中。需要注意的是，通过 AbstractAnnotationConfigDispatcherServletInitializer来配置DispatcherServlet是传统web.xml方式的替代方案。如果你愿意的话，可以同时包含web.xml和 AbstractAnnotationConfigDispatcherServletInitializer，但这其实并没有必要。

　　但是，问题是现在还不会使用Java方式对hibernate进行配置，所以没有办法只能采用xml方式配置。如果使用Java方式整合hibernate，那么将hibernate相关的bean放入WebConfig.java中即可。

　　需要注意的是，以xml方式整合hibernate时，需要在web.xml中进行如下配置：

 <?xml version="1.0" encoding="UTF-8"?>
 <web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
 http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" id="WebApp_1529217958650">
     <!-- 配置Spring IOC 容器 -->
     <context-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>classpath:applicationContext.xml</param-value>
     </context-param>
     <listener>
         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
     </listener>

     <!-- 配置Springmvc的核心控制器 -->
     <servlet>
         <servlet-name>dispatcherServlet</servlet-name>
         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
         <init-param>
             <param-name>contextConfigLocation</param-name>
             <param-value>classpath:springmvc.xml</param-value>
         </init-param>
         <load-on-startup>1</load-on-startup>
     </servlet>
     <servlet-mapping>
         <servlet-name>dispatcherServlet</servlet-name>
         <url-pattern>/*</url-pattern>
     </servlet-mapping>
     <!-- 配置编码方式过滤器，且必须配置在所有的过滤器最前面 -->
     <filter>
         <filter-name>characterEncodingFilter</filter-name>
         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
         <init-param>
             <param-name>encoding</param-name>
             <param-value>UTF-8</param-value>
         </init-param>
     </filter>
     <filter-mapping>
         <filter-name>characterEncodingFilter</filter-name>
         <url-pattern>/*</url-pattern>
     </filter-mapping>
     <!-- 为了使用SpringMVC框架实现REST，需配置HiddenHttpMethodFilter -->
     <filter>
         <filter-name>hiddenHttpMethodFilter</filter-name>
         <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
     </filter>
     <filter-mapping>
         <filter-name>hiddenHttpMethodFilter</filter-name>
         <url-pattern>/*</url-pattern>
     </filter-mapping>

 </web-app>

　　但是其中DispatcherServlet和 ContextLoaderListener已经在SpittrWebAppInitializer.java中配置过了，所以要去掉。那么如何加载hibernate相关的bean呢?新建applicationContext.xml文件，在这里面存放有关hibernate的配置，具体代码如下所示：

 <?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"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
             http://www.springframework.org/schema/context
             http://www.springframework.org/schema/context/spring-context-4.1.xsd">

     <!-- 配置数据源 -->
     <context:property-placeholder location="classpath:/config/db.properties" />

     <!-- 配置DataSource -->
     <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
         <property name="user" value="${jdbc.user}"></property>
         <property name="password" value="${jdbc.password}"></property>
         <property name="driverClass" value="${jdbc.driverClass}"></property>
         <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
     </bean>

     <!-- 配置SeeionFactory -->
     <bean class="org.springframework.orm.hibernate5.LocalSessionFactoryBean"
         id="sessionFactory">
         <!-- 配置数据源 -->
         <property name="dataSource" ref="dataSource"></property>
         <!-- 配置实体包（pojo） -->
         <property name="PhysicalNamingStrategy">
             <bean
                 class="org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl"></bean>
         </property>
         <property name="packagesToScan" value="com.Spittr.entity"></property>

         <!-- 配置Hibernate的常用属性 -->
         <property name="hibernateProperties">
             <props>
                 <!-- 数据库的方言 -->
                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                 <prop key="hibernate.show_sql">true</prop>
                 <prop key="hibernate.format_sql">true</prop>
                 <prop key="hibernate.hbm2ddl.auto">update</prop>
             </props>
         </property>
     </bean>

     <!-- 配置hibernate的事务管理器 -->
     <bean class="org.springframework.orm.hibernate5.HibernateTransactionManager">
         <property name="sessionFactory" ref="sessionFactory"></property>
     </bean>
 </beans>

如何加载这里面的bean呢?使用ClassPathXmlApplicationContext获取配置文件，然后使用getBean方法获取相应bean,即SessionFactory。

代码如下：

 ApplicationContext ctx= new ClassPathXmlApplicationContext("/config/applicationContext.xml");
 SessionFactory sessionFactory=ctx.getBean(SessionFactory.class);

　　classpath请参考：笔记48

二、Spittr应用中数据的处理

1.应用中只涉及到两个实体类，一个是spiitle，另一个是spitter。它俩之间的关系是：一个spitter可以对应多个spittle，多个spittle对应一个spitter。

所以在spittle中增加下面代码：

     private Spitters spitters;
         @ManyToOne
     @JoinColumn(name = "author")
     public Spitters getSpitters() {
         return spitters;
     }

     public void setSpitters(Spitters spitters) {
         this.spitters = spitters;
     }    

在spitter中增加下面代码：

     Set<Spittles> spittles;
         @OneToMany(fetch = FetchType.EAGER)
     @JoinColumn(name = "author")
     public Set<Spittles> getSpittles() {
         return spittles;
     }

     public void setSpittles(Set<Spittles> spittles) {
         this.spittles = spittles;
     }    

2.Spittr中注册界面和发布页面分别对应实体类spitter和spittle，但是如果这两个实体类直接使用hibernate映射为数据库中的表时，会出现一些问题，因为有一些字段是不用存储在数据库当中的，比如说确认密码。所以需要新建两个实体类，用作与数据库的交互，而原来的spitter和spittle用来与应用交互。下面给出两个新的实体类：

Spitters.java

 package com.Spittr.entity;

 import java.io.Serializable;
 import java.util.Set;

 import javax.persistence.Entity;
 import javax.persistence.FetchType;
 import javax.persistence.GeneratedValue;
 import javax.persistence.GenerationType;
 import javax.persistence.Id;
 import javax.persistence.JoinColumn;
 import javax.persistence.OneToMany;
 import javax.persistence.Table;

 @Entity
 @Table(name = "spitters")
 public class Spitters implements Serializable {
     /**
      *
      */
     private static final long serialVersionUID = 1L;

     int id;
     String username;
     String password;
     String email;
     Set<Spittles> spittles;

     public Spitters() {
         // TODO Auto-generated constructor stub
     }

     public Spitters(String username, String password, String email) {
         super();
         this.username = username;
         this.password = password;
         this.email = email;
     }

     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     public int getId() {
         return id;
     }

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

     public String getUsername() {
         return username;
     }

     public void setUsername(String username) {
         this.username = username;
     }

     public String getPassword() {
         return password;
     }

     public void setPassword(String password) {
         this.password = password;
     }

     public String getEmail() {
         return email;
     }

     public void setEmail(String email) {
         this.email = email;
     }

     @OneToMany(fetch = FetchType.EAGER)
     @JoinColumn(name = "author")
     public Set<Spittles> getSpittles() {
         return spittles;
     }

     public void setSpittles(Set<Spittles> spittles) {
         this.spittles = spittles;
     }

 }

Spittles.java

 package com.Spittr.entity;

 import java.io.Serializable;

 import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
 import javax.persistence.GenerationType;
 import javax.persistence.Id;
 import javax.persistence.JoinColumn;
 import javax.persistence.ManyToOne;
 import javax.persistence.Table;

 @Entity
 @Table(name = "spittles")
 public class Spittles implements Serializable {
     /**
      *
      */
     private static final long serialVersionUID = 1L;
     private int id;
     private Long spittleId;
     private String message;
     private String title;
     private String time;
     private String username;
     private String spittlePicture;

     private Spitters spitters;

     public Spittles() {
         // TODO Auto-generated constructor stub
     }

     public Spittles(Long spittleId, String message, String title, String time, String username, String spittlePicture) {
         this.spittleId = spittleId;
         this.message = message;
         this.title = title;
         this.time = time;
         this.username = username;
         this.spittlePicture = spittlePicture;
     }

     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     public int getId() {
         return id;
     }

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

     public Long getSpittleId() {
         return spittleId;
     }

     public void setSpittleId(Long spittleId) {
         this.spittleId = spittleId;
     }

     public String getMessage() {
         return message;
     }

     public void setMessage(String message) {
         this.message = message;
     }

     public String getTitle() {
         return title;
     }

     public void setTitle(String title) {
         this.title = title;
     }

     public String getTime() {
         return time;
     }

     public void setTime(String time) {
         this.time = time;
     }

     public String getUsername() {
         return username;
     }

     public void setUsername(String username) {
         this.username = username;
     }

     public String getSpittlePicture() {
         return spittlePicture;
     }

     public void setSpittlePicture(String spittlePicture) {
         this.spittlePicture = spittlePicture;
     }

     @ManyToOne
     @JoinColumn(name = "author")
     public Spitters getSpitters() {
         return spitters;
     }

     public void setSpitters(Spitters spitters) {
         this.spitters = spitters;
     }

 }

三、总结