spring已经成为了java开发人员必备的框架，spring基本引领着整个java开发方向的流程，现在spring提供了五花八门的模块来帮助开发人员进行各种java项目的构建，在spring5中提出了非阻塞的web框架。这里将会从头开始讲解spring5的一些比较重要的知识，这一讲将会主要介绍Spring 的IOC。

Spring的安装

Spring的安装非常的简单，只要使用在maven中引入相应的java即可完成安装

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.0.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>5.0.2.RELEASE</version>
</dependency>

下面我们创建一个Spring的java文件，在Spring4之后，就可以使用基于Annotation的方式来完全替换原有的xml的方法，但是我们这部分的内容会两个方式都简单进行介绍。我们首先通过基于Annotation的方式来创建一个Spring的项目，以此验证spring是否安装成功。

@Configuration
public class HelloSpringConfig {
    
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(HelloSpringConfig.class);
        String hello = ctx.getBean("hello",String.class);
        System.out.println(hello);
    }

    @Bean("hello")
    public String getHello() {
        return "hello";
    }
}

@Configuration声明的类就表示该类是一个配置类，就等于原来的beans.xml文件，类中的方法getHello上使用@Bean，这说明该方法会返回一个String类型的对象。在main方法中通过AnnotationConfigApplicationContext 将该配置文件加载进去到spring的上下文中，spring的上下文就等于一个大容器，spring通过这个容器来管理所有的对象，通过getBean方法可以获取刚才创建的bean，然后输出结果。

以上程序将会输入hello这个字符串，只要能运行成功说明spring 的环境已经正确的安装完成，下面我们将介绍spring 的IOC的作用和意义。

IOC介绍

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

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

Ioc介绍类图

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配置文件来完成同样的操作。

基于xml的配置方式

首先在资源文件中创建beans.xml，并且引入spring的schema

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

在该文件中可以直接创建具体的对象和依赖关系

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="weapon" class="org.konghao.spring.xml.Knife"/>
    <bean id="knight" class="org.konghao.spring.xml.Knight">
        <property name="weapon" ref="weapon"/>
    </bean> 
</beans>

创建了两个bean，一个是weapon，weapon的类型是Knife，另外一个是knight，其中knight依赖于weapon，接着只要通过spring的ApplicationContext来创建对象就会被spring所管理。

public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
        Knight k = (Knight)ctx.getBean("knight");//根据beans.xml中的id来获取对象
        k.fight();
    }
}

在spring3之后就提供了基于Annotation的方式来进行对象的管理，这样可以简单大量的配置操作。

基于Annotation的方式

首先在beans.xml中开启Annotation的支持，并且设定需要扫描的包，需要加入context的schema

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <context:annotation-config/>
    <context:component-scan base-package="org.konghao.spring.annotation.*"/>
</beans>

之后在需要spring管理对象中添加@Component的Annotation，在需要注入的对象的setter方法上添加@Autowired,首先看看几种武器的设置

@Component("axe")
public class Axe implements Weapon {
    ...
}
@Component("gun")
public class Gun implements Weapon {
    ...
}
@Component("knife")
public class Knife implements Weapon {
    ...
}

这里创建了三个对象axe,gun和knife，但是此时Knight的setWeapon使用了@Autowired进行注入，由于方法是setWeapon，所以会找weapon的对象，显然没有，此时需要指定要注入的对象类型,使用@Qualifier来进行设定

@Component("knight")
public class Knight {
    private String username;
    private Weapon weapon;
    ...
    @Autowired
    @Qualifier("axe")
    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
}

main函数的代码不用进行任何修改，可以直接运行。在spring4之后提供了基于java的配置方式，此时连xml 文件都不需要，下面就来看看这种方式

基于java配置文件的方式

在spring的新版本中，提供纯java的支持方式，此时甚至都不需要添加如何的xml文件，但需要专门创建一个java的配置类，在该类上增加一些配置说明。

@Configuration
@ComponentScan("org.konghao.spring.java")
public class BaseConfiguration {
}

其他的类的设定不变，最后在调用的时候有一些基本的区别。

public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(BaseConfiguration.class);
        Knight k = (Knight)ctx.getBean("knight");
        k.fight();
        ((AnnotationConfigApplicationContext)ctx).close();
    }
}

以上内容就是spring的IOC的主要内容，IOC是spring的最基础，它让所有的类被spring所管控，这样spring就可以非常方便的为开发人员提供各种功能，下一部分看spring的另外一个重要的功能，AOP。