4、IoC原理，模拟实现IoC

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量376 收藏 7
点赞数 8
文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46544376/article/details/135426535
版权

4、原理-手写IoC

我们都知道，Spring框架的IOC是基于Java反射机制实现的，下面我们先回顾一下java反射。

4.1、回顾Java反射

Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。简单来说，反射机制指的是程序在运行时能够获取自身的信息。

要想解剖一个类，必须先要获取到该类的Class对象。而剖析一个类或用反射解决具体的问题就是使用相关API （1）java.lang.Class（2）java.lang.reflect，所以，Class对象是反射的根源。

自定义类

public class Car {

    // 属性
    private String name;
    private int age;
    private String color;

    // 无参数构造
    public Car() {
    }

    // 有参数构造
    public Car(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    // 普通方法
    private void run() {
        System.out.println("私有方法-run.....");
    }

    // get和set方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }
}

编写测试类

package com.atguigu.reflect;

import org.junit.jupiter.api.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class TestCar {

    // 1、获取Class对象多种方式
    @Test
    public void test01() throws Exception {
        // 1 类名.class
        Class clazz1 = Car.class;

        // 2 对象.getClass()
        Class clazz2 = new Car().getClass();

        // 3 Class.forName("全路径")
        Class clazz3 = Class.forName("com.atguigu.reflect.Car");

        // 实例化
        Car car = (Car) clazz3.getConstructor().newInstance();
        System.out.println(car);
    }

    // 2、获取构造方法
    @Test
    public void test02() throws Exception {
        Class clazz = Car.class;
        // 获取所有构造
        // getConstructors()获取所有public的构造方法
        // Constructor[] constructors = clazz.getConstructors();
        // getDeclaredConstructors()获取所有的构造方法public private
        Constructor[] constructors = clazz.getDeclaredConstructors();
        for (Constructor c : constructors) {
            System.out.println("方法名称：" + c.getName() + " 参数个数：" + c.getParameterCount());
        }

        // 指定有参数构造创建对象
        // 1 构造public
        // Constructor c1 = clazz.getConstructor(String.class, int.class, String.class);
        // Car car1 = (Car)c1.newInstance("夏利", 10, "红色");
        // System.out.println(car1);

        // 2 构造private
        Constructor c2 = clazz.getDeclaredConstructor(String.class, int.class, String.class);
        c2.setAccessible(true);
        Car car2 = (Car) c2.newInstance("捷达", 15, "白色");
        System.out.println(car2);
    }

    // 3、获取属性
    @Test
    public void test03() throws Exception {
        Class clazz = Car.class;
        Car car = (Car) clazz.getDeclaredConstructor().newInstance();
        // 获取所有public属性
        // Field[] fields = clazz.getFields();
        // 获取所有属性（包含私有属性）
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            if (field.getName().equals("name")) {
                // 设置允许访问
                field.setAccessible(true);
                field.set(car, "五菱宏光");
                System.out.println(car);
            }
            System.out.println(field.getName());
        }
    }

    // 4、获取方法
    @Test
    public void test04() throws Exception {
        Car car = new Car("奔驰", 10, "黑色");
        Class clazz = car.getClass();
        // 1 public方法
        Method[] methods = clazz.getMethods();
        for (Method m1 : methods) {
            // System.out.println(m1.getName());
            // 执行方法 toString
            if (m1.getName().equals("toString")) {
                String invoke = (String) m1.invoke(car);
                // System.out.println("toString执行了："+invoke);
            }
        }

        // 2 private方法
        Method[] methodsAll = clazz.getDeclaredMethods();
        for (Method m : methodsAll) {
            // 执行方法 run
            if (m.getName().equals("run")) {
                m.setAccessible(true);
                m.invoke(car);
            }
        }
    }
}

4.2、实现Spring的IoC

具体的推荐看自己写的idea项目

我们知道，IoC（控制反转）和DI（依赖注入）是Spring里面核心的东西，那么，我们如何自己手写出这样的代码呢？下面我们就一步一步写出Spring框架最核心的部分。

①搭建子模块

搭建模块：guigu-spring，搭建方式如其他spring子模块

②准备测试需要的bean

添加依赖

<dependencies>
    <!--junit5测试-->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.3.1</version>
    </dependency>
</dependencies>

创建UserDao接口

package com.atguigu.spring6.test.dao;

public interface UserDao {

    public void print();
}

创建UserDaoImpl实现

package com.atguigu.spring6.test.dao.impl;

import com.atguigu.spring.dao.UserDao;

public class UserDaoImpl implements UserDao {

    @Override
    public void print() {
        System.out.println("Dao层执行结束");
    }
}

创建UserService接口

package com.atguigu.spring6.test.service;

public interface UserService {

    public void out();
}

创建UserServiceImpl实现类

package com.atguigu.spring.test.service.impl;

import com.atguigu.spring.core.annotation.Bean;
import com.atguigu.spring.service.UserService;

@Bean
public class UserServiceImpl implements UserService {

    private UserDao userDao;

    @Override
    public void out() {
        userDao.print();
        System.out.println("Service层执行结束");
    }
}

③定义注解

我们通过注解的形式加载bean与实现依赖注入

创建Bean注解

package com.atguigu.spring.core.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Bean {
}

创建 Di依赖注入注解

package com.atguigu.spring.core.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface Di {
}

说明：上面两个注解可以随意取名

④定义bean容器接口

package com.atguigu.spring.core;

public interface ApplicationContext {

    Object getBean(Class clazz);
}

⑤编写注解bean容器接口实现

AnnotationApplicationContext基于注解扫描bean

package com.atguigu.spring.core;

import java.util.HashMap;

public class AnnotationApplicationContext implements ApplicationContext {

    // 存储bean的容器
    private HashMap<Class, Object> beanFactory = new HashMap<>();

    @Override
    public Object getBean(Class clazz) {
        return beanFactory.get(clazz);
    }

    /**
     * 根据包扫描加载bean
     * 
     * @param basePackage
     */
    public AnnotationApplicationContext(String basePackage) {

    }
}

⑥编写扫描bean逻辑

我们通过构造方法传入包的base路径，扫描被@Bean注解的java对象，完整代码如下：

package com.atguigu.spring.core;

import com.atguigu.spring.core.annotation.Bean;

import java.io.File;
import java.util.HashMap;

public class AnnotationApplicationContext implements ApplicationContext {

    // 存储bean的容器
    private HashMap<Class, Object> beanFactory = new HashMap<>();
    private static String rootPath;

    @Override
    public Object getBean(Class clazz) {
        return beanFactory.get(clazz);
    }

    /**
     * 根据包扫描加载bean
     * 
     * @param basePackage
     */
    public AnnotationApplicationContext(String basePackage) {
        try {
            String packageDirName = basePackage.replaceAll("\\.", "\\\\");//这里 \\是转义字符，注意 mac 上路径用/不用转义，\\\\的意思是\\声明是转义，\\声明是\
            Enumeration<URL> dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
            while (dirs.hasMoreElements()) {
                URL url = dirs.nextElement();
                String filePath = URLDecoder.decode(url.getFile(), "utf-8");
                rootPath = filePath.substring(0, filePath.length() - packageDirName.length());
                loadBean(new File(filePath));
            }

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private void loadBean(File fileParent) {
        if (fileParent.isDirectory()) {
            File[] childrenFiles = fileParent.listFiles();
            if (childrenFiles == null || childrenFiles.length == 0) {
                return;
            }
            for (File child : childrenFiles) {
                if (child.isDirectory()) {
                    // 如果是个文件夹就继续调用该方法，使用了递归
                    loadBean(child);
                } else {
                    // 通过文件路径转变成全类名，第一步把绝对路径部分去掉
                    String pathWithClass = child.getAbsolutePath().substring(rootPath.length() - 1);
                    // 选中class文件
                    if (pathWithClass.contains(".class")) {
                        // com.xinzhi.dao.UserDao
                        // 去掉.class后缀，并且把 \ 替换成 .
                        String fullName = pathWithClass.replaceAll("\\\\", ".").replace(".class", "");
                        try {
                            Class<?> aClass = Class.forName(fullName);
                            // 把非接口的类实例化放在map中
                            if (!aClass.isInterface()) {
                                Bean annotation = aClass.getAnnotation(Bean.class);
                                if (annotation != null) {
                                    Object instance = aClass.getConstructor().newInstance();
                                    // 判断一下有没有接口
                                    if (aClass.getInterfaces().length > 0) {
                                        // 如果有接口把接口的class当成key，实例对象当成value
                                        System.out.println("正在加载【" + aClass.getInterfaces()[0] + "】，实例对象是："
                                                + instance.getClass().getName());
                                        beanFactory.put(aClass.getInterfaces()[0], instance);
                                    } else {
                                        // 如果有接口把自己的class当成key，实例对象当成value
                                        System.out.println("正在加载【" + aClass.getName() + "】，实例对象是："
                                                + instance.getClass().getName());
                                        beanFactory.put(aClass, instance);
                                    }
                                }
                            }
                        } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

}

⑦java类标识Bean注解

@Bean
public class UserServiceImpl implements UserService {
}

@Bean
public class UserDaoImpl implements UserDao {
}

⑧测试Bean加载

package com.atguigu.spring;

import com.atguigu.spring.core.AnnotationApplicationContext;
import com.atguigu.spring.core.ApplicationContext;
import com.atguigu.spring.test.service.UserService;
import org.junit.jupiter.api.Test;

public class SpringIocTest {

    @Test
    public void testIoc() {
        ApplicationContext applicationContext = new AnnotationApplicationContext("com.atguigu.spring.test");
        UserService userService = (UserService) applicationContext.getBean(UserService.class);
        userService.out();
        System.out.println("run success");
    }
}

控制台打印测试

⑨依赖注入

只要 userDao.print(); 调用成功，说明就注入成功

package com.atguigu.spring.test.service.impl;

import com.atguigu.spring.core.annotation.Bean;
import com.atguigu.spring.core.annotation.Di;
import com.atguigu.spring.dao.UserDao;
import com.atguigu.spring.service.UserService;

@Bean
public class UserServiceImpl implements UserService {

    @Di
    private UserDao userDao;

    @Override
    public void out() {
        userDao.print();
        System.out.println("Service层执行结束");
    }
}

执行第八步：报错了，说明当前userDao是个空对象

⑩依赖注入实现

package com.atguigu.spring.core;

import com.atguigu.spring.core.annotation.Bean;
import com.atguigu.spring.core.annotation.Di;

import java.io.File;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class AnnotationApplicationContext implements ApplicationContext {

    // 存储bean的容器
    private HashMap<Class, Object> beanFactory = new HashMap<>();
    private static String rootPath;

    @Override
    public Object getBean(Class clazz) {
        return beanFactory.get(clazz);
    }

    /**
     * 根据包扫描加载bean
     * 
     * @param basePackage
     */
    public AnnotationApplicationContext(String basePackage) {
        try {
            String packageDirName = basePackage.replaceAll("\\.", "\\\\");
            Enumeration<URL> dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
            while (dirs.hasMoreElements()) {
                URL url = dirs.nextElement();
                String filePath = URLDecoder.decode(url.getFile(), "utf-8");
                rootPath = filePath.substring(0, filePath.length() - packageDirName.length());
                loadBean(new File(filePath));
            }

        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        // 依赖注入
        loadDi();
    }

    private void loadBean(File fileParent) {
        if (fileParent.isDirectory()) {
            File[] childrenFiles = fileParent.listFiles();
            if (childrenFiles == null || childrenFiles.length == 0) {
                return;
            }
            for (File child : childrenFiles) {
                if (child.isDirectory()) {
                    // 如果是个文件夹就继续调用该方法，使用了递归
                    loadBean(child);
                } else {
                    // 通过文件路径转变成全类名，第一步把绝对路径部分去掉
                    String pathWithClass = child.getAbsolutePath().substring(rootPath.length() - 1);
                    // 选中class文件
                    if (pathWithClass.contains(".class")) {
                        // com.xinzhi.dao.UserDao
                        // 去掉.class后缀，并且把 \ 替换成 .
                        String fullName = pathWithClass.replaceAll("\\\\", ".").replace(".class", "");
                        try {
                            Class<?> aClass = Class.forName(fullName);
                            // 把非接口的类实例化放在map中
                            if (!aClass.isInterface()) {
                                Bean annotation = aClass.getAnnotation(Bean.class);
                                if (annotation != null) {
                                    Object instance = aClass.getConstructor().newInstance();
                                    // 判断一下有没有接口
                                    if (aClass.getInterfaces().length > 0) {
                                        // 如果有接口把接口的class当成key，实例对象当成value
                                        System.out.println("正在加载【" + aClass.getInterfaces()[0] + "】，实例对象是："
                                                + instance.getClass().getName());
                                        beanFactory.put(aClass.getInterfaces()[0], instance);
                                    } else {
                                        // 如果有接口把自己的class当成key，实例对象当成value
                                        System.out.println("正在加载【" + aClass.getName() + "】，实例对象是："
                                                + instance.getClass().getName());
                                        beanFactory.put(aClass, instance);
                                    }
                                }
                            }
                        } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

    private void loadDi() {
        for (Map.Entry<Class, Object> entry : beanFactory.entrySet()) {
            // 就是咱们放在容器的对象
            Object obj = entry.getValue();
            Class<?> aClass = obj.getClass();
            Field[] declaredFields = aClass.getDeclaredFields();
            for (Field field : declaredFields) {
                Di annotation = field.getAnnotation(Di.class);
                if (annotation != null) {
                    field.setAccessible(true);
                    try {
                        System.out.println("正在给【" + obj.getClass().getName() + "】属性【" + field.getName() + "】注入值【"
                                + beanFactory.get(field.getType()).getClass().getName() + "】");
                        field.set(obj, beanFactory.get(field.getType()));
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}

执行第八步：执行成功，依赖注入成功

Hang-
关注
  • 8
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
IOC的模拟实现
weixin_46421861的博客
04-19 151
文章目录Ioc:Ioc的模拟实现： Ioc和Aop是Spring框架中重要的两个技术。 Ioc: Ioc称为控制反转，即不再有APP代码实现对类对象的初始化，而是由Spring完成自动初始化过程。这个过程又称为“注入”。 这里需要通过配置方式，告知Ioc自动注入过程。 Ioc的模拟实现： 1.通过两个注解，实现Ioc注入的配置。 @Component：此注解用于类，表示有此注解的类都将成为一个bean放入beanFactory中。 @Autowired：此注解用于成员或者set方法（主要用于set方法），表
java ioc 实现_Spring IOC实现原理
weixin_28362173的博客
02-15 418
1、BeanDefinition 对依赖翻转模式中管理对象依赖关系的数据抽象实现依赖翻转功能的核心数据结构依赖翻转功能都是围绕对BeanDefinition 处理完成的有了这些BeanDefinition 基础数据结构，容器才能发挥作用2、BeanFactory 定义了IOC 容器的基本功能规范IOC容器最基本形式遵守的基本契约最底层最基本编程规范仅仅是一个接口DefaultListableBe...
spring IOC容器的核心实现原理
喜欢猪猪
05-24 411
Spring IoC 容器通过控制反转和依赖注入的原理，有效地降低了程序元素间的耦合度，并且通过和提供了强大的对象管理和配置功能。
java ioc 简单实现原理_自己简单实现Spring的IOC原理
weixin_31119281的博客
02-19 88
控制反转(Inversion ofControl，缩写为IoC)简单来说就是当自己需要一个对象的时候不需要自己手动去new一个，而是由其他容器来帮你提供；Spring里面就是IOC容器。例如：在Spring里面经常需要在Service这个装配一个Dao，一般是使用@Autowired注解：类似如下public Class ServiceImpl{@AutowiredDao dao;public v...
IOC和AOP的实现原理与详解
You’re a wanderer just like me
10-27 2014
IoC（Inversion of Control） (1). IoC（Inversion of Control）是指容器控制程序对象之间的关系，而不是传统实现中，由程序代码直接操控。控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。 对于Spring而言，就是由Spring来控制对象的生命周期和对象之间的关系；IoC还有另外一个名字——“依赖注入（Dependency Injection）...
基于java简单模拟实现spring_ioc
03-19
在Java开发领域，Spring...通过这个模拟项目，开发者可以深入了解Spring IoC的基本原理，学习如何在没有Spring框架的情况下手动管理对象的生命周期和依赖关系，这对于理解Spring框架的工作机制和优化代码结构大有裨益。
Spring的IOC原理
03-21
**Spring的IOC原理详解** **一、IoC理论背景** 在面向对象的软件设计中，对象间的耦合是不可避免的，它们通过相互合作实现业务逻辑。这种耦合就像机械手表中的齿轮，彼此啮合共同完成任务。随着软件系统规模的扩大...
模拟Spring的IOC
03-20
要模拟Spring的IOC容器，我们需要实现以下几个核心功能： - **Bean定义（Bean Definition）**：存储对象的创建信息，如类名、属性值、依赖关系等。 - **Bean工厂（Bean Factory）**：负责读取Bean定义，并根据定义...
模拟Spring的IoC容器实现注解自动装配
05-10
最后，通过实际运行一些示例代码，验证我们的模拟IoC容器是否能正确地自动装配bean的依赖，确保功能完备。 以上就是模拟Spring的IoC容器实现注解自动装配的主要步骤和关键点。虽然这个实现可能不会涵盖Spring的所有...
以注解方式模拟Spring IoC AOP
09-12
本篇将深入探讨如何通过注解方式来模拟Spring的这两种机制，帮助你理解其底层原理。 ### 1. 依赖注入（IoC） 依赖注入是Spring框架的核心特性之一，它通过反转对象创建和管理的控制权，使得应用程序组件之间的耦合...
spring事务详细讲解-深入浅出
小电玩
09-08 409
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1419
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1344
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
Java集合——Stack详解
最新发布
yang_brother的博客
09-10 342
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
自定义Stater
m0_63624484的博客
09-07 688
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
央顺科技官方博客
09-05 550
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
MyBatis面试
Tony_yitao的博客
09-09 547
MyBatis面试
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
不起眼小菜菜的博客
09-07 308
步骤很详细，直接上教程……
SpringBoot总结
2302_77073236的博客
09-06 232
都做成图了，方便理解和掌握全局关系。
Java注解模拟Spring IoC容器详解与实例
然后，我们有一个`ioc`包，这是实际模拟IoC容器的地方。在这里，我们可以通过`java.lang.reflect.Field`类的反射API，扫描带有`@Component`注解的类，并根据`@Value`注解为这些类的字段注入值。 ```java package ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值