精华内容
下载资源
问答
  • SpringBoot常用注解

    2020-07-06 18:51:55
    SpringBoot常用注解 @RequestMapping 用来处理请求地址映射的注解 value, method value: 指定请求的实际地址,指定的地址可以是具体地址、可以RestFul动态获取、也可以使用正则设置; method: 指定请求的method...

    SpringBoot常用注解

    @RequestMapping
    用来处理请求地址映射的注解

    value, method
    value: 指定请求的实际地址,指定的地址可以是具体地址、可以RestFul动态获取、也可以使用正则设置;

    method: 指定请求的method类型, 分为GET、POST、PUT、DELETE等;

    consumes,produces
    consumes: 指定处理请求的提交内容类型(Content-Type),例如application/json, text/html;

    produces: 指定返回的内容类型,仅当request请求头中的(Accept)类型中包含该指定类型才返回;

    params,headers
    params: 指定request中必须包含某些参数值是,才让该方法处理。

    headers: 指定request中必须包含某些指定的header值,才能让该方法处理请求。

    @RestController
    @RestController注解相当于@ResponseBody + @Controller合在一起的作用

    @Controller
    定义一个Controller控制器

    @PathVariable(“xxx”)
    通过 @PathVariable 可以将URL中占位符参数{xxx}绑定到处理器类的方法形参中@PathVariable(“xxx“)
    @RequestMapping(value=”user/{id}/{name}”)
    请求路径:http://localhost:8080/hello/show5/1/james

    @ResponseBody
    将controller的方法返回的对象通过适当的转换器转换为指定的格式之后,写入到response对象的body区,通常用来返回JSON数据或者是XML
    数据,需要注意的呢,在使用此注解之后不会再走试图处理器,而是直接将数据写入到输入流中,他的效果等同于通过response对象输出指定格式的数据。

    @Api
    用作注释说明以及生成文档
    https://www.jianshu.com/p/c79f6a14f6c9

    @Autowired
    它可以对类成员变量、方法及构造函数进行标注,让 spring 完成 bean 自动装配的工作。

    @Acl
    可以方便地提供数据的读写控制权限

    @ApiOperation
    接口注释
    @GetMapping,处理get请求
    @PostMapping,处理post请求
    @PutMapping,处理put请求
    @DeleteMapping,处理delete请求

    restful风格
    https://blog.csdn.net/qq_27026603/article/details/82012277

    @RequestBody
    接收请求参数封装成JavaBean
    接受的是一个json格式的字符串,一定是一个字符串。
    将HttpRequest的请求体映射为Java的POJO对象

    @Validated
    校验请求参数

    @Data
    注解功能
    1、@Data可以为类提供读写功能,从而不用写get、set方法。
    2、他还会为类提供 equals()、hashCode()、toString() 方法。

    注解注释
    @author xiongzg001@cmft.com 作者名
    @date 2019/4/16 日期
    @time 16:12 具体时间
    @since JDK1.8 jdk版本

    业务层注解
    @Slf4j
    实现日志输出
    log.debug(“debug”);//默认日志级别为info
    log.info(“info”);
    log.error(“error”);
    log.warn(“warn”);

    @Service
    标注业务层组件

    @Mapper
    mybatis3.4.0开始加入了@Mapper注解,目的就是为了不再写mapper映射文件

    • 添加了@Mapper注解之后这个接口在编译时会生成相应的实现类
    • 需要注意的是:这个接口中不可以定义同名的方法,因为会生成相同的id
    • 也就是说这个接口是不支持重载的

    @Repository
    标注数据层组件

    展开全文
  • SpringBoot常用注解有哪些 一注解(annotations)列表? @Configuration?等同于spring的XML配置文件使用Java代码可以检查类型安全 @EnableAutoConfiguration?自动配置 @ComponentScan?组件扫描可自动发现和装配一些Bean...
  • No.3.2.4_1 SpringBoot常用注解、lombok常用注解、SpringBoot完整项目 0.创建springboot项目 1.主程序类(@SpringBootApplication) 2.Controller层 3.Service层 4.注入Bean 5.其他 6.lombok插件 7.springboot常见...

    相关链接


    目录


    springboot-annotation


    版本:
      JDK:1.8
      Spring:5.3.8
      Springboot:2.5.2
      lombok:1.16.10

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.5.2</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
        <groupId>com.springboot</groupId>
        <artifactId>annotation</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>annotation</name>
        <description>Demo project for Spring Boot</description>
        <properties>
            <java.version>1.8</java.version>
        </properties>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <!--视图解析器 freemarker-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-freemarker</artifactId>
            </dependency>
            <!-- SpringBoot中使用lombok -->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.16.10</version>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    
    

    注意: 不同版本之间注解会存在差异,例如@CrossOrigin注解

    在这里插入图片描述


    • @Component: 泛指组件,当组件不好归类的时候,我们可以使用这个注解进行标注;
    • @Repository: 用于标注数据访问组件,即DAO组件;
    • @Service: 用于标注业务层组件(业务逻辑);
    • @Controller: 用于标注控制层组件(不包含业务逻辑);

    • DispatcherServlet: 前端控制器 拦截前端所有请求:任务调度和分发;
    • 映射器: Handler 配置的映射对象;
    • 适配器: 通过ModelAndView寻找具体的处理器 Controller,以及Controller与前端进行数据交互;
    • 视图解析器: 根据返回的逻辑视图找到对应的物理视图,并且将其封装成一个View对象,由视图渲染器进行视图的渲染最终展现给用户,有JSP,Volocity,或下面用到的 Freemarker;

    在这里插入图片描述


    〇、创建springboot项目

    • Step1: New Project

    在这里插入图片描述

    • Step2: Spring Initializr

    在这里插入图片描述

    • Step3: wait

    在这里插入图片描述

    • Step4: Java version 8

    在这里插入图片描述

    • Step5: 导入依赖 Spring web

    在这里插入图片描述

    • Step7: Finish

    在这里插入图片描述

    • Step8: Wait (没有Maven的需要配置Maven,过程省略)

    在这里插入图片描述

    • Step9: Finish (默认端口8080)

    在这里插入图片描述

    • Step10: 解决pom.xml报红问题(不影响项目运行)File -> Invalidate Caches / Restart... -> Invalidate and Restart 清除缓存并重启IDEA就可以解决

    在这里插入图片描述


    一、主程序类


    1. @SpringBootApplication


    @SpringBootApplication: 是Sprnig Boot项目的核心注解,目的是开启自动配置。包含以下三个@

      @SpringBootConfiguration: 声明当前类是SpringBoot应用的配置类。
      (项目中只能有一个,一般无需自己添加。)

      @EnableAutoConfiguration: 开启自动配置。
      告诉SpringBoot基于所添加的依赖,去"猜测"你想要如何配置Spring。
      比如我们引入了spring-boot-starter-web,而这个启动器中帮我们添加了tomcat、SpringMVC的依赖,此时自动配置就知道你是要开发一个web应用,所以就帮你完成了web及SpringMVC的默认配置了!我们使用SpringBoot构建一个项目,只需要引入所需框架的依赖,配置就可以交给SpringBoot处理了。

      @ComponentScan: 配置组件扫描的指令。
      提供了类似与<context:component-scan>标签的作用。通过basePackageClasses或者basePackages属性来指定要扫描的包。
      如果没有指定这些属性,那么将从声明这个注解的类所在的包开始,扫描包及子包。而我们的@SpringBootApplication注解声明的类就是main函数所在的启动类。
      因此扫描的包是该类所在包及其子包。因此,一般启动类会放在一个比较前的包目录中。

    20210706171655927


    二、Controller层(控制层)


    2.1 类注解 TYPE


    1. @Controller 注入ioc容器->controller层 ⭐️


    a.作用域:
      ElementType.TYPE:类、接口、枚举。

    b.功能:
      1. @Controller用于标记在一个类上,使用它标记的类就是一个SpringMvc Controller对象,分发处理器会扫描使用该注解的类的方法,并检测该方法是否使用了@RequestMapping注解。
      2. @Controller只是定义了一个控制器类,而使用@RequestMapping注解的方法才是处理请求的处理器。

    c.参数:
      value:指定注入ioc容器中的名称(Bean的id),如果不指定则默认为类名首字母小写(例如UserController -> userController)

    d.返回数据类型:
      具体页面(比如*.html)

    e.相关注解:
      1. 常见组合:@Controller(类) + @RequestMapping(类) + @GetMapping(方法)+ @RequestParam(参数)
      2. 注解合并:@Controller + @ResponseBody = @RestController
      3. 对比注解:@Controller 与 @RestController(2.5.1)


    ViewController : 处理器

    package com.springboot.annotation.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    /**
     * @author GroupiesM
     * @date 2021/07/06
     * @introduction 1.controller注解相关的测试
     *
     * \@Controller 与 @RequestMapping
     */
    @Controller
    public class ViewController {
        /**
         * 不带数据直接返回页面
         * @return String
         */
        @RequestMapping("view")//url:http://localhost:8080/page/view
        public String view() {
            return "view.html";
        }
    }
    

    view.html: 页面(必须放在图中为位置,否则读不到)

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>视图页面</title>
    </head>
    <body>
    	<div>我的页面</div>
    </body>
    </html>
    

    Step1: 使用浏览器访问 http://localhost:8080/view

    在这里插入图片描述

    Step2: 每次都写.html太麻烦了,在 application.properties 配置视图解析器(ViewResolver)前后缀

    spring.mvc.view.prefix=/
    spring.mvc.view.suffix=.html
    

    在这里插入图片描述

    Step3: 再次访问http://localhost:8080/view

    在这里插入图片描述

    Step4: 上面都是不带数据只返回页面,下面要带数据返回 view.html 页面

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>视图页面</title>
    </head>
    <body>
        <div>我的页面</div>
        <hr><div>${str1}</div>
        <hr><div>${str2}</div>
    </body>
    </html>
    

    Step5: 再次访问 http://localhost:8080/view

    在这里插入图片描述

    视图解析器: 常用的有 jsp、Volocity、Freemarker等。其中jsp视图解析器配置比较复杂,演示用freemarker解析比较方便

    在这里插入图片描述

    Step6: pom.xml 中引入freemarker(视图解析器,用来数据交互)

            <!--视图解析器 freemarker-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-freemarker</artifactId>
            </dependency>
    

    Step7: application.properteis配置freemarker

    #spring视图解析器
    ##页面视图前缀
    spring.mvc.view.prefix=/
    ##页面视图后缀
    spring.mvc.view.suffix=.html
    
    #freeMarker视图解析器
    ##后缀
    spring.freemarker.suffix=.html
    ##指定资源(页面)默认路径,默认指向templates路径
    spring.freemarker.template-loader-path=classpath:/static/
    

    在这里插入图片描述

    Step8: ViewController新增返回数据方法 dataview,并稍加改造

    在这里插入图片描述

    package com.springboot.annotation.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.servlet.ModelAndView;
    
    /**
     * @author GroupiesM
     * @date 2021/07/06
     * @introduction 1.controller注解相关的测试
     *
     * \@Controller 与 @RequestMapping
     */
    @Controller
    @RequestMapping("/page")
    public class ViewController {
    
        public static final String PAGE = "view";
    
        /**
         * 不带数据直接返回页面
         * @return String
         */
        @RequestMapping("/view")//url:http://localhost:8080/page/view
        public String view(){
            return PAGE;
        }
    
        /**
         * 带数据的返回页面
         * @return ModelAndView
         */
        @RequestMapping("/dataview")//url:http://localhost:8080/page/dataview
        public ModelAndView dataView(){
            ModelAndView view = new ModelAndView(PAGE);
            view.addObject("str1","我叫hello!");
            view.addObject("str2","我是张三!");
            return view;
        }
    }
    

    Step10: 访问 http://localhost:8080/page/view (不返回数据)

    在这里插入图片描述

    Step11: 访问 http://localhost:8080/page/dataview (返回数据),成功解析

    在这里插入图片描述


    2. @RequestMapping 映射->资源目录 ⭐️


    a.作用域:
      1. ElementType.TYPE:类、接口、枚举;
      2. ElementType.METHOD:方法。

    b.功能:
      配置http请求(url访问地址、请求方式、请求头等)。

    c.参数
      1. name:为这个映射分配一个名称;
      2. ⭐️value:映射的资源路径,与 path() 等价;
        @RequestMapping ("/getusers") 普通传参,使用@RequestParam或@RequestBody接收参数
        @RequestMapping ("/getbyid/{id}") restful风格传参,使用@PahVariable接收参数
      3. path:映射的资源路径,与 value() 等价;
      4. method:要映射到http请求方法,共八种(GET、POST、HEAD、OPTIONS、PUT、PATCH、DELETE、TRACE);
      5. params:映射的请求参数;
      6. headers:映射的请求头;
      7. consumes:映射的Content-type请求信格式,例如
        consumes = “text/plain” => HTML格式
        consumes = {“text/plain”, “application/"} => 纯文本格式
        consumes = MediaType.TEXT_PLAIN_VALUE => ?
      8. produces:映射的返回数据的类型以及编码;
        produces = “text/plain” => HTML格式
        produces = {“text/plain”, "application/”} => 纯文本格式
        produces = MediaType.TEXT_PLAIN_VALUE => ?
        produces = “text/plain;charset=UTF-8” => HTML格式,编码UTF-8
        produces = “application/json;charset=UTF-8” => JSON对象,编码UTF-8(返回json对象时一定要加这个,手动返回json字符串前端不能使用)

    d.相关注解:
      1. 常见组合:@Controller(类) + @RequestMapping(类) + @GetMapping(方法)+ @RequestParam(参数)
      2. 注解合并:@RequestMapping可以使用在接口、类、枚举、方法上,@GETMapping、@POSTMapping等只能使用在方法上
        REST模式:POST,GET,PUT,DELETE,PATCH的含义与区别
       @RequestMapping(value = “user” , method = RequestMethod.GET) = @GetMapping(“user”)
       @RequestMapping(value = “user” , method = RequestMethod.POST) = @PostMapping(“user”)
       @RequestMapping(value = “user” , method = RequestMethod.PUT) = @PutMapping(“user”)
       @RequestMapping(value = “user” , method = RequestMethod.DELETE) = @DeleteMapping(“user”)
       @RequestMapping(value = “user” , method = RequestMethod.PATCH) = @PatchMapping(“user”)


    映射资源目录示例(详细使用方法在2.1.1@Controller)
    在这里插入图片描述


    3. @ResponseBody 后端 -> 浏览器 json对象⭐️


    a.作用域:
      1. ElementType.TYPE:类、接口、枚举;
      2. ElementType.METHOD:方法。

    b.功能:
      1. 将java对象转为json对象(下面示例中返回User实体类,自动解析为json)。
      2. 将controller的方法返回的对象通过适当的转换器转换为指定的格式之后,写入到response对象的body区,通常用来返回JSON数据或者是XML数据。
      3. 表示该方法的返回结果直接写入 HTTP responsebody 中,一般在异步获取数据时使用(也就是AJAX)。

    c.参数:
      

    d.相关注解:
      注解合并:@Controller + @ResponseBody = @RestController


    User 实体类

    package com.springboot.annotation.entity;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @AllArgsConstructor//全参构造
    @NoArgsConstructor//无参构造
    public class User {
       private int id;//身份证
       private String name;//姓名
       private String gender;//性别
       private int age;//年龄
       //private List<String> hobbies;
       private String[] hobbies;//爱好
    }
    

    UserController 处理器

    package com.springboot.annotation.controller;
    
    import com.springboot.annotation.entity.User;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.*;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author GroupiesM
     * @date 2021/07/07
     * @introduction 4.@RequestBody相关测试
     */
    @Controller
    public class UserController {
        private static List<User> users = new ArrayList<>();
    
        //静态代码块--存储用户信息
        static {
            users.add(new User(1, "张三", "男", 20, new String[]{"足球", "篮球"}));
            users.add(new User(2, "李四", "女", 21, new String[]{"舞蹈"}));
        }
    
        /**
         * 查询用户
         * @return
         */
        @GetMapping("/get/user/a")//http://localhost:8080/get/user/a
        public Object get() {
            return users;
        }
    
        /**
         * 查询用户,返回json对象 @ResponseBody
         * @return
         */
        @ResponseBody
        @GetMapping("/get/user/b")//http://localhost:8080/get/user/b
        public Object getUser() {
            return users;
        }
    }
    

    Postman请求java对象 (没有@ResponseBody) http://localhost:8080/get/user/a

    在这里插入图片描述

    Postman请求java对象 (添加@ResponseBody)http://localhost:8080/get/user/b

    user对象转为json对象
    在这里插入图片描述


    4. @CrossOrigin 解决跨域问题


    a.作用域:
      1. ElementType.TYPE:类、接口、枚举;
      2. ElementType.METHOD:方法。

    b.功能:
      1. 用于允许特定处理程序类和/或处理程序方法上的跨源请求(解决跨域问题)。
      2. 需要在每个接口上添加此注解,或者统一使用过滤器进行配置,效果相同。

    c.参数:
      1.origins:允许可访问的域列表 @CrossOrigin(origins = "http://domain2.com")
      2. ⭐️value:允许可访问的域列表,与 origins() 等价;
      3. originPatterns:允许可访问的域列表,正则表达式,更加灵活;
      4. allowedHeaders:允许访问的请求头列表,默认 allowedHeaders = {"*"}
        1. *表示允许所有请求头。
        2. 允许访问的请求头在 响应首部(Access-Control-Allow-Headers)预检请求(preflight request)中列出(没看懂)。
      5. exposedHeaders:用户代理(user-agent)允许访问的响应头列表 => HTTP Headers
        Cache-Control:?
        Content-Language:?
        Content-Type:指示服务器文档的MIME 类型。帮助用户代理(浏览器)去处理接收到的数据。
        Expires:?
        Last-Modified:?
        Pragma:?
      6. methods:支持的HTTP请求方法列表,默认与当前controller一致
      7. allowCredentials:默认情况下,标准的跨域请求是不会发送cookie等用户认证凭据的。打开后可以携带cookiec等信息。默认allowCredentials = “false”
        a. allowCredentials = “true” 表示对已配置域的高度信任,并通过公开特定于用户的敏感信息(如cookie和CSRF令牌),增加了web项目的攻击层面(attack surface)。
        b. allowCredentials = “true” 时,远程服务器也要作相应的处理。在响应头那里设置 Access-Control-Allow-Credentials: true 。如果没有这个设置的话,浏览器就会报错。
        c. allowCredentials = “true” 时,Access-Control-Allow-Origin不能设置为 *
      8. maxAge:准备响应前的缓存持续的最大时间(秒),默认maxAge = -1

    d.名词解释:
      跨域: 指的是浏览器不能执行其他网站的脚本。它是由浏览器的同源策略造成的,是浏览器对javascript施加的安全限制。
      同源策略:是指协议,域名,端口都要相同,其中有一个不同都会产生跨域;
       跨域问题以及使用@CROSSORIGIN解决
       注解@CrossOrigin解决跨域问题


    UserController 处理器 添加@CrossOrigin
    (表示来自本地8090端口的跨域请求可以访问以下两个资源 get 和 getUser)

    package com.springboot.annotation.controller;
    
    import com.springboot.annotation.entity.User;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.*;
    
    import java.util.ArrayList;
    import java.util.List;
    
    @Controller
    public class UserController {
        private static List<User> users = new ArrayList<>();
    
        //静态代码块--存储用户信息
        static {
            users.add(new User(1, "张三", "男", 20, new String[]{"足球", "篮球"}));
            users.add(new User(2, "李四", "女", 21, new String[]{"舞蹈"}));
        }
    
        /**
         * 查询用户
         * @return
         */
        @CrossOrigin(origins = "http://localhost:8090")
        @GetMapping("/get/user/a")//http://localhost:8080/get/user/a
        public Object get() {
            return users;
        }
    
        /**
         * 查询用户,返回json对象 @ResponseBody
         * @return
         */
        @ResponseBody
        @CrossOrigin(origins = "http://localhost:8090")
        @GetMapping("/get/user/b")//http://localhost:8080/get/user/b
        public Object getUser() {
            return users;
        }
    }
    

    2.2 方法注解 METHOD


    1. @RequestMapping => 2.1.2 🚕


    2. @CrossOrigin => 2.1.4 🚕


    2.3 参数注解 PARAMETER


    1. @RequestParam 获取 -> get请求参数 ⭐️


    a.作用域:
      ElementType.PARAMETER:参数。

    b.功能:
      1. 用于将请求参数区域的数据映射到控制层方法的参数上。
      2. 搭配@GetMapping使用,接收get请求 ?后面的参数。
      3. 搭配@PostMapping使用,接收post请求?后面的参数。
      4. 当请求中缺少某个参数时,默认为null,对于基本数据类型变量,则必须有值,如果允许空值,需要使用包装类声明;

    c.参数:
      1. name:请求的参数名,默认为接收参数的变量名;
      2. ⭐️value:请求的参数名,默认为接收参数的变量名,与name()等价;

    在这里插入图片描述

      3. required:请求时该参数是否必传,默认required = true
      4. defaultValue:参数的默认值,支持SpEL表达式。默认defaultValue = ValueConstants.DEFAULT_NONE,因为不能在注解的属性中使用null来表示空值,所以用这段16位Unicode的字符串来表示空值,并且是不会发生这段字符串与用户定义的值是一样的情况。避免了用户给出的值却被当作是空值的情况(value = \n\t\t\n\t\t\n\uE000\uE001\uE002\n\t\t\t\t\n时会被处理为null);

    在这里插入图片描述

    d.请求格式:
      多个参数用&隔开: http://localhost:8080/param?id=1&type=苹果&discount=80%&price=3元

    e.相关注解:
      1. 常见组合:@Controller(类) + @RequestMapping(类) + @GetMapping(方法)+ @RequestParam(参数)
      2. 对比注解:@RequesetParam、@PathVariable、@RequestBody(2.5.2)


    ParamController 处理器

    package com.springboot.annotation.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.servlet.ModelAndView;
    
    /**
     * @author GroupiesM
     * @date 2021/07/06
     * @introduction 参数相关的测试
     */
    @Controller
    public class ParamController {
        public static final String PAGE = "param";
    
        @RequestMapping("/param")
        public ModelAndView param(//必须传参
                                  @RequestParam(value = "id") int id,
                                  //可以不传参,但在类中要进行赋值,否则freeMarker解析页面时会报错
                                  @RequestParam(value = "type", required = false) String type,
                                  //可以不传参,取默认值
                                  @RequestParam(value = "discount", required = false, defaultValue = "80%") String discount,
                                  //可以不传参,取默认值
                                  @RequestParam(value = "price",defaultValue = "5元") String price) {
            //作用类似于上面 @RequestParam注解中的属性 defaultValue="苹果"
            //不同的是 defaultValue会让required默认转为false
            if (type == null) {
                type = "苹果";
            }
            System.out.print("id = " + id);
            System.out.print(" type = " + type);
            System.out.print(" price = " + price);
            System.out.println(" discount = " + discount);
    
            ModelAndView view = new ModelAndView(PAGE);
            view.addObject("id", id);
            view.addObject("type", type);
            view.addObject("price", price);
            view.addObject("discount", discount);
            return view;
        }
    }
    

    param.html 页面

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>参数测试</title>
    </head>
    <body>
    	<h2>${id}</h2>
    	<h2>${type}</h2>
    	<h2>${discount}</h2>
    	<h2>${price}</h2>
    </body>
    </html>
    

    Step1: 编辑要访问的页面param.html

    在这里插入图片描述

    Step2: 接受请求参数的控制类ParamController

    在这里插入图片描述

    Step3: 获得浏览器提交的请求参数

    在这里插入图片描述

    Step4: 默认required = fasle(必须传参),get请求没有给id传值,导致报错;

    在这里插入图片描述

    Step5: 解决方式:RequstMapping添加属性 ,required = false(允许为空),defaultValue = 0(默认值为0,默认defaultValue = null,基本类型接收null也会报错);

    在这里插入图片描述

    Step6: 请求多个参数时(id,type,price,discount)的页面;

    在这里插入图片描述

    Step7: 请求参数不完整时,由于type值为null,会报错;

    在这里插入图片描述

    Step8: 可以在代码中给默认值,效果等类似 defaultValue(但例如基本数据类型int就不可以通过判断 == null进行赋值,所以不完全一样);

    在这里插入图片描述

    Step9: 测试正常传值的效果;

    在这里插入图片描述


    2. @RequestBody 浏览器 -> 后端 json数据(post请求) ⭐️


    a.作用域:
      ElementType.PARAMETER:参数。

    b.功能:
      1. 用于将请求体区域的数据【前端返回json内容给后端】映射到控制层方法的参数【后端接收的是java对象(自定义entity)】上。
      2. 搭配@PostMapping使用,接收post请求中,请求体携带的json字符串。
      3. @RequestBody接收数据时,前端不能使用get方式提交数据(get方式没有请求体),而是用post方式进行提交。

    c.参数:
      required:该参数get请求时是否必传,默认required = true

    d.请求格式:
      post -> body -> raw -> JSON

      {
          "id":66,
          "name": "admin",
          "gender": "男",
          "age": 33,
          "hobbies": [
              "睡觉"
          ]
      }
    

    e.相关注解:
      1. 常见组合:@Controller(类) + @RequestMapping(类) + @PostMapping(方法)+ @RequestBody(参数)
      2. 对比注解:@RequesetParam、@PathVariable、@RequestBody(2.5.2)


    User : 实体类

    package com.springboot.annotation.entity;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @AllArgsConstructor//全参构造
    @NoArgsConstructor//无参构造
    public class User {
       private int id;//身份证
       private String name;//姓名
       private String gender;//性别
       private int age;//年龄
       private String[] hobbies;//爱好
    }
    

    UserRestController : 处理器

    package com.springboot.annotation.controller;
    
    import com.springboot.annotation.entity.User;
    import org.springframework.web.bind.annotation.*;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    @RestController
    @RequestMapping("/user")
    public class UserRestController {
        private static List<User> users = new ArrayList<>();
        private static List<User> returnUser;
    
        //静态代码块--存储用户信息
        static {users.add(new User(1, "张三", "男", 20,new String[]{"足球", "篮球"}))}
    
        /**
         * 新增数据,返回所有用户
         * @param user
         * @return
         */
        @PostMapping("/post")//http://localhost:8080/user/post
        public List<User> addUser(@RequestBody User user) {
            users.add(user);
            return users;
        }
    

    Postman请求示例:

    在这里插入图片描述


    3. @PathVariable 获取 -> restful风格请求参数


    a.作用域:
      ElementType.PARAMETER:参数。

    b.功能:
      1. 映射URL绑定的占位符。
      2. 带占位符的URL是 Spring3.0 新增的功能,URL中的 {xxx} 占位符可以通过 @PathVariable(“xxx”) 绑定到操作方法的入参中。

    c.参数:
      1. name:请求的参数名,默认为接收参数的变量名;
      2. ⭐️value:请求的参数名,默认为接收参数的变量名,与name()等价;
      3. required:该参数请求时是否必传,默认required = true

    在这里插入图片描述

    d.请求格式:
      多个参数用&隔开: http://localhost:8080/param?1/苹果/0.8/3元

    e.相关注解:
      1. 常见组合:@Controller(类) + @RequestMapping(类) + @GetMapping(方法)+ @PathVariable(参数)
      2. 对比注解:@RequesetParam、@PathVariable、@RequestBody(2.5.2)


    ParamController: 处理器

    package com.springboot.annotation.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.servlet.ModelAndView;
    
    @Controller
    public class ParamController {
        public static final String PAGE = "param";
    
        @RequestMapping("/param")
        public ModelAndView param(//必须传参
                                  @RequestParam(value = "id") int id,
                                  //可以不传参,但在类中要进行赋值,否则freeMarker解析页面时会报错
                                  @RequestParam(value = "type", required = false) String type,
                                  //可以不传参,取默认值
                                  @RequestParam(value = "discount", required = false, defaultValue = "80%") String discount,
                                  //可以不传参,取默认值
                                  @RequestParam(value = "price", defaultValue = "5元") String price) {
            //作用类似于上面 @RequestParam注解中的属性 defaultValue="苹果"
            //不同的是 defaultValue会让required默认转为false
            if (type == null) {
                type = "苹果";
            }
            System.out.print("id = " + id);
            System.out.print(" type = " + type);
            System.out.print(" price = " + price);
            System.out.println(" discount = " + discount);
    
            ModelAndView view = new ModelAndView(PAGE);
            view.addObject("id", id);
            view.addObject("type", type);
            view.addObject("discount", discount);
            view.addObject("price", price);
            return view;
        }
    
        @RequestMapping("/param/{id}/{type}/{discount}/{price}")
        public ModelAndView path(@PathVariable(required = false) int id,
                                 @PathVariable(required = false) String type,
                                 @PathVariable(required = false) String discount,
                                 @PathVariable(required = false) String price) {
            if (discount == null) {
                discount = "80%";
            }
            if (price == null) {
                price = "5元";
            }
            System.out.print("id = " + id);
            System.out.println("type = " + type);
            System.out.print(" price = " + price);
            System.out.println(" discount = " + discount);
    
            ModelAndView view = new ModelAndView(PAGE);
    
            view.addObject("id", id);
            view.addObject("type", type);
            view.addObject("discount", discount);
            view.addObject("price", price);
            return view;
        }
    }
    

    param.html: 页面

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>参数测试</title>
    </head>
    <body>
    	<h2>${id}</h2>
    	<h2>${type}</h2>
    	<h2>${discount}</h2>
    	<h2>${price}</h2>
    </body>
    </html>
    

    Step1: 使用Path格式正常请求

    在这里插入图片描述

    Step2: 使用Path格式请求,带特殊符号%

    在这里插入图片描述

    Step3: 使用Path请求缺少参数时(没有映射缺少参数的URL地址)

    20210707110928514

    Step4: 使用Path请求缺少参数时,需要先在Mapping中映射多个URL地址

    在这里插入图片描述


    2.4 合并注解

    1. @RestController 注入ioc容器->controller层⭐️


    a.作用域:
      ElementType.TYPE:类、接口、枚举。

    b.功能:
      1. @RestController = @Controller + @Responsebody 等于同时了这添加两个注解。
      2. @RestController 用于标记在一个类上,使用它标记的类就是一个SpringMvc Controller对象,分发处理器会扫描使用该注解的类的方法,并检测该方法是否使用了@RequestMapping注解。
      3. 将Controller的方法返回的对象,通过 HttpMessageConverter 转换为指定格式后,写入到Response对象的body数据区。
      4. 使用此注解此次请求将不再走视图处理器,而是直接将此响应结果写入到输入流中,其效果等同于使用response对象输出指定格式的数据(java对象转为json对象)。

    c.参数:
      1. ⭐️value:指定注入ioc容器中的名称(Bean的id),如果不指定则默认为类名首字母小写(例如UserController -> userController),与 @Controller.value等价;
      2. ⭐️Controller.value:与 @Component.value等价;

    d.返回数据类型:
      返回数据(对象,json,xml等)

    e.相关注解:
      1. 常见组合:@Restcontroller(类) + @RequestMapping(value = “/xxx”, produces = “application/json;charset=UTF-8”)(类) + @PostMapping(方法)+ @RequestBody(参数)
      2. 注解合并:@Controller + @ResponseBody = @RestController
      3. 对比注解:@Controller 与 @RestController(2.5.1)


    Step1: @RestController返回数据 (返回一个String)

    在这里插入图片描述

    Step2: @RestController返回数据 (返回一个entity,entity通过HttpMessageConverter转为json对象)

    在这里插入图片描述
      使用Postman请求页面
    在这里插入图片描述


    Users 实体类: 修改用户属性

    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    @Data
    @AllArgsConstructor//全参构造
    @NoArgsConstructor//无参构造
    public class User {
       private int id;//身份证
       private String name;//姓名
       private String gender;//性别
       private int age;//年龄
       private String[] hobbies;//爱好
    }
    

    UserController 用户处理器

    package com.springboot.annotation.controller;
    
    import com.springboot.annotation.entity.User;
    import org.springframework.web.bind.annotation.*;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author GroupiesM
     * @date 2021/07/07
     * @introduction 3.RestController注解相关测试
     *
     * \@RestController 与 @GetMapping
     */
    
    @RestController
    @RequestMapping("user")
    public class UserController {
        private static List<User> users = new ArrayList<>();
        private static List<User> returnUser;
        //静态代码块--存储用户信息
        static {
            users.add(new User(1, "张三", "男", 20, new String[]{"足球","篮球"}));
            users.add(new User(2, "李四", "女", 21, new String[]{"舞蹈"}));
            users.add(new User(3, "林青霞", "女", 22, new String[]{"唱歌","看电影"}));
        }
        @GetMapping("/get")//http://localhost:8080/user/get
        public Object get() {
            ArrayList<Object> arr = new ArrayList<>();
            User user = new User(1, "张三", "男", 20, new String[]{"足球","篮球"});
            System.out.println(user.toString());
            return user;
        }
    
        //通过性别查找用户的方法(@RequestParam传参)
        @GetMapping("/getbygender")//http://localhost:8080/user/getbygender
        public static Object getByGenderA(@RequestParam(value = "gender") String gender) {
            returnUser = new ArrayList<>();
            for (User user : UserController.users) {
                if (user.getGender().equals(gender)) {
                    returnUser.add(user);
                }
            }
            System.out.println(returnUser);
            return returnUser;
        }
    
        //通过性别查找用户的方法(@PathVariable传参)
        @GetMapping("/getbygender/{gender}")//http://localhost:8080/user/getbygender
        public static Object getByGenderB(@PathVariable("gender") String gender) {
            returnUser = new ArrayList<>();
            for (User user : UserController.users) {
                if (user.getGender().equals(gender)) {
                    returnUser.add(user);
                }
            }
            System.out.println(returnUser);
            return returnUser;
        }
    }
    

    Step3: 测试自定义功能,根据性别查询用户(@RequestParam格式)http://localhost:8080/user/getbygender?&gender=男

    在这里插入图片描述

    Step4: 测试自定义功能:根据性别查询用户(@PathVariable格式)`http://localhost:8080/user/getbygender/女``

    在这里插入图片描述


    2. @GetMapping Get方式请求资源目录 ⭐️


    a.作用域:
      ElementType.METHOD:方法。

    b.功能:
      1. 配置http请求(url访问地址、请求头等),指定请求方式为Get。
      2. get请求一般用于信息获取,而且是安全的和幂等的 => 安全与幂等

    c.参数
      1. name:为这个映射分配一个名称;
      2. ⭐️value:映射的资源路径,与 path() 等价;
        @GetMapping("/getusers") 普通传参,使用@RequestParam或@RequestBody接收参数
        @GetMapping("/getbyid/{id}") restful风格传参,使用@PahVariable接收参数
      3. path:映射的资源路径,与 value() 等价;
      5. params:映射的请求参数;
      6. headers:映射的请求头;
      7. consumes:映射的Content-type请求信格式,例如
        consumes = “text/plain” => HTML格式
        consumes = {“text/plain”, “application/"} => 纯文本格式
        consumes = MediaType.TEXT_PLAIN_VALUE => ?
      8. produces:映射的返回数据的类型以及编码;
        produces = “text/plain” => HTML格式
        produces = {“text/plain”, "application/”} => 纯文本格式
        produces = MediaType.TEXT_PLAIN_VALUE => ?
        produces = “text/plain;charset=UTF-8” => HTML格式,编码UTF-8
        produces = “application/json;charset=UTF-8” => JSON对象,编码UTF-8(返回json对象时一定要加这个,手动返回json字符串前端不能使用)

    d.相关注解:
      1. 常见组合:@Controller(类) + @RequestMapping(类) + @GetMapping(方法)+ @RequestParam(参数)
      2. 注解合并:@RequestMapping(value = “user” , method = RequestMethod.GET) = @GetMapping(“user”)
      3. 对比注解:@Get/Post/Put/Delete/Patch Mapping(2.5.3)


    GetMapping部分源码

    在这里插入图片描述


    User : 实体类

    package com.springboot.annotation.entity;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @AllArgsConstructor//全参构造
    @NoArgsConstructor//无参构造
    public class User {
       private int id;//身份证
       private String name;//姓名
       private String gender;//性别
       private int age;//年龄
       private String[] hobbies;//爱好
    }
    

    UserController : 处理器

    package com.springboot.annotation.controller;
    
    import com.springboot.annotation.entity.User;
    import org.springframework.web.bind.annotation.*;
    
    import java.util.ArrayList;
    import java.util.List;
    
    
    @RestController
    @RequestMapping("/user")
    public class UserController {
        private static List<User> users = new ArrayList<>();
    
        //静态代码块--存储用户信息
        static {
            users.add(new User(1, "张三", "男", 20,
                    new String[]{"足球", "篮球"}));
            users.add(new User(2, "李四", "女", 21,
                    new String[]{"舞蹈"}));
            users.add(new User(3, "林青霞", "女", 22,
                    new String[]{"唱歌", "看电影"}));
        }
        
        /**
         * 查询用户
         * @return
         */
        @GetMapping(value = "/get")//http://localhost:8080/user/get
        public List<User> get() {
            return users;
        }
    
    

    Step1: POSTMAN请求  http://localhost:8080/user/get

    在这里插入图片描述


    3. @PostMapping Post方式请求资源目录⭐️


    a.作用域:
      ElementType.METHOD:方法。

    b.功能:
      1. 配置http请求(url访问地址、请求头等),指定请求方式为Post。
      2. Post请求一般用于创建数据,不是安全和幂等的 => 安全与幂等

    c.参数
      1. name:为这个映射分配一个名称;
      2. ⭐️value:映射的资源路径,与 path() 等价;
        @PostMapping ("/getusers") 普通传参,使用@RequestParam或@RequestBody接收参数
        @PostMapping ("/getbyid/{id}") restful风格传参,使用@PahVariable接收参数
      3. path:映射的资源路径,与 value() 等价;
      5. params:映射的请求参数;
      6. headers:映射的请求头;
      7. consumes:映射的Content-type请求信格式,例如
        consumes = “text/plain” => HTML格式
        consumes = {“text/plain”, “application/"} => 纯文本格式
        consumes = MediaType.TEXT_PLAIN_VALUE => ?
      8. produces:映射的返回数据的类型以及编码;
        produces = “text/plain” => HTML格式
        produces = {“text/plain”, "application/”} => 纯文本格式
        produces = MediaType.TEXT_PLAIN_VALUE => ?
        produces = “text/plain;charset=UTF-8” => HTML格式,编码UTF-8
        produces = “application/json;charset=UTF-8” => JSON对象,编码UTF-8(返回json对象时一定要加这个,手动返回json字符串前端不能使用)

    d.相关注解:
      1. 常见组合:@Restcontroller(类) + @RequestMapping(value = “/xxx”, produces = “application/json;charset=UTF-8”)(类) + @PostMapping(方法)+ @RequestBody(参数)
      2. 注解合并:@RequestMapping(value = “user” , method = RequestMethod.POST) = @PostMapping(“user”)
      3. 对比注解:@Get/Post/Put/Delete/Patch Mapping(2.5.3)


    User : 实体类

    package com.springboot.annotation.entity;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @AllArgsConstructor//全参构造
    @NoArgsConstructor//无参构造
    public class User {
       private int id;//身份证
       private String name;//姓名
       private String gender;//性别
       private int age;//年龄
       private String[] hobbies;//爱好
    }
    

    UserController : 处理器

    package com.springboot.annotation.controller;
    
    import com.springboot.annotation.entity.User;
    import org.springframework.web.bind.annotation.*;
    
    import java.util.ArrayList;
    import java.util.List;
    
    
    @RestController
    @RequestMapping("/user")
    public class UserController {
        private static List<User> users = new ArrayList<>();
    
        //静态代码块--存储用户信息
        static {
            users.add(new User(1, "张三", "男", 20,
                    new String[]{"足球", "篮球"}));
            users.add(new User(2, "李四", "女", 21,
                    new String[]{"舞蹈"}));
            users.add(new User(3, "林青霞", "女", 22,
                    new String[]{"唱歌", "看电影"}));
        }
        
        /**
         * 新增一个用户,返回所有用户列表
         * @param user
         * @return
         */
        @PostMapping(value = "/post", produces = "application/json;charset=UTF-8")//http://localhost:8080/user/post
        public List<User> addUser(@RequestBody User user) {
            users.add(user);
            return users;
        }
    
    

    Step1: Postman第一次请求  http://localhost:8080/user/post
    请求方式: POST请求,Body -> raw -> json字符串

    {
        "id": 4,
        "name": "张曼玉",
        "gender": "女",
        "age": 23,
        "hobbies": [
            "听音乐",
            "做饭"
        ]
    }
    

    在这里插入图片描述

    Step2: Postman第二次请求  http://localhost:8080/user/post
    请求方式: POST请求,Body -> raw -> json字符串

    {
        "id": 5,
        "name": "王祖贤",
        "gender": "女",
        "age": 24,
        "hobbies": [
            "睡觉"
        ]
    }
    

    在这里插入图片描述


    4. @PutMapping Put方式请求资源目录


    a.作用域:
      ElementType.METHOD:方法。

    b.功能:
      1. 配置http请求(url访问地址、请求头等),指定请求方式为Put。
      2. Put请求一般用于创建或完整更新数据,而且是安全和幂等的 => 安全与幂等

    c.参数
      1. name:为这个映射分配一个名称;
      2. ⭐️value:映射的资源路径,与 path() 等价;
        @PutMapping ("/getusers") 普通传参,使用@RequestParam或@RequestBody接收参数
        @PutMapping ("/getbyid/{id}") restful风格传参,使用@PahVariable接收参数
      3. path:映射的资源路径,与 value() 等价;
      5. params:映射的请求参数;
      6. headers:映射的请求头;
      7. consumes:映射的Content-type请求信格式,例如
        consumes = “text/plain” => HTML格式
        consumes = {“text/plain”, “application/"} => 纯文本格式
        consumes = MediaType.TEXT_PLAIN_VALUE => ?
      8. produces:映射的返回数据的类型以及编码;
        produces = “text/plain” => HTML格式
        produces = {“text/plain”, "application/”} => 纯文本格式
        produces = MediaType.TEXT_PLAIN_VALUE => ?
        produces = “text/plain;charset=UTF-8” => HTML格式,编码UTF-8
        produces = “application/json;charset=UTF-8” => JSON对象,编码UTF-8(返回json对象时一定要加这个,手动返回json字符串前端不能使用)

    d.相关注解:
      1. 常见组合:
      2. 注解合并:@RequestMapping(value = “user” , method = RequestMethod.PUT) = @PutMapping (“user”)
      3. 对比注解:@Get/Post/Put/Delete/Patch Mapping(2.5.3)


    无示例…


    5. @DeleteMapping Delete方式请求资源目录


    a.作用域:
      ElementType.METHOD:方法。

    b.功能:
      1. 配置http请求(url访问地址、请求头等),指定请求方式为Delete。
      2. Delete请求一般用于删除数据,而且是安全和幂等的 => 安全与幂等

    c.参数
      1. name:为这个映射分配一个名称;
      2. ⭐️value:映射的资源路径,与 path() 等价;
        @DeleteMapping ("/getusers") 普通传参,使用@RequestParam或@RequestBody接收参数
        @DeleteMapping ("/getbyid/{id}") restful风格传参,使用@PahVariable接收参数
      3. path:映射的资源路径,与 value() 等价;
      5. params:映射的请求参数;
      6. headers:映射的请求头;
      7. consumes:映射的Content-type请求信格式,例如
        consumes = “text/plain” => HTML格式
        consumes = {“text/plain”, “application/"} => 纯文本格式
        consumes = MediaType.TEXT_PLAIN_VALUE => ?
      8. produces:映射的返回数据的类型以及编码;
        produces = “text/plain” => HTML格式
        produces = {“text/plain”, "application/”} => 纯文本格式
        produces = MediaType.TEXT_PLAIN_VALUE => ?
        produces = “text/plain;charset=UTF-8” => HTML格式,编码UTF-8
        produces = “application/json;charset=UTF-8” => JSON对象,编码UTF-8(返回json对象时一定要加这个,手动返回json字符串前端不能使用)

    d.相关注解:
      1. 常见组合:@Restcontroller(类) + @RequestMapping(value = “/xxx”, produces = “application/json;charset=UTF-8”)(类) + @PostMapping(方法)+ @RequestBody(参数)
      2. 注解合并:@RequestMapping(value = “user” , method = RequestMethod.DELETE) = @DeleteMapping(“user”)
      3. 对比注解:@Get/Post/Put/Delete/Patch Mapping(2.5.3)


    User : 实体类

    package com.springboot.annotation.entity;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @AllArgsConstructor//全参构造
    @NoArgsConstructor//无参构造
    public class User {
       private int id;//身份证
       private String name;//姓名
       private String gender;//性别
       private int age;//年龄
       private String[] hobbies;//爱好
    }
    

    UserController : 处理器

    package com.springboot.annotation.controller;
    
    import com.springboot.annotation.entity.User;
    import org.springframework.web.bind.annotation.*;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    @RestController
    @RequestMapping("/user")
    public class UserController {
        private static List<User> users = new ArrayList<>();
    
        //静态代码块--存储用户信息
        static {
            users.add(new User(1, "张三", "男", 20,new String[]{"足球", "篮球"}));
            users.add(new User(2, "李四", "女", 21,new String[]{"舞蹈"}));
            users.add(new User(3, "林青霞", "女", 22,new String[]{"唱歌", "看电影"}));
        }
    
         /**
         * 根据id删除对应User
         * @param id
         * @return
         */
        @DeleteMapping(value = "/delete", produces = "application/json;charset=UTF-8")//http://localhost:8080/user/delete?id=3
        public List<User> deleteUser(@RequestParam(value = "id") int id) {
            Iterator<User> it = users.iterator();
            while (it.hasNext()) {
                User next = it.next();
                if (next.getId() == id) {
                    it.remove();
                }
            }
            return users;
        }
    }
    

    Step1: Postman第一次请求  http://localhost:8080/user/delete?id=1

    在这里插入图片描述

    Step2: Postman第二次请求  http://localhost:8080/user/delete?id=2

    在这里插入图片描述

    Step3: Postman第三次请求  http://localhost:8080/user/delete?id=3

    在这里插入图片描述


    6. @PatchMapping Patch方式请求资源目录


    a.作用域:
      ElementType.METHOD:方法。

    b.功能:
      1. 配置http请求(url访问地址、请求头等),指定请求方式为Patch。
      2. Patch请求一般用于更新部分数据,不是安全和幂等的 => 安全与幂等

    c.参数
      1. name:为这个映射分配一个名称;
      2. ⭐️value:映射的资源路径,与 path() 等价;
        @PatchMapping ("/getusers") 普通传参,使用@RequestParam或@RequestBody接收参数
        @PatchMapping ("/getbyid/{id}") restful风格传参,使用@PahVariable接收参数
      3. path:映射的资源路径,与 value() 等价;
      5. params:映射的请求参数;
      6. headers:映射的请求头;
      7. consumes:映射的Content-type请求信格式,例如
        consumes = “text/plain” => HTML格式
        consumes = {“text/plain”, “application/"} => 纯文本格式
        consumes = MediaType.TEXT_PLAIN_VALUE => ?
      8. produces:映射的返回数据的类型以及编码;
        produces = “text/plain” => HTML格式
        produces = {“text/plain”, "application/”} => 纯文本格式
        produces = MediaType.TEXT_PLAIN_VALUE => ?
        produces = “text/plain;charset=UTF-8” => HTML格式,编码UTF-8
        produces = “application/json;charset=UTF-8” => JSON对象,编码UTF-8(返回json对象时一定要加这个,手动返回json字符串前端不能使用)

    d.相关注解:
      1. 常见组合:
      2. 注解合并:@RequestMapping(value = “user” , method = RequestMethod.Patch) = @PutMapping (“user”)
      3. 对比注解:@Get/Post/Put/Delete/Patch Mapping(2.5.3)


    无示例…


    2.5 对比


    1. @Controller 和 @RestController


    • @Controller
      • 在对应的方法上,视图解析器可以解析return 的jsp,html页面
      • 使用@Controller 这个注解,就不能返回JSON,XML或自定义mediaType内容到页面
      • 适用场景:跳转页面

    • @RestController
      • @RestController注解相当于@ResponseBody + @Controller
      • 返回对象(String、Integer)、json(entity会自动转为json对象)、xml、自定义media Type给浏览器
      • 使用@RestController这个注解,就不能返回jsp,html页面,视图解析器无法解析jsp,html页面
      • 适用场景:返回数据

    2. @RequesetParam、@PathVariable、@RequestBody


    @RequesetParam("/xxx")
      http://localhost:8080/param?id=1&type=苹果&discount=80%&price=3元

    @PathVariable("/xxx/{param1}/{param2…}")
      http://localhost:8080/param/2/苹果/0.5/3元 (不能传特殊符号./\%#等,=> 处理方式

    • 在后端的同一个接收方法里,@RequestBody与@RequestParam()可以同时使用,@RequestBody最多只能有一个,而@RequestParam()可以有多个。
    • @RequestBody接收数据时,前端不能使用GET方式提交数据,而是用POST方式进行提交。
    注解 支持类型 支持的请求类型 支持的Content-Type 请求示例 默认值
    @RequestParam url Get all /orders?name=abc
    Body Post/Put/Delete/Patch form-data,x-www.form-urlencoded 见下图(Postman请求示例1
    @RequestBody Body Post/Put/Delete/Patch json {"id":1,"name":"abc"}(Postman请求示例2 ×
    @PathVariable url Get all /orders/{id} ×

    Postman请求示例1:

    在这里插入图片描述

    Postman请求示例2:

    在这里插入图片描述


    3.@Get/Post/Put/Delete/Patch Mapping


    REST模式:POST,GET,PUT,DELETE,PATCH的含义与区别


    三、Service层(服务层) (放入ioc)


    3.1 类注解 TYPE


    1. @Service 标记服务类->自动bean注册⭐️


    a.作用域:
      ElementType.TYPE:类、接口、枚举。

    b.功能:
      1. 将ioc容器中指定的service对象放入spring ioc容器。
      2. 在实现类上(Impl)加@Service注解,一个接口可以有多个实现类。
      3. 一般按照以下方式分层使用。
       1) service层:业务逻辑接口;

    	public interface UserService {
    		List<User> get();
    	}
    

       2) serviceimpl层:继承service,业务逻辑实现,并将impl实现类放入ioc容器 @service;

        @Service
    	public class UserServiceImpl implements UserService{
    		public List<User> get(){...调用dao层查询Userreturn...};
    	}
    

     &emsp ;3) controller层:调用service方法,需要先将ioc容器中的 service对象从ioc容器中取出;

       @RestController
       @RequestMapping("/user")
       public class UserController {
       @Autowired
       private UserService userService;
       @GetMapping("/get")//http://localhost:8080/action/get
       public List<User> get() {
           return userService.get();
       }
    

    c.参数:
      1. ⭐️value:指定注入ioc容器中的名称(Bean的id),如果不指定则默认为类名首字母小写(例如UserController -> userController),与 @Component.value等价;

    d.相关注解:
      1. 常见组合:@Service(SerivceImpl中) + @Autowired(Controller中)
      2. 对比注解:@Service — @Component — @Configuration + Bean(3.4.1)


    具体用法参看@Autowired


    2. @Component 标记组件类->自动bean注册⭐️

    a.作用域:
      ElementType.TYPE:类、接口、枚举。

    • @Service 和 @Component从功能角度来说效果相同,区别在于,按照约定使用在不同场合:
      • @Service标记的是服务层,只和需求相关,仅由Controller层调用
      • @Component标记的是组件(比如工具类),可以被Service,Controller等任何调用

    3. @Configuration 注入容器(手动) -> 自定义组件


    a.作用域:
      ElementType.TYPE:类、接口、枚举。

    b.功能:
      被标记的类会被Spring扫描,该类中被@Bean注解的实例化方法,会放入ioc容器(手动Bean注册)

    c.参数:
      1. ⭐️value:指定注入ioc容器中的名称(Bean的id),如果不指定则默认为类名首字母小写(例如UserController -> userController),与 @Component.value等价;

    d.相关注解:
      1. 常见组合:@Configuration (类) + @Bean(方法)
      2. 对比注解:@Service — @Component — @Configuration + Bean(3.4.1)


    Step1: 手动创建一个MyBeans类,将需要注入ioc容器的方法用@Bean注解(具体使用方法查看3.4.1)

    在这里插入图片描述


    MyBeans: 自定义实体类,通过@Configuration+@BEan方式手动注入ioc容器

    package com.springboot.annotation.cfg;
    
    import com.springboot.annotation.impl.AdminServiceImpl;
    import com.springboot.annotation.impl.UserServiceImpl;
    import com.springboot.annotation.service.UserService;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    @Configuration
    public class MyBeans {
        /**手动注入spring ioc容器,指定对象名称admin
         * @return AdminServiceImpl对象*/
        @Bean
        public UserService admin() {
            return new AdminServiceImpl();
        }
    
        @Bean
        public UserService user() {
            return new UserServiceImpl();
        }
    }
    

    UserService: 服务层接口

    package com.springboot.annotation.service;
    import com.springboot.annotation.entity.User;
    import java.util.List;
    
    
    public interface UserService {
        List<User> get();
        List<User> getByGenderB(String gender);
    }
    

    AdminServiceImpl: 服务层实现类1

    package com.springboot.annotation.impl;
    
    import com.springboot.annotation.entity.User;
    import com.springboot.annotation.service.UserService;
    import org.springframework.stereotype.Service;
    
    import java.util.ArrayList;
    import java.util.List;
    
    @Service
    public class AdminServiceImpl implements UserService {
        private static List<User> users = new ArrayList<>();
        private static List<User> returnUser;
        //静态代码块--存储用户信息
        static {
            users.add(new User(1, "admin1", "男", 20, new String[]{"足球", "篮球"}));
            users.add(new User(2, "admin2", "女", 21, new String[]{"舞蹈"}));
            users.add(new User(3, "admin3", "女", 22, new String[]{"唱歌", "看电影"}));
        }
        /**
         * 查询用户
         * @return
         */
        @Override
        public List<User> get() {
            return users;
        }
    
        /**
         * 通过性别查找用户的方法(@PathVariable传参)
         * @param gender
         * @return
         */
        @Override
        public List<User> getByGenderB(String gender) {
            returnUser = new ArrayList<>();
            for (User user : users) {
                if (user.getGender().equals(gender)) {
                    returnUser.add(user);
                }
            }
            System.out.println(returnUser);
            return returnUser;
        }
    }
    

    UserServiceImpl: 服务层实现类2,与实现类1相比,查询的用户不同

    package com.springboot.annotation.impl;
    
    import com.springboot.annotation.entity.User;
    import com.springboot.annotation.service.UserService;
    import org.springframework.stereotype.Service;
    
    import java.util.ArrayList;
    import java.util.List;
    
    @Service
    public class UserServiceImpl implements UserService {
        private static List<User> users = new ArrayList<>();
        private static List<User> returnUser;
        static {
            users.add(new User(1, "张三", "男", 20, new String[]{"足球", "篮球"}));
            users.add(new User(2, "李四", "女", 21, new String[]{"舞蹈"}));
            users.add(new User(3, "林青霞", "女", 22, new String[]{"唱歌", "看电影"}));
        }
    
        @Override
        public List<User> get() {
            return users;
        }
    
        @Override
        public List<User> getByGenderB(String gender) {
            returnUser = new ArrayList<>();
            for (User user : users) {
                if (user.getGender().equals(gender)) {
                    returnUser.add(user);
                }
            }
            System.out.println(returnUser);
            return returnUser;
        }
    }
    

    UserActionController: 处理器

    package com.springboot.annotation.controller;
    
    import com.springboot.annotation.entity.User;
    import com.springboot.annotation.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.annotation.Resource;
    import java.util.List;
    
    @RestController
    @RequestMapping("/action")
    public class UserActionController {
        //使用MyBeans中手动注入ioc的对象
        @Resource(name = "user")
        private UserService userService;
    
    	@Resource(name = "admin")
        private UserService adminService;
    
        /**
         * 查询user用户
         * @return 当前所有用户
         */
        @GetMapping("/getUser")//http://localhost:8080/action/getUser
        public List<User> getUser() {
            return userService.get();//
        }
    
        /**
         * 查询admin用户
         * @return 当前所有用户
         */
        @GetMapping("/getAdmin")//http://localhost:8080/action/getAdmin
        public List<User> getAdmin() {
            return adminService.get();//
        }
    }
    

    Step2: Postman请求实现类1   http://localhost:8080/action/getUser

    在这里插入图片描述

    按照如下顺序找到对应的实现类 UserServiceImpl(Service接口有两个实现类,返回内容不一样)

    在这里插入图片描述

    Step3: Postman请求实现类2   http://localhost:8080/action/getAdmin

    在这里插入图片描述

    按照如下顺序找到对应的实现类 AdminServiceImpl

    在这里插入图片描述

    Step4: 还可以通过@Autowired + @Qualifier组合使用来指定MyBeans中自定义的对象

    在这里插入图片描述


    3.2 方法注解 METHOD


    1. @Bean 手动Bean注册


    a.作用域:
      1. ElementType.METHOD:方法。
      2. ElementType.ANNOTATION_TYPE:注解。

    b.功能:
      手动注入ioc容器,指定实例化对象,和ioc容器中实例对象名称


    3.3 注解的注解 ANNOTATION_TYPE


    1. @Bean => 3.2.1 🚕


    3.4 对比


    1. @Service — @Component — @Configuration + Bean


    @Service 和 @Component从功能角度来说效果相同,区别在于,按照约定使用在不同场合;

    而@Configuration在功能上有一些差别了 => @Component和@Configuration作为配置类的差别

    1. @Service
      1. 将实例化对象自动放入Spring ioc容器
      2. 按照约定,@Service标记的是业务层,仅由Controller层调用

    2. @Component
      1. 将实例化对象自动放入Spring ioc容器
      2. 按照约定,@Component标记的是组件类,可以被Service,Controller等任何调用

    3. @Configuration + @Bean
      1. 将实例化对象手动放入Spring ioc容器
      2. 手动通过@Bean进行注册


    MyBeans: 自定义实体类,通过@Configuration+@BEan方式手动注入ioc容器

    @Configuration
    public class MyBeans {
        /**手动注入spring ioc容器,指定对象名称admin
         * @return AdminServiceImpl对象*/
        @Bean
        public UserService admin() {
            return new AdminServiceImpl();
        }
    
        @Bean
        public UserService user() {
            return new UserServiceImpl();
        }
    }
    

    UserService: 服务层接口

    package com.springboot.annotation.service;
    import com.springboot.annotation.entity.User;
    import java.util.List;
    
    
    public interface UserService {
        List<User> get();
        List<User> getByGenderB(String gender);
    }
    

    AdminServiceImpl: 服务层实现类1

    package com.springboot.annotation.impl;
    
    import com.springboot.annotation.entity.User;
    import com.springboot.annotation.service.UserService;
    import org.springframework.stereotype.Service;
    
    import java.util.ArrayList;
    import java.util.List;
    
    @Service
    public class AdminServiceImpl implements UserService {
        private static List<User> users = new ArrayList<>();
        private static List<User> returnUser;
        //静态代码块--存储用户信息
        static {
            users.add(new User(1, "admin1", "男", 20, new String[]{"足球", "篮球"}));
            users.add(new User(2, "admin2", "女", 21, new String[]{"舞蹈"}));
            users.add(new User(3, "admin3", "女", 22, new String[]{"唱歌", "看电影"}));
        }
        /**
         * 查询用户
         * @return
         */
        @Override
        public List<User> get() {
            return users;
        }
    
        /**
         * 通过性别查找用户的方法(@PathVariable传参)
         * @param gender
         * @return
         */
        @Override
        public List<User> getByGenderB(String gender) {
            returnUser = new ArrayList<>();
            for (User user : users) {
                if (user.getGender().equals(gender)) {
                    returnUser.add(user);
                }
            }
            System.out.println(returnUser);
            return returnUser;
        }
    }
    

    UserServiceImpl: 服务层实现类2,与实现类1相比,查询的用户不同

    package com.springboot.annotation.impl;
    
    import com.springboot.annotation.entity.User;
    import com.springboot.annotation.service.UserService;
    import org.springframework.stereotype.Service;
    
    import java.util.ArrayList;
    import java.util.List;
    
    @Service
    public class UserServiceImpl implements UserService {
        private static List<User> users = new ArrayList<>();
        private static List<User> returnUser;
        static {
            users.add(new User(1, "张三", "男", 20, new String[]{"足球", "篮球"}));
            users.add(new User(2, "李四", "女", 21, new String[]{"舞蹈"}));
            users.add(new User(3, "林青霞", "女", 22, new String[]{"唱歌", "看电影"}));
        }
    
        @Override
        public List<User> get() {
            return users;
        }
    
        @Override
        public List<User> getByGenderB(String gender) {
            returnUser = new ArrayList<>();
            for (User user : users) {
                if (user.getGender().equals(gender)) {
                    returnUser.add(user);
                }
            }
            System.out.println(returnUser);
            return returnUser;
        }
    }
    

    UserActionController: 处理器

    package com.springboot.annotation.controller;
    
    import com.springboot.annotation.entity.User;
    import com.springboot.annotation.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.annotation.Resource;
    import java.util.List;
    
    @RestController
    @RequestMapping("/action")
    public class UserActionController {
        //使用MyBeans中手动注入ioc的对象
        @Resource(name = "user")
        private UserService userService;
    
    	@Resource(name = "admin")
        private UserService adminService;
    
        /**
         * 查询user用户
         * @return 当前所有用户
         */
        @GetMapping("/getUser")//http://localhost:8080/action/getUser
        public List<User> getUser() {
            return userService.get();//
        }
    
        /**
         * 查询admin用户
         * @return 当前所有用户
         */
        @GetMapping("/getAdmin")//http://localhost:8080/action/getAdmin
        public List<User> getAdmin() {
            return adminService.get();//
        }
    }
    

    请求接口1: Postman请求实现类1   http://localhost:8080/action/getUser

    在这里插入图片描述

    按照如下顺序找到对应的实现类 UserServiceImpl(Service接口有两个实现类,返回内容不一样)

    在这里插入图片描述

    请求接口2: Postman请求实现类2   http://localhost:8080/action/getAdmin

    在这里插入图片描述

    按照如下顺序找到对应的实现类 AdminServiceImpl

    在这里插入图片描述


    四、注入bean(从ioc取)


    4.1 字段注解 FIELD


    1. @Autowired 容器ioc->获取bean⭐️


    a.作用域:
      1. ElementType.FIELD:字段(包括枚举常量)。
      2. ElementType.METHOD:方法。
      3. ElementType.PARAMETER:参数。
      4. ElementType.CONSTRUCTOR:构造器。
      5. ElementType.ANNOTATION_TYPE:注解。

    b.功能:
      1. 自动按照类型注入。当使用注解注入属性时,set方法可以省略。它只能注入其他bean类型。当有多个类型匹配时。使用要注入的对象变量名称作为bean的id,在spring容器中查找,找到了注入成功,找不到就报错。
      2. 将ioc容器中指定的service对象从ioc容器中取出。
      3. 接口单个实现时,注入时加@Autowired 即可。
      4. 接口多个实现时,注入时加@Autowired + @Qualifier配合使用(或者使用@Resource代替@Autowired,在参数name中指定bean的名称 ),指定具体的实现类。
      5. 一般按照以下方式分层使用
       1) service层:业务逻辑接口

    	public interface UserService {
    		List<User> get();
    	}
    

       2) serviceimpl层:继承service,业务逻辑实现,并将impl实现类放入ioc容器 @service

        @Service
    	public class UserServiceImpl implements UserService{
    		public List<User> get(){...调用dao层查询Userreturn...};
    	}
    

       3) controller层:调用service方法,需要先将ioc容器中的 service对象从ioc容器中取出

       @RestController
       @RequestMapping("/user")
       public class UserController {
       	@Autowired
           private UserService userService;
           @GetMapping("/get")//http://localhost:8080/user/get
           public List<User> get() {
               return userService.get();
           }
       }
    

    c.参数
      required:请求时该参数是否必传,默认required = true

    d.相关注解:
      1. 常见组合:@Service(类-注入ioc)+ @Autowired(字段-从ioc取出Bean)
      2. 注解合并:@Autowired + @Qualifier(“BeanId”) = @ Resource ( name = “BeanId” )
      3. 对比注解:@Autowired — @Autowired + @Qualifier — @Resource (4.6.1)


    场景1: @Autowired 注入Service,Service只有单个实现类

    在这里插入图片描述

    场景2: @Autowired 注入Service,Service有多个实现类(指定AdminServiceImpl 还是 UserServiceImpl,不同实现类会返回不同处理结果)

    在这里插入图片描述

    场景3: 通过@Autowired + @Qualifier组合使用来指定@Configuration + @Bean 中的bean

    在这里插入图片描述


    2. @Resource 容器ioc->获取bean


    a.作用域:
      1. ElementType.TYPE:类、接口、枚举。
      2. ElementType.FIELD:字段(包括枚举常量)。
      3. ElementType.METHOD:方法。

    b.功能:
      1. 直接按照Bean的id注入。它也只能注入其他Bean类型。
      2. name属性是指定Bean的id ,Bean的id是首字母小写的对象名。</font
      3. 将ioc容器中指定的service对象(一个服务接口有多个实现时)从ioc容器中取出 。
      4. 接口单个实现时,注入时加@Resource 即可。
      5. 接口多个实现时,注入时加@Resource(name = “beanid”)(在参数name中指定bean的名称 ),指定具体的实现类。
      6. 一般按照以下方式分层使用(不指定Bean id)
       1) service层:业务逻辑接口

    	public interface UserService {
    		List<User> get();
    	}
    

       2) serviceimpl层:继承service,业务逻辑实现,并将impl实现类放入ioc容器 @service

        @Service
    	public class UserServiceImpl implements UserService{
    		public List<User> get(){...调用dao层查询Userreturn...};
    	}
    

       3) controller层:调用service方法,需要先将ioc容器中的 service对象从ioc容器中取出

       @RestController
       @RequestMapping("/user")
       public class UserController {
       	@Resource 
           private UserService userService;
           @GetMapping("/get")//http://localhost:8080/user/get
           public List<User> get() {
               return userService.get();
           }
       }
    

      7. (不指定Bean id)
       1) service层:业务逻辑接口()
       2) serviceimpl层:继承service,业务逻辑实现,并将impl实现类放入ioc容器 @service

     @Service
     public class UserServiceImpl implements UserService{...}
    
     @Service
     public class AdminServiceImpl implements UserService{...}
    

       3) controller层:调用service方法,需要先将ioc容器中的 service对象从ioc容器中取出 ,需要指定Bean id,id为Bean对象的首字母小写。

     @Resource(name = "userServiceImpl")
     private UserService userService;
    
     @Resource(name = "adminServiceImpl")
     private UserService adminService;
    

    c.参数
      1.⭐️name:指定从ioc容器中要取出的名称(Bean的id),默认为空。
      2. lookup
      3. type
      4. authenticationType
      5. shareable
      6. mappedName
      7. description:对该资源的描述。该描述预计将使用部署应用程序的系统的默认语言。可以将描述呈现给部署人员,以帮助选择正确的资源。

    d.相关注解:
      1. 常见组合:@Service(多个类-注入ioc)+ @Resource( name = “BeanId” )
      2. 注解合并:@Autowired + @Qualifier(“BeanId”) = @ Resource ( name = “BeanId” )
      3. 对比注解:@Autowired — @Autowired + @Qualifier — @Resource (4.6.1)


    3. @Qualifier 容器ioc->(获取时)指定bean


    a.作用域:
      1. ElementType.TYPE:接口、类、枚举。
      2. ElementType.FIELD:字段(包括枚举常量)。
      3. ElementType.METHOD:方法。
      4. ElementType.PARAMETER:参数。
      5. ElementType.ANNOTATION_TYPE:注解。

    b.功能:
      1. 在自动按照类型注入(@Autowired)的基础上,再按照Bean的id注入。它在给字段注入时不能单独使用
      2. 必须和@Autowire一起使用;但是给方法参数注入时,可以单独使用。
      3. value属性是指定Bean的id,Bean的id是首字母小写的对象名。

        @Autowired
        @Qualifier("userServiceImpl")
        private UserService userService;
        
        @Autowired
        @Qualifier("adminServiceImpl")
        private UserService adminService;
    

    c.参数
      value:指定从ioc容器中要取出的名称(Bean的id),默认为空。

    d.相关注解:
      1. 常见组合:@Service(多个类-注入ioc)+ @Autowired(字段-从ioc取出Bean)+ @Qualifier(匹配到多个Bean实例时,指定Bean的id)
      2. 注解合并:@Autowired + @Qualifier(“BeanId”) = @ Resource ( name = “BeanId” )
      3. 对比注解:@Autowired — @Autowired + @Qualifier — @Resource (4.6.1)


    4.2 类注解 TYPE


    1. @Resource => 4.1.2🚕

    2. @Qualifier => 4.1.3 🚕


    4.3 方法注解 METHOD


    1. @Autowired => 4.1.1🚕

    2. @Resource => 4.1.2🚕

    3. @Qualifier => 4.1.3 🚕


    4.4 参数注解 PARAMETER


    1. @Autowired => 4.1.1🚕

    1. @Qualifier => 4.1.3 🚕



    4.5 构造器注解 CONSTRUCTOR


    1. @Autowired => 4.1.1🚕


    4.6 注解的注解 ANNOTATION_TYPE


    1. @Autowired => 4.1.1🚕

    2. @Qualifier => 4.1.3 🚕


    4.6 对比


    1. @Autowired — @Autowired + @Qualifier — @Resource

    1.使用语法不同: 当有注入Bean时有多个匹配类型,通过以下三种方式指定Bean的id

    	//写法1
    	@Autowired
    	@Qualifier("userServiceImpl")
        private UserService userService;
        @Autowired
        @Qualifier("adminServiceImpl")
        private UserService adminService;
        
        //写法2
        @Autowired
        private UserServiceImpl userService;
        @Autowired
        private AdminServiceImpl adminService;
        
     	//写法3(建议此方式)
        @Resource(name = "userServiceImpl")
        private UserService userService;
        @Resource(name = "adminServiceImpl")
        private UserService adminService;
    

    1. 使用语法不同: 当有注入Bean时只有单个匹配类型

        //写法1
        @Autowired
        private UserService userService;
     	//写法2(建议此方式)
        @Resource
        private UserService userService;
    

    2. 底层加载方式不同: => @Autowired 与@Resource的区别


    五、其他


    1. @Alisfor 注解属性等价⭐️


    作用域:
      ElementType.METHOD:方法。

    功能:
      可以使两个注解的属性互为别名(完全等价)。同一注解下可以指定任意两个注解,跨注解时表示两个注解的同名属性相等;(Alisfor标记的两个注解同时赋不同值时会报错)

    备注:
      等价的意思可以理解为多个属性(实例对象),但指向内存中同一地址


    @Aliasfor源码:

    在这里插入图片描述

    场景1: 同注解中,两个属性等价

    在这里插入图片描述

    场景2: 跨注解时,两个同名属性等价(*.class只能是注解类)

    在这里插入图片描述

    场景3: 跨注解时,多个属性等价(*.class只能是注解类)

    在这里插入图片描述


    测试1: @RequestMapping的 只有一个属性时(仅有一个属性且为value时可以省略)

    正常访问
    在这里插入图片描述

    测试2: @RequestMapping的 value 和 path属性相同时

    正常访问
    在这里插入图片描述

    测试3: @RequestMapping的 value 和 path属性不同时

    编译阶段不通过,启动项目时报错
    在这里插入图片描述


    2. @Value 从配置文件中取参数


    a.作用域:
      1. ElementType.FIELD:字段(包括枚举常量)。
      2. ElementType.METHOD:方法。
      3. ElementType.PARAMETER:参数。
      4. ElementType.ANNOTATION_TYPE:注解。

    • 作用
      • 从配置文件(application.properties)中取参数
        注入基本数据类型和String类型数据

    • application.properties中添加配置参数
    spring.mvc.view.prefix=/
    spring.mvc.view.suffix=.html
    
    ##freeMarker
    #后缀
    spring.freemarker.suffix=.html
    #指定资源(页面)默认路径,默认指向templates路径
    spring.freemarker.template-loader-path=classpath:/static/
    
    #@Value相关测试
    view.page=view
    local.user.username=admin
    local.user.password=123456
    

    在这里插入图片描述

    • 新建ValueController,测试从配置文件中取值
    package com.springboot.annotation.controller;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @author GroupiesM
     * @date 2021/07/07
     * @introduction @Value相关测试
     *
     */
    @RestController
    @RequestMapping("/value")
    public class ValueController {
    
        @Value("${view.page}")
        private String page;
    
        @Value("${local.user.username}")
        private String username;
    
        @Value("${local.user.password}")
        private String password;
    
        @GetMapping("val")//localhost:8080/value/val
        public String getValue() {
            System.out.println(page + "..." + username + "..." + password);
            return page + "..." + username + "..." + password;
        }
    }
    

    在这里插入图片描述

    • 注意导包时选择springfreamwork包下的Value

    在这里插入图片描述

    • 重启springboot项目,使用Postman访问接口,成功获取配置文件的值

    在这里插入图片描述


    六、lombok插件

    SpringBoot - Lombok使用详解2(@Setter、@Getter、@ToString、@EqualsAndHashCode)

    SpringBoot中lombok使用,自动生成getter、setter、构造器、toString()、equals()等

    • lombok简介
      Lombok想要解决了的是在我们实体Bean中大量的Getter/Setter方法,以及toString, hashCode等可能不会用到,但是某些时候仍然需要复写,以期方便使用的方法;在使用Lombok之后,将由其来自动帮你实现代码生成,注意,其是 在运行过程中,帮你自动生成的 。就是说,将极大减少你的代码总量。

    • lombok作用
      消除模板代码
      getter、setter、构造器、toString()、equals()
      便捷的生成比较复杂的代码,例如一个POJO要转化成构建器模式的形式,只需要一个注解。

    • 常用注解

      • @Data : 注解在类上, 为类提供@Getter、@Setter, 此外还提供了 equals()、hashCode()、toString() 方法
      • @NoArgsConstructor : 注解在类上, 为类提供无参构造
      • @AllArgsConstructor : 注解在类上, 为类提供全参构造
      • @Getter/@Setter : 注解在类上, 为类提供读写属
      • @ToString : 注解在类上, 为类提供 toString() 方法
      • @Slf4j : 注解在类上, 为类提供一个属性名为 log 的 log4j 的日志对象
      • @Log4j : 注解在类上, 为类提供一个属性名为 log 的 log4j 的日志对象

    Step1: pom.xml添加lombok的jar包依赖

    <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.16.10</version>
    </dependency>
    

    Step2: 编写一个实体类 User,使用@Data注解

    @AllArgsConstructor//全参构造
    @NoArgsConstructor//无参构造
    public class User {  
     	private String name;  
     	private int age;
    }
    

    Step2: 或者@Setter和@Getter(注意是lambok包下的Getter)

    在这里插入图片描述


    6.1 类注解


    1. @Data 实体类常用功能打包⭐️

    User: 实体类

    package com.springboot.annotation.entity;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @AllArgsConstructor//全参构造
    @NoArgsConstructor//无参构造
    public class User {
       private int id;//身份证
       private String name;//姓名
       private String gender;//性别
       private int age;//年龄
       private String[] hobbies;//爱好
    }
    

    TestUser: 编写测试方法,测试@Data是否起作用(测试了set方法和构造器)

    @Test
    public void TestUser(){  
      User user1 = new User();  
      user1.setName("AnyCode");  
      user1.setAge(20);  
      System.err.println(user.toString());
        
      User user1 = new User("张三",30);  
    }
    

    2. @NoArgsConstructor 无参构造⭐️

    3. @AllArgsConstructor 全参构造⭐️

    4. @Getter​ ​get方法⭐️

    5. @Setter set方法⭐️


    附录:springboot常见分层(AOP)


      备注: 这里的案例不涉及mybaties,没有和数据库交互查询数据的步骤,数据是在静态代码块中添加到userList中来模拟数据库课的;通常情况下Serviceimpl还需要调用dao层,dao层负责和数据库的交互;

    在这里插入图片描述

    测试1: 调用get方法 http://localhost:8080/action/get

    在这里插入图片描述

    测试2: 调用getbygender方法 http://localhost:8080/action/getbygender/男

    在这里插入图片描述


    1. controller层 @Controller

      概述: controller层叫控制器层,负责前后端交互,接受前端请求,调用service层,接收service层返回的数据,最后返回具体的页面和数据到客户端。
      不存放业务逻辑,通过调用Service层实现业务逻辑


    2. service层 @Service

      概述: service层叫业务逻辑层,存放业务逻辑处理,不直接对数据库进行操作,有接口和接口实现类,提供controller层调用的方法。
      implService是接口的实现类,实现业务逻辑,impl通过@Service注解注入ioc容器


    3. dao层(mapper层) @Repository

      概述: dao层也叫mapper层,数据持久层,个人比较喜欢mapper层。
    对数据库进行持久化操作,他的方法是针对数据库操作的,基本用到的就是增删改查。它只是个接口,只有方法名字,具体实现在mapper.xml中。

      既然mapper层是直接与数据库相挂钩的,所以要先连接数据库。
      可以在sqlMapConfig.xml文件或者application.properties文件里添加数据库属性等,如下所示


    sqlMapConfig.xml:添加属性

    <!-- 加载属性文件 -->
    <properties resource="/config/db.properties"></properties>
    
    <!-- 和spring整合后environment配置将废除 -->
    <environments default="development">
        <environment id="development">
            <!-- 使用jdbc事务管理 -->
            <transactionManager type="JDBC" />
            <!-- 数据库连接池,由mybatis管理 -->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}" />
                <property name="url" value="${jdbc.url}" />
                <property name="username" value="${jdbc.username}" />
                <property name="password" value="${jdbc.password}" />
            </dataSource>
        </environment>
    </environments>
    

    application.properties:添加属性

    jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/mybatis
    jdbc.username=root
    jdbc.password=123
    

    5. model层 @Data


      概述: model层也叫pojo层或者entity层。一般数据库的一张表对应一个pojo类,并且表中所有字段都在pojo类都一一对应。

    1. POJO:Plain Ordinary Java Object 无规则简单Java对象。一个中间对象,可以转化为VO、DTO、PO。
    2. VO:View Object 表示层对象。对应页面显示的数据对象,可以和表对应,也可以不对应。一般在Controller层使用。
    3. DTO:Data Transfer Object 数据传输对象。传递数据。如PO有100个属性,页面VO只显示10个,那么DTO就也传输10个。一般在Service层使用。
    4. PO:Persistent Object 持久化对象。它跟数据表形成一一对应的映射关系。一般在Dao层使用。
    5. Entity: 实体,和PO的功能类似,和数据表一一对应,一个实体一张表。


    6. common层


    概述: 通用模块,不依赖其它任何模块,主要有utils


    21/07/15

    M

    展开全文
  • SpringBoot常用注解及方法 注解/方法 注释 @SpringBootApplication 是一个组合注解,用于快捷配置启动类。由@ComponentScan 注解、@EnableAutoConfiguration 注解、@SpringBootConfiguration 注解、@...

    SpringBoot常用注解及方法

    注解/方法 注释
    @SpringBootApplication 是一个组合注解,用于快捷配置启动类。由@ComponentScan 注解、@EnableAutoConfiguration 注解、@SpringBootConfiguration 注解、@Inherited 注解、@Documented 注解、@Retention() 注解、@Target() 注解组成
    ConfigurableApplicationContext.getBean(aa) 获取容器中aa的bean
    matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) @ConditionOnClass(“AA”)的条件方法。Conditional 是在spring4.0 增加的条件注解,当你注册bean时,可以对这个bean添加一定的自定义条件,当满足这个条件时,注册这个bean,否则不注册。conditionContext 上下文对象,获取属性值、获取类加载器、获取BeanFactory,annotatedTypeMetadata 元数据对象,获取注解属性。
    @Configuration 用@Configuration注释类表明其主要目的是作为bean定义的源
    SpringIOC 容器管理一个或者多个bean,这些bean都需要在@Configuration注解下进行创建,在一个方法上使用@Bean注解就表明这个方法需要交给Spring进行管理。
    @Bean @Bean注解用于告诉方法,产生一个Bean对象,然后这个Bean对象交给Spring管理。产生这个Bean对象的方法Spring只会调用一次,随后这个Spring将会将这个Bean对象放在自己的IOC容器中。
    @ConditionOnClass(“AA”) 判断AA是否存在,存在才会注入
    @Target({ElementType.TYPE, ElementType.METHOD}) @Target说明了Annotation所修饰的对象范围:
    Annotation可被用于 packages、types(类、接口、枚举、Annotation类型)、类型成员(方法、构造方法、成员变量、枚举值)、方法参数和本地变量(如循环变量、catch参数)。在Annotation类型的声明中使用了target可更加明晰其修饰的目标。 
    作用:用于描述注解的使用范围(即:被描述的注解可以用在什么地方)
    取值(ElementType)有:1.CONSTRUCTOR:用于描述构造器2.FIELD:用于描述域3.LOCAL_VARIABLE:用于描述局部变量4.METHOD:用于描述方法5.PACKAGE:用于描述包6.PARAMETER:用于描述参数7.TYPE:用于描述类、接口(包括注解类型) 或enum声明
    @Retention(RetentionPolicy.RUNTIME) 注解@Retention可以用来修饰注解,是注解的注解,称为元注解。Retention注解有一个属性value,是RetentionPolicy类型的,Enum RetentionPolicy是一个枚举类型,这个枚举决定了Retention注解应该如何去保持,也可理解为Rentention 搭配 RententionPolicy使用。RetentionPolicy有3个值:CLASS RUNTIME SOURCE按生命周期来划分可分为3类: 1、RetentionPolicy.SOURCE:注解只保留在源文件,当Java文件编译成class文件的时候,注解被遗弃2、RetentionPolicy.CLASS:注解被保留到class文件,但jvm加载class文件时候被遗弃,这是默认的生命周期;3、RetentionPolicy.RUNTIME:注解不仅被保存到class文件中,jvm加载class文件之后,仍然存在; 这3个生命周期分别对应于:Java源文件(.java文件) —> .class文件 —> 内存中的字节码。那怎么来选择合适的注解生命周期呢?首先要明确生命周期长度 SOURCE < CLASS < RUNTIME ,所以前者能作用的地方后者一定也能作用。一般如果需要在运行时去动态获取注解信息,那只能用 RUNTIME 注解,比如@Deprecated使用RUNTIME注解 如果要在编译时进行一些预处理操作,比如生成一些辅助代码(如 ButterKnife),就用 CLASS注解;如果只是做一些检查性的操作,比如 @Override 和 @SuppressWarnings,使用SOURCE 注解。注解@Override用在方法上,当我们想重写一个方法时,在方法上加@Override,当我们方法的名字出错时,编译器就会报错注解@Deprecated,用来表示某个类或属性或方法已经过时,不想别人再用时,在属性和方法上用@Deprecated修饰注解@SuppressWarnings用来压制程序中出来的警告,比如在没有用泛型或是方法已经过时的时候
    @Documented @Documented 注解表明这个注解应该被 javadoc工具记录. 默认情况下,javadoc是不包括注解的. 但如果声明注解时指定了 @Documented,则它会被 javadoc 之类的工具处理, 所以注解类型信息也会被包括在生成的文档中,是一个标记注解,没有成员
    @interface @interface表示该类是一个注解类,相当于自己定义一个注解
    String[] value() default{}; 定义一个String[] 变量为value() 值为default{}(默认值为空)
    @Conditional(value = {ClassCondition.class}) 使用自定义注解
    getAnnotationAttributes(ConditionOnClass.class.getName()) 获取注解中的所有的属性值(.class.getName()获取全限定类名)
    map.get(“value”) 跟据指定键获取值
    Class.forName(s); 获取该对象的实体类名称
    @ConditionalOnBean 判断spring容器中有某个bean时初始化该Bean
    @ConditionalOnClass 判断程序中有某个class字节码文件时初始化该Bean
    @ConditionalOnMissingBean 判断spring容器中没有该Bean时会初始化该Bean
    @ConditionalOnMissingClass 判断程序中没有某个class字节码文件时初始化该Bean
    @ConditionalOnProperty 判断配置文件中是否有对应的属性和值才初始化该bean
    @ComponentScan(basePackages = {“com.cn”}) 指定扫描的包(无法获取该bean的实例原因是,启动类默认加载当前包以及子包下的类。而我们的User/UserConfig与启动类并不在同一个包下,因此我们可以通过@ComponentScan指定扫描的包。)
    @Import(UserConfig.class) @Import注解,直接指定UserConfig.class字节码文件。
    @ConfigurationProperties(prefix = “myredis”) @ConfigurationProperties是springboot提供读取配置文件的一个注解。其对应的bean的后置处理器为ConfigurationPropertiesBindingPostProcessor
    @EnableConfigurationProperties @EnableConfigurationProperties注解的作用是:使 @ConfigurationProperties 注解的类生效。
    MyCommandLineRunner CommandLineRunner是一个接口,预先数据的加载,我们需要时,只需实现该接口就行(初始化系统参数)
    Arrays.asList(a) Arrays.asList的作用是将数组转化为list
    ApplicationRunner ApplicationReadyEvent事件可以实现系统启动完后做一些系统初始化的操作(进行缓存预热)
    ApplicationArguments 中args.getSourceArgs() 获取命令行中所有参数
    @component @component (把普通pojo实例化到spring容器中,相当于配置文件中的 < bean id="" class=""/>)
    SpringApplicationRunListener SpringApplicationRunListener 接口的作用主要就是在Spring Boot 启动初始化的过程中可以通过SpringApplicationRunListener接口回调来让用户在启动的各个流程中可以加入自己的逻辑。Spring Boot启动过程的关键事件(按照触发顺序)包括:
    开始启动
    Environment构建完成
    ApplicationContext构建完成
    ApplicationContext完成加载
    ApplicationContext完成刷新并启动
    启动完成
    启动失败
    ApplicationContextInitializer ApplicationContextInitializer接口是在spring容器刷新之前执行的一个回调函数。
    @Mapper @Mapper注解的的作用
    1:为了把mapper这个DAO交給Spring管理
    2:为了不再写mapper映射文件
    3:为了给mapper接口 自动根据一个添加@Mapper注解的接口生成一个实现类
    @RestController 将查询到的数据转换成json
    @PathVariable @PathVariable是用来bai对指定请求的URL路径里du面的变量 eg: Java代码 @RequestMapping(value = “form/{id}/apply”, method = {RequestMethod.PUT, RequestMethod.POST}) {id}在这zhi个请求的URL里就是个变量,可以使用@PathVariable来获dao取 @PathVariable和@RequestParam的区别就在于:@RequestParam用来获得静态的URL请求入参
    @EnableEurekaServer 开启eureka注册中心服务
    @EnableEurekaClient 开启eureka客户端
    @EnableCircuitBreaker 开启熔断器的注解
    @SpringCloudApplication 注解@SpringCloudApplication包括:@SpringBootApplication、@EnableDiscoveryClient、@EnableCircuitBreaker,分别是SpringBoot注解、注册服务中心Eureka注解、断路器注解。
    @HystrixCommand(fallbackMethod = “findByIdFallBack”) 该方法调用服务失败时会调用findByIdFallBack方法
    @FeignClient Spring Cloud声明式调用Feign负载均衡FeignClient
    @EnableFeignClients 开启Feign客户端功能
    ClientGlobal.init() fastDFS文件服务器的java客户端初始化方法ClientGlobal.init()
    ClassPathResource(path) 加载资源文件
    fastDFSFile.getContent() 附件内容
    fastDFSFile.getExt() 附件扩展名
    NameValuePair[1] 附件备注([x]x为指定元素个数)
    TrackerClient 创建跟踪服务器的客户端类
    trackerClient.getConnection() 通过跟踪服务器的客户端获取服务器端
    StorageClient(); 存储服务器客户端类(new StorageClient(跟踪服务器, 存储服务器);)
    storageClient.upload_file 文件上传
    getInetSocketAddress() IP 套接字地址 (IP 地址+端口号)
    getAddress() 封装计算机的 IP 地址,不包含端口号
    getHostName() 获取主机名
    ClientGlobal.getG_tracker_http_port() 获取服务器端口号
    storageClient.download_file(group_name, remote_filename); 文件下载,参数(组名,文件所在的磁盘目录)
    storageClient.delete_file(group_name, remote_filename); 删除文件,参数(组名,文件所在的磁盘目录)
    FileInfo fileInfo = storageClient.get_file_info(group_name, remote_filename); 获取文件信息,参数(组名,文件所在的磁盘目录)
    MultipartFile MultipartFile实现文件上传
    MultipartFile.getOriginalFilename() 获取文件名
    FilenameUtils.getExtension(name); 根据文件名获取文件扩展名
    MultipartFile.getBytes() 获取文件内容
    IOUtils.write(bytes,new FileOutputStream(“D:\100.jpg”)) write(指定数据,输出地址)方法可以把数据写入到输出流中
    FileInfo 文件信息类
    fileInfo.getCreateTimestamp() 文件上传的时间
    ileInfo.getFileSize() 文件大小
    fileInfo.getSourceIpAddr() 服务器地址
    StorageServer 封装存储服务器信息
    storageServer.getStorePathIndex() 存储服务器所在的组的index索引
    storageServer.getInetSocketAddress().getAddress().getHostAddress()) 服务器ip
    storageServer.getInetSocketAddress().getPort() 服务器端口号port
    idworker 产生唯一的id(idworker工具类)
    JSON.parseObject(spec, Map.class) json字符串转化为对象
    entrySet() 由于Map中存放的元素均为键值对,故每一个键值对必然存在一个映射关系。Map中采用Entry内部类来表示一个映射项,映射项包含Key和ValueMap.Entry里面包含getKey()和getValue()方法Set<Entry<T,V>> entrySet()该方法返回值就是这个map中各个键值对映射关系的集合。
    @EnableCanalClient 开启mysql数据监听
    @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class}) 排除自动注入数据源的配置(取消数据库配置),一般使用在客户端(消费者)服务中
    @CanalEventListener 声明当前的类是canal的监听类
    @InsertListenPoint 监听新增操作
    CanalEntry.EntryType entryType 数据库操作事件
    CanalEntry.RowData rowData 行数据
    rowData.getAfterColumnsList() 获取数据库操作新增数据
    CanalEntry.Column 操作的数据列名和列值
    rowData.getBeforeColumnsList() 获取数据库操作更新前的数据
    rowData.getAfterColumnsList() 获取数据库操作更新的数据
    rowData.getBeforeColumnsList(); 获取数据库操作删除的数据
    @DeleteListenPoint 监听删除操作
    @UpdateListenPoint 监听更新操作
    stringRedisTemplate.boundValueOps() 设置redis中的key键
    @EnableElasticsearchRepositories(basePackages = {“com.changgou.search.dao”}) 操作es数据库(启动类中扫描数据库)
    JSON.toJSONString JSON.toJSONString则是将对象转化为Json字符串
    JSON.parseArray(text, SkuInfo.class); 将json数据text转换成SkuInfo类型的List集合
    JSON.parseObject JSON.parseObject,是将Json字符串转化为相应的对象
    ElasticsearchTemplate ElasticsearchTemplate是Spring对ES的java api进行的封装,提供了大量的相关的类来完成各种各样的查询
    NativeSearchQueryBuilder NativeSearchQueryBuilder多条件查询方法
    NativeSearchQueryBuilder.withQuery() 添加检索条件
    QueryBuilders.matchQuery(“name”, keywords) 为所提供的字段名和文本创建一个类型为“布尔”的匹配查询。(字段名,条件)
    AggregatedPage.getContent() 商品列表数据
    AggregatedPage.getTotalElements() 总条数
    AggregatedPage.getTotalPages() 总页数
    NativeSearchQueryBuilder.addAggregation // 添加聚合条件(分组条件)
    AggregationBuilders.terms(“skuCategory”).field(“categoryName”) terms指定字段的别名,field指定需要检索的字段
    AggregatedPage.getAggregations() 获取聚合结果(获取分组结果)
    aggregations.get(“skuCategory”) 根据字段名获取结果
    getBuckets() 将结果转换成list集合
    elasticsearchTemplate.queryForPage(nativeSearchQuery, SkuInfo.class) 根据条件查询后分页(条件,类型)
    intValue(); 将数据转换成int类型
    NativeSearchQueryBuilder.build() 将NativeSearchQueryBuilder类型数据转换成NativeSearchQuery类型数据
    getKeyAsString() 将数据转换成String类型
    QueryBuilders.boolQuery() 返回满足bool下所有query的结果(拼接查询条件)
    BoolQueryBuilder.must() 添加检索条件
    keySet() 遍历所有的键
    startsWith(“spec_”) 判断是否以指定字段开头
    QueryBuilders.rangeQuery(“price”).gte(prices[0]).lte(prices[1]) 查询字段price中的数据,条件是:gte(值)(大于等于)lte(值)(小于等于)
    NativeSearchQueryBuilder .withSort() 对结果进行排序
    SortBuilders.fieldSort(sortField).order(SortOrder.ASC) SortBuilders.fieldSort(需要排序的字段).order(排序规则) SortOrder.ASC升序,SortOrder.DESC)降序
    withFilter(bool) 根据条件bool进行过滤
    Integer.valueOf(pageNum) 将数据转成int类型
    PageRequest.of(page, size); 分页工具PageRequest.of(当前页码, 每页显示行数);封装分页条件
    withPageable(pageable) 对分页条件进行分页
    手机 $12
    导管 $1电脑
    手机 $12
    导管 $1
    手机 $12
    导管 $1电脑
    手机 $12
    导管 $1电脑
    手机 $12
    导管 $1电脑
    手机 $12
    导管 $1电脑
    手机 $12
    导管 $1电脑
    手机 $12
    导管 $1电脑
    手机 $12
    导管 $1
    手机 $12
    导管 $1电脑
    手机 $12
    导管 $1电脑
    手机 $12
    导管 $1电脑
    手机 $12
    导管 $1电脑
    手机 $12
    导管 $1电脑
    手机 $12
    导管 $1电脑
    手机 $12
    导管 $1
    展开全文
  • Springboot常用注解记录

    2019-07-23 15:31:37
    在使用springboot的使用,注解很多,一般配置完成后就不去看了, 所以在这里做下记录 @SpringBootApplication 启动类注解,一般放置于springboot初始化类中 @ComponentScan 包扫描注解,用来配置springboot需要进行...
    在使用springboot的使用,注解很多,一般配置完成后就不去看了, 所以在这里做下记录
    @SpringBootApplication  启动类注解,一般放置于springboot初始化类中
    
    @ComponentScan 包扫描注解,用来配置springboot需要进行注解解析的包
    
    @EnableTransactionManagement 事务管理注解, 用来开启数据库事务管理
    
    @EnableSwagger2 启用swagger文档生成注解,用于启动时生成swagger文档
    
    @RestController controller注解(包含Controller和ResponseBody两个注解)
    
    @RequestMapping 路由注解
    
    @ResponseBody 返回数据注解
    
    @Service 服务注解
    
    @Component 通用注解(表示这是一类组件)
    
    @RequestParam 普通参数注解
    
    @RequestBody json参数注解
    
    @Autowired  属性注入注解
    
    @Profile 分环境条件注解
    
    @RunWith (测试相关)
    
    @SpringBootTest (测试相关)
    
    @Before  (测试相关)测试类初始化
    
    @Test (测试相关)测试用例注解
    

    未完,待续....

    展开全文
  • 一、SpringBoot常用注解二、SpringBoot自动配置机制SpringBoot版本:1.5.13.RELEASE 对应官方文档链接:https://docs.spring.io/spring-boot/docs/1.5.13.RELEASE/reference/htmlsingle/ 一、SpringBoot常用注解...
  • springboot常用注解集锦

    2017-09-20 09:39:13
    @SpringBootApplication: 包含@Configuration、@EnableAutoConfiguration、@ComponentScan 通常用在主类上。 @Repository: 用于标注数据访问组件,即DAO组件。 @Service: 用于标注业务层组件。  @RestController...
  • Springboot常用注解小结

    千次阅读 2018-03-07 11:25:11
    Springboot专有注解,用于标注该类为项目的启动类,入口类。 @Aspect 表示该类是AOP类 要想把一个类变成切面类,需要两步, ①在类上使用 @Component 注解把切面类加入到IOC容器中 ②在类上使用 @Aspect 注解使之...
  • 自动生成Api常用注解 @Configuration 注解,让Spring来加载该类配置 @EnableSwagger2 注解来启用Swagger2 @ApiOperation(value = “接口说明”, httpMethod = “接口请求方式”, response = “接口返回参数...
  • @SpringBootApplication Spring Boot的项目一般都会有*Application...@SpringBootApplication注解是Spring Boot的核心注解,它其实是一个组合注解, 源码如下: @SpringBootConfiguration:表示Application作为...
  • 一、SpringBoot常用注解 在上一篇文章中引用了官方文档的入门例子,那个例子中只是告诉我们如何去快速上手SpringBoot。我们实际开发中,肯定不会在一个类中把所有业务处理包圆,通常会划分出Controller层、Service...
  • springboot @RestController注解来控制处理Http请求 配合@RequestMapping 配置url映射使用。 1.@RestController注解是@Controller和@RequestBody的组合使用 @RestController public class HelloController { @...
  • @SpringBootApplication: 包含了@ComponentScan、@Configuration和@EnableAutoConfiguration注解。 其中@ComponentScan让spring Boot扫描到Configuration类并把它加入到程序上下文。 home.php?mod=space&uid=...
  • springboot_poi_demo:整合poi文档操作,最简单的导入导出操作 springboot_poi_demo_v2:整合poi文档操作,升级版 springboot_poi_demo_v3:整合poi文档操作,模板操作 springboot_poi_demo_v3:excel纯文本的导入, ...
  • springboot常用注解(包含spring及MVC)

    千次阅读 2017-03-06 13:45:20
    说明:以下的注解springboot,spring以及spinrgMVC中常见的部分注解,并不包含全部,我只是列出了常用的一些。@Controller 这个无需多言,表明某类是一个controller,配合@RequestMapping注解即可实现跳转 @...
  • @SpringBootApplication: 包含了@ComponentScan、@Configuration和@EnableAutoConfiguration注解。其中@ComponentScan让spring Boot扫描到Configuration类并把它加入到程序上下文。 @Configuration 等同于spring...
  • Target设定注解使用范围,通过ElementType来指定注解可使用范围的枚举集合 。 @Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.ANNOTATION_TYPE) public @interface Target { Element...
  • SpringBoot常用注解

    2019-08-18 13:44:46
    SpringBoot常用注解 springboot注解: @Service: 注解在类上,表示这是一个业务层bean @Controller:注解在类上,表示这是一个控制层bean @Repository: 注解在类上,表示这是一个数据访问层bean @Component: 注解...
  • SpringBoot框架常用注解+SpringBoot框架常用注解项目配置注解controller 层注解servcie层注解持久层注解参数校验读取配置信息其他相关注解Java元注解spring AOP常用注解JPA 相关常用注解restSwagger常用注解lombok...
  • SpringBoot常用注解

    2020-05-15 11:53:06
    SpringBoot常用注解 在spring boot中,摒弃了spring以往项目中大量繁琐的配置,遵循约定大于配置的原则,通过自身默认配置,极大的降低了项目搭建的复杂度。同样在spring boot中,大量注解的使用,使得代码看...
  • SpringBoot 1.3 注解

    2020-02-20 17:11:51
    1.3 SpringBoot注解 本节主要介绍常用的注解,想了解更多信息可参考官网文档: ...1.3.1 SpringBoot/Spring常用注解 注解列表 @SpringBootAppl...
  • SpringBoot中的常用注解扫描类的注解4种请求方法参数类资源引入类事务类属性校验类其他类型的注解 扫描类的注解 @Mapper 和 @Repository 相同点 两个都是注解在Dao上 回到顶部 不同 @Repository需
  • 在使用 Springboot 框架进行开发的时候,通常我们会在 main 函数上添加 @SpringBootApplication 注解,今天为大家解析一下 @SpringBootApplication,如有不正之处,欢迎批评...
  • Springboot注解–IoC常用注解(Componnent 提示:Springboot注解 提示:写完文章后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录Springboot注解--IoC常用注解(Componnent前言一、pandas是什么?二、...
  • Springboot常用注解

    2019-03-21 11:09:11
    @ApiOperation是swagger里的,用来构建API文档的 @ApiOperation(value = “接口说明”, httpMethod = “接口请求方式”, response = “接口返回参数类型”, notes = “接口发布说明”; @ResponseBody将java对象转为...
  • springboot各种注解

    2018-09-29 17:39:49
    Spring4.3中引进了{@GetMapping、@PostMapping、@PutMapping、@DeleteMapping、@PatchMapping},来帮助简化常用的HTTP方法的映射,并更好地表达被注解方法的语义。  以@GetMapping为例,Spring官方文档说:  @...
  • springboot 项目注解

    2018-10-25 19:41:58
    @Configuration可理解为用spring的时候xml里面的标签 ...Swagger 注解 Swagger 是一款RESTFUL接口的文档在线自动生成+功能测试功能软件 。 (原文地址:  https://www.jianshu.com/p/8033ef83a8ed |  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,264
精华内容 4,505
关键字:

springboot常用注解文档

spring 订阅