Spring IOC ：相关接口分析、手写简易 Spring IOC

转x33g5p2x  于2022-04-10 转载在 Spring  
字(16.2k)|赞(0)|评价(0)|浏览(310)

Spring IOC 相关接口分析

1.BeanFactory

Spring 中 Bean 的创建是典型的工厂模式，这一系列的 Bean 工厂，即 IOC 容器，为开发者管理对象之间的依赖关系提供了很多便利和基础服务，在 Spring 中有许多 IOC 容器的实现供用户选择，其相互关系如下图所示

其中，BeanFactory 作为最顶层的一个接口，定义了 IOC 容器的基本功能规范，BeanFactory 有三个重要的子接口：ListableBeanFactory、HierarchicalBeanFactory 和 AutowireCapableBeanFactory，但是从类图中可以发现最终的默认实现类是DefaultListableBeanFactory，它实现了所有的接口

每个接口都有它的使用场合，主要是为了区分在 Spring 内部操作过程中对象的传递和转化，对对象的数据访问所做的限制

  • ListableBeanFactory 接口表示这些Bean可列表化
  • HierarchicalBeanFactory 表示这些Bean 是有继承关系的，也就是每个 Bean 可能有父 Bean
  • AutowireCapableBeanFactory 接口定义 Bean 的自动装配规则

BeanFactory 源码

  1. public interface BeanFactory {
  3. 	String FACTORY_BEAN_PREFIX = "&";
  5. 	//根据bean的名称获取IOC容器中的的bean对象
  6. 	Object getBean(String name) throws BeansException;
  7. 	//根据bean的名称获取IOC容器中的的bean对象，并指定获取到的bean对象的类型，这样我们使用时就不需要进行类型强转了
  8. 	<T> T getBean(String name, Class<T> requiredType) throws BeansException;
  9. 	Object getBean(String name, Object... args) throws BeansException;
  10. 	<T> T getBean(Class<T> requiredType) throws BeansException;
  11. 	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
  12. 	
  13. 	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
  14. 	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
  16. 	//判断容器中是否包含指定名称的bean对象
  17. 	boolean containsBean(String name);
  18. 	//根据bean的名称判断是否是单例
  19. 	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
  20. 	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
  21. 	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
  22. 	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
  23. 	@Nullable
  24. 	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
  25. 	String[] getAliases(String name);
  26. }

在 BeanFactory 里只对 IOC 容器的基本行为做了定义，根本不关心 Bean 是如何定义及怎样加载的，也就是说只关心能从工厂里得到什么产品，不关心工厂是怎么生产这些产品的

BeanFactory 有一个很重要的子接口，就是 ApplicationContext 接口，该接口主要来规范容器中的 Bean 对象是非延时加载，即在创建容器对象的时候就对象 Bean 进行初始化，并存储到一个容器中

要知道工厂是如何产生对象的，需要看具体的 IOC 容器实现，Spring 提供了许多 IOC 容器实现，比如：

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

2.BeanDefinition

Spring IOC 容器管理我们定义的各种 Bean 对象及其相互关系，而 Bean 对象在 Spring 实现中是以 BeanDefinition 来描述的

3.BeanDefinitionReader

Bean 的解析过程非常复杂，功能被分得很细，因为这里需要被扩展的地方很多，必须保证足够的灵活性，以应对可能的变化。Bean 的解析主要就是对 Spring 配置文件的解析。这个解析过程主要通过 BeanDefinitionReader 来完成

BeanDefinitionReader源码

  1. public interface BeanDefinitionReader {
  3. 	//获取BeanDefinitionRegistry注册器对象
  4. 	BeanDefinitionRegistry getRegistry();
  6. 	@Nullable
  7. 	ResourceLoader getResourceLoader();
  9. 	@Nullable
  10. 	ClassLoader getBeanClassLoader();
  12. 	BeanNameGenerator getBeanNameGenerator();
  14. 	/*
  15. 		下面的loadBeanDefinitions都是加载bean定义，从指定的资源中
  16. 	*/
  17. 	int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;
  18. 	int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;
  19. 	int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;
  20. 	int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;
  21. }

4.BeanDefinitionRegistry

BeanDefinitionReader 用来解析 Bean 定义，并封装 BeanDefinition 对象，而配置文件中定义了很多 Bean 标签，所以就有一个问题，解析的 BeanDefinition 对象存储到哪儿？答案就是 BeanDefinition 的注册中心，而该注册中心顶层接口就是 BeanDefinitionRegistry

BeanDefinitionRegistry 源码

  1. public interface BeanDefinitionRegistry extends AliasRegistry {
  3. 	//往注册表中注册bean
  4. 	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
  5. 			throws BeanDefinitionStoreException;
  7. 	//从注册表中删除指定名称的bean
  8. 	void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
  10. 	//获取注册表中指定名称的bean
  11. 	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
  12.     
  13. 	//判断注册表中是否已经注册了指定名称的bean
  14. 	boolean containsBeanDefinition(String beanName);
  15.     
  16. 	//获取注册表中所有的bean的名称
  17. 	String[] getBeanDefinitionNames();
  18.     
  19. 	int getBeanDefinitionCount();
  20. 	boolean isBeanNameInUse(String beanName);
  21. }

5. 创建容器

ClassPathXmlApplicationContex t对 Bean 配置资源的载入是从 refresh() 方法开始的。refresh() 方法是一个模板方法，规定了 IOC 容器的启动流程，有些逻辑要交给其子类实现。它对 Bean 配置资源进行载入，ClassPathXmlApplicationContext 通过调用其父类 AbstractApplicationContext的refresh() 方法启动整个 IOC 容器对 Bean 定义的载入过程

自定义 Spring IOC

现要对下面的配置文件进行解析，并自定义 Spring 框架的 IOC 对涉及到的对象进行管理

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans>
  3.     <bean id="userService" class="com.henrik.service.impl.UserServiceImpl">
  4.         <property name="userDao" ref="userDao"></property>
  5.     </bean>
  6.     <bean id="userDao" class="com.henrik.dao.impl.UserDaoImpl"></bean>
  7. </beans>

1.定义 Bean 相关的 pojo 类

PropertyValue类

用于封装 Bean 的属性，就是封装 Bean 标签的子标签 property 标签数据

  1. package com.henrik.framework.beans;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. // 用于封装 Bean 标签下的 property 标签的属性
  8. @Data
  9. @AllArgsConstructor
  10. @NoArgsConstructor
  11. public class PropertyValue {
  13.     private String name;
  14.     private String value;
  15.     private String ref;
  17. }

MutablePropertyValues

一个bean标签可以有多个 property 子标签，所以再定义一个 MutablePropertyValues 类，用来存储并管理多个 PropertyValue 对象

  1. package com.henrik.framework.beans;
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5. import java.util.List;
  7. // 用来存储和管理多个 PropertyValue 对象
  8. // 使用迭代器模式
  9. public class MutablePropertyValues implements Iterable<PropertyValue>{
  11.     // 定义 list 集合对象，用于存储 PropertyValue 对象
  12.     private final List<PropertyValue> propertyValueList;
  14.     public MutablePropertyValues() {
  15.         propertyValueList = new ArrayList<PropertyValue>();
  16.     }
  18.     public MutablePropertyValues(List<PropertyValue> propertyValueList){
  19.         if(propertyValueList == null) {
  20.             this.propertyValueList = new ArrayList<PropertyValue>();
  21.         } else {
  22.             this.propertyValueList = propertyValueList;
  23.         }
  24.     }
  26.     // 获取所有的 PropertyValue 对象，返回以数组的形式
  27.     public PropertyValue[] getPropertyValues(){
  28.         // 将集合转化为数组并返回
  29.         return propertyValueList.toArray(new PropertyValue[0]);
  30.     }
  32.     // 根据 name 属性值获取 PropertyValue 对象
  33.     public PropertyValue getPropertyValue(String propertyName){
  34.         // 遍历集合对象
  35.         for (PropertyValue propertyValue : propertyValueList) {
  36.             if (propertyValue.getName().equals(propertyName)){
  37.                 return propertyValue;
  38.             }
  39.         }
  40.         return null;
  41.     }
  43.     // 判断集合是否为空
  44.     public boolean isEmpty(){
  45.         return propertyValueList.isEmpty();
  46.     }
  48.     // 添加 PropertyValue 对象
  49.     // 返回当前对象的目的是实现链式编程
  50.     public MutablePropertyValues addPropertyValue(PropertyValue pv){
  51.         // 判断集合中存储的 PropertyValue 对象是否和传递进来的重复
  52.         for (int i = 0; i < propertyValueList.size(); i++) {
  53.             // 获取集合中每一个 PropertyValue 对象
  54.             PropertyValue currentPv = propertyValueList.get(i);
  55.             if (currentPv.getName().equals(pv.getName())){
  56.                 propertyValueList.set(i, pv);
  57.                 return this;
  58.             }
  59.         }
  60.         this.propertyValueList.add(pv);
  61.         return this;
  62.     }
  64.     // 判断是否有指定 name 属性值的对象
  65.     public boolean contains(String propertyName){
  66.         return getPropertyValue(propertyName) != null;
  67.     }
  70.     // 获取迭代器对象
  71.     @Override
  72.     public Iterator<PropertyValue> iterator() {
  73.         return propertyValueList.iterator();
  74.     }
  75. }

BeanDefinition

BeanDefinition 类用来封装 Bean 信息的，主要包含 id（即 Bean 对象的名称）、class（需要交由 spring 管理的类的全类名）及子标签 property 数据

  1. package com.henrik.framework.beans;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  6. // 用来封装 Bean 信息的，主要包含 id（即Bean对象的名称）、class（需要交由 spring 管理的类的全类名）及子标签 property 数据
  7. @Data
  8. @AllArgsConstructor
  9. public class BeanDefinition {
  10.     private String id;
  11.     private String className;
  12.     private MutablePropertyValues propertyValues;
  13.     
  14.     public BeanDefinition(){
  15.         propertyValues = new MutablePropertyValues();
  16.     }
  17. }

2.定义注册表相关类

BeanDefinitionRegistry 接口

BeanDefinitionRegistry 接口定义了注册表的相关操作，定义如下功能：

  • 注册 BeanDefinition 对象到注册表中
  • 从注册表中删除指定名称的 BeanDefinition 对象
  • 根据名称从注册表中获取 BeanDefinition 对象
  • 判断注册表中是否包含指定名称的 BeanDefinition 对象
  • 获取注册表中 BeanDefinition 对象的个数
  • 获取注册表中所有的 BeanDefinition 的名称
  1. package com.henrik.framework.beans.factory.support;
  3. import com.henrik.framework.beans.BeanDefinition;
  5. // 注册表对象
  6. public interface BeanDefinitionRegistry {
  7.     //注册BeanDefinition对象到注册表中
  8.     void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);
  10.     //从注册表中删除指定名称的BeanDefinition对象
  11.     void removeBeanDefinition(String beanName) throws Exception;
  13.     //根据名称从注册表中获取BeanDefinition对象
  14.     BeanDefinition getBeanDefinition(String beanName) throws Exception;
  16.     boolean containsBeanDefinition(String beanName);
  18.     int getBeanDefinitionCount();
  20.     String[] getBeanDefinitionNames();
  21. }

SimpleBeanDefinitionRegistry 类

该类实现了BeanDefinitionRegistry接口，定义了Map集合作为注册表容器

  1. package com.henrik.framework.beans.factory.support;
  3. import com.henrik.framework.beans.BeanDefinition;
  5. import java.util.HashMap;
  6. import java.util.Map;
  8. public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry{
  9.     
  10.     // 定义一个容器，用来存储 BeanDefinition 对象
  11.     private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();
  12.     
  13.     @Override
  14.     public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
  15.         beanDefinitionMap.put(beanName, beanDefinition);
  16.     }
  18.     @Override
  19.     public void removeBeanDefinition(String beanName) throws Exception {
  20.         beanDefinitionMap.remove(beanName);
  21.     }
  23.     @Override
  24.     public BeanDefinition getBeanDefinition(String beanName) throws Exception {
  25.         return beanDefinitionMap.get(beanName);
  26.     }
  28.     @Override
  29.     public boolean containsBeanDefinition(String beanName) {
  30.         return beanDefinitionMap.containsKey(beanName);
  31.     }
  33.     @Override
  34.     public int getBeanDefinitionCount() {
  35.         return beanDefinitionMap.size();
  36.     }
  38.     @Override
  39.     public String[] getBeanDefinitionNames() {
  40.         return beanDefinitionMap.keySet().toArray(new String[0]);
  41.     }
  42. }

3.定义解析器相关类

BeanDefinitionReader 接口

BeanDefinitionReader 是用来解析配置文件并在注册表中注册 Bean 的信息。定义了两个规范：

  • 获取注册表的功能，让外界可以通过该对象获取注册表对象
  • 加载配置文件，并注册 Bean 数据
  1. package com.henrik.framework.beans.factory.support;
  3. // 用于解析配置文件，定义规范
  4. public interface BeanDefinitionReader {
  5.     //获取注册表对象
  6.     BeanDefinitionRegistry getRegistry();
  7.     //加载配置文件并在注册表中进行注册
  8.     void loadBeanDefinitions(String configLocation) throws Exception;
  9. }

XmlBeanDefinitionReader 类

XmlBeanDefinitionReader 类是专门用来解析 xml 配置文件的。该类实现 BeanDefinitionReader 接口并实现接口中的两个功能

  1. package com.henrik.framework.beans.factory.xml;
  3. import com.henrik.framework.beans.BeanDefinition;
  4. import com.henrik.framework.beans.MutablePropertyValues;
  5. import com.henrik.framework.beans.PropertyValue;
  6. import com.henrik.framework.beans.factory.support.BeanDefinitionReader;
  7. import com.henrik.framework.beans.factory.support.BeanDefinitionRegistry;
  8. import com.henrik.framework.beans.factory.support.SimpleBeanDefinitionRegistry;
  9. import org.dom4j.Document;
  10. import org.dom4j.Element;
  11. import org.dom4j.io.SAXReader;
  13. import java.io.InputStream;
  14. import java.util.List;
  16. public class XmlBeanDefinitionReader implements BeanDefinitionReader {
  18.     // 声明注册表对象
  19.     private BeanDefinitionRegistry registry;
  21.     public XmlBeanDefinitionReader(){
  22.         registry = new SimpleBeanDefinitionRegistry();
  23.     }
  25.     @Override
  26.     public BeanDefinitionRegistry getRegistry() {
  27.         return registry;
  28.     }
  30.     @Override
  31.     public void loadBeanDefinitions(String configLocation) throws Exception {
  32.         // 使用 dome4j 进行 xml 配置文件的解析
  33.         SAXReader reader = new SAXReader();
  34.         // 获取类路径下的配置文件
  35.         InputStream is = XmlBeanDefinitionReader.class.getClassLoader().getResourceAsStream(configLocation);
  36.         Document document = reader.read(is);
  37.         // 根据 Document 对象获取标签对象（Beans）
  38.         Element rootElement = document.getRootElement();
  39.         // 获取根标签下所有的 Bean 标签对象
  40.         List<Element> beanElements = rootElement.elements("bean");
  41.         // 遍历集合
  42.         for (Element beanElement : beanElements) {
  43.             // 获取 id 属性
  44.             String id = beanElement.attributeValue("id");
  45.             // 获取 class 属性
  46.             String className = beanElement.attributeValue("class");
  47.             // 封装到 BeanDefinition
  48.             BeanDefinition beanDefinition = new BeanDefinition();
  49.             beanDefinition.setId(id);
  50.             beanDefinition.setClassName(className);
  51.             
  52.             // 创建 mutablePropertyValues 对象
  53.             MutablePropertyValues mutablePropertyValues = new MutablePropertyValues();
  54.             
  55.             // 获取 property 标签
  56.             List<Element> propertyElements = beanElement.elements("property");
  57.             for (Element propertyElement : propertyElements) {
  58.                 String name = propertyElement.attributeValue("name");
  59.                 String value = propertyElement.attributeValue("value");
  60.                 String ref = propertyElement.attributeValue("ref");
  61.                 PropertyValue propertyValue = new PropertyValue(name,value,ref);
  62.                 mutablePropertyValues.addPropertyValue(propertyValue);
  63.             }
  65.             // 将 mutablePropertyValues 加入 beanDefinition
  66.             beanDefinition.setPropertyValues(mutablePropertyValues);
  67.             
  68.             registry.registerBeanDefinition(id,beanDefinition);
  69.         }
  70.     }
  71. }

4.IOC 容器相关类

BeanFactory 接口

在该接口中定义 IOC 容器的统一规范即获取 Bean 对象

  1. package com.henrik.framework.beans.factory;
  3. // IOC 容器父接口
  4. public interface BeanFactory {
  5.     
  6.     Object getBean(String name) throws Exception;
  7.     
  8.     <T> T getBean(String name, Class<? extends T> clazz) throws Exception;
  9. }

ApplicationContext 接口

该接口的所以的子实现类对bean对象的创建都是非延时的，所以在该接口中定义 refresh() 方法，该方法主要完成以下两个功能：

  • 加载配置文件
  • 根据注册表中的 BeanDefinition 对象封装的数据进行 Bean 对象的创建
  1. package com.henrik.framework.context;
  3. import com.henrik.framework.beans.factory.BeanFactory;
  5. // 定义非延时加载功能
  6. public interface ApplicationContext extends BeanFactory {
  7.     //进行配置文件加载并进行对象创建
  8.     void refresh() throws IllegalStateException, Exception;
  9. }

AbstractApplicationContext 类

  • 作为 ApplicationContext 接口的子类，所以该类也是非延时加载，所以需要在该类中定义一个 Map 集合，作为 Bean 对象存储的容器
  • 声明 BeanDefinitionReader 类型的变量，用来进行 xml 配置文件的解析，符合单一职责原则
  • BeanDefinitionReader 类型的对象创建交由子类实现，因为只有子类明确到底创建 BeanDefinitionReader 哪儿个子实现类对象
  1. package com.henrik.framework.context.support;
  3. import com.henrik.framework.beans.BeanDefinition;
  4. import com.henrik.framework.beans.factory.support.BeanDefinitionReader;
  5. import com.henrik.framework.beans.factory.support.BeanDefinitionRegistry;
  6. import com.henrik.framework.context.ApplicationContext;
  8. import java.util.HashMap;
  9. import java.util.Map;
  11. // ApplicationContext 接口的子实现类，用于立即加载
  12. public abstract class AbstractApplicationContext implements ApplicationContext {
  14.     // 声明解析器变量
  15.     protected BeanDefinitionReader beanDefinitionReader;
  17.     // 定义用于存储 Bean 对象的 map 容器
  18.     protected Map<String, Object> singletonObjects = new HashMap<>();
  20.     // 声明配置文件路径的变量
  21.     protected String configLocation;
  23.     @Override
  24.     public void refresh() throws IllegalStateException, Exception {
  25.         // 加载 BeanDefinition 对象
  26.         beanDefinitionReader.loadBeanDefinitions(configLocation);
  27.         // 初始化 Bean
  28.         finishBeanInitialization();
  29.     }
  31.     private void finishBeanInitialization() throws Exception {
  32.         // 获取注册表对象
  33.         BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
  35.         // 获取 BeanDefinition 对象
  36.         String[] beanNames = registry.getBeanDefinitionNames();
  38.         for (String beanName : beanNames) {
  39.             BeanDefinition beanDefinition = registry.getBeanDefinition(beanName);
  40.             getBean(beanName);
  41.         }
  42.     }
  44. }

tips：该类 finishBeanInitialization() 方法中调用 getBean() 方法使用到了模板方法模式

ClassPathXmlApplicationContext 类

该类主要是加载类路径下的配置文件，并进行 Bean 对象的创建，主要完成以下功能：

  • 在构造方法中，创建 BeanDefinitionReader 对象
  • 在构造方法中，调用 refresh() 方法，用于进行配置文件加载、创建 Bean 对象并存储到容器中
  • 重写父接口中的 getBean() 方法，并实现依赖注入操作
  1. package com.henrik.framework.context.support;
  3. import com.henrik.framework.beans.BeanDefinition;
  4. import com.henrik.framework.beans.MutablePropertyValues;
  5. import com.henrik.framework.beans.PropertyValue;
  6. import com.henrik.framework.beans.factory.support.BeanDefinitionRegistry;
  7. import com.henrik.framework.beans.factory.xml.XmlBeanDefinitionReader;
  8. import com.henrik.framework.utils.StringUtils;
  10. import java.lang.reflect.Method;
  12. // IOC 容器的具体实现子类，用于加载类路径下的 xml 格式的配置文件
  13. public class ClassPathXmlApplicationContext extends AbstractApplicationContext{
  15.     public ClassPathXmlApplicationContext(String configLocation){
  16.         this.configLocation = configLocation;
  17.         // 构建解析器对象
  18.         beanDefinitionReader = new XmlBeanDefinitionReader();
  19.         try {
  20.             this.refresh();
  21.         }catch (Exception e){
  23.         }
  24.     }
  26.     // 根据 Bean 对象的名称获取 Bean对象
  27.     @Override
  28.     public Object getBean(String name) throws Exception {
  29.         Object obj = singletonObjects.get(name);
  30.         if (obj != null) return obj;
  32.         BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
  33.         BeanDefinition beanDefinition = registry.getBeanDefinition(name);
  35.         String className = beanDefinition.getClassName();
  36.         Class<?> clazz = Class.forName(className);
  37.         Object beanObj = clazz.newInstance();
  38.         MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
  39.         for (PropertyValue propertyValue : propertyValues) {
  40.             String propertyName = propertyValue.getName();
  41.             String value = propertyValue.getValue();
  42.             String ref = propertyValue.getRef();
  44.             if(ref != null && !"".equals(ref)) {
  45.                 Object bean = getBean(ref);
  46.                 String methodName = StringUtils.getSetterMethodNameByFieldName(propertyName);
  47.                 Method[] methods = clazz.getMethods();
  48.                 for (Method method : methods) {
  49.                     if(method.getName().equals(methodName)) {
  50.                         // 执行该 set 方法
  51.                         method.invoke(beanObj,bean);
  52.                     }
  53.                 }
  54.             }
  56.             if(value != null && !"".equals(value)) {
  57.                 String methodName = StringUtils.getSetterMethodNameByFieldName(propertyName);
  58.                 Method method = clazz.getMethod(methodName, String.class);
  59.                 method.invoke(beanObj,value);
  60.             }
  61.         }
  62.         singletonObjects.put(name,beanObj);
  64.         return null;
  65.     }
  67.     @Override
  68.     public <T> T getBean(String name, Class<? extends T> clazz) throws Exception {
  69.         Object bean = getBean(name);
  70.         if(bean != null) {
  71.             return clazz.cast(bean);
  72.         }
  73.         return null;
  74.     }
  75. }

Test

  1. package com.henrik.controller;
  3. import com.henrik.framework.context.ApplicationContext;
  4. import com.henrik.framework.context.support.ClassPathXmlApplicationContext;
  5. import com.henrik.service.UserService;
  8. public class UserController {
  9.     public static void main(String[] args) throws Exception {
  10.         //1,创建spring的容器对象
  11.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  12.         //BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
  13.         //2,从容器对象中获取userService对象
  14.         UserService userService = applicationContext.getBean("userService", UserService.class);
  15.         //3,调用userService方法进行业务逻辑处理
  16.         userService.add();
  17.     }
  18. }

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/qq_50216270/article/details/124026758

内容来源于网络，如有侵权，请联系作者删除！

Javaspringspring ioc

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com