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

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();
    }
}

@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
    }
}