MVC配置类

在boot中(一个注解,实现方法,然后重写方法进行注册)

@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/user/hello
@ComponentScan("com.cskaoyan.controller")
@EnableWebMvc
public class MvcConfig implements WebMvcConfigurer {
    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
            registry.addInterceptor(new MyHandlerInterceptor()).addPathPatterns("/user/hello
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/jpg
    @Override
    public Validator getValidator() {
        LocalValidatorFactoryBean validatorFactoryBean = new LocalValidatorFactoryBean();
        validatorFactoryBean.setProviderClass(Hibernatevalidator.class);
        return validatorFactoryBean;
    }


    
    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(new MyConvert());
    }


}

        1.导入依赖

    
        
            org.hibernate.validator
            hibernate-validator
            6.2.0.Final
        

        2.校验类上注解

@Data
public class HibernateUser {
    @Length(max = 8)
    String username;
    @Length(min = 3)
    String password;
}

        3.控制层注解

    @RequestMapping("login2")
    public baseUserVO getLogin2(@Valid HibernateUser user, BindingResult bindingResult) throws MyExceptionParamVer {
        //对传入的字段用user类的属性做校验,
//        baseUserVO.gerBinding(bindingResult);
        //测试切面
        return baseUserVO.getResult(user);

    }

   MVC容器注册

   
    @Override
    public Validator getValidator() {
        LocalValidatorFactoryBean validatorFactoryBean = new LocalValidatorFactoryBean();
        validatorFactoryBean.setProviderClass(Hibernatevalidator.class);
        return validatorFactoryBean;
    }

1.实现HandlerInterception接口

package com.cskaoyan.HandlerInterceptor;

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

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


@Component
public class MyHandlerInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String username = (String) request.getSession().getAttribute("username");
        if (username == null) {
            response.getWriter().println("Login Plz");
            return false;
        }
        return true;
    }

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

    }

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

    }
}

2.MVC容器注册

@ComtrollerAdvice注解

@ExceptionHandler注解映射

package com.cskaoyan.error;

import com.cskaoyan.bean.VO.baseUserVO;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;



@ControllerAdvice
public class MyHandlerEx {
    //username过长

    @ExceptionHandler(MyExceptionUsername.class)
    public String myExceptionUsername(){
        return "redirect:/index.jsp";

    }
     //psw过短
    @ExceptionHandler(MyExceptionPSW.class)
    public  String myExceptionPSW(){
        return "redirect:/index.jsp";
    }

    @ResponseBody
    @ExceptionHandler(MyExceptionParam.class)
    public baseUserVO myExceptionParam(){
        return baseUserVO.getWrong("yuanzhi!!");
    }

    @ResponseBody
    @ExceptionHandler(MyExceptionParamVer.class)
    public baseUserVO myExceptionParamVer(MyExceptionParamVer exceptionParamVer){
        String msg = exceptionParamVer.getMsg();
        return baseUserVO.getWrong(msg);
    }






}

package com.cskaoyan.convert;

import org.springframework.core.convert.converter.Converter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;


public class MyConvert implements Converter {


    @Override
    public Date convert(String s) {
        Date parse = null;
        try {
            parse = new SimpleDateFormat("yyyy-MM-dd").parse(s);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return parse;

    }
}

   
    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(new MyConvert());
    }

MVC注册

心脏搭桥思想

只需要注册组件@component

通知器和aspectJ是后置处理器的细化

AspectJ:配合校验器BindingResult进行参数校验

@Before @After @Around @AfterReturning@AfterThrowing注解

package com.cskaoyan.aspectj;

import com.cskaoyan.bean.BO.HibernateUser;
import com.cskaoyan.bean.VO.baseUserVO;
import com.cskaoyan.error.MyExceptionParamVer;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.validation.BindingResult;


@Aspect
@Component
public class MyAspectJ {
    //类下所有方法
    @Pointcut("execution(* com.cskaoyan.controller.UserController..*(..))")
    public  void MyPointcut(){}


    @Before("MyPointcut()")
    public void before(JoinPoint joinPoint) throws MyExceptionParamVer {
        System.out.println("切面生效");
        Object[] args = joinPoint.getArgs();
        for (Object arg : args) {
            if (arg instanceof BindingResult){
                //属于结果集,那么就调用静态方法对结果集做分析,输出json字符串(此处方法是抛出异常)
                baseUserVO.gerBinding(((BindingResult) arg));
                                        //强转
            }
        }
    }


}

配合自定义注解指定方法

package com.cskaoyan.aspectj;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnno {

}

@ControllerAdvice

@ExceptionHandler

总结：  过滤器和拦截器的区别，过滤器是依赖于servlet容器（struts），在实现上基于函数回调，可以对几乎所有的请求进行过滤。但缺点是一个过滤器实例只能在容器初始化时调用一次，来进行过滤操作，获得我们想要的数据。

三者之间主要还是粒度的差异，应用场景的不同。

过滤器（Filter）(责任链模式) ：可以拿到原始的http请求，但是拿不到你请求的控制器和请求控制器中的方法的信息。

拦截器（Interceptor）(责任链)：可以拿到你请求的控制器和方法，却拿不到请求方法的参数。

(访问路径,拿到请求的方法,拿不到方法参数)

切片（Aspect）(动态代理)  :  可以拿到方法的参数，但是却拿不到http请求和响应的对象

(以方法为主,可以拿到方法的参数,动态代理,可以做增强)

注册组件

@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/user/hello/**");
    }


    @Bean
    public CommonsMultipartResolver multipartResolver() {
        return new CommonsMultipartResolver();
    }
}

  @PostMapping("upload")
    public baseUserVO upload(MultipartFile[] myfile,
                             HttpServletRequest request) throws IOException {
        String realPath = request.getServletContext().getRealPath("WEB-INF/static");

        for (MultipartFile multipartFile : myfile) {
            String filename = multipartFile.getOriginalFilename();
            File file = new File(realPath, filename);
            multipartFile.transferTo(file);

        }
        return null;

    }