记录常用的Web服务实现方式，常用注解如下图源码：
image.png

添加依赖

  1. <dependency>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>
  7. 本文依赖SpringBoot版本信息：
  8. <parent>
  9.   <groupId>org.springframework.boot</groupId>
  10.   <artifactId>spring-boot-starter-parent</artifactId>
  11.   <version>2.5.0</version>
  12.   <relativePath/> <!-- lookup parent from repository -->
  13. </parent>

各种响应

  1. /**
  2.      * HTTP的所有请求方式: GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE.
  3.      *
  4.      * @param request 注入
  5.      * @return 返回字符串
  6.      */
  7.     @RequestMapping("all")
  8.     public String all(HttpServletRequest request) {
  9.         log.info("request:{}", JSONUtil.toJsonStr(request));
  10.         return "all";
  11.     }
  14.     @Data
  15.     @Builder //支持构建者模式
  16.     public static class R<T> implements Serializable {
  17.         protected Integer code;
  18.         protected String msg;
  19.         protected T data;
  21.         /**
  22.          * 响应状态码
  23.          */
  24.         interface Code {
  25.             int SUCCESS_CODE = 1;
  26.             int FAIL_CODE = 0;
  27.         }
  29.         /**
  30.          * 响应状态码
  31.          */
  32.         interface Message {
  33.             String SUCCESS_MESSAGE = "成功";
  34.             String FAIL_MESSAGE = "失败";
  35.         }
  37.         public static <T> R<T> ok() {
  38.             return new R<>(Code.SUCCESS_CODE, Message.SUCCESS_MESSAGE, null);
  39.         }
  40.     }
  42.     /**
  43.      * 响应自定义Bean
  44.      *
  45.      * @return R
  46.      * @see R
  47.      */
  48.     @RequestMapping("returnR")
  49.     public R<String> returnR() {
  50.         log.warn("returnR");
  51.         return R.ok();
  52.     }
  55.     /**
  56.      * 响应ResponseEntity
  57.      *
  58.      * @return ResponseEntity
  59.      * @see ResponseEntity
  60.      */
  61.     @RequestMapping("returnResponseEntity")
  62.     public ResponseEntity<String> returnResponseEntity() {
  63.         log.warn("returnResponseEntity");
  64.         return ResponseEntity.ok("SUCCESS");
  65.     }
  67.  /**
  68.      * 响应自定义ResponseEntity
  69.      *
  70.      * @return ResponseEntity
  71.      * @see ResponseEntity
  72.      */
  73.     @RequestMapping("returnResponseEntityHttpStatus")
  74.     public ResponseEntity<String> returnResponseEntityHttpStatus() {
  75.         log.warn("returnResponseEntityHttpStatus");
  76.         return ResponseEntity.status(HttpStatus.BAD_REQUEST)//400
  77.                 .build();
  78.     }
  81.     /**
  82.      * 注解实现响应自定义HTTP状态码
  83.      *
  84.      * @return ResponseEntity
  85.      */
  86.     @ResponseStatus(HttpStatus.BAD_REQUEST)
  87.     @RequestMapping("returnResponseStatus")
  88.     public String returnResponseStatus() {
  89.         log.warn("returnResponseStatus");
  90.         return "returnResponseStatus";
  91.     }

关于自定义响应对象，示例如下：

  1. package com.initit.sbweb.controller;
  3. import cn.hutool.db.PageResult;
  4. import com.baomidou.mybatisplus.core.metadata.IPage;
  5. import com.fasterxml.jackson.annotation.JsonFormat;
  6. import io.swagger.annotations.ApiModel;
  7. import io.swagger.annotations.ApiModelProperty;
  8. import lombok.AllArgsConstructor;
  9. import lombok.Builder;
  10. import lombok.Data;
  11. import lombok.NoArgsConstructor;
  13. import java.io.Serializable;
  14. import java.time.LocalDateTime;
  16. /**
  17.  * Result
  18.  * 统一响应解构
  19.  */
  20. @Data
  21. @AllArgsConstructor
  22. @NoArgsConstructor
  23. @Builder //支持构建者模式
  24. @ApiModel(value = "R对象", description = "统一响应对象")
  25. public class R<T> implements Serializable {
  26.     @ApiModelProperty(value = "状态码 0失败 1成功", required = true)
  27.     protected Integer code;
  28.     @ApiModelProperty(value = "提示信息")
  29.     protected String msg;
  30.     @ApiModelProperty(value = "数据")
  31.     protected T data;
  32.     @ApiModelProperty(value = "服务器响应时间 yyyy-MM-dd HH:mm:ss GMT+8", required = true)
  33.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
  34.     protected LocalDateTime responseTime = LocalDateTime.now();
  37.     /**
  38.      * 响应状态码
  39.      */
  40.     interface Code {
  41.         int SUCCESS_CODE = 1;
  42.         int FAIL_CODE = 0;
  43.     }
  45.     /**
  46.      * 响应状态码
  47.      */
  48.     interface Message {
  49.         String SUCCESS_MESSAGE = "成功";
  50.         String FAIL_MESSAGE = "失败";
  51.     }
  53.     //构造函数
  54.     private R(Integer code, String msg, T data) {
  55.         this.code = code;
  56.         this.msg = msg;
  57.         this.data = data;
  58.     }
  61. //----------- 封装常用方法-----------------
  63.     public static <T> R<T> result(Integer code, String message, T data) {
  64.         return new R<T>(code, message, data);
  65.     }
  67.     /**
  68.      * 封装特有的boolean类型
  69.      * 根据boolean类型自动封装返回类型
  70.      *
  71.      * @param result 结果
  72.      * @return R
  73.      */
  74.     public static R<Boolean> result(Boolean result) {
  75.         if (result) {
  76.             return ok();
  77.         } else {
  78.             return fail();
  79.         }
  80.     }
  82.     public static <T> R<T> ok() {
  83.         return result(Code.SUCCESS_CODE, Message.SUCCESS_MESSAGE, null);
  84.     }
  86.     public static <T> R<T> ok(T data) {
  87.         return result(Code.SUCCESS_CODE, Message.SUCCESS_MESSAGE, data);
  88.     }
  90.     public static <T> R<T> ok(String message, T data) {
  91.         return result(Code.SUCCESS_CODE, message, data);
  92.     }
  95.     public static <T> R<T> fail() {
  96.         return result(Code.FAIL_CODE, Message.FAIL_MESSAGE, null);
  97.     }
  99.     public static <T> R<T> fail(T data) {
  100.         return result(Code.FAIL_CODE, Message.FAIL_MESSAGE, data);
  101.     }
  103.     public static <T> R<T> fail(String message, T data) {
  104.         return result(Code.FAIL_CODE, message, data);
  105.     }
  107.     //支持各种分页框架  需要引入Mybatis-Plus框架
  108. //    public static <T> R<PageResult<T>> ok(IPage<T> page) {
  109. //        return result(Code.SUCCESS_CODE, Message.SUCCESS_MESSAGE, PageResult.page(page));
  110. //    }
  113.     public static <T> R<T> okMsg(String msg) {
  114.         return R.ok(msg, null);
  115.     }
  117.     public static <T> R<T> failMsg(String msg) {
  118.         return R.fail(msg, null);
  119.     }
  121. }

HTTP各种请求方式

  2.     /**
  3.      * GET请求
  4.      *
  5.      * @param str    url变量，字符串类型参数
  6.      * @param num    url变量， 数字类型参数
  7.      * @param param1 path参数1
  8.      * @param param3 path参数2，测试别名
  9.      * @return 返回字符串
  10.      */
  11.     @GetMapping("get/{param1}/{param2}/test")
  12.     public String get(String str,
  13.                       Long num,
  14.                       @PathVariable String param1,
  15.                       @PathVariable("param2") String param3
  16.     ) {
  17.         log.warn("str:{},num:{},param1:{},param2:{}", str, num, param1, param3);
  18.         return "get";
  19.     }
  22.     /**
  23.      * POST请求，地址变量
  24.      *
  25.      * @param str          url变量，字符串类型参数
  26.      * @param num          url变量， 数字类型参数
  27.      * @param pathVariable path变量
  28.      * @return 返回字符串
  29.      */
  30.     @PostMapping("postPathVariable/{pathVariable}")
  31.     public String postPathVariable(
  32.             String str,
  33.             Long num,
  34.             @PathVariable String pathVariable
  35.     ) {
  36.         log.warn("str:{},num:{}", str, num);
  37.         log.warn("pathVariable:{}", pathVariable);
  39.         return "postPathVariable";
  40.     }
  42.     /**
  43.      * POST请求，body转为JSON对象
  44.      *
  45.      * @param map     json字符串转为map
  46.      * @param request 请求对象
  47.      * @return 返回字符串
  48.      */
  49.     @PostMapping("postRequestBodyJson")
  50.     public String postRequestBodyJson(
  51.             @RequestBody Map<String, Object> map,
  52.             HttpServletRequest request
  53.     ) {
  54.         log.warn("map:{}", JSONUtil.toJsonStr(map));
  55.         log.warn(request.getRequestURI());
  56.         return "postRequestBodyJson";
  57.     }
  60.     /**
  61.      * POST请求，body转为字符串
  62.      *
  63.      * @param txt     字符串请求，使用js/xml/html等
  64.      * @param request 请求对象
  65.      * @return 返回字符串
  66.      */
  67.     @PostMapping("postRequestBodyStr")
  68.     public String postRequestBodyStr(
  69.             @RequestBody String txt,
  70.             HttpServletRequest request
  71.     ) {
  72.         log.warn("txt:{}", txt);
  73.         log.warn(request.getRequestURI() + " " + request.getContentType());
  74.         return "postRequestBodyStr";
  75.     }
  77.     /**
  78.      * POST 表单提交
  79.      *
  80.      * @param str  表单数据，文本类型
  81.      * @param file 表单数据，文件类型
  82.      * @return 返回字符串类型
  83.      */
  84.     @PostMapping("postFormData")
  85.     public String postFormData(
  86.             String str,
  87.             MultipartFile file
  88.     ) {
  89.         log.warn("str:{}", str);
  90.         log.warn("file:{}--{}--{}--{}--{}",
  91.                 JSONUtil.toJsonStr(file), file.getOriginalFilename(), file.getName(), file.getSize(), file.getContentType());
  92.         return "postFormData";
  93.     }
  96.     /**
  97.      * POST请求，多文件上传
  98.      *
  99.      * @param files 多个文件
  100.      * @return 返回字符串
  101.      */
  102.     @PostMapping("postFiles")
  103.     public String postFiles(List<MultipartFile> files) {
  104.         log.warn("files:{}", files.size());
  105.         for (MultipartFile file : files) {
  106.             log.warn("file:{}--{}--{}--{}--{}",
  107.                     JSONUtil.toJsonStr(file), file.getOriginalFilename(), file.getName(), file.getSize(), file.getContentType());
  108.         }
  109.         return "postFiles";
  110.     }
  112.     /**
  113.      * DELETE请求
  114.      *
  115.      * @param str          url参数，字符串类型
  116.      * @param num          url参数，数字类型
  117.      * @param pathVariable path参数
  118.      * @return 返回字符串
  119.      */
  120.     @DeleteMapping("delete/{pathVariable}")
  121.     public String delete(String str,
  122.                          Long num,
  123.                          @PathVariable String pathVariable
  124.     ) {
  125.         log.warn("str:{},num:{}", str, num);
  126.         log.warn("pathVariable:{}", pathVariable);
  128.         return "delete";
  129.     }
  131.     /**
  132.      * PUT请求
  133.      *
  134.      * @param str          url参数，字符串类型
  135.      * @param num          url参数，数字类型
  136.      * @param pathVariable path参数
  137.      * @return 返回字符串
  138.      */
  139.     @PutMapping("put/{pathVariable}")
  140.     public String put(
  141.             String str,
  142.             Long num,
  143.             @PathVariable String pathVariable
  144.     ) {
  145.         log.warn("str:{},num:{}", str, num);
  146.         log.warn("pathVariable:{}", pathVariable);
  147.         return "put";
  148.     }
  150.     /**
  151.      * PATH请求
  152.      *
  153.      * @return 返回字符串
  154.      */
  155.     @PatchMapping("patch")
  156.     public String put() {
  157.         log.warn("patch");
  158.         return "patch";
  159.     }

请求头

  1.  /**
  2.      * 请求头示例
  3.      *
  4.      * @param str 请求头数据，字符串类型，测试别名
  5.      * @param num 请求头数据，数字类型
  6.      * @return 字符串类型
  7.      */
  8.     @GetMapping("requestHeader")
  9.     public String requestHeader(@RequestHeader("headerStr") String str, @RequestHeader Integer num) {
  10.         log.warn("str:{},num:{}", str, num);
  11.         return "requestHeader";
  12.     }
  14.     /**
  15.      * 请求头示例，自定义模式获取
  16.      *
  17.      * @param request 请求对象
  18.      * @return 字符串类型
  19.      */
  20.     @GetMapping("requestHeaderRequest")
  21.     public String requestHeaderRequest(HttpServletRequest request) {
  22.         String str = request.getHeader("str");
  23.         String num = request.getHeader("num");
  24.         log.warn("str:{},num:{}", str, num);
  25.         return "requestHeaderRequest";
  26.     }

Cookies

  2.     /**
  3.      * 设置cookie
  4.      *
  5.      * @param response 响应对象
  6.      * @return 字符串类型
  7.      */
  8.     @GetMapping("setCookies")
  9.     public String setCookies(HttpServletResponse response) {
  10.         Cookie cookie = new Cookie("cookieStr", "test");
  11.         //设置过期时间 7天过期
  12.         cookie.setMaxAge(7 * 24 * 60 * 60);
  13.         //Https 安全cookie 该Cookie将无法在Http连接中传输，只能是Https连接中传输
  14. //        cookie.setSecure(true);
  15.         response.addCookie(cookie);
  16.         log.warn("setCookies");
  17.         return "setCookies";
  18.     }
  21.     /**
  22.      * 获取cookie
  23.      *
  24.      * @param request 请求对象
  25.      * @return 字符串类型
  26.      */
  27.     @GetMapping("getCookiesRequest")
  28.     public String getCookiesRequest(HttpServletRequest request) {
  29.         Cookie[] cookies = request.getCookies();
  30.         log.warn("cookies：{}", cookies.length);
  31.         for (Cookie cookie : cookies) {
  32.             log.warn("cookie:{}", cookie);
  33.         }
  34.         return "getCookiesRequest";
  35.     }
  37.     /**
  38.      * 获取cookie
  39.      *
  40.      * @param str cookie数据，字符串类型，测试别名
  41.      * @param num cookie数据，数字类型
  42.      * @return 返回字符串类型
  43.      */
  44.     @GetMapping("getCookies")
  45.     public String getCookies(@CookieValue(name = "cookieStr", defaultValue = "默认数据") String str, Integer num) {
  46.         log.warn("str:{},num:{}", str, num);
  47.         return "getCookies";
  48.     }

Session

  2.     /**
  3.      * 设置Session
  4.      *
  5.      * @param request 请求对象
  6.      * @return 返回字符串
  7.      */
  8.     @GetMapping("setSession")
  9.     public String setSession(HttpServletRequest request) {
  10.         HttpSession session = request.getSession();
  11.         session.setAttribute("sessionStr", "test");
  12.         session.setAttribute("num", 123);
  13.         //设置过期时间
  14.         session.setMaxInactiveInterval(30 * 60);
  15.         log.warn("setSession:{}", session);
  16.         return "setSession";
  17.     }
  19.     /**
  20.      * 获取Session
  21.      *
  22.      * @param request 请求对象
  23.      * @return 返回字符串
  24.      */
  25.     @GetMapping("getSession")
  26.     public String getSession(HttpServletRequest request) {
  27.         HttpSession session = request.getSession();
  28.         Object sessionStr = session.getAttribute("sessionStr");
  29.         log.warn("sessionStr:{}", sessionStr);
  30.         log.warn("getSession:{}", session);
  31.         return "getSession";
  32.     }
  34.     /**
  35.      * 获取Session，使用@SessionAttribute注解
  36.      *
  37.      * @param str session数据，字符串类型，别名测试
  38.      * @return 返回字符串类型
  39.      */
  40.     @GetMapping("getSessionSessionAttribute")
  41.     public String getSessionSessionAttribute(@SessionAttribute("sessionStr") String str) {
  42.         log.warn("str:{}", str);
  43.         return "getSessionSessionAttribute";
  44.     }
  47. //@SessionAttributes({"sessionStr", "num"})
  48. @SessionAttributes
  49. public class WebController {
  51.     /**
  52.      * 获取Session，使用@SessionAttributes注解
  53.      *
  54.      * @param str session数据，字符串类型，别名测试
  55.      * @param num session数据，数字类型
  56.      * @return 返回字符串类型
  57.      * <p>
  58.      * 注解@SessionAttributes抓取域对象分为两步；
  59.      * 1. 在类上添加注解@SessionAttributes；
  60.      * 2. 在方法的参数中通过@ModelAttribute获取域对象；
  61.      */
  62.     @GetMapping("getSessionSessionAttributes")
  63.     public String getSessionSessionAttributes(@ModelAttribute("sessionStr") String str, @ModelAttribute Integer num) {
  64.         log.warn("str:{},num:{}", str, num);
  65.         return "getSessionSessionAttributes";
  66.     }