SpringBoot常用注解及自动装配原理

最新推荐文章于 2024-05-27 10:17:58 发布
最新推荐文章于 2024-05-27 10:17:58 发布
阅读量1.2k 收藏 12
点赞数 25
文章标签： java spring boot spring 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63588450/article/details/137788432
版权

一、核心注解

@SpringBootApplication
通常用于启动类上，让SpringBoot自动给程序进行必要的配置，其组合包含3个注解@SpringBootConfiguration:组合了@Configuration注解，实现配置文件的功能。@EnableAutoConfiguration打开自动配置功能也可以关闭某个自动配置的选项。
如关闭数据源自动配置功能： @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })；
@ComponentScan：Spring组件的扫描功能，让SpringBoot扫描到Configuration类并把它加入到程序的上下文

二、配置注解

@Configuration
声明一个配置类，相当于让这个类的功能等同于bean xml配置文件

如：配置自定义拦截对象

@Configuration  // 定义一个配置类
public class WebConfig implements WebMvcConfigurer {
​
    // 拦截器对象
    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;
​
    @Override
    public void addInterceptors(InterceptorRegistry registry){
        // 自定义注册的拦截对象
        // .addPathPatterns设置拦截请求  /**表示拦截全部请求
        registry.addInterceptor(loginCheckInterceptor).addPathPatterns("/**")
                .excludePathPatterns("/login");  // 设置不拦截的请求路径
    }
}
​
@Bean注解
@Bean是一个方法级别的注解，spring的@Bean注解用于告诉方法产生一个bean对象，并把这个bean对象交给spring管理。产生这个bean对象的方法spring只会调用一次，随后这个spring将会将这个bean对象交给springIOC容器管理。创建bean的名称默认为 "方法名"+"首字母小写"
@Bean一般用于声明第三方的Bean交由spring管理。如果要管理的bean对象来自于第三方（不是自定义的），是无法用 @Component 及衍生注解声明bean的，就需要用到 @Bean注解。通过@Bean注解的name或value属性可以声明bean的名称，如果不指定，默认bean的名称就是方法名。如果第三方bean需要依赖其它bean对象，直接在bean定义方法中设置形参即可，容器会根据类型自动装配

如：

@Configuration //配置类  (在配置类当中对第三方bean进行集中的配置管理)
public class CommonConfig {
​
    //声明第三方bean
    @Bean //将当前方法的返回值对象交给IOC容器管理, 成为IOC容器bean
          //通过@Bean注解的name/value属性指定bean名称, 如果未指定, 默认是方法名
    // DeptService为其依赖的bean对象，直接设置形参即可，容器会根据类型自动装配的
    public SAXReader reader(DeptService deptService){
        System.out.println(deptService);
        return new SAXReader();
    }
​
}

有无@Configuration注解下的@Bean注解的区别

有没有@Configuration注解，@Bean都会起效，都会将@Bean修饰的方法作为bean注册到容器中
​
@Configuration注解修饰的类，会被spring通过cglib做增强处理，通过cglib会生成一个代理对象，代理会拦截所有被@Bean注解修饰的方法，可以确保一些bean是单例的
​
不管@Bean所在的类上是否有@Configuration注解，都可以将@Bean修饰的方法作为一个bean注册到spring容器中
@ConfigurationProperties

读取.yml配置文件中相同开头的属性，并与bean中的字段进行匹配

@Component
@ConfigurationProperties(prefix = "sky.alioss")
@Data
public class AliOssProperties {
​
    private String endpoint;
    private String accessKeyId;
    private String accessKeySecret;
    private String bucketName;
​
}
sky:
#配置阿里云文件上传
  alioss:
    endpoint: https....
    access-key-id: ......
    access-key-secret: .....
    bucket-name: .....

三、自动配置注解

SpringBoot的自动配置就是当Spring容器启动后，一些配置类、bean对象就自动存入到了IOC容器中，不需要我们手动去声明，从而简化了开发，省去了繁琐的配置操作。

@ComponentScan

告诉Spring那个包会被自动扫描并且装进bean容器中。@SpringBootApplication注解就是包含@ComponentScan注解，所以其在启动时会自动扫描启动类所在的包及其子包。当然也可通过使用@ComponentScan注解扫描指定的包。

@SpringBootApplication
@ComponentScan({"com.xiaoxie","com.example"}) //指定要扫描的包
public class SpringbootWebConfig2Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }
}
​

@Import

@import注解可以将类导入Spring加载到IOC容器中，可代替@ComponentScan导入第三方依赖的bean

import的三种导入类型

  • 导入普通类

  • 导入配置类

  • 导入ImportSelector接口实现类

1）导入普通类

@Import(TokenParser.class) //导入的类会被Spring加载到IOC容器中
@SpringBootApplication
public class SpringbootWebConfig2Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }
}

2）导入配置类

配置类

@Configuration
public class HeaderConfig {
    @Bean
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
​
    @Bean
    public HeaderGenerator headerGenerator(){
        return new HeaderGenerator();
    }
}

启动类

@Import(HeaderConfig.class) //导入配置类
@SpringBootApplication
public class SpringbootWebConfig2Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }
}

3）导入ImportSelector接口实现类

ImportSelector接口实现类

public class MyImportSelector implements ImportSelector {
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        //返回值字符串数组（数组中封装了全限定名称的类）
        return new String[]{"com.example.HeaderConfig"};
    }
}

启动类

@Import(MyImportSelector.class) //导入ImportSelector接口实现类
@SpringBootApplication
public class SpringbootWebConfig2Application {
​
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }
}

@ComponentScan和@Import注解虽然都可以导入第三方依赖的bean，但是其导入需指定所需的Bean这对我们来说依旧时比较麻烦的，因此我们还可以使用第三方依赖提供的 @EnableXxxxx注解

@EnableXxxxx

第三方依赖中提供的注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(MyImportSelector.class)//指定要导入哪些bean对象或配置类
public @interface EnableHeaderConfig { 
}

在使用时只需在启动类上加上@EnableXxxxx注解即可

@EnableHeaderConfig  //使用第三方依赖提供的Enable开头的注解
@SpringBootApplication
public class SpringbootWebConfig2Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }
}

@EnableAutoConfiguration

开启自动配置功能，当SpringBoot程序启动时，就会加载配置文件当中所定义的配置类，并将这些配置类信息(类的全限定名)封装到String类型的数组中，最终通过@Import注解将这些配置类全部加载到Spring的IOC容器中，交给IOC容器管理。

@EnableAutoConfiguration封装了@Import注解（Import注解中指定了一个ImportSelector接口的实现类）
- 在实现类重写的selectImports()方法，读取当前项目下所有依赖jar包中METAINF/spring.factories、METAINF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports两个文件里面定义的配置类（配置类中定义了@Bean注解标识的方法）。

INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件中定义的配置类非常多，而且每个配置类中又可以定义很多的bean，这些bean不会都注册到Spring的IOC容器中。在声明bean对象时，上面有加一个以@Conditional开头的注解，这种注解的作用就是按照条件进行装配，只有满足条件之后，才会将bean注册到Spring的IOC容器中

@Conditional

按照一定的条件进行判断，在满足给定条件后才会注册对应的bean对象到Spring的IOC容器中。

@Conditional本身是一个父注解，派生出大量的子注解：

  • @ConditionalOnClass：判断环境中有对应字节码文件，才注册bean到IOC容器。

  • @ConditionalOnMissingBean：判断环境中没有对应的bean(类型或名称)，才注册bean到IOC容器。

  • @ConditionalOnProperty：判断配置文件中有对应属性和值，才注册bean到IOC容器。

@ConditionalOnClass注解
@Configuration
public class HeaderConfig {
​
    @Bean
    @ConditionalOnClass(name="io.jsonwebtoken.Jwts")//环境中存在指定的这个类，才会将该bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
    
    //省略其他代码...
}

pom.xml

<!--JWT令牌-->
<dependency>
     <groupId>io.jsonwebtoken</groupId>
     <artifactId>jjwt</artifactId>
     <version>0.9.1</version>
</dependency>

@ConditionalOnMissingBean注解
@Configuration
public class HeaderConfig {
​
    @Bean
    @ConditionalOnMissingBean //不存在该类型的bean，才会将该bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
    
    //省略其他代码...
}

SpringBoot在调用@Bean标识的headerParser()前，IOC容器中是没有HeaderParser类型的bean，所以HeaderParser对象正常创建，并注册到IOC容器中。

或者是：

@Configuration
public class HeaderConfig {
​
    @Bean
    @ConditionalOnMissingBean(name="deptController2")//不存在指定名称的bean，才会将该bean加入IOC容器
    // @ConditionalOnMissingBean(HeaderConfig.class)//不存在指定类型的bean，才会将bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
    
    //省略其他代码...
}

@ConditionalOnProperty注解

这个注解和配置文件当中配置的属性有关系

先在application.yml配置文件中添加如下的键值对：

name: xiaoxie
@Configuration
public class HeaderConfig {
​
    @Bean
    @ConditionalOnProperty(name ="name",havingValue = "xiaoxie")//配置文件中存在指定属性名与值，才会将bean加入IOC容器
    public HeaderParser headerParser(){
        return new HeaderParser();
    }
​
}

SpringBoot自动配置的核心

自动配置的核心就在@SpringBootApplication注解上，SpringBootApplication这个注解底层包含了3个注解，分别是：

  • @SpringBootConfiguration

  • @ComponentScan

  • @EnableAutoConfiguration

@EnableAutoConfiguration这个注解才是自动配置的核心。

  • 它封装了一个@Import注解，Import注解里面指定了一个ImportSelector接口的实现类。

  • 在这个实现类中，重写了ImportSelector接口中的selectImports()方法。

  • 而selectImports()方法中会去读取两份配置文件，并将配置文件中定义的配置类做为selectImports()方法的返回值返回，返回值代表的就是需要将哪些类交给Spring的IOC容器进行管理。

  • 那么所有自动配置类的中声明的bean都会加载到Spring的IOC容器中吗? 其实并不会，因为这些配置类中在声明bean时，通常都会添加@Conditional开头的注解，这个注解就是进行条件装配。而Spring会根据Conditional注解有选择性的进行bean的创建。

  • @Enable 开头的注解底层，它就封装了一个注解 import 注解，它里面指定了一个类，是 ImportSelector 接口的实现类。在实现类当中，我们需要去实现 ImportSelector 接口当中的一个方法 selectImports 这个方法。这个方法的返回值代表的就是我需要将哪些类交给 spring 的 IOC容器进行管理。

  • 此时它会去读取两份配置文件，一份儿是 spring.factories，另外一份儿是 autoConfiguration.imports。而在 autoConfiguration.imports 这份儿文件当中，它就会去配置大量的自动配置的类。

  • 而前面我们也提到过这些所有的自动配置类当中，所有的 bean都会加载到 spring 的 IOC 容器当中吗？其实并不会，因为这些配置类当中，在声明 bean 的时候，通常会加上这么一类@Conditional 开头的注解。这个注解就是进行条件装配。所以SpringBoot非常的智能，它会根据 @Conditional 注解来进行条件装配。只有条件成立，它才会声明这个bean，才会将这个 bean 交给 IOC 容器管理。

封装自定义公共组件starter

业务场景：

  • 我们在案例当中所使用的阿里云OSS对象存储服务，现在阿里云的官方是没有给我们提供对应的起步依赖的，这个时候使用起来就会比较繁琐，我们需要引入对应的依赖。我们还需要在配置文件当中进行配置，还需要基于官方SDK示例来改造对应的工具类，我们在项目当中才可以进行使用。

  • 大家想在我们当前项目当中使用了阿里云OSS，我们需要进行这么多步的操作。在别的项目组当中要想使用阿里云OSS，是不是也需要进行这么多步的操作，所以这个时候我们就可以自定义一些公共组件，在这些公共组件当中，我就可以提前把需要配置的bean都提前配置好。将来在项目当中，我要想使用这个技术，我直接将组件对应的坐标直接引入进来，就已经自动配置好了，就可以直接使用了。我们也可以把公共组件提供给别的项目组进行使用，这样就可以大大的简化我们的开发。

在SpringBoot项目中，一般都会将这些公共组件封装为SpringBoot当中的starter，也就是我们所说的起步依赖。

SpringBoot官方starter命名： spring-boot-starter-xxxx

第三组织提供的starter命名： xxxx-spring-boot-starter

在自定义一个起步依赖starter的时候，按照规范需要定义两个模块：

  1. starter模块（进行依赖管理把程序开发所需要的依赖都定义在starter起步依赖中]）

  2. autoconfigure模块（自动配置）

自定义starter实现

需求

  • 自定义aliyun-oss-spring-boot-starter，完成阿里云OSS操作工具类 AliyunOSSUtils 的自动配置。

  • 目标：引入起步依赖引入之后，要想使用阿里云OSS，注入 AliyunOSSUtils直接使用即可。

步骤：

  • 创建 aliyun-oss-spring-boot-starter 模块（进行依赖的管理）

  • 创建 aliyun-oss-spring-boot-autoconfigure 模块，在starter中引入该模块

  • 在starter中引入autoconfigure （我们使用时只需要引入starter起步依赖即可）

  • 在 aliyun-oss-spring-boot-autoconfigure 模块中的定义自动配置功能，并定义自动配置文件 METAINF/spring/xxxx.imports

首先我们先来创建两个Maven模块：

1). aliyun-oss-spring-boot-starter模块

创建完starter模块后，删除多余的文件，最终保留内容如下：

删除pom.xml文件中多余的内容后：

<?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.7.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
​
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-oss-spring-boot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
​
    <properties>
        <java.version>11</java.version>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>
​
</project>

2). aliyun-oss-spring-boot-autoconfigure模块

创建完starter模块后，删除多余的文件，最终保留内容如下：

没有出现iml文件的：进入aliyun-oss-spring-boot-starter文件夹，输入cmd，输入 mvn idea:module

删除pom.xml文件中多余的内容后：

<?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.7.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
    <version>0.0.1-SNAPSHOT</version>
​
    <properties>
        <java.version>11</java.version>
    </properties>
​
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>
​
</project>

按照我们之前的分析，是需要在starter模块中来引入autoconfigure这个模块的。打开starter模块中的pom文件：

<?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.7.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
​
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-oss-spring-boot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
​
    <properties>
        <java.version>11</java.version>
    </properties>
    
    <dependencies>
        <!--引入autoconfigure模块-->
        <dependency>
            <groupId>com.aliyun.oss</groupId>
            <artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>
​
</project>

前两步已经完成了，接下来是最关键的就是第三步：

在autoconfigure模块当中来完成自动配置操作。

我们将之前案例中所使用的阿里云OSS部分的代码直接拷贝到autoconfigure模块下，然后进行改造就行了。

拷贝过来后，还缺失一些相关的依赖，需要把相关依赖也拷贝过来：

<?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.7.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
    <version>0.0.1-SNAPSHOT</version>
​
    <properties>
        <java.version>11</java.version>
    </properties>
​
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
​
        <!--引入web起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
​
        <!--Lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
​
        <!--阿里云OSS-->
        <dependency>
            <groupId>com.aliyun.oss</groupId>
            <artifactId>aliyun-sdk-oss</artifactId>
            <version>3.15.1</version>
        </dependency>
​
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.1</version>
        </dependency>
        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>activation</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!-- no more than 2.3.3-->
        <dependency>
            <groupId>org.glassfish.jaxb</groupId>
            <artifactId>jaxb-runtime</artifactId>
            <version>2.3.3</version>
        </dependency>
    </dependencies>
</project>

现在类上添加的@Component注解还有用吗？

答案：没用了。 在SpringBoot项目中，并不会去扫描com.aliyun.oss这个包，不扫描这个包那类上的注解也就失去了作用。

@Component注解不需要使用了，可以从类上删除了。

删除后报红色错误，暂时不理会，后面再来处理

删除AliOSSUtils类中的@Component注解、@Autowired注解

下面我们就要定义一个自动配置类了，在自动配置类当中来声明AliOSSUtils的bean对象。

AliOSSAutoConfiguration类：

@Configuration//当前类为Spring配置类
@EnableConfigurationProperties(AliOSSProperties.class)//导入AliOSSProperties类，并交给SpringIOC管理
public class AliOSSAutoConfiguration {
​
​
    //创建AliOSSUtils对象，并交给SpringIOC容器
    @Bean
    public AliOSSUtils aliOSSUtils(AliOSSProperties aliOSSProperties){
        AliOSSUtils aliOSSUtils = new AliOSSUtils();
        aliOSSUtils.setAliOSSProperties(aliOSSProperties);
        return aliOSSUtils;
    }
}

AliOSSProperties类：

/*阿里云OSS相关配置*/
@Data
@ConfigurationProperties(prefix = "aliyun.oss")
public class AliOSSProperties {
    //区域
    private String endpoint;
    //身份ID
    private String accessKeyId ;
    //身份密钥
    private String accessKeySecret ;
    //存储空间
    private String bucketName;
}

AliOSSUtils类：

@Data 
public class AliOSSUtils {
    private AliOSSProperties aliOSSProperties;
​
    /**
     * 实现上传图片到OSS
     */
    public String upload(MultipartFile multipartFile) throws IOException {
        // 获取上传的文件的输入流
        InputStream inputStream = multipartFile.getInputStream();
​
        // 避免文件覆盖
        String originalFilename = multipartFile.getOriginalFilename();
        String fileName = UUID.randomUUID().toString() + originalFilename.substring(originalFilename.lastIndexOf("."));
​
        //上传文件到 OSS
        OSS ossClient = new OSSClientBuilder().build(aliOSSProperties.getEndpoint(),
                aliOSSProperties.getAccessKeyId(), aliOSSProperties.getAccessKeySecret());
        ossClient.putObject(aliOSSProperties.getBucketName(), fileName, inputStream);
​
        //文件访问路径
        String url =aliOSSProperties.getEndpoint().split("//")[0] + "//" + aliOSSProperties.getBucketName() + "." + aliOSSProperties.getEndpoint().split("//")[1] + "/" + fileName;
​
        // 关闭ossClient
        ossClient.shutdown();
        return url;// 把上传到oss的路径返回
    }
}

在aliyun-oss-spring-boot-autoconfigure模块中的resources下，新建自动配置文件：

  • META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

    com.aliyun.oss.AliOSSAutoConfiguration

3.2.4.3 自定义starter测试

阿里云OSS的starter我们刚才已经定义好了，接下来我们就来做一个测试。

今天的课程资料当中，提供了一个自定义starter的测试工程。我们直接打开文件夹，里面有一个测试工程。测试工程就是springboot-autoconfiguration-test，我们只需要将测试工程直接导入到Idea当中即可。

测试前准备：

  1. 在test工程中引入阿里云starter依赖

    • 通过依赖传递，会把autoconfigure依赖也引入了

    <!--引入阿里云OSS起步依赖-->
<dependency>
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-oss-spring-boot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

  2. 在test工程中的application.yml文件中，配置阿里云OSS配置参数信息（从以前的工程中拷贝即可）

    #配置阿里云OSS参数
aliyun:
  oss:
    endpoint: https://oss-cn-shanghai.aliyuncs.com
    accessKeyId: LTAI5t9MZK8iq5T2Av5GLDxX
    accessKeySecret: C0IrHzKZGKqU8S7YQcevcotD3Zd5Tc
    bucketName: web-framework01

  3. 在test工程中的UploadController类编写代码

    @RestController
public class UploadController {
​
    @Autowired
    private AliOSSUtils aliOSSUtils;
​
    @PostMapping("/upload")
    public String upload(MultipartFile image) throws Exception {
        //上传文件到阿里云 OSS
        String url = aliOSSUtils.upload(image);
        return url;
    }
​
}

编写完代码后，我们启动当前的SpringBoot测试工程：

  • 随着SpringBoot项目启动，自动配置会把AliOSSUtils的bean对象装配到IOC容器中

用postman工具进行文件上传：

通过断点可以看到自动注入AliOSSUtils的bean对象：

四、常用注解

@Component
@Component： 标注Spring管理的Bean，使用@Component注解在一个类上，表示将此类标记为Spring容器中的一个Bean,交由Spring IOC容器管理

@Autowired

依赖注入，是指IOC容器要为应用程序去提供运行时所依赖的资源，而资源指的就是对象。

@Autowired注解，完成了依赖注入的操作，为程序运行所需的对象实现了自动装配功能，默认是按照类型进行自动装配的。如果有多个实现类可以配合@Qualifier(value=“类名”)来使用 （是根据名称来进行注入的）
@primary
使用@Primary注解：当存在多个相同类型的Bean注入时，加上@Primary注解，来确定默认的实现。

@Qualifier
指定当前要注入的bean对象。 在@Qualifier的value属性中，指定注入的bean的名称。@Qualifier注解不能单独使用，必须配合@Autowired使用

@Resource
是按照bean的名称进行注入。通过name属性指定要注入的bean的名称。

@Autowird 与 @Resource的区别

  • @Autowired 是spring框架提供的注解，而@Resource是JDK提供的注解

  • @Autowired 默认是按照类型注入，而@Resource是按照名称注入

@Controller

@Controller 用于传统的 MVC 架构，负责处理请求并返回视图作为响应，默认返回的是一个页面。

@Component的衍生注解，用于标识一个 Java 类是一个控制器。控制器负责接收请求、处理请求，并返回响应。具体来说，使用 @Controller 注解的类将会被 Spring MVC 自动扫描，并注册为一个控制器，然后将web请求映射到注解了@RequestMapping的方法上。

@Contrlloer特性：
自动映射 URL。@Controller 注解可以自动将请求映射到控制器的方法上。
支持视图解析。@Controller 注解可以将方法的返回值解析为视图，并渲染到客户端。（可以封装jsp页面进行返回）

视图解析：

    @RequestMapping("/adminList")
    public String adminList(Model model){
        IAdminService adminService = new AdminServiceImpl();
            List<Admin> list =  adminService.findAlladmins();
            model.addAttribute("Aadmins", list);
            return "/admin/admin-list";
        }

@Service
@Component的衍生注解，标注在业务层上。

@Reponsitory

由于与Mybatis整合，用的少

@Repository是标注在Dao层接口上，作用是将接口的一个实现类交给Spring管理。同时它还能将所标注的类中抛出的数据访问异常封装为 Spring 的数据访问异常类型。
注意：
使用这个注解的前提是必须在启动类上添加@MapperScan("Mapper接口层路径") 注解

@Mapper
@Mapper: 这个注解一般使用在Dao层接口上，相当于一个mapper.xml文件，它的作用就是将接口生成一个动态代理类。加入了@Mapper注解，目的就是为了不再写mapper映射文件。这个注解就是用来映射mapper.xml文件的。
​
使用@mapper后，不需要在spring配置中设置扫描地址，通过mapper.xml里面的namespace属性对应相关的mapper类，spring将动态的生成Bean后注入到ServiceImpl中。

@RequestMapping
@RequestMapping表示共享映射，如果没有指定请求方式，将接收GET、POST、HEAD、OPTIONS、PUT、PATCH、DELETE、TRACE、CONNECT所有的HTTP请求方式。@GetMapping、@PostMapping、@PutMapping、@DeleteMapping、@PatchMapping 都是HTTP方法特有的快捷方式@RequestMapping的变体，分别对应具体的HTTP请求方式的映射注解。
@RequestMapping 注解可以在控制器类上和控制器类中的方法上使用。
@Slf4j
@RestController
@RequestMapping("/user")
public class DeptController {
​
    @Autowired
    private DeptService deptService;
​
​
//    查询全部部门
    @GetMapping("/depts")
    public Result list(){
        log.info("查询到所有部门");
        List<Dept> deptList = deptService.list();
        return Result.success(deptList);
    }
}
@ResponseBody
@ResponseBody：将java对象转为json格式的数据。@responseBody注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据。
注意：在使用此注解之后不会再走视图处理器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据。
​
@ResponseBody一般是作用在方法上的，@ResponseBody 表示该方法的返回结果直接写入 HTTP response body 中，一般在异步获取数据时使用。
​
注意：在使用 @RequestMapping后，返回值通常解析为跳转路径，但是加上 @ResponseBody 后返回结果不会被解析为跳转路径，而是直接写入 HTTP response body 中。 比如异步获取 json 数据，加上 @ResponseBody 后，会直接返回 json 数据。@RequestBody 将 HTTP 请求正文插入方法中，使用适合的 HttpMessageConverter 将请求体写入某个对象。

后台 Controller类中对应的方法：
@RequestMapping("/login")
@ResponseBody
public Object login(String name, String password, HttpSession session) {
    user = userService.checkLogin(name, password);
    session.setAttribute("user", user);
    return new JsonResult(user);
}

@RestController
@RestController包含@Controller和@ResponseBody。在使用 @RestController 注解标记的类中，每个方法的返回值都会以 JSON 或 XML 的形式直接写入 HTTP 响应体中，相当于在每个方法上都添加了 @ResponseBody 注解。
@ResponseBody 注解表示方法的返回值应该直接写入 HTTP 响应体中，而不是被解析为视图。它告诉 Spring MVC 框架将方法的返回值序列化为特定格式（如 JSON、XML 等）并作为响应的主体内容返回给客户端。
@RestController
@RequestMapping("/orders")
public class OrderController {
    @GetMapping("/{id}")
    public Order getOrderById(@PathVariable int id) {
        Order order = orderService.getOrderById(id);
        return order;
    }
}

@RequestParam
@RequestParam：将请求参数绑定到你控制器的方法参数上（是springmvc中接收普通参数的注解）
@RequestParam(value=”参数名”,required=”true/false”,defaultValue=””)
value：参数名
required：是否包含该参数，默认为true，表示该请求路径中必须包含该参数，如果不包含就报错。
defaultValue：默认参数值，如果设置了该值，required=true将失效，自动为false,如果没有传该参数，
就使用默认值
@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name = "name", required = false) String username, Integer age){
System.out.println(username+ ":" + age);
return "OK";
}

@DateTimeFormat

接收日期参数，避免接收参数时数据格式错误

@DateTimeFormat注解的pattern属性中指定了哪种日期格式，前端的日期参数就必须按照指定的格式传递。
后端controller方法中，需要使用Date类型或LocalDateTime类型，来封装传递的参数。
@RestController
public class RequestController {
    //日期时间参数
   @RequestMapping("/dateParam")
    public String dateParam(@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime updateTime){
        System.out.println(updateTime);
        return "OK";
    }
}

@RequestBody
将JSON数据映射到形参的实体类对象中（JSON中的key和实体类中的属性名保持一致）
@RestController
public class RequestController {
    //JSON参数
    @RequestMapping("/jsonParam")
    public String jsonParam(@RequestBody User user){
        System.out.println(user);
        return "OK";
    }
}

@PathVariable
接收路径参数，可传递多个路径参数
@RestController
public class RequestController {
    //路径参数
    @RequestMapping("/path/{id}/{name}")
    public String pathParam2(@PathVariable Integer id, @PathVariable String name){
        System.out.println(id+ " : " +name);
        return "OK";
    }
}
玛朵布莎.哈
关注
  • 25
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
SpringBoot-起步依赖与自动装配原理
sinat_41847989的博客
12-11 1416
简化开发，约定大于配置，开箱即用，提供了各种默认配置来简化项目 1. 起步依赖分析 在起步依赖上，SpringBoot 帮我们管理了各个依赖的版本，使各个依赖不会出现版本冲突；另外，Spring Boot还帮我们打包了各个依赖让不用再像之前使用Spring那样导入一堆的依赖，只要引入起步依赖的坐标就可以进行web开发了，同样体现了依赖传递的用。 pom.xml 配置文件 spring-boot-dependencies： 核心依赖在父工程 spring-boot-starter-parent 中，部分坐
SpringBoot自动装配原理详解
m0_51007250的博客
07-01 1343
SpringBoot 自动装配原理 1. spring-boot-starter 我们创建了一个SpringBoot项目，首先看引入了哪些依赖。在pom.xml中，我们发现： <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.5.1&
手动实现SpringBoot自动装配类
04-21
手动实现SpringBoot自动装配类 ，清测可用，代码详见com.auto包
Springboot自动装配
纯洁的小魔鬼
05-31 4434
自动装配是springboot的核心，一般提到自动装配就会和springboot联系在一起。实际上 Spring Framework 早就实现了这个功能。Spring Boot 只是在其基础上，通过 SPI 的方式，做了进一步优化。
springboot自动装配注解
最新发布
m0_74295055的博客
05-27 339
如果@ComponentScan不指定basePackages，那么默认扫描当前包以及其子包，而@SpringBootApplication里的@ComponentScan就是默认扫描，所以我们一般都是把springboot启动类放在最外层，以便扫描所有的类。@ComponentScan作用就是扫描当前包以及子包，将有@Component，@Controller，@Service，@Repository等注解的类注册到容器中，以便调用。
springboot自动装配
热门推荐
好好玩的博客
04-03 4万+
文章目录1、自动装配是什么及作用2、spring自动装配的原理2.1、启动类上注解的作用@SpringBootApplication@SpringBootConfiguration@EnableAutoConfiguration@AutoConfigurationPackage@Import(AutoConfigurationImportSelector.class)@ComponentScan2.2、springboot自动装配的流程3、相关注解的作用@Conditional 1、自动装配是什么及作用 s
SpringBoot：自动化装配功能（@SpringBootApplication注解详解）
jpkopkop的博客
06-30 911
SpringBoot：自动化装配功能（@SpringBootApplication注解详解）
Springboot的自动装配解读
qq_43649937的博客
06-27 8071
Springboot java
SpringBoot自动注入原理
m0_53305501的博客
03-16 2185
SpringBoot中的自动注入是一个非常强大的功能，可以简化代码的编写，提高代码的可维护性。通过对自动注入的原理和配置的了解，可以更好地使用SpringBoot中的自动注入功能。
Spring 自动装配及其注解
07-23
5. **注解自动装配**（Annotation-based Autowiring）：这是最常用的方式，使用`@Autowired`、`@Qualifier`等注解进行精确控制。 三、注解驱动的自动装配 1. **@Autowired**：这是最常用的注解，用于自动装配bean。...
SpringBoot注解文档
12-27
7. `@Autowired`: 自动装配Bean，Spring会根据类型或名称将合适的Bean注入到字段或方法中。 8. `@Value`: 用于注入配置属性值，可以是从application.properties或application.yml文件中读取的。 9. `@Profile`: ...
Spring Boot 常用注解.rar
11-28
自动装配注解，Spring会根据类型自动将Bean注入到需要的地方，可以用于字段、构造器、方法参数。 9. **@Value** 用于注入配置文件中的属性值，可以注入基本类型或者SpEL表达式。 10. **@Conditional** 这个注解...
springboot07
12-14
@SpringBootApplication是SpringBoot的核心注解，它结合了@ComponentScan、@EnableAutoConfiguration和@Configuration的作用。通过分析其源码，我们可以了解到它是如何启动Spring的组件扫描、自动配置以及定义配置...
SpringBoot的自动装配
lhf2112的博客
05-13 1311
从SpringBoot源码，来看自动装配的原理
springboot中一些实现自动配置注解标签
weixin_52394141的博客
10-07 883
EnableAutoConfiguration 是利用SpringFactoriesLoader 机制加载自动装配配置的，它的配置数据在META-INF/spring.factories 中，我们打开 spring-boot-autoconfigure jar 中的该文件，发现对应着许多个 XXXAutoConfiguration 配置类.是作用在方法上的 , 方法中会产生一个对象,最终把此对象交给spring容器管理，注意此对象返回值就需要是你需要是spring管理的对象。名称，也就是小写的名称。
springBoot自动装配
qq_62898618的博客
11-16 1万+
为了简化配置，使spring的使用更加方便，例如：可以回忆一下springboot中是如何继承redis的。使用springboot后集成常用的第三方框架变得非常简单了。springboot starter带来的问题starter使SpringBoot集成第三方框架变得简单，但对刚刚上手SpringBoot的人来说，可能只知道配置属性是在application.xml或application.yml中添加，但他们各自的属性都有哪些，具体怎么配置，却无从下手。
springBoot的自动装配
HongSuShouyu的博客
03-28 2534
5、在解析@Import注解的时候，会有一个getImport()方法，从主类开始递归解析注解，把所有包含@Import的注解都解析到，然后在processImport()方法中对import的类进行分类，例如AutoConfigurationImportSelect归属于ImportSelect的子类，在后续的过程中会调用DeferredImportSelectorHandler类里面的process方法，来完成整个EnableAutoConfiguration的加载。
搞定SpringBoot的自动注入原理，一篇文章就够了
沸羊羊_
06-29 4335
使用 springboot 进行项目开发时，无需各种配置文件，无需繁杂的 pom 坐标，只要一个 xxxApplication （启动类）就 run 起来了，那 springboot 是怎么做到约定大于配置的？
springboot核心注解以及自动装配原理
Learning_foolish的博客
09-03 872
springboot核心注解以及自动装配原理
SpringBoot自动装配原理
05-18
SpringBoot自动装配原理是通过在classpath中扫描依赖的jar包，自动配置Bean，实现快速构建应用程序的一种机制。 SpringBoot利用了Spring框架中的自动装配特性，通过@EnableAutoConfiguration注解启用自动装配功能，并通过@Configuration注解和@Conditional注解控制Bean的加载。 在启动SpringBoot应用程序时，SpringBoot会自动扫描classpath中的jar包，将其中的配置文件和注解进行解析，并根据解析结果自动配置Bean，最终将这些Bean注入到应用程序中。 SpringBoot的自动装配机制主要涉及以下几个方面： 1. 自动扫描：SpringBoot会自动扫描应用程序中的所有类和jar包，查找与SpringBoot自动配置相关的注解。 2. 自动配置：SpringBoot会根据自动扫描结果，自动配置一系列的Bean，并将这些Bean注入到应用程序中。 3. 条件化装配：SpringBoot支持通过@Conditional注解指定Bean的加载条件，只有满足条件的Bean才会被加载。 4. 启动器：SpringBoot提供了一系列的启动器，用于快速集成常用的第三方库和框架，避免手动配置的繁琐和复杂。 总之，SpringBoot的自动装配机制能够帮助开发人员快速构建应用程序，减少手动配置的工作量，提高开发效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值