[TOC]
# 注解方式 IOC/DI
在本知识点中，讲演示如何使用注解的方式完成注入对象中的效果
## 步骤 1 : 先运行，看到效果，再学习
先将完整的 spring 项目（向老师要相关资料），配置运行起来，确认可用之后，再学习做了哪些步骤以达到这样的效果。
## 步骤 2 : 模仿和排错
在确保可运行项目能够正确无误地运行之后，再严格照着教程的步骤，对代码模仿一遍。
模仿过程难免代码有出入，导致无法得到期望的运行结果，此时此刻通过比较**正确答案** ( 可运行项目 ) 和自己的代码，来定位问题所在。
采用这种方式，**学习有效果，排错有效率**，可以较为明显地提升学习速度，跨过学习路上的各个槛。
## 步骤 3 : 修改applicationContext.xml
~~~
<?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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:annotation-config/>
<bean name="c" class="com.dodoke.pojo.Category">
<property name="name" value="category 1" />
</bean>
<bean name="product" class="com.dodoke.pojo.Product">
<property name="name" value="Apple Watch" />
<property name="number" value="2" />
<property name="price" value="8800" />
<!-- <property name="category" ref="c" /> -->
</bean>
</beans>
~~~
> 1. `<context:annotation-config/>`：表示告诉Spring要用注解的方式进行配置
> 2. 注入对象的语句注释掉，这个行为在后面将使用注解来完成。
## 步骤 4 : @Autowired
在Product.java的category属性前加上@Autowired注解
~~~
package com.dodoke.pojo;
import org.springframework.beans.factory.annotation.Autowired;
public class Product {
private int id;
private String name;
private int number;
private double price;
@Autowired
private Category category;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Category getCategory() {
return category;
}
public void setCategory(Category category) {
this.category = category;
}
}
~~~
## 步骤 5 : 运行测试
运行 TestSpring.java，结果如下：
> 由此可见，除了使用xml配置，可以使用@Autowired注入对象。
## 步骤 6 : @Autowired的位置
除了前面的 在属性前加上@Autowired 这种方式外，也可以在setCategory方法前加上@Autowired，这样来达到相同的效果。
~~~
package com.dodoke.pojo;
import org.springframework.beans.factory.annotation.Autowired;
public class Product {
private int id;
private String name;
private int number;
private double price;
private Category category;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Category getCategory() {
return category;
}
@Autowired
public void setCategory(Category category) {
this.category = category;
}
}
~~~
运行 TestSpring.java，结果如下：
## 步骤 7 : @Resource
除了@Autowired之外，@Resource也是常用的手段
~~~
package com.dodoke.pojo;
import javax.annotation.Resource;
public class Product {
private int id;
private String name;
private int number;
private double price;
@Resource(name="c")
private Category category;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Category getCategory() {
return category;
}
public void setCategory(Category category) {
this.category = category;
}
}
~~~
运行 TestSpring.java，结果如下：
## 步骤 8 : 对Bean的注解
上述例子是对**注入对象行为**的注解，那么bean对象本身，比如Category,Product可不可以移出applicationContext.xml配置文件，也通过注解进行呢？
接下来就讲解如何对Bean进行注解配置
## 步骤 9 : applicationContext.xml
修改applicationContext.xml，什么都去掉，只新增：`<context:component-scan base-package="com.dodoke.pojo" />`，其作用是告诉Spring，bean都放在com.dodoke.pojo这个包下。
~~~
<?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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:component-scan base-package="com.dodoke.pojo" />
</beans>
~~~
## 步骤 10 : @Component
为Product类加上@Component注解，即表明此类是bean
~~~
@Component("product")
public class Product {
~~~
为Category 类加上@Component注解，即表明此类是bean
~~~
@Component("c")
public class Category {
~~~
另外，因为配置从applicationContext.xml中移出来了，所以属性初始化放在属性声明上进行了。
Product
~~~
package com.dodoke.pojo;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
@Component("product")
public class Product {
private int id;
private String name = "Apple Watch";
private int number = 2;
private double price = 8800;
@Resource(name = "c")
private Category category;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Category getCategory() {
return category;
}
public void setCategory(Category category) {
this.category = category;
}
}
~~~
Category
~~~
package com.dodoke.pojo;
import org.springframework.stereotype.Component;
@Component("c")
public class Category {
private int id;
private String name = "category 1";
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
~~~
## 步骤 11 : 运行测试
运行TestSpring，可以发现运行结果是一样的，结果如下：
> 总结：
> 注解最大的好处就是简化了XML配置
# 拓展资料
## 控制反转
~~~
public class PersonServiceBean {
private PersonDao personDao = new PersonDaoBean();
public void save(Person person){
personDao.save(person);
}
}
~~~
PersonDaoBean 是在应用内部创建及维护的。所谓控制反转就是应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护是由外部容器负责的。这样控制权就由应用转移到了外部容器，控制权的转移就是所谓反转
> IOC—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在 Java 开发中，IOC 意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。
>
> ●谁控制谁，控制什么：传统 Java SE 程序设计，我们直接在对象内部通过 new 进行创建对象，是程序主动去创建依赖对象；而 IOC 是有专门一个容器来创建这些对象，即由 IOC 容器来控制对象的创建；谁控制谁？当然是 IOC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。
> ●为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。
实现 IOC 的方式：依赖注入（DI，英文quancDependency Injection）
所谓依赖注入，就是由 IOC 容器在运行期间，动态地将某种依赖关系注入到对象之中。
> IOC 对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在 IOC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。
> IOC 很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由 IOC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。
## 依赖注入
* 使用构造器注入
* 使用属性setter方法注入
* 使用Field注入（用于注解方式）
注入依赖对象可以采用手工装配或自动装配，在实际应用中建议使用手工装配，因为自动装配会产生未知情况,开发人员无法预见最终的装配结果。
1. 手工装配依赖对象
2. 自动装配依赖对象
### 依赖注入-手工装配
手工装配依赖对象，在这种方式中又有两种编程方式
1. 在xml配置文件中，通过在bean节点下配置，如
~~~
<bean id="orderService" class="cn.itcast.service.OrderServiceBean">
<constructor-arg index=“0” type=“java.lang.String” value=“xxx”/>//构造器注入
<property name=“name” value=“zhao/>//属性setter方法注入
</bean>
~~~
2. 在java代码中使用@Autowired或@Resource注解方式进行装配。但我们需要在xml配置文件中配置以下信息：
~~~
<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-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:annotation-config/>
</beans>
~~~
这个配置隐式注册了多个对注释进行解析处理的处理器:AutowiredAnnotationBeanPostProcessor，CommonAnnotationBeanPostProcessor，PersistenceAnnotationBeanPostProcessor，RequiredAnnotationBeanPostProcessor
注： @Resource注解在spring安装目录的lib\j2ee\common-annotations.jar
在java代码中使用@Autowired或@Resource注解方式进行装配，这两个注解的区别是：@Autowired 默认按类型装配，@Resource默认按名称装配，当找不到与名称匹配的bean才会按类型装配。
~~~
@Autowired
private PersonDao personDao;//用于字段上
@Autowired
public void setOrderDao(OrderDao orderDao) {//用于属性的setter方法上
this.orderDao = orderDao;
}
~~~
`@Autowired` 注解是按类型装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许 null 值，可以设置它 required 属性为 false 。如果我们想使用按名称装配，可以结合`@Qualifier`注解一起使用。如下：
~~~
@Autowired @Qualifier("personDaoBean")
75
private PersonDao personDao;
~~~
`@Resource` 注解和`@Autowired`一样，也可以标注在字段或属性的 setter 方法上，但它默认按名称装配。名称可以通过`@Resource`的 name 属性指定，如果没有指定 name属性，当注解标注在字段上，即默认取字段的名称作为 bean 名称寻找依赖对象，当注解标注在属性的 setter 方法上，即默认取属性名作为 bean 名称寻找依赖对象。
~~~
@Resource(name=“personDaoBean”)
private PersonDao personDao;//用于字段上
~~~
注意：如果没有指定 name 属性，并且按照默认的名称仍然找不到依赖对象时， `@Resource`注解会回退到按类型装配。但一旦指定了 name 属性，就只能按名称装配了。
### 依赖注入-自动装配依赖对象
对于自动装配，了解一下就可以了，不推荐使用。例子：
`<bean id="..." class="..." autowire="byType"/>`
autowire属性取值如下：
byType：按类型装配，可以根据属性的类型，在容器中寻找跟该类型匹配的 bean。如果发现多个，那么将会抛出异常。如果没有找到，即属性值为 null。
byName：按名称装配，可以根据属性的名称，在容器中寻找跟该属性名相同的 bean，如果没有找到，即属性值为 null。
### 通过在classpath自动扫描方式把组件纳入spring容器中管理
在一个稍大的项目中，通常会有上百个组件，如果这些这组件采用 xml 的 bean 定义来配置，显然会增加配置文件的体积，查找及维护起来也不太方便。spring2.5为我们引入了组件自动扫描机制，他可以在类路径底下寻找标注了`@Component`、`@Service`、`@Controller`、`@Repository`注解的类，并把这些类纳入进spring容器中管理。它的作用和在xml文件中使用 bean 节点配置组件是一样的。要使用自动扫描机制，我们需要打开以下配置信息:
~~~
<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-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:component-scan base-package="cn.itcast"/>
</beans>
~~~
其中`base-package`为需要扫描的包(含子包)。
`@Service`用于标注业务层组件、 `@Controller`用于标注控制层组件、`@Repository`用于标注数据访问组件，即 DAO 组件。而`@Component`泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。
