实现简单的IOC容器（ByName）

实现功能：小黄开奥迪上班/下班
要求：可维护，可复用，可扩展，灵活性好

第一版
Audi

public class Audi {

    public void start() {
        System.out.println("启动奥迪");
    }

    public void shutDown() {
        System.out.println("启动奥迪");
    }

    public void turnLeft() {
        System.out.println("奥迪左转");
    }

    public void turnRight() {
        System.out.println("奥迪右转");
    }
}

人类

public class Person {

    void goHome() {
        Audi audi = new Audi();
        audi.start();
        audi.turnLeft();
        audi.turnRight();
        audi.shutDown();
    }

    void goWork() {
        Audi audi = new Audi();
        audi.start();
        audi.turnRight();
        audi.turnLeft();
        audi.shutDown();
    }

    void aNormalDay()
    {
        System.out.println("新的一天开始啦");
        System.out.println("------------");
        System.out.println("去工作");
        goWork();
        System.out.println("------------");
        System.out.println("回家");
        goHome();
        System.out.println("------------");
        System.out.println("一天结束啦");
    }
}

测试代码

public static void main(String[] args) {
        Person xiaoHuang=new Person();
        xiaoHuang.aNormalDay();
    }

缺点：
1.是人类对象创建的奥迪车
    (1)不是每个人都有车(考虑将有车的人继承与普通人/或者把回家,工作的行为抽象成接口，由不同的人来实现)
    (2)不是每个人有车的人都是奥迪(考虑将汽车抽象出来)
2.小黄如果要换车的话，需要修改代码过多
3.小黄new了两次奥迪车，其实应该是同一辆奥迪车(考虑把局部变量，变为类的私有属性)

违反  单一职责原则(人类创建车)
     开闭原则(需要修改代码)
     面向接口(都是实现类，没有使用接口)


第二版

汽车抽象类

public abstract class Car {
    public abstract void start();

    public abstract void shutDown();

    public abstract void turnLeft();

    public abstract void turnRight();
}

Audi

// 奥迪车世界上有很多辆
// 所以应该是类，每个奥迪车应该是对象
// 人这不一样，每个人都是一个单独的对象
// 所以判断该成对象还是类的时候可以想象是单数还是复数
// 单数则是对象，复数则是类
public class Audi extends Car{
    @Override
    public void start() {
        System.out.println("启动奥迪");
    }

    @Override
    public void shutDown() {
        System.out.println("启动奥迪");
    }

    @Override
    public void turnLeft() {
        System.out.println("奥迪左转");
    }

    @Override
    public void turnRight() {
        System.out.println("奥迪右转");
    }
}

BMW

public class BMW extends Car{
    @Override
    public void start() {
        System.out.println("启动宝马");
    }

    @Override
    public void shutDown() {
        System.out.println("启动宝马");
    }

    @Override
    public void turnLeft() {
        System.out.println("启动宝马");
    }

    @Override
    public void turnRight() {
        System.out.println("启动宝马");
    }
}

抽象人类

public abstract class Person {
    abstract void goHome();
    abstract void goWork();
    //设计模式：模板模式
    public void aNormalDay()
    {
        System.out.println("新的一天开始啦");
        System.out.println("------------");
        System.out.println("去工作");
        goWork();
        System.out.println("------------");
        System.out.println("回家");
        goHome();
        System.out.println("------------");
        System.out.println("一天结束啦");
    }
}

有车一族

public class PersonWithCar extends Person{
    //优点
    //1这个car不应该有人类创建，而是通过传入指定的car
    //2回家，工作使用的是同一辆车
    //3换车不需要修改代码，遵守开放闭合原则
    private Car car;

    public PersonWithCar(Car car) {
        this.car = car;
    }


    @Override
    void goHome() {
        car.start();
        car.turnRight();
        car.turnLeft();
        car.shutDown();
    }

    @Override
    void goWork() {
        car.start();
        car.turnRight();
        car.turnLeft();
        car.shutDown();
    }
}

小黄开奥迪上班/下班
小张开宝马上班/下班
模板模式

优点
1这个car不应该有人类创建，而是通过传入指定的car
2回家，工作使用的是同一辆车
3换车不需要修改代码，遵守开放闭合原则
4.设置每个人的一天（上班，回家）的抽象，通过对不同交通工具的人来具体实现（模板模式）

IOC容器版

public class MyIocContainer {

    //保证只被初始化一次
    //跟随类的初始化而初始化
    private static Map<String, Object> container = new ConcurrentHashMap<>();

    public Object getBean(String id) {
        return container.get(id);
    }

    public void setBean(Class<?> clazz, String beanId, String... paramBeanId) {
        //通过id获取所有在bean容器的实例
        Object[] objects = new Object[paramBeanId.length];
        for (int i = 0; i < paramBeanId.length; i++) {
            objects[i] = getBean(paramBeanId[i]);
        }

        //使用不同的构造函数构造，最终只有一个能够成功
        Object bean = null;
        for (Constructor constructor : clazz.getConstructors()) {
            try {
                bean = constructor.newInstance(objects);
            } catch (InstantiationException e) {
            } catch (IllegalAccessException e) {
            } catch (InvocationTargetException e) {
            }
        }
        if (bean == null)
            throw new RuntimeException("实例化失败");
        container.put(beanId, bean);
    }
}

很明显这次的IOC容器使用的模式是使用ByName，名字匹配类型（查阅资料发现ByName效率的确比ByType高，所有对使用@resource的byName）

写了这个demo后对倚赖注入，反转控制有了更深的理解
倚赖注入是目标：通过从容器注入bean，对象间的聚合和合成关系，是一种弱耦合的关系
反转控制是手段：通过bean容器来控制bean的生命周期

   在容器中对象的创建只会创建一次（singleton模式下），如果name指定不对，就会出现bean注入失败的错误(我经常犯的错QAQ)

1.控制bean的生命周期指的不是类加载，指的是控制对象bean的生命周期

原来：客户端管理车的生产，现在由容器管理
优点：大大解耦类与类的倚赖
2.所有的对象都由容器管理
优点：解耦，每个类只关注自己的业务逻辑

代码地址：https://gitee.com/gang_bryant/DesignMode/tree/master/src/MyIoc