一起来学设计模式之依赖注入模式

程序员皮卡秋
1,414 阅读8分钟

前言

目前正在出一个设计模式专题系列教程, 篇幅会较多, 喜欢的话，给个关注❤️ ~

本节给大家讲一下设计模式中的依赖注入模式,并结合实际业务场景给大家讲解如何使用~

本专题的所有案例代码主要以Java语言为主, 好了, 废话不多说直接开整吧~

依赖注入模式

Dependency Injection（依赖注入）是一种设计模式，用于解决对象之间的耦合关系问题，一个对象通常会通过New操作符显式创建出它所需要的相关对象，这样会导致对象之间高度耦合、难以重用、难以测试等问题。而Dependency Injection则是一种反向控制的思想，即对象不再直接操作其他对象，而是通过容器（例如Spring）来进行依赖注入，容器在运行时将需要的依赖关系注入对象中，从而降低对象之间的耦合度，提高了对象的重用性和可测试性。

public interface UserService {
    void sayHello();
}

public class UserServiceImpl implements UserService {
    @Override
    public void sayHello() {
        System.out.println("Hello, world!");
    }
}


public class UserController {
    private UserService userService;

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public void sayHello() {
        userService.sayHello();
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建一个 UserController 对象
        UserController controller = new UserController();
         // 创建一个 UserServiceImpl 对象并注入到 UserController 中
        UserService userService = new UserServiceImpl();
        controller.setUserService(userService);
         // 调用 UserController 的 sayHello 方法
        controller.sayHello();
    }
}

Spring中的IOC原理

Spring的依赖注入(DI)原理，其核心是IOC(控制反转)。控制反转正如其名，是一种反传统的控制方式。传统的控制方式是：应用程序通过new关键字或工厂方法等方式主动创建对象并维护对象之间的依赖关系。而控制反转则是由外部容器负责创建和维护对象，从而将对象的创建和依赖关系的维护的控制权交由Spring容器来统一管理。

Spring的依赖注入(DI)实现原理主要基于以下几个步骤：

  • 配置文件解析：Spring会解析XML配置文件，读取配置中的信息(如类名、属性等)，并创建相应的Java对象。

  • 对象实例化：配置文件解析完成后，Spring会根据配置文件中的信息来创建相应的Java对象，并将这些对象存储到Spring容器中。

  • 对象依赖关系的维护：在创建对象时，Spring会扫描对象的属性，通过反射机制将依赖的对象注入到属性中。

  • 对象生命周期的管理：Spring会管理对象的生命周期，即对象的创建、初始化、使用和销毁等过程。

下面我们就来简单的实现一下它的原理，主要分为以下几个步骤:

  • 定义Java类的接口及实现类
  • 定义IOC容器，即存储Java对象的容器
  • 使用反射机制在IOC容器中创建Java对象
  • 对象依赖关系的维护，即在创建对象时，扫描对象的属性并注入依赖的对象

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {

    /**
     * Declares whether the annotated dependency is required.
     * <p>Defaults to {@code true}.
     */
    boolean required() default true;

}

// 定义Java类的接口及实现类
public interface UserService {
    void sayHello();
}


public class UserServiceImpl implements UserService {

    @Autowired
    private UserService userService1;

    @Override
    public void sayHello() {
        userService1.sayHello();
    }
}


public class UserService1Impl implements UserService {

    @Override
    public void sayHello() {
        System.out.println("Hello, userService1");
    }
}

// 使用反射机制在IOC容器中创建Java对象
public class BeanFactory {
    public static Object getBean(String className) {
        Object object = null;
        try {
            Class clazz = Class.forName(className);
            object = clazz.newInstance();
        } catch (ClassNotFoundException e) {
            // handle exception
        } catch (InstantiationException e) {
            // handle exception
        } catch (IllegalAccessException e) {
            // handle exception
        }
        return object;
    }
}

// 定义IOC容器类，即存储Java对象的容器
// 对象依赖关系的维护，即在创建对象时，扫描对象的属性并注入依赖的对象
public class Container {
    private Map<String, Object> beans = new HashMap<>();
    public void register(String beanName, Object bean) {
        beans.put(beanName, bean);
    }
    public Object getBean(String beanName) {
        Object object = beans.get(beanName);
        // 获取对象的所有属性
        Field[] fields = object.getClass().getDeclaredFields();
        // 遍历属性，注入依赖的对象
        for (Field field : fields) {
            if (field.isAnnotationPresent(Autowired.class)) {
                String fieldName = field.getName();
                Object dependency = getBean(fieldName);
                if (dependency != null) {
                    try {
                        field.setAccessible(true);
                        field.set(object, dependency);
                    } catch (IllegalAccessException e) {
                        // handle exception
                    }
                }
            }
        }
        return object;
    }
}


public class Main {
    public static void main(String[] args) {
        Container container = new Container();
        // 注册Java对象到IOC容器
        container.register("userService", BeanFactory.getBean("com.java.design.dependency.UserServiceImpl"));
        container.register("userService1", BeanFactory.getBean("com.java.design.dependency.UserService1Impl"));

        // 从IOC容器中获取Java对象并使用
        UserService userService = (UserService) container.getBean("userService");
        userService.sayHello();

        // Hello, userService1
    }
}

总之，Spring的依赖注入(DI)的原理主要基于IOC，即通过Java反射机制，将对象的创建和依赖关系的维护的控制权交由Spring容器来统一管理。这种方式有利于减少代码的重复性，提高代码的可读性、可维护性和可扩展性。

结束语

设计模式其实并不难，大家在学习的时候一定要在理解的基础上去写代码，不要去背代码。本专题到这里就结束了，大家要学会灵活使用设计模式去写代码，多理解多思考~ 下期我们进入查漏补缺(八股文)专题

本着把自己知道的都告诉大家，如果本文对您有所帮助，点赞+关注鼓励一下呗~

相关文章

项目源码(源码已更新 欢迎star⭐️)

Kafka 专题学习

项目源码(源码已更新 欢迎star⭐️)

ElasticSearch 专题学习

项目源码(源码已更新 欢迎star⭐️)

往期并发编程内容推荐

推荐 SpringBoot & SpringCloud (源码已更新 欢迎star⭐️)

博客(阅读体验较佳)

avatar
文章
阅读
粉丝