SpringBoot的Web开发

已于 2024-08-13 10:50:16 修改
阅读量861 收藏 18
点赞数 20
文章标签： java 开发语言 后端 spring mvc
于 2024-08-13 10:48:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_71072718/article/details/141133923
版权

目录

一、静态资源映射规则

二、enjoy模板引擎

三、springMVC

1、springMVC的概念理解

2、springMVC的工作流程

3、请求处理

4、springMVC的参数绑定

（1）绑定的机制

（2）支持的数据类型

（3）使用要求

（4）示例代码

5、springMVC常用注解

（1）@RequestParam

（2）@RequestBody

（3）@PathVaribale

（4）@RequestHeader

（5）@CookieValue

6、springMVC的数据传递

7、Spring的文件上传

四、注册Servlet三大组件 Servlet/Filter/Listener

五、切换为其他嵌入式Servlet容器

1、SpringBoot 默认针对Servlet容器提供以下支持

一、静态资源映射规则

        只要静态资源放在类路径下： called /static (or /public or /resources or /METAINF/resources。

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

二、enjoy模板引擎

        Spring Boot 的 enjoy 模板引擎是由 JFinal 提供的。JFinal 是一个轻量级的 Java Web 框架，而 Enjoy 是 JFinal 自带的模板引擎。Enjoy 模板引擎具有速度快、语法简洁、功能丰富等特点，适用于生成 HTML、XML、JSON 等各种文本内容。

        首先是导入依赖：

        <dependency>
            <groupId>com.jfinal</groupId>
            <artifactId>enjoy</artifactId>
            <version>5.0.3</version>
        </dependency>

        然后是创建一个配置类EnjoyConfig，用于配置 JFinal Enjoy 模板引擎与 Spring Boot 的集成。它定义了一个 JFinalViewResolver Bean，使得 Enjoy 模板引擎可以作为 Spring Boot 的视图解析器来使用，从而将模板文件渲染成 HTML 响应。

@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();
        
        // 设置模板文件的基础路径，这里设置为 resources 目录下的 templates 文件夹
        engine.setBaseTemplatePath("/templates/");
        
        // 更多的配置可以在这里添加，例如自定义指令、共享方法等
        // engine.addDirective(...);
        // engine.addSharedMethod(...);
        
        return jfr;
    }
}

        其中@Configuration表明这是一个配置类，Spring 会自动扫描并加载该类中的配置。

        JFinalViewResolver：这是 JFinal 框架提供的一个视图解析器，用于将控制器返回的视图名解析为实际的模板文件，并进行渲染。

        setSuffix：是设置模板后缀，以什么结尾。

        setConentType：是设置响应的内容类型为 text/html，并使用 UTF-8 编码。

        setOrder：是设置这个ViewResolver 的优先级为0，表示它的优先级最高。

        setSessionInView（true）：是将允许在模板中直接访问 session 中的数据。例如，可以通过 #(session.value) 语法访问 session 中的 value。

        setDevMode(true)：开启开发模式，这样可以在修改模板文件后立即生效，而不需要重启服务器。这对于开发阶段非常有用。

        setBaseTemplatePath("/templates/")：设置模板文件的基础路径为 /templates/。在这种情况下，模板文件应该存放在 resources/templates/ 目录下。

        比如在控制器层中方法返回值：

        @RequestMapping(value="/init")//二级目录
        public String userInit(){
            System.out.println("==========进入了springMVC的控制器=========");
            System.out.println("调用业务层，调用持久层");
            return "success";//返回方法执行完要跳转的页面名称
        }

        这段代码因为没有@?所以这段代码的return将返回的 success 视图名加上 .html 后缀，并且在 engine.setBaseTemplatePath("/templates/") 指定的模板路径下查找。                        会在src/main/resources/templates/ 目录下，那么 Spring MVC 会寻找            src/main/resources/templates/success.html 这个文件并渲染它。

三、springMVC

1、springMVC的概念理解

        Spring MVC 是一个基于 MVC 模式的 Java Web 框架，属于 Spring 框架的一部分。它将应用程序分为三层：模型（处理数据和业务逻辑）、视图（展示数据）、控制器（处理用户请求并协调模型和视图）。用户请求由 DispatcherServlet 接收并分发到合适的控制器，控制器处理后返回视图名称，最终生成 HTML 页面返回给用户。

2、springMVC的工作流程
  • 用户请求：用户通过浏览器发起一个 HTTP 请求。
  • 请求处理：请求首先到达 Spring 的 DispatcherServlet（前端控制器），它是整个 Spring MVC 的核心组件，负责协调整个请求处理流程。
  • 处理器映射：DispatcherServlet 通过处理器映射（Handler Mapping）找到对应的控制器（Controller）。
  • 调用控制器：DispatcherServlet 调用找到的控制器中的对应方法。
  • 业务逻辑处理：控制器调用业务层（Service）和数据访问层（DAO）进行数据处理。
  • 返回视图名称：控制器处理完业务逻辑后，返回一个视图名称（或视图对象）。
  • 视图解析：DispatcherServlet 通过视图解析器（ViewResolver）找到对应的视图模板。
  • 渲染视图：视图解析器将视图和模型数据结合，生成最终的 HTML 响应。
  • 返回响应：最终的 HTML 响应通过 DispatcherServlet 返回给用户的浏览器。
3、请求处理

        方式一：

        关键词：@RequestMapping。

        意义：处理用户的请求，相似于doget与dopost。

        位置：类上、一级目录。

        方法：二级目录。

        例如：user/save、user/delete、student/save、student/delete。

        属性：value = ""，path = ""。

        表示请求路径。

        示例代码：

        @RequestMapping(value="/init")//二级目录
        public String userInit(){
            System.out.println("==========进入了springMVC的控制器=========");
            System.out.println("调用业务层，调用持久层");
            return "success";//返回方法执行完要跳转的页面名称
        }

         就是当用户访问localhost:8080/init是这个方法就会被调用，并且执行完跳转到/templates/success页面中，value代表二级目录。

        方式二：

        在原有的基础上加上method属性，method=常量，此请求的类型（get，post），若不设置则此请求适配所有的请求方式 。

        示例代码：

        @RequestMapping(value="/show1",method ={RequestMethod.POST})
        public String show1(){
            System.out.println("==========进入了springMVC的控制器=========");
            System.out.println("使用post方式发送请求进入");
            return "success";//返回方法执行完要跳转的页面名称
        }

        这里这个method={RequestMethod.POST}：限定这个方法只处理HTTP POST请求。

        方式三：

        在原有的基础上加params属性，params = ""，限制请求参数，例如：params={"msg1","msg2"}表示请求路径中必须携带参数名为msg1与msg2的参数。

        示例代码：

        @RequestMapping(value="/show2",params = {"msg1=aa","msg2=bb"})
        public String show2(){
            System.out.println("==========进入了springMVC的控制器=========");
            System.out.println("限制请求携带的参数");
            return "success";//返回方法执行完要跳转的页面名称
        }

        只有在请求中包含特定参数msg1=aa和msg2=bb时，这个方法才会被执行。一个字都不能少。

        然后是使用postman测试，超链接默认发送的是get请求 ，所有请求所携带的参数格式均为：key = value。

        其中包含了：@DeleteMapping 删除、@PutMapping 修改、@GetMapping 查询 @PostMapping 新增

        @GetMapping（这个方法会响应GET请求。当客户端发送GET /show3请求时，该方法将被调用）

        @GetMapping("/show3")
        public String show3(){
            System.out.println("==========进入了springMVC的控制器=========");
            System.out.println("必须使用get方式请求");
            return "success";//返回方法执行完要跳转的页面名称
        }

        @DeleteMapping（这个方法会响应DELETE请求。当客户端发送DELETE /show5请求时，该方法将被调用）

        @DeleteMapping("/show5")
        public String show5(){
            System.out.println("==========进入了springMVC的控制器=========");
            System.out.println("必须使用delete方式请求");
            return "success";//返回方法执行完要跳转的页面名称
        }

        @PutMapping（这个方法会响应PUT请求。当客户端发送PUT /show6请求时，该方法将被调用）

        @PostMapping（这个方法会响应POST请求。当客户端发送POST /show4请求时，该方法将被调用）

        @RequestMapping可以点击查看源码

        @Target({ElementType.METHOD, ElementType.TYPE})，@Target注解用于指定自定义注解可以应用的程序元素类型，METHOD==代表修饰方法,TYPE==代表修饰类。

4、springMVC的参数绑定
（1）绑定的机制

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

（2）支持的数据类型

        基本类型参数：包括基本类型和 String 类型。

        POJO类型参数：包括实体类，以及关联的实体类。

        数组和集合类型参数：包括 List 结构和 Map 结构的集合（包括数组）。

        使用 ServletAPI 对象作为方法参数：HttpServletRequest、HttpServletResponse、HttpSession、java.security.Principal、Locale、InputStream、OutputStream、Reader、Writer。

（3）使用要求
  • 发送请求中携带数据的key与方法参数的name必须一致
  • 数据类型合法
（4）示例代码

        首先是创建出两个templates包下的两个html页面，一个one页面，负责完成用户完成功能二点操作界面，一个是success，用户操作成功的界面。

        最开始是进入选择页面：

    @RequestMapping("/show")
    public String show(){
        return "one";
    }

        one页面形式为：

        基本类型和String类型作为参数：

    @RequestMapping("/show2")
    public String show2(String msg1,int msg2){
        System.out.println("=====接受到用户发送数据为:"+msg1+"=======");
        System.out.println("=====接受到用户发送数据为:"+msg2+"=======");
        return "success";
    }

        对应one.html界面的a标签为：

<a href="/one/show2?msg1=jdk&msg2=9527">发送请求2</a>

        POJO 类型作为参数（对象嵌套 emp实体类里封装了dept对象）：

    @RequestMapping("/show4")
    public String show4(Emp emp){
        System.out.println("=====接受到用户发送数据为:"+emp+"=======");
        return "success";
    }

        对应one.html界面的a标签为：

    <form action="/one/show4" method="post">
        员工编号:<input type="text" name="eid" ><br/>
        员工姓名:<input type="text" name="ename" ><br/>
        员工性别:<input type="text" name="esex" ><br/>
        部门编号:<input type="text" name="dept.did" ><br/>
        部门名称:<input type="text" name="dept.dname" ><br/>
        <input type="submit" value="发送请求4"/>
    </form>

        如果只想要几个属性又不想封装实体类方法，则可以用map来解决：

    @RequestMapping("/map")
    public String map(@RequestParam Map map){
        System.out.println(map);
        return "success";
    }

        其中的@RequestParam注解用于将HTTP请求的参数绑定到处理方法的参数上。

        对应one.html界面的a标签为：

    <form action="/one/map" method="post">
        员工编号:<input type="text" name="eids"><br/>
        员工姓名:<input type="text" name="enames"><br/>
        员工性别:<input type="text" name="esexs"><br/>
        <input type="submit" value="发送请求4(map)"/>
    </form>

        POJO 类中包含集合类型参数：

        首先是通过逐一绑定来实现：

    @RequestMapping("/show5")
    public String show5(Dep dep){
        System.out.println("=====接受到用户发送数据为:"+dep+"=======");
        return "success";
    }

        对应one.html界面的a标签为：

    <form action="/one/show5" method="post">
        部门编号:<input type="text" name="did" ><br/>
        部门名称:<input type="text" name="dname" ><br/>
        员工编号1:<input type="text" name="mylist[0].eid" ><br/>
        员工姓名1:<input type="text" name="mylist[0].ename" ><br/>
        员工性别1:<input type="text" name="mylist[0].esex" ><br/>
        员工编号2:<input type="text" name="mylist[1].eid" ><br/>
        员工姓名2:<input type="text" name="mylist[1].ename" ><br/>
        员工性别2:<input type="text" name="mylist[1].esex" ><br/>

        员工编号3:<input type="text" name="myMap['one'].eid" ><br/>
        员工姓名3:<input type="text" name="myMap['one'].ename" ><br/>
        员工性别3:<input type="text" name="myMap['one'].esex" ><br/>
        员工编号4:<input type="text" name="myMap['two'].eid" ><br/>
        员工姓名4:<input type="text" name="myMap['two'].ename" ><br/>
        员工性别4:<input type="text" name="myMap['two'].esex" ><br/>
        <input type="submit" value="发送请求5"/>
    </form>

        其次是用数组来接收：

    @RequestMapping("/show6")
    public String show8(int[] nums){
        System.out.println("=====接受到用户发送数据为:"+ Arrays.toString(nums) +"=======");
        return "success";
    }

        对应one.html界面的a标签为：

<a href="/one/show6?nums=123&nums=456&nums=789">发送请求6</a>

        

        最后是使用 ServletAPI 对象作为方法参数：

    @RequestMapping("/show7")
    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 applaction =  session.getServletContext();

        return "success";
    }

        对应one.html界面的a标签为：

<a href="/one/show7">发送请求7</a>

5、springMVC常用注解
（1）@RequestParam

        作用：把请求中指定名称的参数给控制器中的形参赋值，如果页面标签名称和方法参数名称不一致，可以使用此注解实现。

        属性：

  • name属性：设置参数名称
  • defaultValue属性：设置默认值
  • required属性：设置是否为必传

        示例代码： 

        /**
     * @RequestParam("名称必须与页面标签或者url地址key名称一致")
     * */
    @RequestMapping("/show1")
    public String show1(@RequestParam(name="msg1") String msg){
        System.out.println("=====接受到用户发送数据为:"+msg+"=======");
        return "success";
    }

        例如，如果请求是/show1?msg1=hello，那么msg将等于"hello"。

        @RequestParam还有defaultValue属性：

    @RequestMapping("/show3")
    public String show4(@RequestParam(name = "uname",defaultValue = "暂无用户") String name){
        System.out.println("账号:"+name);
        return "success";
    }

        defaultValue = "暂无用户"指定了一个默认值。如果请求中没有提供uname参数，name将被赋值为"暂无用户"。

（2）@RequestBody

        作用：用于获取"请求体"内容。直接使用得到是 key=value&key=value...结构的数据，并可以转换为对象，前后端分离，@RequestBody可以将json转换为javaBean。

        属性：required：是否必须有请求体。默认值是：true。

        注意：前端不能使用GET方式提交数据，GET方式无请求体。

        示例代码：

    public String show4(@RequestBody Emp emp){
        System.out.println("=========="+emp+"==========");
        return "success";
    }

        就比如说用这段json代码来填充：

      {
      	"eid":101,
      	"ename":"詹姆斯邦德",
      	"esex":"绅士"
      }

        那么就会用把这段json代码中的数据按照键值对的方式来填充，存储在emp中。

（3）@PathVaribale

        作用：用于绑定 url 中的占位符。例如：请求 url 中 /delete/{id}，这个{id}就是 url 占位符。url 支持占位符是 spring3.0 之后加入的。是 springmvc 支持 rest 风格 URL 的一个重要标志。

        属性：

  • value：用于指定 url 中占位符名称。
  • required：是否必须提供占位符。

        示例代码：

    @PostMapping("/show5/{uname}/{pwd}")
    public String show5(@PathVariable("uname") String msg1, @PathVariable("pwd") String msg2){
        System.out.println(msg1);
        System.out.println(msg2);
        return "success";
    }
    @PostMapping("/show6/{uname}/{pwd}")
    public String show6(@PathVariable String uname, @PathVariable String pwd){
        System.out.println(uname);
        System.out.println(pwd);
        return "success";
    }

        上面这两种方式均可，都是可以直接实现路径变量的名称与方法参数的映射关系。

        Restful风格的请求是使用“url+请求方式”表示一次请求目的的，HTTP 协议里面四个表示操作方式的动词如下：

  • GET：用于获取资源
  • POST：用于新建资源
  • PUT：用于更新资源
  • DELETE：用于删除资源

        例如：

  • 新增 POST http://localhost:8080/user/用户名/用户密码/用户性别
  • 查询 GET http://localhost:8080/user/用户ID
  • 删除 delete http://localhost:8080/user/用户ID
  • 修改 put http://localhost:8080/user/用户ID/用户名/用户密码/用户性别

（4）@RequestHeader

        作用：用于获取请求消息头，获取头信息只获取头信息中的Accept-Language对应的数据(记得使用浏览器测试)。

        属性：value：提供消息头名称，required：是否必须有此消息头。

        示例代码：

    @RequestMapping("/show1")
    public String show1(@RequestHeader(value="msg1") String msg){
        System.out.println(msg);
        return "success";
    }

        必须在请求头中包含一个名为 "msg1" 的字段，其值会传递给 msg 参数，也只会传递msg1参数。

（5）@CookieValue

        作用：用于把指定 cookie 名称的值传入控制器方法参数。

        属性：

  • value：指定 cookie 的名称。
  • required：是否必须有此 cookie。

         示例代码：

    @RequestMapping("/show2")
    public String show2(@CookieValue(value = "JSESSIONID",required = false)
                                    String jsessionid){
        System.out.println(jsessionid);
        return "success";
    }

6、springMVC的数据传递
    @RequestMapping("/show")
    public String show(){
        return "index";
    }

        首先是先进入show界面：

        然后是充当试图的逻辑名称，默认页面跳转为请求转发方式：

    @RequestMapping("/show1")
    public String show1(){
        System.out.println("=========show1=========");
        return "success_String";
    }

        redirect关键词：

    @RequestMapping("/show2")
    public String show2(){
        System.out.println("=========show2=========");
        // 表示客户端会被重定向到 /show1 路径。也就是说，服务器会告诉浏览器发起一个新的请求到 /show1。这会导致浏览器的URL地址栏更新为 /show1。
        return "redirect:show1";
    }

        表示当前方法执行完毕后（show2），客户端会重定向到 /string/show1，浏览器会更新 URL 并发起新请求，再执行show1方法。

       

        forward关键词：

    @RequestMapping("/show3")
    public String show3(){
        System.out.println("=========show3=========");
        // 表示请求会被服务器内部转发到 /show1，而不会通知客户端（即浏览器）。这意味着浏览器的URL不会发生变化，仍然是 /show3，但服务器会处理 /show1 的逻辑。
        return "forward:show1";
    }

        表示当前方法执行完毕后，Spring MVC 会将请求对象直接传递给另一个处理器方法（show1()），而不会通过浏览器进行第二次请求，也不会通知浏览器客户端，所以界面不会发生变化。

        servlet方式进行获取：

@RequestMapping("/show4")
    public String show4(HttpServletRequest request){
        System.out.println("=========show4=========");
        //1.查询数据库(模拟)
        Emp emp = new Emp(1,"张毅老师","男");
        //2.获取session
        request.getSession().setAttribute("emp",emp);
        return "success_String";
    }

        通过 Spring MVC 提供的 HttpServletRequest 对象，可以访问请求信息，如参数、会话（session）等。创建一个 Emp 对象，模拟从数据库中查询到的一条记录。将创建的 Emp 对象存储在当前会话（session）中，键名为 "emp"。返回一个名为 "success_String" 的视图名称。

        再success_String.html中进行提取并打印操作：

<body>
    <h1>返回值String成功页面</h1>
    <h3>#(session.emp.eid)</h3>
    <h3>#(session.emp.ename)</h3>
    <h3>#(session.emp.esex)</h3>
</body>

        接下来有几个关键词：

  • @ResponseBody：对象转换为json
  • @RequestBody：json转换为对象
  • @RestController = @Controller + @ResponseBody

        示例代码（@ResponseBody）：

@RequestMapping("/show1")
    @ResponseBody
    public List<Emp> show1(){
        //1模拟数据库
        Emp emp1 = new Emp(1,"张毅老师","男");
        Emp emp2 = new Emp(2,"张毅老师","男");
        Emp emp3 = new Emp(3,"张毅老师","男");
        List<Emp> list = new ArrayList<>();
        list.add(emp1);
        list.add(emp2);
        list.add(emp3);
        return list;
    }

        这段代码主要是通过@ResponseBody告诉 Spring MVC 这个方法的返回值应直接作为 HTTP 响应体，而不是作为视图名称，并且返回的数据（在这里是一个 List<Emp>）会被序列化为 JSON（或 XML，取决于配置），并作为响应体发送给客户端。

        客户端的结果：

        示例代码：

    @RequestMapping("/show2")
    @ResponseBody
    public String show2(){
        return "helloWorld";
    }

        这也是一样的道理，只不过加了@ResponseBody，不会被当成视图名称，而是直接给客户端返回helloWorld。

7、Spring的文件上传

        这里主要是对七云牛云仓库的文件上传和删除操作：

        示例代码（controller层）：

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

        首先进入测试页面：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>文件上传</title>
</head>
<body>
    文件上传：
    <ol>
        <li>坐标</li>
        <li>制作页面-form表单编码</li>
        <li>通过*****接受文件</li>
    </ol>
    <hr/>
    <form action="fileupload" method="post" enctype="multipart/form-data">
        用户名:<input name="uname"/><br/>
        图片:<input name="upic" type="file"/><br/>
        <input type="submit" value="上传"/>
    </form>

</body>
</html>

        定义一个方法上传：

//文件上传
    @RequestMapping("/fileupload")
    public String fileupload(String uname, MultipartFile upic, HttpServletRequest request){
        // 上传的用户名
        System.out.println("用户名:"+uname);
        // 是上传的文件
        System.out.println(upic);
        // upic.getOriginalFilename() 获取上传文件的原始名称
        System.out.println(upic.getOriginalFilename());
        // 获取表单字段名称。
        System.out.println(upic.getName());


        //方式1.将文件upic以流的方式写入当前服务器磁盘(应用服务器)
        //方式2.文件服务器（七牛云）
        //构造一个带指定 Region 对象的配置类
        //创建一个七牛云的配置对象，并使用自动选择的区域。
        Configuration cfg = new Configuration(Region.autoRegion());
        //...其他参数参考类注释
        // 创建一个UploadManager对象，这是七牛云提供的用于上传文件的管理器。
        UploadManager uploadManager = new UploadManager(cfg);
        //...生成上传凭证，然后准备上传
        String accessKey = "7tIQFZHzpSykkNeXOqjc1fD7_7BbVtV4h_L6qHsy";
        String secretKey = "vglGxwOz1SuuZlMzqLI-N_SA9fTs_CCINwt6tU70";
        String bucket = "zrzwork";
        //默认不指定key的情况下，以文件内容的hash值作为文件名
        String key = null;
        String name = null;

        try {
            // 将上传的文件转换为字节数组uploadBytes
            byte[] uploadBytes = upic.getBytes();
            // 使用accessKey和secretKey创建一个Auth对象，用于生成上传凭证upToken。
            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";
    }

        具体实现步骤请看注释。

        每次表单上传都会调用/filedeleteload方法，完成上传。

四、注册Servlet三大组件 Servlet/Filter/Listener

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

        分别为：

  • ServletRegistrationBean 注册自定义Servlet（响应器）
  • FilterRegistrationBean 注册自定义Filter（过滤器）
  • ServletListenerRegistrationBean 注册自定义Listener（监听器）

        MyFilter层的代码：

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


    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {

        System.out.println("============请求过滤");

        request.setCharacterEncoding("utf-8");

        //分水岭
        chain.doFilter(request, response);


        response.setCharacterEncoding("utf-8");

        System.out.println("============响应过滤");
    }

}

        @WebFilter(urlPatterns = {"/*"})：这个注解将过滤器应用于所有的请求路径。"/*"表示所有URL都会经过这个过滤器。

        chain.doFilter(request, response)：这是分水岭，表示请求继续传递到下一个过滤器或目标Servlet，执行完之后，响应开始处理。

        MyListener层的代码：

@WebListener
public class MyListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        ServletContextListener.super.contextInitialized(sce);
        System.out.println("-------------MyListener inited !");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        ServletContextListener.super.contextDestroyed(sce);
        System.out.println("----------------MyListener Destroy !");
    }
}

        @WebListener：这个注解用于标记类为一个监听器，表示它会监听Web应用的某些事件。在部署时，服务器会自动注册这个监听器。

        implements ServletContextListener：实现了ServletContextListener接口，表示这个类会监听Servlet上下文（即整个Web应用）初始化和销毁的事件。

        contextInitialized方法：保证未来扩展时不会遗漏父类的处理。

        contextDestroyed方法：Web应用关闭（上下文销毁）。

        MyServlet层的代码：

@WebServlet("/myServlet")
public class MyServlet extends HttpServlet {

    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException,IOException {

        System.out.println("进入servlet");
        resp.getWriter().println("<h1>hello world</h1>");
    };

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

    }
}

        resp.getWriter().println("<h1>hello world</h1>")；向客户端返回一个简单的HTML响应（即页面上显示“hello world”）。

五、切换为其他嵌入式Servlet容器

1、SpringBoot 默认针对Servlet容器提供以下支持
  • Tomcat（默认使用）
  • Jetty ：支持长连接项目（如：聊天页面）[ˈdʒeti]
  • Undertow : 不支持 JSP , 但是并发性能高，是高性能非阻塞的容器[ˈʌndətəʊ]

        默认Tomcat容器：

在spring-boot-starter-web启动器中默认引入了tomcat容器 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <version>2.1.0.RELEASE</version>
    <scope>compile</scope>
</dependency>

        切换Jetty容器：

<dependency>
    <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 <!-- 排除tomcat容器 -->
 <exclusions>
        <exclusion>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <groupId>org.springframework.boot</groupId>
        </exclusion>
    </exclusions>
</dependency>
<!--引入其他的Servlet容器-->
<dependency>
    <artifactId>spring-boot-starter-jetty</artifactId>
    <groupId>org.springframework.boot</groupId>
</dependency>

        使用外置Servlet容器Tomcat9.x

        嵌入式Servlet容器：运行启动类就可启动，或将项目打成可执行的 jar 包

  • 优点：简单、快捷；
  • 缺点：默认不支持JSP、优化定制比较复杂使用定制器, 还需要知道 每个功能 的底层原理；

        外置Servlet容器：配置 Tomcat, 将项目部署到Tomcat中运行

派大星籽
关注
  • 20
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot WEB篇
程序员劝退师的博客
05-17 265
先使用SpringBoot初始化器初始化一个SpringBoot工程 初始化后的项目结构是这样的 WEB么肯定就会有静态界面 SpringBoot对静态资源的映射规则 这里的映射规则核心是这个，这个在WebMvcAutoConfiguration类中 @ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false) public class ResourceProperties { //spring.res
SpringBoot Web工程框架
06-09
SpringBoot Web工程框架是现代Java开发中的核心组件，它简化了基于Spring的应用程序的初始设置和配置。SpringBoot以其“开箱即用”的理念，极大地降低了开发者构建Web服务的复杂性。在这个“SpringBoot Web工程框架...
SpringBoot与Web开发（超详细）【篇一】
2401_84093490的博客
05-06 989
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！
Spring Boot的Web开发
最新发布
qq_63688997的博客
07-23 1010
SpringBoot的Web开放详细讲解，包括请求处理、参数绑定以及各种常用注解和SpringMVC的讲解。
使用Spring Boot开发Web项目
weixin_30726161的博客
12-21 3754
前面两篇博客中我们简单介绍了Spring Boot项目的创建、并且也带小伙伴们来DIY了一个Spring Boot自动配置功能，那么这些东西说到底最终还是要回归到Web上才能体现出它的更大的价值，so，今天我们就来看一下如何使用Spring Boot来开发Web项目。当然，如果小伙伴对Spring Boot尚不熟悉的话，可以先参考一下这两篇博客： 1.初识Spring B...
Springboot开发web项目
weixin_34268310的博客
07-30 553
当前，Spring毫无疑问已经成为java后台对象管理标准框架，除了通过IOC能够管理我们的自定义对象的生命周期之外还提供了众多功能繁复的可配置功能模块。但同时带来了复杂的配置项，这对初学者而言简直是一种灾难。于是SpringBoot应运而生，Springboot的出现大大简化了配置，主要表现在消除了web.xml和依赖注入配置的整合，处处遵循规约大于配置的思想，将初学者在繁杂的配置项中解放出来，...
springboot-web开发
weixin_51604685的博客
08-09 3268
这是springboot关于web开发的知识，springboot的web开发和springmvc很相似
SpringBoot的web开发
Huberyxiao的博客
01-26 851
简介 Web开发的核心内容主要包括内嵌的Servlet容器和SpringMVC。 SpringBoot使用起来非常简洁，大部分配置都有SpringBoot自动装配。 SpringBoot的web支持 SpringBoot提供了spring-boot-starter-web为web开发予以支持，而这个启动器内嵌了Tomcat以及SpringMVC依赖。而web相关的自动配置存储在spring-boot-autoconfigure.jar的org.springframework.boot.autoconfigu
狂神说springboot web开发 员工信息管理系统.zip
03-07
人工智能-项目实践-信息管理系统
SpringBoot开发第一个Web应用代码
07-09
在IT行业中，SpringBoot是一个备受推崇的框架，它极大地简化了Java Web应用程序的开发过程。SpringBoot是由Pivotal团队创建的，目的是为了使开发者能够快速地构建独立运行的、生产级别的基于Spring的应用。本教程将...
第5章 SpringBoot实现Web开发.ppt
03-08
SpringBoot实现Web开发
SpringBoot WEB入门
03-22
在IT行业中，SpringBoot是一个备受推崇的框架，它极大地简化了Spring应用的初始搭建以及开发过程。本教程将带你入门SpringBoot，特别是如何在maven环境下集成SpringBoot和JSP来构建一个WEB应用。 首先，我们需要...
SpringBoot——Web开发
前尘忆梦的博客
04-09 2401
文章目录1、SpringMVC自动配置概览2、简单功能分析2.1、静态资源访问2.1.1、静态资源目录2.1.2、静态资源访问前缀2.1.3、静态资源目录2.1.4、webjar2.2、欢迎页支持2.3、自定义 Favicon2.4、静态资源配置原理3、请求参数处理3.1、请求映射3.1.1、Rest使用与原理3.1.2、请求映射原理3.2、普通参数与基本注解3.2.1、注解 1、SpringMVC自动配置概览 https://docs.spring.io/spring-boot/docs/current/
Spring Boot的Web项目开发
2201_76023024的博客
01-02 1801
Spring 框架不断在Web开发领域发展，由于Spring兼容了各种常用的（无论过时与不过时）Web组件，并且这些组件使用时需要自己配置，导致Spring Web开发越来越复杂，学习曲线越来越陡峭。而Spring Boot将传统Web开发中的mvc、validation、tomcat等框架汇总在一起整合，形成了Spring Boot的Web组件即 spring-boot-starter-web。
SpringBoot开发Web项目
weixin_42529806的博客
01-12 494
文章目录SpringBoot-Web项目 SpringBoot-Web项目 注意：用的IDEA来示范 1、直接选择Spring Initializr项目点击【next】 步骤：File-&amp;amp;gt;new-&amp;amp;gt;Project-&amp;amp;gt;Spring Initializr-&amp;amp;gt;Next 继续Next ① 选择Web–&amp;amp;gt;web勾上 ② 选择Template Engine
SpringBoot开发web项目
weixin_45611051的博客
09-26 405
导入SpringBoot 先导入空项目 修改依赖的版本： 重新导入依赖： 引入 mybatis-spring-boot-starter依赖和 mysql连接的依赖： <!-- mybatis-spring-boot-starter依赖--> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId&
Spring Boot Web
weixin_53622554的博客
04-16 4418
首先我们先来看一下pom.xml这一份配置文件，在这份配置文件当中，最上面有这么一堆标签叫做parent，parent这里指定了一个坐标，这个是Spring Boot的父工程，我们把创建的所有的Spring Boot工程，它都需要继承自这个父工程，这个呢Maven当中叫做继承，就是来指定一个父工程，因为这些框架它都属于Spring体系内的框架，框架之间的整合会非常的容易，甚至可以说是无缝衔接，所以这是当前企业开发当中非常流行，也是非常受欢迎的一种解决方案，
SpringBoot2-Web开发
wjt19981022的博客
08-09 318
1、SpringMVC自动配置概览 Spring Boot provides auto-configuration for Spring MVC that works well with most applications.(大多场景我们都无需自定义配置) The auto-configuration adds the following features on top of Spring’s defaults: Inclusion of ContentNegotiatingViewResolve..
SpringBoot—Web开发
菜菜的博客
04-09 391
SpringBoot—Web
springbootweb开发
05-21
Spring Boot 是一个快速构建基于 Spring 框架的应用程序的工具。它为 Spring 应用程序开发提供了一种简单的方法，无需繁琐地配置 XML，只需要使用注解即可实现常见的业务逻辑。 下面是一个基本的 Spring Boot Web 应用程序的步骤： 1. 创建一个 Maven 项目，并添加 Spring Boot 的依赖。 2. 创建一个 Controller 类，并添加处理请求的方法。 3. 配置应用程序的入口点，并启动应用程序。 以下是一个简单的示例： 1. 创建 Maven 项目 使用 Maven 创建一个新的项目，可以参考以下命令： ``` mvn archetype:generate -DgroupId=com.example -DartifactId=webapp -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false ``` 2. 添加 Spring Boot 依赖 在 pom.xml 文件中添加 Spring Boot Starter Web 依赖： ``` <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies> ``` 3. 创建 Controller 类 创建一个 HomeController 类，并添加处理请求的方法： ``` @RestController public class HomeController { @GetMapping("/") public String home() { return "Hello, World!"; } } ``` 4. 配置应用程序的入口点 创建一个 SpringBootWebApplication 类，并使用 @SpringBootApplication 注解标记为应用程序的入口点： ``` @SpringBootApplication public class SpringBootWebApplication { public static void main(String[] args) { SpringApplication.run(SpringBootWebApplication.class, args); } } ``` 5. 启动应用程序 使用以下命令启动应用程序： ``` mvn spring-boot:run ``` 在浏览器中访问 http://localhost:8080/ ，即可看到 "Hello, World!"。 这就是一个简单的 Spring Boot Web 应用程序的开发过程。当然，除了以上步骤，还有很多其他的配置和实现方式，具体可以参考官方文档。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值