简单实现自定义IOC(控制反转)

最新推荐文章于 2022-10-15 23:07:22 发布
最新推荐文章于 2022-10-15 23:07:22 发布
阅读量306 收藏
点赞数
分类专栏： spring 文章标签： ioc java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41543905/article/details/113057525
版权

IOC(inversion of control)的中文解释是“控制反转”，对象的使用者不是创建者. 作用是将对象的创建 反转给spring框架来创建和管理。
控制反转怎么去理解呢。 其实它反转的是什么呢，是对象的创建工作。 举个例子:平常我们在servlet或者service里面创建对象，都是使用new 的方式来直接创建对象，现在有了spring之后，我们就再也不new对象了，而是把对象创建的工作交给spring容器去维护。我们只需要问spring容器要对象即可。
IOC 的作用：削减计算机程序的耦合(解除我们代码中的依赖关系)。

本次案例中我们使用工厂模式来创建对象，模拟spring容器从配置文件中读取类路径然后实例化的过程。

  1. 首先，创建一个接口和它的实现类
public interface UserService {

    void insert();
}

public class UserServiceImpl implements UserService {
    @Override
    public void insert() {
        System.out.println("插入了一条数据");
    }
}
  1. 其次，创建一个配置文件。
<?xml version="1.0" encoding="utf-8" ?>
<beans>
<bean id="userService"  class="com.hy.serviceImpl.AnotherUserServiceImpl" ></bean>
</beans>
  1. 然后，我们创建一个工厂类，创建一个getInstance()方法，提供给对象获取实例，方法内使用dom4j解析xml文件的内容。对了，还要引入依赖
		 <!-- dom4j -->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <!-- dom4j 的依赖包 jaxen -->
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1-beta-8</version>
        </dependency>
  1. 下面是这个工厂类的初级版本。至于为什么是初级版本，下面我会解释
package com.hy.factory;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.junit.jupiter.api.Test;

import java.io.InputStream;
import java.util.List;

/**
 * @author HY
 * @ClassName BeanFactory
 * @Description 最原始方法
 * @DateTime 2020/12/24 15:36
 * Version 1.0
 */
public class BeanFactory {
    public static Object getInstance(String name) {
        //dom4j解析xml文件
        SAXReader saxReader = new SAXReader();
        //获得配置文件
        InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beanconfig.xml");
        try {
            Document read = saxReader.read(resourceAsStream);
            //拿到标签为bean element对象
            List<Element> list = read.selectNodes("//bean");
            for (Element element : list) {
                //获得标签内id属性的值
                String id = element.attributeValue("id");
                //与传入的类名做对比
                if (name.equals(id)){
                    //相等，就获得这个标签中的class属性的值。
                    String aClass = element.attributeValue("class");
                    //拿到全限定名称，加载到内存中
                    Class<?> aClass1 = Class.forName(aClass);
                    //通过反射实例化对象
                    return aClass1.newInstance();
                }
            }
            throw new RuntimeException("找不到Id为:"+name+"的bean标签");
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e.getMessage());
        }
    }
}

4.1创建测试类测试。

@Test
    public void testRead() {
        UserService userService1= (UserService) BeanFactory.getInstance("userService");
        userService1.insert();
    }

输出：
在这里插入图片描述
到这里想必大家已经发现了，每实例化一个类对象就要读取一次xml配置文件，而且这个类的内容是写死不会变的，不会因为不同的对象产生不同的结果，所以没必要每次都去读取配置文件实例化新的对象。这时候就可以使用单例模式来配合工厂模式；

  1. 饿汉式单例模式配合工厂模式的使用
package com.hy.factory;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author HY
 * @ClassName BeanFactoryV2
 * @Description 饿汉式单例模式(先实例化所有bean标签中的类)
 * @DateTime 2020/12/24 16:37
 * Version 1.0
 */
public class BeanFactoryV2 {
    /**
     * 容器，存储bean标签的id和对应的对象
     */
    private static Map<String, Object> map = new HashMap();

    static {
        //dom4j解析xml文件
        SAXReader saxReader = new SAXReader();
        //获得配置文件
        InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beanconfig.xml");
        Document read = null;
        List<Element> list = null;
        try {
            //获得所有标签
            read = saxReader.read(resourceAsStream);
            //获得标签下的bean标签
            list = read.selectNodes("//bean");
            for (Element element : list) {
                String id = element.attributeValue("id");
                String aClass = element.attributeValue("class");
                Object object = Class.forName(aClass).newInstance();
                map.put(id, object);
            }
        } catch (Exception e) {
           throw new RuntimeException("类加载错误，请检查标签内class的类路径是否拼写错误");
        }
    }

    public static Object getInstance(String name) {
        Object obj = map.get(name);
        if (obj != null) {
            return obj;
        }
        throw new RuntimeException("找不到Id为:" + name + "的对象");
    }

}

5.1测试代码

	@Test
    public void testRead() {
        UserService userService1= (UserService) BeanFactoryV2.getInstance("userService");
        userService1.insert();
    }

输出:
在这里插入图片描述
虽然用饿汉式单例模式可以实现对象的唯一，但是如果配置文件中配置了很多很多个要注册的bean对象，但是某些对象又不会经常被用到，这样就造成了资源的浪费，所以，我们可以使用懒汉式单例模式来实现本案例的终极版本。

  1. 懒汉式单例模式配合工厂模式
package com.hy.factory;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import javax.crypto.Cipher;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @author HY
 * @ClassName BeanFactoryV3
 * @Description 懒汉式单例模式
 * @DateTime 2020/12/24 16:37
 * Version 1.0
 */
public class BeanFactoryV3 {
    /**
     * 用于存放类id与类的全限定名
     */
    private static Map<String, String> map = new HashMap();
    /**
     *用户存放已经实例化过的对象
     */
    private static Map cache = new HashMap();

    static {
        //dom4j解析xml文件
        SAXReader saxReader = new SAXReader();
        //获得配置文件
        InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beanconfig.xml");
        Document read = null;
        List<Element> list = null;
        try {
            read = saxReader.read(resourceAsStream);
            list = read.selectNodes("//bean");
            for (Element element : list) {
                String id = element.attributeValue("id");
                String aClass = element.attributeValue("class");
                //存放类id与类路径
                map.put(id, aClass);
            }
        } catch (Exception e) {
            throw new RuntimeException("类加载错误，请检查标签内class的类路径是否拼写错误");
        }
    }

    /**
     * 双重检测锁实现单例模式
     * @param name
     * @return
     * @throws Exception
     */
    public static Object getInstance(String name) throws Exception {
        Object obj = cache.get(name);
        //如果容器中没有该对象。
        if (obj == null) {
            //从map中取出全限定名加载
            String classPath= map.get(name);
            Class<?> aClass = Class.forName(classPath);
            synchronized (BeanFactoryV3.class) {
                if (cache.get(name) != null) {
                    cache.put(name,aClass.newInstance());
                }
            }
        }
        return obj;
    }
}

6.1 开多个线程测试。

@Test
    public void testRead() {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                try {
                    UserService userService = (UserService) BeanFactoryV3.getInstance("userService");
                    System.out.println(userService);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

测试结果:
在这里插入图片描述成功

兔头？
关注
专栏目录
Ioc(控制反转)之概念，使用典例
Ha_Girl的博客
05-20 346
Ioc是Inversion of Control的缩写，被称为控制反转，是Spring框架中其他功能的基础，因此，理解并能够熟练使用Ioc是进一步学习Spring 框架的前提必要。 ①什么是Ioc 任何一个应用，都是若干个对象互相协作完成的。创建一个对象后,总是需要对这个对象所依赖的属性进行初始化。在实际应用中，一个对象越复杂（依赖的属性多），对其装配的过程也将越复杂。通过dbcp连接池的例子...
Spring(二)-IoC控制反转
最新发布
程序员飞扬的博客
02-10 805
IOC控制反转，是一个理论，一个指导思想，指导开发人员如何使用对象，管理对象的，把对象的创建，属性赋值，对象的生命周期都交给代码之外的容器管理。
Spring IOC(控制反转)示例解析
ak364877的博客
03-23 309
控制反转——Spring通过一种称作控制反转（IoC）的技术促进了低耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。 首先用简单代码做一个简单示例来介绍一下什么事控制反转。 1.做一个叫JavaWork的测试...
自定义IOC
m0_46533814的博客
02-22 320
简单实现一个spring框架，来了解IOC的实现原理，方便以后学习Spring
深入理解IOC控制反转及应用实例
wayne liu 的博客
08-14 6569
一、IOC雏形 1、程序V1.0 话说，多年以前UT公司提出一个需求，要提供一个系统，其中有个功能可以在新春佳节之际给公司员工发送一封邮件。邮件中给大家以新春祝福，并告知发放一定数额的过节费。      经分析，决定由张三、李四和王五来负责此系统的开发。     其中：由张三负责业逻辑控制模块 LogicController的开发,此处简化为UT.LogicContro
自定义IOC 简单实现
lyf_zm的博客
09-05 528
自定义IOC 简单实现 IOC概念: IOC(inversion of control)的中文解释是“控制反转”，对象的使用者不是创建者. 作用是将对象的创建 反转给spring框架来创建和管理。说白了就是把对象交给spring创建和管理. 我们要用对象时直接从Spring的IOC容器【集合】中获取,使用spring最主要的目的是实现解耦, 到时候我们只需要修改配置文件, 不需要修改源码 简单实...
Java仿Spring框架IOC控制反转利用反射简单实现(源码)
12-11
Java中的控制反转（IOC，Inversion of Control）和Spring框架是现代企业级应用开发的核心概念。IOC使得应用程序的组件之间解耦，提高了代码的可测试性和可维护性。本篇文章将详细探讨如何通过反射机制来实现一个简单...
自定义IOC容器
02-18
【自定义IOC容器】是一个Java开发中的实践项目，旨在深入理解Spring框架的核心组件——IOC（Inversion of Control，控制反转）容器的工作原理。IOC容器是Spring框架的核心，它负责管理和装配应用中的对象，实现了...
ISpring-IOC-AOP:自定义IOC & AOP实现
05-26
标题 "ISpring-IOC-AOP:自定义IOC & AOP实现" 涉及到的是在Java编程领域中，对Spring框架的两个核心概念——控制反转（Inversion of Control, IOC）和面向切面编程（Aspect-Oriented Programming, AOP）的自定义实现...
Spring_IoC控制反转、依赖注入详解
WziH_CSDN的博客
09-30 678
Spring_IoC 一、IoC相关概念简介 1、理解【控制】和【依赖】的概念 IoC即控制反转、依赖注入 。—— OOAD依赖倒置 【控制】和【依赖】都代表对象之间的关联关系，而且他们在Spring中是一对近义词，控制和依赖几乎是并存的。 例如，现有如下需求：汽车的功能是行驶，司机的功能是驾驶汽车，令汽车行驶。 我们可以通过代码描述上述关系： public class Car { // 汽车类 private String name; // 品牌 private Double price;
自定义实现 IOC
Joker
03-01 315
对IOC和AOP的概念了解清楚了，那么如何运用它们呢？ 这里我们来通过一个银行转帐的demo来进行自定义IOC以及AOP的实现。 首先，我们实体类代码如下： public class BankAccount { //卡号 private String cardNo; //姓名 private String name; //余额 private in...
自定义实现IOC与DI
Lucifer__L的博客
06-14 239
由浅入深理解IOC和DI
自定义IOC容器(简易版)
技术记录薄
10-15 361
自定义IOC精简版
自定义一个IOC容器
yinbucheng的博客
01-09 1001
开始之前我们先要清楚一个事IOC容器是干什么用的，IOC容器是控制对象的生成，维护对象之间的关系。在不适用IOC容器时我们使用对象，比如A需要B对象上的show方法，是在A对象中持有B对象的实例然后再调用它上面的show方法。而采用IOC容器我们可以结合注解使用 扫描包的工具类 package cn.yc.myspring.ioc.utils; import java.io.File
控制反转
March
09-20 359
依赖注入介绍例子Laravel底层例子 介绍 一种设计模式，通过构造函数或一个方法，把一个外部实例注入进本类内部，而不是在本类内部创建外部实例，就是依赖注入。好处就是解耦。 例子 拿我之前写的compose pack举例： https://github.com/OX007/easywechatshare src/Share.php中的Share类里面需要使用EasyWeChat\Foundatio...
IOC控制反转——基础概念与实例
devops
04-21 831
  IOC（Inversion of Control）控制反转——为了符合依赖倒置原则，也就是高层模块不依赖于低层模块，他们都应该依赖于抽象；抽象不应该依赖于具体，具体依赖于抽象。例如小时候一家一户水井，人们喝水依赖水井和地下水，如果搬迁就要重新打井，水污染就没水喝，这是反依赖倒置；引入自来水厂以后，人们随意搬迁都能喝到水，接一根水管就行，当地下水污染，自来水厂也可以选择其他水源。也就是使用接口，但是总归接口是要被实现的，耦合也就不可避免的产生了。   通过IOC模式可以解决这个问题，把耦合放到XML文件，
自定义IOC容器思路
Java持续实践
03-05 245
文章目录自定义IOC容器思路框架应该具备的最基本的功能IOC容器的实现 自定义IOC容器思路 自定义IOC容器的思路如下, 给类标识上注解, 通过IOC容器去解析注解生成对象, 在程序运行时, 让容器去注入对象. 框架应该具备的最基本的功能 解析配置: 将相关配置加载进内存中, 存入进数据结构. 解析的配置可以是注解或者XML 定位与注册对象: 解析完配置后, 需要获取内存中的目标对象, 定位就涉及到标记, 注解就是一种很好的标记语言. 注入对象: 把需要用到这个对象的地方, 把对象精确无误的返回过来
简单的IOC控制反转实现
weixin_52263247的博客
09-27 137
1。编写接口 package com.yyf.dao; public interface UserDao { void getUser(); } 2.编写多个实现类 package com.yyf.dao; public class UserDaoImpl implements UserDao{ @Override public void getUser() { System.out.println ("UserDao获取数据"); } }
Android IoC设计模式实战：控制反转与依赖注入解析
"Android应用开发中的控制反转IoC设计模式是一种重要的编程理念，它通过依赖注入降低了组件间的耦合。在Android开发中，IoC能够帮助开发者更好地管理对象的创建和依赖关系，使得代码更加灵活和可维护。 1、IoC...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值