IOC和DI(控制反转和依赖注入)

已于 2024-07-23 14:44:06 修改
阅读量438 收藏 5
点赞数 4
文章标签： 项目框架 系统架构
于 2024-07-18 11:53:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yusude123456/article/details/140518822
版权

IOC介绍
控制反转（Inversion of Control, IoC）

概念

控制反转（IoC）是一种设计原则，旨在提高代码的灵活性和可维护性。它通过将对象的创建和依赖关系的管理从对象本身转移到外部容器或框架，从而实现松耦合。

实现方式

IoC 通常通过以下几种方式实现：

依赖注入（Dependency Injection, DI）：

构造函数注入：通过构造函数传递依赖对象。

 public class Service {
     private Repository repository;

     public Service(Repository repository) {
         this.repository = repository;
     }
 }

属性注入：通过属性（字段）传递依赖对象。

    public class Service {
         @Autowired
         private Repository repository;
     }

方法注入：通过方法参数传递依赖对象。

     public class Service {
         private Repository repository;

         @Autowired
         public void setRepository(Repository repository) {
             this.repository = repository;
         }
     }

服务定位器（Service Locator）：通过一个集中管理的对象来获取依赖对象。

   public class Service {
       private Repository repository;

       public Service() {
           this.repository = ServiceLocator.getRepository();
       }
   }
优点

松耦合：通过外部容器管理依赖关系，减少对象之间的耦合。
可测试性：更容易进行单元测试，因为依赖可以被轻松替换为模拟对象。
可维护性：更容易管理和修改依赖关系。

单例模式（Singleton Pattern）

概念
单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点。
实现方式

单例模式通常通过以下几种方式实现：

在以下的单例模式中 如果要控制单例模式无法复制，需要使用clone 抛错方法加到类中

@Override
    protected Object clone() throws CloneNotSupportedException {
        // 防止克隆
        throw new CloneNotSupportedException();
        // 或者 return instance; 保持单例
    }

饿汉式（在类加载时初始化实例）：

public class HungrySingleton implements Cloneable{
    private static final HungrySingleton instance = new HungrySingleton();

    private HungrySingleton(){};

    public static HungrySingleton getInstance(){
        return instance;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }
}

懒汉式（在第一次使用时初始化实例）：

  public class LazySingleton implements Cloneable{
    private static LazySingleton instance = null;

    LazySingleton(){}

    private static LazySingleton getInstance(){
        if (instance == null)
        {
            instance = new LazySingleton();
        }
        return instance;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }

}

双重检查锁定（结合懒汉式和线程安全）：

   public class Singleton {
       private static volatile Singleton instance;

       private Singleton() {}

       public static Singleton getInstance() {
           if (instance == null) {
               synchronized (Singleton.class) {
                   if (instance == null) {
                       instance = new Singleton();
                   }
               }
           }
           return instance;
       }
   }

静态内部类（线程安全且延迟加载）：

   public class Singleton {
       private Singleton() {}

       private static class SingletonHolder {
           private static final Singleton INSTANCE = new Singleton();
       }

       public static Singleton getInstance() {
           return SingletonHolder.INSTANCE;
       }
   }
优点

唯一实例：确保一个类只有一个实例，节省资源。
全局访问：提供一个全局访问点，便于管理和使用。

缺点

可测试性差：单例模式可能会导致代码难以测试，因为它隐藏了依赖关系。
不易扩展：单例模式可能会限制类的扩展性和灵活性。
IoC 与 单例模式的关系
单例模式在 IoC 中的应用：在 IoC 容器中，单例模式经常用于管理服务对象的生命周期。例如，Spring 框架默认情况下会将 Bean 定义为单例，这样可以确保每个 Bean 在容器中只有一个实例。
不同的关注点：IoC 关注的是对象的创建和依赖关系的管理，旨在实现松耦合和可维护性；而单例模式关注的是确保一个类只有一个实例，旨在节省资源和提供全局访问点。
总结
IoC：一种设计原则，通过将对象的创建和依赖关系的管理从对象本身转移到外部容器或框架，实现松耦合和可维护性。
单例模式：一种创建型设计模式，确保一个类只有一个实例，并提供全局访问点。

单例模式的一般实现

单例模式适用于那些在整个应用程序生命周期内只需要一个实例的类。这些类通常具有以下特点：
管理共享资源：
例如，线程池、数据库连接池等资源管理类，这些资源通常比较昂贵，创建多个实例会浪费资源。


   public class ConnectionPool {
       private static final ConnectionPool INSTANCE = new ConnectionPool();

       private ConnectionPool() {
           // 初始化连接池
       }

       public static ConnectionPool getInstance() {
           return INSTANCE;
       }

       // 其他方法
   }

提供全局访问点：
例如，配置管理类、日志管理类等，这些类需要在整个应用程序中被频繁访问。

   public class ConfigurationManager {
       private static final ConfigurationManager INSTANCE = new ConfigurationManager();

       private Properties properties;

       private ConfigurationManager() {
           properties = new Properties();
           // 加载配置
       }

       public static ConfigurationManager getInstance() {
           return INSTANCE;
       }

       public String getProperty(String key) {
           return properties.getProperty(key);
       }
   }

控制全局状态：
例如，缓存类、上下文类等，这些类需要维护全局状态。

   public class Cache {
       private static final Cache INSTANCE = new Cache();

       private Map<String, Object> cacheMap;

       private Cache() {
           cacheMap = new HashMap<>();
       }

       public static Cache getInstance() {
           return INSTANCE;
       }

       public void put(String key, Object value) {
           cacheMap.put(key, value);
       }

       public Object get(String key) {
           return cacheMap.get(key);
       }
   }

跨模块共享实例：
例如，服务定位器、事件总线等，需要在不同模块之间共享实例。

   public class EventBus {
       private static final EventBus INSTANCE = new EventBus();

       private EventBus() {
           // 初始化事件总线
       }

       public static EventBus getInstance() {
           return INSTANCE;
       }

       public void register(Object listener) {
           // 注册监听器
       }

       public void post(Object event) {
           // 发送事件
       }
   }

注意事项
虽然单例模式有很多优点，但也需要谨慎使用：
线程安全：确保单例实例在多线程环境下的安全性。例如，可以使用双重检查锁定或静态内部类来实现线程安全的单例模式。
可测试性：单例模式可能会影响代码的可测试性，因为它隐藏了依赖关系。可以考虑使用依赖注入（DI）来替代单例模式。
生命周期管理：在某些情况下，单例实例的生命周期需要特别管理。例如，在 Web 应用中，可能需要确保单例实例在应用程序关闭时正确释放资源。
总结
单例模式适用于那些需要在全局范围内共享实例的类，特别是那些管理共享资源、提供全局访问点、控制全局状态或跨模块共享实例的类。但在使用单例模式时，需要注意线程安全、可测试性和生命周期管理等问题。希望这些信息对你有所帮助！如果你有更多问题或需要进一步的解释，请告诉我。

IOC的其他模式

oC（控制反转）是一种设计原则，它不仅可以通过单例模式实现，还可以结合其他设计模式来实现依赖管理和控制反转。以下是一些常见的设计模式，它们通常在 IoC 容器中被使用：

  1. 工厂模式（Factory Pattern）
    概念
    工厂模式通过定义一个创建对象的接口，让子类决定实例化哪一个类。工厂模式使得一个类的实例化延迟到子类。
    示例
public interface Shape {
    void draw();
}

public class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

public class Square implements Shape {
    public void draw() {
        System.out.println("Drawing Square");
    }
}

public class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
            return new Square();
        }
        return null;
    }
}
  1. 抽象工厂模式（Abstract Factory Pattern）
    概念
    抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
    示例
public interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}


public class WinFactory implements GUIFactory {
    public Button createButton() {
        return new WinButton();
    }
    public Checkbox createCheckbox() {
        return new WinCheckbox();
    }
}

public class MacFactory implements GUIFactory {
    public Button createButton() {
        return new MacButton();
    }
    public Checkbox createCheckbox() {
        return new MacCheckbox();
    }
}
  1. 建造者模式（Builder Pattern）
    概念
    建造者模式通过一步一步地构建复杂对象，允许你创建不同的表示。
    示例
public class Meal {
    private List<Item> items = new ArrayList<>();

    public void addItem(Item item) {
        items.add(item);
    }

    public float getCost() {
        float cost = 0.0f;
        for (Item item : items) {
            cost += item.price();
        }
        return cost;
    }
}

public class MealBuilder {
    public Meal prepareVegMeal() {
        Meal meal = new Meal();
        meal.addItem(new VegBurger());
        meal.addItem(new Coke());
        return meal;
    }

    public Meal prepareNonVegMeal() {
        Meal meal = new Meal();
        meal.addItem(new ChickenBurger());
        meal.addItem(new Pepsi());
        return meal;
    }
}
  1. 原型模式（Prototype Pattern）
    概念
    原型模式通过复制现有对象来创建新对象，而不是通过实例化类。
    示例
public abstract class Shape implements Cloneable {
    private String id;
    protected String type;

    abstract void draw();

    public Object clone() {
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}

public class Circle extends Shape {
    public Circle() {
        type = "Circle";
    }

    public void draw() {
        System.out.println("Drawing Circle");
    }
}
  1. 代理模式（Proxy Pattern）
    概念
    代理模式为其他对象提供一种代理以控制对这个对象的访问。
    示例
public interface Image {
    void display();
}

public class RealImage implements Image {
    private String fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk(fileName);
    }

    private void loadFromDisk(String fileName) {
        System.out.println("Loading " + fileName);
    }

    public void display() {
        System.out.println("Displaying " + fileName);
    }
}

public class ProxyImage implements Image {
    private RealImage realImage;
    private String fileName;

    public ProxyImage(String fileName) {
        this.fileName = fileName;
    }

    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName);
        }
        realImage.display();
    }
}
  1. 装饰者模式（Decorator Pattern）
    概念
    装饰者模式通过将对象放入包含行为的特殊封装对象中来为原对象添加新的行为。
    示例
public interface Shape {
    void draw();
}

public class Rectangle implements Shape {
    public void draw() {
        System.out.println("Drawing Rectangle");
    }
}

public abstract class ShapeDecorator implements Shape {
    protected Shape decoratedShape;

    public ShapeDecorator(Shape decoratedShape) {
        this.decoratedShape = decoratedShape;
    }

    public void draw() {
        decoratedShape.draw();
    }
}

public class RedShapeDecorator extends ShapeDecorator {
    public RedShapeDecorator(Shape decoratedShape) {
        super(decoratedShape);
    }

    public void draw() {
        decoratedShape.draw();
        setRedBorder(decoratedShape);
    }

    private void setRedBorder(Shape decoratedShape) {
        System.out.println("Border Color: Red");
    }
}
  1. 策略模式（Strategy Pattern）
    概念
    策略模式定义了一系列算法，并将每一个算法封装起来，使它们可以互换。
    示例
public interface Strategy {
    int doOperation(int num1, int num2);
}

public class OperationAdd implements Strategy {
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

public class OperationSubstract implements Strategy {
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

总结
IoC 容器不仅可以管理单例模式，还可以结合工厂模式、抽象工厂模式、建造者模式、原型模式、代理模式、装饰者模式、策略模式等设计模式来实现更灵活和可扩展的依赖管理和控制反转。这些模式各有其适用场景和优缺点，可以根据具体需求选择合适的模式来实现 IoC。

菜菜小堡
关注
详解 Spring - Ioc(控制权反转) 和 DI(依赖注入)
Lzm的博客
07-19 382
这样做的目的是解耦组件之间的依赖，提高代码的可维护性和可扩展性。Spring框架的核心功能之一就是提供了一个IOC容器，通过配置文件或注解，开发者可以声明对象之间的依赖关系，让Spring容器来负责对象的创建和依赖注入，从而实现控制反转。在修改或更新依赖的时候，不需要修改大量的代码，只需要调整配置即可，减少了代码的改动范围，从而降低了出错的风险，提高了代码的可维护性。通过依赖注入，对象只需关注自身的业务逻辑，而不需要关心依赖的具体实现细节，从而降低了组件之间的耦合度，提高了代码的可维护性和灵活性。
php中Ioc(控制反转)和Di(依赖注入)
10-19
PHP中的控制反转（IoC）与依赖注入（DI）是面向对象编程中非常重要的设计模式，它们是为了解决传统编程中类与类之间过于紧密耦合的问题而设计的。在PHP中实现这些设计模式可以帮助开发者提高代码的可维护性和可扩展...
DI（控制反转容器）
sinat_38992528的博客
04-28 939
来自维基百科的解释：  个人觉得 知道是ng中的依赖注入就可以了   （容器！！！）实现方法[编辑]实现控制反转主要有两种方式：依赖注入和依赖查找。两者的区别在于，前者是被动的接收对象，在类A的实例创建过程中即创建了依赖的B对象，通过类型或名称来判断将不同的对象注入到不同的属性中，而后者是主动索取相应类型的对象，获得依赖对象的时间也可以在代码中自由控制。依赖注入[编辑]依赖注入有如下实现方式：基于...
一篇文章看懂IOC/DI 控制反转依赖注入
最新发布
m0_37800461的博客
02-28 232
控制反转（IoC）与依赖注入（DI）
IoC(控制反转) 和DI(依赖注入)
大为的博客
09-19 306
首先：第一个问题，参与者都有谁？ 1）对象 2）IOC/DI容器 3）某个对象的外部资源第二问题：依赖，谁依赖谁？为什么需要依赖？ 依赖嘛，很好理解的，对象依赖于IOC/DI容器，至于为什么要依赖呢？对象需要IOC/DI容器来提供对象需要的外部资源。第三个问题：注入，谁注入谁？又注入了什么呢？ 显而易见是IOC/DI容器注入对象，注入了what呢？肯定注入的是某个需要的东西那就是注入对象所需要的...
依赖注入（DI）和控制反转（IOC）
wlq_567的博客
12-19 194
可以分别指定服务类型（Service type）和实现类型（implementation type）,这两者可能相同，也可能不同，服务类型可以是类，也可以是接口，建议面向接口编程，更灵活。依赖注入（Dependency Injection,DI）是控制反转（inversion of Controller，IOC）思想的实现方式。（2）依赖注入（Dependency Injection,DI）;（1）服务定位器（ServiceLocator）；生活中的”控制反转“,自己发电——用电网的电。
什么是IOC(控制反转)、DI(依赖注入)
七一
08-11 631
学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念，对于初学Spring的人来说，总觉得IoC 、DI这两个概念是模糊不清的，是很难理解的，今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解。 一、分享Iteye的开涛对Ioc的精彩讲解 　　首先要分享的是Iteye的开涛这位技术牛人对Spring框架的IOC的理解，写得非常通俗易懂，以下内容全部来......
PHP控制反转（IOC）和依赖注入（DI）
10-20
在PHP编程中，控制反转（IOC）和依赖注入（DI）是两种重要的设计模式，它们有助于提高代码的可测试性、可维护性和可扩展性。理解这两种概念对于编写高质量的PHP应用程序至关重要。 控制反转（IOC）的核心思想是将...
Spring框架控制反转IOC和依赖注入DI详解
01-20
本文介绍了Spring框架中的控制反转IOC和依赖注入DI，欢迎阅读，共同学习，一起进步。 Spring框架基础参考：深入学习Spring基础 文章目录一.入门程序和IOC简介二.IOC-控制反转三.DI-依赖注入四. IOC和DI五.Spring...
PHP依赖注入(DI)和控制反转(IoC)详解
10-19
总结来说，依赖注入和控制反转是现代软件开发中重要的设计模式，尤其是在大型项目和框架中，它们提供了一种解耦合的有效手段。通过应用这两种模式，开发者可以更容易地管理和维护代码，使软件更加灵活和可扩展。在...
di_ioc_c#.zip
08-19
依赖注入和IoC乍一看似乎很复杂，但是它们很容易学习和理解。 在本文中，我们将通过在C＃中重构一个非常简单的代码示例来说明依赖注入和IoC容器。
依赖注入（DI）和控制反转（IoC）简介
大道至简
09-28 267
首先需要明白的是依赖注入和控制反转说的是同一件事。依赖注入（DI）是控制反转的实现方式之一。在容器启动将类创建到容器之中，在需要的地方，创建对应的类。 @Service public class UserServiceImpl implements IUserService { @Autowired private UserRepository userRepository; @Override public void addUser(UserDto dto) { User user =
依赖注入（DI）和控制反转（IoC）的理解
样young的博客
08-09 2万+
本文转自：https://blog.csdn.net/bestone0213/article/details/47424255        学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念，对于初学Spring的人来说，总觉得IoC 、DI这两个概念是模糊不清的，是很难理解的，今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解...
控制反转（Ioc）和依赖注入（DI）
QinWei_的博客
05-15 2615
一、Spring和SpringBoot简介 Spring简介【总】 概念：是一个java技术框架，简化了企业开发的难度和开发周期。 作用：1、分层解耦。2、简化框架的使用难度。 SpringBoot简介【总】 概念：基于Spring的框架。 作用：简化了Spring框架开发的难度（省去了Spring的很多配置） 二、控制反转（Ioc) IoC概念【总】 控制反转：将创建Bean对象的权利交给Spring，Spring创建Bean对象之后保存到Spring容器中，我们程序从Spring容器中获取需要的Bean
控制反转和依赖注入的理解(通俗易懂)
热门推荐
行者彡的博客
05-13 15万+
　学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念，对于初学Spring的人来说，总觉得IoC 、DI这两个概念是模糊不清的，是很难理解的，今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解。 一、分享Iteye的开涛对Ioc的精彩讲解 　　首先要分享的是Iteye的开涛这位技术牛人对Sp...
控制反转（Ioc）与依赖注入（DI）
weixin_48627356的博客
01-21 1112
1、什么是控制反转（Ioc） Ioc 是 Inversion of Control 的缩写，译为“控制反转”，还有的译为“控制反向”或者“控制倒置”。 在面向对象传统编程方式中，获取对象的方式通常是用new关键字主动创建一个对象。Spring中的Ioc方式对象的生命周期由Spring框架提供的Ioc容器来管理，直接从Ioc容器中获取一个对象，控制权从应用程序交给了Ioc容器。 Ioc理论上是借助于“第三方（代理）”实现具有依赖关系对象之间的解耦。即把各个对象类封装之后，通过Ioc容器来关联这些对象类。
依赖注入（DI）和控制反转（IOC）分别是什么？二者有什么区别？
caolun12344321的博客
08-31 1623
依赖注入（DI）和控制反转（IOC）分别是什么？二者有什么区别？ 依赖注入（DI）：假如有A和B俩个不同的类，A依赖与B，A中有一个方法使用到了B，就将对象B注入到A中，依赖注入就是程序运行过程中，如果遇到一个对象需要另一个对象协助时，不用代码中创建调用者，通过依赖与外部的注入来完成。 控制反转（IOC）：控制反转时Spring的核心，所有的类都会在Spring的容器来登记，来告诉Spring你是...
PHP中的IOC和DI：控制反转与依赖注入解析
在软件开发中，控制反转（Inversion of Control，简称IOC）和依赖注入（Dependency Injection，简称DI）是两种重要的设计模式，它们主要用于提升代码的灵活性、可测试性和可维护性。这两种模式在面向对象编程，尤其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值