手动实现springIoc

手动实现springIoc

IOC介绍

IOC是控制反转，它是spring非常重要的一个特性，它是spring学习的基础，Ioc也成为DI（依赖注入），简单来说就是把spring变成一个容器，由spring来控制对象的创建和他们之间的依赖关系，下面我们通过一个实例来给大家讲解spring的IOC的使用和意义。

我们希望做一个简单的游戏，这个游戏中有一个战士(Knight)，战士有不同的武器可以战斗，我们通过java的代码来实现，java代码非常简单

public class Knight {
    private String username;
    private Weapon weapon;
    
    public Knight(String username,Weapon weapon) {
        this.username = username;
        this.weapon = weapon;
    }
    //省略了getter和setter
    public void fight() {
        weapon.attack();
    }
}

和Weapon相关的代码

public interface Weapon {
    void attack();
}

public class Axe implements Weapon {
    public void attack() {
        System.out.println("提起斧头，向人砍去");
    }
}

public class Knife implements Weapon {
    public void attack() {
        System.out.println("提着大刀向敌人劈去");
    }
}

public class Gun implements Weapon {
    public void attack() {
        System.out.println("哒哒哒哒哒!");
    }
}

下面就是Knight中如何创建Weapon的问题，最原始的方案就是在使用new来创建具体的Weapon实例

public class Test {
    public static void main(String[] args) {
        Weapon w = new Axe();
        Knight k = new Knight("Leon",w);
        k.fight();
    }
}

这种方案最大的问题就是依赖于一个具体的实现类，将来如果要修改Weapon的实现类所有的代码都需要调整，丧失了灵活性，第二种方案是基于工厂的模式来创建，这里使用简单工厂来演示。

public class SimpleFactory {
    public static Weapon getWeapon() {
        return new Knife();
    }
}

public class Test {
    public static void main(String[] args) {
        //Weapon w = new Axe();
        Weapon w = SimpleFactory.getWeapon();
        Knight k = new Knight("Leon",w);
        k.fight();
    }
}

这种方案将来如果希望修改Weapon的实现类只要修改一个地方即可，这种方法虽然解决了灵活性的问题，但将来修改的时候需要调整源代码，所以这种方式也不是很理想，最佳的方案是将具体的类写到一个配置文件中，通过读取配置文件来创建具体的对象。创建一个factory.properties文件来存储具体的对象

weapon = org.konghao.spring.original.Gun

为了方便确定那些对象需要创建，可以自己定义一个Annotation来指定要创建的对象

@Retention(RUNTIME)
public @interface Inject {
    public String value() default "";
}

然后在需要创建的对象的setter方法上添加该Annotation

@Inject
public void setWeapon(Weapon weapon) {
  this.weapon = weapon;
}

让所以需要添加这个对象的类继承于一个基类，在这个基类中来创建所有的对象

public class Base {
    public Base() {
        try {
            Properties prop = new Properties();
            prop.load(Base.class.getClassLoader()
                    .getResourceAsStream("org/konghao/spring/original/factory.properties"));
            //通过反射来读取需要创建对象的信息
            Method []ms =  this.getClass().getDeclaredMethods();
            for(Method m:ms) {
                if(m.isAnnotationPresent(Inject.class)) {
                    Inject in = m.getAnnotation(Inject.class);
                    String name = null;
                    //获取对象key
                    if("".equals(in.value())) {
                        //没有指定，就默认通过setXXX方法来处理，把set去掉，然后第一个字母小写
                        name = m.getName();
                        name = name.substring(3);
                        name = name.substring(0, 1).toLowerCase()+name.substring(1);
                    } else {
                        name = in.value();
                    }
                    String o = prop.getProperty(name);
                    if(o!=null) {
                        //创建对象
                        Object obj = Class.forName(o).newInstance();
                        //调用方法创建对象
                        m.invoke(this, obj);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Base是所有需要创建对象的基类，此处Knight需要继承于Base这个基类，只要创建Knight，就会自动调用父类不带参数的构造方法来完成对象的注入。这就是依赖注入的一种通过这种方式，只要继承于Base这个类的所有类，都支持这种依赖注入的方式，这就是spring的DI所做的事情，spring提供了一个大容器来管理所有的对象依赖，接下来我们首先通过spring的xml配置文件来完成同样的操作。