springboot--集成springmvc，RESTful，拦截器，过滤器

springboot–集成springmvc

多个注解的使用

1.@RestController注解的使用：
@RestController注解相当于控制类上加@Controller + 方法上面加@ResponseBody，相当于当前Controller类的所有方法返回的都是JSON对象

//@Controller
@RestController  //相当于控制类上加@Controller + 方法上面加@ResponseBody
// 相当于当前Controller类中所有的方法返回的都是JSON对象
public class StudentController {

    @Resource
    private StudentService studentService;

    @RequestMapping(value = "/update")
//    @ResponseBody
    public Object update(){
        Student student = new Student();

        student.setId(5);
        student.setName("zhaosi");

        return student;
    }
}

2.@GetMapping注解的使用：
@GetMapping是只能接收get请求。下面是代码示例：

//@Controller
@RestController  //相当于控制类上加@Controller + 方法上面加@ResponseBody
// 相当于当前Controller类中所有的方法返回的都是JSON对象
public class StudentController {

    @Resource
    private StudentService studentService;

//    @RequestMapping(value = "/update", method = RequestMethod.GET)
    @GetMapping(value = "/update")//相当于上面那句话，只支持GET方法
    //该注解通常在查询数据时使用
//    @ResponseBody
    public Object update(){
        Student student = new Student();

        student.setId(5);
        student.setName("zhaosi");

        return student;
    }
}

3.@PostMapping注解的使用：
类似上面的@GetMapping的使用，只能接收post请求。
4.@DeleteMapping注解的使用：
类似上面的使用，只能接收Delete请求，通常用于删除数据时使用。
5.@PutMapping注解的使用：
类似上面的使用，只能接收put请求，通常用于更新操作。

RESTful风格请求

RESTful请求代码示例：

package com.web;

import com.model.Student;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;

@RestController
public class StudentController {

	//这是请求地址，id和age都是请求参数，使用@PathVariable注解
	//获取请求地址的参数
   @RequestMapping(value = "/student/detail/{id}/{age}")
    public Object student(@PathVariable("id") Integer id,
                          @PathVariable("age") Integer age){
       HashMap<String, Integer> map = new HashMap<>();
       map.put("id", id);
       map.put("age", age);

       return map;
   }
}

RESTful风格的请求会面对请求重复的问题。
我们解决的方法有两种，一种是使用不同的注解，就是上面的注解，接收不同的请求方式，比如只能接收post，get，put，delete等请求，可以避免的请求重复的问题。
第二种是改变的参数在请求地址中的位置，这样也可以避免请求重复的问题。
需要注意的是，RESTful风格的请求，地址里面最好是填名词，不要填动词。
1.第一种方法：

package com.web;

import com.model.Student;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;

@RestController
public class StudentController {

   @GetMapping(value = "/student/detail/{id}/{age}")
    public Object student(@PathVariable("id") Integer id,
                          @PathVariable("age") Integer age){
       HashMap<String, Integer> map = new HashMap<>();
       map.put("id", id);
       map.put("age", age);

       return map;
   }

    @PostMapping(value = "/student/detail/{id}/{city}")
    public Object addstudent(@PathVariable("id") Integer id,
                          @PathVariable("city") Integer city){
        HashMap<String, Integer> map = new HashMap<>();
        map.put("id", id);
        map.put("city", city);

        return map;
    }
}

2.第二种方法：

package com.web;

import com.model.Student;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;

@RestController
public class StudentController {

   @GetMapping(value = "/student/detail/{id}/{age}")
    public Object student(@PathVariable("id") Integer id,
                          @PathVariable("age") Integer age){
       HashMap<String, Integer> map = new HashMap<>();
       map.put("id", id);
       map.put("age", age);

       return map;
   }

    @PostMapping(value = "/student/{id}/detail/{city}")
    public Object addstudent(@PathVariable("id") Integer id,
                          @PathVariable("city") Integer city){
        HashMap<String, Integer> map = new HashMap<>();
        map.put("id", id);
        map.put("city", city);

        return map;
    }
}

springboot创建拦截器

代码示例：

1.创建控制器类(UserController):

package com.web;

import com.model.User;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.jws.Oneway;
import javax.servlet.http.HttpServletRequest;

@Controller
@RequestMapping(value = "/user")
public class UserController {
    /*
    * 用户登录的请求
    * 不需要登录请求进行拦截，否则无法登录
    * */
    @RequestMapping(value = "/login")
    @ResponseBody
    public Object login(HttpServletRequest request){
        //将用户的信息放入到session中
        User user = new User();
        user.setId(1001);
        user.setUserName("lzx");
        request.getSession().setAttribute("user", user);

        return "login Success";
    }
    //该请求需要用户登录之后，才可以访问
    @RequestMapping(value = "/center")
    @ResponseBody
    public Object center(){
        return "See center Message";
    }

    //这个请求，用户不登陆也能访问
    @RequestMapping(value = "/out")
    @ResponseBody
    public Object out(){
        return "OUT";
    }
    /*
    * 如果用户未登录访问了需要登录才能访问的页面,之后会跳转到该请求路径
    * 这个请求路径不需要用户登录也可以访问
    * */
    @RequestMapping(value = "/error")
    @ResponseBody
    public Object error(){
        return "error";
    }
}

2.编写拦截器类，实现HandlerInterceptor接口(UserInterceptor),之前已经创建了Student类了，代码就不写上去了，Student类会放入到session域中，作为登录的证明

package com.interceptor;

import com.model.User;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

//需要实现HandlerInterceptor接口
public class UserInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //编写拦截业务的规则
        //从session中获取用户的信息
        User user = (User) request.getSession().getAttribute("user");
        //判断用户是否登录
        if (user == null){
            //未登录
            response.sendRedirect(request.getContextPath() + "/user/error");
            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.实现一个配置文件类，代替springmvc中的xml配置文件(InterceptorConfig)：

package com.config;

import com.interceptor.UserInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration  //定义此类为配置文件类(即相当于之前的xml配置文件)
//同时还需要实现一个接口WebMvcConfigurer
public class InterceptorConfig implements WebMvcConfigurer {

    /*
    *  需要重写一个方法，添加拦截器
    *  InterceptorRegistry是拦截器方法注册类
    *   需要将我们创建的拦截器类注册进去
    * */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        /*
        * 需要拦截的路径，是一个数组形式
        * 要拦截user下的所有访问请求，必须用户登录后才可以访问
        * 但是这样拦截的路径下有一些是不需要用户登录也可访问
        * */
        String[] addPathPatterns = {
            "/user/**"
        };

        /*
        * 排除拦截的路径，也算是一个数组的形式
        * 这个是要排除的路径，排除的路径说明不需要用户登录也可以访问
        * */
        String[] excludePathPatterns = {
            "/user/out",
            "/user/error" ,
            "/user/login"
        };
        /*
        *  addInterceptor相当于mvc:interceptor
        *  addPathPatterns相当于需要拦截的路径
        *  excludePathPatterns相当于排除拦截的路径
        * */
        registry.addInterceptor(new UserInterceptor()).addPathPatterns(addPathPatterns).excludePathPatterns(excludePathPatterns);
    }
}

springboot集成过滤器

1.创建过滤器类，要实现Filter接口，同时要标注WebFilter注解，标注需要过滤的请求地址(MyFilter)

package com.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

@WebFilter(urlPatterns = "/myfilter")
public class MyFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("-----您已经进入了过滤器-----------");

        filterChain.doFilter(servletRequest, servletResponse);
    }
}

2.在入口方法上面加入注解ServletComponentScan，扫描过滤器所在的包

package com.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

@WebFilter(urlPatterns = "/myfilter")
public class MyFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("-----您已经进入了过滤器-----------");

        filterChain.doFilter(servletRequest, servletResponse);
    }
}

springboot进行字符过滤

springboot进行字符过滤只需要在主配置文件里面加入三行代码就可以实现。

#开启springboot的字符过滤
server.servlet.encoding.enabled=true
server.servlet.encoding.force=true
server.servlet.encoding.charset=utf-8