Spring+SpringMVC+hibernate整合开发

前言：

　　最近没什么事做，搭个框架写成博客记录下来，拉通一下之前所学知识.

　　话不多说，我们直接步入正题。

　　准备工作：

　　　　 1/安装并配置java运行环境

　　　　 2/数据库的安装配置（Mysql）

　　　　 3/安装并配置服务器(Tomcat)

　　　　 4/Maven

　　　　 5/ IntelliJIDEA的安装配置（本人使用的主要软件是IntelliJIDEA,没用eclipse什么的）

　　 　　6/ 使用IntelliJIDEA创建一个web app项目。

　　　　貌似就这些了吧

导包

不同于以往的导包，由于我们创建的是maven的webapp项目，所以现在只需配置下pomxml这个配置文件，系统会自动到maven的中央仓库去下载相应的包.

本人的pom.xml配置文件如下（都写有说明的哈）： 

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>XRog</groupId>
  <artifactId>ssh</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>ssh Maven Webapp</name>
  <url>http://maven.apache.org</url>

  <!-- 本人将配置包的版本信息都统一放入此处，方便以后管理-->
  <properties>
    <springVersion>4.3.1.RELEASE</springVersion>
    <hibernateVersion>4.3.5.Final</hibernateVersion>
    <jstlVersion>1.2</jstlVersion>
    <taglibVersion>1.1.2</taglibVersion>
    <servletVersion>3.0-alpha-1</servletVersion>
    <jsonVersion>1.9.13</jsonVersion>
    <jacksonVersion>2.5.0</jacksonVersion>
    <mysqlVersion>5.1.38</mysqlVersion>
    <c3p0Version>0.9.1.2</c3p0Version>
    <log4jVersion>1.2.17</log4jVersion>
    <fileuploadVersion>1.3.1</fileuploadVersion>
    <lombokVersion>1.16.10</lombokVersion>
  </properties>

  <dependencies>
    <!-- 单元测试 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

    <!-- spring-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${springVersion}</version>
    </dependency>

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

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

    <!-- spring web + spring MVC-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${springVersion}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${springVersion}</version>
    </dependency>

    <!-- hibernate配置-->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>${hibernateVersion}</version>
    </dependency>

    <!-- hibernate 缓存, 视情况添加-->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-ehcache</artifactId>
      <version>${hibernateVersion}</version>
    </dependency>

    <!-- jsp页面使用的jstl支持-->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>${jstlVersion}</version>
    </dependency>
    <dependency>
      <groupId>taglibs</groupId>
      <artifactId>standard</artifactId>
      <version>${taglibVersion}</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>${servletVersion}</version>
      <scope>provided</scope>
    </dependency>

    <!-- DataBase数据库连接 mysql包-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysqlVersion}</version>
    </dependency>

    <!-- 数据库连接池-->
    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>${c3p0Version}</version>
    </dependency>

    <!-- json数据 使springMVC可以返回json值 ,视情况添加-->
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-mapper-asl</artifactId>
      <version>${jsonVersion}</version>
    </dependency>

    <!-- Jackson可以轻松的将Java对象转换成json对象和xml文档,同样也可以将json、xml转换成Java对象-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>${jacksonVersion}</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>${jacksonVersion}</version>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>${jacksonVersion}</version>
    </dependency>

    <!-- log4j配置, 视情况添加-->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4jVersion}</version>
    </dependency>

    <!--文件 上传-->
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>${fileuploadVersion}</version>
    </dependency>

    <!-- lombok插件导包-->
      <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>${lombokVersion}</version>
        <scope>provided</scope>
      </dependency>


  </dependencies>


  <build>
    <finalName>ssh</finalName>
  </build>
</project>

 

OK，配置后运行下maven,就会自动向中央仓库下载相应的包啦！（这个就不多说了）。

 

SpringMVC配置

我现在在这里把我配置后的结构拿出来给你们看下

 

 

我们先配置下SpringMVC的配置：resources/META-INF/spring-mvc.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-4.1.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.1.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">
       
       <!-- 启动注解驱动的spring MVC功能,注册请求url和注解POJO类方法的映射-->
       <mvc:annotation-driven />

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

    <!-- 对模型视图名称的解析,在请求时模型视图名称添加前后缀 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
        <property name="prefix" value="views/" />      <!-- 前缀 -->
        <property name="suffix" value=".jsp" />   <!-- 后缀 -->
    </bean>
    
    <!--这里是对静态资源的映射-->
    <mvc:resources mapping="/js/**" location="/resources/js/" />
    <mvc:resources mapping="/css/**" location="/resources/css/" />
    <mvc:resources mapping="/img/**" location="/resources/img/" />

</beans>

 好了，我们现在修改下web.xml这个配置文件，完善下SpringMVC的配置， 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"
         version="3.0">
        <!-- 地址为http://localhost:8080/  显示的默认网页-->
        <welcome-file-list>
          <welcome-file>/index.jsp</welcome-file>
        </welcome-file-list>

        <!-- spring MVC config start-->
        <servlet>
            <servlet-name>spring</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <init-param>
              <param-name>contextConfigLocation</param-name>
              <!-- 此处指向的的是SpringMVC的配置文件 -->
              <param-value>classpath:META-INF/spring-mvc.xml</param-value>
            </init-param>
            <!--配置容器在启动的时候就加载这个servlet并实例化-->
            <load-on-startup>1</load-on-startup>
        </servlet>

        <servlet-mapping>
            <servlet-name>spring</servlet-name>
            <url-pattern>/</url-pattern>
        </servlet-mapping>
        <!-- spring MVC config end-->

</web-app>

OK，SpringMVC配置完成，现在我们进行一下测试吧

在controller层新建一个MainController，内容如下

package com.ssh.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;


/**
 * Created by XRog
 * On 2/1/2017.12:36 AM
 */
@Controller
public class MainController {

    @RequestMapping(value = "test", method = RequestMethod.GET)
    public String test(){
//        实际返回的是views/test.jsp ,spring-mvc.xml中配置过前后缀
        return "test";
    }
}

test.jsp网页如下：

<html>
<body>
<center>
<h2 style="color: #ff261a;">this is my test page!</h2>
</center>
</body>
</html>

 

重启Tomcat服务器， 然后浏览器访问http://localhost/test如下图所示：

 

PS： Tomcat默认端口是8080，我更改了端口号，如若你们为更改，正确的访问地址是localhost：8080/test

OK，成功访问。 

SpringMVC+Spring整合

 这个就十分简单了， 配置applicationContext.xml这个Spring的配置文件如下：

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

        <!-- 自动扫描 -->
        <context:component-scan base-package="com.ssh">
            <!-- 扫描时跳过 @Controller 注解的JAVA类（控制器） -->
            <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>

</beans>

完善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"
         version="3.0">
        <!-- 地址为http://localhost:8080/  显示的默认网页-->
        <welcome-file-list>
          <welcome-file>/index.jsp</welcome-file>
        </welcome-file-list>

    <!--加载Spring的配置文件到上下文中去-->
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>
                classpath:META-INF/applicationContext.xml
            </param-value>
        </context-param>

        <!-- spring MVC config start-->
        <servlet>
            <servlet-name>spring</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <init-param>
              <param-name>contextConfigLocation</param-name>
              <!-- 此处指向的的是SpringMVC的配置文件 -->
              <param-value>classpath:META-INF/spring-mvc.xml</param-value>
            </init-param>
            <!--配置容器在启动的时候就加载这个servlet并实例化-->
            <load-on-startup>1</load-on-startup>
        </servlet>

        <servlet-mapping>
            <servlet-name>spring</servlet-name>
            <url-pattern>/</url-pattern>
        </servlet-mapping>
        <!-- spring MVC config end-->


        <!-- Spring监听器 -->
        <listener>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
        </listener>

        <!--  字符集过滤  -->
        <filter>
            <filter-name>encodingFilter</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>encodingFilter</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>

</web-app>

web.xml配置文件中更改了三处：引入Spring配置文件 Spring的监听器  以及 字符集过滤

 

OK，Spring+SpringMVC配置完成，下面我们开始测试：

在service写一个TestServiceImpl实现TestService接口并实现其test()方法， 代码如下：

package com.ssh.service.impl;

import com.ssh.service.TestService;
import org.springframework.stereotype.Service;

/**
 * Created by XRog
 * On 2/1/2017.12:58 AM
 */
@Service
public class TestServiceImpl implements TestService {
    public String test() {
        return "test";
    }
}

PS:这里注意写@Service注解

MainController控制器更改如下：

package com.ssh.controller;

import com.ssh.service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;


/**
 * Created by XRog
 * On 2/1/2017.12:36 AM
 */
@Controller
public class MainController {

    @Autowired
    private TestService testService;

    @RequestMapping(value = "test", method = RequestMethod.GET)
    public String test(){
//        实际返回的是views/test.jsp ,spring-mvc.xml中配置过前后缀
        return "test";
    }

    @RequestMapping(value = "springtest", method = RequestMethod.GET)
    public String springTest(){
        return testService.test();
    }
}

控制器这里我们运用了Spring的依赖注入自动装配。

在浏览器中输入地址http://localhost/springtest调用springtest方法     

 

yes，成功返回，说明我们之前的配置没问题

Spring+SpringMVC+hibernate整合

好了，现在就缺hibernate这个框架了。。 我先给大家看些我搭建好之后的结构图吧

 

我们想来编写config.properties这个配置文件，里面存放的是hibernate的一些配置

#database connection config
jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://?????:3306/ssh?useUnicode=true&characterEncoding=utf-8
jdbc.username = root
jdbc.password = ???

#hibernate config
hibernate.dialect = org.hibernate.dialect.MySQLDialect
hibernate.show_sql = true
hibernate.format_sql = true
hibernate.hbm2ddl.auto = update

这里连接数据库的参数由于我是连接我晚上的数据库，因此我数据库地址和密码打了“？？？”,你们连接时改成自己本地的就OK了

下面配置hibernate，这里我为了方便，就直接写进applicationContext.xml里面。配置后的applicationContext.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-4.1.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.1.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">

    <!--********************************************配置Spring***************************************-->
        <!-- 自动扫描 -->
        <context:component-scan base-package="com.ssh">
            <!-- 扫描时跳过 @Controller 注解的JAVA类（控制器） -->
            <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>


    <!--********************************************配置hibernate********************************************-->

    <!--扫描配置文件(这里指向的是之前配置的那个config.properties)-->
    <context:property-placeholder location="classpath:/config.properties" />

    <!--配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass" value="${jdbc.driver}" />  <!--数据库连接驱动-->
        <property name="jdbcUrl" value="${jdbc.url}" />     <!--数据库地址-->
        <property name="user" value="${jdbc.username}" />   <!--用户名-->
        <property name="password" value="${jdbc.password}" />   <!--密码-->
        <property name="maxPoolSize" value="40" />      <!--最大连接数-->
        <property name="minPoolSize" value="1" />       <!--最小连接数-->
        <property name="initialPoolSize" value="10" />      <!--初始化连接池内的数据库连接-->
        <property name="maxIdleTime" value="20" />  <!--最大空闲时间-->
    </bean>

    <!--配置session工厂-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan" value="com.ssh.entity" />
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop> <!--hibernate根据实体自动生成数据库表-->
                <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" />
    </bean>

</beans>

 

 OK，到了这里，配置结束。下面进入测试阶段

实体类（entity)：

package com.ssh.entity;

import lombok.Data;

import javax.persistence.*;

/**
 * Created by XRog
 * On 2/2/2017.2:03 PM
 */
@Data
@Entity
@Table(name = "Person")
public class Person {

    @Id
    @GeneratedValue
    private Long id;

    @Column(name = "created")
    private Long created = System.currentTimeMillis();

    @Column(name = "username")
    private String username;

    @Column(name = "address")
    private String address;

    @Column(name = "phone")
    private String phone;

    @Column(name = "remark")
    private String remark;
}

　　PS：我这里用了一个@Data注解，此注解会自动生成get方法，set方法，toString方法等一系列方法，功能十分强大，不过需要安装插件以及导包， 有兴趣的可以百度下

　　　当然，你也可以手动编写get/set/构造方法。

 

数据库访问层（repository）:

package com.ssh.repository;

import java.io.Serializable;
import java.util.List;

/**
 * Created by XRog
 * On 2/2/2017.2:28 PM
 */
public interface DomainRepository<T,PK extends Serializable>{
    T load(PK id);

    T get(PK id);

    List<T> findAll();

    void persist(T entity);

    PK save(T entity);

    void saveOrUpdate(T entity);

    void delete(PK id);

    void flush();
}

package com.ssh.repository;

import com.ssh.entity.Person;

/**
 * Created by XRog
 * On 2/2/2017.2:25 PM
 */
public interface PersonRepository extends DomainRepository<Person,Long> {
}

package com.ssh.repository.impl;

import com.ssh.repository.PersonRepository;
import com.ssh.entity.Person;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * Created by XRog
 * On 2/2/2017.2:30 PM
 */
@Repository
public class PersonRepositoryImpl implements PersonRepository {

    @Autowired
    private SessionFactory sessionFactory;

    private Session getCurrentSession() {
        return this.sessionFactory.openSession();
    }

    public Person load(Long id) {
        return (Person)getCurrentSession().load(Person.class,id);
    }

    public Person get(Long id) {
        return (Person)getCurrentSession().get(Person.class,id);
    }

    public List<Person> findAll() {
        return null;
    }

    public void persist(Person entity) {
        getCurrentSession().persist(entity);
    }

    public Long save(Person entity) {
        return (Long)getCurrentSession().save(entity);
    }

    public void saveOrUpdate(Person entity) {
        getCurrentSession().saveOrUpdate(entity);
    }

    public void delete(Long id) {
        Person person = load(id);
        getCurrentSession().delete(person);
    }

    public void flush() {
        getCurrentSession().flush();
    }
}

　　PS:我这里显示写了一个比较通用的接口，其他所有接口皆继承此接口， 再编写实现类

　　注意：我这里写的session产生是调用的SessionFactory的openSession（）这个方法。之前使用getCurrentSession()一直报错，后来百度了一下才知道，hibernate3版本可以使用getCurrentSession()来创建session，而hibernate4版本则不行。

 

服务层（service）:

package com.ssh.service;

import com.ssh.entity.Person;

/**
 * Created by XRog
 * On 2/2/2017.2:39 PM
 */
public interface PersonService {
    Long savePerson();
}

package com.ssh.service.impl;

import com.ssh.entity.Person;
import com.ssh.repository.PersonRepository;
import com.ssh.service.PersonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * Created by XRog
 * On 2/2/2017.2:40 PM
 */
@Service
public class PersonServiceImpl implements PersonService {

    @Autowired
    private PersonRepository personRepository;

    public Long savePerson() {
        Person person = new Person();
        person.setUsername("XRog");
        person.setPhone("18381005946");
        person.setAddress("chenDu");
        person.setRemark("this is XRog");
        return personRepository.save(person);
    }
}

控制层（controller）:

package com.ssh.controller;

import com.ssh.entity.Person;
import com.ssh.service.PersonService;
import com.ssh.service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;


/**
 * Created by XRog
 * On 2/1/2017.12:36 AM
 */
@Controller
public class MainController {

    @Autowired
    private PersonService personService;

    @RequestMapping(value = "savePerson", method = RequestMethod.GET)
    @ResponseBody
    public String savePerson(){
        personService.savePerson();
        return "success!";
    }
}

OK，编写完毕，我们重启下服务器然后测试：

我们在看下数据库，跟我们插入的数据对比下

有段时间没有更新博客了，跟最近比较忙有关系。无聊搭建个Java web框架，反正好久没有自己搭建框架了，算是练练手了，今天我就来搭建一个框架，技术选型为Spring mvc+Spring+hibernate。若想搭建Spring mvc+Spring+Mybatis请看我上篇日志，好了废话不多说，见代码。

1、开发环境：jdk1.7，tomcat6,eclipse版本过高需要设置jdk

2、项目结构

2、Spring mvc+Spring+Hibernate框架搭建流程跟Spring mvc+Spring+Mybatis搭建类似

首先在web.xml中配置Spring监听器及加载文件，其次配置spring mvc的配置，并在web.xml中配置spring mvc的servlet，最后在配置Spring与Hibernate整合部分即sessionFactory、数据库连接池等

3、先看web.xml配置

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee   
5.     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
6.     <welcome-file-list>  
7.         <welcome-file>index.jsp</welcome-file>  
8.     </welcome-file-list>  
9.   
10. <!-- 加载spring配置文件 -->  
11.     <context-param>  
12.         <param-name>contextConfigLocation</param-name>  
13.         <param-value>  
14.             classpath:config/application-config.xml  
15.         </param-value>  
16.     </context-param>  
17.   
18. <!-- spring监听器 -->  
19.     <listener>  
20.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
21.     </listener>  
22. <!-- 配置编码 -->  
23.     <filter>  
24.         <filter-name>CharacterEncodingFilter</filter-name>  
25.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
26.         <init-param>  
27.             <param-name>encoding</param-name>  
28.             <param-value>UTF-8</param-value>  
29.         </init-param>  
30.         <init-param>  
31.             <param-name>forceEncoding</param-name>  
32.             <param-value>true</param-value>  
33.         </init-param>  
34.     </filter>  
35.     <filter-mapping>  
36.         <filter-name>CharacterEncodingFilter</filter-name>  
37.         <url-pattern>/*</url-pattern>  
38.     </filter-mapping>  
39.   
40.   
41.     <!-- spring mvc dispatcher -->  
42.     <servlet>  
43.         <servlet-name>dispatcherServlet</servlet-name>  
44.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
45.         <init-param>  
46.             <param-name>contextConfigLocation</param-name>  
47.             <param-value>classpath:config/mvc-config.xml</param-value>  
48.         </init-param>  
49.         <load-on-startup>1</load-on-startup>  
50.     </servlet>  
51.   
52.     <servlet-mapping>  
53.         <servlet-name>dispatcherServlet</servlet-name>  
54.         <url-pattern>/</url-pattern>  
55.     </servlet-mapping>  
56. <!--错误页面配置 -->  
57.     <error-page>  
58.         <error-code>403</error-code>  
59.         <location>/WEB-INF/view/error/403.jsp</location>  
60.     </error-page>  
61.     <error-page>  
62.         <error-code>404</error-code>  
63.         <location>/WEB-INF/view/error/404.jsp</location>  
64.     </error-page>  
65.     <error-page>  
66.         <error-code>500</error-code>  
67.         <location>/WEB-INF/view/error/500.jsp</location>  
68.     </error-page>   
69. </web-app>  

4、 我们在来看看spring mvc的配置文件mvc-config.xml

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2.   
3. <beans xmlns="http://www.springframework.org/schema/beans"  
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"  
5.     xmlns:context="http://www.springframework.org/schema/context"  
6.     xmlns:p="http://www.springframework.org/schema/p"  
7.     xsi:schemaLocation="http://www.springframework.org/schema/mvc  
8.        http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd  
9.         http://www.springframework.org/schema/beans  
10.         http://www.springframework.org/schema/beans/spring-beans.xsd   
11.         http://www.springframework.org/schema/context   
12.         http://www.springframework.org/schema/context/spring-context.xsd" default-autowire="byType">  
13.   
14. <!-- 启动注解 -->  
15.     <mvc:annotation-driven />   
16. <!-- 扫描注解包 -->  
17.     <context:component-scan base-package="com.demo"></context:component-scan>  
18. <!-- 配置view页面 -->  
19.     <bean  
20.         class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
21.         <property name="prefix" value="/WEB-INF/view/" />  
22.         <property name="suffix" value=".jsp" />  
23.     </bean>  
24. <!-- 加载application.properties文件，这个文件一般都配置了数据库及数据库连接池等 -->  
25.     <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PreferencesPlaceholderConfigurer">    
26.         <property name="location">    
27.         <value>classpath:config/application.properties</value>    
28.         </property>    
29.     </bean>    
30.     <!-- 静态文件 -->  
31.     <mvc:resources mapping="/resources/**" location="/WEB-INF/resources/"></mvc:resources>  
32. </beans>  

[html]  view plain  copy

1.   

5、 常用配置信息如数据库连接池等信息，一般习惯配置在新的文件中application.properties

[html]  view plain  copy

1. #hibernate  
2. hibernate.max_fetch_depth=3  
3. hibernate.jdbc.fetch_size=50  
4. hibernate.jdbc.batch_size=10  
5. hibernate.show_sql=true  
6. hibernate.cache.use_second_level_cache=true  
7. hibernate.cache.use_query_cache=true  
8. hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory  
9.   
10. jdbc.driverClassName=com.mysql.jdbc.Driver  
11. jdbc.url=jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=UTF-8  
12. jdbc.username=root  
13. jdbc.password=root  
14. jdbc.maxActive=50  
15.   
16. c3p0.acquireIncrement=10  
17. c3p0.minPoolSize=3  
18. c3p0.maxPoolSize=200  
19. c3p0.maxIdleTime=6000  

6、 spring基本配置，及spring 事物数据库连接池等配置
基本配置application-config.xml

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.        xmlns:context="http://www.springframework.org/schema/context"  
5.        xmlns:task="http://www.springframework.org/schema/task"  
6.        xmlns:cache="http://www.springframework.org/schema/cache"  
7.        xmlns:p="http://www.springframework.org/schema/p"  
8.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
9.         http://www.springframework.org/schema/beans/spring-beans.xsd  
10.         http://www.springframework.org/schema/context  
11.         http://www.springframework.org/schema/context/spring-context.xsd  
12.         http://www.springframework.org/schema/task  
13.         http://www.springframework.org/schema/task/spring-task.xsd  
14.         http://www.springframework.org/schema/cache  
15.         http://www.springframework.org/schema/cache/spring-cache.xsd">  
16.   
17.       
18.     <!-- 扫描包 -->  
19.     <context:component-scan base-package="com.demo"/>  
20. <!-- 注解配置 -->  
21.     <context:annotation-config></context:annotation-config>  
22.     <!-- 引人其他文件 -->  
23.      <import resource="data-source-tx.xml"></import>  
24.       
25.      <!-- hibernate ehcache   
26.     <cache:annotation-driven cache-manager="cacheManager"></cache:annotation-driven>  
27.       
28.      <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">  
29.         <property name="cacheManager" ref="ehcache"></property>  
30.     </bean>  
31.     <bean id="ehcache" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"  
32.           p:configLocation="classpath:config/ehcache.xml" p:shared="true"/>-->  
33.   
34. </beans>  

hibernate的sessionFactory及数据库连接池配置datasource-tx.xml

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
4.     xmlns:context="http://www.springframework.org/schema/context"  
5.     xmlns:jdbc="http://www.springframework.org/schema/jdbc"   
6.     xmlns:tx="http://www.springframework.org/schema/tx"  
7.     xmlns:aop="http://www.springframework.org/schema/aop"  
8.     xmlns:p="http://www.springframework.org/schema/p"  
9.     xsi:schemaLocation="http://www.springframework.org/schema/jdbc  
10.         http://www.springframework.org/schema/jdbc/spring-jdbc.xsd  
11.         http://www.springframework.org/schema/beans   
12.         http://www.springframework.org/schema/beans/spring-beans.xsd  
13.         http://www.springframework.org/schema/tx   
14.         http://www.springframework.org/schema/tx/spring-tx.xsd  
15.         http://www.springframework.org/schema/aop  
16.         http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
17.         http://www.springframework.org/schema/context   
18.         http://www.springframework.org/schema/context/spring-context.xsd">  
19.   
20.     <context:property-placeholder location="classpath:config/application.properties"/>  
21.   
22.     <!-- sessionFactory -->  
23.     <bean id="sessionFactory"   
24.         class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">  
25.         <property name="dataSource" ref="dataSource" />  
26.         <property name="packagesToScan" value="com.demo.model" />  
27.         <property name="hibernateProperties">  
28.             <props>  
29.                 <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>  
30.                 <prop key="hibernate.current_session_context_class">thread</prop>   
31.             </props>  
32.         </property>  
33.     </bean>  
34.   
35.     <!-- dataSource -->  
36.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"  
37.         destroy-method="close">  
38.         <property name="driverClass" value="${jdbc.driverClassName}" />  
39.         <property name="jdbcUrl" value="${jdbc.url}" />  
40.         <property name="user" value="${jdbc.username}" />  
41.         <property name="password" value="${jdbc.password}" />  
42.   
43.         <!-- these are C3P0 properties -->  
44.         <property name="acquireIncrement" value="${c3p0.acquireIncrement}" />  
45.         <property name="minPoolSize" value="${c3p0.minPoolSize}" />  
46.         <property name="maxPoolSize" value="${c3p0.maxPoolSize}" />  
47.         <property name="maxIdleTime" value="${c3p0.maxIdleTime}" />  
48.     </bean>  
49.       
50.     <!-- 配置Hibernate事务管理器 -->  
51.     <bean id="transactionManager"  
52.         class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
53.       <property name="sessionFactory" ref="sessionFactory" />  
54.    </bean>  
55.    <!-- 事物注解配置 -->  
56.    <tx:annotation-driven transaction-manager="transactionManager"/>      
57.          
58.   
59. </beans>  

以上内容为配置内容，配置讲完了，下面以用户登录为测试案例

1、控制层controller

[java]  view plain  copy

1. package com.demo.controller;  
2.   
3. import javax.validation.Valid;  
4.   
5. import org.springframework.beans.factory.annotation.Autowired;  
6. import org.springframework.stereotype.Controller;  
7. import org.springframework.ui.Model;  
8. import org.springframework.validation.BindingResult;  
9. import org.springframework.web.bind.annotation.RequestMapping;  
10. import org.springframework.web.bind.annotation.RequestMethod;  
11.   
12. import com.demo.model.User;  
13. import com.demo.service.UserService;  
14.   
15. @Controller  
16. @RequestMapping("/user")  
17. public class UserController {  
18.       
19.     @Autowired  
20.     private UserService userService;  
21.       
22.     @RequestMapping(value="/login",method=RequestMethod.GET,params="form")  
23.     public String toLogin(Model model){  
24.         User user = new User();  
25.         model.addAttribute(user);  
26.         return "user/login";  
27.     }  
28.       
29.     @RequestMapping(value="/login",method=RequestMethod.POST)  
30.     public String login(@Valid User user,BindingResult result){  
31.         if(result.hasErrors()){  
32.             return "user/login";  
33.         }  
34.         if(this.userService.login(user.getUsername(), user.getPassword())){  
35.             return "user/success";  
36.         }  
37.         return "user/fail";  
38.           
39.     }  
40.   
41. }  

2、实体层model

[java]  view plain  copy

1. package com.demo.model;  
2.   
3. import java.io.Serializable;  
4.   
5. import javax.persistence.Entity;  
6. import javax.persistence.GeneratedValue;  
7. import javax.persistence.Id;  
8. import javax.persistence.Table;  
9.   
10. @Entity  
11. @Table(name="user")  
12. public class User implements Serializable {  
13.   
14.     /** 
15.      *  
16.      */  
17.     private static final long serialVersionUID = 1482055695347272535L;  
18.       
19.     @Id  
20.     @GeneratedValue  
21.     private long id;  
22.       
23.     private String username;  
24.       
25.     private String password;  
26.   
27.     public long getId() {  
28.         return id;  
29.     }  
30.   
31.     public void setId(long id) {  
32.         this.id = id;  
33.     }  
34.   
35.     public String getUsername() {  
36.         return username;  
37.     }  
38.   
39.     public void setUsername(String username) {  
40.         this.username = username;  
41.     }  
42.   
43.     public String getPassword() {  
44.         return password;  
45.     }  
46.   
47.     public void setPassword(String password) {  
48.         this.password = password;  
49.     }  
50.       
51.       
52.   
53. }  

3、服务层service

服务层接口

[java]  view plain  copy

1. package com.demo.service;  
2.   
3. public interface UserService {  
4.       
5.     public boolean login(String username,String password);  
6.   
7. }  

服务层实现类

[java]  view plain  copy

1. package com.demo.service.impl;  
2.   
3. import javax.transaction.Transactional;  
4.   
5. import org.springframework.beans.factory.annotation.Autowired;  
6. import org.springframework.stereotype.Service;  
7.   
8. import com.demo.dao.UserDao;  
9. import com.demo.model.User;  
10. import com.demo.service.UserService;  
11.   
12. @Service  
13. @Transactional  
14. public class UserServiceImpl implements UserService {  
15.       
16.     @Autowired  
17.     private UserDao userDao;  
18.   
19.     @Override  
20.     @Transactional  
21.     public boolean login(String username, String password) {  
22.         boolean flag = false;  
23.         User user = this.userDao.findByUsernameAndPassword(username, password);  
24.         if(user != null){  
25.             if(username.equals(user.getUsername()) && password.equals(user.getPassword())){  
26.                 flag = true;  
27.             }  
28.         }  
29.         return flag;  
30.     }  
31.   
32. }  

4、持久层dao

[java]  view plain  copy

1. package com.demo.dao;  
2.   
3. import org.hibernate.Query;  
4. import org.hibernate.Session;  
5. import org.hibernate.SessionFactory;  
6. import org.springframework.beans.factory.annotation.Autowired;  
7. import org.springframework.stereotype.Repository;  
8.   
9. import com.demo.model.User;  
10. @Repository  
11. public class UserDao{  
12.       
13.     @Autowired  
14.     private SessionFactory sessionFactory;  
15.       
16.     public Session getSession(){  
17.         return this.sessionFactory.openSession();  
18.     }  
19.       
20.     public void close(Session session){  
21.         if(session != null)  
22.             session.close();  
23.     }  
24.           
25.     public User findByUsernameAndPassword(String username,String password){  
26.         String hsql="from User u where u.username= :username and u.password= :password";  
27.         Session session = getSession();  
28.         Query query = session.createQuery(hsql);  
29.         query.setParameter("username", username).setParameter("password", password);  
30.         User user = (User) query.uniqueResult();  
31.         close(session);  
32.         return user;  
33.     }  
34.   
35. }  

5、sql脚本

[sql]  view plain  copy

1. /*  
2. Navicat MySQL Data Transfer  
3.   
4. Source Server         : localhost  
5. Source Server Version : 50622  
6. Source Host           : localhost:3306  
7. Source Database       : demo  
8.   
9. Target Server Type    : MYSQL  
10. Target Server Version : 50622  
11. File Encoding         : 65001  
12.   
13. Date: 2016-07-19 20:36:51  
14. */  
15.   
16. SET FOREIGN_KEY_CHECKS=0;  
17.   
18. -- ----------------------------  
19. -- Table structure for `kpi`  
20. -- ----------------------------  
21. DROP TABLE IF EXISTS `kpi`;  
22. CREATE TABLE `kpi` (  
23.   `id` int(11) NOT NULL AUTO_INCREMENT,  
24.   `day` varchar(20) DEFAULT NULL,  
25.   `state` varchar(20) DEFAULT NULL,  
26.   `num` int(111) DEFAULT NULL,  
27.   PRIMARY KEY (`id`)  
28. ) ENGINE=InnoDB AUTO_INCREMENT=21 DEFAULT CHARSET=utf8;  
29.   
30. -- ----------------------------  
31. -- Records of kpi  
32. -- ----------------------------  
33. INSERT INTO `kpi` VALUES ('1', '6月28日', 'success', '11');  
34. INSERT INTO `kpi` VALUES ('2', '6月28日', 'fail', '22');  
35. INSERT INTO `kpi` VALUES ('3', '6月29日', 'success', '33');  
36. INSERT INTO `kpi` VALUES ('4', '6月29日', 'fail', '27');  
37. INSERT INTO `kpi` VALUES ('5', '6月30日', 'success', '232');  
38. INSERT INTO `kpi` VALUES ('6', '6月30日', 'fail', '123');  
39. INSERT INTO `kpi` VALUES ('7', '7月1日', 'success', '235');  
40. INSERT INTO `kpi` VALUES ('8', '7月1日', 'fail', '80');  
41. INSERT INTO `kpi` VALUES ('9', '7月2日', 'success', '90');  
42. INSERT INTO `kpi` VALUES ('10', '7月2日', 'fail', '324');  
43. INSERT INTO `kpi` VALUES ('11', '7月3日', 'success', '325');  
44. INSERT INTO `kpi` VALUES ('12', '7月3日', 'fail', '134');  
45. INSERT INTO `kpi` VALUES ('13', '7月4日', 'success', '345');  
46. INSERT INTO `kpi` VALUES ('14', '7月4日', 'fail', '245');  
47. INSERT INTO `kpi` VALUES ('15', '7月5日', 'success', '124');  
48. INSERT INTO `kpi` VALUES ('16', '7月5日', 'fail', '256');  
49. INSERT INTO `kpi` VALUES ('17', '7月6日', 'success', '193');  
50. INSERT INTO `kpi` VALUES ('18', '7月6日', 'fail', '274');  
51. INSERT INTO `kpi` VALUES ('19', '7月7日', 'success', '232');  
52. INSERT INTO `kpi` VALUES ('20', '7月7日', 'fail', '234');  
53.   
54. -- ----------------------------  
55. -- Table structure for `kpi_detail`  
56. -- ----------------------------  
57. DROP TABLE IF EXISTS `kpi_detail`;  
58. CREATE TABLE `kpi_detail` (  
59.   `id` int(11) NOT NULL AUTO_INCREMENT,  
60.   `startTime` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,  
61.   `endTime` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,  
62.   `state` varchar(20) DEFAULT NULL,  
63.   PRIMARY KEY (`id`)  
64. ) ENGINE=InnoDB AUTO_INCREMENT=41 DEFAULT CHARSET=utf8;  
65.   
66. -- ----------------------------  
67. -- Records of kpi_detail  
68. -- ----------------------------  
69. INSERT INTO `kpi_detail` VALUES ('1', '2016-07-17 16:02:19', '2016-07-17 16:02:19', 'success');  
70. INSERT INTO `kpi_detail` VALUES ('2', '2016-07-17 16:03:27', '2016-07-17 16:03:27', 'success');  
71. INSERT INTO `kpi_detail` VALUES ('3', '2016-07-17 16:03:27', '2016-07-17 16:03:27', 'success');  
72. INSERT INTO `kpi_detail` VALUES ('4', '2016-07-17 16:03:27', '2016-07-17 16:03:27', 'success');  
73. INSERT INTO `kpi_detail` VALUES ('6', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
74. INSERT INTO `kpi_detail` VALUES ('7', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
75. INSERT INTO `kpi_detail` VALUES ('8', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
76. INSERT INTO `kpi_detail` VALUES ('9', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
77. INSERT INTO `kpi_detail` VALUES ('13', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
78. INSERT INTO `kpi_detail` VALUES ('14', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
79. INSERT INTO `kpi_detail` VALUES ('15', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
80. INSERT INTO `kpi_detail` VALUES ('16', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
81. INSERT INTO `kpi_detail` VALUES ('17', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
82. INSERT INTO `kpi_detail` VALUES ('18', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
83. INSERT INTO `kpi_detail` VALUES ('19', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
84. INSERT INTO `kpi_detail` VALUES ('20', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
85. INSERT INTO `kpi_detail` VALUES ('28', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
86. INSERT INTO `kpi_detail` VALUES ('29', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
87. INSERT INTO `kpi_detail` VALUES ('30', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
88. INSERT INTO `kpi_detail` VALUES ('31', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
89. INSERT INTO `kpi_detail` VALUES ('32', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
90. INSERT INTO `kpi_detail` VALUES ('33', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
91. INSERT INTO `kpi_detail` VALUES ('34', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
92. INSERT INTO `kpi_detail` VALUES ('35', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
93. INSERT INTO `kpi_detail` VALUES ('36', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
94. INSERT INTO `kpi_detail` VALUES ('37', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
95. INSERT INTO `kpi_detail` VALUES ('38', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
96. INSERT INTO `kpi_detail` VALUES ('39', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
97. INSERT INTO `kpi_detail` VALUES ('40', '2016-07-17 16:03:28', '2016-07-17 16:03:28', 'success');  
98.   
99. -- ----------------------------  
100. -- Table structure for `user`  
101. -- ----------------------------  
102. DROP TABLE IF EXISTS `user`;  
103. CREATE TABLE `user` (  
104.   `id` int(11) NOT NULL AUTO_INCREMENT,  
105.   `username` varchar(255) DEFAULT NULL,  
106.   `password` varchar(255) DEFAULT NULL,  
107.   PRIMARY KEY (`id`)  
108. ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;  
109.   
110. -- ----------------------------  
111. -- Records of user  
112. -- ----------------------------  
113. INSERT INTO `user` VALUES ('1', 'samtest', '123456');  

至此，整个项目算是搭建并测试成功

spring springmvc hibernate(ssh)项目整合开发---总体架构搭建

    国庆觉得没啥地方想去，于是乎想自己搭建一个长期的用于练手的ssh项目（注意：这里的ssh指的是spring4 springmvc4 hibernate4），在其中融进自己学到的技术，并持续进行更新，与诸位博友共享。目前开发了一个在web项目中比较实用的邮件通信工具类，其中在这个ssh项目中主要用于：“注册成功时采用邮箱验证”与“忘记密码时通过邮件找回密码”。我觉得两个是比较实用的小模块。

    好了，废话不多说，在介绍上述的两个小模块之前，毫无疑问的，得先把项目的整体架构搭建起来！项目的后端架构采用spring4 springmvc4 hibernate4，前端采用jsp、jquery、ajax。

    首先先预览一下项目的总体架构图：

      

     放入jar包，可以到这里下载：ssm整合jar包

     接下来，配置web.xml，如下所示：

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
3.     xmlns="http://java.sun.com/xml/ns/javaee"  
4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"  
5.     id="WebApp_ID" version="2.5">  
6.     <display-name>springspringmvchibernate</display-name>  
7.   
8.     <welcome-file-list>  
9.         <welcome-file>index.jsp</welcome-file>  
10.     </welcome-file-list>  
11.       
12.     <!-- spring配置文件名称与位置 -->  
13.     <context-param>  
14.         <param-name>contextConfigLocation</param-name>  
15.         <param-value>classpath:applicationContext-spring.xml</param-value>  
16.     </context-param>  
17.   
18.     <listener>  
19.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
20.     </listener>  
21.       
22.     <!-- springmvc的配置 -->  
23.     <servlet>  
24.         <servlet-name>dispatcherServlet</servlet-name>  
25.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
26.         <init-param>  
27.             <param-name>contextConfigLocation</param-name>  
28.             <param-value>classpath:applicationContext-springmvc.xml</param-value>  
29.         </init-param>  
30.         <load-on-startup>1</load-on-startup>  
31.     </servlet>  
32.   
33.     <servlet-mapping>  
34.         <servlet-name>dispatcherServlet</servlet-name>  
35.         <url-pattern>/</url-pattern>  
36.     </servlet-mapping>  
37.       
38.     <!-- 配置编码过滤器 -->  
39.     <filter>  
40.         <filter-name>characterEncodingFilter</filter-name>  
41.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
42.         <init-param>  
43.             <param-name>encoding</param-name>  
44.             <param-value>utf-8</param-value>  
45.         </init-param>  
46.         <init-param>  
47.             <param-name>forceEncoding</param-name>  
48.             <param-value>true</param-value>  
49.         </init-param>  
50.     </filter>  
51.     <filter-mapping>  
52.         <filter-name>characterEncodingFilter</filter-name>  
53.         <url-pattern>/*</url-pattern>  
54.     </filter-mapping>  
55.       
56.     <listener>  
57.         <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>  
58.     </listener>  
59.   
60. </web-app>  

    spring的配置文件：（已在xml文件中进行详细的注释，不多说明）

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.     xmlns:aop="http://www.springframework.org/schema/aop"  
5.     xmlns:context="http://www.springframework.org/schema/context"  
6.     xmlns:tx="http://www.springframework.org/schema/tx"  
7.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
8.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
9.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd  
10.         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">  
11.       
12.     <!-- 添加注解支持 -->  
13.     <context:annotation-config />  
14.       
15.     <!-- 扫描server层包 -->  
16.     <context:component-scan base-package="com.steadyjack.server"></context:component-scan>  
17.   
18.     <!-- 导入jdbc数据库连接信息的配置文件 -->  
19.     <context:property-placeholder location="classpath:jdbc.properties" />  
20.       
21.     <!-- 配置数据源 c3p0 -->  
22.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">  
23.         <property name="driverClass" value="${jdbc.driverClassName}"></property>  
24.         <property name="user" value="${jdbc.user}"></property>  
25.         <property name="password" value="${jdbc.password}"></property>  
26.         <property name="jdbcUrl" value="${jdbc.url}"></property>  
27.           
28.         <property name="initialPoolSize" value="${jdbc.initialPoolSize}"></property>  
29.         <property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>  
30.         <property name="acquireIncrement" value="${jdbc.acquireIncrement}"></property>  
31.         <property name="maxStatements" value="${jdbc.maxStatements}"></property>  
32.         <property name="maxStatementsPerConnection" value="${jdbc.maxStatementsPerConnection}"></property>  
33.         <property name="maxIdleTime" value="${jdbc.maxIdleTime}"></property>  
34.     </bean>  
35.       
36.     <!-- 配置hibernate的sessionFactory,并让spring的ioc进行管理 -->  
37.     <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">  
38.         <!-- 配置数据源属性 -->  
39.         <property name="dataSource" ref="dataSource"></property>  
40.           
41.         <!-- 引入hibernate的属性配置文件 -->  
42.         <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>  
43.           
44.         <!-- 扫描实体类,将其映射为具体的数据库表 -->  
45.         <property name="packagesToScan" value="com.steadyjack.server.model"></property>  
46.     </bean>  
47.       
48.     <!-- 配置事务管理,采用Hibernate4 -->  
49.     <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
50.         <property name="sessionFactory" ref="sessionFactory"></property>  
51.     </bean>  
52.       
53.     <!-- 配置事务传播属性,注意需要有事务管理(transaction-manager) : 其实就是事务(方法)发生的时间和要发生的故事-->  
54.     <tx:advice id="txAdvice" transaction-manager="transactionManager">  
55.         <tx:attributes>  
56.             <tx:method name="add*" propagation="REQUIRED"/>  
57.             <tx:method name="save*" propagation="REQUIRED"/>  
58.             <tx:method name="insert*" propagation="REQUIRED"/>  
59.             <tx:method name="delete*" propagation="REQUIRED"/>  
60.             <tx:method name="update*" propagation="REQUIRED"/>  
61.             <tx:method name="find*" propagation="REQUIRED" read-only="true"/>  
62.             <tx:method name="load*" propagation="REQUIRED" read-only="true"/>  
63.             <tx:method name="query*" propagation="REQUIRED" read-only="true"/>  
64.             <tx:method name="*" propagation="REQUIRED"/>  
65.         </tx:attributes>  
66.     </tx:advice>  
67.       
68.     <!-- 配置事务切面,并关联事务的传播属性: 其实就是一个方法,只是这个方法是事务性的事务,它的发生不是随机的,而是具有时间,地点和该发生的故事的 -->  
69.     <aop:config>  
70.           
71.         <!-- 切点: 其实就是告诉了地点 -->  
72.         <aop:pointcut expression="execution(* com.steadyjack.server.service.*.*(..))" id="pointCut"/>  
73.           
74.         <!-- 要执行那样的事务,那当然得需要通知,通知它什么时候发生,在哪里发生,发生啥事 -->  
75.         <aop:advisor advice-ref="txAdvice" pointcut-ref="pointCut"/>  
76.     </aop:config>  
77.       
78. </beans>  

    数据库配置文件jdbc.properties：

[html]  view plain  copy

1. jdbc.driverClassName=com.mysql.jdbc.Driver  
2. jdbc.url=jdbc:mysql://localhost:3306/db_springspringmvchibernate?autoReconnect=true&amp;useUnicode=true&amp;characterEncoding=utf-8  
3. jdbc.user=root  
4. jdbc.password=123456  
5.   
6. jdbc.initialPoolSize=4  
7. jdbc.minPoolSize=3  
8. jdbc.maxPoolSize=15  
9. jdbc.acquireIncrement=3  
10. jdbc.maxStatements=10  
11. jdbc.maxStatementsPerConnection=5  
12. jdbc.maxIdleTime=6000  

    hibernate配置文件：

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE hibernate-configuration PUBLIC  
3.         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
4.         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  
5. <hibernate-configuration>  
6.     <session-factory>  
7.           
8.         <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>  
9.         <property name="show_sql">true</property>  
10.         <property name="format_sql">true</property>  
11.         <property name="hbm2ddl.auto">update</property>  
12.           
13.         <!-- 配置二级缓存相关 -->  
14.           
15.     </session-factory>  
16. </hibernate-configuration>  

    springmvc的配置文件：

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"  
4.     xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"  
5.     xmlns:mvc="http://www.springframework.org/schema/mvc"  
6.     xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
7.         http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd  
8.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
9.         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
10.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">  
11.   
12.     <!-- 扫描web层 -->  
13.     <context:component-scan base-package="com.steadyjack.web.controller" />  
14.   
15.     <!-- 配置静态资源不经过dispatcher处理 -->  
16.     <mvc:default-servlet-handler/>  
17.       
18.     <mvc:annotation-driven />  
19.   
20.     <!-- 解析的结果: 前缀+ viewName +后缀 -->  
21.     <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
22.         <property name="prefix" value="/WEB-INF/pages/"></property>  
23.         <property name="suffix" value=".jsp"></property>  
24.     </bean>  
25.   
26.   
27. </beans>  

     最后是日志配置log4j.properties：

[html]  view plain  copy

1. log4j.rootLogger = INFO, console, R  
2.   
3. log4j.appender.console = org.apache.log4j.ConsoleAppender  
4. log4j.appender.console.layout = org.apache.log4j.PatternLayout  
5. log4j.appender.console.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n  
6.   
7. log4j.appender.R = org.apache.log4j.RollingFileAppender  
8. log4j.appender.R.File = D:\\logs\\log.log     
9. log4j.appender.R.MaxFileSize = 500KB  
10.   
11. log4j.appender.R.MaxBackupIndex = 1  
12. log4j.appender.R.layout = org.apache.log4j.PatternLayout  
13. log4j.appender.R.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] - %m%n  

     然后，建立com.steadyjack.server.dao、com.steadyjack.server.dao.impl这两个package，并在impl包创建BaseDaoImpl.java文件，用于获取hibernate的sessionFactory，以便给各个dao通用。

[java]  view plain  copy

1. package com.steadyjack.server.dao.impl;  
2.   
3. import org.hibernate.Session;  
4. import org.hibernate.SessionFactory;  
5. import org.springframework.beans.factory.annotation.Autowired;  
6. import org.springframework.stereotype.Repository;  
7.   
8. @Repository  
9. public class BaseDaoImpl{  
10.   
11.     @Autowired  
12.     private SessionFactory sessionFactory;  
13.       
14.     public Session getSession(){  
15.         return sessionFactory.getCurrentSession();  
16.     }  
17.   
18. }  

     在 com.steadyjack.server.model包下建立 User 这个Model

[java]  view plain  copy

1. package com.steadyjack.server.model;  
2.   
3. import java.io.Serializable;  
4. import java.util.Date;  
5.   
6. import javax.persistence.Column;  
7. import javax.persistence.Entity;  
8. import javax.persistence.GeneratedValue;  
9. import javax.persistence.GenerationType;  
10. import javax.persistence.Id;  
11. import javax.persistence.Table;  
12.   
13. @Entity  
14. @Table(name="tb_user")  
15. public class User implements Serializable{  
16.       
17.     /** 
18.      *  
19.      */  
20.     private static final long serialVersionUID = -5813264827007873950L;  
21.   
22.     private Integer id;  
23.       
24.     private String userName;  
25.       
26.     private String password;  
27.       
28.     private String email;  
29.       
30.     //1-男  0-女  
31.     private Integer sex;   
32.       
33.     //序列码  
34.     private String validateSerCode;  
35.       
36.     //序列码过时日期  
37.     private Date validateOverDate;  
38.       
39.     //用户名的字节编码  
40.     private String userNameEncodes;  
41.       
42.     //是否已经被验证：0表示未验证 1表示已经验证  
43.     private Integer isValidated=0;  
44.       
45.     @Id  
46.     @GeneratedValue(strategy = GenerationType.AUTO)  
47.     public Integer getId() {  
48.         return id;  
49.     }  
50.   
51.     public void setId(Integer id) {  
52.         this.id = id;  
53.     }  
54.   
55.     @Column(name="user_name")  
56.     public String getUserName() {  
57.         return userName;  
58.     }  
59.   
60.     public void setUserName(String userName) {  
61.         this.userName = userName;  
62.     }  
63.   
64.     public String getPassword() {  
65.         return password;  
66.     }  
67.   
68.     public void setPassword(String password) {  
69.         this.password = password;  
70.     }  
71.   
72.     public Integer getSex() {  
73.         return sex;  
74.     }  
75.   
76.     public void setSex(Integer sex) {  
77.         this.sex = sex;  
78.     }  
79.       
80.     public String getEmail() {  
81.         return email;  
82.     }  
83.   
84.     public void setEmail(String email) {  
85.         this.email = email;  
86.     }  
87.       
88.     @Column(name="validate_ser_code")  
89.     public String getValidateSerCode() {  
90.         return validateSerCode;  
91.     }  
92.   
93.     public void setValidateSerCode(String validateSerCode) {  
94.         this.validateSerCode = validateSerCode;  
95.     }  
96.   
97.     @Column(name="validate_over_date")  
98.     public Date getValidateOverDate() {  
99.         return validateOverDate;  
100.     }  
101.   
102.     public void setValidateOverDate(Date validateOverDate) {  
103.         this.validateOverDate = validateOverDate;  
104.     }  
105.       
106.     @Column(name="user_name_encodes")  
107.     public String getUserNameEncodes() {  
108.         return userNameEncodes;  
109.     }  
110.   
111.     @Column(name="is_validated")  
112.     public Integer getIsValidated() {  
113.         return isValidated;  
114.     }  
115.   
116.     public void setIsValidated(Integer isValidated) {  
117.         this.isValidated = isValidated;  
118.     }  
119.   
120.     public void setUserNameEncodes(String userNameEncodes) {  
121.         this.userNameEncodes = userNameEncodes;  
122.     }  
123.   
124.     @Override  
125.     public String toString() {  
126.         return "User [id=" + id + ", userName=" + userName + ", password="  
127.                 + password + ", email=" + email + ", sex=" + sex + "]";  
128.     }  
129.   
130. }  

     在com.steadyjack.server.dao建立UserDao以及在 com.steadyjack.server.dao.impl建立UserDaoImpl

[java]  view plain  copy

1. package com.steadyjack.server.dao;  
2.   
3. import java.util.List;  
4.   
5. import com.steadyjack.server.model.User;  
6.   
7. public interface UserDao {  
8.       
9.     public void saveUser(User user);  
10.       
11.     public User queryUser(User user);  
12.       
13.     public User findUserById(Integer id);  
14.       
15.     public User findUserPassword(String userName,String email);  
16.       
17.     public List<User> findUser(List<Object> params,String hql);  
18.       
19.     public void updateUser(User user);  
20.       
21.     public User findUserByUserName(String userName);  
22. }  

[java]  view plain  copy

1. package com.steadyjack.server.dao.impl;  
2.   
3. import java.util.List;  
4.   
5. import org.hibernate.Query;  
6. import org.springframework.stereotype.Repository;  
7.   
8. import com.steadyjack.server.dao.UserDao;  
9. import com.steadyjack.server.model.User;  
10.   
11. @Repository  
12. public class UserDaoImpl extends BaseDaoImpl implements UserDao {  
13.   
14.     @SuppressWarnings("unchecked")  
15.     public User queryUser(User user) {  
16.         String hql="from User where userName=? and password=?";  
17.         Query query=getSession().createQuery(hql);  
18.         query.setParameter(0, user.getUserName());  
19.         query.setParameter(1, user.getPassword());  
20.           
21.         User currentUser=null;  
22.           
23.         List<User> userList=query.list();  
24.         if (userList!=null && userList.size()>0) {  
25.             currentUser=userList.get(0);  
26.         }  
27.           
28.         return currentUser;  
29.     }  
30.       
31.     public void saveUser(User user) {  
32.         getSession().save(user);  
33.     }  
34.   
35.     public User findUserById(Integer id) {  
36.         String hql="from User where id=?";  
37.         Query query=getSession().createQuery(hql);  
38.         query.setParameter(0, id);  
39.         User user=(User) query.uniqueResult();  
40.         return user;  
41.     }  
42.   
43.     public User findUserPassword(String userName, String email) {  
44.         String hql="from User where userName=? and email=?";  
45.         Query query=getSession().createQuery(hql);  
46.         query.setParameter(0, userName);  
47.         query.setParameter(1, email);  
48.         User currentUser=(User) query.uniqueResult();  
49.           
50.         return currentUser;  
51.     }  
52.   
53.     public void updateUser(User user) {  
54.         getSession().update(user);  
55.     }  
56.   
57.     @SuppressWarnings("unchecked")  
58.     public List<User> findUser(List<Object> params,String hql) {  
59.         Query query=getSession().createQuery(hql);  
60.         if (params!=null && params.size()>0) {  
61.             for(int i=0;i<params.size();i++){  
62.                 query.setParameter(i, params.get(i));  
63.             }  
64.         }  
65.         return query.list();  
66.     }  
67.   
68.     public User findUserByUserName(String userName) {  
69.         String hql="from User where userName=?";  
70.         Query query=getSession().createQuery(hql);  
71.         query.setParameter(0, userName);  
72.         return (User) query.uniqueResult();  
73.     }  
74.       
75. }  

     在com.steadyjack.server.service包下建立UserService以及在com.steadyjack.server.service.impl包下建立UserServiceImpl

[java]  view plain  copy

1. package com.steadyjack.server.service;  
2.   
3. import java.util.List;  
4. import java.util.Map;  
5.   
6. import com.steadyjack.server.model.User;  
7.   
8. public interface UserService {  
9.       
10.     public void addUser(User user);  
11.       
12.     public User queryUser(User user);  
13.       
14.     public User getUserById(Integer id);  
15.       
16.     public User findUserPassword(String userName,String email);  
17.       
18.     public List<User> findUsers(Map<String, Object> map);  
19.       
20.     public void updateUser(User user);  
21.       
22.     public void saveUser(User user);  
23.       
24.     public User findUserByUserName(String userName);  
25.       
26. }  

[java]  view plain  copy

1. package com.steadyjack.server.service.impl;  
2.   
3. import java.util.LinkedList;  
4. import java.util.List;  
5. import java.util.Map;  
6.   
7. import org.springframework.beans.factory.annotation.Autowired;  
8. import org.springframework.stereotype.Service;  
9.   
10. import com.steadyjack.server.dao.UserDao;  
11. import com.steadyjack.server.model.User;  
12. import com.steadyjack.server.service.UserService;  
13.   
14. @Service  
15. public class UserServiceImpl implements UserService {  
16.       
17.     @Autowired  
18.     private UserDao userDao;  
19.       
20.     public void addUser(User user) {  
21.         userDao.saveUser(user);  
22.     }  
23.   
24.     public User queryUser(User user) {  
25.         return userDao.queryUser(user);  
26.     }  
27.   
28.     public User getUserById(Integer id) {  
29.         return userDao.findUserById(id);  
30.     }  
31.   
32.     public User findUserPassword(String userName, String email) {  
33.         return userDao.findUserPassword(userName, email);  
34.     }  
35.   
36.     public void updateUser(User user) {  
37.         userDao.updateUser(user);  
38.     }  
39.   
40.     public List<User> findUsers(Map<String, Object> map) {  
41.         StringBuffer hql=new StringBuffer("from User where 1=1 ");  
42.         List<Object> params=new LinkedList<Object>();  
43.           
44.         if (map.get("userName")!=null) {  
45.             hql.append(" and userName=? ");  
46.             params.add(map.get("userName"));  
47.         }  
48.         if (map.get("email")!=null) {  
49.             hql.append(" and email=? ");  
50.             params.add(map.get("email"));  
51.         }  
52.         if (map.get("sex")!=null) {  
53.             hql.append(" and sex=? ");  
54.             params.add(map.get("sex"));  
55.         }  
56.         if (map.get("validateOverDate")!=null) {  
57.             hql.append(" and validateOverDate=? ");  
58.             params.add(map.get("validateOverDate"));  
59.         }  
60.         if (map.get("validateSerCode")!=null) {  
61.             hql.append(" and validateSerCode=? ");  
62.             params.add(map.get("validateSerCode"));  
63.         }  
64.         if (map.get("userNameEncodes")!=null) {  
65.             hql.append(" and userNameEncodes=? ");  
66.             params.add(map.get("userNameEncodes"));  
67.         }  
68.           
69.         System.out.println(hql.toString());  
70.         return userDao.findUser(params, hql.toString());  
71.     }  
72.   
73.     public User findUserByUserName(String userName) {  
74.         return userDao.findUserByUserName(userName);  
75.     }  
76.   
77.     public void saveUser(User user) {  
78.         userDao.saveUser(user);  
79.     }  
80.       
81. }  

    最后，我们需要在com.steadyjack.web.controller包建立UserController（先介绍登录这个功能）

[java]  view plain  copy

1. package com.steadyjack.web.controller;  
2.   
3. import java.util.Date;  
4. import java.util.HashMap;  
5. import java.util.List;  
6. import java.util.Map;  
7.   
8. import javax.servlet.http.HttpServletRequest;  
9.   
10. import org.springframework.beans.factory.annotation.Autowired;  
11. import org.springframework.stereotype.Controller;  
12. import org.springframework.ui.ModelMap;  
13. import org.springframework.web.bind.annotation.PathVariable;  
14. import org.springframework.web.bind.annotation.RequestMapping;  
15. import org.springframework.web.bind.annotation.ResponseBody;  
16.   
17. import com.steadyjack.server.model.User;  
18. import com.steadyjack.server.service.UserService;  
19. import com.steadyjack.server.utils.DateUtils;  
20. import com.steadyjack.server.utils.JavaMailUtils;  
21. import com.steadyjack.server.utils.SystemUtils;  
22. import com.steadyjack.server.utils.UUIDUtils;  
23.   
24. @RequestMapping("/user")  
25. @Controller  
26. public class UserController {  
27.       
28.     @Autowired  
29.     private UserService userService;  
30.   
31.       
32.     @RequestMapping("/index/{id}")  
33.     public String index(ModelMap map,@PathVariable Integer id){  
34.         System.out.println(userService.getUserById(id));  
35.         map.put("loginUser", userService.getUserById(id));  
36.         return "user/index";  
37.     }  
38.       
39.     @ResponseBody  
40.     @RequestMapping("/login")  
41.     public Map<String, Object> userLogin(ModelMap map,HttpServletRequest request) throws Exception{  
42.         Map<String, Object> resultMap=new HashMap<String, Object>();  
43.         User user=new User();  
44.         user.setUserName(request.getParameter("userName"));  
45.         user.setPassword(request.getParameter("password"));  
46.         User currentUser=userService.queryUser(user);  
47.         if (currentUser!=null) {  
48.             resultMap.put("id", currentUser.getId());  
49.             resultMap.put("res", "yes");  
50.         }else{  
51.             resultMap.put("res", "no");  
52.         }  
53.         return resultMap;  
54.     }  
55.       
56. }  

    最后是webContent的启动jsp文件index.jsp（这里用到了jquery ajax的交互）：

[html]  view plain  copy

1. <%@ page language="java" contentType="text/html; charset=utf-8"  
2.     pageEncoding="utf-8" %>  
3. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>  
4. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
5. <html>  
6. <head>  
7. <meta http-equiv="Content-Type" content="text/html; charset=utf-8">  
8. <c:set value="${pageContext.request.contextPath }" var="ctx"></c:set>  
9. <script type="text/javascript" src="${ctx}/style/js/jquery-1.7.2.min.js"></script>  
10. <title>用户登录</title>  
11.   
12. <script type="text/javascript">  
13.       
14.     $(function(){  
15.         var serverUrl=$('#serverUrl').val();  
16.           
17.         $('#loginBtn').click(function(){  
18.             var userName = $('#userName').val();  
19.             var password = $('#password').val();  
20.             if (userName == null || password == null || trim(userName) == "" || trim(password) == "") {  
21.                 $('#errorTip').html("用户名或密码不能为空!");  
22.                 return false;  
23.             }  
24.             $('#errorTip').html("");  
25.               
26.             $.post(serverUrl+'/user/login',{  
27.                 userName:userName,  
28.                 password:password  
29.                   
30.             },function(requestData){  
31.                 if (requestData.res=='yes') {  
32.                     window.location.href=serverUrl+'/user/index/'+parseInt(requestData.id);  
33.                 } else {  
34.                     $('#errorInfo').html('*用户名或者密码错误!');                      
35.                 }  
36.                   
37.             });  
38.               
39.         });  
40.     });  
41.   
42.     function resetValue() {  
43.         $('#userName').val("");  
44.         $('#password').val("");  
45.     }  
46.   
47.     //去掉最后的空格  
48.     function trim(str) {  
49.         return str.replace(/(^\s+)|(\s+$)/g, "");  
50.     }  
51.   
52. </script>  
53.   
54. </head>  
55. <body>  
56. <input type="hidden" id="serverUrl" value="${pageContext.request.contextPath}" />  
57.     <div align="center" style="padding-top: 50px;">  
58.         <form>  
59.             <table>  
60.                 <tr>  
61.                     <td>用户名：</td>  
62.                     <td><input type="text" id="userName" name="userName" /></td>  
63.                 </tr>  
64.                 <tr>  
65.                     <td>密码：</td>  
66.                     <td><input type="password" id="password" name="password" /></td>  
67.   
68.                 </tr>  
69.                 <tr>  
70.                     <td><input type="button" value="登录" id="loginBtn"/></td>  
71.                     <td><input type="button" value="重置" /></td>  
72.                 </tr>  
73.                 <tr>  
74.                     <td></td>  
75.                     <td id="errorInfo" style="color: #ff0000;"></td>  
76.                 </tr>  
77.             </table>  
78.             <div id="errorTip"></div>  
79.         </form>  
80.         <a href="${ctx}/user/forgetPassword">忘记密码</a>  <a href="${ctx}/user/toRegister">用户注册</a>  
81.     </div>  
82. </body>  
83. </html>  

    右键项目，run 到tomcat，跑起来。如果没有报错，说明启动成功了！然后我们需要在我们的数据库录入用户的信息，测试登录功能。如下图：

     

最近学习spring框架，学习中总是磕磕绊绊的，出现这样或者那样的问题，于是就像写一篇笔记，将spring，springmvc，hibernate框架整合的过程，以及简单的实现记录下来，一来加深印象，二来一遍以后忘记好找资料（...）当然，初学者也可以借鉴一下。废话不多说，直接上干货！

平台：eclipse

1.首先看看我整个项目的结构

2.项目开始：开始配置配置文件，主要有web.xml, applicationContext.xml, springmvc这三个文件

web.xml文件如下（主要是配置spring IOC容器，springmvc的dispacherServlet, 编码的格式化：防止出现乱码，SessionFilter过滤器：防止session异常。这里主要注意的是路径问题，由于楼主的配置文件是放在src下的config包中的，所以配置的时候用classpath：包名/配置文件名.xml的形式；如果放在WebContext下，直接写文件名就行， WEB-INF下就是/WEB-INF/文件名.xml，以此类推。。）

[java]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <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" id="WebApp_ID" version="3.0">  
3.   <display-name>springmvc_1</display-name>  
4.   <welcome-file-list>  
5.     <welcome-file>index.html</welcome-file>  
6.     <welcome-file>index.htm</welcome-file>  
7.     <welcome-file>index.jsp</welcome-file>  
8.     <welcome-file>default.html</welcome-file>  
9.     <welcome-file>default.htm</welcome-file>  
10.     <welcome-file>default.jsp</welcome-file>  
11.   </welcome-file-list>  
12.     
13.   <!-- 配置spring ioc容器 -->  
14.     <context-param>  
15.         <param-name>contextConfigLocation</param-name>  
16.         <param-value>classpath:config/applicationContext.xml</param-value>  
17.     </context-param>  
18.   
19.     <!-- Bootstraps the root web application context before servlet initialization -->  
20.     <listener>  
21.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
22.     </listener>  
23.       
24.     <!-- 配置springmvc 的DispatcherServlet -->  
25.     <servlet>  
26.         <servlet-name>dispatcherServlet</servlet-name>  
27.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
28.         <init-param>  
29.             <param-name>contextConfigLocation</param-name>  
30.             <param-value>classpath:config/springmvc.xml</param-value>  
31.         </init-param>  
32.         <load-on-startup>1</load-on-startup>  
33.     </servlet>  
34.   
35.     <!-- Map all requests to the DispatcherServlet for handling -->  
36.     <servlet-mapping>  
37.         <servlet-name>dispatcherServlet</servlet-name>  
38.         <url-pattern>*.do</url-pattern>  
39.     </servlet-mapping>  
40.       
41.     <filter>  
42.         <filter-name>CharacterEncodingFilter</filter-name>  
43.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
44.         <init-param>  
45.             <param-name>encoding</param-name>  
46.             <param-value>UTF-8</param-value>  
47.         </init-param>  
48.     </filter>  
49.     <filter-mapping>  
50.         <filter-name>CharacterEncodingFilter</filter-name>  
51.         <url-pattern>/*</url-pattern>  
52.     </filter-mapping>  
53.       
54.     <filter>  
55.         <filter-name>SessionFilter</filter-name>  
56.         <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>  
57.     </filter>  
58.     <filter-mapping>  
59.         <filter-name>SessionFilter</filter-name>  
60.         <url-pattern>/*</url-pattern>  
61.     </filter-mapping>  
62. </web-app>  

springmvc.xml文件如下（主要是添加一个注解扫描，然后就是视图解析器。其中prefix表示的是跳转后的页面放置的前缀路径，楼主这里纠结了一会儿。。suffix表示的是后缀名，这个好理解。）

[java]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.     xmlns:context="http://www.springframework.org/schema/context"  
5.     xmlns:mvc="http://www.springframework.org/schema/mvc"  
6.     xmlns:tx="http://www.springframework.org/schema/tx"  
7.     xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd  
8.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
9.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd  
10.         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd">  
11.   
12.     <!-- 配置自动扫描包 -->  
13.     <context:component-scan base-package="com.shin">  
14. <!--         <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> -->  
15. <!--         <context:include-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/> -->  
16.     </context:component-scan>  
17.       
18.     <!-- 配置视图解析器 -->  
19.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
20.         <property name="prefix" value="/pages/"></property>  
21.         <property name="suffix" value=".jsp"></property>  
22.     </bean>  
23.       
24.     <mvc:default-servlet-handler/>  
25.       
26.     <mvc:annotation-driven/>  
27. </beans>  

applicationContext.xml配置如下（1.注解扫描  2.加载db.properties文件：配合数据库连接池配置实用，这里的路径与web.xml中路径同理 3.配置数据源：与dp.properties中的各个属性对应 4.配置sessionFactory:配置hibernate中的一些方言，属性等，这里将这些写在spring配置文件中，去除了hibernate.cfg.xml文件，当然也可以将添加这个文件，只需在sessionFactory中添加映射路径即可 5.配置事务管理器 ）

[java]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.     xmlns:context="http://www.springframework.org/schema/context"  
5.     xmlns:tx="http://www.springframework.org/schema/tx"  
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
7.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd  
8.         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd">  
9.   
10.   
11.     <!-- 配置自动扫描的包 -->  
12.     <context:component-scan base-package="com.shin">  
13. <!--         <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/> -->  
14. <!--         <context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/> -->  
15.     </context:component-scan>  
16.       
17.     <context:property-placeholder location="classpath:config/db.properties"/>  
18.       
19.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >  
20.         <property name="user" value="${jdbc.user}"></property>  
21.         <property name="password" value="${jdbc.password}"></property>  
22.         <property name="driverClass" value="${jdbc.driverClass}"></property>  
23.         <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>      
24.     </bean>  
25.       
26.     <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean" >  
27.         <property name="dataSource" ref="dataSource"></property>  
28.         <property name="namingStrategy">   
29.             <bean class="org.hibernate.cfg.ImprovedNamingStrategy"></bean>  
30.         </property>  
31.         <property name="packagesToScan" value="com.shin.entities"></property>  
32.           
33.         <property name="hibernateProperties">  
34.             <props>  
35.                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect </prop>  
36.                 <prop key="hibernate.show_sql">true</prop>  
37.                 <prop key="hibernate.format_sql">true</prop>  
38.                 <prop key="hibernate.hbm2ddl.auto">update</prop>  
39.                 <prop key="hibernate.temp.use_jdbc_metadata_defaults">false</prop>  
40.             </props>  
41.         </property>  
42.         <property name="mappingResources" >  
43.             <list>  
44.                 <value>com/shin/entities/User.hbm.xml</value>  
45.             </list>  
46.         </property>  
47.     </bean>  
48.       
49.     <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
50.         <property name="sessionFactory" ref="sessionFactory"></property>  
51.     </bean>  
52.       
53. </beans>  

db.properties文件：

[java]  view plain  copy

1. jdbc.user=root  
2. jdbc.password=123456  
3. jdbc.driverClass=com.mysql.jdbc.Driver  
4. jdbc.jdbcUrl=jdbc:mysql:///test  

然后开始java代码的编写：

楼主只是做了一个简单的用户添加应用，所以代码比较简单，主要是实现这个基本框架，还有很多东西需要去学习；

先来实体类 User.java  然后我用hibernate插件自动生成hbm.xml文件（当然也可以手动配置，挺简单的）

[java]  view plain  copy

1. package com.shin.entities;  
2.   
3. public class User {  
4.   
5.     private Integer id;  
6.     private String name;  
7.     private String password;  
8.   
9.     public Integer getId() {  
10.         return id;  
11.     }  
12.   
13.     public void setId(Integer id) {  
14.         this.id = id;  
15.     }  
16.   
17.     public String getName() {  
18.         return name;  
19.     }  
20.   
21.     public void setName(String name) {  
22.         this.name = name;  
23.     }  
24.   
25.     public String getPassword() {  
26.         return password;  
27.     }  
28.   
29.     public void setPassword(String password) {  
30.         this.password = password;  
31.     }  
32.   
33. }  

[java]  view plain  copy

1. <?xml version="1.0"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
4. <!-- Generated 2016-7-12 10:59:16 by Hibernate Tools 3.5.0.Final -->  
5. <hibernate-mapping>  
6.     <class name="com.shin.entities.User" table="USER">  
7.         <id name="id" type="java.lang.Integer">  
8.             <column name="ID" />  
9.             <generator class="native" />  
10.         </id>  
11.         <property name="name" type="java.lang.String">  
12.             <column name="NAME" />  
13.         </property>  
14.         <property name="password" type="java.lang.String">  
15.             <column name="PASSWORD" />  
16.         </property>  
17.     </class>  
18. </hibernate-mapping>  

然后是dao层，分别是UserDao.java接口 和 UserDaoImpl.java实现

[java]  view plain  copy

1. package com.shin.dao;  
2.   
3. import com.shin.entities.User;  
4.   
5. public interface UserDao {  
6.   
7.     public void addUser(User user);  
8. }  

[java]  view plain  copy

1. package com.shin.dao.impl;  
2.   
3. import org.hibernate.SessionFactory;  
4. import org.springframework.beans.factory.annotation.Autowired;  
5. import org.springframework.stereotype.Repository;  
6. import org.springframework.transaction.annotation.Transactional;  
7.   
8. import com.shin.dao.UserDao;  
9. import com.shin.entities.User;  
10.   
11. @Repository("userDao")  
12. public class UserDaoImpl implements UserDao {  
13.   
14.     @Autowired  
15.     private SessionFactory sessionFactory;  
16.       
17.     public SessionFactory getSessionFactory() {  
18.         return sessionFactory;  
19.     }  
20.       
21.     public void addUser(User user) {  
22.           
23.         sessionFactory.getCurrentSession().save(user);  
24.   
25.     }  
26.   
27. }  

再就是service层，分别是UserService.java接口和UserServiceImpl,java实现类

[java]  view plain  copy

1. package com.shin.service;  
2.   
3. import com.shin.entities.User;  
4.   
5. public interface UserService {  
6.   
7.     public void addUser(User user);  
8. }  

[java]  view plain  copy

1. package com.shin.service.impl;  
2.   
3. import org.springframework.beans.factory.annotation.Autowired;  
4. import org.springframework.stereotype.Service;  
5.   
6. import com.shin.dao.UserDao;  
7. import com.shin.entities.User;  
8. import com.shin.service.UserService;  
9.   
10. @Service("userService")  
11. public class UserServiceImpl implements UserService {  
12.   
13.     @Autowired  
14.     private UserDao userDao;  
15.   
16.     public void setUserDao(UserDao userDao) {  
17.         this.userDao = userDao;  
18.     }  
19.   
20.     @Override  
21.     public void addUser(User user) {  
22.         // TODO Auto-generated method stub  
23.         userDao.addUser(user);  
24.     }  
25.   
26. }  

最后是controller： UserController.java（controller是核心，页面的处理跳转都要经过他，requestMapping中的值和.jsp中的action对应，由于web.xml中springmvc拦截的是.do结尾的动作，这里在处理方法上复制以此结尾）

[java]  view plain  copy

1. package com.shin.controller;  
2.   
3. import javax.servlet.http.HttpServletRequest;  
4.   
5. import org.springframework.beans.factory.annotation.Autowired;  
6. import org.springframework.stereotype.Controller;  
7. import org.springframework.web.bind.annotation.RequestMapping;  
8.   
9. import com.shin.entities.User;  
10. import com.shin.service.UserService;  
11.   
12. @Controller  
13. @RequestMapping("/user")  
14. public class UserController {  
15.   
16.     @Autowired  
17.     private UserService userService;  
18.       
19.     @RequestMapping(value="sucess.do")  
20.     public String add(HttpServletRequest request){  
21.         String username = request.getParameter("username");  
22.         String password = request.getParameter("password");  
23.         System.out.println(username+" "+password);  
24.           
25.         User user = new User();  
26.         user.setName(username);  
27.         user.setPassword(password);  
28.           
29.         userService.addUser(user);  
30.         return "sucess";  
31.           
32.     }  
33. }  

然后是简单的jsp页面，测试用的。

add.jsp

[java]  view plain  copy

1. <%@ page language="java" contentType="text/html; charset=utf-8"  
2.     pageEncoding="utf-8"%>  
3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
4. <html>  
5. <head>  
6. <meta http-equiv="Content-Type" content="text/html; charset=utf-8">  
7. <title>Insert title here</title>  
8. </head>  
9. <body>  
10.     <h1>添加用户</h1>  
11.     <form action="user/sucess.do" method="post">  
12.         用户  <input type="text" name="username"/><br/>  
13.         密码  <input type="text" name="password"/><br/>  
14.         <input type="submit" value="添加">  
15.     </form>  
16.       
17. </body>  
18. </html>  

sucess.jsp

[java]  view plain  copy

1. <%@ page language="java" contentType="text/html; charset=utf-8"  
2.     pageEncoding="utf-8"%>  
3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
4. <html>  
5. <head>  
6. <meta http-equiv="Content-Type" content="text/html; charset=utf-8">  
7. <title>Insert title here</title>  
8. </head>  
9. <body>  
10.     添加成功！  
11. </body>  
12. </html>  

测试：