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修饰的注解,则其⼦类将⾃动具有该注解)
- @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