SpringBoot2-web简单开发使用到的常见注解（含义+用法/案例）_spring-web的注解 2023

---

@SpringBootApplication

• 应用的主程序类

package com.abc;
//SpringBoot应用的主程序类，这是一个SpringBoot应用
@SpringBootApplication
public class HelloSpringBoot {
    public static void main(String[] args) {
        //启动Spring，传入的类必须是@SpringBootApplication注解标注的类
        SpringApplication.run(HelloSpringBoot.class,args);
    }
}

1
2
3
4
5
6
7
8
9
10

这是个合成注解

@SpringBootConfiguration代表当前是一个配置类
@EnableAutoConfiguration自动载入应用程序所需的所有Bean
	@AutoConfigurationPackage自动导入包
		@Import(AutoConfigurationPackages.Registrar.class)  //给容器中导入一个组件
		public @interface AutoConfigurationPackage {}
		//利用Registrar给容器中导入一系列组件
		//将指定的一个包下的所有组件导入进来？MainApplication 所在包下。
	@Import(AutoConfigurationImportSelector.class)给容器导入组件
		1、利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
		2、调用List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
		3、利用工厂加载 Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader)；得到所有的组件
		4、从META-INF/spring.factories位置来加载一个文件。
		默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件
	    spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories    
@ComponentScan(扫描那个包）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在启动类中，这个注解也可以增加一个参数使得默认扫描注解的范围从启动类同级别及其以下变为指定的包及其以下。

@ResponseBody

• 返回值是返回给浏览器的,以json格式提交

@Controller

• 表明这是一个控制器类
• 处理 Http 请求
• （注入服务）

@RestController

• 是@Controller与@ResponseBody两个注解的综合体

@RequestMapping(“/hello”)

• 映射类，可通过参数的地址找到对应的控制器类实现的功能

package com.abc.controller;


import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 异侠 2021/4/23
 */

//每一个方法返回的数据都是给浏览器的
@ResponseBody
//控制器类
@RestController
//可以用
//@RestController代替@RestController与@ResponseBody
public class Controller {

    @RequestMapping("/hello")
    public String handle01(){
        return "Hello, Spring Boot 2!";
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

@Configuration(proxyBeanMethods = true)

这是一个配置类

proxyBeanMethods：代理bean的方法
*全配置Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
*情配置Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
*      组件依赖必须使用Full模式默认。其他默认是否Lite模式
1
2
3
4

设置成false的话每次启动不会检查是不是已经有了组件，所以启动会快。

@Bean

    //给容器添加组件，方法名就是ID，返回值就是类型，返回的数值就是组件的实例化
    @Bean
    public User user01(){
        User user=new User(1,"异侠",23);
        user.setUserPet(new Pet("小黄狗"));
        return user;
    }

    //有参数的话就相当于给组件起新名字
    @Bean("user03")
    public User user02(){
        return new User(2,"异侠",22);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

@EnableAutoConfiguration

//自动载入应用程序所需的所有Bean

但是会和@SpringBootApplication重复，可以删去@EnableAutoConfiguration注解以平衡。

@ComponentScan(“com”)

会扫描该com包及其所在的包下所有的配置类

@component

是spring中的一个注解，它的作用就是实现bean的注入，

web开发，提供3个@Component注解衍生注解（功能一样）取代
@Repository(“名称”)：dao层
@Service(“名称”)：service层
@Controller(“名称”)：web层

泛指各种组件，就是说当我们的类不属于各种归类的时候（不属于@Controller、@Services等的时候），我们就可以使用@Component来标注这个类。

@Service （注入dao）

用于标注服务层，主要用来进行业务的逻辑处理

@Repository（实现dao访问）

用于标注数据访问层，也可以说用于标注数据访问组件，即DAO组件

@Import({User.class, DBHelper.class})

导入组件，数组形式，一次可以导入很多，自动创建参数类型的组件，默认组件名字是全类名
可以在Main函数里面打印出来检验

@Import 高级用法： https://www.bilibili.com/video/BV1gW411W7wy?p=8

@ConditionalOnBean(name=“pet”)

这是条件装配，常用在配置文件中，
当配置文件的注册bean中有pet组件时，此注解下面的组件才会配值生效

@ImportResource

在配置类上使用
原生配置文件导入

======================beans.xml=========================
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="haha" class="com.atguigu.boot.bean.User">
        <property name="name" value="zhangsan"></property>
        <property name="age" value="18"></property>
    </bean>

    <bean id="hehe" class="com.atguigu.boot.bean.Pet">
        <property name="name" value="tomcat"></property>
    </bean>
</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@ImportResource("classpath:beans.xml")
public class MyConfig {}

======================测试=================
        boolean haha = run.containsBean("haha");
        boolean hehe = run.containsBean("hehe");
        System.out.println("haha："+haha);//true
        System.out.println("hehe："+hehe);//true
1
2
3
4
5
6
7
8

@Autowired

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

@ConfigurationProperties(prefix = “mycar”)

在Bean上使用，配置绑定，配置文件中的信息绑定到bean里面

package com.abc.bean;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @author 异侠 2021/4/26
 */
//组件加入容器
@Component
//配置绑定，配置文件中的信息绑定到bean里面
@ConfigurationProperties(prefix = "mycar")
public class MyCar {
    private String brand;
    private Integer price;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public MyCar(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }

    public MyCar() {
    }

    @Override
    public String toString() {
        return "MyCar{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

@EnableConfigurationProperties(MyCar.class)

必须在配置类中使用

开器属性配置绑定功能，并且自动注册到容器中

package com.abc.config;

import ch.qos.logback.core.db.DBHelper;
import com.abc.bean.MyCar;
import com.abc.bean.Pet;
import com.abc.bean.User;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

/**
 * @author 异侠 2021/4/25
 */
/**proxyBeanMethods：代理bean的方法
*全配置Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
*情配置Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
*      组件依赖必须使用Full模式默认。其他默认是否Lite模式
 */
//导入组件，数组形式，一次可以导入很多，自动创建参数类型的组件，默认组件名字是全类名
@Import({User.class, DBHelper.class})
//这是一个配置类== 配置文件
@Configuration(proxyBeanMethods = true)
//开器属性配置绑定功能，并且自动注册到容器中
@EnableConfigurationProperties(MyCar.class)
public class MyConfig {

    //给容器添加组件，方法名就是ID，返回值就是类型，返回的数值就是组件的实例化
    @Bean
    public User user01(){
        User user=new User(1,"异侠",23);
        //User组件依赖Pet组件,使得pet属性也是单实例的
        //前提是proxyBeanMethods = true
        user.setUserPet(pet());
        return user;
    }

@ConditionalOnBean(name="pet")
    //@Bean
    public Pet pet(){
        return new Pet("小黄狗");
    }



    //有参数的话就相当于给组件起新名字
    @Bean("user03")
    public User user02(){
        return new User(2,"异侠",22);
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

@GetMapping(“/user”)

等价于 @RequestMapping(value = “/user”,method = RequestMethod.GET)

@PostMapping(“/user”)

等价于 @RequestMapping(value = “/user”,method = RequestMethod.POST)

@PutMapping(“/user”)

等价于@RequestMapping(value = “/user”,method = RequestMethod.PUT)

@DeleteMapping(“/user”)

等价于@RequestMapping(value = “/user”,method = RequestMethod.DELETE)

---

@PathVariable

请求路径变量注解
处理请求 url 路径中的参数 /user/

@RequestHeader

请求头

@RequestParam

处理问号后面的参数

    //  car/2/owner/zhangsan
    @GetMapping("/car/{id}/owner/{username}")
    //@PathVariable路径变量注解
    public Map<String,Object> getCar(@PathVariable("id") Integer id,
                                     @PathVariable("username") String name,
                                     @PathVariable Map<String,String> pv,
                                     //请求头
                                     @RequestHeader("User-Agent") String userAgent,
                                     //map形式的请求头
                                     @RequestHeader Map<String,String> header,
                                     //单个请求参数
                                     @RequestParam("age") Integer age,
                                     //多个请求参数，两种写法
                                     @RequestParam("inters") List<String> inters,
                                     @RequestParam Map<String,String> params
    ){


        Map<String,Object> map = new HashMap<>();

//        map.put("id",id);
//        map.put("name",name);
//        //pv是路径里面出现的参数的集合
//        map.put("pv",pv);
//        map.put("userAgent",userAgent);
//        map.put("headers",header);
        map.put("age",age);
        map.put("inters",inters);
        map.put("params",params);
        return map;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

---

@RequestBody

获得请求体内容@RequestBody
因为前端向后端传递的是json格式

    @PostMapping("/save")
    //获得编请求体内容@RequestBody
    public Map postMethod(@RequestBody String content){
        Map<String,Object> map = new HashMap<>();
        map.put("content",content);
        return map;
    }

1
2
3
4
5
6
7
8

@RequestAttribute

获得Request作用域里面的请求里面的参数

package com.abc.maven05.controller;

import com.sun.javafx.collections.MappingChange;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestAttribute;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

/**
 * @author 异侠 2021-04-28
 */



@Controller
public class RequestController {


    @RequestMapping("/goto")
    //拿到原始的request请求
    public String goToPag(HttpServletRequest request){

        request.setAttribute("msg1","成功了1");
        request.setAttribute("msg2","成功了2");
        //转发到当前页面下的success路径
        return "forward:success";
    }


    //方法1：注解方式1取参数
    @ResponseBody
    @RequestMapping("/success")
    public Map success(@RequestAttribute("msg1") String str1,
                          @RequestAttribute("msg2") String str2,
                          HttpServletRequest request){
        //方法2：request方式取参数
        String str3=request.getAttribute("msg1").toString();
        String str4=request.getAttribute("msg2").toString();
        //打印两种方式取值结果
        Map<String,String> map=new HashMap<>();
        map.put("str1",str1);
        map.put("str2",str2);
        map.put("str3",str3);
        map.put("str4",str4);
        return map;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

@Data :

注解在类上, 为类提供读写属性, 此外还提供了 equals()、hashCode()、toString() 方法

@Getter/@Setter :

注解在类上, 为类提供读写属性

@ToString :

注解在类上, 为类提供 toString() 方法

@Slf4j :

注解在类上, 为类提供一个属性名为 log 的 log4j 的日志对象

@Log4j :

注解在类上, 为类提供一个属性名为 log 的 log4j 的日志对象