spring已经成为了java开发人员必备的框架，spring基本引领着整个java开发方向的流程，现在spring提供了五花八门的模块来帮助开发人员进行各种java项目的构建，在spring5中提出了非阻塞的web框架。这里将会从头开始讲解spring5的一些比较重要的知识，这一讲将会主要介绍Spring 的IOC。
Spring的安装
Spring的安装非常的简单，只要使用在maven中引入相应的java即可完成安装
org.springframework
spring-context
5.0.2.RELEASE
org.springframework
spring-core
5.0.2.RELEASE
下面我们创建一个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的代码来实现，类图如下图所示
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
在该文件中可以直接创建具体的对象和依赖关系
创建了两个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
之后在需要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。