SpringMVC

最新推荐文章于 2023-04-25 19:37:05 发布

chensi2113

最新推荐文章于 2023-04-25 19:37:05 发布

阅读量101

点赞数

分类专栏： SpringMVC

本文链接：https://blog.csdn.net/chaochao2113/article/details/119176458

版权

SpringMVC 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

SpringMVC

1Rest风格的URL

1.1什么是rest?

资源在网络中以某种表现形式进行状态转移。URL中只使用名词来定位资源，用HTTP协议里的动词（GET、POST、PUT、DELETE）来实现资源的增删改查操作。

以CRUD为例

新增：/order post

修改：/ordere/1 put update?id=1

获取：/order/1 GET get?id=1

删除：/order/1 DELETE delete?id=1

1.2如何发送PUT请求和DELETE请求呢？

1.需要配置HiddenHttpMethodFilter

2.需要发送POST请求

3.需要在发送POST请求时携带一个name=“_method”的隐藏域，值为DELETE或PUT

1.3在SpringMVC的目标方法中如何得到id呢？

使用@PathVariable 注解

@RequestMapping(value="/testRest/{id}",method=RequestMethod.put)

2视图解析流程分析

2.1SpringMVC流程

（1）用户发送出请求到前端控制器DispatcherServlet。

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

（3）HandlerMapping找到具体的控制器(可查找xml配置或注解配置)，生成处理器对象的执行链(如果有)，再一起返回给DispatcherServlet。

（4）DispatcherServlet调用HandlerAdapter（处理器适配器）。

（5）HandlerAdapter经过适配调用具体的处理器（controller）。

（6）Controller执行完成返回ModelAndView对象。

（7）HandlerAdapter将Controller执行结果ModelAndView返回给DispatcherServlet。

（8）DispatcherServlet将ModelAndView传给ViewReslover（视图解析器）。

（9）ViewReslover解析后返回具体View（视图）。

（10）DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。

（11）DispatcherServlet响应用户。

2.2涉及组件分析

（1）前端控制器DispatcherServlet（不需要程序员开发）,由框架提供，在web.xml中配置。

作用：接收请求，响应结果，相当于转发器，中央处理器。

（2）处理器映射器HandlerMapping(不需要程序员开发),由框架提供。

作用：根据请求的url查找Handler(处理器/Controller)，可以通过XML和注解方式来映射。

（3）处理器适配器HandlerAdapter(不需要程序员开发),由框架提供。

作用：按照特定规则（HandlerAdapter要求的规则）去执行Controller。

（4）控制器Controller(需要工程师开发)

注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler。

作用：接受用户请求信息，调用业务方法处理请求，也称之为后端控制器。

（5）视图解析器ViewResolver(不需要程序员开发),由框架提供

作用：进行视图解析，把逻辑视图名解析成真正的物理视图。

SpringMVC框架支持多种View视图技术，包括：jstlView、freemarkerView、pdfView等。

（6）视图View(需要工程师开发)

作用：把数据展现给用户的页面

View是一个接口，实现类支持不同的View技术（jsp、freemarker、pdf等）

3重定向与转发

3.1forward

请求转发的特点：

1，地址栏路径不变

2，转发只能访问当前服务器下的资源

3，转发是一次请求，可以使用request对象共享数据

3.2redirect的特点

1，地址栏发生变化

2，重定向可以访问其他站点（服务器）的资源

3，重定向是两次请求，不能使用request对象共享数据

4拦截器和过滤器的区别？

4.1过滤器Filter

过滤器，是在java web中将你传入的request,response提前过滤掉一些信息，或者提前设置一些参数，然后再传入Servlet进行业务逻辑处理，比如过滤掉非法url(不是login.do的地址请求，如果用户没有登录都过滤掉),或者再传入Servlet前统一设置字符集，或者去除掉一些非法字符。

过滤器是单例的。在服务器启动时，服务器会创建filter对象，被访问的时候会初始化，只初始化一次，而每一次请求被拦截时，就会执行dofilter方法，多次请求，多次拦截.然后在服务器关闭后，filter对象被销毁，如果服务器正常关闭，则会执行destory方法

4.2拦截器interceptor

拦截器，是面向切面编程（AOP,Aspect Oriented Program）的，就是再你的Service或者一个方法前调用一个方法，或者在方法后调用一个方法，比如动态代理就是拦截器的简单实现，在你调用方法前打印出字符串（或者做其他业务逻辑的操作），也可以在你调用方法后打印字符串，甚至在你抛出异常的时候做业务逻辑的操作。

通俗理解：

（1）过滤器(Filter):当你有一堆东西的时候，你只希望选择符合你要求的某一些东西，定义这些要求的工具，就是过滤器。（理解：就是一堆字母中取出符合要求的）

（2）拦截器（Interceptor）：在一个流程正在进行的时候，你希望干预它的进展，甚至终止它的进行，这就是拦截器做的事请（理解：就是一堆字母中，干预他，通过验证的少点，顺便干点别的东西）

4.3拦截器与过滤器的区别？

区别：

1，拦截器是基于java反射机制的，而过滤器是基于函数的回调。

2，拦截器不依赖servlet容器，而过滤器依赖于servlte容器

3，拦截器只对action请求起作用，而过滤器则可以对几乎所有请求起作用。

4，拦截器可以访问action上下文，值，栈里面的对象，而过滤器不可以。

5，在action的声明周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。

6，拦截器可以获取IOC容器的各个bean，而过滤器不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。

区别:

Spring的拦截器与Servlet的Filter有相似之处，比如二者都是AOP编程思想的体现，都能实现权限检查，日志记录等，不同的是：

**使用范围不同：**Filter是Servlet规定的，只能用于web程序中，而拦截器既要可以用于Web程序，也可以用于Application，Swing程序中。

**规范不同：**Filter是在Servlet规范中定义的，是Servlet容器支持的，而拦截器是在Spring容器内的，是Spring框架支持的。

使用的资源不同：同其他的代码一样，拦截器也是一个Spring的组件，归Spring管理，配置在Spring文件中，因此能使用Spring里的任何资源，对象，例如Service对象，数据源，事务管理等，通过IOC注入到拦截器即可，而Filter则不能。

**深度不同：**Filter在只在Servlet前后起作用，而拦截器能够深入到方法前后，异常抛出前后等，因此拦截器的使用具有很大的弹性，所有Spring框架的程序中，要优先使用拦截器

4.4SpringBoot中过滤器的实现

（1）在启动类里面增加@ServletComponentScan注解进行扫描

@ServletComponentScan

（2）新建一个Filter类，implements Filter,并实现对应的接口，并添加WebFilter注解，标志一个类为filter，被spring进行扫描，urlPatterns拦截规则，支持正则,调用filterChain.doFilter(servletRequest,servletResponse);的方法的调用，来实现是否通过放行，web应用resp.sendRedirect("/index.html")或者返回json字符串。

package net.xdclass.demoproject.filter;

import net.xdclass.demoproject.domain.User;
import net.xdclass.demoproject.service.impl.UserServiceImpl;
import org.springframework.util.StringUtils;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebFilter(urlPatterns = "/api/v1/pri/*", filterName = "loginFilter")
public class LoginFilter implements Filter {

    /**
     * 容器加载的时候
     * @param filterConfig
     * @throws ServletException
     */
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

        System.out.println("init LoginFilter======");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        System.out.println("doFilter LoginFilter======");

        HttpServletRequest req = (HttpServletRequest) servletRequest;

        HttpServletResponse resp = (HttpServletResponse) servletResponse;


        String token = req.getHeader("token");
        if(StringUtils.isEmpty(token)){
            token = req.getParameter("token");
        }


        if(StringUtils.isEmpty(token)){

            return;

        }else {
            //判断token是否合法
            User user = UserServiceImpl.sessionMap.get(token);
            if(user!=null){
                filterChain.doFilter(servletRequest,servletResponse);
            }
        }
    }


    /**
     * 容器销毁的时候
     */
    @Override
    public void destroy() {

        System.out.println("destroy LoginFilter======");
    }
}

场景：权限控制、⽤用户登录状态控制，也可以交给拦截器器处理理等

4.5监听器

应用上下文监听器

WebListener

package net.xdclass.demoproject.listener;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

/**
 *
 * 应用上下文监听器
 */

@WebListener
class ApplicationListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {

        System.out.println("contextInitialized====");

    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {

        System.out.println("contextDestroyed====");
    }
}

CustomRequestListener

package net.xdclass.demoproject.listener;

import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.annotation.WebListener;

@WebListener
class CustomRequestListener implements ServletRequestListener {

    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        System.out.println("requestDestroyed====");
    }

    @Override
    public void requestInitialized(ServletRequestEvent sre) {

        System.out.println("requestInitialized====");

    }
}

CustomSessionListener

package net.xdclass.demoproject.listener;

import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

@WebListener
class CustomSessionListener implements HttpSessionListener {

    @Override
    public void sessionCreated(HttpSessionEvent se) {


        System.out.println("sessionCreated====");
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {

        System.out.println("sessionDestroyed====");

    }

}

4.6SpringBoot拦截器的实现

（1）实现WebMvcConfigurer类配置拦截器

package net.xdclass.demoproject.intercepter;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;


/**
 * 拦截器配置类
 */
@Configuration
class CustomWebMvcConfigurer implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        registry.addInterceptor(getLoginInterceptor()).addPathPatterns("/api/v1/pri/**");

        registry.addInterceptor(new TwoIntercepter()).addPathPatterns("/api/v1/pri/**");

        WebMvcConfigurer.super.addInterceptors(registry);


    }
    
    @Bean
    public LoginIntercepter getLoginInterceptor(){
        return new LoginIntercepter();
    }
}

（2）自定义登录拦截器LoginIntercepter，实现HandlerInterceptor类

package net.xdclass.demoproject.intercepter;

import com.fasterxml.jackson.databind.ObjectMapper;
import net.xdclass.demoproject.domain.User;
import net.xdclass.demoproject.service.impl.UserServiceImpl;
import net.xdclass.demoproject.utils.JsonData;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;

class LoginIntercepter implements HandlerInterceptor {


    private static final ObjectMapper objectMapper = new ObjectMapper();



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

        System.out.println("LoginIntercepter preHandle =====");



        String token = request.getHeader("token");
        if(StringUtils.isEmpty(token)){
            token = request.getParameter("token");
        }


        if(!StringUtils.isEmpty(token)){

            //判断token是否合法
            User user = UserServiceImpl.sessionMap.get(token);

            if(user!=null){

                return true;
            }else {

                JsonData jsonData =  JsonData.buildError("登录失败，token无效",-2);
                String jsonStr = objectMapper.writeValueAsString(jsonData);
                renderJson(response,jsonStr);
                return false;

            }

        }else {

            JsonData jsonData =  JsonData.buildError("未登录",-3);
            String jsonStr = objectMapper.writeValueAsString(jsonData);
            renderJson(response,jsonStr);
            return false;
        }

        //return HandlerInterceptor.super.preHandle(request,response,handler);
    }



    private void renderJson(HttpServletResponse response,String json){

        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");


        try(PrintWriter writer = response.getWriter()){
            writer.print(json);
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

        System.out.println("LoginIntercepter postHandle =====");

        HandlerInterceptor.super.postHandle(request,response,handler,modelAndView);

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

        System.out.println("LoginIntercepter afterCompletion =====");

        HandlerInterceptor.super.afterCompletion(request,response,handler,ex);
    }
}

preHandle：调用Controller某个方法之前

postHandle：Controller之后调用，视图渲染之前，如果控制器Controller出现恶略异常，则不执行此方法

afterCompletion：不管有没有异常，这个afterCompletion都会被调用，用于资源清理

（3）添加第二个拦截器

package net.xdclass.demoproject.intercepter;

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

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

class TwoIntercepter implements HandlerInterceptor {


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

        System.out.println("TwoIntercepter preHandle =====");

        return HandlerInterceptor.super.preHandle(request,response,handler);
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

        System.out.println("TwoIntercepter postHandle =====");

        HandlerInterceptor.super.postHandle(request,response,handler,modelAndView);

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

        System.out.println("TwoIntercepter afterCompletion =====");

        HandlerInterceptor.super.afterCompletion(request,response,handler,ex);
    }
}

按照注册顺序进行拦截，先注册，先被拦截，

添加拦截类以后要在配置类中添加

registry.addInterceptor(new TwoIntercepter()).addPathPatterns("/api/v1/pri/**");

拦截器不生效的常见问题

是否加@Configuration

拦截路径是否有问题 ** 和 *

拦截器最后路径一定要/** 如果是目录的话则是/*/

Interceptor和Filter过滤器的区别？

Filter和Interceptor⼆二者都是AOP编程思想的体现，功能基本都可以实现
拦截器器功能更更强⼤大些， Filter能做的事情它都能做
Filter在只在Servlet前后起作⽤用，⽽而Interceptor够深⼊入到⽅方法前后、异常抛出前后等
filter依赖于Servlet容器器即web应⽤用中，⽽而Interceptor不不依赖于Servlet容器器所以可以运⾏行行在
多种环境。
在接⼝口调⽤用的⽣生命周期⾥里里， Interceptor可以被多次调⽤用，⽽而Filter只能在容器器初始化时调⽤用⼀一
次。
Filter和Interceptor的执⾏行行顺序
过滤前->拦截前->action执⾏行行->拦截后->过滤后

如何配置不被拦截某些路径？

    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        registry.addInterceptor(getLoginInterceptor()).addPathPatterns("/api/v1/pri/**","/api/v1/pri/user/**")
        .excludePathPatterns("/**/*.html","/**/*.js"); //配置不拦截某些路径;

        registry.addInterceptor(new TwoIntercepter()).addPathPatterns("/api/v1/pri/**")
        WebMvcConfigurer.super.addInterceptors(registry);
    }