自定义一个IOC容器

最新推荐文章于 2022-10-15 23:07:22 发布
最新推荐文章于 2022-10-15 23:07:22 发布
阅读量1k 收藏 3
点赞数
分类专栏： spring常用知识点 制作小框架 文章标签： IOC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yinbucheng/article/details/79016415
版权
本文探讨了IOC容器的作用，它是用来控制对象的生成和维护对象间的关系。传统的做法是在对象A中直接持有对象B的实例并调用其show方法。但通过IOC容器，结合注解，我们可以更灵活地管理和调用对象，如使用扫描包的工具类进行对象的自动装配。
摘要由CSDN通过智能技术生成

开始之前我们先要清楚一个事IOC容器是干什么用的，IOC容器是控制对象的生成，维护对象之间的关系。在不适用IOC容器时我们使用对象，比如A需要B对象上的show方法，是在A对象中持有B对象的实例然后再调用它上面的show方法。而采用IOC容器我们可以结合注解使用


扫描包的工具类

package cn.yc.myspring.ioc.utils;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

/***
 * 扫描包下类的工具类
 */
public  abstract  class ScannerClass {

    /***
     **参数1 要扫描包的完整路径  要扫描包的名称(cn.itcast.manage)
     **返回参数 该包下面所有的类的全名称
     **/
    public static List<String> parseClassName(String packageName) {
        List<String> array = new ArrayList<>();
        String packagePath = resovlePackagePath(packageName);
        File root = new File(packagePath);
        resolveFile(root, packageName, array);
        return array;
    }

    /***
     **参数 包名(cn.itcast.manage)
     **返回参数 该包的全路径
     **/
    private static String resovlePackagePath(String packageName) {
        //扫码所有的包并把其放入到访问关系和方法放入到内存中
        File f = new File(ScannerClass.class.getResource("/").getPath());
        String totalPath = f.getAbsolutePath();
        String pageName = ScannerClass.class.getPackage().getName().replace(".","\\");
        totalPath = totalPath.replace(pageName,"");
        String  packagePath = packageName.replace(".","\\");
        totalPath=totalPath+"\\"+packagePath;
        return totalPath;
    }




    private  static void resolveFile(File root, String packageName, List<String> classNames) {
        if (!root.exists())
            return;
        File[] childs = root.listFiles();
        if (childs != null && childs.length > 0) {
            for (File child : childs) {
                if (child.isDirectory()) {
                    String parentPath = child.getParent();
                    String childPath = child.getAbsolutePath();
                    String temp = childPath.replace(parentPath, "");
                    temp = temp.replace("\\", "");
                    resolveFile(child, packageName + "." + temp, classNames);
                } else {
                    String fileName = child.getName();
                    if (fileName.endsWith(".class")) {
                        String name = fileName.replace(".class", "");
                        String className = packageName + "." + name;
最低0.47元/天 解锁文章
yinbucheng
关注
专栏目录
自定义IOC
donjor的博客
10-24 557
自定义ioc 1.IOC 控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。 控制反转,对象的使用者不是创建者 . 2.原始方式 特点:创建累,根据类自己new对象 优点:易写,简洁 缺点:耦合度太高,不方便维护 3.面向接口 特点:创建接口(规则),根据接口编写实现类(可以是多个),根据实现类自己new对象. ...
自定义IOC容器
02-18
自己动手实现IOC容器的demo，帮助理解和学习spring IOC容器的基本原理和实现，适合学过或者用过spring的java玩家
自定义IOC容器思路
Java持续实践
03-05 246
文章目录自定义IOC容器思路框架应该具备的最基本的功能IOC容器的实现 自定义IOC容器思路 自定义IOC容器的思路如下, 给类标识上注解, 通过IOC容器去解析注解生成对象, 在程序运行时, 让容器去注入对象. 框架应该具备的最基本的功能 解析配置: 将相关配置加载进内存中, 存入进数据结构. 解析的配置可以是注解或者XML 定位与注册对象: 解析完配置后, 需要获取内存中的目标对象, 定位就涉及到标记, 注解就是一种很好的标记语言. 注入对象: 把需要用到这个对象的地方, 把对象精确无误的返回过来
自定义IOC容器(简易版)
技术记录薄
10-15 364
自定义IOC精简版
Spring源码解读『IOC容器1-自定义实现IOC容器』
卓立的博客
06-30 649
上篇文章介绍了Spring的相关基础概念，我们了解到Spring Framework提供的两个基础功能就是IOC和AOP。关于IOC容器我们分为两篇文章来介绍，本篇文章会介绍IOC容器的基础概念，并自定义实现一个基础的IOC容器，帮助我们后续更好的解读IOC源码。AOP会在之后的文章中介绍。 1. IOC容器基本概念 IOC（Inversion Of Control）也叫控制反转，这个概念经常会伴随另一个概念DI（Dependence Injection）依赖注入出现。直白的讲就是，Java中一个对象依
手写一个SpringIoc容器
04-12
通过实现这样一个自定义的Spring IOC容器，我们可以更深入地理解Spring是如何工作的，以及如何使用IoC和DI原则来设计和构建软件。这将有助于提高我们的编程技巧和设计能力，特别是在大型企业级应用开发中。
Laravel 5.4向IoC容器中添加自定义类的方法示例
10-19
因为包含了一大堆所谓“先进”的概念，其中依赖注入（DI）和Ioc容器是比较核心的内容之一。下面这篇文章主要给大家介绍了关于Laravel 5.4向IoC容器中添加自定义类的相关资料，需要的朋友可以参考下。
自定义的IOC容器，dom4j进行解析，反射创建对象
02-07
使用dom4j解析spring配置文件，通过反射创建对象并存放到临时空间中。通过getBean获取对象
自定义IOC 简单实现
lyf_zm的博客
09-05 528
自定义IOC 简单实现 IOC概念: IOC(inversion of control)的中文解释是“控制反转”，对象的使用者不是创建者. 作用是将对象的创建 反转给spring框架来创建和管理。说白了就是把对象交给spring创建和管理. 我们要用对象时直接从Spring的IOC容器【集合】中获取,使用spring最主要的目的是实现解耦, 到时候我们只需要修改配置文件, 不需要修改源码 简单实...
自定义实现 IOC
Joker
03-01 315
对IOC和AOP的概念了解清楚了，那么如何运用它们呢？ 这里我们来通过一个银行转帐的demo来进行自定义IOC以及AOP的实现。 首先，我们实体类代码如下： public class BankAccount { //卡号 private String cardNo; //姓名 private String name; //余额 private in...
自定义实现spring式的IOC
maoyeqiu的专栏
10-28 1491
这两天想好好学习一下spring，对于spring的东西无非就是一些配置，但是不想只停留在应用的层面。一直以来对spring的内部的运行的原理非常好奇，想着研究一下源码，但是把源码拿过来如大海捞针，实在是无从下手，于是乎，自己综合查了的一些资料实现了spring式的IOC，感觉很有意思。下边把代码贴出来： 首先是定义了两个测试用的接口： package com.ioc.dao; public
手写IOC容器
qq_42477665的博客
07-25 269
手写IOC容器 IOC容器执行流程 编写流程如下： 序号 内容 1 编写自定义的AnnotationConfigApplicationContext类,解析某包下所有的class类 2 将带有@Component注解的class封装成BeanDefinition对象,格式k->beanName v->class类,最终将BeanDefinition存放入Set集合中 3 遍历Set集合，从BeanDefinition对象获取class类进行实例化，并填充属性值 4
自定义实现IOC与DI
Lucifer__L的博客
06-14 242
由浅入深理解IOC和DI
简单实现自定义IOC(控制反转)
qq_41543905的博客
01-23 306
IOC(inversion of control)的中文解释是“控制反转”，对象的使用者不是创建者. 作用是将对象的创建 反转给spring框架来创建和管理。 控制反转怎么去理解呢。 其实它反转的是什么呢，是对象的创建工作。 举个例子:平常我们在servlet或者service里面创建对象，都是使用new 的方式来直接创建对象，现在有了spring之后，我们就再也不new对象了，而是把对象创建的工作交给spring容器去维护。我们只需要问spring容器要对象即可。 IOC 的作用：削减计算机程序的耦合(解
仿照IOC容器Unity容器实现自定义IOC容器
佛陀爱老虎的博客
05-19 506
仿照IOC容器Unity容器实现自定义IOC容器 文章目录仿照IOC容器Unity容器实现自定义IOC容器1.实现思路2.程序上端应用3.源代码 1.实现思路 （1）首先提供一个接口，这个接口包括实现注册类型的泛型方法，以及实例化类型的方法：IDZBContainer public interface IDZBContainer { /// <summary> ...
基于注解方式的 自定义IOC容器 核心代码块
qq_36194388的博客
07-12 1001
自定义@Service、@Autowired、@Transactional注解类，完成基于注解的IOC容器（Bean对象创建及依赖注入维护）和声明式事务控制 注意考虑以下情况： 1）注解有无value属性值【@service（value=""@Repository（value=""）】 2）service层是否实现接口的情况【jdk还是cglib】 BeanFactory 完成对注解的 解析， Bean对象创建及依赖注入维护 package com.lwl.edu.factory; import com
写一个自己的Spring框架——简单实现IoC容器功能
热门推荐
u010994169的博客
05-04 1万+
学习过Spring的同学都知道，Spring框架的核心就是IoC和AOP。Spring可以理解为一个工厂，负责对象的创建和对象间关系的维护。IoC即控制反转，简单点说就是原来的对象是在要使用之前通过在代码里通过new 的方式创建出来的而IOC的思想则是由spring容器创建同一创建(配置文件中注册bean对象)，在程序要使用到该对象的时候，自动注入。（spring默认在web容器启动的时候就创建了
用java代码自定义一个springioc容器
最新发布
09-05
### 回答1： 很高兴回答您的问题。首先，需要定义一个Bean类，然后使用反射机制创建Bean实例并将其存储在Map中。接着，需要解析Bean的依赖关系并进行注入。最后，需要实现Bean的生命周期管理，包括初始化和销毁。具体实现可以参考Spring源码。 ### 回答2： 实现一个简单的自定义Spring IOC容器需要以下步骤： 1. 定义一个bean类，该类包含需要注入的属性和对应的setter方法。 2. 创建一个容器类，用于管理bean的实例。在该容器类中，定义一个Map用来存储bean的名称和对应的实例。 3. 创建一个注入类，该类负责根据配置文件或注解来实例化和注入bean。可以使用反射机制来动态创建对象。 4. 编写一个配置类，该类用于读取配置文件或注解，获取需要创建的bean的信息。 5. 在容器类中，编写一个方法用于注册bean实例，将bean的名称和对应的实例放入Map中。 6. 在容器类中，编写一个方法用于从容器中获取bean的实例。 7. 将以上步骤整合到一个主程序中，测试容器类的功能。 以下是一个简单的实现示例： 1. 创建一个User类，包含name和age属性，并提供相应的setter方法。 ```java public class User { private String name; private int age; // Getter and Setter methods // ... } ``` 2. 创建一个容器类MyIOCContainer，使用Map来存储bean的名称和对应的实例。 ```java public class MyIOCContainer { private Map<String, Object> beans = new HashMap<>(); public void registerBean(String name, Object bean) { beans.put(name, bean); } public Object getBean(String name) { return beans.get(name); } } ``` 3. 创建一个注入类，用于实例化和注入bean。 ```java public class BeanInjector { public static void inject(Object bean) { // 通过反射机制实例化对象 // 通过反射机制注入属性 } } ``` 4. 创建一个配置类，使用注解来获取bean的信息。 ```java public class AppConfig { @Bean public User getUser() { User user = new User(); // 设置属性值 return user; } } ``` 5. 在容器类中实现注册和获取bean的方法。 ```java public class MyIOCContainer { // ... public void registerBean(String name, Object bean) { BeanInjector.inject(bean); // 注入属性 beans.put(name, bean); } public Object getBean(String name) { return beans.get(name); } // ... } ``` 6. 编写一个主程序，测试容器类的功能。 ```java public class Main { public static void main(String[] args) { MyIOCContainer container = new MyIOCContainer(); // 创建配置类实例 AppConfig config = new AppConfig(); // 获取bean的信息 Method[] methods = config.getClass().getMethods(); for (Method method : methods) { if (method.isAnnotationPresent(Bean.class)) { try { // 调用配置类的方法获取bean实例 Object bean = method.invoke(config); // 注册到容器中 container.registerBean(method.getName(), bean); } catch (Exception e) { e.printStackTrace(); } } } // 从容器中获取bean的实例 User user = (User) container.getBean("getUser"); System.out.println("Name: " + user.getName()); System.out.println("Age: " + user.getAge()); } } ``` 这是一个简单的自定义Spring IOC容器的实现示例，可以根据需要进行扩展和优化。 ### 回答3： 自定义一个简单的Spring IOC容器需要包含几个基本的组件和功能。以下是一个简单的实现示例： ```java import java.util.HashMap; import java.util.Map; public class CustomIOCContainer { private Map<String, Object> beanMap; // 存储bean的map public CustomIOCContainer() { beanMap = new HashMap<>(); } public void registerBean(String beanName, Object bean) { beanMap.put(beanName, bean); // 注册bean到map中 } public Object getBean(String beanName) { return beanMap.get(beanName); // 通过beanName获取对应的bean对象 } public static void main(String[] args) { CustomIOCContainer container = new CustomIOCContainer(); // 创建bean对象并注册到容器中 UserService userService = new UserServiceImpl(); container.registerBean("userService", userService); // 从容器中获取bean对象并使用 UserService userServiceFromContainer = (UserService) container.getBean("userService"); userServiceFromContainer.sayHello(); // 调用方法 // 结果输出：Hello, World! } } interface UserService { void sayHello(); } class UserServiceImpl implements UserService { @Override public void sayHello() { System.out.println("Hello, World!"); } } ``` 以上代码实现了一个简单的Spring IOC容器，核心思想是使用一个Map来存储注册的bean，通过bean的名称来获取对应的对象。在main方法中，我们创建了一个UserService对象并注册到容器中，然后通过容器的getBean方法获取UserService对象，并调用其sayHello方法进行输出。 这只是一个简化的实现示例，实际的Spring IOC容器功能还包括依赖注入、生命周期管理、AOP等复杂功能，不过以上代码可作为基本框架的起点。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值