Spring-SpringMVC-Hibernate在IntelliJ与Maven的环境下搭建

本篇主要介绍的是JavaEE中的框架SpringMVC，在以前上JavaEE课程时，课程项目里使用的是比较“古老”的SSH（Struts2+Spring+Hibernate）框架，最近受某小朋友的影响着手了解SpringMVC，一种更轻量级，更方便使用的框架。老规矩，附Wikipedia链接——Spring，其中Model-view-controller framework部分的介绍就是我们常说的SpringMVC。

受以前项目的影响，感觉框架的合理使用可以省去不少的麻烦。所以此次介绍的是另一种多框架的混合使用，即，Spring + SpringMVC + Hibernate框架在InteliJ和Maven的环境下的搭建，并采用注释的写法。后续还会有在此框架的基框之上的demo，敬请期待。

搭建环境

操作系统：Mac OSX Yosemite Version 10.10.3

集成开发环境（IDE）：IntelliJ IDEA 14.1

本地服务器：Tomcat 8.0.21

Maven版本：Maven3 3.0.5

工程建好了之后，如果想先看一下本文所展示的demo的工程目录，用来为后面的步骤过程中路径配置时作为参考，其次还有项目的源码都请戳：structure:https://raw.githubusercontent.com/MarK-YANG/Spring-SpringMVC-Hibernate/master/structure.png
源码：https://github.com/MarK-YANG/Spring-SpringMVC-Hibernate

3.pom.xml

正如开始的时候介绍的一样，我们使用Maven来管理我们在项目使用到的各种包，而所有包的配置信息都在pom.xml文件中，所以我们首要的工作就是通过pom.xml文件来找并管理到我们想要的包。在pom.xml文件中加入我们所需要的dependence和properties，具体如下：

<properties>
   <!-- spring版本号 -->
    <spring.version>4.0.4.RELEASE</spring.version>
</properties>

<dependencies>
   <!-- spring核心包 -->
    <!-- springframe start -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- springframe end -->
    <dependency>
        <groupId>javax.servlet.jsp.jstl</groupId>
        <artifactId>javax.servlet.jsp.jstl-api</artifactId>
        <version>1.2.1</version>
    </dependency>
    <dependency>
        <groupId>taglibs</groupId>
        <artifactId>standard</artifactId>
        <version>1.1.2</version>
    </dependency>
    <dependency>
        <groupId>tomcat</groupId>
        <artifactId>servlet-api</artifactId>
        <version>5.5.23</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>tomcat</groupId>
        <artifactId>jsp-api</artifactId>
        <version>5.5.23</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>commons-fileupload</groupId>
        <artifactId>commons-fileupload</artifactId>
        <version>1.3.1</version>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-validator</artifactId>
        <version>5.1.2.Final</version>
    </dependency>
    <!-- json数据 -->
    <dependency>
        <groupId>org.codehaus.jackson</groupId>
        <artifactId>jackson-mapper-asl</artifactId>
        <version>1.9.13</version>
    </dependency>
</dependencies>

然后，简单的介绍一下这些我们导入的包， spring-webmvc是我们SpringMVC框架的核心包，spring-core,spring-web都是其依赖包。

其次，jstl、taglibs等包是为了在jsp页面中使用JSTL标签。

然后，jackson-mapper包是使springMVC可以返回json值，json和xml方法是我们常用的两种网络传值方式。在springMVC中仅提供了json的接口，并未提供其实现，所以我们要导入它的实现包json-mapper。

再之，commons-fileupload包是为了文件上传所需要的，在本文中的demo中并未涉及到文件的上传，可以选择不添加。

然后，hibernate-validator是为了正常的使用springMVC中的valid，这是因为springMVC中的valid只提供了接口的实现，如果想使用这个接口，就必须要导入它的实现——hibernate-validator，但这项在本文中也未涉及，可以选择不添加。

4.修改web.xml

springMVC中只有一个核心的Servlet，所以我们要在web.xml中注册这个springMVC的Servlet，web.xml文件如下，

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    metadata-complete="true" version="3.0">

    <servlet>
        <servlet-name>spring-dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>spring-dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

这只是我们配置springMVC的开始，springMVC还有许多其他的配置项，但其他的配置项在另一个文件中，这个配置文件就是默认位置为web.xml同路径下的——<servlet-name>-servlet.xml。如，我的web.xml中配置的是spring-dispatcher，对应的xml文件的名字应为：spring-dispatcher-servlet.xml。

5.开始配置spring-dispatcher-servlet.xml

我们在与web.xml同路径下创建spring-dispatcher-servlet.xml如下：

<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/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

      <!-- 扫描controller（controller层注入） -->
       <context:component-scan base-package="com.mark.java.controller"/>

       <mvc:annotation-driven />
      <!-- 对模型视图添加前后缀 -->
       <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
              <property name="prefix" value="/pages/"/>
              <property name="suffix" value=".jsp"/>
       </bean>

       <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
              <property name="defaultEncoding" value="UTF-8"/>
              <property name="maxUploadSize" value="2000000"/>
       </bean>

       <mvc:resources mapping="/static/**" location="/"/>

       <mvc:default-servlet-handler />

</beans>

简单的解释一下，springMVC中的虚拟路径与处理函数的映射，是通过annotation（注释）来设置的，而这些类都在哪个包下面，就是通过component-scan属性配置的，并设置支持annotation支持。

springMVC的每一个处理函数都会返回一个String类型的变量（有的函数返回值就是 String，有的返回值是一个对象，对象里有一个viewResolver需要的字符串），我们这里设置了一个前缀和后缀，举个例子来说，对于函数返回的这个String，比如是fowafolo，那么需要的文件就是/pages/fowafolo.jsp。

multipartResolver是上传文件需要的配置，本文中并未涉及到。

最后是对静态资源的映射，经过这个映射之后，要访问/static/fowafolo.png时，实际访问的就是/resources/fowafolo.png。

6.MainController

下面我们开始写我们springMVC中的第一个controller, MainController，这个controller的位置就应该是我们刚才配置的spring-dispatcher-servlet.xml中component-scan配置的路径下，代码如下：

@Controller
@RequestMapping("/")
public class MainController {

    @RequestMapping("")
    public String index(){
        return "index";
    }

    @RequestMapping("/json")
    @ResponseBody
    public Map<String, String> json(){
        Map<String, String> result = new HashMap<String, String>();
        result.put("MarK", "hello");
        result.put("Ken", "Hehe");
        result.put("Fowafolo", "fool");
        return result;
    }
}

简单的解释一下，这个controller的RequestMapping是"/"，index()的RequestMapping也是"/"，而方法json的RequestMapping是"/json"，也就是说，当访问的URL是”/“时，我们会调用index()方法处理，它返回的字符串是index，再根据我们配置文件中的路径，它指向的就是我们/webapp/pages下的index.jsp，所以别忘了去在这个目当下新建一个index.jsp，给一个简单的例子。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title></title>
</head>
<body>

<h1>Hello, Fowafolo</h1>
<h2>Fowafolo is a foolish !</h2>

</body>
</html>

部署工程，我们给这个工程加一个前缀，如/spring，那么我们访问：http://localhost:8080/spring/得到的就是我们新建的index.jsp，如果我们访问http://localhost:8080/spring/json得到的就是我们json的返回值:{"MarK":"hello","Ken":"Hehe","Fowafolo":"fool"}。

最后，我们再多说几句，因为我们想在/webapp/pages下管理我们所有jsp，所以/webapp下的index.jsp可以不保留，其次，在部署项目时，不建议勾选此项，手动的在browser中输入url更好。

二、SpringMVC与Spring结合

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为J2EE应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

1. 再次配置web.xml

Spring要在程序调用某个对象的时候，就要首先把这个对象的实例注入进去。Spring自己对实例、程序运行的管理构成了Spring自己的容器，第一步就是要在web.xml中注册初始化这个容器。在此之前我们先在/resources文件夹下，创建子路径META-INF，然后在这个文件夹下，创建我们后面要用到的applicationContext.xml文件，如果用过spring框架的人对这个文件都不会陌生，这是spring的配置文件。最后web.xml文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         metadata-complete="true" version="3.0">

    <servlet>
        <servlet-name>spring-dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>spring-dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:/META-INF/applicationContext.xml</param-value>
    </context-param>

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

</web-app>

2. 配置applicationContext.xml文件

在spring4之后，spring配置的bean不是在xml文件中配置了，而是采用固定扫描annotation的类，根据对象的类型或者名字自动加载，但此前提是我们仍然要在配置文件中配置好这些类所在包的路径。最后applicationContext.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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd">

       <context:component-scan base-package="com.mark.java.service"/>

</beans>

3. 创建一个Service类，UserService.java

Service的创建我们还是比较推荐具体的service实现相应的接口的方式，下面我们写一个服务类，用来获取注册的用户，在包com.mark.java.service下创建接口UserService。

public interface UserService {
    public List<String> getAllUsernames();
}

然后再创建一个UserServiceImpl来实现此接口，

@Service
public class UserServiceImpl implements UserService {

    public List<String> getAllUsernames() {
        List<String> users = new ArrayList<String>();
        users.add("MarK");
        users.add("Ken");
        users.add("Fowafolo");
        return users;
    }

}

注意！！！，我们要对个实现加上注释@Service，这是在告诉spring，我需要你来管理我。

4. 修改MainController

在上一节中，我们通过json来返回一个json对象，现在我们修改这个方法，通过刚刚创建的service来返回用户列表给客户端。

首先，我们得先定义一个全局变量，usrService，

@Autowired
private UserService userService;

这里要注意的是Autowire这个annotation，它是为了告诉spring，这个对象没有实例化，需要注入一个UserService的实例，可是问题是，UserSerivce是一个接口，如果不指定就不知道你想用哪个实现类，Spring会首先看自己的容器里有没有一个叫做userService的对象（刚才创建的UserServiceImpl的对象名字就叫做userServiceImpl），如果找不到就在配置文件里配置的路径下面寻找UserService的实现类，找到了就把它的对象拿过来.除此之外刚才Service那个annotation还可以指定一个value：@Service("userService")。这样一来，对于UserServiceImpl这个类的实例，Spring给它起的名字就不是userServiceImpl了，而是userService，如果某个接口的实现类有多个，就可以使用这种方法来指定用哪个实现类，个人认为，如果每个接口都只有一个实现类，那么这么做确实很方便，但如果有多个实现类并且可能会更换的话，就不如配置文件明了了。

说了半天，最后修改json方法，

@RequestMapping("/json")
@ResponseBody
public List<String> json(){
    return userService.getAllUsernames();
}

Spring在这里的作用就是把MainController需要的userService引入进来，然后访问http://localhost:8080/spring/json会得到以下结果：

["MarK","Ken","Fawofolo"]

三、Hibernate框架的加入

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。

1. 导入Hibernate所需要的包

在pom.xml中，在properties标签下面定义一个版本，

<properties>
    <spring.version>4.0.4.RELEASE</spring.version>
    <hibernate.version>4.3.5.Final</hibernate.version>
</properties>

然后加入hibernate的核心包，因为要让Spring管理一些对象，还要引入spring-orm的包：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>${hibernate.version}</version>
</dependency>

除此之外，因为我们要用mysql数据库，并使用c3p0连接池，因此需要引入这两个对应的包：

<dependency>
    <groupId>c3p0</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.31</version>
</dependency>

2. 再次修改web.xml

Hibernate通过SessionFactory来获取Session,我们要在spring的配置文件中配置一个我们所需的SessionFactory，为了便于修改，我们新建一个配置文件，路径与spring的配置文件相同，我们新建一个infrastructure.xml, 最后我们的web.xml文件如下，其他的不做具体的介绍了。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         metadata-complete="true" version="3.0">

    <servlet>
        <servlet-name>spring-dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>spring-dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <filter>
        <filter-name>hibernateFilter</filter-name>
        <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>hibernateFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- Spring字符集过滤器 -->
    <filter>
        <filter-name>SpringEncodingFilter</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>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>SpringEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

  <!-- 读取spring配置文件 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:/META-INF/applicationContext.xml,
            classpath:/META-INF/infrastructure.xml
        </param-value>
    </context-param>

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

</web-app>

3. 配置hibernate.properties, infrastructure.xml

infrastructure.xml之前，我们要在/META-INF下新建properties文件夹，在里在新建hibernate.properties文件用来加入我们数据库的参数，hibernate.properties的配置如下，

hibernate.dialect=org.hibernate.dialect.MySQLDialect
driverClassName=com.mysql.jdbc.Driver
validationQuery=SELECT 1
url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
username=root
password=yang

hibernate.hbm2ddl.auto=none
hibernate.show_sql=true
hibernate.format_sql=true

注意以下几点，

driverClassName是你所连数据库的驱动的jar包的名称，这里我用的MySQL，所以是com.mysql.jdbc.Driver，

url是连接数据库的url，这里是jdbc:mysql://localhost:3306/本机本地数据库，后面是数据库的名称，为test，然后后面的一串，是JDBC对数据库进行CRUD时的编码，我们采用UTF-8以支持中文。

username和password是本地数据库的用户名和密码。

其他项可无视。infrastructure.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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd  
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
    ">

       <context:property-placeholder location="classpath:/META-INF/properties/hibernate.properties" />

       <!-- 使用C3P0数据源，MySQL数据库 -->
       <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
             destroy-method="close">
              <!-- MySQL5 -->
              <property name="driverClass" value="${driverClassName}"></property>
              <property name="jdbcUrl" value="${url}"></property>
              <property name="user" value="${username}"></property>
              <property name="password" value="${password}"></property>
              <property name="maxPoolSize" value="40"></property>
              <property name="minPoolSize" value="1"></property>
              <property name="initialPoolSize" value="1"></property>
              <property name="maxIdleTime" value="20"></property>
       </bean>

       <!-- session工厂 -->
       <!-- spring与hibernate整合配置，扫描所有dao -->
       <bean id="sessionFactory"
             class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
              <property name="dataSource" ref="dataSource" />
              <property name="packagesToScan" value="com.mark.java.entity" />
              <property name="hibernateProperties">
                     <props>
                            <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                            <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                            <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                            <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
                     </props>
              </property>
       </bean>

       <bean id="transactionManager"
             class="org.springframework.orm.hibernate4.HibernateTransactionManager">
              <property name="sessionFactory" ref="sessionFactory"></property>
       </bean>

      <!-- 对数据源进行事务管理 -->
       <tx:annotation-driven transaction-manager="transactionManager" />

</beans>

其所需的参数信息都是从刚才配置好的properties文件中读取。

4. 再次修改applicationContext.xml

我们还需要对这个配置文件做一点点小的修改，加入两行，

<context:component-scan base-package="com.mark.java.entity"/>
<!-- 扫描文件（自动将servicec层注入） -->
<context:component-scan base-package="com.mark.java.DAO"/>

解释一下，其中com.mark.java.entity则是我们MVC模式中model或称为JavaBean的文件夹目录，其格式应与数据库中字段相同；com.mark.java.DAO是访问数据库要使用DAO，即数据访问对象的目录。我们把这些同service都交给spring管理。最后applicationContext.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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd">

       <context:component-scan base-package="com.mark.java.service"/>
        <context:component-scan base-package="com.mark.java.entity"/>
        <context:component-scan base-package="com.mark.java.DAO"/>

</beans>

5. 建立表User

我们在我们的本地数据库中建立一个表，名为User, 其有两个字段，一个为id，主键，int类型，自增，另一个为usrname, varchar。

具体请戳：https://raw.githubusercontent.com/MarK-YANG/Spring-SpringMVC-Hibernate/master/table.png

6. 创建JavaBean

在entity目录下创建User.java

@Entity
@Table
public class User implements Serializable {
    @Id
    @GeneratedValue
    private int id;


    private String username;

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

注：这里的annotation用的都是JPA的接口。

7. 创建UserDAO

首先创建UserDAO接口，

public interface UserDAO {
    public int save(User u);
    public List<User> findAll();
}

创建UserDAOImpl实现此接口，

@Repository
public class UserDAOImpl implements UserDAO {

    @Autowired
    private SessionFactory sessionFactory;

    public int save(User u) {
        return (Integer) sessionFactory.getCurrentSession().save(u);
    }

    public List<User> findAll() {
        Criteria criteria = sessionFactory.getCurrentSession().createCriteria(User.class);
        return criteria.list();
    }
}

注：第一个annotation注明这是一个repository，需要被Spring管理，然后自动装载之前在配置文件中配置的 SessionFactory，获取当前session后获取所有的用户，下面修改之前的UserService代码，service封装业务逻辑层代码，我把每个service方法封装为一个事务。（PS:上面的SessionFactory获取当前Session是依赖于事务的，如果不在某个事务之内，会报错：No Session found for current thread。)

8.更新UserService

修改UserService接口，

public interface UserService {
    public void saveUsers(List<User> us);
    public List<User> getAllUsernames();
}

修改UserServiceImpl,

@Service("userService")
@Transactional
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDAO userDao;

    public void saveUsers(List<User> us) {
        for (User u : us) {
            userDao.save(u);
        }
    }

    public List<User> getAllUsernames() {
        return userDao.findAll();
    }
}

注：这个annotation为Transactional，就是指明每个方法是一个事务。

9. 修改MainController

@Controller
@RequestMapping("/")
public class MainController {

    @Autowired
    private UserService userService;

    @RequestMapping("")
    public String home(){
        List<User> us = new ArrayList<User>();
        User u = new User();
        u.setUsername("MarK");
        us.add(u);
        u = new User();
        u.setUsername("Fawofolo");
        us.add(u);
        userService.saveUsers(us);
        return "index";
    }

    @RequestMapping("/json")
    @ResponseBody
    public List<User> json(){
      return userService.getAllUsernames();
    }

}

部署项目，访问http://localhost:8080/spring加入两条新的数据，

访问http://localhost:8080/spring/json查看这两条数据，

结果如下：[{"id":1,"username":"MarK"},{"id":2,"username":"Fawofolo"}]

注：如果发现数据插入两遍，请回头看第一节关于项目部署的介绍。

至此，环境搭建完毕，后面还会有一篇在此环境基础之上做的springMVC的简单实例，敬请期待…

完。

四、总结

写在这里我已经坚持不下去，如果想要看总结的小朋友，请支付宝联系：emp.yangchunyu@gmail.com

（PS：只接受人民币请求，非诚勿扰 :) ）

MarK’s Blog

Rules for happiness: something to do, someone to love, something to hope for.

Spring-SpringMVC-Hibernate在IntelliJ与Maven的环境下搭建

搭建环境

目录

一、SpringMVC框架的使用

二、SpringMVC与Spring结合

三、Hibernate框架的加入

四、总结

Comments