Spring Boot 原理的分析（超详细！！！）

2023-05-16

1 Spring Boot

Spring Boot 没有特定的业务，将其他框架进行整合，去掉配置

开箱即用

Spring Boot 跟 Spring MVC 的整合

Spring Boot 跟 Thymeleaf 的整合

Spring Boot 跟 MyBatis 的整合

Spring Boot 跟 MyBatis Plus 的整合

Spring Boot 跟 Swagger 的整合

2 Spring Boot 自动装配原理

入口启动类 Application

核心注解 @SpringBootApplication，由 3 个注解组成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-17rQcIWY-1621772154364)(D:\图片\springBoot.png)]

2.1@SpringBootConfiguration

它本质上就是一个 @Configuration 注解， @Configuration 非常重要，因为它是 Spring Boot 框架中使用最多的一个注解。

2.1.1 @Configuration

标注了一个配置类，一个类如果添加了 @Configuration 注解，那么这个类就是一个配置类

什么是配置类？

取代 XML 的

Spring 中配置一个 bean

用xml方式

1、User

public class User{
	private Integer id;
	private String name;
}

2、spring.xml

<bean id="user" class="User">
	<property name="id" value="1"/>
	<property name="name" value="张三"/>
</bean>

<bean id="accout" class="Accout">
</bean>

使用 @Configuration 注解的方式完成。

注意事项

配置类一定要被启动类扫描到，配置扫包的结构
配置类本身也会被注入到 IOC 容器中。

2.1.2 @ConfigurationProperties

可以直接读取 YML 中的数据，封装到 bean 中

package com.wdzl.entity;

import lombok.Data;
import
org.springframework.boot.context.properties.ConfigurationProperties;

@Data
@ConfigurationProperties(prefix = "people")
public class People {
	private Integer id;
	private String name;
	private String tel;
}

people:
  id: 11
  name: Tom
  tel: 13378900987

package com.wdzl.configuration;
import com.wdzl.entity.People;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties(People.class)
public class PeopleConfiguration {
}

使用 @ConfigurationProperties 有什么用呢？

Spring Boot 整合 MyBatis 自动装配 MyBatis 需要的各种组件，DataSource 那么 Spring Boot 是怎么自动装配的呢？

SSM : XML 自己配 bean

@Configuration 取代了 XML， @ConfigurationProperties 的功能是从 YML 文件中读取信息，进而自动创建对象。

2.2@EnableAutoConfiguration

Spring Boot 框架中需要自动装载 bean

所有的 bean 可以分为两类：

框架自带的 bean，比如 DataSource、 SqlSessionFactory
- 开发者自定义的 bean，通过 @ComponentScan 注解完成
开发者自定义的，比如 controller、service、 repository
- 框架自带的 bean，通过 @EnableAutoConfiguration 来完成，本质上就@Import(Class) 注解
- 它的 Selector 又指定让 Spring Boot 去读取 META-INF/spring.factories 文件，这个文件中就将框架需要的 bean 全部配合，等着 Spring Boot 来读取，进而加载。

@Import 注解的作用也是给 IOC 中注入对象，需要结合传入它内部的类来处理的

类中返回需要注入的 bean 的信息，再由 @Import 完成注入

自定义 Selector

创建实体类

package com.wdzl.entity;
import lombok.Data;

@Data
public class Account {
	private String title;
}

创建 Selector

package com.wdzl.selector;
import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

public class MySelector implements ImportSelector {
	@Override
	public String[]	selectImports(AnnotationMetadataannotationMetadata) {
        return new String[]
        {"com.wdzl.entity.Account"};
    }
}

创建 @Import 所在的类

package com.wdzl.configuration;
import com.wdzl.selector.MySelector;
import org.springframework.context.annotation.Import;

@Import(MySelector.class)
public class ImportConfiguration {
}

通过 @Import 注入 MySelector.class 中返回的 bean 信息，Account

ImportConfiguration 怎么生效？只需要让 Spring Boot 读到它即可，怎么让 Spring Boot 读到它？

需要在工程中创建 META-INF/spring.factories 文件，将目标类配置进来即可

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.wdzl.configuration.ImportConfiguration

2.3@ComponentScan

自动扫描并加载符合条件的组件，通过设置 basePackage 参数来指定要扫描的根目录，该目录下的所有子类都会被扫描。

给哪个类添加该注解，那么该类所在的包就是默认的扫描路径

package com.wdzl;
import
com.wdzl.configuration.MyConfiguration;
import com.wdzl.controller.UserController;
import com.wdzl.entity.People;
import com.wdzl.entity.User;
import com.wdzl.repository.UserRepository;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.autoconfigure.AutoConfigurationExcludeFilter;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.TypeExcludeFilter;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.FilterType;
//@SpringBootApplication
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(basePackages ={"com.wdzl.controller","com.wdzl.repository
"})
public class Springboot002Application {
    public static void main(String[] args) {
        ApplicationContext applicationContext = springApplication.run(Springboot002Application.class, args);
        System.out.println(applicationContext.getBean(UserRepository.class));
        System.out.println(applicationContext.getBean(UserController.class));
    }
}

3 Spring Boot整合第三方框架的实现

所有的Spring Boot 和第三方框架的整合都是通过Starter来完成

框架的整合操作全部封装到Starter

MyBatis Starter

Starter 相当于 Spring Boot 提供的一种规范，你只要实现这种规范，那么你的代码就会融入 Spring Boot中。

手写一个 Spring Boot Starter

自己写一个工程，可以导入Spring Boot进行使用

3.1创建自己的工程

将 MSS 引入到其他的 Spring Boot 中，可以读取 Spring Boot 的 YML 配置。

1、创建Spring Boot工程，pom.xml

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

2、创建属性读取类 ServiceProperties

package com.wdzl.properties;

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


@ConfigurationProperties("zhao")
public class ServiceProperties {


    private String prefix;
    private String suffix;


    public String getPrefix() {
        return prefix;
    }

    public void setPrefix(String prefix) {
        this.prefix = prefix;
    }

    public String getSuffix() {
        return suffix;
    }

    public void setSuffix(String suffix) {
        this.suffix = suffix;
    }

    @Override
    public String toString() {
        return "ServiceProperties{" +
                "prefix='" + prefix + '\'' +
                ", suffix='" + suffix + '\'' +
                '}';
    }
}

3、创建 Service

package com.wdzl.service;

public class Service {
    private String prefix;
    private String suffix;

    public Service(String prefix, String suffix) {
        this.prefix = prefix;
        this.suffix = suffix;
    }

    public String doService(String value){
        return this.prefix+value+this.suffix;
    }
}

4、创建自动配置类 AutoConfigure

package com.wdzl.configure;

import com.wdzl.properties.ServiceProperties;
import com.wdzl.service.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnClass(Service.class)//必须要service类
@EnableConfigurationProperties(ServiceProperties.class)
public class AutoConfigure {
    @Autowired
    private ServiceProperties serviceProperties;


    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnProperty(
            prefix = "zhao",
            value = "enable",
            havingValue = "true"
    )
    public Service service(){
        return new Service(this.serviceProperties.getPrefix(),this.serviceProperties.getSuffix());
    }

}

5、在 resources 路径下创建 META-INF/spring.fatories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.wdzl.configure.AutoConfigure

6、将项目打成 jar 包，不要用 Maven 插件

7、将 jar 安装到本地仓库

mvn install:install-file -DgroupId=com.wdzl.spring.boot -DartifactId=demo_starter -Dversion=1.1.0 -Dpackaging=jar -Dfile=D:\代码\demo\out\artifacts\demo_jar\demo.jar

3.2 导入现有的 Spring Boot 工程

1、pom.xml

		<dependency>
            <groupId>com.wdzl.spring.boot</groupId>
            <artifactId>demo_starter</artifactId>
            <version>1.1.0</version>
        </dependency>

2、application.yml

zhao:
  prefix: 赵大帅哥
  suffix: 腰缠万贯
  enable: true

3、Controller

package com.wdzl.controller;


import com.wdzl.entity.Account;
import com.wdzl.service.Service;
import com.wdzl.service.impl.AccountServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

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

import java.util.List;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author 赵大帅哥
 * @since 2021-05-16
 */
@RestController
@RequestMapping("//account")
public class AccountController {


    @Autowired
    private Service service;

  

    @GetMapping("/test/{value}")
    public String list(@PathVariable("value") String value){

        return this.service.doService(value);
    }

}

4 Spring Boot整合持久层框架

ORM

MyBatis MyBatis Plus

JdbcTemplate Spring自带的一个JDBC封装框架，轻量级框架

Spring Data JPA底层就是Hibernate相当于Spring框架对Hibernate进行了封装，变得更加简单

Spring Data JPA

1、创建 Spring Boot 工程，引入 lombok、web、mysql Driver、Spring Data JPA

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

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
         </dependency>

		<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

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

2、创建实体类

package com.wdzl.entity;

import lombok.Data;

import javax.persistence.*;

@Data
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    @Column
    private Integer age;
    @Column
    private String name;
    @Column
    private String password;
}

3、创建UserRepository接口

package com.wdzl.dao;

import com.wdzl.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserDao extends JpaRepository<User,Integer> {
}

4、创建 UserController

package com.wdzl.controller;

import com.wdzl.dao.UserDao;
import com.wdzl.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
public class UserController {

    @Autowired
    private UserDao userDao;

    @GetMapping("/list")
    public List<User> findAll(){
        return this.userDao.findAll();
    }

    @GetMapping("/findById/{id}")
    public User findById(@PathVariable("id") Integer id){
        return this.userDao.findById(id).get();
    }

    @PostMapping("/save")
    public User save( User user){
        return this.userDao.save(user);
    }

    @PutMapping("/update")
    public User update(User user){
        return this.userDao.save(user);
    }

    @DeleteMapping("/delete/{id}")
    public void delete(@PathVariable("id")Integer id){
        this.userDao.deleteById(id);
    }
}

5、application.yml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 13992794421
  jpa:
    show-sql: true
    properties:
      hibernate:
        format_sql: true

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)