【Java设计模式】二十四、Spring重要接口回顾

左手的ㄟ右手 2024-04-23 15:47 1阅读 0赞

#### 文章目录 ####

*  1、Spring架构概述
 *  2、BeanFactory接口
 *  3、BeanDefinition
 *  4、BeanDefinitionReader
 *  5、BeanDefinitionRegistry
 *  6、创建容器

## 1、Spring架构概述 ##

Spring包含约20个模块，1300多个文件。主要架构：

![在这里插入图片描述][abdf566c65954af1a9a8dc72e54293cf.png]

Spring面向Bean编程，Bean即受Spring容器管控的对象，而核心容器则是由beans、core、context、express（Spring Expression Language，SpEL）4个模块组成。

1）spring-beans 和 spring-core是核心，包含了控制反转IoC和依赖注入DI。核心接口BeanFactory。

> BeanFactory属于延时加载，也就是说在实例化容器对象后并不会自动实例化Bean，只有当Bean被使用时，BeanFactory才会对该 Bean 进行实例化与依赖关系的装配。

2）spring-context模块，扩展了BeanFactory，其核心接口ApplicationContext就是BeanFactory的子接口。该模块添加了Bean的生命周期控制等

> 与BeanFactory不同，ApplicationContext实例化后会自动对所有的单实例Bean进行实例化与依赖关系的装配，使之处于待用状态。

最后，关于上面BeanFactory延时加载，而ApplicationContext非延时加载的Demo。先准备个测试Bean：

改下类的无参构造，让它在被调用时打印一句话，以便下面观察Bean何时被实例化的：

@Setter
    public class UserServiceImpl implements UserService {
        
    
    	private UserDao ueserDao;   //声明个UserDao类型的对象
    
    	public UserServiceImpl(){
        
    		System.out.println("userService被创建了");
    	}
    }

public class UserDaoImpl implements UserDao {
        
    	
    	public UserDaoImpl(){
        
    		System.out.println("UserDao被创建了");
    	}
    }

打断点：

//创建Spring容器对象
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicaitonContext.xml");
    //从容器中获取Bean
    UserService bean = applicationContext.getBean("userService", UserService.class);

![在这里插入图片描述][09a8d3f7a3a54ab491842e6afca004ef.png]  
同样的断点：

//创建Spring容器对象
    BeanFactory beanFacotry = new XmlBeanFactory(new ClassPathResource("applicaitonContext.xml"));
    //从容器中获取Bean
    UserService bean = beanFacotry.getBean("userService", UserService.class);

![在这里插入图片描述][250a95ea5c5640bab695b798d094c5e7.png]

## 2、BeanFactory接口 ##

Spring中Bean的创建是工厂模式的应用，确切的说是**简单工厂 + 配置文件的形式**。  
![在这里插入图片描述][c300d28b595a4d37a69850b8958fb0ff.png]

> **这一系列的Bean工厂，即IoC容器**，帮助开发者创建和管理对象及对象间的依赖关系。BeanFactory作为最顶层的一个接口，**定义了IoC容器的基本功能规范。**

BeanFactory的源码：

public interface BeanFactory {
        
    
    	String FACTORY_BEAN_PREFIX = "&";
    
    	//根据bean的名称获取IOC容器中的的bean对象
    	Object getBean(String name) throws BeansException;
    	//根据bean的名称获取IOC容器中的的bean对象，并指定获取到的bean对象的类型，这样我们使用时就不需要进行类型强转了
    	<T> T getBean(String name, Class<T> requiredType) throws BeansException;
    	Object getBean(String name, Object... args) throws BeansException;
    	<T> T getBean(Class<T> requiredType) throws BeansException;
    	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
    	
    	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
    	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
    
    	//判断容器中是否包含指定名称的bean对象
    	boolean containsBean(String name);
    	//根据bean的名称判断是否是单例
    	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
    	@Nullable
    	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    	String[] getAliases(String name);
    }

BeanFactory接口有个重要的子接口ApplicationContext，它规范了其子类IoC容器中的bean对象是非延时加载，即在创建容器对象的时候就对象bean进行初始化，并存储到一个容器中。

![在这里插入图片描述][f3a41b0bfaec458196e438f86b88237f.png]

如上，不同的子类，即不同的IoC容器，它们生产对象的方式也是不同的：

*  `ClasspathXmlApplicationContext` : 根据类路径加载xml配置文件，并创建IOC容器对象。
 *  `FileSystemXmlApplicationContext` ：根据系统路径加载xml配置文件，并创建IOC容器对象。
 *  `AnnotationConfigApplicationContext` ：加载注解类配置，并创建IOC容器。

![在这里插入图片描述][e5684f0ed22848279138cc3ee3e87a4e.png]

## 3、BeanDefinition ##

开发者在xml中描述自己的Bean，而定义的Bean的那些属性，在Spring中用BeanDefinition来描述。

![在这里插入图片描述][39f968717cf54910b3f5bb77b6cda778.png]

BeanDefinition对xml中的Bean相关的属性进行封装，那这个xml配置文件由谁解析呢 ⇒ BeanDefinitionReader

## 4、BeanDefinitionReader ##

Bean的解析主要就是对Spring配置文件的解析。这个解析过程主要通过BeanDefinitionReader来完成。

![在这里插入图片描述][48a9925c52b04cbebe50e080e1187fd3.png]

BeanDefinitionReader接口定义了解析的规范，其不同的子实现类，则用于解析不同的配置文件，如xml、Properties

public interface BeanDefinitionReader {
        
    
    	//获取BeanDefinitionRegistry注册器对象
    	BeanDefinitionRegistry getRegistry();
    
    	/*
    		下面的loadBeanDefinitions都是加载bean定义，从指定的资源中
    	*/
    	int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;
    	int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;
    	int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;
    	int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;
    }

## 5、BeanDefinitionRegistry ##

**BeanDefinitionReader用来解析bean的定义，然后封装到BeanDefinition对象。而封装的BeanDefinition对象，则存储到了BeanDefinition的注册中心，该注册中心的顶层接口就是BeanDefinitionRegistry**

public interface BeanDefinitionRegistry extends AliasRegistry {
        
    
    	//往注册表中注册bean
    	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
    			throws BeanDefinitionStoreException;
    
    	//从注册表中删除指定名称的bean
    	void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    
    	//获取注册表中指定名称的bean
    	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
        
    	//判断注册表中是否已经注册了指定名称的bean
    	boolean containsBeanDefinition(String beanName);
        
    	//获取注册表中所有的bean的名称，返回一个数组
    	String[] getBeanDefinitionNames();
        
        //获取注册表中BeanDefiniton的数量
    	int getBeanDefinitionCount();
    	
    	//判断bean的名字在注册表中是否已被使用
    	boolean isBeanNameInUse(String beanName);
    }

Ctrl+H看继承体系：

![在这里插入图片描述][0e0e2e762c48409ba1e572e81ac7446d.png]

看其子类的源码，里面定义了Map，key为String，value为BeanDefinition。

![在这里插入图片描述][01752a4b13e54822b3aa0ab92583b07a.png]

## 6、创建容器 ##

以ClassPathXmlApplicationContext这个Ioc类为例，创建它的对象（IoC容器对象）是传入了xml的文件名，找到源码中的相关构造方法，this调用了另一个构造方法，继续跟进：

![在这里插入图片描述][5b4072afbb264a52b65d2a7dc1f9a964.png]

看到调用了refresh方法：

![在这里插入图片描述][c5f4f8ea3a784811aafba813219f3bf2.png]  
跟进refresh方法，发现到了父类的refresh方法。refresh方法是一个**模板方法**，该方法定义好了 IoC 容器的启动流程（加载配置文件、初始化Bean对象、将Bean对象存储到容器中等等），有些逻辑要交给其子类实现。它对 Bean 配置资源进行载入，ClassPathXmlApplicationContext通过调用其父类AbstractApplicationContext的refresh方法启动整个IoC容器对Bean定义的载入过程。

[abdf566c65954af1a9a8dc72e54293cf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/15769799b5274fde9cceb4998bf82b8b.png
[09a8d3f7a3a54ab491842e6afca004ef.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/6baa60ae32fd44c491b397d01a70d031.png
[250a95ea5c5640bab695b798d094c5e7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/792cc215ab8c478a854dc761958e68de.png
[c300d28b595a4d37a69850b8958fb0ff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/b09bad54ee694271bb623e66d1785e3d.png
[f3a41b0bfaec458196e438f86b88237f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/570d4412efea4640a4efc4aabb40dad6.png
[e5684f0ed22848279138cc3ee3e87a4e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/00fbea3e225c49a491b1eb591cbec54a.png
[39f968717cf54910b3f5bb77b6cda778.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/64a37c98908b40de88c9a206fafc2a1b.png
[48a9925c52b04cbebe50e080e1187fd3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/abcd63ef56934c6f95a834197abc713b.png
[0e0e2e762c48409ba1e572e81ac7446d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/8783dc1f7de6425584f2e117b3ec66da.png
[01752a4b13e54822b3aa0ab92583b07a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/63d913b207334edeab3946642a44a50d.png
[5b4072afbb264a52b65d2a7dc1f9a964.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/faa02f77c2c94cbb8505496fe44f846a.png
[c5f4f8ea3a784811aafba813219f3bf2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/8b06dc361c5e44df8061272180ccfc9d.png