笔触狂放9

这个屌丝很懒，什么也没留下！

热门标签

Spring Boot 的Web开发

作者：笔触狂放9 | 2024-08-13 11:44:02

踩

Spring Boot 的Web开发

一、静态资源映射规则

总结：

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

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

二、 enjoy模板引擎

Enjoy模板引擎是一个轻量级的 Java 模板引擎，主要用于生成动态 HTML 内容。它的设计目标是简化 Java Web 应用中的页面渲染过程，同时保持高效和灵活。Enjoy模板引擎使用一种简单的语法，适用于 Java 开发者，用于创建和渲染模板。

（1）将页面保存在templates目录下


<!DOCTYPE html>
<html lang="cn" xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Title</title>
</head>
<body>
 
    <h1>springMVC控制器方法参数作用：接受用户请求中的数据</h1>
    <hr/>
 
    <h3>基本类型和 String 类型作为参数</h3>
    <a href="/one/show1?msg1=9527">发送请求1</a>
    <a href="/one/show2?msg1=jdk&msg2=9527">发送请求2</a>
 
    <h3>POJO 类型作为参数</h3>
    <a href="/one/show3?eid=7&ename=钟无艳&esex=女">发送请求3</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>
 
    <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>
 
 
    <h3>POJO 类中包含集合类型参数</h3>
    <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>
 
    <a href="/one/show6?nums=123&nums=456&nums=789">发送请求6</a>
 
    <h3>使用 ServletAPI 对象作为方法参数</h3>
    <a href="/one/show7">发送请求7</a>
 
</body>
</html>


<!DOCTYPE html>
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>spring成功页面</h1>
</body>
</html>

（2）添加坐标


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

（3）开启配置

在代码中配置 Enjoy 模板引擎，例如设置模板目录和引擎名称。一般来说，可以在应用程序的启动类中进行配置：


package com.apesource.springboot_web_02.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;
 
/**
 * @version 1.0
 * @Author 王老师
 * @since 2023/4/11
 */
@Configuration
public class SpringBootConfig {
 
    @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;
    }
}

（4）编写代码

三、 springMVC

（1）请求处理

在 Spring MVC 中，请求处理一般由控制器（Controller）来完成。你可以通过 @RequestMapping 注解定义请求的 URL 映射。


@Controller
@RequestMapping("/one")
public class OneController {
 
    /**
     * 进入one.html页面
     * */
    @RequestMapping("/show")
    public String show(){
        return "one";
    }
}

（2）参数绑定

Spring MVC 允许你将请求参数绑定到方法的参数中，例如 Java 对象、基本数据类型或集合。


@Controller
@RequestMapping("/one")
public class OneController {
 
    /**
     * 进入one.html页面
     * */
    @RequestMapping("/show")
    public String show(){
        return "one";
    }
 
    /***********************基本类型和 String 类型作为参数*********************************/
    @RequestMapping("/show1")
    public String show1(String msg1){
        System.out.println("=====接受到用户发送数据为:"+msg1+"=======");
        return "success";
    }
 
    @RequestMapping("/show2")
    public String show2(String msg1,int msg2){
        System.out.println("=====接受到用户发送数据为:"+msg1+"=======");
        System.out.println("=====接受到用户发送数据为:"+msg2+"=======");
        return "success";
    }
 
}

2.POJO类型参数：
包括实体类，以及关联的实体类
3.数组和集合类型参数：
包括 List 结构和 Map 结构的集合（包括数组）

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

二.使用要求
1.发送请求中携带数据的key与方法参数的name必须一致
2.数据类型合法


/***********************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";
    }
 
    //@RequestParam
    @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 show8(int[] nums){
        System.out.println("=====接受到用户发送数据为:"+ Arrays.toString(nums) +"=======");
        return "success";
    }
 
 
    /*********************使用 ServletAPI 对象作为方法参数*********************************/
    @RequestMapping("/show7")
    public String show7(HttpServletRequest request, HttpServletResponse response){
 
 
//        request.setCharacterEncoding("UTF-8");
//        response.setCharacterEncoding("UTF-8");
        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";
    }

（3）常用注解

在 Spring MVC 中，有一些常用注解可以帮助简化开发过程：

@Controller：标记一个类为控制器。
@RequestMapping：映射 HTTP 请求到特定方法。
@GetMapping、@PostMapping：分别用于处理 GET 和 POST 请求的快捷方式。
@RequestParam：将请求参数绑定到方法参数。
@PathVariable：从 URI 模板中提取变量并绑定到方法参数。
@RequestBody：将请求体的内容绑定到对象。
@ResponseBody：将方法返回的对象直接写入 HTTP 响应体。
@ModelAttribute：将请求参数绑定到模型对象。

一.@RequestParam
      作用：
          把请求中指定名称的参数给控制器中的形参赋值。
          如果页面标签名称和方法参数名称不一致，可以使用此注解实现
      属性：
          name属性：设置参数名称
          defaultValue属性：设置默认值
          required属性：设置是否为必传


/**
     * @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("msg1") String msg, @RequestParam("msg2") int num){
        System.out.println("=====接受到用户发送数据为:"+msg+"=======");
        System.out.println("=====接受到用户发送数据为:"+num+"=======");
        return "success";
    }
 
 
    @RequestMapping("/show3")
    public String show4(@RequestParam(name = "uname",defaultValue = "暂无用户") String name){
        System.out.println("账号:"+name);
        return "success";
    }

二.@RequestBody
      作用：
          用于获取"请求体"内容。直接使用得到是 key=value&key=value...
          结构的数据,并可以转换为对象
      属性：
          required：是否必须有请求体。默认值是:true。


/**
     * 前后端分离
     * @RequestBody可以将json ===》 javaBean
     * 注意:
     *  1.前端不能使用GET方式提交数据,GET方式无请求体
     * {
     * 	"eid":101,
     * 	"ename":"詹姆斯邦德",
     * 	"esex":"绅士"
     * }
     *
     * * */
    @RequestMapping("/show4")
    public String show4(@RequestBody Emp emp){
        System.out.println("=========="+emp+"==========");
        return "success";
    }

三.@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是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。
主要用于客户端和服务器交互类的软件，基于这个风格设计的软件可以更简洁，更有层次，
更易于实现缓存机制等。

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/用户名/用户密码/用户性别

localhost:8080/login?uname=王老师&upwd=123
localhost:8080/login/王老师/123

（4）数据传递

在 Spring MVC 中，你可以通过模型对象来传递数据到视图。通常用 Model 或 ModelAndView 类。

1.页面跳转重定向

redirect:表示浏览器执行重定向，会改变浏览器地址栏的URL。
forward:表示请求转发，URL不改变，还是原来的URL。
返回的字符串值（如"index"或"success_String"）通常会对应于Spring MVC的视图解析器配置，决定最终渲染的视图。

根据需要的行为选择使用重定向或转发，合适的设计将有助于提升用户体验和应用性能。


package com.xn.springboot_web_04.controller;
 
import com.xn.springboot_web_04.pojo.Emp;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
 
import javax.servlet.http.HttpServletRequest;
 
/**
 * 返回值为:字符串
 * */
@Controller
@RequestMapping("/string")
public class StringController_01 {
 
    /**
     * 进入首页
     * */
    @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);
        return "success_String";
    }
 
}

2、 json格式转换

@RestController 是一个在 Spring Framework 中常用的注解，主要用于简化 RESTful Web 服务的开发。它结合了 @Controller 和 @ResponseBody 的作用。以下是 @RestController 的一些关键点和特点：

1. 意义与用途

@RestController 注解用于定义一个控制器，处理 HTTP 请求并返回 JSON/XML 格式的响应体。这在构建 RESTful API 时非常有用。
当一个类被标注为 @RestController，这个类中的每个方法默认为返回 JSON 或 XML 响应，而不是渲染视图。


@Controller
@RequestMapping("/json")
public class JsonController_02 {
 
    /**
     *
     * @ResponseBody   对象====>json
     *  位置:1.类
     *      2.方法
     *
     *
     * @RequestBody    json====>对象
     * 位置:方法参数
     *
     * @RestController   =  @Controller  +  @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;
    }
 
    @RequestMapping("/show2")
    @ResponseBody
    public String show2(){
        return "helloWorld";
    }
 
}

自动响应

方法返回的对象会自动转换为 JSON（或 XML，取决于请求的 Accept 头）并写入 HTTP 响应体中，而不需要显式使用 @ResponseBody 注解。

（5）文件上传

方式1.将文件upic以流的方式写入当前服务器磁盘(应用服务器)


 <!-- 文件上传 -->
        <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>


@Controller
public class UserController {
 
    //进入测试页面
    @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());
    }
}

方式2.文件服务器（七牛云）


 <!-- 导入七牛云需要坐标 -->
        <dependency>
            <groupId>com.qiniu</groupId>
            <artifactId>qiniu-java-sdk</artifactId>
            <version>7.2.25</version>
        </dependency>
        <dependency>
            <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>


@Controller
public class UserController {
 
    //进入测试页面
    @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 = "Lo5tVZ7DcrNNVMWCaq4wPosNdrAbRv5aKGldQ__l";
        String secretKey = "N2wIAm84WQXAz63RVI82AFa81j03afQnmg4ekZMz";
        String bucket = "xiaobainn";
        //默认不指定key的情况下，以文件内容的hash值作为文件名
        String key = "2024/2.jpg";
        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";
    }
}

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

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

ServletRegistrationBean 注册自定义

Servlet FilterRegistrationBean 注册自定义Filter

ServletListenerRegistrationBean 注册自定义Listener


@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("============响应过滤");
    }
 
}


@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);
 
    }
}


 
@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 !");
    }
}

如果使用传统

@WebFilter...实现注册也可以

条件：

1.一定是自定义组件

2.启动类添加@ServletComponentScan

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

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

Tomcat（默认使用）

Jetty ：支持长连接项目（如：聊天页面）[ˈdʒeti]

Undertow : 不支持 JSP , 但是并发性能高，是高性能非阻塞的容器[ˈʌndətəʊ]

默认Tomcat容器

切换 Jetty 容器


package com.apesource.springboot04web04;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;
 
@SpringBootApplication
@ServletComponentScan
public class SpringBoot04Web04Application {
 
	public static void main(String[] args) {
		SpringApplication.run(SpringBoot04Web04Application.class, args);
	}
 
}

使用外置Servlet容器Tomcat9.x

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

优点：简单、快捷；

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

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/974694

Spring Boot 的Web开发