学习SPRING MVC + SPRING + HIBERNATE 逐步搭建总结

最新推荐文章于 2024-04-17 04:21:28 发布

很倔也很天真

最新推荐文章于 2024-04-17 04:21:28 发布

阅读量558

点赞数

分类专栏：经验记事本文章标签： SPRINGMVC SPRING+HIBERNATE SPRINGMVC+HIBERNATE SPRING MVC HIBERNATE 整合

本文链接：https://blog.csdn.net/wang845252276/article/details/81013208

版权

经验同时被 2 个专栏收录

23 篇文章 0 订阅

订阅专栏

记事本

9 篇文章 0 订阅

订阅专栏

唠叨

个人不怎么上进,对新鲜事物不感兴趣,主要是麻烦。。。但也需要会几样东西。
一直用myeclipse，最近才用了一下IDEA，相比IDEA支持最新版本，没有先在IDEA上练习SPRING MVC，用MYECLIPSE成功后再去试。
使用了MAVEN环境方便看源码和随意加包,也是刚上手。

版本

myeclipse 2014

这里写图片描述

tomcat 7(配置了编码格式)/8
springMVC Version 4.3.18.RELEASE
spring Version 4.4.18.release
servlet Version 3.1.0
jstl Version 1.2
taglibs Version 1.1.2
jackson Version 2.9.6
commonsFileupload Version 1.3.3
commonsIo Version 2.6
log4j Version 1.2.17
json Version 2.4
hibernate Version 4.3.11.Final
c3p0 Version 0.9.5.2
slf4j Version 1.7.25
mysql Version 5.1.46

部分功能并不是必须只是个人习惯
比如: json 用的是SSH中的json包应该是老旧的东西

注:并不是不想用最新版,这些框架有JDK版本限制,而Myeclipse也有JDK版本限制

创建MAVEN 项目

1 new -> project -> Maven project
这里写图片描述
2 使用默认workspace

至于create a simple project (skip archetype selection) 如果不打算细究就不必理会，不勾选时会使用模版也就是自带配置和目录结构,勾上之后就是基本的Maven结构零配置(粘贴首选哈哈)
3 设置项目参数
这里写图片描述
4 点击 finish 结果如图

5 添加基础配置

<build>
    <plugins>
        <!-- 修改默认JDK版本,不然会是JDK1.5 -->
        <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.7.0</version>
            <configuration>
                <!-- jdk 版本 -->
                <source>1.7</source>
                <!-- jre 版本 -->
                <target>1.7</target>
            </configuration>
        </plugin>
        <!-- 打包用的插件 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-war-plugin</artifactId>
            <version>3.2.2</version>
        </plugin>
    </plugins>
</build>

maven-compiler-plugin 用于指定jdk版本，不然默认是jdk1.5
maven-war-plugin 用于打包成 .war,如果要忽略web.xml不存在时报错就加这个配置.感觉不太用的到
详细使用参考官方文档:Apache Maven WAR Plugin

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>3.2.2</version>
    <configuration>
        <!-- 忽略web.xml不存在 -->
        <failOnMissingWebXml>false</failOnMissingWebXml>
    </configuration>
</plugin>

最好配置一个web.xml 目录格式已固定,注意是folder不是包

|--src
    |--main
        |-- webapp
            |-- WEB-INF
                    |-- web.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"
    id="WebApp_ID" version="3.0">
<!-- 配置列表 -->

</web-app>

此时需要以下操作
右键项目->Maven4MyEclipse->update project 将插件应用
再右键项目->run as->Maven install 运行（产生打包文件.war）产生如下结果说明成功,如果有失败检查是否有未下载成功的包

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2.014 s
[INFO] Finished at: 2018-07-12T15:01:53+08:00
[INFO] ------------------------------------------------------------------------

添加到Myeclipse Tomcat中运行

此时的项目能够打包（可在target目录下找到），放到Tomcat webapps中再启动Tomcat运行。
为了方便测试，转换为 web框架直接myeclipse中发布运行
右键项目属性
这里写图片描述

转换后会生成几个目录和文件，不用他们直接删掉 WebRoot 目录

|-- WebRoot
    |--WEB-INF
    |--META-INF
    index.jsp

还要清理遗留配置
右键项目属性
这里写图片描述
移除/WebRoot 添加 folder /src/main/webapp 发布到 / 根目录

新建一个index.html 到 webapp 目录下，添加项目到Tomcat 启动，可以打开页面了。

Spring MVC 支持

根基有了添加柱子，修改 pom.xml 添加dependencies节点，和build节点同级。
在此之前添加一个配置（可选）

<!-- 自定义属性,可用${标签名}使用 -->
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <springMVCVersion>4.3.18.RELEASE</springMVCVersion>
</properties>

在dependency中version标签中用${springMVCVersion}来代替4.3.18.RELEASE或者直接写版本号: <version>4.3.18.RELEASE</version> 前者自有好处

spring-webmvc 依赖

<dependencies>
    <!-- SPRING MVC 配置 -->
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
    <!-- JDK 8+ for Spring Framework 5.x JDK 6+ for Spring Framework 4.x JDK 5+ for Spring Framework 3.x -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${springMVCVersion}</version>
    </dependency>
</dependencies>

SPRING-WEBMVC 包含Spring框架一些常用包如下:

spring-webmvc.jar
spring-aop.jar
spring-beans.jar
spring-context.jar
spring-core.jar
spring-web.jar
spring-expression.jar
commons-logging.jar

SERVLET 依赖

添加到属性标签 <properties></properties>

<servletVersion>3.1.0</servletVersion>

添加到 <dependencies></dependencies>

<!-- SERVLET 配置 -->
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>${servletVersion}</version>
    <scope>provided</scope>
</dependency>

新增，此包和 servlet-api.jar 功能类似，且tomcat自带servlet-api.jar会冲突所以用下面这个测试不会冲突
scope 标签代表此包的使用范围，发布、测试、运行等，此处写不写都无碍。
- javax.servlet-api.jar

修改web.xml添加分发器(DispatcherServlet) , 还有一些配置

<display-name>testSpringMVC</display-name>
<welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
</welcome-file-list>
<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springmvc-servlet.xml</param-value>
    </init-param>
    <!--配置容器在启动的时候就加载这个servlet并实例化 -->
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>
<!-- Servlet 请求编码 -->
<filter>
    <filter-name>characterEncoding</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>characterEncoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

springmvc-servlet.xml 配置
在 src/main/resources 中新建配置文件，此配置文件名与上面 web.xml 中 servlet-name 标签名的值有关
“servlet-name” + “-servlet.xml” 组成，不过可像上面那样修改。

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

    <!-- 扫描包和子包 -->
    <!-- 只扫描Controller,不扫描Service -->
    <context:component-scan base-package="com.test.demo">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>
    </context:component-scan>
    <!-- 不处理静态资源 html,js,css,img -->
    <mvc:default-servlet-handler />

    <!-- 使用注解 -->
    <mvc:annotation-driven />

    <!-- 用于action返回查找 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
        id="internalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 后缀 -->
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

bean internalResourceViewResolver 用于映射 WEB-INF 目录下的jsp目录下的 .jsp 文件能被action找到,不用带后缀名，需不需要看需求。

<context:component-scan base-package="com.test.demo">

配置扫描注解包。

<context:component-scan base-package="com.test.demo">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>
</context:component-scan>

第一个为包含（spring mvc 需要 @Controller）,第二个为不包含（spring 需要 @Service 等），因为与 Spring 冲突所以必须。
测试下，在src/main/java 下新建包 com.test.demo.controller com.test.demo.entry
先在com.test.demo.entry中新建类 User.java

package com.test.demo.entry;

import java.sql.Timestamp;

public class User {
    private Integer id;
    private String username;
    private String password;
    private Timestamp birthday;
    private Boolean sex;

    public User() { }

    public User(Integer id, String username, String password,
            Timestamp birthday, Boolean sex) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.birthday = birthday;
        this.sex = sex;
    }

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

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

    public Timestamp getBirthday() {
        return birthday;
    }

    public void setBirthday(Timestamp birthday) {
        this.birthday = birthday;
    }

    public Boolean getSex() {
        return sex;
    }

    public void setSex(Boolean sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", password="
                + password + ", birthday=" + birthday + ", sex=" + sex + "]";
    }

}

在再 com.test.demo.controller 包下建立 Test.java 测试类

package com.test.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;

import com.test.demo.entry.User;

@Controller
@RequestMapping("/")
public class Test {
    @RequestMapping("user")
    public String test(){
        out("跳转 testuser.jsp");
        return "testuser";
    }
    @RequestMapping("test1")
    public String testNoParam(){
        out("测试 1");
        return "showuser";
    }

    @RequestMapping("test2")
    public String testStringParam(String username , String password , ModelMap model){
        out("测试 2");
        out(username + "," + password);
        User user = new User(null, username, password, null, null);
        model.addAttribute("id", user.getId());
        model.addAttribute("username", user.getUsername());
        model.addAttribute("password", user.getPassword());
        model.addAttribute("birthday", user.getBirthday());
        model.addAttribute("sex",user.getSex());
        return "showuser";
    }

    @RequestMapping("test3")
    public String testObjectParam(User user , ModelMap model){
        out("测试 3");
        out(user);
        model.addAttribute("id", user.getId());
        model.addAttribute("username", user.getUsername());
        model.addAttribute("password", user.getPassword());
        model.addAttribute("birthday", user.getBirthday());
        model.addAttribute("sex",user.getSex());
        return "showuser";
    }


    //测试用
    void out(Object obj){
        String ch = " ■■■■■■ ";
        System.out.println(ch+obj+ch);
    }
}

其中 model 可用request向jsp传值 , “showuser” 为一个名为 “WEB-INF/jsp/showuser.jsp”的文件,因为配置了internalResourceViewResolver所以可以找到。
在 WEB-INF 目录下建目录 jsb , 写两个jsp文件
testuser.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
    String name = request.getContextPath();
    String basename = request.getScheme() + "://"
            + request.getServerName() + ":" + request.getServerPort()
            + name + "/";
    pageContext.setAttribute("basename", basename);
%>
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<base href="${basename}">
<meta charset="UTF-8">
<title>HTML5 JSP</title>
</head>
<body>
<h1>测试无参</h1>
<form action="test1" method="post">
<input type="submit" value="提交表单" />
</form>
<h1>测试对象传参</h1>
<form action="test2" method="post">
    <table>
        <tr>
            <td><label>编号：</label></td>
            <td><input name="id" /></td>
        </tr>
        <tr>
            <td><label>用户名：</label></td>
            <td><input name="username" /></td>
        </tr>
        <tr>
            <td><label>密码：</label></td>
            <td><input name="password" /></td>
        </tr>
        <tr>
            <td><label>生日：</label></td>
            <td><input name="birthday" /></td>
        </tr>
        <tr>
            <td><label>性别：</label></td>
            <td><input type="radio" name="sex" value="true" /> 男 <input
                type="radio" name="sex" value="false" /> 女</td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交表单" /></td>
        </tr>
    </table>
</form>
<h1>测试参数转对象</h1>
<form action="test3" method="post">
    <table>
        <tr>
            <td><label>编号：</label></td>
            <td><input name="id" /></td>
        </tr>
        <tr>
            <td><label>用户名：</label></td>
            <td><input name="username" /></td>
        </tr>
        <tr>
            <td><label>密码：</label></td>
            <td><input name="password" /></td>
        </tr>
        <tr>
            <td><label>生日：</label></td>
            <td><input name="birthday" /></td>
        </tr>
        <tr>
            <td><label>性别：</label></td>
            <td><input type="radio" name="sex" value="true" /> 男 <input
                type="radio" name="sex" value="false" /> 女</td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交表单" /></td>
        </tr>
    </table>
</form>
</body>
</html>

showuser.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
    String name = request.getContextPath();
    String basename = request.getScheme() + "://"
            + request.getServerName() + ":" + request.getServerPort()
            + name + "/";
    pageContext.setAttribute("basename", basename);
%>
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<base href="${basename}">
<meta charset="UTF-8">
<title>HTML5 JSP</title>
</head>
<body>
    <h2>提交的学生信息如下 -</h2>
    <table>
        <tr>
            <td>编号：</td>
            <td>${id}</td>
        </tr>
        <tr>
            <td>名称：</td>
            <td>${username}</td>
        </tr>
        <tr>
            <td>密码：</td>
            <td>${password}</td>
        </tr>
        <tr>
            <td>出生日期：</td>
            <td>${birthday}</td>
        </tr>
        <tr>
            <td>性别：</td>
            <td>${sex}</td>
        </tr>
    </table>
</body>
</html>

此时还不能运行,lib目录为空 , 需配置将包部署到 WEB-INF/lib 中
这里写图片描述
点击下一步后可选择Maven Dependencies finish确定。
第一次启动先执行过以下操作 (第二个步骤,暂不明白原因)
如果之后失败,运行以下操作

执行过 Maven4MyEclipse -> Update Project
执行过 Run as -> Maven install
将Maven包部署到 lib(如上图操作)
执行过 Tomcat -> Redeploy/Reload application

其中第1步会清除lib配置,需要重新执行第3步
每次添加依赖重新发布到Tomcat 不然可能会有包没更新过去

启动服务器,无异常算成功
这里写图片描述

如果404 检查扫描包路径是否正确。

JACKSON 依赖

用于json数据转换，添加 pom.xml 配置，针对日期型数据默认最好用毫秒数作为参数传参。

<properties>
    <jacksonVersion>2.9.6</jacksonVersion>
</properties>
<dependencies>
    <!-- Controller 转换 JSON 配置 -->
    <!-- jackson-core 与 jackson-databind 用于servlet 对象转json -->
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>${jacksonVersion}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>${jacksonVersion}</version>
    </dependency>
</dependenciefs>

新增包如下：

jackson-core.jar
jackson-databind.jar
jackson-annotations.jar

测试修改Test.java

@RequestMapping("test4")
public String testJsonParam(@RequestBody User user , ModelMap model){
    out("测试 4");
    out(user);
    model.addAttribute("id", user.getId());
    model.addAttribute("username", user.getUsername());
    model.addAttribute("password", user.getPassword());
    model.addAttribute("birthday", user.getBirthday());
    model.addAttribute("sex",user.getSex());
    return "showuser";
}

@RequestMapping("test5")
@ResponseBody
public User testResponseJson(User user){
    out("测试 5");
    out(user);
    return user;
}

使用测试工具 Postman 模拟提交数据
test4
这里写图片描述
test5

4和5的区别在于 , test4 传入String 转 Json 再转 User, 使用了 Jackson 转换格式有要求，这里使用了毫秒数转换
test5 是传入String 转 User, 直接转换的TimeStamp 不能用毫秒数 , 输出由 Timestamp 转 JSON 转成了毫秒数，可以配置mvc配置文件修改Jackson转换格式和普通转换规则。

在未做修改前 JSON与TIMESTAMP转换有以下特点

json 数据传递日期需要用毫秒数(使用@RequestBody接收)，不支持日期时间格式
表单数据传递需要用日期格式如 yyyy-MM-dd HH:mm:ss ，不支持毫秒数
Timestamp转JSON会输出毫秒数(使用@ResponseBody输出)

全局表单数据格式配置，如配置日期格式。
在com.test.demo.component包下创建转换器类DateConverter

package com.test.demo.component;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;

import org.springframework.core.convert.converter.Converter;
import org.springframework.stereotype.Component;
@Component("dateConvert")
public class DateConverter implements Converter<String, Timestamp> {

    @Override
    public Timestamp convert(String stringDate) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        Timestamp d = null;
        try {
            if(stringDate.indexOf("-") == -1){
                return new Timestamp(Long.parseLong(stringDate));
            }
            d = new Timestamp(sdf.parse(stringDate).getTime());
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return d;
    }
}

并在springmvc-servlet.xml中添加配置

<bean id="conversionService"
    class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
    <property name="converters">
        <list>
            <bean class="com.test.demo.component.DateConverter" />
        </list>
    </property>
</bean>
<mvc:annotation-driven conversion-service="conversionService" />

表单提交的数据会经过DataConverter

表单数据传递可以使用日期时间格式”2018-7-13 09:58:40” 或毫秒数，得益于return new Timestamp(Long.parseLong(stringDate));这一句

也可单独制定实体类，在实体类中添加注解

@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")  
@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")  
public Timestamp getBirthday() {
    return birthday;
}

注解作用

@DateTimeFormat 使当前字段表单日期时间数据格式转换必须按此格式
@JsonFormat 使当前字段其字符串转JSON时按照指定格式来转换,现在前端日期格式需要按照pattern指示格式传值，已不能用毫秒数传值
可配置全局json日期格式

package com.test.demo.component;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.TimeZone;

import org.springframework.stereotype.Component;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
@Component("customrObjectMapper")
public class CustomerObjectMapper extends ObjectMapper {
    private static final long serialVersionUID = -957470952587462408L;

    /**
     * 设置全局json日期格式,+8时区
     */
    public CustomerObjectMapper(){
        super();
        //设置null转换""
        getSerializerProvider().setNullValueSerializer(new NullSerializer());
        //设置日期转换yyyy-MM-dd HH:mm:ss
        setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        setTimeZone(TimeZone.getTimeZone("GMT+8"));
    }

    //null的JSON序列,对象为null值输出json时为""而不是null
    private class NullSerializer extends JsonSerializer<Object> {
        public void serialize(Object value, JsonGenerator jgen,
                SerializerProvider provider) throws IOException,
                JsonProcessingException {
            jgen.writeString("");
        }
    }
}

springmvc-servlet.xml配置文件:

    <!-- 使用注解 -->
    <mvc:annotation-driven />
    <!-- 参数 转换器 -->
    <mvc:annotation-driven conversion-service="conversionService" />
    <!-- Jackson 转换器 -->  
    <mvc:annotation-driven conversion-service="conversionService">
        <mvc:message-converters>  
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">  
                <property name="objectMapper" ref="customrObjectMapper" />  
            </bean>
        </mvc:message-converters>  
    </mvc:annotation-driven>

此处三个 mvc:annotation-driven ,会按照顺序被替换,也即是只有最后一个会生效。
注解使用第一个，只是用参数转换器用第二个，使用全部转换器用第三个，或者第三个去掉conversion-service="conversionService" 只是用json转换器。

总的来说就是以下几点：
- 表单以日期格式传值，可什么都不配置
- 表单以毫秒数传值，或其他日期格式，添加DateConverter
- 表单以其他日期格式，可单独使用@DateTimeFormat配置
- 以JSON 毫秒数日期数据传值，可什么都不用配置
- 以JSON 日期数据格式传值，可单独添加注解 @JsonFormat或配置第三个objectMapper

FileUpload 文件上传依赖

添加版本信息，这里把 IO 依赖加上，可以使用文件工具，可不配置。

<properties>
    <commonsFileuploadVersion>1.3.3</commonsFileuploadVersion>
    <commonsIoVersion>2.6</commonsIoVersion>
</properties>

依赖

<dependencies>
    <!-- FILEUPLOAD 文件上传 -->
    <!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
    <dependency>
        <groupId>commons-fileupload</groupId>
        <artifactId>commons-fileupload</artifactId>
        <version>${commonsFileuploadVersion}</version>
    </dependency>
    <!-- FILEUTILS 文件工具配置 -->
    <!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>${commonsIoVersion}</version>
    </dependency>
</dependencies>

新增包如下：

commons-fileupload.jar
commons-io.jar

SPRINGMVC-SERVLET.XML 添加上传设置配置

<bean id="multipartResolver"
    class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!--defaultEncoding：请求的编码格式必须和用户JSP的编码一致，以便正确读取表单中的内容。 uploadTempDir:文件上传过程中的临时目录，上传完成后，临时文件会自动删除 
        maxUploadSize:设置文件上传大小上限（单位为字节） -->
    <property name="defaultEncoding" value="UTF-8" />
    <property name="maxUploadSize" value="102400000" />
    <!-- uploadTempDir可以不做设置，有默认的路径，上传完毕会临时文件会自动被清理掉 -->
    <!-- maxInMemorySize：设置在文件上传时允许写到内存中的最大值，以字节为单位计算，默认是10240。 -->
    <!-- 设置是否在文件或参数访问时懒散地解决多部分请求。默认值是“false” -->
    <property name="resolveLazily" value="true" />
</bean>

注意重新更新项目文件到Tomcat

在Test.java添加测试方法

    public static String WEB_ROOT_FOLDER_PATH;
    public static String CLASSES_FOLDER_PATH;
    static{
        try {
            //E:\程序软件\apache-tomcat-8.0.23\webapps\testSSH\WEB-INF\classes\ 
            CLASSES_FOLDER_PATH = Test.class.getClassLoader().getResource("").toURI().getPath().substring(1).replaceAll("/", "\\\\");
            //E:\程序软件\apache-tomcat-8.0.23\webapps\testSSH\ 
            WEB_ROOT_FOLDER_PATH = CLASSES_FOLDER_PATH.split("WEB-INF")[0];
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
    }
    @RequestMapping("test6")
    public String testFileUpload(User user , MultipartFile file , ModelMap model){
        if(file!=null && !file.isEmpty()){
            out(file.getName());
            out(file.getOriginalFilename());
            out(file.getContentType());
            out(file.getSize());
            model.addAttribute("id", user.getId());
            model.addAttribute("username", user.getUsername());
            model.addAttribute("password", user.getPassword());
            model.addAttribute("birthday", user.getBirthday());
            model.addAttribute("sex",user.getSex());
            try {
                String classesUploadFolder = "img/upload/";
                File up = new File(CLASSES_FOLDER_PATH + classesUploadFolder + file.getOriginalFilename());
                //只能用一次,相当于剪切
                file.transferTo(up);
                String rootUploadFolder = "upload/";
                File copy = new File(WEB_ROOT_FOLDER_PATH + rootUploadFolder + file.getOriginalFilename());
                FileUtils.copyFile(up, copy);
                out(up.getAbsolutePath());
                out(copy.getAbsolutePath());
                //classes目录
                model.addAttribute("userhead1", classesUploadFolder + file.getOriginalFilename());
                //根目录
                model.addAttribute("userhead2", rootUploadFolder + file.getOriginalFilename());
            } catch (IllegalStateException | IOException e) {
                e.printStackTrace();
            }
        }
        return "showuser";
    }

创建目录
在src/main/resource下创建img,在img里面创建upload文件夹，另在webapp目录下创建upload供根目录测试。
可先看下运行结果

 ■■■■■■ file ■■■■■■ 
 ■■■■■■ qinchu.jpg ■■■■■■ 
 ■■■■■■ image/jpeg ■■■■■■ 
 ■■■■■■ 16671 ■■■■■■ 
 ■■■■■■ E:\程序软件\apache-tomcat-8.0.23\webapps\testSSH\WEB-INF\classes\img\upload\qinchu.jpg ■■■■■■ 
 ■■■■■■ E:\程序软件\apache-tomcat-8.0.23\webapps\testSSH\upload\qinchu.jpg ■■■■■■

但现在不能直接访问WEB-INF 下的图片 ，所以需要配置映射（顺便把js，css也加上了）
修改springmvc-servlet.xml 添加配置，必须在最前。

<!--这里是对静态资源的映射,必须放到最前-->
<mvc:resources mapping="/js/**" location="/WEB-INF/classes/js/" />
<mvc:resources mapping="/css/**" location="/WEB-INF/classes/css/" />
<mvc:resources mapping="/img/**" location="/WEB-INF/classes/img/" />

这样就能直接用 /img/upload/xx.jpg 访问 /WEB-INF/classes/img/upload/xx.jpg 了。
修改showuser.jsp 追加td标签

<tr>
    <td>头像1:</td>
    <td>
        <img height="100" src="${userhead1}"/>
    </td>
</tr>
<tr>
    <td>头像2:</td>
    <td>
        <img height="100" src="${userhead2}"/>
    </td>
</tr>

运行结果如图：
这里写图片描述

添加HIBERNATE 框架

先添加 hibernate ，mysql，c3p0 依赖但不配置。

<properties>
    <hibernateVersion>4.3.11.Final</hibernateVersion>
    <c3p0Version>0.9.5.2</c3p0Version>
    <slf4jVersion>1.7.25</slf4jVersion>
    <mysqlVersion>5.1.46</mysqlVersion>
</properties>

依赖

<!-- HIBERNATE 5 JDK需求1.8 -->
<!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
<!-- 若hibernate版本大于3.5 则包含 hibernate-annotations,否则会冲突 -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>${hibernateVersion}</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>${slf4jVersion}</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-nop -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-nop</artifactId>
    <version>${slf4jVersion}</version>
    <scope>test</scope>
</dependency>
<!-- 数据库连接池 -->
<!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
<dependency>
    <groupId>com.mchange</groupId>
    <artifactId>c3p0</artifactId>
    <version>${c3p0Version}</version>
</dependency>
<!-- MYSQL 支持 -->
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<!-- MYSQL-CONNECTOR JDK1.7最高仅支持5.1.46 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>${mysqlVersion}</version>
</dependency>

Hibernate 框架包如下：

hibernate-core.jar
hibernate-commons-annotations.jar
hibernate-jpa.jar
jboss-logging.jar
jboss-logging-annotations.jar
jboss-transaction-api.jar
dom4j.jar
xml-apis.jar
antlr.jar
jandex.jar
javassist.jar

slf4j 包如下：

slf4j-api.jar
slf4j-nop.jar

mysql 包

mysql-connector-java.jar

c3p0 包

c3p0.jar
mchange-commons-java.jar

SPRING HIBERNATE 框架整合

由于springmvc已包含了Spring框架需要的包，就不用加依赖，添加一个applicationContext.xml 即可。
spring与hibernate整合需要依赖故配置：
spring 与 springmvc版本一致。

<!-- SPRING HIBERNATE 整合配置 -->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-orm -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>${springMVCVersion}</version>
</dependency>

新增包如下：

spring-orm.jar
spring-jdbc.jar
spring-tx.jar

配置applicationContext.xml , 在src/main/resources下面新建配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:tx="http://www.springframework.org/schema/tx" 
    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
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx.xsd 
        ">
    <!--********************************************配置Spring*************************************** -->
    <!-- 自动扫描 -->
    <context:component-scan base-package="com.test.demo">
        <!-- 扫描时跳过 @Controller 注解的JAVA类（控制器） -->
        <context:exclude-filter type="annotation"
            expression="org.springframework.stereotype.Controller" />
    </context:component-scan>
    <!--********************************************配置hibernate******************************************** -->
    <!--读取配置文件(jdbcConfig.properties) -->
    <context:property-placeholder location="classpath:/jdbcConfig.properties" />
    <!--配置数据源 -->
    <!-- destroy-method="close" 在已确定会关闭的情况下可不使用,否则DEBUG会出现异常信息 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <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.test.demo.entry" />
        <!--自动扫描实体 -->
<!--        <property name="packagesToScan">
            <list>
                <value>com.test.demo.entry</value>
            </list>
        </property> -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.autoReconnect">true</prop>
                <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>

    <!-- aop ? -->
<!--    <tx:advice id="txAdvice" transaction-manager="transactionManager">  
        <tx:attributes>  
            <tx:method name="add*" propagation="REQUIRED"/>  
            <tx:method name="del*" propagation="REQUIRED"/>  
            <tx:method name="modify*" propagation="REQUIRED"/>  
            <tx:method name="*" propagation="REQUIRED" read-only="true"/>  
        </tx:attributes>  
    </tx:advice> -->
    <!-- 用注解来实现事务管理 -->
    <tx:annotation-driven transaction-manager="transactionManager" />
</beans>

同目录的jdbc配置文件 jdbcConfig.properties 如下：

#数据库连接信息
jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/
jdbc.username = root
jdbc.password = 123456
#hibernate 配置
hibernate.dialect = org.hibernate.dialect.MySQLDialect
hibernate.show_sql = true
hibernate.format_sql = true
hibernate.hbm2ddl.auto =update

被注释的是备用方案
在web.xml中添加Spring的监听器

<!-- Spring 支持 -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:applicationContext.xml</param-value>
</context-param>

数据库操作

创建数据表

CREATE TABLE `user` (
  `Id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(25) DEFAULT NULL,
  `password` varchar(25) DEFAULT NULL,
  `sex` bit(1) DEFAULT b'1',
  `birthday` datetime DEFAULT NULL,
  PRIMARY KEY (`Id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;

给实体类添加注解
将注解都移到字段处。

package com.test.demo.entry;

import java.sql.Timestamp;

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

import org.springframework.format.annotation.DateTimeFormat;

import com.fasterxml.jackson.annotation.JsonFormat;
@Entity
@Table(name = "user" , catalog = "test")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    @Column
    private String username;
    @Column
    private String password;
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")  
    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
    @Column
    private Timestamp birthday;
    @Column
    private Boolean sex;

    public User() { }

    public User(Integer id, String username, String password,
            Timestamp birthday, Boolean sex) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.birthday = birthday;
        this.sex = sex;
    }

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

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

    public Timestamp getBirthday() {
        return birthday;
    }

    public void setBirthday(Timestamp birthday) {
        this.birthday = birthday;
    }

    public Boolean getSex() {
        return sex;
    }

    public void setSex(Boolean sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", password="
                + password + ", birthday=" + birthday + ", sex=" + sex + "]";
    }

}

DAO层
在com.test.demo.dao包种添加 DAO 接口 , com.test.demo.dao.impl 包添加DAO接口实现类
BaseDAO.java

package com.test.demo.dao;

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

import org.hibernate.criterion.Criterion;

/**
 * @Title: BaseDAO.java
 * @Package com.information.dao (基础数据操作接口) author Mr.Wang date 2016年6月13日
 *          上午10:21:37
 * @version V1.0
 */
public interface BaseDAO<T> {

    /**
     * TODO 使实体对象从session中剥离
     * 
     * @param o
     *            实体对象 author Mr.Wang date 2017年4月20日
     */
    public void evict(Object o);

    /**
     * 添加 TODO (保存所设类型的对象,序列化用于生成主键)
     * 
     * @param o
     *            要保存的实体对象可以没有ID
     * @return Serializable 返回生成的主键
     */
    public Serializable save(T o);

    /**
     * 删除用户 TODO (删除一个记录)
     * 
     * @param o
     *            要删除的对象,必须有主键ID,并且此ID必须存在于数据库表
     */
    public void delete(T o);

    /**
     * TODO 更新一个对象,成功后更新session缓存
     * 
     * @param o
     *            修改的对象 请确保 o对应的记录存在于数据库表,否者抛出异常 所以必须验证有效性
     */
    public void update(T o);

    /**
     * TODO 添加或修改对象
     * 
     * @param o
     *            要修该的对象请确保 o对应的记录存在于数据库表,否者抛出异常 所以必须验证有效性
     */
    public void saveOrUpdate(T o);

    /**
     * TODO 查询 (以完整的 hql语句查询)
     * 
     * @param hql
     *            from 类名 where field=n
     * @return 查询结果必定返回一个List对象即使size()为0
     * @throws 如果语句不正确抛出异常
     */
    public List<T> find(String hql);

    /**
     * TODO 查询集合(带分页)
     * 
     * @param hql
     *            ,from 类名 where field = ? and field = ?
     * @param page
     *            查询第几页
     * @param rows
     *            每页显示几条记录
     * @return List<T> 返回结果集或 size == 0 的 list
     */
    public List<T> find(String hql, Integer page, Integer rows);

    /**
     * TODO 查询集合(使用Criterion方式查询)
     * 
     * @param c
     *            类.class
     * @param criterions
     *            规则 Property.eq() Restrictions.eq()...条件数组例如 Criterion[] cs =
     *            new Criterion[1]; cs[0] = Restrictions.like("username",
     *            "test%"); 或者 new
     *            Criterion[]{Restrictions.like("username","test%"
     *            ),Restrictions.eq("userId",12),..}
     * @return List<T> 返回结果集或 size == 0 的 list
     */
    public List<T> find(Class<T> c, Criterion[] criterions);

    /**
     * TODO 查询集合
     * 
     * @param hql
     *            ,from 类名 where field = ? and field = ?
     * @param param
     *            ,数组代表按顺序代表hql中的?
     * @return 泛型列表
     */
    public List<T> find(String hql, Object[] param);

    /**
     * TODO 查询集合
     * 
     * @param hql
     *            ,from 类名 where field = ? and field = ?
     * @param param
     *            ,list集合 按顺序代表hql中的?
     * @return 泛型列表
     */
    public List<T> find(String hql, List<Object> param);

    /**
     * TODO 查询集合
     * 
     * @param hql
     *            ,from 类名 where field = :param1 and field = :param2
     * @param param
     *            ,map键值对集合 按名称代表hql中的:param*
     * @return 泛型列表
     */
    public List<T> find(String hql, Map<String, Object> param);

    /**
     * TODO 查询集合(带分页)
     * 
     * @param hql
     *            ,from 类名 where field = ? and field = ?
     * @param param
     *            ,数组参数顺序对应?位置
     * @param page
     *            查询第几页
     * @param rows
     *            每页显示几条记录
     * @return 查询结果
     */
    public List<T> find(String hql, Object[] param, Integer page, Integer rows);

    /**
     * TODO 查询集合(带分页)
     * 
     * @param hql
     *            ,from 类名 where field = ? and field = ?
     * @param param
     *            ,集合参数顺序对应?位置
     * @param page
     *            查询第几页
     * @param rows
     *            每页显示几条记录
     * @return 查询结果
     */
    public List<T> find(String hql, List<Object> param, Integer page,
            Integer rows);

    /**
     * TODO 查询集合(带分页)
     * 
     * @param hql
     *            ,from 类名 where field = ? and field = ?
     * @param param
     *            ,Map集合参数顺序对应?位置
     * @param page
     *            查询第几页
     * @param rows
     *            每页显示几条记录
     * @return 查询结果
     */
    public List<T> find(String hql, Map<String, Object> param, Integer page,
            Integer rows);

    /**
     * TODO 获得一个对象
     * 
     * @param c
     *            查询类的class 对象类型
     * @param id
     *            主键,联合主键则是一个完整对象
     * @return Object 或 null
     */
    public T get(Class<T> c, Serializable id);

    /**
     * TODO 以hql语句查询,自带条件,只能获得一个记录
     * 
     * @param hql
     *            查询语句
     * @return T 想要的结果或null author Mr.Wang date 2016年8月2日
     */
    public T get(String hql);

    /**
     * TODO 获得一个对象 同find() 唯一不同只是返回一个元素
     * 
     * @param hql
     *            查询语句 from 类名 where field = ? and field = ?
     * @param param
     *            对象数组
     * @return 想要的结果或null
     */
    public T get(String hql, Object[] param);

    /**
     * TODO 获得一个对象
     * 
     * @param hql
     *            ,from 类名 where field = ? and field = ?
     * @param param
     *            ,list集合 按顺序代表hql中的?
     * @return 想要的结果或null
     */
    public T get(String hql, List<Object> param);

    /**
     * TODO 获得一个对象
     * 
     * @param hql
     *            ,from 类名 别名 where 别名.field = :参数名
     * @param param
     *            map<参数名,参数对应值>
     * @return 想要的结果或null
     */
    public T get(String hql, Map<String, Object> param);

    /**
     * TODO 获得一个对象
     * 
     * @param c
     *            查询类的class 对象类型
     * @param id
     *            主键,联合主键则是一个完整对象
     * @return T 如果load的实体没有在事务中使用过,则会在事务外使用时抛出异常
     */
    public T load(Class<T> c, Serializable id);

    /**
     * TODO 统计数据 例如"select count(*) from User u where u.password = 'test12'"
     * 
     * @param hql
     *            必须为一个统计语句
     * @throws 内部为uniqueResult
     *             返回多个结果将抛出异常,结果不为数值型也是异常
     * @return 统计条件范围内记录数
     */
    public Long count(String hql);

    /**
     * TODO 统计数据,带条件 select count(*) from 类 类别名 where 类别名.field = ?
     * 
     * @param hql
     *            统计语句
     * @param param
     *            条件值,顺序对应 hql 中的 ?
     * @return 符合条件的记录数
     */
    public Long count(String hql, Object[] param);

    /**
     * TODO 统计数据,带条件 select count(*) from 类 类别名 where 类别名.field = ?
     * 
     * @param hql
     *            统计语句
     * @param param
     *            条件值,顺序对应 hql 中的 ?
     * @return 符合条件的记录数
     */
    public Long count(String hql, List<Object> param);

    /**
     * TODO 统计数据,带条件 select count(*) from 类 类别名 where 类别名.field = :varName
     * 
     * @param hql
     *            统计语句
     * @param param
     *            条件值,键名对应HQL中 :后面的变量名
     * @return Long 符合条件的 author Mr.Wang date 2016年11月28日
     */
    Long count(String hql, Map<String, Object> param);

    /**
     * TODO 执行HQL语句 执行 update delete 语句 不支持 select 返回被修改数
     * 
     * @param hql
     *            ,from 类名 where field = n
     * @return 返回修改/删除记录条数
     */
    public Integer executeHql(String hql);

    /**
     * TODO 执行HQL语句 update,delete 不支持 select
     * 
     * @param hql
     *            ,from 类名 where field = ? and field = ?
     * @param param
     *            ,条件值对应 hql语句中的 ?
     * @return 返回修改/删除记录条数
     */
    public Integer executeHql(String hql, Object[] param);

    /**
     * TODO 执行HQL语句 update,delete 不支持 select
     * 
     * @param hql
     *            ,from 类名 where field = ? and field = ?
     * @param param
     *            ,条件值对应 hql语句中的 ?
     * @return 返回修改/删除记录条数
     */
    public Integer executeHql(String hql, List<Object> param);

    /**
     * TODO 执行HQL语句 update,delete 不支持 select
     * 
     * @param hql
     *            ,from 类名 where field = :param1 and field = :param2
     * @param param
     *            键值对数对象Map<参数名,参数值> 对应':'之后的参数名
     * @return 返回修改/删除记录条数
     */
    public Integer executeHql(String hql, Map<String, Object> param);

    /**
     * TODO 执行sql语句
     * 
     * @param sql
     *            是sql语句,而不是hql
     * @return Integer 执行条数 author Mr.Wang date 2018年1月16日
     */
    public Integer executeSql(String sql);

}

实现类 BaseDAOImpl.java

package com.test.demo.dao.impl;

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

import javax.annotation.Resource;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Criterion;
import org.springframework.stereotype.Repository;

import com.test.demo.dao.BaseDAO;
@Repository("baseDAO")
@SuppressWarnings("all")
public class BaseDAOImpl<T> implements BaseDAO<T> {
    /**
     * hibernate.sessionFactory session工厂
     */
    @Resource
    private SessionFactory sessionFactory;

    /**
     * TODO sessionFactory 的 set方法 author Mr.Wang date 2018年4月11日
     */
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    /**
     * TODO sessionFactory 的 get 方法
     * 
     * @return SessionFactory session工厂 author Mr.Wang date 2018年4月11日
     */
    public SessionFactory getSessionFactory() {
        return this.sessionFactory;
    }

    /**
     * TODO 得到上下文session对象,即有且只有同一个session对象
     * 
     * @return Session 会话对象 author Mr.Wang date 2018年4月11日
     */
    private Session getCurrentSession() {
        return sessionFactory.getCurrentSession();
    }

    /**
     * 保存实体对象
     */
    @Override
    public Serializable save(T o) throws RuntimeException {
        return this.getCurrentSession().save(o);
    }

    /**
     * 删除实体对象
     */
    @Override
    public void delete(T o) throws RuntimeException {
        this.getCurrentSession().delete(o);
    }

    /**
     * 修改实体对象
     */
    @Override
    public void update(T o) throws RuntimeException {
        this.getCurrentSession().update(o);
    }

    /**
     * 保存或修改实体对象
     */
    @Override
    public void saveOrUpdate(T o) throws RuntimeException {
        this.getCurrentSession().saveOrUpdate(o);
    }

    /**
     * 查找实体对象集合,无明显条件
     */
    @Override
    public List<T> find(String hql) throws RuntimeException {
        return this.getCurrentSession().createQuery(hql).list();
    }

    /**
     * 查找实体对象集合,无明显条件,带分页
     */
    @Override
    public List<T> find(String hql, Integer page, Integer rows) {
        if (page == null || page < 1) {
            page = 1;
        }
        if (rows == null || rows < 1) {
            rows = 10;
        }
        Query q = this.getCurrentSession().createQuery(hql);
        return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
    }

    /**
     * 查找实体对象集合,以Criterion条件筛选
     */
    @Override
    public List<T> find(Class<T> c, Criterion[] criterions) {
        /**
         * Session session=this.getHibernateTemplate().getSessionFactory().
         * getCurrentSession(); session.createCriteria(ProjectBD.class,"h")
         * .add(Restrictions.eq("h.xmguid", xmguid))
         * .addOrder(Order.desc("h.subtime")) .createAlias("bidCompany",
         * "b",Criteria.LEFT_JOIN) .add(Restrictions.eq("b.xxx", 1)) ,
         * 此处的条件(add:eq ,like...)都是第一个Criteria的where条件 .list();
         * createAlias("bidCompany", "b",Criteria.LEFT_JOIN，Criteria)
         * 多了一个Criteria参数，这个Criteria参数就是直接加到on后
         */
        Criteria crit = this.getCurrentSession().createCriteria(c);
        for (Criterion cr : criterions) {
            crit.add(cr);
        }
        return crit.list();
    }

    /**
     * 查找实体对象集合,使用数组按顺序填充条件参数 ?
     */
    @Override
    public List<T> find(String hql, Object[] param) throws RuntimeException {
        Query q = this.getCurrentSession().createQuery(hql);
        if (param != null && param.length > 0) {
            for (int i = 0; i < param.length; i++) {
                q.setParameter(i, param[i]);
            }
        }
        return q.list();
    }

    /**
     * 查找实体对象集合,使用集合按顺序填充条件参数 ?
     */
    @Override
    public List<T> find(String hql, List<Object> param) throws RuntimeException {
        Query q = this.getCurrentSession().createQuery(hql);
        if (param != null && param.size() > 0) {
            for (int i = 0; i < param.size(); i++) {
                q.setParameter(i, param.get(i));
            }
        }
        return q.list();
    }

    /**
     * 查找实体对象集合,使用map key 对应的value 指定填充条件参数 :key
     */
    @Override
    public List<T> find(String hql, Map<String, Object> param)
            throws RuntimeException {
        Query q = this.getCurrentSession().createQuery(hql);
        if (param != null && param.size() > 0)
            for (String key : param.keySet()) {
                q.setParameter(key, param.get(key));
            }
        return q.list();
    }

    /**
     * 查找实体对象集合,使用数组按顺序填充条件参数 ? , 带分页
     */
    @Override
    public List<T> find(String hql, Object[] param, Integer page, Integer rows)
            throws RuntimeException {
        if (page == null || page < 1) {
            page = 1;
        }
        if (rows == null || rows < 1) {
            rows = 10;
        }
        Query q = this.getCurrentSession().createQuery(hql);
        if (param != null && param.length > 0) {
            for (int i = 0; i < param.length; i++) {
                q.setParameter(i, param[i]);
            }
        }
        return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
    }

    /**
     * 查找实体对象集合,使用集合按顺序填充条件参数 ? , 带分页
     */
    @Override
    public List<T> find(String hql, List<Object> param, Integer page,
            Integer rows) throws RuntimeException {
        if (page == null || page < 1) {
            page = 1;
        }
        if (rows == null || rows < 1) {
            rows = 10;
        }
        Query q = this.getCurrentSession().createQuery(hql);
        if (param != null && param.size() > 0) {
            for (int i = 0; i < param.size(); i++) {
                q.setParameter(i, param.get(i));
            }
        }
        return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
    }

    /**
     * 查找实体对象集合,使用map key 对应的value 指定填充条件参数 :key , 带分页
     */
    @Override
    public List<T> find(String hql, Map<String, Object> param, Integer page,
            Integer rows) throws RuntimeException {
        if (page == null || page < 1) {
            page = 1;
        }
        if (rows == null || rows < 1) {
            rows = 10;
        }
        Query q = this.getCurrentSession().createQuery(hql);
        if (param != null && param.size() > 0) {
            for (String key : param.keySet()) {
                q.setParameter(key, param.get(key));
            }
        }
        return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
    }

    /**
     * 得到实体对象,用id获取
     */
    @Override
    public T get(Class<T> c, Serializable id) throws RuntimeException {
        return (T) this.getCurrentSession().get(c, id);
    }

    /**
     * 得到实体对象,用hql语句查找返回第一个
     */
    @Override
    public T get(String hql) throws RuntimeException {
        List<T> lt = this.getCurrentSession().createQuery(hql).list();
        return lt.size() == 0 ? null : lt.get(0);
    }

    /**
     * 得到实体对象,用hql加数组参数查找返回第一个
     */
    @Override
    public T get(String hql, Object[] param) throws RuntimeException {
        Query query = this.getCurrentSession().createQuery(hql);
        for (int i = 0; i < param.length; i++) {
            query.setParameter(i, param[i]);
        }
        List<T> lt = query.list();
        return lt.size() == 0 ? null : lt.get(0);

    }

    /**
     * 得到实体对象,用hql加list参数查找返回第一个
     */
    @Override
    public T get(String hql, List<Object> param) throws RuntimeException {
        Query query = this.getCurrentSession().createQuery(hql);
        for (int i = 0; i < param.size(); i++) {
            query.setParameter(i, param.get(i));
        }
        List<T> lt = query.list();
        return lt.size() == 0 ? null : lt.get(0);
    }

    /**
     * 得到实体对象,用hql加map参数查找返回第一个
     */
    @Override
    public T get(String hql, Map<String, Object> param) throws RuntimeException {
        Query query = this.getCurrentSession().createQuery(hql);
        for (String name : param.keySet()) {
            query.setParameter(name, param.get(name));
        }
        List<T> list = query.list();
        return list.size() == 0 ? null : list.get(0);
    }

    /**
     * 得到T 类型的一个代理引用,在使用其他字段时会向缓存或数据库查询,若无结果则会抛异常
     */
    @Override
    public T load(Class<T> c, Serializable id) {
        return (T) this.getCurrentSession().load(c, id);
    }

    /**
     * 统计,无条件
     */
    @Override
    public Long count(String hql) throws RuntimeException {
        return (Long) this.getCurrentSession().createQuery(hql).uniqueResult();
    }

    /**
     * 统计,带条件,参数数组依次填充 ?
     */
    @Override
    public Long count(String hql, Object[] param) throws RuntimeException {
        Query q = this.getCurrentSession().createQuery(hql);
        if (param != null && param.length > 0) {
            for (int i = 0; i < param.length; i++) {
                q.setParameter(i, param[i]);
            }
        }
        return (Long) q.uniqueResult();
    }

    /**
     * 统计,带条件,参数list依次填充 ?
     */
    @Override
    public Long count(String hql, List<Object> param) throws RuntimeException {
        Query q = this.getCurrentSession().createQuery(hql);
        if (param != null && param.size() > 0) {
            for (int i = 0; i < param.size(); i++) {
                q.setParameter(i, param.get(i));
            }
        }
        return (Long) q.uniqueResult();
    }

    /**
     * 统计,带条件,参数Map value 按key名填充 :key
     */
    @Override
    public Long count(String hql, Map<String, Object> param)
            throws RuntimeException {
        Query q = this.getCurrentSession().createQuery(hql);
        if (param != null && param.size() > 0)
            for (String item : param.keySet()) {
                q.setParameter(item, param.get(item));
            }
        return (Long) q.uniqueResult();
    }

    /**
     * 执行hql
     */
    @Override
    public Integer executeHql(String hql) throws RuntimeException {
        return this.getCurrentSession().createQuery(hql).executeUpdate();
    }

    /**
     * 执行hql,带参数 ,参数数组依次填充 ?
     */
    @Override
    public Integer executeHql(String hql, Object[] param)
            throws RuntimeException {
        Query q = this.getCurrentSession().createQuery(hql);
        if (param != null && param.length > 0) {
            for (int i = 0; i < param.length; i++) {
                q.setParameter(i, param[i]);
            }
        }
        return q.executeUpdate();
    }

    /**
     * 执行hql,带条件,参数list依次填充 ?
     */
    @Override
    public Integer executeHql(String hql, List<Object> param)
            throws RuntimeException {
        Query q = this.getCurrentSession().createQuery(hql);
        if (param != null && param.size() > 0) {
            for (int i = 0; i < param.size(); i++) {
                q.setParameter(i, param.get(i));
            }
        }
        return q.executeUpdate();
    }

    /**
     * 执行hql,带条件,参数Map value 按key名填充 :key
     */
    @Override
    public Integer executeHql(String hql, Map<String, Object> param)
            throws RuntimeException {
        Query q = this.getCurrentSession().createQuery(hql);
        if (param != null && param.size() > 0) {
            for (String key : param.keySet()) {
                q.setParameter(key, param.get(key));
            }
        }
        return q.executeUpdate();
    }

    /**
     * 从session中剥离实体关联
     */
    @Override
    public void evict(Object o) {
        this.getCurrentSession().evict(o);
    }

    /**
     * 执行sql
     */
    @Override
    public Integer executeSql(String sql) {
        Query q = this.getCurrentSession().createSQLQuery(sql);
        return q.executeUpdate();
    }
}

Service层
在com.test.demo.service包中添加service 接口 , com.test.demo.service.impl包添加实现类
UserService.java

package com.test.demo.service;

import com.test.demo.entry.User;

public interface UserService {
    /**
     * 登录验证
     * @param username 用户名
     * @param password 密码
     * @return boolean 是否正确
     */
    public boolean loginCheck(String username,String password);

    /**
     * 注册
     * @param user 用户信息
     */
    public void register(User user);
}

实现类UserServiceImpl.java

package com.test.demo.service.implement;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.transaction.Transactional;

import org.springframework.stereotype.Service;

import com.test.demo.dao.BaseDAO;
import com.test.demo.entry.User;
import com.test.demo.service.UserService;

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

    @Resource(name="baseDAO")
    BaseDAO<User> userD;

    @Override
    public boolean loginCheck(String username, String password) {
        if(username != null && password != null){
            String hql = "from User as u where u.username = :username and u.password = :password";
            Map<String, Object> param = new HashMap<String, Object>();
            param.put("username", username);
            param.put("password", password);
            List<User> list = userD.find(hql,param);
            return list.size()>0;
        }
        return false;
    }

    @Override
    public void register(User user) {
        userD.save(user);
    }


}

在Controller Test 中使用

@Resource(name = "userService")
UserService userSrv;//用户接口

注册测试 这里以表单提交，json格式返回

@RequestMapping("test7")
@ResponseBody
public Map<String,Object> testRigster(User user){
    out(user);
    Map<String, Object> result = new HashMap<String, Object>();
    result.put("code", "ERROR");
    try {
        userSrv.register(user);
        result.put("code", "SUCCESS");
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result;
}
@RequestMapping("test8")
@ResponseBody
public Map<String,Object> testLogin(String username , String password){
    out(username + " - " + password);
    Map<String, Object> result = new HashMap<String, Object>();
    result.put("code", "ERROR");
    if(userSrv.loginCheck(username , password))
        result.put("code", "SUCCESS");
    return result;
}

运行结果 无法上传图片(可能文章太长了吧…..)
请求结果

{
    "code": "SUCCESS"
}

后台输出

 ■■■■■■ User [id=null, username=test中文, password=123456, birthday=2018-07-13 13:14:25.0, sex=true] ■■■■■■ 
Hibernate: 
    insert 
    into
        test.user
        (birthday, password, sex, username) 
    values
        (?, ?, ?, ?)
 ■■■■■■ User [id=null, username=test中文, password=123456, birthday=null, sex=null] ■■■■■■ 
Hibernate: 
    insert 
    into
        test.user
        (birthday, password, sex, username) 
    values
        (?, ?, ?, ?)

总结 , 废话了一大篇。记性不好全当记事本了。不知有没有纰漏

追加内容
漏了一些东西,TAGLIB ,JSTL 用于JSP页面 JSON用于转换json,LOG4J用于日志

<properties>  
    <jstlVersion>1.2</jstlVersion>  
    <taglibsVersion>1.1.2</taglibsVersion>  
    <log4jVersion>1.2.17</log4jVersion>  
    <jsonVersion>2.4</jsonVersion>  
</properties>  
<dependencies>  
    <!-- JSON 工具配置 -->  
    <dependency>  
        <groupId>net.sf.json-lib</groupId>  
        <artifactId>json-lib</artifactId>  
        <version>${jsonVersion}</version>  
        <!-- JSON-LIB 支持jdk1.5 -->  
        <classifier>jdk15</classifier>  
    </dependency>  
    <!-- LOG4J 配置 -->  
    <dependency>  
        <groupId>log4j</groupId>  
        <artifactId>log4j</artifactId>  
        <version>${log4jVersion}</version>  
    </dependency>  
</dependencies>

log4j.properties

log4j.rootLogger = INFO,stdout  
# 输出到控制台 #  
log4j.appender.stdout = org.apache.log4j.ConsoleAppender  
log4j.appender.stdout.Target = System.out  
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout  
log4j.appender.stdout.layout.ConversionPattern =[%-5p] %d{yyyy-MM-dd HH\:mm\:ss,SSS} method\:%l%n%m%n

很倔也很天真

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
学习SPRING MVC + SPRING + HIBERNATE 逐步搭建总结

唠叨个人不怎么上进,对新鲜事物不感兴趣,主要是麻烦。。。但也需要会几样东西。一直用myeclipse，最近才用了一下IDEA，相比IDEA支持最新版本，没有先在IDEA上练习SPRING MVC，用MYECLIPSE成功后再去试。使用了MAVEN环境方便看源码和随意加包,也是刚上手。版本myeclipse 2014tomcat 7(配置了编码格式)/8sprin...
复制链接

扫一扫