[SSM]SpringMVC详解

已于 2023-08-02 18:59:02 修改
阅读量323 收藏 2
点赞数 2
文章标签： SSM SpringMVC
于 2023-08-02 16:55:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71229255/article/details/132066065
版权

目录

一、SpringMVC简介 

1.1什么是MVC

1.2什么是SpringMVC

1.3SpringMVC优点

1.4SpringMVC优化的方向

1.5SpringMVC执行的流程

1.6基于注解的SpringMVC程序

二、SpringMVC注解式开发

2.1@RequestMapping定义请求规则

2.1.1指定模块名称

2.1.2对请求提交方式的定义

2.2五种数据提交的方式

2.2.1单个数据注入

2.2.2对象封装注入

2.2.3动态占位符提交（仅用于超链接）

2.2.4请求参数名称与形参名称不一致

2.2.5使用HttpServletRequest对象提取

​编辑2.3请求参数中文乱码解决

2.3.1解决方案

2.3.2源码分析

2.4处理器方法的返回值

2.4.1返回ModelAndView（较少使用）

2.4.2返回String

2.4.3无返回值void

2.4.4返回对象Object

2.5SpringMVC的四种跳转方式

2.6SpringMVC支持的默认参数类型

2.7日期处理

2.7.1日期注入

2.7.2日期显示

2.8标签的使用

2.9资源在WEB-INF目录下

三、SpringMVC拦截器

3.1拦截器介绍

3.1.1拦截器的应用场景

3.1.2拦截器的执行原理

3.1.3拦截器执行的时机

3.1.4拦截器实现的两种方式

3.2自定义拦截器实现权限验证

四、SSM整合

4.1SSM整合后台功能

(1)新建Maven项目，添加依赖

(2)拷贝所有的配置文件到config，开发每个配置文件

(3)在web.xml文件中完成springmvc，spring两个框架的注册

(4)创建实体类对象User

(5)创建UserMapper接口和实现功能的UserMapper.xml

(6)创建业务逻辑层UserService接口和实现类

(7)创建测试类进行功能测试

(8)创建action进行分页显示，查询用户个数，删除处理

4.2Vue实现前台功能

(1)安装node.js

(2)构建项目

(3)为idea添加vue插件

(4)配置启动项

(5)项目结构

(6)UserHome.vue解读

一、SpringMVC简介 

1.1什么是MVC

  • MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分。

  • M：Model，模型层，指工程中的JavaBean，作用是处理数据。

    • JavaBean分为两类：

      • 一类称为实体类Bean：专门存储业务数据的，如Student、User等。

      • 一类称为业务处理Bean：指Service或Dao对象，专门用于处理业务逻辑和数据访问。

  • V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据

  • C：Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器。

  • MVC的工作流程：用户通过视图层发生请求到服务器，在服务器中请求被Controller接收，Controller调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果找到相应的View视图，渲染数据后最终响应给浏览器。

1.2什么是SpringMVC

  • 它是基于MVC开发模式的框架，用来优化控制器。

  • 它是Spring家族的一员，它也具备IOC和AOP。

1.3SpringMVC优点

  • 基于MVC架构

    • 基于MVC架构，功能分工明确，解耦合。

  • 容易理解，上手快，使用简单

    • SpringMVC是轻量级的，jar很小。不依赖特定的接口和类。

  • 作为Spring框架的一部分，能够使用Spring的IOC和AOP

    • 方便整合Strtus、MyBatis、Hiberate、JPA等其它框架。

  • SpringMVC强化注解的使用

    • 在Controller、Service、Dao都可以使用注解，方便灵活。使用@Controller创建处理器对象，@Service创建业务对象，@Autowired或者@Resource在控制器类上注入Service，在Service类中注入Dao。

1.4SpringMVC优化的方向

  • 数据提交的优化

  • 携带数据的优化

  • 简化返回处理

1.5SpringMVC执行的流程

  • 执行流程说明：

    1. 向服务器发送HTTP请求，请求被前端控制器DispatcherServlet捕获。

    2. DispatcherServlet根据<servlet-name>中的配置对请求的URL进行解析，得到请求资源标识符（URI）。然后根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain对象的形式返回。

    3. DispatcherServlet根据获得的Handler，选择一个合适的HandlerAdapter。

    4. 提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller）。在天赐Handler入参过程中，根据你的配置，Spring将帮你做一些额外的工作：

      HttpMessageConveter：将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息。

      数据转换：对请求消息进行数据转换。如String转换成Integer、Double等。

      数据格式化：对请求消息进行数据格式化。如将字符串转换成格式化数字或格式化日期等。

      数据验证：验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中。

    5. Handler(Controller)执行完成后，向 DispatcherServlet 返回一个 ModelAndView 对象。

    6. 根据返回的ModelAndView，选择一个适合的 ViewResolver（必须是已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet。

    7. ViewResolver 结合Model和View，来渲染视图。

    8. 视图负责将渲染结果返回给客户端。

1.6基于注解的SpringMVC程序

  • 所谓SpringMVC的注解式开发是指，在代码中通过对类与方法的注解，便可完成处理器在springmvc容器的注册。注解式开发是重点。

  • 项目案例：用户提交一个请求，服务端处理器在接收到这个请求后，给出一条欢迎信息，在响应页面中显示该信息。

  • 创建步骤：

    1. 新建maven_web项目

    2. 添加依赖

      <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>

    3. 删除web.xml文件重新添加，因为自动生成的web.xml文件版本太低了。

    4. 在web.xml文件中注册SpringMVC框架。因为web的请求都是由Servlet来进行处理的，而SpringMVC的核心处理器就是一个DispatcherServlet，它负责接收客户端的请求，并根据请求的路径分派给对应的action（控制器）进行处理，处理结束后依然由核心处理器DispatcherServlet进行响应返回。

      <!--注册SpringMVC框架-->
<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.xml</param-value>
    </init-param>
</servlet>
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>*.action</url-pattern>
</servlet-mapping>

    5. 删除index.jsp页面，重新建index.jsp页面，因为自动生成的页面缺失指令设置。

    6. 在index.jsp中开发页面，发送请求。

      <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<br><br><br>
<a href="${pageContext.request.contextPath}/zar/demo.action">访问服务器</a>
</body>
</html>

      • /demo 是方法上的注解路径

    7. 在webapp目录上新添目录/admin。

    8. 在/admin目录下新建main.jsp页面，用来进行服务器处理完毕后数据的回显。

    9. 开发DemoAction.java-->控制器（相当于以前的Servlet）。这是一个普通的类，不用继承和实现接口，类中的每个方法就是一个具体的action控制器。

      • 类中的方法定义规范：

        • 访问权限是public

        • 方法名自定义

        • 方法的参数可以有多个，任意类型，用来接收客户端提交上来的数据

        • 方法的返回值任意，以返回String居多

      • @Controller:标识当前类为处理器，交给Spring容器去创建。

      • @RequestMapping：标识路径映射。该注解可以加在类上相当于包名，还可以加在方法上相当于action的名称，都是来指定映射路径的。

      package com.hhb.controller;
​
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
​
@Controller //交给Spring去创建对象
@RequestMapping("/zar")
public class DemoAction {
    /**
     * 以前的Servlet的规范
     * protected void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException {}
     * action中所有的功能实现都是由方法来完成的
     * action方法的规范
     * 1）访问权限是public
     * 2）方法的返回值任意
     * 3）方法名称任意
     * 4）方法可以没有参数，如果有可以是任意类型
     * 5）要使用@RequestMapping注解来声明一个访问的路径（名称）
     */
    @RequestMapping("/demo")
    public String demo() {
        System.out.println("服务器被访问到了");
        return "main";//可以直接跳到/admin/main.jsp
    }
}

    10. 完成springmvc.xml文件的配置。在工程的类路径即resources目录下创建SpringMVC的配置文件springmvc.xml。该文件名可以任意，推荐使用springmvc.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
​
    <!--添加包扫描-->
    <context:component-scan base-package="com.hhb.controller"/>
​
    <!--添加视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--配置前缀-->
        <property name="prefix" value="/admin/"/>
        <!--配置后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

      • SpringMVC框架为了避免对于请求资源路径与扩展名上的冗余，在视图解析器InternalResouceViewResolver中引入了请求的前缀与后缀。而action中只需给出要跳转页面的文件名即可，对于具体的文件路径与文件扩展名，视图解析器会自动完成拼接。

      • context:component-scan：用来进行包扫描，这里用于指定@Controller注解所在的包路径。

二、SpringMVC注解式开发

2.1@RequestMapping定义请求规则

2.1.1指定模块名称

  • 通过@RequestMapping注解可以定义处理器对于请求的映射规则。该注解可以注解在方法上，也可以注解在类上，但意义不同。value属性值常以"/"开始。@ResourceMapping的value属性用于定义所有匹配请求的URI。

  • 一个@Controller所注解的类中，可以定义多个处理器方法。当然，不同的处理器方法所匹配的URI是不同的。这些不同的URI被指定在注解于方法之上的@RequestMapping的value属性中。但若这些请求具有相同的URI部分，则这写相同的URI部分可以被抽取到注解在类之上的@RequestMapping的value属性中。此时的这个URI标识模块（相当于包）的名称。URI的请求是相对于Web的根目录。

示例

提取后

@Controller
@RequestMapping("/zar")
public class HelloSpringMvc {
//相当于一个控制器处理的方法
@RequestMapping("/hello")
public String one() {
return "main";
}
@RequestMapping("/two")
public String two() {
return "main";
}
2.1.2对请求提交方式的定义

  • 对应@RequestMappinp，其中有一个属性method，用于对被注解方法所处理请求的提交方式进行限制，即只有满足该method属性指定的提交方式的请求，才会执行该注解方法。

  • method属性的取值为RequestMethod.枚举常量。常用的为RequestMethod.GET与RequestMethod.POST，分别表示提交方式的匹配规则为GET与POST提交。

  • 客户端浏览器常用的请求方式，及其提交方式有以下几种：

post提交方式

get提交方式

2.2五种数据提交的方式

  • 前四种数据注入的方式，会自动进行类型转换，但无法自动转换日期类型。

2.2.1单个数据注入

  • 在方法中声明一个和表单提交的参数名称相同的参数，由框架按照名称直接注入。

2.2.2对象封装注入

  • 在方法中声明一个自定义的实体类参数，框架调用实体类中相应的setter方法注入属性值，只要保证实体类中成员变量的名称与提交请求的那么属性值一致即可。

  • get请求不会乱码，post请求会乱码。

2.2.3动态占位符提交（仅用于超链接）

  • 使用框架提供的一个注解@PathVariable，将请求url中的值作为参数进行提取，只能是超链接。

2.2.4请求参数名称与形参名称不一致

  • 请求与形参中的名字不对应，可以使用@RequestParam("name")来进行参数名称绑定。

2.2.5使用HttpServletRequest对象提取

  • 在方法参数中声明一个request对象，使用request对象的getParameter()获取表单提交的数据，这样得到的数据还要手工进行数据类型的转换。

2.3请求参数中文乱码解决

  • 对于前面所接收的请求参数，若含有中文并且使用post请求，则会出现中文乱码问题。

  • Spring对于中文请求参数的中文乱码问题，给出了专门的字符集过滤器：spring-web-5.2.5.RELEASE.jar 的org.springframework.web.filter 包下的 CharacterEncodingFilter 类。

2.3.1解决方案

  • 在web.xml中注册字符集过滤器，即可解决Spring的请求参数的中文乱码问题。

  • 最好将该过滤器注册在其它过滤器之前，因为过滤器的执行是按照其注册顺序进行的。

<!--配置中文编码过滤器:解决post请求乱码的问题-->
<filter>
    <filter-name>encode</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <!--配置参数
            private String encoding;
            private boolean forceRequestEncoding;
            private boolean forceResponseEncoding;
    -->
    <!--指定字符集-->
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <!--强制request使用字符集encoding-->
    <init-param>
        <param-name>forceRequestEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
    <!--强制response使用字符集encoding-->
    <init-param>
        <param-name>forceResponseEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>encode</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
2.3.2源码分析

2.4处理器方法的返回值

  • 使用@Controller注解的处理器的方法，其返回值常用的有四种类型：

    • ModelAndView

    • String

    • 无返回值void

    • 返回对象类型

2.4.1返回ModelAndView（较少使用）

  • 若处理器方法处理完后，需要跳转到其它资源，且又要在跳转的资源间传递数据，此时处理器方法返回 ModelAndView 比较好。当然，若要返回 ModelAndView，则处理器方法中需要定义 ModelAndView 对象。在使用时，若该处理器方法只是进行跳转而不传递数据，或只是传递数据而并不向任何资源跳转（如对页面的 Ajax 异步响应），此时若返回 ModelAndView，则将总是有一部分多余：要么 Model 多余，要么 View 多余。即此时返回 ModelAndView 将不合适。较少使用。

2.4.2返回String

  • 处理器方法返回的字符串可以指定逻辑视图名，通过视图解析器解析可以将其转换为物理视图地址。

  • 也可以直接返回资源的物理视图名。不过，此时就需要再在视图解析器中再配置前缀与后缀了。

2.4.3无返回值void

  • 对于处理器方法返回void的应用场景，应用在AJAX响应处理。

  • 若处理器对请求处理后，无需跳转到其它任何资源，此时可以让处理器方法返回void。

  • 代码后面见。

2.4.4返回对象Object

  • 处理器方法也可以返回Object对象。这个Object对象可以是Integer，自定义对象，Map，List等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面显示的数据出现的。

  • 返回对象需要使用@ResponseBody注解，将转换后的JSON数据放入到响应体中。

  • Ajax请求多用于Object返回值类型。

  • 由于转换器底层使用了Jackson转换方式将对象转换为JSON数据，所以需要添加Jackson的相关依赖。

实现步骤

  1. 在pom.xml文件中添加依赖

    <dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.8</version>
</dependency>

  2. 添加jQuery的函数库，在webapp目录下新建js目录，拷贝jquery-3.3.1.js到目录下

  3. 发送ajax请求

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="js/jquery-3.3.1.js"></script>
</head>
<body>
<script>
    function show() {
        $.ajax({
            url: "${pageContext.request.contextPath}/ajax.action",
            dataType: "json",
            type: "get",
            success: function (list) {
                var s = "";
                $.each(list, function (i, stu) {
                    s += stu.name + "-----" + stu.age + "<br>"
                });
                $("#mydiv").html(s);
            }
        })
    }
</script>
<a href="javascript:show()">访问服务器</a>
<div id="mydiv"></div>
</body>
</html>

  4. 开发实体类Student

    package com.hhb.pojo;
​
public class Student {
    private String name;
    private int age;
​
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public Student() {
    }
}

  5. 开发action

    @Controller
public class AjaxAction {
    @RequestMapping("/ajax")
    //处理ajax请求，一定要加@ResponseBody
    @ResponseBody
    public List<Student> ajax() {
        Student student1 = new Student("张三", 22);
        Student student2 = new Student("李四", 23);
        Student student3 = new Student("王五", 24);
        List<Student> list = new ArrayList<Student>();
        list.add(student1);
        list.add(student2);
        list.add(student3);
        //自动调用json转换工具进行转换
        return list;
    }
}

  6. 在springmvc.xml文件中添加注解驱动

    <!--添加注解驱动，专门用来处理ajax请求-->
<mvc:annotation-driven/>

2.5SpringMVC的四种跳转方式

  • 默认的跳转方式是请求转发，直接跳到jsp页面展示。

  • 可以使用框架提供的关键字redirect:，进行一个重定向操作，包括重定向页面和重定向action。

  • 使用框架提供的关键字forward:，进行服务器内部转发操作，包括转发页面和转发action。

  • 当使用redirect:和forward:关键字时，视图解析器中前缀后缀的拼接就无效了。

页面部分

<a href="${pageContext.request.contextPath}/one.action">请求转发页面(默认)</a><br>
<a href="${pageContext.request.contextPath}/two.action">请求转发action</a><br>
<a href="${pageContext.request.contextPath}/three.action">重定向页面</a><br>
<a href="${pageContext.request.contextPath}/four.action">重定向action</a><br>

Controller部分

 

@Controller
public class JumpAction {
    @RequestMapping("/one")
    public String one(){
        System.out.println("请求转发页面(默认)");
        //以前的访问方式
    //request.getRequestDispatcher("/admin/main.jsp").forward(request,response);
        //观察地址栏的变化:  http://localhost:8080/one.action
        //return "main"; //默认的访问方式是自动拼接前缀和后缀进行跳转
        return "forward:/fore/user.jsp";//只要使用了forward:就可以屏蔽前缀和后缀的拼接,自己手工构建返回的全部路径+.jsp
    }
    @RequestMapping("/two")
    public String two(){
        System.out.println("请求转发action");
        //观察地址栏的变化:  http://localhost:8080/two.action
        return "forward:/other.action";   //不使用forward:,就会是这样的路径  /admin/other.action/.jsp
    }
    @RequestMapping("/three")
    public String three(){
        System.out.println("重定向页面");
        //观察地址栏的变化  http://localhost:8080/admin/main.jsp
        return "redirect:/admin/main.jsp";//只要使用了redirect:就可以屏蔽前缀和后缀的拼接
    }
    @RequestMapping("/four")
    public String four(){
        System.out.println("重定向action");
        //观察地址栏的变化  http://localhost:8080/other.action
        return "redirect:/other.action";//只要使用了redirect:就可以屏蔽前缀和后缀的拼接
    }
}
 

 

@Controller
public class OtherAction {
    @RequestMapping("/other")
    public String other(){
        System.out.println("other");
        return "main";
    }
}
 

2.6SpringMVC支持的默认参数类型
 

  •  
    这些类型只要写在方法参数上就可以使用了。
     
  
    •  
      HttpServletRequest对象
       
    •  
      HttpServletResponse对象
       
    •  
      HttpSession对象
       
    •  
      Model对象
       
    •  
      ModelMap对象
       
    •  
      Map对象
       
 

示例
 

<a href="${pageContext.request.contextPath}/data.action">访问服务器，进行数据携带</a>
 

@Controller
public class DataAction {
    @RequestMapping("/data")
    public String Data(
            HttpServletRequest request,
            HttpSession session,
            Model model,
            Map map,
            ModelMap modelMap
    ) {
        Users users = new Users("张三", 20);
        request.setAttribute("requestUser", users);
        session.setAttribute("sessionUser", users);
        model.addAttribute("modelUser", users);
        map.put("mapUser", users);
        modelMap.addAttribute("modelMapUser", users);
        //请求转发跳转
        return "main";
        //重定向会丢失数据
        //return "redirect:/admin/main.jsp";
    }
}
 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h2>显示数据</h2>
requestUser:${requestUser}<br>
sessionUser:${sessionUser}<br>
modelUser:${modelUser}<br>
mapUser:${mapUser}<br>
modelMapUser:${modelMapUser}<br>
</body>
</html>
 

  •  
    注意：Model、Map、ModelMap都使用的是request请求作用域，意味着只能是请求转发后，页面才可以得到值。
     
  •  
    response不能携带数据。
     
 

2.7日期处理
 

2.7.1日期注入
 

在方法的参数上使用@DateTimeFormat注解
 

  •  
    日期类型不能自动注入到方法的参数中，需要单独做转换处理，使用@DateTimeFormat注解，需要在springmvc.xml文件中添加mvc:annotation-driven/标签
     
 

<form action="${pageContext.request.contextPath}/mydate.action">
    日期:<input type="date" name="dates"><br>
    <input type="submit" value="提交"><br>
</form>
 

@Controller
public class DateAction {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
​
    @RequestMapping("/mydate")
    public String MyDate(
            @DateTimeFormat(pattern = "yyyy-MM-dd")
            Date dates) {
        System.out.println(dates);
        System.out.println(sdf.format(dates));
        return "show";
    }
}
 

@InitBinder注解解决类中日期问题
 

@Controller
public class DateAction {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
​
    //注册一个全局的日期处理注解
    @InitBinder
    public void initBinder(WebDataBinder dataBinder) {
        dataBinder.registerCustomEditor(Date.class, new CustomDateEditor(sdf, true));
    }
​
    @RequestMapping("/mydate")
    public String MyDate(Date dates) {
        System.out.println(dates);
        System.out.println(sdf.format(dates));
        return "show";
    }
}
 

2.7.2日期显示
 

JSON中的日期显示
 

  •  
    需要在类中的成员变量的getXXX方法上加注解
     
 

@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
public Date getDate() {
return date;
}
 

JSP页面的日期显示
 

  •  
    使用JSTL标签库，先添加依赖。
     
    <dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
     
     
  •  
    导入标签库
     
    <%--引入jstl核心标签库--%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--%@引入jstl格式化标签库--%>
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
     
     
 

<a href="${pageContext.request.contextPath}/list.action">显示集合中对象的日期成员</a>
 

@RequestMapping("/list")
public String listDate(HttpServletRequest request) throws ParseException {
    Student student1 = new Student("张三", sdf.parse("2003-08-19"));
    Student student2 = new Student("李四", sdf.parse("2000-12-09"));
    Student student3 = new Student("王五", sdf.parse("2002-03-29"));
    List<Student> list = new ArrayList<Student>();
    list.add(student1);
    list.add(student2);
    list.add(student3);
    request.setAttribute("list", list);
    return "show";
}
 

<table width="500px" border="1">
    <tr>
        <th>姓名</th>
        <th>生日</th>
    </tr>
    <c:forEach items="${list}" var="stu">
        <tr>
            <td>${stu.name}</td>
                <%--<td>${stu.birthday}</td>--%>
            <td><fmt:formatDate value="${stu.birthday}" pattern="yyyy-MM-dd"/></td>
        </tr>
    </c:forEach>
</table>
 

2.8<mvc:annotation-driven/>标签的使用
 

  •  
    <mvc:annotation-driven/>会自动注册两个bean，分别为DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter。是springmvc为@Controller分发请求所必须的。除了注册这两个bean，还提供了很多支持。
     
  
    •  
      支持使用ConversionService实例对表单参数进行类型转换
       
    •  
      支持使用@NumberFormat、@DateTimeFormat。
       
    •  
      注解完成数据类型的格式化。
       
    •  
      支持使用@RequestBody和@ResponseBody注解。
       
    •  
      静态资源的分流也使用这个标签。
       
 

2.9资源在WEB-INF目录下
 

  •  
    很多企业会将动态资源放在WEB-INF目录下，这样可以保证资源的安全性。在WEB-INF目录下的动态资源不可以直接访问，必须要通过请求转发的方式进行访问。这样避免了通过地址栏直接对资源的访问。重定向也无法访问动态资源。
     
 

项目案例
 

  •  
    页面结构图：
     
     
  •  
    主要代码：
     
    package com.hhb.controller;
​
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
​
import javax.servlet.http.HttpServletRequest;
​
@Controller
public class WebInfAction {
    @RequestMapping("/showIndex")
    public String ShowIndex() {
        return "index";
    }
​
    @RequestMapping("/showMain")
    public String ShowMain() {
        return "main";
    }
​
    @RequestMapping("/showLogin")
    public String Login() {
        return "login";
    }
​
    @RequestMapping("/login")
    public String doLogin(String name, String pwd, HttpServletRequest request) {
        if ("tom".equals(name) && "123".equals(pwd)) {
            return "main";
        } else {
            request.setAttribute("msg", "用户名或密码错误");
            return "login";
        }
    }
}
     
     
 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h2>登录</h2>
<form action="${pageContext.request.contextPath}/login">
    用户名 <input type="text" name="name"><br>
    密码 <input type="password" name="pwd"> ${msg}<br>
    <input type="submit" value="提交">
</form>
</body>
</html>
 

 

三、SpringMVC拦截器
 

  •  
    拦截器的主要作用是：针对请求和响应进行的额外处理，在请求和响应的过程中添加预处理、后处理和最终处理。
     
 

3.1拦截器介绍
 

3.1.1拦截器的应用场景
 

  •  
    日志记录：记录请求信息的日志
     
  •  
    权限检查：如登录检查
     
  •  
    性能检测：检测方法的执行时间
     
 

3.1.2拦截器的执行原理
 

 

 

3.1.3拦截器执行的时机
 

  •  
    preHandle():预处理，在请求被处理之前进行操作
     
  •  
    postHandle():后处理，在请求被处理之后，但结果还没有被渲染前进行操作，可以改变响应结果
     
  •  
    afterCompletion:最终处理，所有的请求响应结束后执行善后工作，清理对象，关闭资源
     
 

3.1.4拦截器实现的两种方式
 

  •  
    继承HandlerInterceptorAdapter的父类
     
  •  
    实现HandlerInterceptor接口，实现的接口，推荐使用实现接口的方式
     
 

3.2自定义拦截器实现权限验证
 

  •  
    实现一个权限验证拦截器
     
 

  1.  
    修改web.xml文件中请求路径
     
    <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.xml</param-value>
    </init-param>
</servlet>
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>
     
     
  2.  
    将所有的页面放入WEB-INF目录下
     
     
     
  3.  
    开发登录action
     
    @Controller
public class WebInfAction {
    @RequestMapping("/showIndex")
    public String ShowIndex() {
        return "index";
    }
​
    @RequestMapping("/showMain")
    public String ShowMain() {
        return "main";
    }
​
    @RequestMapping("/showLogin")
    public String Login() {
        return "login";
    }
​
    //登录业务的判断
    @RequestMapping("/login")
    public String doLogin(String name, String pwd, HttpServletRequest request) {
        if ("tom".equals(name) && "123".equals(pwd)) {
            //在session中存储用户信息，用于进行权限验证
            request.getSession().setAttribute("user", name);
            return "main";
        } else {
            request.setAttribute("msg", "用户名或密码错误");
            return "login";
        }
    }
}
     
     
  4.  
    开发拦截器
     
    public class LoginInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //判断是否登录
        if (request.getSession().getAttribute("user") == null) {
            request.setAttribute("msg", "您未登录");
            request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
            return false;
        }
        return true;
    }
}
     
     
  5.  
    配置springmvc.xml文件
     
    <!--注册拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--映射要拦截的请求-->
        <mvc:mapping path="/**"/>
        <!--设置放行的请求-->
        <mvc:exclude-mapping path="/showLogin"/>
        <mvc:exclude-mapping path="/login"/>
        <!--配置具体的拦截器实现功能的类 -->
        <bean class="com.hhb.interceptor.LoginInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>
     
     
 

四、SSM整合
 

4.1SSM整合后台功能
 

(1)新建Maven项目，添加依赖
 

<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>com.hhb</groupId>
  <artifactId>SpringMVC006-ssm</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>SpringMVC006-ssm Maven Webapp</name>
​
  <!-- 集中定义依赖版本号 -->
  <properties>
    <junit.version>4.12</junit.version>
    <spring.version>5.2.5.RELEASE</spring.version>
    <mybatis.version>3.5.1</mybatis.version>
    <mybatis.spring.version>1.3.1</mybatis.spring.version>
    <mybatis.paginator.version>1.2.15</mybatis.paginator.version>
    <mysql.version>5.1.32</mysql.version>
    <slf4j.version>1.6.4</slf4j.version>
    <druid.version>1.1.12</druid.version>
    <pagehelper.version>5.1.2</pagehelper.version>
    <jstl.version>1.2</jstl.version>
    <servlet-api.version>3.0.1</servlet-api.version>
    <jsp-api.version>2.0</jsp-api.version>
    <jackson.version>2.9.6</jackson.version>
  </properties>
​
​
  <dependencies>
    <!-- spring -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jms</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!-- Mybatis -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>${mybatis.spring.version}</version>
    </dependency>
    <dependency>
      <groupId>com.github.miemiedev</groupId>
      <artifactId>mybatis-paginator</artifactId>
      <version>${mybatis.paginator.version}</version>
    </dependency>
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>${pagehelper.version}</version>
    </dependency>
    <!-- MySql -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>
    <!-- 连接池 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>${druid.version}</version>
    </dependency>
​
    <!-- junit -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
​
​
    <!-- JSP相关 -->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>${jstl.version}</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jsp-api</artifactId>
      <scope>provided</scope>
      <version>${jsp-api.version}</version>
    </dependency>
    <!-- Jackson Json处理工具包 -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>${jackson.version}</version>
    </dependency>
    <dependency>
      <groupId>org.json</groupId>
      <artifactId>json</artifactId>
      <version>20140107</version>
    </dependency>
​
    <!--    文件异步上传使用的依赖-->
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.4</version>
    </dependency>
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.3.1</version>
    </dependency>
  </dependencies>
​
  <!-- 插件配置 -->
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
    </plugins>
    <!--识别所有的配置文件-->
    <resources>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
  </build>
</project>
 

(2)拷贝所有的配置文件到config，开发每个配置文件
 

jdbc.properties
 

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssmuser
jdbc.username=root
jdbc.password=030522
 

mybatis-config.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>
    <!--设置日志输出语句，显示相应操作的sql语句-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
</configuration>
 

applicationContext_mapper.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
​
    <!--引入外部的属性配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
​
    <!--配置数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
​
    <!--配置SqlSessionFactoryBean-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--配置数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--指定mybatis核心配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <!--注册实体类-->
        <property name="typeAliasesPackage" value="com.hhb.pojo"/>
    </bean>
​
    <!--Mapper扫描配置器，主要扫描Mapper接口，生成代理类-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.hhb.mapper"/>
    </bean>
​
</beans>
 

applicationContext_service.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
​
    <!--引入外部的属性配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
​
    <!--配置数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
​
    <!--配置SqlSessionFactoryBean-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--配置数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--指定mybatis核心配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <!--注册实体类-->
        <property name="typeAliasesPackage" value="com.hhb.pojo"/>
    </bean>
​
    <!--Mapper扫描配置器，主要扫描Mapper接口，生成代理类-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.hhb.mapper"/>
    </bean>
​
</beans>
 

springmvc.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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
​
    <!--添加包扫描-->
    <context:component-scan base-package="com.hhb.controller"/>
​
    <!--添加注解驱动-->
    <mvc:annotation-driven/>
    
    <!--因为本项目全部是ajax请求，不需要配置视图解析器-->
</beans>
 

(3)在web.xml文件中完成springmvc，spring两个框架的注册
 

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!--添加中文编码过滤器
    private String encoding;
    private boolean forceRequestEncoding;
    private boolean forceResponseEncoding;-->
    <filter>
        <filter-name>encode</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>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encode</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
​
    <!--注册SpringMVC框架-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
​
    <!--注册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>
​
</web-app>
 

(4)创建实体类对象User
 

package com.hhb.pojo;
​
public class User {
    private String userId;
    private String cardType;
    private String cardNo;
    private String userName;
    private String userSex;
    private String userAge;
    private String userRole;
​
    @Override
    public String toString() {
        return "User{" +
                "userId='" + userId + '\'' +
                ", cardType='" + cardType + '\'' +
                ", cardNo='" + cardNo + '\'' +
                ", userName='" + userName + '\'' +
                ", userSex='" + userSex + '\'' +
                ", userAge='" + userAge + '\'' +
                ", userRole='" + userRole + '\'' +
                '}';
    }
​
    public String getUserId() {
        return userId;
    }
​
    public void setUserId(String userId) {
        this.userId = userId;
    }
​
    public String getCardType() {
        return cardType;
    }
​
    public void setCardType(String cardType) {
        this.cardType = cardType;
    }
​
    public String getCardNo() {
        return cardNo;
    }
​
    public void setCardNo(String cardNo) {
        this.cardNo = cardNo;
    }
​
    public String getUserName() {
        return userName;
    }
​
    public void setUserName(String userName) {
        this.userName = userName;
    }
​
    public String getUserSex() {
        return userSex;
    }
​
    public void setUserSex(String userSex) {
        this.userSex = userSex;
    }
​
    public String getUserAge() {
        return userAge;
    }
​
    public void setUserAge(String userAge) {
        this.userAge = userAge;
    }
​
    public String getUserRole() {
        return userRole;
    }
​
    public void setUserRole(String userRole) {
        this.userRole = userRole;
    }
​
    public User(String userId, String cardType, String cardNo, String userName, String userSex, String userAge, String userRole) {
        this.userId = userId;
        this.cardType = cardType;
        this.cardNo = cardNo;
        this.userName = userName;
        this.userSex = userSex;
        this.userAge = userAge;
        this.userRole = userRole;
    }
​
    public User() {
    }
}
 

(5)创建UserMapper接口和实现功能的UserMapper.xml
 

UserMapper
 

package com.hhb.mapper;
​
import com.hhb.pojo.User;
import org.apache.ibatis.annotations.Param;
​
import java.util.List;
​
public interface UserMapper {
    //根据条件分页获取分页数据
    List<User> selectUserPage(
            @Param("userName")
            String userName,
            @Param("userSex")
            String userSex,
            @Param("startRow")
            int startRow);
​
    //增加用户
    int createUser(User user);
​
    //根据用户ID删除用户
    int deleteUserById(String userId);
​
    //获取总行数
    int getRowCount(
            @Param("userName")
            String userName,
            @Param("userSex")
            String userSex
    );
}
 

UserMapper.xml
 

<?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.hhb.mapper.UserMapper">
    <!--完成实体类与表中列名的映射-->
    <resultMap id="userMap" type="user">
        <id property="userId" column="user_id"/>
        <result property="cardType" column="card_type"/>
        <result property="cardNo" column="card_no"/>
        <result property="userName" column="user_name"/>
        <result property="userSex" column="user_sex"/>
        <result property="userAge" column="user_age"/>
        <result property="userRole" column="user_role"/>
    </resultMap>
    <!--定义全部列名-->
    <sql id="allColumns">
        user_id
        ,card_type,card_no,user_name,user_sex,user_age,user_role
    </sql>
    <!--根据条件分页获取分页数据-->
    <select id="selectUserPage" resultMap="userMap">
        select
        <include refid="allColumns"></include>
        from user
        <where>
            <if test="userName!=null and userName!=''">
                and user_name like concat('%',#{userName},'%')
            </if>
            <if test="userSex!=null and userSex!=''">
                and user_sex=#{userSex}
            </if>
        </where>
        limit #{startRow},5
    </select>
​
    <!--增加用户-->
    <insert id="createUser" parameterType="user">
        insert into user
        values (#{userId}, #{cardType}, #{cardNo}, #{userName}, #{userSex}, #{userAge}, #{userRole})
    </insert>
​
    <!--根据用户ID删除用户-->
    <delete id="deleteUserById" parameterType="String">
        delete
        from user
        where user_id = #{userId}
    </delete>
​
    <!--获取总行数-->
    <select id="getRowCount" resultType="int" parameterType="String">
        select count(*)
        from user
        <where>
            <if test="userName!=null and userName!=''">
                and user_name like concat('%',#{userName},'%')
            </if>
            <if test="userSex!=null and userSex !=''">
                and user_sex=#{userSex}
            </if>
        </where>
    </select>
</mapper>
 

(6)创建业务逻辑层UserService接口和实现类
 

UserService
 

package com.hhb.service;
​
import com.hhb.pojo.User;
import org.apache.ibatis.annotations.Param;
​
import java.util.List;
​
public interface UserService {
    //根据条件分页获取分页数据
    List<User> selectUserPage(String userName, String userSex, int startRow);
​
    //增加用户
    int createUser(User user);
​
    //根据用户ID删除用户
    int deleteUserById(String userId);
​
    //获取总行数
    int getRowCount(String userName, String userSex);
}
 

UserServiceImpl
 

package com.hhb.service.impl;
​
import com.hhb.mapper.UserMapper;
import com.hhb.pojo.User;
import com.hhb.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
​
import java.util.List;
​
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;
​
    @Override
    public List<User> selectUserPage(String userName, String userSex, int startRow) {
        return userMapper.selectUserPage(userName, userSex, startRow);
    }
​
    @Override
    public int createUser(User user) {
        return userMapper.createUser(user);
    }
​
    @Override
    public int deleteUserById(String userId) {
        return userMapper.deleteUserById(userId);
    }
​
    @Override
    public int getRowCount(String userName, String userSex) {
        return userMapper.getRowCount(userName, userSex);
    }
}
 

(7)创建测试类进行功能测试
 

package test;

import com.hhb.pojo.User;
import com.hhb.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

//启动spring容器
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext_mapper.xml", "classpath:applicationContext_service.xml"})
public class ServiceTest {
    @Autowired
    private UserService userService;

    @Test
    public void testSelectUserPage() {
        List<User> users = userService.selectUserPage(null, null, 0);
        users.forEach(user -> System.out.println(user));
    }

    @Test
    public void testCreateUser() {
        User user = new User("15968162087363061", "身份证", "114264195202156468", "赵云", "男", "29", "打野");
        int count = userService.createUser(user);
        System.out.println(count);
    }

    @Test
    public void testDeleteUserById(){
        int count = userService.deleteUserById("15968162087363060");
        System.out.println(count);
    }

    @Test
    public void test(){
        int rowCount = userService.getRowCount(null, null);
        System.out.println(rowCount);
    }
}
 

(8)创建action进行分页显示，查询用户个数，删除处理
 

package com.hhb.controller;
​
import com.hhb.pojo.User;
import com.hhb.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
​
import java.util.List;
​
@CrossOrigin
@RestController //如果本类中全部都是ajax请求，则使用此注解，方法上的@ResponseBody可以省略
@RequestMapping("/user")
public class UserController {
    //切记：一定要有业务逻辑层对象
    @Autowired
    private UserService userService;
​
    public static final int PAGE_SIZE = 5;
​
    @RequestMapping("/selectUserPage")
    public List<User> selectUserPage(String userName, String userSex, Integer page) {
        //根据页面计算起始行
        int startRow = 0;
        if (page != null) {
            startRow = (page - 1) * PAGE_SIZE;
        }
        return userService.selectUserPage(userName, userSex, startRow);
    }
​
    @RequestMapping("/getRowCount")
    public int getRowCount(String userName, String userSex) {
        return userService.getRowCount(userName, userSex);
    }
​
    @RequestMapping("/createUser")
    public int createUser(User user) {
        String userId = System.currentTimeMillis() + "";
        user.setUserId(userId);
        return userService.createUser(user);
    }
​
    @RequestMapping("/deleteUserById")
    public int deleteUserById(String userId) {
        return userService.deleteUserById(userId);
    }
}
 

4.2Vue实现前台功能
 

(1)安装node.js
 

  •  
    查看版本编号
     
    node -v
npm -v
     
     
 

  •  
    node.js的安装是为了使当前的计算机使用vue的框架，预安装的工具。
     
  •  
    类似于运行java程序必须按照JDK一样的道理。
     
 

(2)构建项目
 

  •  
    使用命令行进入到当前要运行的vue的项目的目录下，运行以下命令行进行项目搭建。
     
 

cd E:\idea_workspace\vuedemo01 进入到当前项目的目录下
​
npm i element -ui -S 下载elementUI的框架
​
npm install //打包项目
​
npm install --save vue-axios //下载跨域访问组件axios
 

(3)为idea添加vue插件
 

 

(4)配置启动项
 

 

(5)项目结构
 

 

 

​​​​​​​build   项目构建(webpack)相关代码
config  配置目录，包括端口号等。我们初学可以使用默认的。
node_modules    npm 加载的项目依赖模块
src     
这里是我们要开发的目录，基本上要做的事情都在这个目录里。里面包含了几个目录及文件：
    assets: 放置一些图片，如logo等。
    components: 目录里面放了一个组件文件，可以不用。
    App.vue: 项目入口文件，我们也可以直接将组件写这里，而不使用 components 目录。
    main.js: 项目的核心文件。
​
static  静态资源目录，如图片、字体等。
test    初始测试目录，可删除
.xxxx文件     这些是一些配置文件，包括语法配置，git配置等。
index.html  首页入口文件，你可以添加一些 meta 信息或统计代码啥的。
package.json    项目配置文件。
README.md   项目的说明文档，markdown 格式
 

 

(6)UserHome.vue解读
 

  •  
    UserHome.vue是所有功能实现的组件.与后台跨域访问,分页显示数据,并实现增加,按主键删除,批量删除,更新,多条件查询等功能.
     
 

  •  
    首先确定钩子函数中的启动访问函数
     
    created() {
        this.handlePageChange();           ===>分页
        this.getRowCount();                ===>计算总行数
      }
     
     
 

  •  
    分页函数解析
     
    handlePageChange() {
         //定义变量,封装将要提交的数据
         let postData=this.qs.stringify({
            page:this.currentPage,
            userName:this.formInline.search1,
            userSex:this.formInline.search2
          });
          this.$axios({                    ==>发出跨域访问的请求,参考$.ajax();
            method:'post',                 ==>请求提交的方式
            url:'/api/user/selectUserPage',==>服务器的地址
            data:postData  //this.qs.stringify==>{"page":1,"userName":"","userSex":""}                               ==>提交的数据
          }).then(response=>{              ==>成功后进入到这里
            this.tableData=response.data;  ==>数据绑定,返回的5个用户的json数据,一下子绑定给表格
          }).catch(error=>{                ==>出错了进入到这里
            console.log(error);
          })
        }
     
     
 

  •  
    计算总行数函数分析
     
     getRowCount() {
          //创建变量,提取文本框和下拉列表框中的数据
          let postData=this.qs.stringify({
            userName:this.formInline.search1,
            userSex:this.formInline.search2
          });
          this.$axios({                  ==>发出跨域访问的请求,参考$.ajax();
            method:'post',               ==>请求提交的方式
            url:'/api/user/getRowCount', ==>服务器的地址
            data:postData                ===>提交的数据
          }).then(response=>{
            this.total=response.data;    ==>返回的总行数赋值给变量total
          }).catch(error=>{
            console.log(error);
          })
        },
     
     
 

  •  
    按主键删除分析
     
     //弹出提示框,让用户确定是否删除 
      this.$confirm('删除操作, 是否继续?', '提示', {
        confirmButtonText: '确定',
        cancelButtonText: '取消',
        type: 'warning'                      ==>黄色的警告图标
      }).then(() => {                        ==>用户点击确定后进入到这里
        let postData = this.qs.stringify({   ==>封装成JSON数据格式
          userId: row.userId,                ==>将要提交的主键值
        });
        this.$axios({                      ==>发出跨域访问的请求,参考$.ajax();
          method: 'post',                    ==>请求提交的方式
          url: '/api/user/deleteUserById',
          data: postData  //{"userId":15968162893439470}
        }).then(response => {                ==>跨域请求成功后进入这里
          this.getRowCount();     ==>计算删除后的总行数,进行分页插件的页码变化
          ...
          this.handlePageChange();            ==>删除后重新分页
          this.$message({                     ==>删除成功后弹框
            type: 'success',
            message: '删除成功!'
          });          
        }).catch(error => {
          console.log(error);
        });
​
      }).catch(() => {                        ===>用户点击取消后进入到这里
        this.$message({
          type: 'info',
          message: '已取消删除'
        });
      });
    },
     
     
 


                

        

        

    




    

      

        

            

              
                
                  Ja kar ta
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    2
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
                
  • 
                  
                    打赏
                    
                  
                  
    打赏
    
                
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
基于SSM（Spring-SpringMVC-MyBatis）的高级整合（增删改查功能）电影

				
			

			

				

					01-17
				

			

		

		

			
				
基于SSM（Spring-SpringMVC-MyBatis）的高级整合（增删改查功能）电影

			
		

	



                

              
                



	

		

			

				
					
SSM之SpringMVC（一）简单介绍

				
			

			

				

					weixin_44044929的博客
				

				

					07-07
					
					163
					
				

			

		

		

			
				
SpringMVC介绍
SpringMVC是Spring家族的一员，Spring是将现在开发中流行的组件进行组合而成的一个框架！它用在基于MVC的表现层开发，类似于struts2框架，Struts2能做的东西，SpringMVC也能够做…

简单入门
1、导入开发包
导入jar包或者使用maven、gradle引入
2、编写Action
Action实现Controller接口

public class HelloAction implements Controller {
    @Override
 

			
		

	



                


  
              

                


	

		

			

				
					
Spring MVC基本使用

					
最新发布

				
			

			

				

					qq_34629454的博客
				

				

					06-04
					
					194
					
				

			

		

		

			
				
与servlet技术相同,均属于web层开发项目,进行表现层开发。

			
		

	





	

		

			

				
					
ssm整合-springmvc

				
			

			

				

					龙小虬的博客
				

				

					06-12
					
					120
					
				

			

		

		

			
				
1.我们先来创建javaweb中的springmvc。

如果遇到项目在建立中创建速度太慢，可以在配置中载入这一键值对name=archetypeCatalog ，value=internal
2.项目
//pom.xml

<dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</ar

			
		

	



		

			
		



	

		

			

				
					
SSM框架之SpringMVC——SpringMVC入门

				
			

			

				

					小唐要努力的博客
				

				

					11-17
					
					453
					
				

			

		

		

			
				
SpringMVC 是 Spring 提供的一种基于MVC设计模式的轻量级 Web 开发框架，本质上相当于Servlet，我们来看看如何在Spring中集成 Web 环境。

一、Spring集成 Web 环境

首先我们创建一个有web环境的项目spring_mvc，详细步骤可见链接。

我们快速实现Dao层和Service层的代码，实现一个save方法，打印save这几个字。

然后将UserDao和UserService利用xml配置文件放到Spring容器中，创建对应的Bean对象。


&...

			
		

	





	

		

			

				
					
【SSM】SSM之SpringMVC框架：SpringMVC的工作原理

				
			

			

				

					景谦Nice的博客
				

				

					03-01
					
					369
					
				

			

		

		

			
				
客户端发送的请求被DispatcherServlet捕获后其流程如下：

其大致流程如下：


1、用户发送请求至前端控制器DispatcherServlet。


2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。


3、处理器映射器如果没有找到具体的处理器：

如果配置了<mvc:default-servlethandler/>，就调用默...

			
		

	





	

		

			

				
					
ssm框架Springmvc文件上传实现代码详解

				
			

			

				

					08-18
				

			

		

		

			
				
ssm框架Springmvc文件上传实现代码详解  ssm框架是基于Spring框架的全栈式框架，它提供了一个完整的Java EE应用程序开发解决方案。 Springmvc是ssm框架中的一个核心组件，负责处理Web请求和响应。文件上传是Web应用...

			
		

	





	

		

			

				
					
ssm框架详解

				
			

			

				

					12-27
				

			

		

		

			
				
详解spring mvc ，mybatis，深入spring数据库事务机制，通过spring介绍redis，以抢红包介绍并发与所。

			
		

	





	

		

			

				
					
springmvc ssm demo 例子

				
			

			

				

					05-03
				

			

		

		

			
				
【SpringMVC与SSM整合详解】  SpringMVC、Spring和MyBatis是Java开发中常用的三大框架，它们各自在Web应用中承担着不同的职责。SpringMVC作为控制器，负责处理HTTP请求，Spring则作为服务层，管理对象的依赖关系和...

			
		

	





	

		

			

				
					
SpringMVC+Mybatis,CRM系统教程和源代码（SSM项目）

				
			

			

				

					04-10
				

			

		

		

			
				
**SpringMVC+Mybatis,CRM系统教程与源代码详解**  在现代企业信息化管理中，客户关系管理系统（CRM）扮演着至关重要的角色。本教程将深入讲解如何利用SpringMVC和Mybatis两大主流技术框架构建一个完整的CRM系统，...

			
		

	





	

		

			

				
					
Spring+SpringMVC+Mybatis SSM三大框架的运行流程、原理、核心技术详解

				
			

			

				

					11-26
				

			

		

		

			
				
Spring+SpringMVC+Mybatis SSM三大框架的运行流程、原理、核心技术详解 理解很透彻， 入门五星推荐

			
		

	





	

		

			

				
					
SSM框架之SpringMVC超详解

				
			

			

				

					qq_52397731的博客
				

				

					11-30
					
					1294
					
				

			

		

		

			
				
SpringMVC框架
SpringMVC第一天



			
		

	





	

		

			

				
					
SSM框架系列之SpringMVC 超详解

				
			

			

				

					JAVA此路漫漫的博客
				

				

					06-17
					
					344
					
				

			

		

		

			
				
三、SpringMVC
3.1 概念
SpringMVC是Spring框架的一个模块，Spring和SpringMVC无需中间整合层整合，SpringMVC是一个基于mvc的web框架。
3.2 MVC设计模式
MVC设计模式是一种通用的软件编程思想，在MVC设计模式中认为, 任何软件都可以分为三部分组成：
(1)控制器（Controller）：控制程序流转。
(2)模型（Model）：封装数据处理数据。
(3)视图（view）：负责展示数据。
并且在MVC设计思想中要求一个符合MVC设计思想的软件应该保证

			
		

	





	

		

			

				
					
springmvc中的ssm

				
			

			

				

					peate55的博客
				

				

					03-23
					
					356
					
				

			

		

		

			
				
- 1.引入框架（其实就是放jar包) 
  spring+springMVC(3个)+mybaits(3个)- 2.编写spring-config.xml主配置文件 
   - 2.1.编写专门处理数据连接池的配置文件spring-db.xml<!-- 数据连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPoole

			
		

	





	

		

			

				
					
Spring MVC详解（转）

				
			

			

				

					朱塔山的博客
				

				

					06-26
					
					1万+
					
				

			

		

		

			
				
1.1介绍Spring MVC是Spring Framework提供的Web组件，全称是Spring Web MVC,是目前主流的实现MVC设计模式的框架，提供前端路由映射、视图解析等功能Java Web开发者必须要掌握的技术框架1.2MVC是什么MVC是一种软件架构思想，把软件按照模型，视图，控制器来划分Model:模型层，指工程中的JavaBean，用来处理数据JavaBean分成两类：一类称为实体类Bean:专门用来存储业务数据，比如Student,User。

			
		

	





	

		

			

				
					
SpringMVC详解

				
			

			

				

					互联网底层民工的博客
				

				

					07-14
					
					1万+
					
				

			

		

		

			
				
SpringMVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级web框架，通过把Model，View，Controller分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分。简化开发，减少出错，方便组内开发人员之间的配合。
他通过一套注解，让一个简单的Java类成为处理请求的控制器，而无需实现任何接口。同时它还支持Restful编程风格的请求。

			
		

	





	

		

			

				
					
超详细讲解SpringMVC三层架构

					
热门推荐

				
			

			

				

					m0_59234718的博客
				

				

					12-06
					
					1万+
					
				

			

		

		

			
				
SpringMVC三层架构

Java SpringMVC的工程结构一般来说分为三层，自下而上是Modle层（模型，数据访问层）、Cotroller层（控制，逻辑控制层）、View层（视图，页面显示层），其中Modle层分为两层：dao层、service层，MVC架构分层的主要作用是解耦。采用分层架构的好处，普遍接受的是系统分层有利于系统的维护，系统的扩展。就是增强系统的可维护性和可扩展性。

对于Spring这样的框架，（View\Web）表示层调用控制层（Controller），控制层调用业务层（Ser

			
		

	





	

		

			

				
					
SpringMVC全套详解

				
			

			

				

					Original0的博客
				

				

					06-25
					
					7220
					
				

			

		

		

			
				
表示应用程序中的数据和业务逻辑。在Spring MVC中，通常使用POJO（Plain Old Java Object）作为模型对象。通常模型对象负责在数据库中存取数据。负责展示用户界面，通常是HTML页面、JSON响应或其他类型的视觉呈现。视图负责将模型数据渲染，并向用户呈现。接收并处理HTTP请求，并根据请求的内容选择相应的处理方法。控制器负责调度适当的业务逻辑，操作模型数据，并通过相应的视图返回响应结果。

			
		

	





	

		

			

				
					
qfedu三段SSM的整合

				
			

			

				

					03-07
				

			

		

		

			
				
qfedu三段SSM的整合

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  





	
打赏作者

	

		

		
			
		
		

		

			
Ja kar ta

			
你的鼓励将是我创作的最大动力

		

	

	

			

	

	

    ¥1
    ¥2
    ¥4
    ¥6
    ¥10
    ¥20
	

	

		

			

				

					扫码支付：¥1
				

				

					

					
					获取中
					

				

				

					
					
					扫码支付
				

			

		

		

			
您的余额不足，请更换扫码支付或充值

			
打赏作者

		

	



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值