2020.11.10，SpringMVC

请使用80%的时间打好扎实的基础，剩下18%的时间研究框架，2%的时间去学点英文，框架的官方文档永远是最好的教程。

spring4.3.25

MVC框架：

1，提供了模型-视图-控制的结构和可以用来开发灵活，松耦合的web应用程序的组件。

2，**模型：**封装了应用程序数据，并且通常他们由POJO组成。

3，**视图：**主要用于呈现模型数据

静态资源过滤问题

<build>
   <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>

1,Servlet

目标：写一个servlet程序，回顾servlet

1.1，导入jar包

junit

spring-webmvc

servlet-api

jsp-api

jstl

<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

<!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

<!-- https://mvnrepository.com/artifact/javax.servlet.jsp/jsp-api -->
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.2</version>
    <scope>provided</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet/servlet-api -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
    <scope>provided</scope>
</dependency>

MVC框架要做那些事情

1，将url映射到java类或者java类的方法

2，封装用户提交的数据

3，处理请求–调用相关的业务处理–封装响应数据

4，将响应的数据进行渲染，jsp/html等表示层数据

2,helloSpring

2.1，使用xml配置文件

1，web.xml写配置

2，sprngmvc-controller.xml,写配置

3，Controller.class

可能遇到的问题：

404：

查看控制台输出，看一下是不是缺少了什么jar包。
如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖！
重启Tomcat 即可解决！

2,DispatcherServlet解析

DispatcherServlet:表示为前端控制器，职责是：分发请求

http://localhost:8080/hello

分解url：

1，http://locahost:8080服务器域名

springmvc部署在服务器上的web站点

/hello表示为控制器

所以url的意思可以理解为：请求位于服务器locahost：8080上的springmvc站点的hello控制器

使用注意：

1，启动级别为1：表示服务器启动时它就启动

2，

2.2,，使用注解开发

步骤：

1，编写web.xml

2，创建Controller类

3，新建springmvc-servlet.xml

具体实现过程：

1，注册DispatcherServlet

2，添加注解@Controller，@RequestMappering

3，开启扫描注解包context:componet-scan

注意点:

1，

@RequestMapping("/h1")
加/和不加/的区别

2，@RequestMapping

@RequestMapping注解用于映射url到控制器类或者一个特定的待处理程序方法。可用于了类或者方法上。用于类上，表示类中的所有响应请求大的方法都是以该地址作为父路径。

1，注解在方法上

http://localhost:8080/h1只用加上注解名即可

2，同时注解类和方法

http://localhost:8080/admin/h1所以是类注解加方法注解

3,使用注解开发

实现步骤：

前提：创建项目，导入依赖，添加web，在项目结构Artifacts中添加lib导入依赖。

1，实现web.xml

2,实现spring配置文件：springmvc-servlet.xml

3，写Controller类

3.1，

web.xml

<?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">
    <!--1.注册DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个springmvc的配置文件:【servlet-name】-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别-1-->
        <!-- 启动顺序，数字越小，启动越早 -->
        <load-on-startup>1</load-on-startup>
    </servlet>


    <!--/ 匹配所有的请求；（不包括.jsp）-->
    <!--/* 匹配所有的请求；（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

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

    <!--<添加处理映射器-->
   <!-- <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    &lt;!&ndash;<添加处理适配器&ndash;&gt;
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>-->
    <!--视图解析器:DispatcherServlet给他的ModelAndView
    1，获得了modelandView的数据
    2，解析modelandView的视图的名字
    3，拼接视图的名字，找到对应的试图：/WEB-INF/jsp/hello.jsp
    4，将数据渲染到这个视图上
    -->
    <!--开启扫描注解包-->
    <context:component-scan base-package="com.zp.controller"/>
    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <!-- 让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler />
    <!--
    支持mvc注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系
        要想使@RequestMapping注解生效
        必须向上下文中注册DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
     -->
    <mvc:annotation-driven />

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

小结：

1，可以发现，我们的两个请求都可以指向一个视图，但是页面结果的结果是不一样的，从这里可以看出视图是被复用的，而控制器与视图之间是弱偶合关系。

这里解释一下，是因为两个方法名不一样，但是请求路径和参数一样，所以会显示url一样，但是实际上却是两个不一样的方法。

4 ，ResFul风格

概念：

会改变url风格

RestFul就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存机制。

功能：

资源：互联网所有的事物都可以被抽象为资源

资源操作：使用POST,DELETE,PUT,GET,使用不同的方法资源对资源进行操作。

分别对应添加，删除，修改，查询

传统方式操作资源：

通过不同的参数老实现不同的效果！方法单一，post，get

使用RESTFUL操作资源：

可以使用不同的请求方式来实现，不同的效果，

就是请求地址一样，但是功能可以不一样！

测试：

实现：就是在对映的类中填写对应的注解

1，在对应的类的方法的参数中写@PathVariable（地址传值）

使用路径变量的好处：

1，使路径变得更加简洁

2，获得参数更加方便，框架会自动进行类型转换

3，通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问的路径是/commit/1/a，则路径与方法参数不匹配，而不会是参数转换失败

报错：400

2.2，使用method属性指定请求类型

用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如GET，POST，PUT。等

测试：

1，增加一个方法，请求为POST

2，我们使用浏览器地址栏进行访问默认是Get请求，会报错405：

小结

springmvc的@RequestMapping注解能够处理HTTP请求的方法：POST，GET，PUT，DELETE，以及PATCH。

所有的地址栏请求迷人都会是HTTP GET类型的。

方法级别的注解变体有如下几个：组合注解：

@GetMapping

@PostMapping

@PutMapping

@DeleteMapping

@PatchMapping

@GetMapping 是一个组合注解，平时使用的会比较多！

相当于：@RequestMapping（method=RequestMethod.GET）的一个快捷方式。

优点：

1，简洁

2，支持缓存

3，安全：在地址栏中别人无法知道你传递的参数是什么意思

扩展：小黄鸭调试法

场景1：我们都有过向别人，（甚至可能向完全不会编程的人）提问及解释编程问题的经历，但是很多时候就在我们自己解释的过程中却想到了问题的解决方案

场景2：你的同行跑来问你一个问题，但是当他吧问题说完，或者说到一半的时候就相处答案了。

这就是所谓的小黄鸭调试法（Rubber Duck Debuging)

5，数据处理及跳转

乱码过滤器

<filter>
    <filter-name>encoding</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>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

5.1,跳转方式

转发和重定向

转发：url不会发生变化

重定向：url会发生变化

1，ModleAndView

准备条件：视图解析器，然后是继承Controller接口，复写它的方法，返回值就是ModleAndView类型。

下面是我粘贴的内容：

设置ModelAndView对象 , 根据view的名称 , 和视图解析器跳到指定的页面 .

页面 : {视图解析器前缀} + viewName +{视图解析器后缀}

之前写过，就懒的重复了

2，ServletApi

准备：不需要视图解析器

1，通过HttpServletResponse进行输出

2，通过HttpServletResponse进行重定向

3，通过HttpServletResponse进行转发

package com.zp.controller;

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

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Controller
public class ResultGo {
    
    
    //ServletApi:输出
    @RequestMapping("/result/h1")
    public void test1(HttpServletRequest req , HttpServletResponse rsp) throws IOException {
    
    
        rsp.getWriter().print("Hello,Spring BY servlet API!");
    }
    //ServletApi:重定向
    @RequestMapping("/result/h2")
    public void test2(HttpServletRequest req , HttpServletResponse rsp) throws IOException {
    
    
        rsp.sendRedirect("/index.jsp");
    }
    //ServletApi:转发
    @RequestMapping("/result/h3")
    public void test3(HttpServletRequest req , HttpServletResponse rsp) throws IOException, ServletException {
    
    
        req.setAttribute("msg","/result/h3");
        req.getRequestDispatcher("/WEB-INF/jsp/hello.jsp").forward(req,rsp);
    }
}

3**,SpringMVC**

没有视图解析器的情况

准备工作：把视图解析器注释掉：

否则：报错：404 /WEB-INF/jsp//index.jsp.jsp

通过SpringMVC来实现转发和重定向

package com.zp.controller;

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

@Controller
public class ResultSpringMVC {
    
    
    //转发
    @RequestMapping("rsm/t1")
    public String test1(){
    
    
        return "/index.jsp";
    }
    //转发2
    @RequestMapping("rsm/t2")
    public String test2(){
    
    
        return "forward:/index.jsp";
    }
    //重定向
    @RequestMapping("rsm/t3")
    public String test3(){
    
    
        return "redirect:/index.jsp";
    }
}

3.2，有视图解析器的情况

注意点就是：

重定向是不需要视图解析器的，本质就是重新请求一个新的地方。

同时：可以重定向到另一个请求实现;没有实现，懒得弄了

package com.zp.controller;

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

@Controller
//有视图解析器的情况
public class ResultSpringMVC2 {
    
    
    //转发
    @RequestMapping("rsm2/t1")
    public String test1(){
    
    
        return "hello";
    }
    //重定向
    @RequestMapping("rsm2/t2")
    public String test2(){
    
    
        return "redirect:/index.jsp";
         //重定向到另一个请求。没实现，不想弄了
   //     return "redirect:/rsm2/t1";
    }
}

5.2，数据处理

就是处理提交数据

package com.zp.controller;

import com.zp.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class ResultData {
    
    
    //1,提交的域名和方法的参数名一样
    @RequestMapping("/hello")
    public String test1(String name){
    
    
        System.out.println(name);
        return "hello";
    }
    //2，提交的域名和方法的参数名不一样
    //http://localhost:8080/hello2?username=zp
    @RequestMapping("/hello2")
    public String test2(@RequestParam("username") String name){
    
    
        System.out.println(name);
        return "hello";
    }
    //3，提交的是一个对象
    //http://localhost:8080/hello3?name=zp&age=18&id=1
    @RequestMapping("/hello3")
    public String test3(User user) {
    
    
        System.out.println(user);
        return "hello";
    }
    }

**注意：**如果传递的值是一个对象，注意前端传递的参数名和对象名要一样

5.3，数据显示到前端

**问题：**model和modle的区别:

1，通过ModelAndViewl

一直都是如此，就不解释了

2，通过ModelMap

3，通过Model

package com.zp.controller;

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

@Controller
public class Modle {
    
    
    //通过ModleMap
    @RequestMapping("/Modle/hello")
    public String test1(@RequestParam("username") String name, ModelMap model){
    
    
        //封装视图所需要的数据
        model.addAttribute("name",name);
        System.out.println(name);
        return "hello";
    }
    //通过Modle
    @RequestMapping("/Modle/hello2")
    public String test2(@RequestParam("username") String name, Model model){
    
    
        //封装视图所需要的数据
        model.addAttribute("msg",name);
        System.out.println(name);
        return "hello";
    }
    //ModleMap比Modle的方法多
}

对比：

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；
 
ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；
 
ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

5.4，乱码问题

实现步骤：

1，index中写一个表单

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  $END$index2
  <form action="/e/t" method="post">
    <input type="text" name="name">
    <input type="submit">
  </form>
  </body>
</html>

2,写后台控制类

package com.zp.controller;

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

@Controller
public class Encoding {
    
    
    @RequestMapping("/e/t")
    public String test(Model model,String name){
    
    
        model.addAttribute("msg",name);//获取表达提交的值
        //如果获取的是中文，会出现乱码情况
        return "test";//跳转到test页面，显示获取的值
    }
}

3,测试

在表单中写入中文，就会报乱码

4，解决方法：

1，在springmvc-servlet.xml中加入乱码过滤器

<!--乱码过滤器-->
<filter>
        <filter-name>encoding</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>

2，在某些情况下乱码资源过滤器可能无法起到预期的效果；

修改Tomcat配置文件：设置编码

备注：没有试过

<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />

3，自定义过滤器

package com.kuang.filter;
 
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;
 
/**
 * 解决get和post请求 全部乱码的过滤器
 */
public class GenericEncodingFilter implements Filter {
    
    
 
    @Override
    public void destroy() {
    
    
    }
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    
    
        //处理response的字符编码
        HttpServletResponse myResponse=(HttpServletResponse) response;
        myResponse.setContentType("text/html;charset=UTF-8");
 
        // 转型为与协议相关对象
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 对request包装增强
        HttpServletRequest myrequest = new MyRequest(httpServletRequest);
        chain.doFilter(myrequest, response);
    }
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    
    
    }
 
}
 
//自定义request对象，HttpServletRequest的包装类
class MyRequest extends HttpServletRequestWrapper {
    
    
 
    private HttpServletRequest request;
    //是否编码的标记
    private boolean hasEncode;
    //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
    public MyRequest(HttpServletRequest request) {
    
    
        super(request);// super必须写
        this.request = request;
    }
 
    // 对需要增强方法 进行覆盖
    @Override
    public Map getParameterMap() {
    
    
        // 先获得请求方式
        String method = request.getMethod();
        if (method.equalsIgnoreCase("post")) {
    
    
            // post请求
            try {
    
    
                // 处理post乱码
                request.setCharacterEncoding("utf-8");
                return request.getParameterMap();
            } catch (UnsupportedEncodingException e) {
    
    
                e.printStackTrace();
            }
        } else if (method.equalsIgnoreCase("get")) {
    
    
            // get请求
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (!hasEncode) {
    
     // 确保get手动编码逻辑只运行一次
                for (String parameterName : parameterMap.keySet()) {
    
    
                    String[] values = parameterMap.get(parameterName);
                    if (values != null) {
    
    
                        for (int i = 0; i < values.length; i++) {
    
    
                            try {
    
    
                                // 处理get乱码
                                values[i] = new String(values[i]
                                        .getBytes("ISO-8859-1"), "utf-8");
                            } catch (UnsupportedEncodingException e) {
    
    
                                e.printStackTrace();
                            }
                        }
                    }
                }
                hasEncode = true;
            }
            return parameterMap;
        }
        return super.getParameterMap();
    }
 
    //取一个值
    @Override
    public String getParameter(String name) {
    
    
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        if (values == null) {
    
    
            return null;
        }
        return values[0]; // 取回参数的第一个值
    }
 
    //取所有值
    @Override
    public String[] getParameterValues(String name) {
    
    
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        return values;
    }
}

最后说明：

基本上在web.xml中配置这个过滤器即可！

乱码问题，需要平时多注意，在尽可能能设置编码的地方，都设置为统一编码 UTF-8！

6，ssm的简单整合

1，分层实现

1,mybatis层

· 数据库sql语句

· 导入项目所需依赖，以及maven静态资源过滤

· 创建pojo：写实体类，dao：写数据库调用，controller，service：调用dao层

· 创建mybatis-config.xml：mybatis的配置文件，别名和映射注册，

applicationContext.xml：，

db.properties：写数据库的基本配置，8.0+需要添加一个时区配置

2，spring层

· spring-dao.xml：关联数据库配置文件（db.properties），连接池，SqlSessionFactory（SqlSessionFactoryBean），配置dao接口扫描包（动态实现dao接口注入到spring容器中）（MapperScanerConfigurer）

· spring-service.xml：扫描包，注入spring容器实现bean注册，声明式事务（配置事务管理器）（DataSourceTransactionManager），aop事务支持（织入）

3，springMVC层

web.xml：DispatcherServlet（前端控制器Servlet，DispatcherServlet），filter（乱码过滤器）（CharacterEncodingFilter）

spring-mvc：注解驱动，静态资源过滤，扫描包，视图解析器（InternalResourceViewResolver）

controller：

4，测试并加入日志

1，测试CRUD是否正常

2，加入日志功能，（标准日志）

5，前端页面

1，首先是首页

2，与controller配合编写

**注意点：**spring的配置文件之间要存在一种关系，applicatonContext.xml

6,新增一个功能

1，首先想到的是aop，切入实现

2，实现过程：

1，pom.xml：导入依赖

lombok,junit,mybatis,spring-mybits,servlet-api,jsp-spi,spring-webmvc,jstl,mysql

2,添加web，sql代码

3，xml配置文件

1，spring-dao.xml：实现数据池连接，自动注入

2，spring-service.xml：Bean注入，事物管理

3，spring-mvc.xml：扫描包，静态资源过滤，注解驱动，视图解析器

4，mybatis-config.xml：mapper映射，别名

5，db.properties：数据库优化

6，applicationContext.xml：引用配置文件

7，web.xml：springmvc过滤器，前端控制器

4，java层

1,dao：写mapper及sql

2,pojo：写实体类

3,controller：写控制器

4,service：服务层

5，写前端页面

1，index.jsp：首页

2，jsp包下（WEB-INF）下，安全性

· addBook.jsp：增加

· allBook：查询所有

· update：修改

3，具体代码

7，JSON

json就是js对象的字符串形式

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>json-测试</title>
</head>
<body>
<script type="text/javascript">
    <!--编写一个js对象-->
    var user={
     
     
        name:"zp",
        age:"18",
        sex:"男"
    };
//    将js对象转化为json字符串
    var str=JSON.stringify(user);
    console.log(str);

//    将json字符串转化为js对象
    var user2=JSON.parse(str);
    console.log(user2.name,user2.age,user2.sex);
</script>

</body>
</html>

Controller返回JSON数据

Jackson应该是目前比较好的json解析工具

还有fastjson

导入Jackson依赖

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.8</version>
</dependency>

controller

@Controller
public class UserController {
    
    
    //produces:指定响应体和返回编码
    @RequestMapping(value = "/json-1",produces = "application/jsp;charset=utf-8")
    @ResponseBody
    public String jsontest() throws JsonProcessingException {
    
    
        //1,创建一个jsckson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User("zp",19,"nan");
        //将我们的对象解析成json格式
        String str = mapper.writeValueAsString(user);
        //由于@ResponseBody注解，这里会将str转换成json格式返回
        return "str";
    }

出现乱码问题

//produces:指定响应体返回类型和编码
@RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

乱码统一解决

JSON乱码过滤器

写在：springmvc-servlet.xml

<mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="utf-8"/>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                        <property name="failOnEmptyBeans" value="false"/>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

@RestController相当于@Controller+@ResponseBody两个注解的结合，返回json数据不需要在方法前面加@ResponseBody注解了，但使用@RestController这个注解，就不能返回jsp,html页面，视图解析器无法解析jsp,html页面

 @RequestMapping("/json3")
    public String json3()throws JsonProcessingException{
    
    
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象，java.util.Date
        Date date = new Date();
        //将我们的对象解析成json格式
        String str = mapper.writeValueAsString(date);

        return str;

    }

默认日期格式会变成一个数字，是1970年1月1日到当前日期的毫秒数！

Jackson 默认是会把时间转成timestamps形式

解决方案：取消timestamps形式，自定义时间格式

@RequestMapping("/json4")
    public String json4() throws JsonProcessingException {
      
      
        ObjectMapper mapper = new ObjectMapper();
        //不使用时间戳的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        //自定义日期格式
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //指定日期格式
        mapper.setDateFormat(format);
        Date date = new Date();
        String str = mapper.writeValueAsString(date);
        return str;
    }
//输出："2020-11-27 10:32:53"

如果要经常使用的话，这样是比较麻烦的，我们可以将这些代码封装到一个工具类中；我们去编写下

package com.zp.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;

public class JsonUtils {
      
      
    public static String getJson(Object object) {
      
      
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }

    public static String getJson(Object object,String dateFormat) {
      
      
        ObjectMapper mapper = new ObjectMapper();
        //不使用时间差的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        //自定义日期格式对象
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        //指定日期格式
        mapper.setDateFormat(sdf);
        try {
      
      
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
      
      
            e.printStackTrace();
        }
        return null;
    }
}

使用

 @RequestMapping("/json5")
    public String json5()throws JsonProcessingException{
      
      
        Date date = new Date();
        String json = JsonUtils.getJson(date);
        return json;
    }

FastJson

fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json的转换方法很多，最后的实现结果都是一样的。

fastjson 的 pom依赖！

 <!--FastJson依赖-->
       <dependency>
           <groupId>com.alibaba</groupId>
           <artifactId>fastjson</artifactId>
           <version>1.2.60</version>
       </dependency>

fastjson 三个主要的类：

JSONObject 代表 json 对象

JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。
JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。

JSONArray 代表 json 对象数组

内部是有List接口中的方法来完成操作的。

JSON代表 JSONObject和JSONArray的转化

JSON类源码分析与使用
仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。

代码测试，我们新建一个FastJsonDemo 类

package com.zp.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.zp.pojo.User;

import java.util.ArrayList;
import java.util.List;

public class FastJsonDemo {
      
      
    public static void main(String[] args) {
      
      
        User user1 = new User("zp1",19,"nan");
        User user2 = new User("zp2",19,"nan");
        User user3 = new User("zp2",19,"nan");
        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        System.out.println("==============java对象===========");
        for (User user : list) {
      
      
            System.out.println(user);
        }
        System.out.println("***************java对象转json字符串**********");
        String str1 = JSON.toJSONString(list);
        System.err.println("JSON.toJSONString------->"+str1);
        String str2 = JSON.toJSONString(user1);
        System.err.println("JSON.toJSONString------->"+str2);

        System.out.println("\n***************json字符串转java对象**********");
        User user = JSON.parseObject(str2, User.class);
        System.out.println("JSON.parseObject(str2, User.class)---->"+user);

        System.out.println("\n***************java对象转json对象**********");
        JSONObject toJSON = (JSONObject) JSON.toJSON(user2);
        System.err.println("(JSONObject) JSON.toJSON(user2)---->"+toJSON);

        System.out.println("\n***************json对象转java对象**********");
        User toJavaObject = JSON.toJavaObject(toJSON, User.class);
        System.out.println("JSON.toJavaObject(toJSON, User.class)--------->"+toJavaObject);
    }
}

输出

com.zp.controller.FastJsonDemo
==============java对象===========
User(name=zp1, age=19, sex=nan)
User(name=zp2, age=19, sex=nan)
User(name=zp2, age=19, sex=nan)
***************java对象转json字符串**********

JSON.toJSONString------->[{
      
      "age":19,"name":"zp1","sex":"nan"},{
      
      "age":19,"name":"zp2","sex":"nan"},{
      
      "age":19,"name":"zp2","sex":"nan"}]
***************json字符串转java对象**********
JSON.toJSONString------->{
      
      "age":19,"name":"zp1","sex":"nan"}
JSON.parseObject(str2, User.class)---->User(name=zp1, age=19, sex=nan)
(JSONObject) JSON.toJSON(user2)---->{
      
      "sex":"nan","name":"zp2","age":19}

***************java对象转json对象**********

***************json对象转java对象**********
JSON.toJavaObject(toJSON, User.class)--------->User(name=zp2, age=19, sex=nan)

Process finished with exit code 0

注意
这种工具类，我们只需要掌握使用就好了，在使用的时候在根据具体的业务去找对应的实现。和以前的commons-io那种工具包一样，拿来用就好了！

8，AJAX

//javascript有个不成文的规则，值提前获取

1，简介

AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。
AJAX 是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。
Ajax 不是一种新的编程语言，而是一种用于创建更好更快以及交互性更强的Web应用程序的技术。
在 2005 年，Google 通过其 Google Suggest 使 AJAX 变得流行起来。Google Suggest能够自动帮你完成搜索单词。
Google Suggest 使用 AJAX 创造出动态性极强的 web 界面：当您在谷歌的搜索框输入关键字时，JavaScript 会把这些字符发送到服务器，然后服务器会返回一个搜索建议的列表。
就和国内百度的搜索框一样!
传统的网页(即不用ajax技术的网页)，想要更新内容或者提交一个表单，都需要重新加载整个网页。
使用ajax技术的网页，通过在后台服务器进行少量的数据交换，就可以实现异步局部更新。
使用Ajax，用户可以创建接近本地桌面应用的直接、高可用、更丰富、更动态的Web用户界面。

2，伪造Ajax

我们可以使用前端的一个标签来伪造一个ajax的样子。iframe标签

1、新建一个module ：sspringmvc-06-ajax ，导入web支持！

2、编写一个 ajax-frame.html 使用 iframe 测试，感受下效果

利用AJAX可以做：

注册时，输入用户名自动检测用户是否已经存在。
登陆时，提示用户名密码错误
删除数据行时，将行ID发送到后台，后台在数据库中删除，数据库删除成功后，在页面DOM中将数据行也删除。
…等等

3,jQuery.ajax

纯JS原生实现Ajax我们不去讲解这里，直接使用jquery提供的，方便学习和使用，避免重复造轮子，有兴趣的同学可以去了解下JS原生XMLHttpRequest ！

Ajax的核心是XMLHttpRequest对象(XHR)。XHR为向服务器发送请求和解析服务器响应提供了接口。能够以异步方式从服务器获取新数据。

jQuery 提供多个与 AJAX 有关的方法。

通过 jQuery AJAX 方法，您能够使用 HTTP Get 和 HTTP Post 从远程服务器上请求文本、HTML、XML 或 JSON – 同时您能够把这些外部数据直接载入网页的被选元素中。

jQuery 不是生产者，而是大自然搬运工。

jQuery Ajax本质就是 XMLHttpRequest，对他进行了封装，方便调用！

jQuery.ajax(...)
      部分参数：
            url：请求地址
            type：请求方式，GET、POST（1.9.0之后用method）
        headers：请求头
            data：要发送的数据
    contentType：即将发送信息至服务器的内容编码类型(默认: "application/x-www-form-urlencoded; charset=UTF-8")
          async：是否异步
        timeout：设置请求超时时间（毫秒）
      beforeSend：发送请求前执行的函数(全局)
        complete：完成之后执行的回调函数(全局)
        success：成功之后执行的回调函数(全局)
          error：失败之后执行的回调函数(全局)
        accepts：通过请求头发送给服务器，告诉服务器当前客户端可接受的数据类型
        dataType：将服务器端返回的数据转换成指定类型
          "xml": 将服务器端返回的内容转换成xml格式
          "text": 将服务器端返回的内容转换成普通文本格式
          "html": 将服务器端返回的内容转换成普通文本格式，在插入DOM中时，如果包含JavaScript标签，则会尝试去执行。
        "script": 尝试将返回值当作JavaScript去执行，然后再将服务器端返回的内容转换成普通文本格式
          "json": 将服务器端返回的内容转换成相应的JavaScript对象
        "jsonp": JSONP 格式使用 JSONP 形式调用函数时，如 "myurl?callback=?" jQuery 将自动替换 ? 为正确的函数名，以执行回调函数

3、导入jquery ，可以使用在线的CDN ，也可以下载导入

<script src="https://code.jquery.com/jquery-3.1.1.min.js"></script>
    <script src="${pageContext.request.contextPath}/static/jsp/jquery-3.5.1.min.js"></script>

ajax运行原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dT9VeojG-1606875339577)(C:\Users\zp\AppData\Roaming\Typora\typora-user-images\image-20201127161352124.png)]

9，拦截器+文件上传和下载

概述

SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理。开发者可以自己定义一些拦截器来实现特定的功能。

**过滤器与拦截器的区别：**拦截器是AOP思想的具体应用。

过滤器

servlet规范中的一部分，任何java web工程都可以使用
在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

拦截器

拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用
拦截器只会拦截访问的控制器方法，如果访问的是jsp/html/css/image/js是不会进行拦截的

自定义拦截器

那如何实现拦截器呢？

想要自定义拦截器，必须实现 HandlerInterceptor 接口。

1、新建一个Moudule ， springmvc-07-Interceptor ，添加web支持

2、配置web.xml 和 springmvc-servlet.xml 文件

3、编写一个拦截器

1,先测试环境是否正常

web.xml

<?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">
    <!--1,注册servlet-->
    <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>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--所有的请求都会被spring拦截-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <!--2，资源过滤器-->
    <filter>
        <filter-name>encoding</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>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

springmvc-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:comtext="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">

    <!--1,自定一定扫描的包，下面所有注解类交给IOC容器管理-->
    <comtext:component-scan base-package="com.zp.controller"/>
    <mvc:annotation-driven/>
    <mvc:default-servlet-handler/>
    <!--2,视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--3,乱码过滤器-->
    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="utf-8"/>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                        <property name="failOnEmptyBeans" value="false"/>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>
    <!--4，mvc拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--
            1,/**:拦截，所有路径，包括子路径
            2，admin/*:只会拦截admin/的一层子路径
            3，admin/**:拦截admin/的多有路径
            -->
            <mvc:mapping path="/**"/>
            <!--bean:配置的就是拦截器-->
            <bean class="com.zp.config.Interceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

</beans>

testController

package com.zp.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class testController {
    @GetMapping("/t1")
    public String test(){
        System.out.println("测试成功，执行完毕");
        return "OK";
    }

}

2,拦截器测试

1,web.xml

<?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">
    <!--1,注册servlet-->
    <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>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--所有的请求都会被spring拦截-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <!--2，资源过滤器-->
    <filter>
        <filter-name>encoding</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>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

2,springmvc-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:comtext="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">

    <!--1,自定一定扫描的包，下面所有注解类交给IOC容器管理-->
    <comtext:component-scan base-package="com.zp.controller"/>
    <mvc:annotation-driven/>
    <mvc:default-servlet-handler/>
    <!--2,视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--3,乱码过滤器-->
    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="utf-8"/>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                        <property name="failOnEmptyBeans" value="false"/>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>
    <!--4，mvc拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--
            1,/**:拦截，所有路径，包括子路径
            2，admin/*:只会拦截admin/的一层子路径
            3，admin/**:拦截admin/的多有路径
            -->
            <mvc:mapping path="/**"/>
            <!--bean:配置的就是拦截器-->
            <bean class="com.zp.config.Interceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

</beans>

3,编写一个拦截器

package com.zp.config;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

//在请求处理的方法之前执行
//如果为ture，就是放行，拦截结束或者执行下一个拦截器
public class Interceptor implements HandlerInterceptor {
      
      
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
      
      
        System.out.println("==============处理前===================");
        return true;
    }
  //  在请求处理的方法之后执行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
      
      
        System.out.println("==============处理后===================");

    }
//在dispatcherservlet执行之后执行，做清理工作
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
      
      
        System.out.println("==============清理===================");

    }
}

4,在springmvc的配置文件中配置拦截器

<!--关于拦截器的配置-->
<mvc:interceptors>
   <mvc:interceptor>
       <!--/** 包括路径及其子路径-->
       <!--/admin/* 拦截的是/admin/add等等这种 , /admin/add/user不会被拦截-->
       <!--/admin/** 拦截的是/admin/下的所有-->
       <mvc:mapping path="/**"/>
       <!--bean配置的就是拦截器-->
       <bean class="com.kuang.interceptor.MyInterceptor"/>
   </mvc:interceptor>
</mvc:interceptors>

5、编写一个Controller，接收请求

package com.zp.controller;

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

@Controller
public class intercepoterController {
    @RequestMapping("/t2")
    @ResponseBody
    //@ResponseBody的作用其实是将java对象转为json格式的数据
    public String test2(){
        System.out.println("控制器中的方法执行了！");
        return "Hello";
    }
}

6,前端界面，index.jsp

 <a href="${pageContext.request.contextPath}/t2">拦截器测试</a>

7,启动，测试

3，登录验证测试

1,web.xml

2，springmvc-servlet.xml

3,userController:控制层的编写

package com.zp.controller;

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

import javax.servlet.http.HttpSession;

@Controller
@RequestMapping("/user")
public class userController {
      
      
    //跳转到登录界面
    @RequestMapping("/jumpLogin")
    public String jumpLogin()throws Exception{
      
      
        return "login";
    }
    //跳转到成功界面
    @RequestMapping("/jumpSuccess")
    public String jumpSuccess()throws Exception{
      
      
        return "success";
    }
    //登陆提交
    @RequestMapping("/login")
    public String login(HttpSession session, String username, String pwd)throws Exception{
      
      
        System.out.println("接收前端信息---》"+username);
        session.setAttribute("user",username);
        return "success";
    }
    //退出登录
    @RequestMapping("/logout")
    public String logout(HttpSession session)throws Exception{
      
      
        //两种方法
        //第一个是直接销毁session
        //第二个是移除
//        session.invalidate();
        session.removeAttribute("user");
        return "login";

    }
}

4,LoginInterceptor：拦截器

package com.zp.config;

import org.springframework.web.servlet.HandlerInterceptor;

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

public class LoginInterceptor implements HandlerInterceptor {
      
      
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
      
      
        //如果是登录界面放行
        System.out.println("url:"+request.getRequestURI());
        if (request.getRequestURI().contains("login"))
        {
      
      
            return true;
        }
        //如果用户自己登录也放行
        HttpSession session = request.getSession();
        if (session.getAttribute("user")!=null){
      
      
            return true;
        }
        //用户没有登录跳转到登录界面
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request,response);
        return false;
    }
}

5，login.jsp，前端登录界面

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

success.jsp:登录成功界面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>登录成功界面</h1>
${user}
<a href="${pageContext.request.contextPath}/user/logout">注销</a>
</body>
</html>

index.jsp：首页

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  <%--<a href="${pageContext.request.contextPath}/t2">拦截器测试</a>--%>
  <h1>首页</h1>
  <a href="${pageContext.request.contextPath}/user/jumpLogin">登录</a>
  <a href="${pageContext.request.contextPath}/user/jumpSuccess">成功界面</a>

  </body>
</html>

13，报错的情况

400：基本是请求有问题

500：基本是代码有问题

在springmvc接受参数的时候，尽量不要使用基本数据类型

1,404

1,是lib包没有写，导入依赖

2，是servlet-mapping：写成/*

3，也有可能是地址传参不正确

**2,**400

· 基本是请求有问题

3,500

**4，**405：

请求方式不一致，我们使用浏览器地址栏进行访问默认是Get请求，会报错405：

4,idea,tomcat使用技巧：如果只是修改了java文件，直接重新加载即可；如果是修改了xml配置文件，需要重新发布项目。修改了xml文件需要重启服务器！

5：

No qualifying bean of type 'com.zp.service.BookService' available

说明:

一般来说就是controller中的自动注入注解名和spring-service.xml中bean注册的不一致

1.看web.xml中是否配置正确（注意classpath：文件命名是否一致。路径是否一致）

2.看applicationContext.xml中是否配置正确
（1）如果在applicationContext.xml中配置的bean，要检查<bean/ >的id是否和@autowired的一样, 《bean》的路径是否和service层一致
（2）如果使用了@service注解，要注意applicatinContext.xml中是否有扫描service的配置 <context:component-scan base-package=“service” /> base-package 就是service包的路径没有这个的话无法获取service bean对象

3.是看自己使用@service是否起了另外的名字，如果没起的话就是一般默认将类名第一个开头的首字母小写，如果是两个或两个以上首字母开头的话bean默认为原类名，无论有没有起另外的名字，都检查一下是否有拼写错误这种低级问题

No bean named ‘booksServiceImpl’ available
思路：
1，以为是和bean：id不一致—>排错后发现没有解决问题

原因是：没有在applicationContext.xml文件中，注册其他xml资源，注册后即可解决问题

2,Mapped Statements collection already contains value for com.zp.dao.BooksMapper.insertBook.
思路：
8，

直接想到去BooksMapper.xml,也就是sql文件中找错误，
原因：在增删改查方法中的id全是insertBook

Could not open ServletContext resource [/db.properties]
思路：可能是db.properties文件出了问题，但是这个只是数据库的配置文件，怎么可能会有问题于是找和
这个文件相关的配置，和mybatis有关的只有spring配置文件
原因：，Tomcat部署项目，src/main/resources目录下的配置文件默认位置为：
{项目名}/WEB-INF/classes，而Spring却在项目根目录下寻找，肯定找不到，
因此，配置时指定classpath目录下寻找即可。
解决方案如下：
　　<context:property-placeholder location=“classpath:db.properties” />
10,

找不到方法：class com.zp.pojo.Books.getdetail()
思路：去Books下去看看，有没有这个get

原因：点开Books，打开Structure，发现，属性是小写开头，但是get方法中确是大写开头

11,

Column ‘detail’ cannot be null
思路：之前碰到过，应该是sql语句的问题

原因：不是sql语句的原因，其实是在jsp页面中表单name属性的值都写成一样的了

12,

修改可以提交，但是数据没有发生修改，无论是前端页面还是数据库本身
思路：事务没有提交，但是增加就可以实现，说明spring事务的自动提交没有出现问题，这里考虑是否加入aop横切

原因：我们修改是根据bookID来的，当跳转到修改页面的时候，我们需要获取一定的数据来作为修改的依据，
但是我们在前端页面用来获取值的参数和后台controller层用来传递值的参数不一致，也就导致了无法获取
到，所以也无法提交
注意点：在表单根据bookID获取值和提交值的时候，我们需要把它设置为隐式

14，常用依赖

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
    </dependency>
    <!--数据库驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    <!-- 数据库连接池 -->
    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.5.2</version>
    </dependency>

    <!--Servlet - JSP -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.2</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>

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

    <!--Spring-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
</dependencies>

15,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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       ">
   
</beans>

<?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>

</configuration>

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

</mapper>

maven资源过滤器

<build>
   <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>

springMVC乱码过滤器

<!--springmvc乱码过滤器-->
    <filter>
        <filter-name>encoding</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>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

16，数据连接池

1，数据连接池

dbcp：半自动化操作，不能自动连接

c3p0：自动化操作（自动化的加载配置文件，并且可以自动设置到对象中）

druid：

hikari：

<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}"/>
        <!--c3p0连接池的私有属性-->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>
        <!--关闭连接后不自动commit-->
        <property name="autoCommitOnClose" value="false"/>
        <!--获取连接超时时间-->
        <property name="checkoutTimeout" value="10000"/>
        <!--获取连接失败重试次数-->
        <property name="acquireRetryAttempts" value="2"/>
    </bean>

2,数据库配置

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?useSSL=true&useUnicode=true&characterEncoding=utf-8
jdbc.userName=root
jdbc.password=123456

17，项目

1，智慧城市项目

2，物联网项目

3，有独立开源项目或参与知名开源项目

4，银行应用软件、金融软件产品开发。

18，待解决问题

1，sqlSessionFactoryBeanName，

19，前端框架

<meta name="viewport" content="width=device-width,initial-scale=1.0">
    <%--引入 Bootstrap，美化界面--%>
    <link href="http://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">

20，前端目标

html

css

js（这是重点）

· 函数：闭包

· Dom

。id，name，tag

。crum

· Bom，

。window

。 document

1,逻辑

判断
循环

2，事件

浏览器事件：window document
Dom事件：增删，遍历，修改节点元素
jQuery
vue

3，视图

html
css
Bootstrap
layui

4，通信

ajax

21，web.xml的基本配置

<?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">
    <!--1,注册servlet-->
    <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>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--所有的请求都会被spring拦截-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <!--2，资源过滤器-->
    <filter>
        <filter-name>encoding</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>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

22.重点

1，mybatis

第一个mybatis程序
ResultMap

2，spring

spring机制
Di
java类配置（springconfig）
代理模式
整合mybatis

3，springmvc

ssm整合
springmvc执行流程
RestFul风格

23，java全栈工程师

后台开发：主打
前端：html，css，js，jquery；
18，待解决问题

1，sqlSessionFactoryBeanName，

19，前端框架

<meta name="viewport" content="width=device-width,initial-scale=1.0">
    <%--引入 Bootstrap，美化界面--%>
    <link href="http://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">

20，前端目标

html

css

js（这是重点）

· 函数：闭包

· Dom

。id，name，tag

。crum

· Bom，

。window

。 document

1,逻辑

判断
循环

2，事件

浏览器事件：window document
Dom事件：增删，遍历，修改节点元素
jQuery
vue

3，视图

html
css
Bootstrap
layui

4，通信

ajax

21，web.xml的基本配置

<?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">
    <!--1,注册servlet-->
    <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>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--所有的请求都会被spring拦截-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <!--2，资源过滤器-->
    <filter>
        <filter-name>encoding</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>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

22.重点

1，mybatis

第一个mybatis程序
ResultMap

2，spring

spring机制
Di
java类配置（springconfig）
代理模式
整合mybatis

3，springmvc

ssm整合
springmvc执行流程
RestFul风格

23，java全栈工程师

后台开发：主打
前端：html，css，js，jquery；
运维：项目发布；服务器如何运行一个项目，linux

SpringMVC学习手册——（狂神说系列)

2020.11.10，SpringMVC

MVC框架：

静态资源过滤问题

1,Servlet

2,helloSpring

2.1，使用xml配置文件

使用注意：

2.2,，使用注解开发

3,使用注解开发

实现步骤：

4 ，ResFul风格

扩展：小黄鸭调试法

5，数据处理及跳转

5.1,跳转方式

5.2，数据处理

5.3，数据显示到前端

5.4，乱码问题

6，ssm的简单整合

1，分层实现

1,mybatis层

2，spring层

3，springMVC层

4，测试并加入日志

5，前端页面

6,新增一个功能

2，实现过程：

3，具体代码

7，JSON

8，AJAX

9，拦截器+文件上传和下载

1,先测试环境是否正常

2,拦截器测试

3，登录验证测试

13，报错的情况

14，常用依赖

15,xml配置文件常用基本模板

16，数据连接池

1，数据连接池

17，项目

18，待解决问题

19，前端框架

20，前端目标

1,逻辑

2，事件

3，视图

4，通信

21，web.xml的基本配置

22.重点

1，mybatis

2，spring

3，springmvc

23，java全栈工程师

19，前端框架

20，前端目标

1,逻辑

2，事件

3，视图

4，通信

21，web.xml的基本配置

22.重点

1，mybatis

2，spring

3，springmvc

23，java全栈工程师

猜你喜欢