【SpringMVC】学习总结（二）

CrazyGuu

于 2023-02-11 00:02:56 发布

阅读量126

点赞数

分类专栏： # SpringMVC 文章标签： java

本文链接：https://blog.csdn.net/qq_35536689/article/details/128979053

版权

SpringMVC 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

SpringMVC（第二天）

1.学习目标

在这里插入图片描述

2. 拦截器

2.1.基本概念

SpringMVC中的Interceptor拦截器也是相当重要和相当有用的，它的主要作用是拦截用户的请求并进行相应的处理。比如通过它来进行权限验证，或者是来判断用户是否登陆等操作。对于SpringMVC拦截器的定义方式有两种：

实现接口：org.springframework.web.servlet.Handlerlnterceptor

继承适配器：org.springframework…web.servlet.handler.HandlerInterceptorAdapter

2.2.拦截器实现

2.2.1.实现HandlerInterceptor接口

接口实现类

package com.zgz.springmvc.interceptor;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 *
 * 拦截器实现
 *      实现接口：HandlerInterceptor
 */
public class MyInterceptor01 implements HandlerInterceptor {


    /**
     * 在目标方法(Handler)执行前执行
     *      如果返回true,表示执行目标方法
     *      如果返回false,表示阻止目标方法执行
     **/
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        System.out.println("MyInterceptor01 -> preHandle方法.，在目标方法(Handler)执行前执行.，");
        return true;
    }

    /**
     * 在目标方法(handLer)执行后，视图生成前执行
     **/
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor01->postHandle方法.·在目标方法(handler)执行后，视图生成前执行..");
    }

    
    /**
     * 在目标方法(handler)执行后，视图生成后执行
     **/
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor01->afterCompletion方法，.·在目标方法(handler)执行后，视图生成后执行..");
    }
}

拦截器配置

<!--拦截器设置-->
    <!--方式一：设置拦截器-->
    <mvc:interceptors>
        <!--
        在mvc:interceptors标签中直接定义bean标签
        bean标签的class执行拦截器的类路径，表示拦截所有的请求
        -->
        <bean class="com.zgz.springmvc.interceptor.MyInterceptor01"/>
    </mvc:interceptors>

<!--拦截器配置 方式二（推荐使用）-->
    <mvc:interceptors>
        <!--
            在mvc:interceptors标签下定义子标签mvc:interceptor,设置具体的拦截器
                在mvc:interceptor标签中：
                    设置mvc:mapping的path属性，设置需要被拦截的路径，可以使用通配符"*"，可以配置多个。"/**"表示拦截所有请求
                    设置mvc:exclude-mapping的path属性，设置需要放行的资源，可以使用通配符"*"，可以配置多个。
					设置bean标签的class属性，设置拦截器的类路径。

        -->
        <mvc:interceptor>
            <!--通过mvc:mapping配置需要拦截的资源。支持通配符。可配置多个。-->
            <mvc:mapping path="/**"/><!--"/**"表示拦截所有的请求。-->
            <!--通过mvc:mapping配置不需要被拦截的资源。支持通配符。可配置多个。-->
            <mvc:exclude-mapping path="/url/*"/><!--"/url/*"表示放行url路径下的请求。-->
            <bean class="com.zgz.springmvc.interceptor.MyInterceptor01"/>
        </mvc:interceptor>
    </mvc:interceptors>

2.2.2.继承HandlerInterceptorAdapter

实际上最终还是Handlerlnterceptor接口实现。

子类实现类

public class MyInterceptor02 extends HandlerInterceptorAdapter {

    /**
     * 在目标方法(Handler)执行前执行
     *      如果返回true,表示执行目标方法
     *      如果返回false,表示阻止目标方法执行
     **/
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        System.out.println("MyInterceptor02 -> preHandle方法.，在目标方法(Handler)执行前执行.，");
        return true;
    }
}

拦截器xml配置

<mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"></mvc:mapping>
            <mvc:exclude-mapping path="/hello"></mvc:exclude-mapping>
            <bean class="com.zgz.springmvc.interceptor.MyInterceptor02"></bean>
        </mvc:interceptor>
</mvc:interceptors>

2.3.拦截器应用-非法请求拦截

使用拦截器完成用户是否登录请求验证功能

2.3.1.用户控制器

UserlnfoController定义

@Controller
@RequestMapping("users")
public class UserController {

    /**
     * 用户登录
     */
    @RequestMapping("login")
    public String login(HttpServletRequest request , HttpSession session){
        //设置请求域
        request.setAttribute("msg","用户登录...");
        //如果用户执行了登录状态，则设置用户信息到session作用域中（如果session作用域中的用信息不为空，则表示登录状态：否则为未登录状态)
        User user = new User();
        user.setUserId(1);
        user.setUserName("zhangsan");
        //设置到作用域
        session.setAttribute("user",user);

        return "success";
    }

    /**
     * 用户添加
     */
    @RequestMapping("add")
    public String add(HttpServletRequest request){
        //设置请求域
        request.setAttribute("msg","用户添加..");
        return "success";
    }

    /**
     * 用户修改
     */
    @RequestMapping("update")
    public String update(HttpServletRequest request){
        //设置请求域
        request.setAttribute("msg","用户修改..");
        return "success";
    }

    /**
     * 用户删除
     */
    @RequestMapping("delete")
    public String delete(HttpServletRequest request){
        //设置请求域
        request.setAttribute("msg","用户删除..");
        return "success";
    }
}

拦截器定义

/**
 *
 * 拦截器
 *  非法访问请求拦截器
 *      用户登录（无需登录，不需要拦截）
 *      用户添加（需要登录，需要拦截判断）
 *      用户修改（需要登录，需要拦截判断）
 *      用户刷别除（需要登录，需要拦截判断）
 */
public class LoginAccessInterceptor extends HandlerInterceptorAdapter {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        //判断用户是否登录
        //通过request对象获取session对象
        HttpSession session = request.getSession();
        //获取session作用域中的用户信息
        User user = (User) session.getAttribute("user");
        //判断user对象是否为空（不为空表示登录状态，否则为未登录状态)
        if(user == null){
            //未登录状态，跳转到登录页面
            response.sendRedirect(request.getContextPath() +"/login.jsp");
            System.out.println(request.getContextPath());
            return false;
        }
        return true;
    }
}

拦截器xml配置

        <mvc:interceptor>
            <mvc:mapping path="/**"></mvc:mapping>
            <mvc:exclude-mapping path="/users/login"></mvc:exclude-mapping>
            <bean class="com.zgz.springmvc.interceptor.LoginAccessInterceptor"></bean>
        </mvc:interceptor>

登录页面

<%--
  Created by IntelliJ IDEA.
  User: ZHANG
  Date: 2023/2/9
  Time: 18:42
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>用户登录</h3>
    <form action="users/login" method="post">
    <button>登录</button>
</form>
</body>
</html>

3.文件上传

3.1.环境配置

3.1.1.pom.xml文件修改

        <!--添加commons-fileupload依赖-->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.2</version>
        </dependency>

3.1.2.servlet-context.xml修改

    <!--文件上传-->
    <bean id="multipartResolver"
          class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!--允许文件上传的最大尺寸-->
        <property name="maxUploadSize">
            <value>104857600</value>
        </property>
        <!--
            设置文件放入临时文件夹的最大大小限制。
            此值是阈值，低于此值，则保存在内存中，如高于此值，则生成硬盘上的临时文件。
        -->
        <property name="maxInMemorySize">
            <value>4096</value>
        </property>
    </bean>

3.2.代码实现

3.2.1.单文件上传

3.2.1.1.页面表单

input的type设置为file
form表单的method设为post,
form表单的enctype设置为multipart/form-data,以二进制的形式传输数据

    <form action="uploadFile" method="post" enctype="multipart/form-data">
        文件<input name="myfile" type="file">
       <button>提交</button>
    </form>

3.2.1.2. 代码实现

package com.zgz.springmvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;

/**
 * 单文件上传
 * 使用MultipartFile对象作为参数，接收前端发送过来的文件
 */
@Controller
public class FileController {

    /**
     * 文件上传
     *  在形参上使用@RequestParam("myfile")MultipartFile file接收上传的文件
     *      @RequestParam("myfile“)中的"myfiLe"代表的是表单元素的name属性值
     **/
    @RequestMapping("uploadFile")
    public String uploadFile(@RequestParam("myfile") MultipartFile file, HttpServletRequest request) {
        //判断文件是否为空，如果不为空进行对应的文件上传操作
        if (!file.isEmpty()) {
            try {
                //获取项目的所在的路径(绝对路径)
                String path = request.getServletContext().getRealPath("/");
                System.out.println(path);
                //设置上传的文件存放的目录
                File uploadFile = new File(path + "/upload");
                //判断文件目录是否存在，不存在则新建目录
                if (!uploadFile.exists())
                    //新建目录
                    uploadFile.mkdir();
                //获取上传文件的原文件名
                String originalName = file.getOriginalFilename();
                //获取上传的文件的后缀
                String suffix = originalName.substring(originalName.lastIndexOf("."));
                //通过系统当前时间的毫秒数，生成随机文件名(避免上传的文件名重复)
                String fileName = System.currentTimeMillis() + suffix;
                //上传文件（转存文件到指定目录）
                file.transferTo(new File(uploadFile, fileName));

                //设置成功的域对象
                request.setAttribute("msg", "文件上传成功！");
            } catch (IOException e) {
                e.printStackTrace();
                //如果报错，设置的域对象
                request.setAttribute("msg", "文件上传失败！");
            }
        } else
            //上传文件不存在，设置的域对象
            request.setAttribute("msg", "文件不存在，上传失败！");

        return "success";
    }
}

4.SSM框架集成与测试

4.1.环境配置

4.1.1.IDEA下创建项目

创建Maven对应的Web项目

4.1.2.配置pom.xml

4.1.2.1.修改JDK版本

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

4.1.2.2.添加坐标依赖

    <dependencies>
        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!--spring核心jar-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.4.RELEASE</version>
        </dependency>

        <!--spring测试jar-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.4.RELEASE</version>
        </dependency>

        <!--spring jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.4.RELEASE</version>
        </dependency>

        <!--spring事务-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.2.4.RELEASE</version>
        </dependency>

        <!--aspectj切面编程的jar-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>

        <!--c3p0连接池-->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>

        <!--mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.3</version>
        </dependency>

        <!--添加nybatis.与Spring整合的核心包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.3</version>
        </dependency>

        <!--mysql驱动包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.19</version>
        </dependency>

        <!--日志打印相关的jar-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.2</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.2</version>
        </dependency>

        <!--分页插件-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.10</version>
        </dependency>

        <!--spring web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.2.4.RELEASE</version>
        </dependency>

        <!--spring mvc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.4.RELEASE</version>
        </dependency>

        <!--web servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>

        <!--添加json依赖jar包（注意版本问题）-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.10.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.10.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.10.0</version>
        </dependency>
        <!--commons-fileupload -->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.2</version>
        </dependency>
    </dependencies>

4.1.2.3.设置资源目录和插件

    <build>
        <finalName>ssm</finalName>
        <!--
            Maven项目：如果源代码(src/main/java)存在xml、properties、tld等文件
            Maven默认不会自动编译该文件到输出目录，如果要编译源代码中xml properties tld等文件
            需要显式配置resources标签
        -->
        <resources>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                    <include>**/*.tld</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

4.1.3.配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="3.0"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
    <!--启动spring容器-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring.xml</param-value>
    </context-param>
    <!--设置监听器-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!--编码过滤utf-8-->
    <filter>
        <description>char encoding filter</description>
        <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>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!--serv1et请求分发器-->
    <servlet>
        <servlet-name>springMvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--初始化参数，在servlet类加载时加载的参数-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:servlet-context.xml</param-value>
        </init-param>
        <!--表示启动容器时初始化该Servlet-->
        <load-on-startup>1</load-on-startup>

    </servlet>
    <servlet-mapping>
        <servlet-name>springMvc</servlet-name>
        <!--这是拦截请求，"/"代表拦截所有请求，"*.do"拦截所有.do请求-->
        <url-pattern>/</url-pattern>
        <!--        <url-pattern>*.do</url-pattern>-->
    </servlet-mapping>
</web-app>

4.1.4配置servlet-context.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!--开启扫描器 -->
    <context:component-scan base-package="com.zgz.springmvc.controller"/>
    
    <!--使用默认的Servlet来响应静态文件-->
    <mvc:default-servlet-handler/>

    <!--开启注解驱动-->
    <mvc:annotation-driven/>

    <!-- mvc注解驱动井添加json支持-->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <!-- 返回信息为字符串时处理 -->
            <bean class="org.springframework.http.converter.StringHttpMessageConverter"/>
            <!-- 将对象转换为json对象 -->
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <!--配置视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceviewResolver">
        <!--前缀：在WEB-INF目录下的jsp目录下-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀：以.jsp结尾的资源-->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--文件上传-->
    <bean id="multipartResolver"
          class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!--允许文件上传的最大尺寸-->
        <property name="maxUploadSize">
            <value>104857600</value>
        </property>
        <!--
            设置文件放入临时文件夹的最大大小限制。
            此值是阈值，低于此值，则保存在内存中，如高于此值，则生成硬盘上的临时文件。
        -->
        <property name="maxInMemorySize">
            <value>4096</value>
        </property>
    </bean>

</beans>

4.1.5.配置spring.xml

在项目的src/main/resources下创建spring.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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd">


    <!--扫描基本包-->
    <context:component-scan base-package="com.zgz.ssm">
        <!--context:exclude-filter标签：排除对某个注解的扫描 (过滤Controller层)-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!--加载properties配置文件-->
    <context:property-placeholder location="classpath:db.properties"/>
    <!--aop-->
    <aop:aspectj-autoproxy/>
    <!--配置c3p0数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <!--配置事务管理器-->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--设置事务增强-->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="add*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!--aop切面配置-->
    <aop:config>
        <aop:pointcut id="servicePointcut" expression="execution(* com.zgz.ssm.service..*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="servicePointcut"/>
    </aop:config>

    <!--配置sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mybatis.xml"/>
        <property name="mapperLocations" value="classpath:com/zgz/ssm/mapper/*.xml"/>
    </bean>

    <!--配置扫描器-->
    <bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--扫描com.zgz.ssm.dao这个包以及它的子包下的所有映射接口类-->
        <property name="basePackage" value="com.zgz.ssm.dao"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>
</beans>

4.1.6.配置mybatis.xml

在项目的src/main/resources下创建mybatis.xml文件，内容如下

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <typeAliases>
        <package name="com.zgz.ssm.po"/>
    </typeAliases>
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>
</configuration>

4.1.7.配置db.properties

在项目的src/main/resources下创建db.properties文件，内容如下(mysql创建数据库ssm)

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
jdbc.username=root
jdbc.password=zhangguzong

4.1.8.添加log4j.properties

在项目的src/main/resources下创建log4j.properties文件，内容如下

1og4j.rootLogger=DEBUG,Console
Console
1og4j.appender.Console=org.apache.10g4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.l0g4j.PatternLayout
1og4j.appender.Console.layout.ConversionPattern=%d [%t]%-5p [%c]-%m%n
log4j.logger.java.sql.ResultSet=INFO
1og4j.logger.org.apache=INFO
1og4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sq1.PreparedStatement=DEBUG

4.2.添加源代码

4.2.1.添加包

在项目的src/main/java下创建对应的包结构
com.xxxx.ssm.controller
com.xXxx.ssm.service
com.xxxx.ssm.mapper
com.XxXX.ssm.dao
com.xxxx.ssm.po

4.2.2.添加User,java

在com.xxxx.ssm.po包下创建JavaBean文件User.java(数据库字段对应如下)

在这里插入图片描述

public class User {
    private Integer userId;
    private String userName;
    private String userPwd;
    private String userEmail;
    private Date createDate;
    private Date updateDate;
}

4.2.3.添加UserDao.java接口

com.xxxx.ssm.dao包下创建UserDao.java文件，提供对应的用户详情查询功能

public interface UserDao {

    //通过用户ID查询用户对象
    public User queryUserById(Integer userId);
}

4.2.4.添加UserMapper.xml映射文件

com.xxxx.ssm.mapper包下创建UserMapper.xml文件，提供select查询标签配置

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.xxxx.ssm.dao.UserDao">
        <select id="queryUserByUserId" parameterType="int" resultType="com.zgz.ssm.po.User">
            select user_id as userId,user_name as userName,user_pwd as userPwd
            from tb_user
            where user_id = #{userId}
    </select>
</mapper>

4.2.5.添加UserService.java

com.xxxx.ssm.service包下创建UserService.java文件，提供用户详情查询方法

@Service
public class UserService {

    @Autowired
    private UserDao userDao ;
    /**
     * 通过用户ID查询用户对象
     **/
    public User queryUser(Integer userId){
        User user = userDao.queryUserById(userId);
        return user;
    }
}

4.2.6.添加UserController.java

@Controller
@RequestMapping("user")
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping("query")
    @ResponseBody
    public User queryUser(Integer userId) {
        return userService.queryUser(userId);
    }
}

4.3.执行测试

4.3.1.Idea下配置tomcat启动命令

在这里插入图片描述

4.3.2.启动jetty浏览器访问http://localhost:8080/ssm/user/query?userId=1查看结果

6.全局异常统一处理

6.1.全局异常概念

在JavaEE项目的开发中，不管是对底层的数据库操作过程，还是业务层的处理过程，还是控制层的处理过程，都不可避免会遇到各种可预知的、不可预知的异常需要处理。每个过程都单独处理异常，系统的代码耦合度高，工作量大且不好统一，维护的工作量也很大。

SpringMVC对于异常处理这块提供了支持，通过SpringMVC提供的全局异常处理机制，能够将所有类型的异常处理从各处理过程解耦出来，既保证了相关处理过程的功能较单一，也实现了异常信息的统一处理和维护。

全局异常实现方式Spring MVC处理异常有3种方式：

使用Spring MVC提供的简单异常处理器SimpleMappingException Resolver
实现Spring的异常处理接口HandlerExceptionResolver自定义自己的异常处理器
使用@ExceptionHandler注解实现异常处理

6.2.异常处理实现

6.2.1.全局异常处理方式一

6.2.1.1.配置简单异常处理器

配置SimpleMappingExceptionResolver对象

配置SimpleMappingExceptionResolver对象
<!--配置全局异常统一处理的Bean(简单异常处理器)-->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<!--页面在转发时出现异常，设置默认的错误页面(error代表的是一个视图)-->
<property name="defaultErrorView"value="error"></property>
<!--异常发生时，设置异常的变量名-->
<property name="exceptionAttribute"value="ex"></property>
</bean>

可以在处理异常的页面获取异常信息

${ex}

6.2.1.2.使用自定义异常

参数异常

package com.zgz.ssm.exceptions;

/**
 * 自定义异常：参数异常
 */
public class ParamsException extends RuntimeException {
    private Integer code = 300;
    private String msg = "参数异常！";

    public ParamsException() {
        super("参数异常！");
    }

    public ParamsException(String msg) {
        super(msg);
        this.msg =msg;
    }

    public ParamsException(Integer code) {
        super("参数异常！");
        this.code =code;
    }

    public ParamsException(Integer code, String msg) {
        super(msg);
        this.code = code;
        this.msg = msg;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

业务异常

package com.zgz.ssm.exceptions;

/**
 * 业务异常
 */
public class BusinessException extends RuntimeException {

    private Integer code = 400;
    private String msg = "业务异常！";

    public BusinessException() {
        super("业务异常！");
    }

    public BusinessException(String msg) {
        super(msg);
        this.msg = msg;
    }

    public BusinessException(Integer code) {
        super("业务异常！");
        this.code = code;
    }

    public BusinessException(Integer code, String msg) {
        super(msg);
        this.code = code;
        this.msg = msg;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }


}

6.2.1.3.设置自定义异常与页面的映射

    <!--配置全局异常统一处理的Bean(简单异常处理器)-->
    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <!--页面在转发时出现异常，设置默认的错误页面(error代表的是一个视图)-->
        <property name="defaultErrorView" value="error"></property>
        <!--异常发生时，设置异常的变量名-->
        <property name="exceptionAttribute" value="ex"></property>
        <!--设置自定义异常与页面的映射-->
        <property name="exceptionMappings">
            <props>
                <!--key:自定义异常对象的路径：标签中设置具体的处理页面的视图名-->
                <prop key="com.zgz.ssm.exceptions.BusinessException">buss_error</prop>
                <prop key="com.zgz.ssm.exceptions.ParamsException">params_error</prop>
            </props>
        </property>
    </bean>

使用SimpleMappingExceptionResolver进行异常处理，具有集成简单、有良好的扩展性、对已有代码没有入侵性等优点，但该方法仅能获取到异常信息，若在出现异常时，对需要获取除异常以外的数据的情况不适用。

6.2.2.全局异常处理方式二（推荐）

6.2.2.1.实现HandlerExceptionResolver接口

@Component
public class GlobalExceptionResolver  implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest,
                                         HttpServletResponse httpServletResponse,
                                         Object o, Exception e) {
        //得到ModelAndView对象，并设置默认视图
        ModelAndView modelAndView =new ModelAndView("error");
        //设置默认的异常信息
        modelAndView.addObject("ex","默认的异常信息，..");
        return modelAndView ;
    }
}

6.2.2.2 自定义异常处理

/**
 * 全局异常统—处理
 *  方式二（推荐使用）
 *      实现Spring的异常处理接口HandlerExceptionResolver
 *      自定义自己的异常处理器具有集成简单、有良好的扩展性、对已有代码没有入侵性等优，点同时，
 *      在异常处理时能获取导致出现异常的对象，有利于提供更详细的异常处理信息。
 */
@Component
public class GlobalExceptionResolver  implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest,
                                         HttpServletResponse httpServletResponse,
                                         Object o, Exception e) {
        //得到ModelAndView对象，并设置默认视图
        ModelAndView modelAndView =new ModelAndView("error");
        //设置默认的异常信息
        modelAndView.addObject("ex","默认的异常信息，..");

        if (e instanceof ParamsException){
            ParamsException p =(ParamsException)e;
            p.setCode(500);
            p.setMsg("这是个参数异常...");
            modelAndView.setViewName("params_error");
            modelAndView.addObject("e",p);
            return modelAndView ;
        }

        if (e instanceof BusinessException){
            BusinessException p =(BusinessException)e;
            p.setCode(500);
            p.setMsg("这是个业务异常...");
            modelAndView.setViewName("buss_error");
            modelAndView.addObject("e",p);
            return modelAndView ;
        }


        return modelAndView ;
    }
}

使用实现HandlerExceptionResolver接口的异常处理器进行异常处理，具有集成简单、有良好的扩展性、对已有代码没有入侵性等优点，同时，在异常处理时能获取导致出现异常的对象，有利于提供更详细的异常处理信息。

6.2.3.全局异常处理方式三

页面处理器继承BaseController

/**
 *全局异常处理方式三
 */
public class BaseController {

    /**
     * 处理异常的方法
     **/
    @ExceptionHandler
    public String exc(HttpServletRequest request, HttpServletResponse response, Exception ex) {
        request.setAttribute("ex", ex);
        if (ex instanceof ParamsException) {
            return "error_param";
        }
        if (ex instanceof BusinessException) {
            return "error business";
        }

        return "error";
    }
}

使用@ExceptionHandler注解实现异常处理，具有集成简单、有扩展性好（只需要将要异常处理的Controller类继承于BaseController即可)、不需要附加Spring配置等优点，但该方法对已有代码存在入侵性（需要修改已有代码，使相关类继承于BaseController),在异常处理时不能获取除异常以外的数据。

全局异常统一处理方式一：

使用Spring MVC提供的简单异常处理器SimpleMappingExceptionResolver使用简单、集成简单、扩展性好，对代码没有入侵性
但仅能获取到异常信息，若在出现异常时，对需要获取除异常以外的数据的情况不适用

全局异常统一处理方式二（推荐使用）

实现Spring的异常处理接口HandlerExceptionResolver自定义自己的异常处理器具有集成简单、有良好的扩展性、对已有代码没有入侵性等优，点同时，在异常处理时能获取导致出现异常的对象，有利于提供更详细的异常处理信息。

全局异常统一处理方式三：

1. 使用@ExceptionHandler注解实现异常处理，具有集成简单、有扩展性好（只需要将要异常处理的Controller类继承于BaseController即可)、不需要附加Spring配置等优点，但该方法对已有代码存在入侵性（需要修改已有代码，使相关类继承于BaseController),在异常处理时不能获取除异常以外的数据。

6.3.未捕获异常的处理

对于Unchecked Exception而言，由于代码不强制捕获，往往被忽略，如果运行期产生了Unchecked Exception,而代码中又没有进行相应的捕获和处理，则我们可能不得不面对尴尬的404、500…等服务器内部错误提示页面。此时需要一个全面而有效的异常处理机制。目前大多数服务器也都支持在wb.xml中通过(Vebsphere/Weblogic)或者(Tomcat)节点配置特定异常情况的显示页面。修改web.xml文件，增加以下内容：

    <!--
        未捕获异常处理
        在web.xml中通过<error-page>(Websphere/Weblogic)或者<error-code>(Tomcat)节点配置特定异常情况的显示页面
        -->
    <error-page>
        <exception-type>java.lang.Throwable</exception-type>
        <location>/500.jsp</location>
    </error-page>
    <error-page>
        <error-code>404</error-code>
        <location>/404.jsp</location>
    </error-page>