Springboot Web

只看见而已

于 2024-09-30 19:24:56 发布

阅读量673

点赞数 20

本文链接：https://blog.csdn.net/fada_da_da/article/details/142651593

版权

1.静态资源映射规则

只要在静态资源放在类路径下：/static(or/public/or/resource or /META-INF/resources

访问：当前项目根路径/+静态资源名

2.enjoy模版引擎

2.1将模版保存到templates目录下

2.2添加坐标

2.3开启配置

package com.ly.springboot_web_01.config;

import com.jfinal.template.Engine;
import com.jfinal.template.ext.spring.JFinalViewResolver;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class EnjoyConfig {
    @Bean(name = "jfinalViewResolver")
    public JFinalViewResolver getJFinalViewResolver() {

        // 创建用于整合 spring boot 的 ViewResolver 扩展对象
        JFinalViewResolver jfr = new JFinalViewResolver();

        // 对 spring boot 进行配置
        jfr.setSuffix(".html");
        jfr.setContentType("text/html;charset=UTF-8");
        jfr.setOrder(0);

        // 设置在模板中可通过 #(session.value) 访问 session 中的数据
        jfr.setSessionInView(true);

        // 获取 engine 对象，对 enjoy 模板引擎进行配置，配置方式与前面章节完全一样
        Engine engine  = JFinalViewResolver.engine;

        // 热加载配置能对后续配置产生影响，需要放在最前面
        engine.setDevMode(true);

        // 使用 ClassPathSourceFactory 从 class path 与 jar 包中加载模板文件
        engine.setToClassPathSourceFactory();

        // 在使用 ClassPathSourceFactory 时要使用 setBaseTemplatePath
        // 代替 jfr.setPrefix("/view/")
        engine.setBaseTemplatePath("/templates/");


        // 更多配置与前面章节完全一样
        // engine.addDirective(...)
        // engine.addSharedMethod(...);

        return jfr;
    }
}

2.4编写代码

3 SpringMVC

请求处理 *@RequestMapping

* 意义:处理用户的请求，相似于doget与dopost
* 位置:
* 类上:一级目录
* 方法:二级目录
* 例如:user/save
* user/delete
* student/save
* student/delete
* 属性:
* value = "",path = ""
* 表示请求路径
* =========================
* method=常量,此请求的类型(get,post),若不设置则此请求适配所有的请求方式
* =========================
* params = ""
* 限制请求参数,例如：params={"msg1","msg2"}表示请求路径中必须携带参数名为msg1与msg2的参数
*
* 注意:1.超链接默认发送的是get请求
* 2.所有请求所携带的参数格式均为：key = value
*
* @DeleteMapping删除
* @PutMapping 修改
* @GetMapping 查询
* @PostMapping 新增
*
* @RequestMapping可以点击查看源码
* @Target({ElementType.METHOD, ElementType.TYPE})
* METHOD==代表修饰方法,TYPE==代表修饰类

参数绑定

* springMVC请求参数的绑定
* 绑定的机制:SpringMVC 绑定请求参数的过程是通过把表单提交请求参数，作为控制器中方法参数进行绑定的

支持数据类型:
*      1.基本类型参数：
*                  包括基本类型和 String 类型
*      2.POJO类型参数：
*                  包括实体类，以及关联的实体类
*      3.数组和集合类型参数：
*                  包括 List 结构和 Map 结构的集合（包括数组）
*      4.使用 ServletAPI 对象作为方法参数
*          HttpServletRequest
*          HttpServletResponse
*          HttpSession
*          java.security.Principal
*          Locale
*          InputStream
*          OutputStream
*          Reader
*          Writer
*
*  二.使用要求
*     1.发送请求中携带数据的key与方法参数的name必须一致
*     2.数据类型合法

常用注解

**
 * springMVC常用注解
 *
 * 一.@RequestParam
 *      作用：
 *          把请求中指定名称的参数给控制器中的形参赋值。
 *          如果页面标签名称和方法参数名称不一致，可以使用此注解实现
 *      属性：
 *          name属性：设置参数名称
 *          defaultValue属性：设置默认值
 *          required属性：设置是否为必传
 *
 * 二.@RequestBody
 *      作用：
 *          用于获取"请求体"内容。直接使用得到是 key=value&key=value...
 *          结构的数据,并可以转换为对象
 *      属性：
 *          required：是否必须有请求体。默认值是:true。
 *
 *
 *
 * 三.@PathVaribale
 *      作用：
 *          用于绑定 url 中的占位符。例如：请求 url 中 /delete/{id}，
 *          这个{id}就是 url 占位符。url 支持占位符是 spring3.0 之
 *          后加入的。是 springmvc 支持 rest 风格 URL 的一个重要标志
 *      属性：
 *          value：用于指定 url 中占位符名称。
 *          required：是否必须提供占位符。
 *
 *  Restful是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。
 *  主要用于客户端和服务器交互类的软件，基于这个风格设计的软件可以更简洁，更有层次，
 *  更易于实现缓存机制等。
 *
 *  Restful风格的请求是使用“url+请求方式”表示一次请求目的的，HTTP 协议里面四个表示操作方式的动词如下：
 *       GET：用于获取资源
 *       POST：用于新建资源
 *       PUT：用于更新资源
 *       DELETE：用于删除资源
 * 例如：
 *  /users/1                GET ：      得到 id = 1 的 user
 *  /users/1                DELETE：    删除 id = 1 的 user
 *  /users/1/新名/新性       PUT：       更新 id = 1 的 user
 *  /users/新名/新性         POST：      新增 user

四.@RequestHeader
*      作用：
*          用于获取请求消息头。
*      属性：
*          value：提供消息头名称
*          required：是否必须有此消息头
* 五.@CookieValue
*      作用：
*          用于把指定 cookie 名称的值传入控制器方法参数。
*      属性：
*          value：指定 cookie 的名称。
*          required：是否必须有此 cookie。
*
* */

数据传递
@ResponseBody   对象====>json
* 位置:1.类
*      2.方法
* @RequestBody    json====>对象
* 位置:方法参数
* @RestController   = @Controller + @ResponseBody
文件上传

利用七牛云

3.1请求处理

package com.ly.springboot_web_01.controller;

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

@Controller
@RequestMapping(path = "/user")
public class UserController {
    /**
     *
     *@RequestMapping
     * 意义:处理用户的请求，相似于doget与dopost
     * 位置:
     *      类上:一级目录
     *      方法:二级目录
     *      例如:user/save
     *          user/delete
     *          student/save
     *          student/delete
     *  属性:
     *      value = "",path = ""
     *      表示请求路径
     *      =========================
     *      method=常量,此请求的类型(get,post),若不设置则此请求适配所有的请求方式
     *      =========================
     *      params = ""
     *      限制请求参数,例如：params={"msg1","msg2"}表示请求路径中必须携带参数名为msg1与msg2的参数
     *
     *      注意:1.超链接默认发送的是get请求
     *          2.所有请求所携带的参数格式均为：key = value
     *
     *     @DeleteMapping删除
     *     @PutMapping   修改
     *     @GetMapping   查询
     *     @PostMapping  新增
     *
     *     @RequestMapping可以点击查看源码
     *     @Target({ElementType.METHOD, ElementType.TYPE})
     *          METHOD==代表修饰方法,TYPE==代表修饰类

     * */
  @RequestMapping(value = "/init")//二级目录
  public String userInit(){
      System.out.println("=====进入了springMVC的控制器======");
      System.out.println("调用业务层，调用持久层");
      return "success";//返回方法执行完要跳转的页面名称
  }
  @RequestMapping(value = "/show1",method = {RequestMethod.POST})
  public String show1(){
      System.out.println("进入了SpringMVC的控制器====");
      System.out.println("使用post方式请求进入");
      return "success";
  }
  @RequestMapping(value = "/show2",params = {"msg1=aa","msg2=bb"})
    public String show2(){
      System.out.println("进入了SpringMVC的控制器====");
      System.out.println("限制请求携带的参数");
      return "success";
  }
  //使用postman测试
    @GetMapping("/show3")
    public String show3(){
        System.out.println("必须使用get请求方式");
      return "success";
    }
    @PostMapping("/show4")
    public String show4(){
        System.out.println("必须使用post方式");
      return "success";
    }
    @DeleteMapping("/show5")
        public String show5(){
            System.out.println("必须使用delete方式请求");
      return "success";
        }
        @PutMapping("/show6")
    public String show6(){
            System.out.println("必须使用put方式请求");
      return "success";
        }
}

3.2参数绑定

package com.ly.spring_web_02.controller;

import com.ly.spring_web_02.pojo.Dep;
import com.ly.spring_web_02.pojo.Emp;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.util.Arrays;
import java.util.Map;

/**
 * springMVC请求参数的绑定
 * 绑定的机制:SpringMVC 绑定请求参数的过程是通过把表单提交请求参数，作为控制器中方法参数进行绑定的
 *
 * 一.支持数据类型:
 *      1.基本类型参数：
 *                  包括基本类型和 String 类型
 *      2.POJO类型参数：
 *                  包括实体类，以及关联的实体类
 *      3.数组和集合类型参数：
 *                  包括 List 结构和 Map 结构的集合（包括数组）
 *      4.使用 ServletAPI 对象作为方法参数
 *          HttpServletRequest
 *          HttpServletResponse
 *          HttpSession
 *          java.security.Principal
 *          Locale
 *          InputStream
 *          OutputStream
 *          Reader
 *          Writer
 *
 *  二.使用要求
 *     1.发送请求中携带数据的key与方法参数的name必须一致
 *     2.数据类型合法
 *
 * */

@Controller
@RequestMapping("/one")
public class OneController {
    @RequestMapping("/show")
    public String show(){
        return "one";
    }
    @RequestMapping("/show1")
    public String show1(String msg1){
        System.out.println("=====接受到用户发送数据为:"+msg1+"=======");
        return "success";
    }
    public String show2(String msg1,int msg2){
        System.out.println("=====接受到用户发送数据为:"+msg1+"=======");
        System.out.println("=====接受到用户发送数据为:"+msg2+"=======");
        return "success";
    }
    /***********************POJO 类型作为参数*********************************/
    //单一对象
    @RequestMapping("/show3")
    public String show3(Emp emp){
        System.out.println("=====接受到用户发送数据为:"+emp+"=======");
        return "success";
    }
    //嵌套对象
    @RequestMapping("/show4")
    public String show4(Emp emp){
        System.out.println("=====接受到用户发送数据为:"+emp+"=======");
        return "success";
    }
    //map获取对象
    @RequestMapping("/map")
    public String map(@RequestParam Map map){
        System.out.println("=====接受到用户发送数据为:"+map+"=======");
        return "success";
    }
    /*********************POJO 类中包含集合类型参数*********************************/
    @RequestMapping("/show5")
    public String show5(Dep dep){
        System.out.println("=====接受到用户发送数据为:"+dep+"=======");
        return "success";
    }
    @RequestMapping("/show6")
    public String show6(int[] nums){
        System.out.println("=====接受到用户发送数据为:"+ Arrays.toString(nums)+"=======");
        return "success";
    }
    public String show7(HttpServletRequest request, HttpServletResponse response){
        System.out.println(request);
        System.out.println(response);
        request.getParameter("msg1");
        HttpSession session = request.getSession();
        System.out.println(session);
        session.setAttribute("","");
        try {
            response.sendRedirect("重定向");
        } catch (IOException e) {
            e.printStackTrace();
        }
        ServletContext servletContext = session.getServletContext();
        return "success";
    }
}

3.3常用注解

package com.ly.spring_web_.controller;


import com.ly.spring_web_.pojo.Emp;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * springMVC常用注解
 *
 * 一.@RequestParam
 *      作用：
 *          把请求中指定名称的参数给控制器中的形参赋值。
 *          如果页面标签名称和方法参数名称不一致，可以使用此注解实现
 *      属性：
 *          name属性：设置参数名称
 *          defaultValue属性：设置默认值
 *          required属性：设置是否为必传
 *
 * 二.@RequestBody
 *      作用：
 *          用于获取"请求体"内容。直接使用得到是 key=value&key=value...
 *          结构的数据,并可以转换为对象
 *      属性：
 *          required：是否必须有请求体。默认值是:true。
 *
 *
 *
 * 三.@PathVaribale
 *      作用：
 *          用于绑定 url 中的占位符。例如：请求 url 中 /delete/{id}，
 *          这个{id}就是 url 占位符。url 支持占位符是 spring3.0 之
 *          后加入的。是 springmvc 支持 rest 风格 URL 的一个重要标志
 *      属性：
 *          value：用于指定 url 中占位符名称。
 *          required：是否必须提供占位符。
 *
 *  Restful是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。
 *  主要用于客户端和服务器交互类的软件，基于这个风格设计的软件可以更简洁，更有层次，
 *  更易于实现缓存机制等。
 *
 *  Restful风格的请求是使用“url+请求方式”表示一次请求目的的，HTTP 协议里面四个表示操作方式的动词如下：
 *       GET：用于获取资源
 *       POST：用于新建资源
 *       PUT：用于更新资源
 *       DELETE：用于删除资源
 * 例如：
 *  /users/1                GET ：      得到 id = 1 的 user
 *  /users/1                DELETE：    删除 id = 1 的 user
 *  /users/1/新名/新性       PUT：       更新 id = 1 的 user
 *  /users/新名/新性         POST：      新增 user
 *
 * */
@Controller
@RequestMapping("/one")
public class OneController {
    /**
     * @RequestParam("名称必须与页面标签或者url地址key名称一致")
     * */
    @RequestMapping("/show1")
    public String show1(@RequestParam(name = "msg1")String msg){
        System.out.println("=====接受到用户发送数据为:"+msg+"=======");
        return "success";
    }
    @RequestMapping("/show2")
    public String show2(@RequestParam(name = "msg1")String msg,@RequestParam(name = "msg2")int num){
        System.out.println("=====接受到用户发送数据为:"+msg+"=======");
        System.out.println("=====接受到用户发送数据为:"+num+"=======");
        return "success";
    }
    @RequestMapping("/show3")
    public String show3(@RequestParam(name = "msg1",defaultValue = "暂无用户")String name){
        System.out.println("账号:"+name);
        return "success";
    }  /**
     * 前后端分离
     * @RequestBody可以将json ===》 javaBean
     * 注意:
     *  1.前端不能使用GET方式提交数据,GET方式无请求体
     * {
     * 	"eid":007,
     * 	"ename":"詹姆斯邦德",
     * 	"esex":"绅士"
     * }
     *
     * * */
    @RequestMapping("/show4")
    public String show4(@RequestBody Emp emp){
        System.out.println("=========="+emp+"==========");
        return "success";
    }
    @RequestMapping("/show5/{ename}/{esex}")
    public String show5(@PathVariable("ename")String msg1,@PathVariable("esex")String msg2){
        System.out.println(msg1);
        System.out.println(msg2);
        return "success";
    }
    @RequestMapping("/show6/{ename}/{esex}")
    public String show6(@PathVariable String ename,@PathVariable String esex){
        System.out.println(ename);
        System.out.println(esex);
        return "success";
    }
}

package com.ly.spring_web_.controller;

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

/**
 *
 * springMVC常用注解
 *
 * 四.@RequestHeader
 *      作用：
 *          用于获取请求消息头。
 *      属性：
 *          value：提供消息头名称
 *          required：是否必须有此消息头
 * 五.@CookieValue
 *      作用：
 *          用于把指定 cookie 名称的值传入控制器方法参数。
 *      属性：
 *          value：指定 cookie 的名称。
 *          required：是否必须有此 cookie。
 *
 * */
@Controller
@RequestMapping("/two")
public class TwoController {
    /**
     * 获取头信息
     * 只获取头信息中的Accept-Language对应的数据(记得使用浏览器测试)
     * */
    @RequestMapping("/show1")
    public String show1(@RequestHeader(value = "msg1")String msg){
        System.out.println("msg");
        return "success";
    }
    /**
     * 获取cookie
     * */
    @RequestMapping("/show2")
    public String show2(@CookieValue(value = "JSESSIONID",required = false)String jessionid){
        System.out.println(jessionid);
        return "success";
    }
}

3.4数据传递

利用JSON

package com.ly.springboot_web_04.controller;



import com.ly.springboot_web_04.pojo.Emp;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

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

/**
 *
 * @ResponseBody   对象====>json
 *  位置:1.类
 *      2.方法
 *
 *
 * @RequestBody    json====>对象
 * 位置:方法参数
 *
 * @RestController   =  @Controller  +  @ResponseBody
 *
 * */
@Controller
@RequestMapping("/json")
public class JsonController {
    @RequestMapping("/show1")
    @ResponseBody
    public List<Emp> show1(){
        Emp emp=new Emp(1,"不晚","女");
        Emp emp1=new Emp(2,"只看见而已","女");
        Emp emp2=new Emp(3,"叮咚","女");
        List<Emp> emps=new ArrayList<>();
        emps.add(emp);
        emps.add(emp1);
        emps.add(emp2);
        for (Emp emp3 : emps) {
            System.out.println(emp3);
        }
     return emps;
    }
    @RequestMapping("/show2")
    @ResponseBody
    public String show2(){
        System.out.println("这是JSON的show2方法");
        return "helloworld";
    }
}

利用String

package com.ly.springboot_web_04.controller;

import com.ly.springboot_web_04.pojo.Emp;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

/**
 * 返回值为:字符串
 * */
@RestController
@RequestMapping("/string")
public class StringController {
    /**
     * 进入首页
     * */
    @RequestMapping("/show")
    public String show(){
        return "index";
    }
    /*
     * 充当试图的逻辑名称，默认页面跳转为请求转发方式
     * */
    @RequestMapping("/show1")
    public String show1(){
        System.out.println("我是show1方法");
        return "success_String";
    }
    /*
     * 作充当一次请求转发或重定向
     * */
    @RequestMapping("/show2")
    public String show2(){
        System.out.println("我是show2方法");
        return "redirect:show1";
    }
    @RequestMapping("/show3")
    public String show3(){
        System.out.println("我是show3方法");
        return "forward:show1";
    }
    @RequestMapping("/show4")
    public String show4(HttpServletRequest request){
        System.out.println("我是show4方法");
        //1.查询数据库(模拟)
        Emp emp=new Emp(1,"不晚","女");
        //2.获取session
        request.getSession().setAttribute("emp",emp);
        System.out.println(emp);
        return "success_String";
    }

}

3.5文件上传

先配置enjoy模版配置类

根据七牛云官网找使用相对应需求方法

导坐标

<groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>3.14.2</version>
    <scope>compile</scope>
</dependency>
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.5</version>
    <scope>compile</scope>
</dependency>
<dependency>
    <groupId>com.qiniu</groupId>
    <artifactId>happy-dns-java</artifactId>
    <version>0.1.6</version>
    <scope>test</scope>
</dependency>
<!--文件上传-->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.3</version>
</dependency>
<!--试图-->
<dependency>
    <groupId>com.jfinal</groupId>
    <artifactId>enjoy</artifactId>
    <version>5.0.3</version>
</dependency>
<dependency>

package com.ly.springboot_web_05.controller;

import com.google.gson.Gson;
import com.qiniu.common.QiniuException;
import com.qiniu.http.Response;

import com.qiniu.storage.BucketManager;
import com.qiniu.storage.Configuration;
import com.qiniu.storage.Region;
import com.qiniu.storage.UploadManager;
import com.qiniu.storage.model.DefaultPutRet;
import com.qiniu.util.Auth;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;


@Controller
public class UserCintroller {
    //进入测试页面
    @RequestMapping("/show")
    public String show(){
        return "index";
    }

    //文件上传
    @RequestMapping("/fileupload")
    public String fileupload(String uname, MultipartFile upic, HttpServletRequest request){
        System.out.println("用户名:"+uname);
        System.out.println(upic);
        System.out.println(upic.getOriginalFilename());
        System.out.println(upic.getName());


        //方式1.将文件upic以流的方式写入当前服务器磁盘(应用服务器)
        //方式2.文件服务器（七牛云）
        //构造一个带指定 Region 对象的配置类
        Configuration cfg = new Configuration(Region.autoRegion());
        //...其他参数参考类注释
        UploadManager uploadManager = new UploadManager(cfg);
        //...生成上传凭证，然后准备上传
        String accessKey = "we0XuzUiPv2i2vtkLbDqsKMMoqaXcvX3ewNuk4mQ";
        String secretKey = "VnsA3xTb_JEYR6rdVZwynAPfva1dos7MWt-pX_MP";
        String bucket = "xiaozhao03";
        //默认不指定key的情况下，以文件内容的hash值作为文件名
        String key ="first";
        String name = null;

        try {
            byte[] uploadBytes = upic.getBytes();
            Auth auth = Auth.create(accessKey, secretKey);
            String upToken = auth.uploadToken(bucket);

            try {
                Response response = uploadManager.put(uploadBytes, key, upToken);
                //解析上传成功的结果
                DefaultPutRet putRet = new Gson().fromJson(response.bodyString(), DefaultPutRet.class);
                System.out.println(putRet.key);//获取文件名
                System.out.println(putRet.hash);//获取文件hash值
                name = putRet.key;
            } catch (QiniuException ex) {
                Response r = ex.response;
                System.err.println(r.toString());
                try {
                    System.err.println(r.bodyString());
                } catch (QiniuException ex2) {
                    //ignore
                }
            }
        } catch (Exception ex) {
            //ignore
        }
        request.getSession().setAttribute("picname",name);

        return "success";

    }
    @RequestMapping("/delete")
    public String delete(MultipartFile upic, HttpServletRequest request){
        //构造一个带指定 Region 对象的配置类
        Configuration cfg = new Configuration(Region.region0());
//...其他参数参考类注释
        String accessKey = "we0XuzUiPv2i2vtkLbDqsKMMoqaXcvX3ewNuk4mQ";
        String secretKey = "VnsA3xTb_JEYR6rdVZwynAPfva1dos7MWt-pX_MP";
        String bucket = "xiaozhao03";
        String key = "first";
        String name=null;
        Auth auth = Auth.create(accessKey, secretKey);
        BucketManager bucketManager = new BucketManager(auth, cfg);
        try {
            bucketManager.delete(bucket, key);
        } catch (QiniuException ex) {
            //如果遇到异常，说明删除失败
            System.err.println(ex.code());
            System.err.println(ex.response.toString());
        }
        request.getSession().setAttribute("picname",name);

        return "del";
    }
}

4.注册Servlet三大组件 Servlet/Filter/Listener

由于Spring Boot默认十一jar包的方式运行嵌入式Servlet容器来启动应用，没有web.xml文件，Spring提供以下Bean来注册三大组件

ServletRegistrationBean 注册自定义Servlet

FilterRegistrationBean 注册自定义Filter

ServletListenerRegistrationBean 注册自定义Listener

1.导坐标

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <!--排除坐标-->
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<!--引入其他的Servlet容器-->
<dependency>
    <artifactId>spring-boot-starter-jetty</artifactId>
    <groupId>org.springframework.boot</groupId>
</dependency>

package com.ly.springboot_web_06.servlet;

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

//@WebServlet("/myservlet")
public class MyServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.printf("进入servlet");
        resp.getWriter().println("<h1>HI</h1>");
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       this.doPost(req, resp);
    }
}

package com.ly.springboot_web_06.filter;

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


//@WebFilter(urlPatterns = "/*")
public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("请求过滤");
        servletRequest.setCharacterEncoding("utf-8");

        filterChain.doFilter(servletRequest,servletResponse);

        servletResponse.setCharacterEncoding("utf-8");
        System.out.println("响应过滤");
    }
}

package com.ly.springboot_web_06.servlet;

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


//@WebServlet("/myservlet")
public class MyServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.printf("进入servlet");
        resp.getWriter().println("<h1>HI</h1>");
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       this.doPost(req, resp);
    }
}