Spring 原理

Spring 原理

Bean作用域

概念

1.通过 @Controller ,@Service ,@Repository ,@Component,@Configuration ,@Bean 来声明Bean对象

2.通过ApplicationContext 或者BeanFactory 来获取对象

3.通过@Autowired,Setter方法或构造方法来注入对应Bean对象

java 复制代码
@Getter @Setter
public class Dog {
    private String name;
}
java 复制代码
@Configuration
public class DogBeanConfig {
    @Bean
    public Dog dog(){
       return new Dog();
    }
}
java 复制代码
@RestController
@RequestMapping("/dog")
public class DogController {

    @Autowired
    private ApplicationContext context;
    @Resource(name = "dog")
    private Dog dog;
    @GetMapping("/single")
    public String single(){
        Dog contextDog = (Dog)context.getBean("dog");
        return "dog:"+ dog+ ",context获取的Dog:"+ contextDog;
    }
    
}

这里访问接口,可以发现两个获取是同一个对象,并且这里刷新,其也不会改变

Bean作用域

其默认singleton每个Spring IoC容器内同名称的bean只有⼀个实例

每次获取都是同一个对象

这个对象可以设置为非单例,也就是改变Bean的作用域

作用域 说明
singleton 单例作⽤域: 每个Spring IoC容器内同名称的bean只有⼀个实例
prototype 原型作⽤域:每次使用该Bean都会创建一个新实例
request 请求作⽤域:每个请求中,创建一个新的实例
session 会话作⽤域:每个会话中,创建一个新实例
Application 全局作⽤域:每个ServletContext,创建一个新实例
websocket HTTP WebSocket 作⽤域:每个WebSocket⽣命周期内创建新实例

Spring有6种作用域,后4种在Spring MVC环境生效

java 复制代码
@Getter @Setter
public class Dog {
    private String name;
}
java 复制代码
@Configuration
public class DogBeanConfig {
    @Bean
    //默认是这个
    @Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
    public Dog dog(){
       return new Dog();
    }

    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public Dog prototypeDog(){
        return new Dog();
    }

    @Bean
    //@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
    @RequestScope
    public Dog requestDog(){
        return new Dog();
    }

    @Bean
//    @Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS)
    @SessionScope
    public Dog sessionDog(){
        return new Dog();
    }

    @Bean
//    @Scope(value = WebApplicationContext.SCOPE_APPLICATION, proxyMode = ScopedProxyMode.TARGET_CLASS)
    @ApplicationScope
    public Dog applicationDog(){
        return new Dog();
    }
}

这里@RequestScope、@SessionScope、@ApplicationScope

@RequestScope等价于

@Scope(value = WebApplicationContext.SCOPE_APPLICATION, proxyMode = ScopedProxyMode.TARGET_CLASS)

剩下同理

java 复制代码
@RestController
@RequestMapping("/dog")
public class DogController {

    @Autowired
    private ApplicationContext context;
    @Resource(name = "dog")
    private Dog dog;

    @Resource(name = "prototypeDog")
    private Dog prototypeDog;

    @Resource(name = "requestDog")
    private Dog requestDog;

    @Resource(name = "sessionDog")
    private Dog sessionDog;

    @Resource(name = "applicationDog")
    private Dog applicationDog;

    @GetMapping("/single")
    public String single(){
        Dog contextDog = (Dog)context.getBean("dog");
        return "dog:"+ dog+ ",context获取的Dog:"+ contextDog;
    }
    @GetMapping("/prototype")
    public String prototype(){
        Dog contextDog = (Dog)context.getBean("prototypeDog");
        return "dog:"+ prototypeDog+ ",context获取的Dog:"+ contextDog;
    }
    @GetMapping("/request")
    public String request(){
        Dog contextDog = (Dog)context.getBean("requestDog");
        return "dog:"+ requestDog+ ",context获取的Dog:"+ contextDog;
    }
    @GetMapping("/session")
    public String session(){
        Dog contextDog = (Dog)context.getBean("sessionDog");
        return "dog:"+ sessionDog+ ",context获取的Dog:"+ contextDog;
    }
    @GetMapping("/application")
    public String application(){
        Dog contextDog = (Dog)context.getBean("applicationDog");
        return "dog:"+ applicationDog+ ",context获取的Dog:"+ contextDog;
    }

}

单例作用域 :http://127.0.0.1:8080/dog/single

多次访问都是同一个对象,@Autowired 和applicationContext.getBean()也是同一个对象

多例作⽤域 :http://127.0.0.1:8080/dog/prototype

context:每次获取新的实例,调用ApplicationContext.getBean() / 进行注入都会创建一个新的对象

请求作⽤域 : http://127.0.0.1:8080/dog/request

每次请求,@Autowired 和applicationContext.getBean()获取的是同一个对象,每次请求对象都会更新

会话作⽤域 :http://127.0.0.1:8080/dog/session

在同一个会话中,获取对象都是同一个

但是切换浏览器,也就切换了不同session,对象和上面浏览器访问的不一样

全局作用域 :http://127.0.0.1:8080/dog/application

一个应用中,多次访问都是同一个对象,一个ServletContext中

Application scope就是对于整个web容器来说,bean的作⽤域是ServletContext级别的,

Application scope是ServletContext的单例

singleton是ApplicationContext的单例

Bean的生命周期

1.实例化(为Bean分配好内存空间)

2.属性赋值(Bean的注入,如@Autowired)

3.初始化

执⾏各种通知 ,如BeanNameAware ,BeanFactoryAware ,

ApplicationContextAware 的接⼝⽅法

执⾏初始化⽅法

xml定义 init-method

使⽤注解的⽅式 @PostConstruct

执⾏初始化后置⽅法( BeanPostProcessor )

4.使用Bean

5.销毁Bean

销毁容器的各种⽅法, 如@PreDestroy ,DisposableBean 接⼝⽅法,destroy - method

java 复制代码
@Component
public class UserComponent {
}

@PostConstruct:在 Bean 初始化完成后立即执行的方法注解

@PreDestroy:在 Bean 销毁前执行的方法注解

java 复制代码
@Component
public class BeanLifeComponent implements BeanNameAware {

    private UserComponent userComponent;

    public BeanLifeComponent(){
        System.out.println("执行构造方法");
    }


    //set方法注入
    @Autowired
    public void setUserComponent(){
        this.userComponent = userComponent;
        System.out.println("setter注入方法");
    }
    
    @PostConstruct
    public void init(){
        System.out.println("执行初始化方法");
    }

    public void use(){
        System.out.println("执行use 方法");
    }

    @PreDestroy
    public void destory(){
        System.out.println("执行destory方法");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("setBeanName:" + name);
    }
}

测试

java 复制代码
@SpringBootTest
class SpringdemoApplicationTests {

	@Autowired
	private ApplicationContext context;
	@Test
	void contextLoads() {
		BeanLifeComponent beanLifeComponent = context.getBean(BeanLifeComponent.class);
		beanLifeComponent.use();
	}
}

Spring Boot自动配置

Spring Boot自动配置就是Spring容器启动后,一些配置类,bean对象自动存入到IoC容器中,不需要手动去生命,从而简化了开发

那它是如何将依赖jar包的配置类和Bean加载到Spring IoC容器中呢?

例如:此时config不在Spring启动类对应目录下,那如果使用其TestConfig类会发生什么呢?

java 复制代码
@Component
public class TestConfig {
    public void use(){
        System.out.println("start use");
    }
}
java 复制代码
@SpringBootApplication
public class SpringdemoApplication {

	public static void main(String[] args) {
		ApplicationContext context = SpringApplication.run(SpringdemoApplication.class, args);

		TestConfig bean = context.getBean(TestConfig.class);
		bean.use();

	}
}

这里就会出现找不到这里TestConfig的异常

SpringdemoApplication项目启动类在com.example.springdemo

而TestConfig类在com.example.config

@Bean注解可以帮对象放到Spring IoC容器中,前提是这些注解需要和SpringBoot启动类在同一个目录下 ,然而此时这里的类不在其扫描范围内

因此这里出现了找不到这个类型的异常

解决问题

@ComponentScan 组件扫描

@Import 导⼊(使⽤@Import导⼊的类会被Spring加载到IoC容器中)
@ComponentScan 组件扫描

java 复制代码
@ComponentScan("com.example.config")
@SpringBootApplication
public class SpringdemoApplication {

	public static void main(String[] args) {
		ApplicationContext context = SpringApplication.run(SpringdemoApplication.class, args);

		TestConfig bean = context.getBean(TestConfig.class);
		bean.use();
	}
}

@Import 导⼊

1.导入类

2.导⼊ ImportSelector 接⼝实现类

java 复制代码
//导入类
@Import(TestConfig.class)
@SpringBootApplication
public class SpringdemoApplication {

	public static void main(String[] args) {
		ApplicationContext context = SpringApplication.run(SpringdemoApplication.class, args);

		TestConfig bean = context.getBean(TestConfig.class);
		bean.use();

	}
}

导入实现ImportSelector 的类

类中将需要导入的类的全限定类名放进去

java 复制代码
public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        //需要导入对应全限定类名
        return new String[]{
                "com.example.config.TestConfig"
        };
    }
}
java 复制代码
//导入实现ImportSelector 的类
@Import(MyImportSelector.class)
@SpringBootApplication
public class SpringdemoApplication {

	public static void main(String[] args) {
		ApplicationContext context = SpringApplication.run(SpringdemoApplication.class, args);

		TestConfig bean = context.getBean(TestConfig.class);
		bean.use();

	}
}

上面这样导入方式,都要先确定需要导入那些类或者Bean对象

Spring使用都是注解形式,可以将上面第三方依赖实现一个注解来使用

@EnableXxxx开头的注解

封装 @Import 注解,导⼊MyImportSelector.class

java 复制代码
@Import(MyImportSelector.class)//实现ImportSelector 的类
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface EnableTestConfig {
}
java 复制代码
@EnableTestConfig
@SpringBootApplication
public class SpringdemoApplication {

	public static void main(String[] args) {
		ApplicationContext context = SpringApplication.run(SpringdemoApplication.class, args);

		TestConfig bean = context.getBean(TestConfig.class);
		bean.use();

	}
}

@SpringBootApplication

启动类注解

java 复制代码
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {

1.元注解

@Target:描述注解的使⽤范围(即被修饰的注解可以⽤在什么地⽅)

@Retention描述注解保留的时间范围

@Documented 描述在使⽤javadoc⼯具为类⽣成帮助⽂档时是否要保留其注解信息

@Inherited使被它修饰的注解具有继承性(如果某个类使⽤了被@Inherited修饰的注解,则其⼦类将⾃动具有该注解)

  1. @SpringBootConfiguration

这里其实就是@Configuration一个封装,标志着这个类是配置类

@Indexed注解,是⽤来加速应⽤启动的

java 复制代码
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

3.@ComponentScan

包扫描扫描当前包及其子包下的组件:

@Component

@Service

@Repository

@Controller

@RestController

可以用basePackageClasses 或 basePackages来定义扫描特定包

TypeExcludeFilter

允许通过自定义逻辑排除某些 Bean

AutoConfigurationExcludeFilter

防止自动配置类被当成普通组件扫描加载

自动配置类应该由 @EnableAutoConfiguration管理,而不是@ComponentScan

4.@EnableAutoConfiguration

@AutoConfigurationPackage :把启动类所在的包下⾯所有的组件都注⼊到Spring容器中,获取主启动类所在包,把这个包注册成一个 Bean

里面的@Import(AutoConfigurationImportSelector.class)是心啊了一些接口,里面的selectImports()方法底层调用了getAutoConfigurationEntry()可以自动装配

getAutoConfigurationEntry() ⽅法通过调⽤

getCandidateConfigurations(annotationMetadata, attributes) ⽅法获取在配置⽂件中配置的所有⾃动配置类的集合

获取所有基于 METAINF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports⽂件,META-INF/spring.factories ⽂件中配置类的集合

在加载⾃动配置类的时候,并不是将所有的配置全部加载进来,⽽是通过@Conditional等注解的判断进⾏动态加载,有些类要在满足一定条件才会生效

在启动的时候获取所有基于 METAINF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports⽂件进行加载,是获取所有这样的,因此也可以将需要加载的类放到这里

java 复制代码
com.example.config.TestConfig
相关推荐
企业数字化笔记33 分钟前
报表上线怎么对账?口径回归、权限抽检与差异定位
java·spring boot·mysql
乌暮38 分钟前
少写重复 CRUD:用大白话搞懂 MyBatis-Plus
java·开发语言·spring boot·面试·mybatis
CoderYanger1 小时前
Java EE 进阶:9.MyBatis 操作数据库(进阶)(第四弹):图书管理系统(用户登录+添加图书)
java·数据库·spring boot·mysql·面试·java-ee·mybatis
goyeer1 小时前
【Kubernetes】Kubernetes之CRI详解
java·容器·kubernetes
牧瀬クリスだ1 小时前
从零手写博客系统:分层架构与统一响应(一)
java·数据库·架构·mybatis·springboot·安全架构
Rain的Java大神之路2 小时前
LeetCode 40 组合总和 II:面试官想听的不是回溯,而是那行去重代码
java·leetcode·面试
wno7043 小时前
Centos下PostgreSQL安装部署详细步骤
java·数据库·spring boot
nice_lcj5203 小时前
【从零理解计算机网络 · 04】TCP 三次握手:为什么恰好是三次
java·后端·tcp/ip·计算机网络·面试·tcp·三次握手
杨凯凡4 小时前
Spring AI MCP 多租户安全实战:共享 Session 会串数据吗?工具权限与隔离边界
人工智能·安全·spring