spring

IOC控制反转

这里先说一下IOC，再说IOC在spring框架中的使用。

IOC的概念

IOC这个缩写有很多意思，比如

• 智慧城市智能运行中心(IOC)
• 奥林匹克运动的领导机构

但是呢，我们这里说的是面向对象编程中的一种设计原则。他的全称是Inversion Of Control即控制反转。这里有两个单词控制和反转。这两个单词单独拿出来会发现，都缺少主语。比如

• 谁控制了谁?
• 什么东西发生反转了呢?

控制

这里说一下第一个问题，谁控制了谁呢？看下面的代码

public class main{public static void main(String[] args) {Person person = new Person();person.setName("tony");System.out.println(person.getName());}
}class Person{private String name;public void setName(String name) {this.name = name;}public String getName() {return this.name;}
}

很显然，在这里，Person类的person对象的一切都控制在main函数里面。main函数创建它，使用它，销毁它。所以在当前上下文中，main控制了person。

反转

上面的写法main函数控制了person对象，这是一种紧耦合的关系，如果person发生了改变，我们就需要改变main。反转是控制权的反转。现在person的控制权在main这里，我们将它反转一下。不在用main控制它。那么我们加一个简单工厂看一下呢。

class Factory{public static Person createPerson() {return new Person();}
}public static void main(String[] args) {Person person = Factory.createPerson();person.setName("tony");System.out.println(person.getName());
}

这里可以看到person的控制权转交给了Factory工厂，而main只有使用权了。当然了作为示例代码，这里的控制只做了创建。

现在，由main控制person改为了Factory控制person。如果person发生了改变，我们只需要改变Factory，而不需要动业务逻辑。

当然了，这种程度的解耦依然不够，因为main还是和Factory有耦合关系，他还控制了Factory。我们可以扩大这个简单工厂，扩大后的简单工厂就不再是工厂了，而叫做容器。我们把所有的控制权都交给容器，让容器控制所有的类，对象。而在使用的时候我们去告诉容器我们要使用哪个对象，让容器给我们提供就可以了。

DI

依赖注入 DI全称Dependency Injection就可以实现我们告诉容器我们需要的对象，然后容器把对象注入给我们的功能。

具体的依赖注入实现方式每个语言，每个框架可能都不一样，这里以spring为例

public class main{@Autowiredprivate Person person;public static void main(String[] args) {person.setName("tony");System.out.println(person.getName());}
}

可以看到，我们通过@Autowired注解告诉容器，我们需要一个Person类型的对象，然后让容器把这个对象注入到我们的person属性中。这里仅做示例使用，具体情况请以实际开发中为准，实际开发中应使用接口类型。

容器中的实现方式就类似刚才工厂中的，假设你需要Person类型的对象，就new Person返回，当然了，要更加复杂，比如可以根据名称来反射创建对象，可以更好的管理对象的生命周期，可以实现单例对象等等。

spring中的IOC

Spring中的IOC实现也是通过容器，但是怎么把类注入到容器中呢，也就是怎么告诉容器，你需要实例化哪些类呢？有两种方式，一种是XML配置方式，一种是注解方式。

XML配置方式

先创建一个XML文件，比如:

touch bean.xml

接下来编辑它。

vim bean.xml

无参数构造方式

重点在这个配置，通过bean这个标签来告诉容器我要把哪些类注册到容器中，其中id就是注册后的唯一标识，我们获取的时候也可以通过指定id来从容器中获取对象。而class是告诉容器，我们具体要注入的类的路径。但是这时候没有指定参数，也就是说类似于Person person = new Person()这样的注册，需要有无参构造器。

使用的时候需要借助于Spring提供的容器获取,可以看一下效果是一样的。

public class main{public static void main(String[] args) {//这里先加载我们的XML配置文件BeanFactory ac = new ClassPathXmlApplicationContext("bean.xml");//通过容器获取一个对象,第一个参数也就是配置的id,第二个就是类Person person = ac.getBean("person", Person.class);person.setName("tony");System.out.println(person.getName());}
}

构造器构造参数方式

同样在上面的XML文件中进行修改，但这次我们需要加上参数，并且告诉容器是通过构造器来构造参数的，而不是set的方式。

我们只需要在原来的bean标签中，加入我们要传给构造器的参数就可以了。

使用constructor-arg标签，name就是参数名，value是对应的值。

我们还需要改造一下原来的Person类，增加一个构造函数.

class Person{private String name;public Person(String name) {this.name = name;}public void setName(String name) {this.name = name;}public String getName() {return this.name;}
}

看一下现在的main函数

public class main{public static void main(String[] args) {//这里先加载我们的XML配置文件BeanFactory ac = new ClassPathXmlApplicationContext("bean.xml");//通过容器获取一个对象,第一个参数也就是配置的id,第二个就是类Person person = ac.getBean("person", Person.class);// 这里不需要setName了，因为通过构造器注入参数了// person.setName("tony");System.out.println(person.getName());}
}

但是如果我们需要构造一个其他类的对象作为参数该怎么配置呢，毕竟我们总不能在value上面写new Class()吧哈哈。但是我们知道一个bean就是一个对象，那我们可以传一个bean进来就可以了。

来看一下配置方式.不再使用value了，因为value只能传基本类型这些，而其他的对象需要使用ref来传参。ref的值就是其他bean的id。

同样需要改造一下构造函数，增加一个avatar参数。

class Avatar{private String url;public Avatar(String url) {this.url = url;}
}class Person{private String name;private Avatar avatar;public Person(String name, Avatar avatar) {this.name = name;this.avatar = avatar;}public void setName(String name) {this.name = name;}public String getName() {return this.name;}public String getAvatar() {return this.avatar.url;}
}

执行一下main函数。

public class main{public static void main(String[] args) {//这里先加载我们的XML配置文件BeanFactory ac = new ClassPathXmlApplicationContext("bean.xml");//通过容器获取一个对象,第一个参数也就是配置的id,第二个就是类Person person = ac.getBean("person", Person.class);// 这里不需要setName了，因为通过构造器注入参数了// person.setName("tony");System.out.println(person.getName());System.out.println(person.getAvatar());}
}

set方式传参

除了通过构造器传参，我们还可以写set函数来传参，比如setName和setAvatar。

class Avatar{private String url;// public Avatar(String url) {//     this.url = url;// }//增加set函数public void setUrl(String url) {this.url = url;}
}class Person{private String name;private Avatar avatar;// public Person(String name, Avatar avatar) {//     this.name = name;//     this.avatar = avatar;// }public void setName(String name) {this.name = name;}public String getName() {return this.name;}public void setAvatar(Avatar avatar) {this.avatar = avatar;}public String getAvatar() {return this.avatar.url;}
}

修改XML配置文件，不在使用constructor-arg标签，而是换成property。不过除了标签名变了，其他的属性name,value,ref都是不变的。

执行一下main函数。

public class main{public static void main(String[] args) {//这里先加载我们的XML配置文件BeanFactory ac = new ClassPathXmlApplicationContext("bean.xml");//通过容器获取一个对象,第一个参数也就是配置的id,第二个就是类Person person = ac.getBean("person", Person.class);// 这里不需要setName了，因为通过构造器注入参数了// person.setName("tony");System.out.println(person.getName());System.out.println(person.getAvatar());}
}

自动注入

可以通过配置XML文件来使用自动注入，就不需要手动增加或的标签了，只需要配置一个属性autowire就可以了。但是这种的只适用于注入其他的bean。

autowire只有两个值，一个是byName，是通过bean的名称进行注入，比如你的属性名是avatar，就会查找id=avatar这个类。还有一个是byType，是通过bean的类型进行注入，比如类型是Avatar，那么就会查找class=Avatar的bean进行注入。

XML读取外部配置文件

通过XML可以读取外部的配置文件，这样的话像数据库，redis连接这些就可以把host,name,password这些写到外部的配置文件中。

配置文件使用.properties后缀。比如spring.properties。

增加一个配置文件spring.properties。

spring.person.name=tony

修改XML直接从配置中读取person.name来注入。读取的时候还需要在XML中增加context命名空间。并通过context命名空间来读取配置文件

注解方式

注解方式要比XML方式简单的多，其中原理就是不再手动配置，而是通过注解告诉Spring我是一个bean。快来注册我吧。

主要是这4个注解告诉Spring

• @Component 单纯的说我是一个bean
• @Service 和上面的一样，不过一般用在service类中，更加语义化
• @Controller 和上面的一样，一般用在controller类中
• @Repository 我也是一个bean

接下来我们告诉Spring，你需要扫描出所有带上面注解的类，把他们注册到容器中。这一步需要修改XML文件,需要配置标签，并且通过base-package属性告诉Spring我们要扫描哪个目录

在类上面增加注解

@Component
class Avatar{private String url;// public Avatar(String url) {//     this.url = url;// }//增加set函数public void setUrl(String url) {this.url = url;}
}@Component
class Person{private String name;private Avatar avatar;// public Person(String name, Avatar avatar) {//     this.name = name;//     this.avatar = avatar;// }public void setName(String name) {this.name = name;}public String getName() {return this.name;}public void setAvatar(Avatar avatar) {this.avatar = avatar;}public String getAvatar() {return this.avatar.url;}
}

还可以自己指定扫描哪些注解，通过context:include-filter标签来指定。type类型写注解，expression指定扫描哪个注解。把标签放在context:component-scan这个里面就可以了。还需要在context:component-scan标签中指定，禁用默认的扫描方式。指定use-default-filters的属性为false.

还可以排除一些注解不进行扫描，通过context:exclude-filter标签来指定。type同样写注解，expression指定排除的注解。

把类注册到容器中以后，我们还需要在使用的时候告诉容器，我们需要从容器中获取这个类，有5个注解

• @Autowired Spring提供的，基于类型注入的，可以放在setter方法上
• @Qualifier Spring提供的，基于名称注入的，一般和@Autowired配合使用来通过value参数指定名称
• @Resource Java提供的，可以基于类型或名称注入的,可以通过name参数来指定名称，可以放在setter方法上
• @RequiredArgsConstructor lombok提供的，基于类型注入，通过增加一个构造函数来注入。
• @Value Spring提供的，注入基本类型的注解，一般用来从配置文件取值。

@RequiredArgsConstructor是lombok提供的，兼容性较差，像写单元测试的时候就用不了，它会给你的类增加一个构造方法，而且只会给final类型的属性进行注入。

@Component
//增加注解
@RequiredArgsConstructor
class Person{private String name;//错误使用，因为没有final// private Avatar avatar;//正确使用，加上finalprivate final Avatar avatar;// public Person(String name, Avatar avatar) {//     this.name = name;//     this.avatar = avatar;// }public void setName(String name) {this.name = name;}public String getName() {return this.name;}public void setAvatar(Avatar avatar) {this.avatar = avatar;}public String getAvatar() {return this.avatar.url;}
}

这个时候可以编译完以后查看.class文件，看到的是这样的

@Component
// 注解没有了
// @RequiredArgsConstructor
class Person{private String name;//错误使用，因为没有final// private Avatar avatar;//正确使用，加上finalprivate final Avatar avatar;//增加了一个构造函数public Person(final Avatar avatar) {this.avatar = avatar;}public void setName(String name) {this.name = name;}public String getName() {return this.name;}public void setAvatar(Avatar avatar) {this.avatar = avatar;}public String getAvatar() {return this.avatar.url;}
}

@Autowired是spring提供的，在spring中不管是写业务还是写单元测试都可以使用，它可以放在要注入的属性上面，也可以放在setter方法上面。使用他的时候不需要final修饰。

@Component
class Person{private String name;//在需要的属性上面增加这个注解，不需要final修饰@Autowiredprivate Avatar avatar;//错误使用，加上final// @Autowired// private final Avatar avatar;// public Person(String name, Avatar avatar) {//     this.name = name;//     this.avatar = avatar;// }public void setName(String name) {this.name = name;}public String getName() {return this.name;}//也可以加在setter方法上面@Autowiredpublic void setAvatar(Avatar avatar) {this.avatar = avatar;}public String getAvatar() {return this.avatar.url;}
}

@Qualifier注解配合@Autowired使用，比如我们有一个头像的接口

interface IAvatar {String getUrl();
}class maleAvatar implements IAvatar{public String getUrl() {return "male avatar";}
}class femaleAvatar implements IAvatar{public String getUrl() {return "female avatar";}
}

这个时候我们在注入的时候如果只根据IAvatar来注入，容器就不知道我们需要哪个实现类了，所以我们需要指定类名.

@Component
class Person{private String name;//在需要的属性上面增加这个注解，不需要final修饰@Autowired//指定要注入的实现类@Qualifier(value="maleAvatar")private IAvatar avatar;//错误使用，加上final// @Autowired// private final Avatar avatar;// public Person(String name, Avatar avatar) {//     this.name = name;//     this.avatar = avatar;// }public void setName(String name) {this.name = name;}public String getName() {return this.name;}//也可以加在setter方法上面@Autowired@Qualifier(value="maleAvatar")public void setAvatar(IAvatar avatar) {this.avatar = avatar;}public String getAvatar() {return this.avatar.url;}
}

@Resource更像是上面两个的合体，并且是由java提供的。也是可以放在属性和setter上面，并且不需要final修饰。

@Component
class Person{private String name;//在需要的属性上面增加这个注解，不需要final修饰@Resourceprivate Avatar avatar;//错误使用，加上final// @Resource// private final Avatar avatar;public void setName(String name) {this.name = name;}public String getName() {return this.name;}//也可以加在setter方法上面@Resourcepublic void setAvatar(Avatar avatar) {this.avatar = avatar;}public String getAvatar() {return this.avatar.url;}
}

同样的，如果我们有多个实现类，需要指定可以通过它的name参数来指定。比如

@Component
class Person{private String name;//在需要的属性上面增加这个注解，不需要final修饰@Resource(name="femaleAvatar")private IAvatar avatar;//错误使用，加上final// @Resource// private final Avatar avatar;public void setName(String name) {this.name = name;}public String getName() {return this.name;}//也可以加在setter方法上面@Resource(name="femaleAvatar")public void setAvatar(IAvatar avatar) {this.avatar = avatar;}public String getAvatar() {return this.avatar.url;}
}

@Value可以注入基本类型，比如字符串这种，但是更多的是从配置文件中取值。比如

@Component
class Person{//直接注入tony字符串到name中@Value("tony")private String name;//从配置文件中取值//person://  name: tony@Value("${person.name}")private String nameFromConfig;//在需要的属性上面增加这个注解，不需要final修饰@Resource(name="femaleAvatar")private IAvatar avatar;//错误使用，加上final// @Resource// private final Avatar avatar;public void setName(String name) {this.name = name;}public String getName() {return this.name;}//也可以加在setter方法上面@Resource(name="femaleAvatar")public void setAvatar(IAvatar avatar) {this.avatar = avatar;}public String getAvatar() {return this.avatar.url;}
}