JavaWeb笔记_SpringBoot原理

配置优先级
Bean管理
- 获取Bean
- Bean作用域
- 第三方Bean
SpringBoot原理
- 自动配置原理
- - @ComponentScan组件扫描
  - @Import导入
  - 源码跟踪
  - @Conditional
  - 自定义starter
  - - 创建aliyun-oss-spring-boot-starter模块
    - 创建aliyun-oss-spring-boot-autoconfigure
来源

配置优先级

命令行参数(–xxx=xxx) > java系统属性(-Dxxx=xxx) > properties > yml > yaml

配置命令行参数和java系统属性:

在IDEA中
在终端
1. 执行maven打包指令package
2. 执行java指令, 运行jar包
  java -Dserver.port=9000 -jar tlias-web-management-0.0.1-SNAPSHOT.jar --server.port=10010

注意事项:
Springboot项目进行打包时，需要引入插件spring-boot-maven-plugin (基于官网骨架创建项目公会自动添加该插件)

Bean管理

获取Bean

@Test
public void testGetBean(){
    //根据bean的名称获取
    DeptController bean1 = (DeptController) applicationContext.getBean("deptController");
    System.out.println(bean1);
    //根据bean的类型获取
    DeptController bean2 = applicationContext.getBean(DeptController.class);
    System.out.println(bean2);

    //根据bean的名称 及 类型获取
    DeptController bean3 = applicationContext.getBean("deptController", DeptController.class);
    System.out.println(bean3);
}

Bean作用域

作用域	说明
singleton	单例, 容器内同名称的bean只有一个实例(默认值)
prototype	每次使用该bean时会创建新的实例
request	每个请求范围内会创建新的实例(web环境中, 了解)
session	每个会话范围内会创建新的实例(web环境中, 了解)
application	每个应用范围内会创建新的实例(web环境中, 了解)

注意事项:

默认singleton的bean, 在容器启动时被创建, 可以使用@Lazy注解来延迟初始化(延迟到第一次使用).

第三方Bean

如果要管理的bean对象来自于第三方(不是自定义的)，是无法用 @Component 及衍生注解声明bean的，就需要用到@Bean注解.

@Configuration // 配置类
public class CommonConfig {

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

}

SpringBoot原理

自动配置原理

@ComponentScan组件扫描

@ComponentScan({"com.example", "com.itheima"})
@SpringBootApplication
public class SpringbootWebConfig2Application {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }

}

@Import导入

//@Import({TokenParser.class}) // 引入普通类, 交给IOC
//@Import({HeaderConfig.class}) // 引入配置类, 交给IOC
//@Import({MyImportSelector.class}) // 引入ImportSelector接口实现类, 交给IOC
@EnableHeaderConfig // 封装@Import注解
@SpringBootApplication
public class SpringbootWebConfig2Application {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }

}

// ImportSelector
public class MyImportSelector implements ImportSelector {
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.example.HeaderConfig"};
    }
}

源码跟踪

@SpringBootConfiguration // 该注解与@Configuration注解作用相同, 用来声明当前也是一个配置类
@EnableAutoConfiguration // 组件扫描, 默认扫描当前引导类所在包及其子包
@ComponentScan // SpringBoot实现自动化配置的核心注解


/**
 * 1. @EnableAutoConfiguration
 * 2. @Import(AutoConfigurationImportSelector.class)
 * 3. String[] selectImports
 * 4. spring.factories(2.7.x之后不使用)和spring/...imports
 * /

@Conditional

@Bean
//@ConditionalOnClass(name = "io.jsonwebtoken.Jwts") // 环境中存在指定的这个类, 才会将该bean加入IOC容器中
//@ConditionalOnMissingBean // 不存在该类型的bean, 才会将该bean加入IOC容器中 -- 指定类型(value属性) 或 名称(name属性)
@ConditionalOnProperty(name = "name ", havingValue = "itheima") // 配置文件中存在指定的键值对, 才会将该bean加入IOC容器中
public HeaderParser headerParser(){
    return new HeaderParser();
}

自定义starter

创建aliyun-oss-spring-boot-starter模块

仅保留pom.xml文件, 用于依赖管理, 导入自动配置模块.

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>com.aliyun.oss</groupId>
        <artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>
</dependencies>

创建aliyun-oss-spring-boot-autoconfigure

// AliOSSAutoConfiguration
@Configuration
@EnableConfigurationProperties(AliOSSProperties.class)
public class AliOSSAutoConfiguration {

    @Bean
    public AliOSSUtils aliOSSUtils(AliOSSProperties ailOSSProperties){
        AliOSSUtils aliOSSUtils = new AliOSSUtils();
        aliOSSUtils.setAilOSSProperties(ailOSSProperties);
        return aliOSSUtils;
    }
}
// AliOSSProperties
@ConfigurationProperties(prefix = "aliyun.oss")
public class AliOSSProperties {

    private String endpoint;
    private String accessKeyId;
    private String accessKeySecret;
    private String bucketName;

    public String getEndpoint() {
        return endpoint;
    }

    public void setEndpoint(String endpoint) {
        this.endpoint = endpoint;
    }

    public String getAccessKeyId() {
        return accessKeyId;
    }

    public void setAccessKeyId(String accessKeyId) {
        this.accessKeyId = accessKeyId;
    }

    public String getAccessKeySecret() {
        return accessKeySecret;
    }

    public void setAccessKeySecret(String accessKeySecret) {
        this.accessKeySecret = accessKeySecret;
    }

    public String getBucketName() {
        return bucketName;
    }

    public void setBucketName(String bucketName) {
        this.bucketName = bucketName;
    }
}
// AliOSSUtils
public class AliOSSUtils {

    // @Value("${aliyun.oss.endpoint}")
    // private String endpoint;
    // @Value("${aliyun.oss.accessKeyId}")
    // private String accessKeyId;
    // @Value("${aliyun.oss.accessKeySecret}")
    // private String accessKeySecret;
    // @Value("${aliyun.oss.bucketName}")
    // private String bucketName;

    private AliOSSProperties aliOSSProperties;

    public AliOSSProperties getAilOSSProperties() {
        return aliOSSProperties;
    }

    public void setAilOSSProperties(AliOSSProperties aliOSSProperties) {
        this.aliOSSProperties = aliOSSProperties;
    }

    /**
     * 实现上传图片到OSS
     */
    public String upload(MultipartFile file) throws IOException {
        // 获取阿里云OSS参数
        String endpoint = aliOSSProperties.getEndpoint();
        String accessKeyId = aliOSSProperties.getAccessKeyId();
        String accessKeySecret = aliOSSProperties.getAccessKeySecret();
        String bucketName = aliOSSProperties.getBucketName();

        // 获取上传的文件的输入流
        InputStream inputStream = file.getInputStream();

        // 避免文件覆盖
        String originalFilename = file.getOriginalFilename();
        String fileName = UUID.randomUUID().toString() + originalFilename.substring(originalFilename.lastIndexOf("."));

        //上传文件到 OSS
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        ossClient.putObject(bucketName, fileName, inputStream);

        //文件访问路径
        String url = endpoint.split("//")[0] + "//" + bucketName + "." + endpoint.split("//")[1] + "/" + fileName;
        // 关闭ossClient
        ossClient.shutdown();
        return url;// 把上传到oss的路径返回
    }
}
// META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
com.aliyun.oss.AliOSSAutoConfiguration
// maven
<dependencies>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</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>