简单了解IOC底层的实现

最新推荐文章于 2024-05-08 20:19:41 发布
最新推荐文章于 2024-05-08 20:19:41 发布
阅读量169 收藏
点赞数
分类专栏： spring5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45858542/article/details/119325603
版权

实现bean的自动创建

本次主要是对ApplicationContext applicationContext = new MyClassPathXmlApplicationContext(“spring-ioc.xml”);进行底层解析

能够更深度理解机制

思路：（实际上就是工厂模式）

1、根据需求编写XML文件，配置需要创建的bean

2、编写程序读取XML文件，获取bean相关信息，比如id、name、类、属性

3、根据第二步获取到的信息，结合反射机制动态创建对象，同时完成属性的赋值。

4、将创建好的bean存入Map集合中，设置key-value映射，key就是bean的id值，value就是bean对象

5、提供方法从Map中通过id获取到对应的value。

这个思路很重要

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
 http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
">

    <bean id="car" class="com.linko.entity.Car">
        <property name="num" value="1"></property>
        <property name="brand" value="奥迪"></property>
        <property name="price" value="30.5"></property>
    </bean>
</beans>

Car实体类

package com.linko.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Car {
    private Integer num;
    private String brand;
    private Double price;
}

MyClassPathXmlApplicationContext

里面有很多函数是没有用到的，是接口所要实现的，我们主要是调用getBean函数，所以只需要使用这一个即可

package com.linko.ioc;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.MessageSourceResolvable;
import org.springframework.context.NoSuchMessageException;
import org.springframework.core.ResolvableType;
import org.springframework.core.env.Environment;
import org.springframework.core.io.Resource;
import org.xml.sax.SAXException;

import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.SQLOutput;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;

public class MyClassPathXmlApplicationContext implements ApplicationContext {

    private Map<String,Object> iocMap;

    public MyClassPathXmlApplicationContext(String path){
        iocMap = new HashMap<String, Object>();
        //解析XML
        parseXML(path);
    }

    public void parseXML(String path){
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read("src/main/resources/" + path);
            //拿到bean
            Element root = document.getRootElement();//找到bean
            Iterator<Element> rootIter = root.elementIterator();//迭代bean文件
            while (rootIter.hasNext()) {
                Element bean = rootIter.next();
                //获取id啥的
                String idStr = bean.attributeValue("id");
                String className = bean.attributeValue("class");
//                System.out.println(idStr);
//                System.out.println(className);
                //反射动态创建对象
                Class clazz = Class.forName(className);
                //获取无参构造
                Constructor constructor = clazz.getConstructor();
//                System.out.println(constructor);
                //创建对象
                Object object = constructor.newInstance();
//                System.out.println(object);//表明我们已经创建好了，接下来就要放到容器了。
                //bean容器中我们采用Map的形式去存储实体类里的信息
                //给属性赋值,所以我们要读取bean里面的property
                Iterator<Element> beanInter = bean.elementIterator();
                while(beanInter.hasNext()){
                    Element property = beanInter.next();
//                    System.out.println(property);
                    String propertyName = property.attributeValue("name");
                    String propertyValue = property.attributeValue("value");
//                    System.out.println(propertyName + "-" + propertyValue);
                    //通过set方法赋值，获取setter方法
                    //num-setNum,brand-setBrand
                    String methodName = "set" + propertyName.substring(0,1).toUpperCase() + propertyName.substring(1);
//                    System.out.println(methodName);
                    //获取属性
//                    Field field = clazz.getField(propertyName);//这个只能是获取公有的public
                    Field field = clazz.getDeclaredField(propertyName);//这个是获取具有访问权限的
//                    System.out.println(field.getType());//获取参数类型
                    Method method = clazz.getMethod(methodName,field.getType());//后面是属性对应的类型，如Integer
                    //调用invoke，这个函数有两个参数，第一个是对象，第二个是属性值,有...是表明是可变参数
                    //类型转换,因为我们读到的是String类型，但是实体类是有它自己的类型，所以需要转化
                    Object value= propertyValue;//这个是属性的值，然后不同值是通过多重循环得到的
                    if(field.getType().getName() == "java.lang.Integer"){
                        value = Integer.parseInt(propertyValue);
                    }else if(field.getType().getName() == "java.lang.Double"){
                        value = Double.parseDouble(propertyValue);
                    }

                    method.invoke(object,value);
                    System.out.println(method);
                }

                //存入Map
                iocMap.put(idStr,object);
                //然后ClassPathXmlApplicationContext本身含有getBean函数，所以我们只需要使用即可

            }
//            System.out.println(document);
        } catch (DocumentException e) {
            e.printStackTrace();
        }catch (ClassNotFoundException e) {
            e.printStackTrace();
        }catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        /*不建议使用这种方式，因为不利于排查错误
        catch (Exception e){
            e.printStackTrace();
        }*/
    }
    public String getId() {
        return null;
    }

    public String getApplicationName() {
        return null;
    }

    public String getDisplayName() {
        return null;
    }

    public long getStartupDate() {
        return 0;
    }

    public ApplicationContext getParent() {
        return null;
    }

    public AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException {
        return null;
    }

    public BeanFactory getParentBeanFactory() {
        return null;
    }

    public boolean containsLocalBean(String s) {
        return false;
    }

    public boolean containsBeanDefinition(String s) {
        return false;
    }

    public int getBeanDefinitionCount() {
        return 0;
    }

    public String[] getBeanDefinitionNames() {
        return new String[0];
    }

    public <T> ObjectProvider<T> getBeanProvider(Class<T> aClass, boolean b) {
        return null;
    }

    public <T> ObjectProvider<T> getBeanProvider(ResolvableType resolvableType, boolean b) {
        return null;
    }

    public String[] getBeanNamesForType(ResolvableType resolvableType) {
        return new String[0];
    }

    public String[] getBeanNamesForType(ResolvableType resolvableType, boolean b, boolean b1) {
        return new String[0];
    }

    public String[] getBeanNamesForType(Class<?> aClass) {
        return new String[0];
    }

    public String[] getBeanNamesForType(Class<?> aClass, boolean b, boolean b1) {
        return new String[0];
    }

    public <T> Map<String, T> getBeansOfType(Class<T> aClass) throws BeansException {
        return null;
    }

    public <T> Map<String, T> getBeansOfType(Class<T> aClass, boolean b, boolean b1) throws BeansException {
        return null;
    }

    public String[] getBeanNamesForAnnotation(Class<? extends Annotation> aClass) {
        return new String[0];
    }

    public Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> aClass) throws BeansException {
        return null;
    }

    public <A extends Annotation> A findAnnotationOnBean(String s, Class<A> aClass) throws NoSuchBeanDefinitionException {
        return null;
    }

    public Object getBean(String s) throws BeansException {
        return iocMap.get(s);
    }

    public <T> T getBean(String s, Class<T> aClass) throws BeansException {
        return null;
    }

    public Object getBean(String s, Object... objects) throws BeansException {
        return null;
    }

    public <T> T getBean(Class<T> aClass) throws BeansException {
        return null;
    }

    public <T> T getBean(Class<T> aClass, Object... objects) throws BeansException {
        return null;
    }

    public <T> ObjectProvider<T> getBeanProvider(Class<T> aClass) {
        return null;
    }

    public <T> ObjectProvider<T> getBeanProvider(ResolvableType resolvableType) {
        return null;
    }

    public boolean containsBean(String s) {
        return false;
    }

    public boolean isSingleton(String s) throws NoSuchBeanDefinitionException {
        return false;
    }

    public boolean isPrototype(String s) throws NoSuchBeanDefinitionException {
        return false;
    }

    public boolean isTypeMatch(String s, ResolvableType resolvableType) throws NoSuchBeanDefinitionException {
        return false;
    }

    public boolean isTypeMatch(String s, Class<?> aClass) throws NoSuchBeanDefinitionException {
        return false;
    }

    public Class<?> getType(String s) throws NoSuchBeanDefinitionException {
        return null;
    }

    public Class<?> getType(String s, boolean b) throws NoSuchBeanDefinitionException {
        return null;
    }

    public String[] getAliases(String s) {
        return new String[0];
    }

    public void publishEvent(Object event) {

    }

    public String getMessage(String code, Object[] args, String defaultMessage, Locale locale) {
        return null;
    }

    public String getMessage(String code, Object[] args, Locale locale) throws NoSuchMessageException {
        return null;
    }

    public String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException {
        return null;
    }

    public Environment getEnvironment() {
        return null;
    }

    public Resource[] getResources(String s) throws IOException {
        return new Resource[0];
    }

    public Resource getResource(String s) {
        return null;
    }

    public ClassLoader getClassLoader() {
        return null;
    }
}

Test测试类

package com.linko.ioc;

import com.linko.entity.Car;
import org.springframework.context.ApplicationContext;

public class Test {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new MyClassPathXmlApplicationContext("spring-ioc.xml");
        Car car = (Car)applicationContext.getBean("car");
        System.out.println(car);
    }
}
lei_gentle
关注
专栏目录
IOC底层原理
weixin_45463797的博客
03-07 2010
IOC底层原理分析
Spring--IOC容器（底层原理）
it14193的博客
04-04 635
Bean管理指的是两个操作（1）Spring创建对象：1）配置对象：在Spring配置文件中定义需要创建的对象，包括对象的类名、属性值等信息。2）实例化对象：Spring容器根据配置文件中的定义，实例化需要创建的对象。实例化过程中会调用对象的构造函数。3）设置属性值：Spring容器使用反射机制将配置文件中定义的属性值注入到对象中。4）调用初始化方法：如果配置文件中定义了初始化方法，Spring容器会在对象实例化和属性注入完成后调用该方法。
Spring学习(2) Spring的IOC底层实现
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
06-29 1222
在创建Bean之前，首先需要创建IOC容器，Spring提供了IOC容器的两种实现方式:bean对象是由Spring IOC容器管理的bean 是一个被实例化，组装，并通过 Spring IoC 容器所管理的对象。这些 bean 是由用容器提供的配置元数据创建的，例如，在 XML 的表单中的 定义。bean的常见属性 如果一个类中，有一个属性不是基本类型，包装类，String类，而是自定义的类型，那么我们就不可以使用value标签或value属性来为它赋值，而要使用ref来进行引用 级联属性更改数值会影
在面试时谈谈对IOC的底层实现
weixin_49283772的博客
09-01 272
面试时谈谈对IOC的底层实现
IOC的底层实现
Hitmi_的博客
12-19 823
第一部分开篇直接给答案：IOC的底层是有工厂+反射+配置文件实现的。 第二部分我将从个人创建一个Bean对象的方式的变迁来引出IOC的底层实现（可跳过直接看第三部分：IOC的底层实现详解）。 以UserDao为例，在最初开始学习javaweb创建一个UserDao对象是直接new的，即UserDao userDao = new UserDao(); 再到后来实训中老师对代码规范的稍作规...
谈一下Spring IOC的底层实现
小泽
10-24 293
spring
简单了解SPRINGIOC的底层原理演变过程
08-25
总结，Spring IOC的底层原理演变过程从简单的对象创建到工厂模式，再到结合反射和配置文件的解耦，以及最终的注解配置和自动配置，体现了软件设计的不断优化和进步。理解这些原理，有助于我们更好地利用Spring框架，...
基于Java反射技术实现简单IOC容器
08-18
基于Java反射技术实现简单IOC容器 Java反射技术是Java语言中一个非常重要的技术，通过反射技术可以在运行时检查和修改类的结构和行为。IOC容器是控制反转的缩写，全称是Inverse of Control，即控制反转。它是一种...
简单了解Spring IoC相关概念原理
08-18
"简单了解Spring IoC相关概念原理" Spring IoC（Inversion of Control，控制反转）是Spring框架的基础，主要是通过描述（在Java中可以是XML或注解）并通过第三方去产生或获取特定对象的方式。Spring IoC容器的设计...
Spring IOC：IOC在Spring底层中如何实现？
siaok的博客
05-09 1001
IOC，英文全称为Inversion of Control，意为反转控制。不是什么新的开发技术，而是一种开发设计思想。我们都知道在应用程序中的组件需要获取资源时，传统的方式是组件主动的从容器中获取所需要的资源，在这样的模式下开发人员往往需要知道在具体容器中特定资源的获取方式，增加了学习成本，同时降低了开发效率。这里的组件是什么？在Spring框架中，组件（Component）是指可以被Spring容器管理和配置的对象，包括Java类和Bean等。反转控制。
Spring(一) IOC的底层实现
我的博客
07-26 460
Spring IOC 底层原理理解
spring5笔记1--IOC的底层原理和两种实现方式
pangpangben的博客
04-07 823
spring笔记1 spring是轻量级的开源框架 spring有两部分核心： 1）. IOC: 控制反转，把**创建对象**和**对象之间的调用**交给spring进行管理 2）. Aop: 面向切面，不修改源代码的基础上进行功能增强 Spring 特点： （1）方便解耦，简化开发 （2）Aop 编程支持 （3）方便程序测试 （4）方便和其他框架进行整合 （5）方便进行事务操作 （6）降低 API 开发难度 IOC IOC：控制反转，把对象创建和对象之间的调用过程交给spring进行管理 目的：降低耦合
ioc底层实现原理（详解）
qq_36473318的博客
11-08 2073
    在使用Spring时不需要写反射的代码，底层已经实现。
Spring4 的IOC的底层实现
23号员工的博客
03-27 225
工厂模式+反射机制+配置文件 实现程序的解耦 配置文件中配置： <bean id="UserDao" class="com.spring.demo1.UserDapImpl"></bean> class BeanFactory { public static Object getBean(String id){ //根据i...
Spring的IOC容器底层原理和实现方式
qq_55673469的博客
01-26 1946
一.IOC是什么 控制反转，把对象的创建和调用过程交给spring进行管理。它的目的是降低耦合度。 二.IOC底层原理 原理是xml解析、工厂模式、反射。 一下是实现一个简单例子的基本过程 （1）第一步 xml配置文件，配置创建的对象 <bean id="名字" class="类路径"></bean> （2）第二部 工厂模式的意思是创建一个工厂类，在其中创建静态方法来返回对象，当其他方法要获取该对象时，能通过“类.方法”获取对象降低耦合度。我们就按照这个模式创..
IOC的底层是怎么实现的
最新发布
m0_63102097的博客
05-08 241
在Java领域，Spring Framework是一个典型的IoC容器，它通过上述方式实现了IoC的功能，提供了依赖注入、AOP、生命周期管理等功能，帮助开发者实现了面向接口编程、解耦和关注点分离。（Inversion of Control，IoC）是一种软件设计原则，它的核心思想是将对象的创建、组装和管理工作交给IoC容器来完成，从而实现了对象之间解耦和关注点分离。总体来说，IoC容器的底层实现是基于反射、配置元数据、依赖注入、AOP等技术，它通过集中管理对象的创建和管理，实现了代码解耦、组装和管理。
Spring IOC容器底层实现原理
only-code的博客
04-25 953
IOC容器里核心的接口：BeanFactory Bean对象 Factory 工厂 Inversion Of Control（控制反转）：把对象的创建过程与使用统一都交给spring来进行管理。 不需要开发者自己去new对象 IOC容器底层实现技术 反射技术 解析xml 工厂模式 作用：降低代码的耦合度 步骤： 1.解析xml技术，解析spring.xml配置文件。 2.获取<bean id="" class=""> </bean> 类完整路径地址。 3
spring IOC底层原理实现
qq_25460159的博客
11-22 893
1.利用dom4j技术根据id找出class位置（解析xml） string calssValue="class属性值"; 2.利用反射机制来创建对象 class clazz=Class.forName(calssValue); //创建类对象 UserService userservice=class.newInstance(); return userservice;
深入解析Spring框架：IOC与AOP原理及自实现Demo
请注意，虽然Spring框架为我们提供了非常强大的工具，但其底层实现相对复杂，涉及Java反射、代理设计模式、类加载器等多个高级概念。因此，在尝试自行实现IoC和AOP时，需要有一定的Java基础知识和面向对象编程的实践...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值