Springboot-自动装配原理和整合配置文件

lqh12138

已于 2022-07-27 09:13:17 修改

阅读量626

点赞数

于 2022-07-23 14:26:16 首次发布

本文链接：https://blog.csdn.net/m0_58212960/article/details/125946946

版权

springboot 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.springboot自动装配原理

什么是自动装配?

无需手动加载某些配置，而由Springboot自动加载进来。

譬如: 自己加载DispatcherServlet

如何完成自动装配?

为什么总的自动装配类由127个。因为这些自动装配类都在某个文件中写死了。

自己用语言总结一下Springboot自动装配的原理

自动装配大致流程是通过@SpringBootApplication进行实现，这个注解声明在SpringBoot的启动类上

1、SpringBoot启动类

2、@SpringBootApplication注解

        SpringBoot启动类=>@SpringBootApplication

3、@SpringBootConfiguration注解

        SpringBoot启动类=>@SpringBootApplication=>@SpringBootConfiguration

        通过@SpringBootConfiguration注解标识SpringBootApplication是一个SpringBoot配置类

        @AliasFor注解用于为注解属性声明别名（@SpringBootApplication注解也有@AliasFor注解）

4、@EnableAutoConfiguration注解

        SpringBoot启动类=>@SpringBootApplication=>@EnableAutoConfiguration

        通过@EnableAutoConfiguration注解实现自动装配

5、@AutoConfigurationPackage注解SpringBoot启动类

        =>@SpringBootApplication=>@EnableAutoConfiguration=>@AutoConfigurationPackage

        通过@AutoConfigurationPackage注解将添加该注解的类所在的package作为自动配置package进行管理

        通过AutoConfigurationPackages工具类获取自动配置package列表，也就是说当SpringBoot应用启动时默认会将启动类所在的package作为自动配置的package

6、@EnableAutoConfiguration注解最重要的是AutoConfigurationImportSelector.class，将需要装配的类装配到IoC容器中，下面重点分析一下这个类的实现

总结

1）通过注解@SpringBootApplication=>@EnableAutoConfiguration=>@Import({AutoConfigurationImportSelector.class})实现自动装配

2）AutoConfigurationImportSelector类中重写了ImportSelector中selectImports方法，批量返回需要装配的配置类

3）通过Spring提供的SpringFactoriesLoader机制，扫描classpath下的META-INF/spring.factories文件，读取需要自动装配的配置类

4）依据条件筛选的方式，把不符合的配置类移除掉，最终完成自动装配

2.springboot整合数据源

数据源: 指的是数据源。即是: springboot框架连接数据库。

（1）引入依赖

 <!--加入数据源的启动依赖: springboot启动时会加载对应的自动装配类。-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

（2）配置数据源信息---application.properties

# 配置数据源
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root

(3) 测试


@SpringBootTest(classes = Qy151SpringbootApplication.class)
class Qy151SpringbootApplicationTests {


    @Autowired
    private DataSource dataSource;

    @Test
    public void test01() throws SQLException {
        //验证了springboot可以帮你完成数据源的自动装配功能
        System.out.println(dataSource.getConnection());
    }

}

上面默认这个数据源使用的连接池Hikari。如果不想使用默认的连接池，我们可以引入第三方的连接池。

2.1 集成druid数据源

（1）依赖

 <!--引入数据库连接池druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.8</version>
        </dependency>

（2）配置文件

spring.datasource.druid.url=jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai
spring.datasource.druid.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.druid.username=root
spring.datasource.druid.password=root
#初始化的个数
spring.datasource.druid.initial-size=5
# 最大活跃数
spring.datasource.druid.max-active=10
# 最大等待时间
spring.datasource.druid.max-wait=3000
# 最小的闲置个数
spring.datasource.druid.min-idle=5

(3)测试


    @Autowired
    private DataSource dataSource;

    @Test
    public void test01() throws SQLException {
        //验证了springboot可以帮你完成数据源的自动装配功能
        System.out.println(dataSource);
        System.out.println(dataSource.getConnection());
    }

3. springboot整合mybatis

(1)引入mybatis启动依赖类

        <!--引入mybatis的启动依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>

(2) 修改配置文件

#指定映射文件的路径
mybatis.mapper-locations=classpath:mapper/*.xml

（3）再主启动类加上注解

@SpringBootApplication
@MapperScan(basePackages = "com.ykq.dao") //为指定的包下的接口生成代理实现类
public class Qy151SpringbootApplication {

    public static void main(String[] args) {
        //加载那含有@SpringBootApplication注解的类,它的特殊之处就是该类使用了@SpringBootApplication ，它是一个复合组件。
        //@EnableAutoConfiguration
        SpringApplication.run(Qy151SpringbootApplication.class, args);
    }

}

(4)测试

    @Autowired
    private DeptMapper deptMapper;

    @Test
    public void test02(){
        System.out.println(deptMapper.findById(1));
    }

4. springboot整合PageHelper分页插件

（1）引入依赖

  <!--pageHelper的启动依赖 自动装配拦截器-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.4.2</version>
        </dependency>

（2）测试:

  @Test
    public void test03(){
         PageHelper.startPage(1, 3);
        List<Dept> list = deptMapper.findAll();
        PageInfo<Dept> pageInfo=new PageInfo<>(list);
        System.out.println("当前页码:"+pageInfo.getPageNum());
        System.out.println("当前总页码:"+pageInfo.getPages());
        System.out.println("总条数:"+pageInfo.getTotal());
        System.out.println("当前页码的记录:"+pageInfo.getList());

    }

5. springboot整合swagger2

什么是swagger2？

它是一个接口文档----用来前后端分离的一款文档。

（1）引入swagger依赖


        <dependency>
            <groupId>com.spring4all</groupId>
            <artifactId>swagger-spring-boot-starter</artifactId>
            <version>1.9.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>swagger-bootstrap-ui</artifactId>
            <version>1.7.8</version>
        </dependency>

（2）创建swagger配置类

package com.lqh.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.service.VendorExtension;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;

import java.util.ArrayList;

/**
 * @Author Li Qinghua
 * @Create 2022/7/22 20:40
 */
@Configuration
public class SwaggerConfig {
    @Bean//swagger中所有的功能都封装再Docket类中
    public Docket testSwagger(){
        Docket docket=new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(productApiInfo())//设置api文档信息
                .select().apis(RequestHandlerSelectors.basePackage("com.lqh.controller"))//指定为哪些包下的类生成接口文档。
                .build();
        return docket;
    }

    //定义自己接口文档信息
    public ApiInfo productApiInfo(){
        Contact contact=new Contact("李青华","http://www.bai","2579528448@qq.com");
        ApiInfo apiInfo=new ApiInfo("管理员系统","这是管理员的文档生成器","V2.0",
                "http://www.baidu.com",contact,"青华科技","http://www.baidu.com",new ArrayList<VendorExtension>());
        return apiInfo;
    }
}

（3）开启swagger注解

（4）使用swagger注解

@Api 接口类的注解---接口类上 tag属性
@ApiOperation 接口方法的注解---接口方法上 value:
@ApiImplicitParams( 接口参数的说明
{
ApiImplicitParam() //单个参数的说明
}
)

@ApiModel---- 实体类接口注解
@ApiModelProperty---->实体类属性的说明

（5）访问

第一种方式:http://192.168.1.22:8080/lqh/swagger-ui.html

第二种方式：http://192.168.1.22:8080/lqh/swagger-ui.html（推荐）

6.springboot整合定时器

什么是定时器?

在指定的时间，执行相应的业务代码。

为什么使用定时器?

比如: OSS文件系统服务器，会产生大量冗余文件。定时删除冗余文件【凌晨2~3点】。

比如: 下单后半个未支付--取消订单。

如何来使用定时器。

（1）引入定时器依赖。

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

（2）编写定义任务代码。

package com.lqh.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component //该类交于spring容器来管理
public class QuartzTask {


    //任务代码cron:定义定时任务的规则 https://www.pppet.net/
    @Scheduled(cron = "0/1 * * * * ?")
    public void task01(){
        System.out.println("业务代码");
    }
}

（3）开启定时任务的注解

lqh12138

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Springboot-自动装配原理和整合配置文件

在使用SpringBoot的时候，会自动将Bean装配到IoC容器中。例如我们在使用Redis数据库的时候，会引入依赖spring-boot-starter-data-redis。在引入这个依赖后，服务初始化的时候，会将操作Redis需要的组件注入到IoC容器中进行后续使用自动装配大致过程如下：获取到组件（例如spring-boot-starter-data-redis）META-INF文件夹下的spring.factories文件spring.factories文件中列出需要注入IoC容器的类....
复制链接

扫一扫