注解介绍

imreW / 2023-05-18 / 原文

@Bean

1.介绍

该注释的属性的名称和语义类似于Spring XML模式中bean的元素的名称和语义。@Bean指示方法产生一个由Spring容器管理的bean。

2.使用

public class DataSource {
    private String url;
    private String userId;
    private String password;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "DataSource{" +
                "url='" + url + '\'' +
                ", userId='" + userId + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

@Configuration
public class DataBaseConfig {
    @Bean("dataSource")
    public DataSource getDataSource(){
        DataSource dataSource = new DataSource();
        dataSource.setUserId("jingsi");
        dataSource.setPassword("123456");
        dataSource.setUrl("www");
        return dataSource;
    }

}

@RestController
public class IndexController {
    @Autowired
//    @Resource(name = "user")
    private User user;
    @Autowired
    private DataSource dataSource;
    @GetMapping(value = "index")
    public String index(){
        return "hello world！"+"dataSource:"+dataSource;
    }
}

@Component & @Configuration

1注解定义

在讨论两者区别之前，先来看看两个注解的定义：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Component {

  /**
   * The value may indicate a suggestion for a logical component name,
   * to be turned into a Spring bean in case of an autodetected component.
   * @return the suggested component name, if any (or empty String otherwise)
   */
  String value() default "";

}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {

  @AliasFor(annotation = Component.class)
  String value() default "";

  boolean proxyBeanMethods() default true;

}

从定义来看， @Configuration 注解本质上还是 @Component，因此 @ComponentScan 能扫描到@Configuration 注解的类。

2注解使用

接下来看看两者在我们日常开发中的使用：以这两种注解来标注一个类为配置类

@Component
public class AppConfig {
}

@Configuration
public class AppConfig {
}

上面的程序，Spring会将其认为配置类来做处理，但是这里有一个概念需要明确一下，就是在Spring中，对于配置类来讲，其实是有分类的，大体可以分为两类，一类称为LITE模式，另一类称为FULL模式，那么对应上面的注解，@Component就是LITE类型，@Configuration就是FULL类型，如何理解这两种配置类型呢？我们先来看这个程序。

当我们使用@Component实现配置类时：

@Component
public class AppConfig {
  @Bean
  public Foo foo() {
    System.out.println("foo() invoked...");
    Foo foo = new Foo();
    System.out.println("foo() 方法的 foo hashcode: " + foo.hashCode());
    return foo;
  }

  @Bean
  public Eoo eoo() {
    System.out.println("eoo() invoked...");
    Foo foo = foo();
    System.out.println("eoo() 方法的 foo hashcode: "+ foo.hashCode());
    return new Eoo();
  }

  public static void main(String[] args) {
    AnnotationConfigApplicationContext context =
        new AnnotationConfigApplicationContext(AppConfig.class);
  }
}

执行结果如下：

foo() invoked...
foo() 方法的 foo hashcode: 815992954
eoo() invoked...
foo() invoked...
foo() 方法的 foo hashcode: 868737467
eoo() 方法的 foo hashcode: 868737467

从结果可知，foo()方法执行了两次，一次是bean方法执行的，一次是eoo()调用执行的，所以两次生成的foo对象是不一样的。很符合大家的预期，但是当我们使用@Configuration标注配置类时，执行结果如下：

foo() invoked...
foo() 方法的 foo hashcode: 849373393
eoo() invoked...
eoo() 方法的 foo hashcode: 849373393

这里可以看到foo()方法只执行了一次，同时eoo()方法调用foo()生成的foo对象是同一个。

这也就是@Component和@Configuration的区别现象展示，那么为什么会有这样的一个现象?

我们来考虑一个问题，就是eoo()方法中调用了foo()方法，很明显这个foo()这个方法就是会形成一个新对象，假设我们调用的foo()方法不是原来的foo()方法，是不是就可能不会形成新对象？如果我们在调用foo()方法的时候去容器中获取一下foo这个Bean，是不是就可以达到这样的效果？那如何才能达到这样的效果呢？有一个方法，代理！换句话说，我们调用的eoo()和foo()方法，包括AppConfig都被Spring代理了，那么这里我们明白了@Component与@Configuration最根本的区别，那就是@Configuration标注的类会被Spring代理，其实这样描述不是非常严谨，更加准确的来说应该是如果一个类的BeanDefinition的Attribute中有Full配置属性，那么这个类就会被Spring代理

3.Spring如何实现FULL配置的代理

如果要明白这一点，那么还需要明确一个前提，就是Spring在什么时间将这些配置类转变成FULL模式或者LITE模式的，接下来我们就要介绍个人认为在Spring中非常重要的一个类，ConfigurationClassPostProcessor。

（1）ConfigurationClassPostProcessor是什么

首先来简单的看一下这个类的定义:

public class ConfigurationClassPostProcessor implements 
                                              BeanDefinitionRegistryPostProcessor,
                                               PriorityOrdered, 
                                               ResourceLoaderAware, 
                                               BeanClassLoaderAware, 
                                               EnvironmentAware {}

由这个类定义可知这个类的类型为BeanDefinitionRegistryPostProcessor，以及实现了众多Spring内置的Aware接口，如果了解Beanfactory的后置处理器，那应该清楚ConfigurationClassPostProcessor的执行时机，当然不了解也没有问题，我们会在后面将整个流程阐述清楚，现在需要知道的是ConfigurationClassPostProcessor这个类是在什么时间被实例化的？

（2）ConfigurationClassPostProcessor在什么时间被实例化

要回答这个问题，需要先明确一个前提，那就是ConfigurationClassPostProcessor这个类对应的BeanDefinition在什么时间注册到Spring的容器中的，因为Spring的实例化比较特殊，主要是基于BeanDefinition来处理的，那么现在这个问题就可以转变为ConfigurationClassPostProcessor这个类是在什么时间被注册为一个Beandefinition的？这个可以在源代码中找到答案，具体其实就是在初始化这个Spring容器的时候。

new AnnotationConfigApplicationContext(ConfigClass.class)
  -> new AnnotatedBeanDefinitionReader(this);
    -> AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
      -> new RootBeanDefinition(ConfigurationClassPostProcessor.class);
        -> registerPostProcessor(BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName)

从这里可以看出，ConfigurationClassPostProcessor已经被注册为了一个BeanDefinition，上面我们讲了Spring是通过对BeanDefinition进行解析，处理，实例化，填充，初始化以及众多回调等等步骤才会形成一个Bean，那么现在ConfigurationClassPostProcessor既然已经形成了一个BeanDefinition。

（3）@Component与@Configuration的实现区别

上面ConfigurationClassPostProcessor已经注册到BeanDefinition注册中心了，说明Spring会在某个时间点将其处理成一个Bean，那么具体的时间点就是在BeanFactory所有的后置处理器的处理过程。

AbstractApplicationContext
  -> refresh()
    -> invokeBeanFactoryPostProcessors(beanFactory);
      -> PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

这个处理BeanFactory的后置处理器的方法比较复杂，简单说来就是主要处理所有实现了BeanFactoryPostProcessor及BeanDefinitionRegistryPostProcessor的类，当然ConfigurationClassPostProcessor就是其中的一个。

第一个方法postProcessBeanDefinitionRegistry主要完成了内部类，@Component，@ComponentScan，@Bean，@Configuration，@Import等等注解的处理，然后生成对应的BeanDefinition，
另一个方法postProcessBeanFactory就是对@Configuration使用CGLIB进行增强，

那我们先来看Spring是在哪里区分配置的LITE模式和FULL模式？在第一个方法中有一个checkConfigurationClassCandidate方法

根据程序的判断可知，如果一个类被@Configuration标注且代理模式为true，那么这个类对应的BeanDefinition将会被Spring添加一个FULL配置模式的属性

有些同学可能对这个”属性“不太理解，这里可以简单说一下，其实这个”属性“在Spring中有一个特定的接口就是AttributeAccessor，BeanDefinition就是继承了这个接口，如何理解这个AttributeAccessor呢？其实也很简单，想想看，BeanDefinition主要是做什么的？这个主要是用来描述Class对象的，例如这个Class是不是抽象的，作用域是什么，是不是懒加载等等信息，那如果一个Class对象有一个“属性”是BeanDefinition描述不了的，那这个要如何处理呢？那这个接口AttributeAccessor又派上用场了，你可以向其中存放任何你定义的数据，可以理解为一个map，现在了解BeanDefinition的属性的含义了么？

在这里也能看到@Configuration(proxyBeanMethods = false)和@Component一样效果，都是LITE模式

在这里第一步先判断出这个类是FULL模式还是LITE模式，那么下一步就需要开始执行对配置类的注解的解析了，在ConfigurationClassParser这个类有一个processConfigurationClass方法，里面有一个doProcessConfigurationClass方法，这里就是解析前文所列举的@Component等等注解的过程，解析完成之后，在ConfigurationClassPostProcessor类的方法processConfigBeanDefinitions，有一个loadBeanDefinitions方法，这个方法就是将前文解析成功的注解数据全都注册成BeanDefinition，这就是ConfigurationClassPostProcessor这个类的第一个方法所完成的任务，另外这个方法在这里是非常简单的描述了一下，实际上这个方法非常的复杂，需要慢慢的研究。

接下来再说ConfigurationClassPostProcessor类的enhanceConfigurationClasses方法，这个方法主要完成了对@Configuration注解标注的类的增强，进行CGLIB代理

这里需要CGLIB的一些知识，我就简单的在这里总结一下，这个方法从所有的BeanDefinition中找到属性为FULL模式的BeanDefinition，然后对其进行代理增强，设置BeanDefinition的beanClass。然后在增强时有一些细节稍微需要明确一下，就是我们这个普通类中的方法，比如eoo(),foo()等方法，将会被MethodInterceptor所拦截，这个方法的调用将会被BeanMethodInterceptor所代理，到这里我们大家应该稍微明确了ConfigurationClassPostProcessor是在什么时间被实例化，什么时间解析注解配置，什么时间进行配置增强。

4.总结

@Component在Spring中是代表LITE模式的配置注解，这种模式下的注解不会被Spring所代理，就是一个标准类，如果在这个类中有@Bean标注的方法，那么方法间的相互调用，其实就是普通Java类的方法的调用。

@Configuration在Spring中是代表FULL模式的配置注解，这种模式下的类会被Spring所代理，那么在这个类中的@Bean方法的相互调用，就相当于调用了代理方法，那么在代理方法中会判断，是否调用getBean方法还是invokeSuper方法，这里就是这两个注解的最根本的区别。

一句话概括就是 @Configuration 中所有带 @Bean 注解的方法都会被动态代理，因此调用该方法返回的都是同一个实例。

@RequestMapping

1.介绍

在Spring MVC 中使用 @RequestMapping 来映射请求，也就是通过它来指定控制器可以处理哪些URL请求，相当于Servlet中在web.xml中配置

<servlet>
    <servlet-name>servletName</servlet-name>
    <servlet-class>ServletClass</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>servletName</servlet-name>
    <url-pattern>url</url-pattern>
</servlet-mapping>

的映射作用一致。让我们先看一下RequestMapping注解类的源码：

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Mapping
public @interface RequestMapping {
    String name() default "";
    String[] value() default {};
    String[] path() default {};
    RequestMethod[] method() default {};
    String[] params() default {};
    String[] headers() default {};
    String[] consumes() default {};
    String[] produces() default {};
}

1）在@Target中有两个属性，分别为 ElementType.METHOD 和 ElementType.TYPE ，也就是说 @RequestMapping 可以在方法和类的声明中使用

2）可以看到注解中的属性除了 name() 返回的字符串，其它的方法均返回数组，也就是可以定义多个属性值，例如 value() 和 path() 都可以同时定义多个字符串值来接收多个URL请求

2.基础

@RequestMapping 用于将任意HTTP 请求映射到控制器方法上。

@RequestMapping表示共享映射，如果没有指定请求方式，将接收GET、POST、HEAD、OPTIONS、PUT、PATCH、DELETE、TRACE、CONNECT所有的HTTP请求方式。
@GetMapping、@PostMapping、@PutMapping、@DeleteMapping、@PatchMapping 都是HTTP方法特有的快捷方式@RequestMapping的变体，分别对应具体的HTTP请求方式的映射注解。

@RequestMapping 注解可以在控制器类上和控制器类中的方法上使用。

在类的级别上的注解会将一个特定请求或者请求模式映射到一个控制器之上。之后你还可以另外添加方法级别的注解来进一步指定到处理方法的映射关系。

需要注意的是，控制器方法都应该映射到一个特定的HTTP方法，而不是使用@RequestMapping共享映射。

3.使用

@RestController
public class UserController {
        // 映射到方法上
        // localhost:8080/user/login
        // 此处通常用 @GetMapping("/user/login") 表明GET请求方式的映射，因为login登录只需向服务器获取用户数据。
    @RequestMapping("/user/login")  
    public String login() {
        return "user login";
    }
    
    // 映射到方法上
    // localhost:8080/user/register
    // 此处通常用 @PostMapping("/user/login") 表明POST请求方式的映射，因为register注册需要向服务器提交用户数据。
    @RequestMapping("/user/register")
    public String register() {
        return "user register";
    }
}

如上述代码所示，到 /user/login 的请求会由 login() 方法来处理，而到 /user/register的请求会由 register() 来处理。

下面是一个同时在类和方法上应用了 @RequestMapping 注解的示例，上述代码与如下代码等价：

@RestController
// 映射到类上
// localhost:8080/user
@RequestMapping("/user")
public class UserController {
        // 映射到方法上
        // localhost:8080/user/login
        // 此处通常用 @GetMapping("/user/login") 表明GET请求方式的映射
    @RequestMapping("/login") 
    public String login() {
        return "user login";
    }
    
    // 映射到方法上
    // localhost:8080/user/register
    // 此处通常用 @PostMapping("/user/login") 表明POST请求方式的映射
    @RequestMapping("/register")
    public String register() {
        return "user register";
    }
}

一般情况下，这样代码更规范，因为user的控制器UserController只对user表进行操作。

4.处理 HTTP 请求

Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。

所有的请求默认都会是 HTTP GET 类型的。

为了能降一个请求映射到一个特定的 HTTP 方法，你需要在 @RequestMapping 中使用 method 属性来声明 HTTP 请求所使用的方法类型，也可以使用等价的组合注解。

请求	组合注解	共享注解
GET	@GetMapping	@RequestMapping(method = RequestMethod.GET)
POST	@PostMapping	@RequestMapping(method = RequestMethod.POST)
PUT	@PutMapping	@RequestMapping(method = RequestMethod.PUT)
DELETE	@DeleteMapping	@RequestMapping(method = RequestMethod.DELETE)
PATCH	@PatchMapping	@RequestMapping(method = RequestMethod.PATCH)

需要注意的是，控制器方法都应该映射到一个特定的HTTP方法，即使用组合注解，而不是使用@RequestMapping共享映射。因为组合注解减少了在应用程序上要配置的元数据，并且代码功能更清晰。

@RestController
@RequestMapping("/home")
public class IndexController {
    @RequestMapping(method = RequestMethod.GET)
    String get() {
        return "Hello from get";
    }
    @RequestMapping(method = RequestMethod.DELETE)
    String delete() {
        return "Hello from delete";
    }
    @RequestMapping(method = RequestMethod.POST)
    String post() {
        return "Hello from post";
    }
    @RequestMapping(method = RequestMethod.PUT)
    String put() {
        return "Hello from put";
    }
    @RequestMapping(method = RequestMethod.PATCH)
    String patch() {
        return "Hello from patch";
    }
}