Spring：工厂模式哪里解耦了？

菜瓜：我一定是太菜了，为什么别人说Spring屏蔽了new关键字创建对象就很丝滑？我完全get不到这个操作的好处啊，我自己写new它也很香啊

水稻：emmmm，换个角度想啊，如果把现在用的注解@Autowired@Resource给干掉，你想在Controller里面引用Service，你会怎么做？new 一个？

菜瓜：对啊，我new一个怎么了，不也可以用？

水稻：那如果，我另一个Controller里面也要用同一个Service，是不是再new一个？有很多个这种Controller是不是new很多个Service？

菜瓜：这。。。我有另一个方法，把Service放在一个容器里，Controller用的时候从容器里面拿？

水稻：哇塞，Spring应该请你去写他们的框架啊

菜瓜：Spring是这么做的？

水稻：不知道你听没听过简单工厂这种设计模式，用于将对象的创建和使用隔离开来，达到解耦的目的。工厂负责创建对象，并且可以干预创建的逻辑

菜瓜：嗯，简单工厂，工厂方法，抽象工厂我都略懂？

水稻：。。。。Talk is cheap , show me your code ! 就简单工厂就行了

菜瓜：下面这样的

package club.interview.design_pattern.chapt2_factory_pattern;

/**
 * @author QuCheng on 2020/6/13.
 */
public class SimpleFactory {

    abstract static class AbstractPhone {
        abstract void call();
    }

    static class XiaoMi extends AbstractPhone {
        @Override
        void call() {
            System.out.println("小米手机打电话。。。。");
        }
    }

    static class Meizu extends AbstractPhone {
        @Override
        void call() {
            System.out.println("魅族手机打电话。。。。");
        }
    }

    public AbstractPhone getPhone(String phoneType) {
        if ("小米".equals(phoneType)) {
            return new XiaoMi();
        } else if ("魅族".equals(phoneType)) {
            return new Meizu();
        }
        return null;
    }

    public static void main(String[] args) {
        SimpleFactory s = new SimpleFactory();
        s.getPhone("小米").call();
        s.getPhone("魅族").call();
    }

}

水稻：那你肯定知道，这种写法的局限性。依靠phoneType来创建对象不利于扩展。如果现在的需求生产的对象不限定返回类型，给啥就创建啥，怎么做

菜瓜：动态创建对象？那不是反射吗？是不是这样

package club.interview.design_pattern.chapt2_factory_pattern;

/**
 * @author QuCheng on 2020/6/13.
 */
public class SpringFactory {

    static class XiaoMi {
        void call() {
            System.out.println("小米手机打电话。。。。");
        }
    }

    static class Meizu  {
        void call() {
            System.out.println("魅族手机打电话。。。。");
        }
    }

    static class HuaWei  {
        void call() {
            System.out.println("华为手机打电话。。。。");
        }
    }

    public <T> T getPhone(Class<T> clazz) {
        try {
            return clazz.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static void main(String[] args) {
        SpringFactory s = new SpringFactory();
        s.getPhone(XiaoMi.class).call();
        s.getPhone(Meizu.class).call();
        s.getPhone(HuaWei.class).call();
    }

}

水稻：秀啊！！厉害厉害。相比你也知道，此时如果我想在创建过程中加入一点点自己的逻辑，那也是很丝滑的。

菜瓜：哦，原来是这样。Spring利用工厂将对象的创建和使用进行隔离，还可以定制一些bean对象的创建逻辑。学到了，学到了。

水稻：我也学到了，反射和设计模式用的6啊。当然，Spring的工厂远没有你现在想的这么简单。你再仔细品品

总结：

• Spring利用反射创建对象，并将创建好的对象放入一个大工厂，实现了对象创建和使用的解耦。后需要使用的时候可以方便的通过BeanFactory.getBean()获取。在此之上还扩展了堆注解的支持，使用注解就可以注入对象。这就是传说中的DI(Dependency Inject)依赖注入