• Spring IOC

    IOC是什么

    •  IOC:控制反转，是一种设计模式。
    • 一层含义是控制权的转移，由传统的在程序中控制依赖转移到由容器来控制。
    • 第二层是依赖注入：将相互依赖的对象分离，在Spring配置文件中描述他们的依赖关系，他们的依赖关系只在使用的时候才建立，简单来说就是不需要的NEW一个对象了。

    BeanFactory

    BeanFactory，以Factory结尾，表示它是一个工厂类(接口)， 它负责生产和管理bean的一个工厂。在Spring中，BeanFactory是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。

    BeanFactory只是个接口，并不是IOC容器的具体实现，但是Spring容器给出了很多种实现，如 DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等，其中XmlBeanFactory就是常用的一个，该实现将以XML方式描述组成应用的对象及对象间的依赖关系。XmlBeanFactory类将持有此XML配置元数据，并用它来构建一个完全可配置的系统或应用。

     原始的BeanFactory无法支持spring的许多插件，如AOP功能、Web应用等。ApplicationContext接口,它由BeanFactory接口派生而来。现在一般使用ApplicationnContext，其不但包含了BeanFactory的作用，同时还进行更多的扩展

    Note:BeanFactory和ApplicationContext创建Bean的区别

    BeanFactory延时加载，在使用到某个Bean时才会进行实例化Bean
    ApplicationConetxt在ApplicationContext对象创建时，会立即实例化单例Bean以及其依赖

     

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    5.        http://www.springframework.org/schema/beans/spring-beans.xsd">
    6.  
    7.     <bean id="userDao" class="com.lb.springioc.dao.UserDaoImpl">bean>
    8.  
    9.     <bean id="userService" class="com.lb.springioc.service.UserServiceImpl">
    10.         <property name="userDao" ref="userDao">property>
    11.     bean>
    12. beans>

    Bean加载原理

    Bean实例化
    BeanDefinition对应配置文件中的标签
    BeanDefinitionReader读取配置文件所有的BeanDefinition
    BeanDefinitionRegistry将Reader读取到的BeanDefinition放在容器中

     BeanDefinition

    BeanDefinitionHolder就是持有对bean标签读取到的信息的对象

     BeanDefinitionReader

     BeanDefinitionRegistry

    自实现的IOC

    依赖

    1.         <dependency>
    2.             <groupId>org.projectlombokgroupId>
    3.             <artifactId>lombokartifactId>
    4.             <version>1.16.10version>
    5.         dependency>
    6.  
    7.         <dependency>
    8.             <groupId>dom4jgroupId>
    9.             <artifactId>dom4jartifactId>
    10.             <version>1.6.1version>
    11.         dependency>

    实体类

    1. @Data
    2. public class BeanDefinition {
    3.     private String id;
    4.     private String className;
    5.     private PropertyValues propertyValues;
    6.  
    7.     public BeanDefinition() {
    8.         propertyValues = new PropertyValues();
    9.     }
    10. }
    11. @Data
    12. @AllArgsConstructor
    13. @NoArgsConstructor
    14. public class PropertyValue {
    15.     private String name;
    16.     private String ref;
    17.     private String value;
    18. }
    19. public class PropertyValues implements Iterable {
    20.     private List list;
    21.  
    22.     public PropertyValues() {
    23.         list = new ArrayList<>();
    24.     }
    25.  
    26.     public PropertyValues add(PropertyValue propertyValue) {
    27.         for (int i = 0; i < list.size(); i++) {
    28.             PropertyValue value = list.get(i);
    29.             if (value.getName().equals(propertyValue.getName())) {
    30.                 list.set(i, propertyValue);
    31.                 return this;
    32.             }
    33.         }
    34.         list.add(propertyValue);
    35.         return this;
    36.     }
    37.  
    38.     public PropertyValue[] getPropertyValues() {
    39.         return list.toArray(new PropertyValue[0]);
    40.     }
    41.  
    42.     public PropertyValue geTPropertyValue(String name) {
    43.         for (int i = 0; i < list.size(); i++) {
    44.             PropertyValue value = list.get(i);
    45.             if (value.getName().equals(name)) {
    46.                 return value;
    47.             }
    48.         }
    49.         return null;
    50.     }
    51.  
    52.     public boolean isEmpty() {
    53.         return list.isEmpty();
    54.     }
    55.  
    56.     @Override
    57.     public Iterator iterator() {
    58.         return list.iterator();
    59.     }
    60. }

    Reader & Registry

    1. public interface BeanDefinitionReader {
    2.     BeanDefinitionRegistry getRegistry();
    3.  
    4.     void loadResource(String location) throws Exception;
    5. }
    6. public class XmlBeanDefinitionReader implements BeanDefinitionReader {
    7.  
    8.     private BeanDefinitionRegistry registry;
    9.  
    10.     public XmlBeanDefinitionReader() {
    11.         registry = new SimpleBeanDefinitionRegistry();
    12.     }
    13.  
    14.     @Override
    15.     public BeanDefinitionRegistry getRegistry() {
    16.         return registry;
    17.     }
    18.  
    19.     @Override
    20.     public void loadResource(String location) throws Exception {
    21.         SAXReader reader = new SAXReader();
    22.         InputStream inputStream = XmlBeanDefinitionReader.class.getClassLoader().getResourceAsStream(location);
    23.         Document document = reader.read(inputStream);
    24.         Element rootElement = document.getRootElement();
    25.         List beans = rootElement.elements("bean");
    26.  
    27.         for (Element bean : beans) {
    28.             BeanDefinition beanDefinition = new BeanDefinition();
    29.             String id = bean.attributeValue("id");
    30.             beanDefinition.setId(id);
    31.             beanDefinition.setClassName(bean.attributeValue("class"));
    32.             PropertyValues values = new PropertyValues();
    33.             List properties = bean.elements("property");
    34.             for (Element property : properties) {
    35.                 PropertyValue value = new PropertyValue();
    36.                 value.setName(property.attributeValue("name"));
    37.                 value.setRef(property.attributeValue("ref"));
    38.                 value.setValue(property.attributeValue("value"));
    39.                 values.add(value);
    40.             }
    41.             beanDefinition.setPropertyValues(values);
    42.             registry.registerBeanDefinition(id, beanDefinition);
    43.         }
    44.     }
    45. }
    1. public interface BeanDefinitionRegistry {
    2.     void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);
    3.  
    4.     void removeBeanDefinition(String beanName) throws Exception;
    5.  
    6.     BeanDefinition getBeanDefinition(String beanName);
    7.  
    8.     boolean containsBeanDefinition(String beanName);
    9.  
    10.     String[] getBeanDefinitionNames();
    11.  
    12.     int getBeanDefinitionCount();
    13. }
    14.  
    15. public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry {
    16.     private Map map = new HashMap();
    17.  
    18.  
    19.     @Override
    20.     public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
    21.         map.put(beanName, beanDefinition);
    22.     }
    23.  
    24.     @Override
    25.     public void removeBeanDefinition(String beanName) throws Exception {
    26.         map.remove(beanName);
    27.     }
    28.  
    29.     @Override
    30.     public BeanDefinition getBeanDefinition(String beanName) {
    31.         return map.get(beanName);
    32.     }
    33.  
    34.     @Override
    35.     public boolean containsBeanDefinition(String beanName) {
    36.         return map.containsKey(beanName);
    37.     }
    38.  
    39.     @Override
    40.     public String[] getBeanDefinitionNames() {
    41.         return map.keySet().toArray(new String[0]);
    42.     }
    43.  
    44.     @Override
    45.     public int getBeanDefinitionCount() {
    46.         return map.size();
    47.     }
    48. }

    BeanFacoty & ApplicationContext

    1. /**
    2.  * 提供BeanFactory的主要功能获取Bean
    3.  */
    4. public interface BeanFactory {
    5.  
    6.     Object getBean(String beanName) throws Exception;
    7.  
    8.      T getBean(String beanName, Class clazz) throws Exception;
    9. }
    10.  
    11. /**
    12.  * 所有的子类对bean的创建都是非延时的
    13.  */
    14. public interface ApplicationContext extends BeanFactory {
    15.     /**
    16.      * 加载配置文件，并创建对象
    17.      * @throws Exception
    18.      */
    19.     void refresh() throws Exception;
    20. }
    21.  
    22. public abstract class AbstractApplicationContext implements ApplicationContext {
    23.     protected Map singletonMaps = new HashMap<>();
    24.  
    25.     protected BeanDefinitionReader beanDefinitionReader;
    26.  
    27.     protected String configLocation;
    28.  
    29.     @Override
    30.     public void refresh() throws Exception {
    31.         beanDefinitionReader.loadResource(configLocation);
    32.  
    33.         //初始化所有的bean
    34.         initializationBean();
    35.     }
    36.  
    37.     private void initializationBean() throws Exception {
    38.         BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
    39.         String[] beanDefinitionNames = registry.getBeanDefinitionNames();
    40.         for (String beanDefinitionName : beanDefinitionNames) {
    41.             BeanDefinition beanDefinition = registry.getBeanDefinition(beanDefinitionName);
    42.             getBean(beanDefinition.getId());
    43.         }
    44.     }
    45. }
    46.  
    47. public class ClassPathXmlApplicationContext extends AbstractApplicationContext {
    48.  
    49.     public ClassPathXmlApplicationContext(String location) {
    50.         this.configLocation = location;
    51.         this.beanDefinitionReader = new XmlBeanDefinitionReader();
    52.  
    53.         try {
    54.             refresh();
    55.         } catch (Exception e) {
    56.  
    57.         }
    58.     }
    59.  
    60.     @Override
    61.     public Object getBean(String beanName) throws Exception {
    62.         Object obj = singletonMaps.get(beanName);
    63.         if (obj != null) {
    64.             return obj;
    65.         }
    66.         BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
    67.         BeanDefinition beanDefinition = registry.getBeanDefinition(beanName);
    68.         String clazzName = beanDefinition.getClassName();
    69.         Class clazz = Class.forName(clazzName);
    70.         Object bean = clazz.newInstance();
    71.  
    72.         PropertyValues propertyValues = beanDefinition.getPropertyValues();
    73.         for (PropertyValue propertyValue : propertyValues) {
    74.             //拼接set方法
    75.             String name = propertyValue.getName();
    76.             String setMethodName = StrUtil.filedName2SetMethodName(name);
    77.             Method[] methods = clazz.getMethods();
    78.             Method method = null;
    79.             for (Method m : methods){
    80.                 if (m.getName().equals(setMethodName)){
    81.                     method = m;
    82.                     break;
    83.                 }
    84.             }
    85.             //反射创建对象
    86.             String refStr = propertyValue.getRef();
    87.             if (null != refStr && !"".equals(refStr)) {
    88.                 Object refObj = getBean(refStr);
    89.                 method.invoke(bean, refObj);
    90.             }
    91.             //value是赋值的
    92.             String value = propertyValue.getValue();
    93.             if (null != value && !"".equals(value)) {
    94.                 method.invoke(bean, value);
    95.             }
    96.         }
    97.         singletonMaps.put(beanName, bean);
    98.         return bean;
    99.     }
    100.  
    101.     @Override
    102.     public  T getBean(String beanName, Class clazz) throws Exception {
    103.         Object obj = getBean(beanName);
    104.         if (obj == null) return null;
    105.         return clazz.cast(obj);
    106.     }
    107. }

    测试

    将上面的项目打包，测试项目引入其依赖

    1.         <dependency>
    2.             <groupId>com.testgroupId>
    3.             <artifactId>mySpringartifactId>
    4.             <version>0.0.1-SNAPSHOTversion>
    5.         dependency>

    测试代码:

    applicationContext.xml

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    5.        http://www.springframework.org/schema/beans/spring-beans.xsd">
    6.  
    7.     <bean id="userDao" class="springioc.dao.UserDaoImpl">bean>
    8.  
    9.     <bean id="userService" class="springioc.service.UserServiceImpl">
    10.         <property name="userDao" ref="userDao">property>
    11.     bean>
    12. beans>
    1. import com.lb.context.ClassPathXmlApplicationContext;
    2. import springioc.dao.UserDao;
    3. import springioc.service.UserService;
    4.  
    5. public class UserController {
    6.     public static void main(String[] args) throws Exception{
    7.         ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    8.         UserDao userDao = classPathXmlApplicationContext.getBean("userDao", UserDao.class);
    9.         UserService userService = classPathXmlApplicationContext.getBean("userService", UserService.class);
    10.         System.out.println(userDao);
    11.         System.out.println(userService);
    12.  
    13.         userService.add();
    14.     }
    15. }

    测试结果:

     

  • 相关阅读:
    2021年中国大学生程序设计竞赛女生专场-ADGIK
    〖Docker指南⑤〗学习Dockerfile，看这一篇就够了
    STL学习笔记（随缘更新）
    VM-Linux基础操作命令
    快乐数[环类问题之快慢指针]
    动态规划算法
    Ngnix封禁IP与ip段
    力扣27.移除元素【顺序表】
    Java学习笔记5.2.2 List接口 - LinkedList类
    【算法 | 模拟No.3】leetcode 38. 外观数列
  • 原文地址：https://blog.csdn.net/qq_33753147/article/details/126680024