某一天
文章内容部分来自于
https://gitee.com/zhongfucheng/Java3y#spring%E5%AE%B6%E6%97%8F
http://c.biancheng.net/view/4241.html
笔记背景
本人在学习Spring玩转全家桶时，发现自己对IOC与AOP以及控制反转、依赖注入、甚至更加简单的注解使用、Bean装配等基础Spring知识有些模糊不清，故写翻看网上各种文章，网上文章有的抽象有的例子鲜明但是喧宾夺主，故还是我自己写个文章梳理一下我自己学到的内容吧
依赖注入
举例学习
在com.mengma.ioc 包下分别创建PersonDao、PersonDaoImpl、PersonService、PersonServiceImpl、FirstTest两个接口两个实现类一个测试类五个文件
package com.mengma.ioc;
public interface PersonDao {
public void add();
}
package com.mengma.ioc;
public class PersonDaoImpl implements PersonDao {
@Override
public void add() {
System.out.println("save()执行了...");
}
}
package com.mengma.ioc;
public interface PersonService {
public void addPerson();
}
package com.mengma.ioc;
public class PersonServiceImpl implements PersonService {
// 定义接口声明
private PersonDao personDao;
// 提供set()方法，用于依赖注入
public void setPersonDao(PersonDao personDao) {
this.personDao = personDao;
}
// 实现PersonService接口的方法
@Override
public void addPerson() {
personDao.add(); // 调用PersonDao中的add()方法
System.out.println("addPerson()执行了...");
}
}
@Test
public void test1() {
// 定义Spring配置文件的路径
String xmlPath = "applicationContext.xml";
// 初始化Spring容器，加载配置文件
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
xmlPath);
// 通过容器获取personService实例
PersonService personService = (PersonService) applicationContext
.getBean("personService");
// 调用personService的addPerson()方法
personService.addPerson();
}
由于在test类中指定，所以同在ioc文件夹下创建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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<!-- 由 Spring容器创建该类的实例对象 -->
<bean id="personDao" class="com.mengma.ioc.PersonDaoImpl" />
<bean id="personService" class="com.mengma.ioc.PersonServiceImpl">
<!-- 将personDao实例注入personService实例中 -->
<property name="personDao" ref="personDao"/>
</bean>
</beans>
程序要想运行，还需要如下几个包
包下载地址1：https://repo.spring.io/simple/libs-release-local/org/springframework/spring/3.2.2.RELEASE/
包下载地址2：http://commons.apache.org/proper/commons-logging/download_logging.cgi
程序运行结果
上述代码中，首先声明了 personDao 对象，并为其添加 setter 方法，用于依赖注入，然后实现了 PersonDao 接口的 addPerson() 方法，并在方法中调用 save() 方法和输出一条语句
在 applicationContext.xml 配置文件中添加一个 元素，用于实例化 PersonServiceImpl 类，并将 personDao 的实例注入到 personService 中
从输出结果中可以看出，使用 Spring 容器获取 userService 的实例后，调用了该实例的 addPerson() 方法，在该方法中又调用了 PersonDao 实现类中的 add() 方法，并输出了结果。这就是 Spring 容器属性 setter 注入的方式，也是实际开发中较为常用的一种依赖注入方式
哪为什么要这么做？为什么用applicationContext、为什么用Bean、为什么要依赖注入？概念是什么？
抽象概念
依赖注入（Dependency Injection，DI）和控制反转（Inversion of Control，Ioc）含义相同，它们是从两个角度描述的同一个概念。
当某个 Java 实例需要另一个 Java 实例时，传统的方法是由调用者创建被调用者的实例（例如，使用 new 关键字获得被调用者实例），而使用 Spring 框架后，被调用者的实例不再由调用者创建，而是由 Spring 容器创建，这称为控制反转。
Spring 容器在创建被调用者的实例时，会自动将调用者需要的对象实例注入给调用者，这样，调用者通过 Spring 容器获得被调用者实例，这称为依赖注入
可以简单理解为依赖注入是做到控制反转的具体实现方法
Spring IOC 解决的是 对象管理和对象依赖的问题
—三歪
本来我们的对象都是new出来的，而我们如果使用Spring 则把对象交给「IOC容器」来管理。
「控制反转」指的就是：本来是「由我们自己」new出来的对象，现在交给了IOC容器。把这个对象的「控制权」给「他方」了。「控制反转」更多的是一种思想或者说是设计模式，把原有由自己掌控的事交给「别人」来处理。
「依赖注入」更多指的是「控制反转」这个思想的实现方式：对象无需自行创建或管理它们的依赖关系，依赖关系将被「自动注入」到需要它们的对象当中去。
最简单理解「依赖注入」和「控制反转」：本来我们的对象都是「由我们自己」new出来的，现在我们把这个对象的创建权限和对象之间的依赖关系交由「IOC容器」来管理。
现在问题又来了，为什么我们要把对象给「IOC容器」来管理呢？
理论上，我们可以把「IOC容器」也当做是一个「工厂」，使用IOC的好处就是：
将对象集中统一管理，便于修改
降低耦合度（调用方无需自己组装，也无需关心对象的实现，直接从「IOC容器」取就好了）
写到这里就得说第二个概念，Ioc容器
IOC容器
IoC 是指在程序开发中，实例的创建不再由调用者管理，而是由 Spring 容器创建。Spring 容器会负责控制程序之间的关系，而不是由程序代码直接控制，因此，控制权由程序代码转移到了 Spring 容器中，控制权发生了反转，这就是 Spring 的 IoC 思想。
Spring 提供了两种 IoC 容器，分别为 BeanFactory 和 ApplicationContext
「IOC容器」是什么？我们可以理解为是一个「工厂」，我们把对象都交由这个「工厂」来管理，包括对象的创建和对象之间的依赖关系等等。等我们要用到对象的时候，就从这个「工厂」里边取出来
一般通常使用的就是ApplicationContext也就是常说的Spring的上下文
就是它代替程序员去操作对象，就是它控制了Bean的生命周期，就是程序员存在了「控制反转」的思想「依赖注入」了Bean给它，它就是Spring上下文，它是Ioc容器的一种
Bean
上述例子中，在ApplicationContext.xml中配置的Bean对象，
总的来说：我们以XML配置+注解来装配Bean比较多，其中注解这种方式占大部分。
把对象放到「IOC容器」了以后，对象与对象之间是有关系的，我们需要把对象之间的依赖告诉Spring，让它来帮我们解决掉对象的依赖关系
「对象之间的关系」别想得太复杂了。在日常开发中其实很多时候就是A对象里边有B对象的属性而已
作为 Spring 核心机制的依赖注入，改变了传统的编程习惯，对组件的实例化不再由应用程序完成，转而交由 Spring 容器完成，在需要时注入应用程序中，从而对组件之间依赖关系进行了解耦。这一切都离不开 Spring 配置文件中使用的 元素。
Spring 容器可以被看作一个大工厂，而 Spring 容器中的 Bean 就相当于该工厂的产品。如果希望这个大工厂能够生产和管理 Bean，这时则需要告诉容器需要哪些 Bean，以及需要以何种方式将这些 Bean 装配到一起
最开始的Bean通过xml文件进行配置，中包含一些重要的属性标签，如id、name、class、scope、ref等，有需要的可以再继续深入学习，由于Spring的迭代，更多的现在采用注解的方式配置
注解配置
我还是先举例子再说概念
举例学习
在 com.mengma.annotation 的包下，分别创建PersonDao、PersonDaoImpl、PersonService、PersonServiceImpl、PersonAction、AnnotationTest两个接口两个实现类一个控制类一个测试类六个文件
package com.mengma.annotation;
public interface PersonDao {
public void add();
}
package com.mengma.annotation;
import org.springframework.stereotype.Repository;
@Repository("personDao")
public class PersonDaoImpl implements PersonDao {
@Override
public void add() {
System.out.println("Dao层的add()方法执行了...");
}
}
package com.mengma.annotation;
public interface PersonService {
public void add();
}
package com.mengma.annotation;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
@Service("personService")
public class PersonServiceImpl implements PersonService {
@Resource(name = "personDao")
private PersonDao personDao;
public PersonDao getPersonDao() {
return personDao;
}
@Override
public void add() {
personDao.add();// 调用personDao中的add()方法
System.out.println("Service层的add()方法执行了...");
}
}
package com.mengma.annotation;
import javax.annotation.Resource;
import org.springframework.stereotype.Controller;
@Controller("personAction")
public class PersonAction {
@Resource(name = "personService")
private PersonService personService;
public PersonService getPersonService() {
return personService;
}
public void add() {
personService.add(); // 调用personService中的add()方法
System.out.println("Action层的add()方法执行了...");
}
}
package com.mengma.annotation;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AnnotationTest {
@Test
public void test() {
// 定义Spring配置文件路径
String xmlPath = "com/mengma/annotation/applicationContext.xml";
// 初始化Spring容器，加载配置文件，并对bean进行实例化
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
xmlPath);
// 获得personAction实例
PersonAction personAction = (PersonAction) applicationContext
.getBean("personAction");
// 调用personAction中的add()方法
personAction.add();
}
}
同样由于配置，故在annotation文件夹下创建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: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.xsd">
<!--使用context命名空间，通知spring扫描指定目录，进行注解的解析-->
<context:component-scan base-package="com.mengma.annotation"/>
</beans>
上述代码中，首先使用 @Repository 注解将 PersonDaoImpl 类标识为 Spring 中的 Bean，其写法相当于配置文件中
<bean id="personDao"class=“com.mengma.annotation.PersonDaoImpl”/>
的书写。然后在 add() 方法中输出一句话，用于验证是否成功调用了该方法。
上述代码中，首先使用 @Service 注解将 PersonServiceImpl 类标识为 Spring 中的 Bean，其写法相当于配置文件中
<bean id="personService"class=“com.mengma.annotation.PersonServiceImpl”/>
的书写。
然后使用 @Resource 注解标注在属性 personDao 上（也可标注在 personDao 的 setPersonDao() 方法上），这相当于配置文件中
<property name="personDao"ref=“personDao”/>
的写法。最后在该类的 add() 方法中调用 personDao 中的 add() 方法，并输出一句话。
上述代码中，首先使用 @Controller 注解标注 PersonAction 类，其写法相当于在配置文件中编写
<bean id="personAction"class=“com.mengma.annotation.PersonAction”/>
然后使用了 @Resource 注解标注在 personService 上，这相当于在配置文件内编写
<property name="personService"ref=“personService”/>。
最后在其 add() 方法中调用了 personService 中的 add() 方法，并输出一句话。
从输出结果中可以看出，DAO 层、Service 层和 Action 层的 add() 方法都成功输出了结果。由此可知，使用 Annotation 装配 Bean 的方式已经成功实现了
概念
在 Spring 中，尽管使用 XML 配置文件可以实现 Bean 的装配工作，但如果应用中 Bean 的数量较多，会导致 XML 配置文件过于臃肿，从而给维护和升级带来一定的困难。
Java 从 JDK 5.0 以后，提供了 Annotation（注解）功能，Spring 也提供了对 Annotation 技术的全面支持。Spring3 中定义了一系列的 Annotation（注解），常用的注解如下。
@Component
可以使用此注解描述 Spring 中的 Bean，但它是一个泛化的概念，仅仅表示一个组件（Bean），并且可以作用在任何层次。使用时只需将该注解标注在相应类上即可。
@Repository
用于将数据访问层（DAO层）的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Service
通常作用在业务层（Service 层），用于将业务层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Controller
通常作用在控制层（如 Struts2 的 Action），用于将控制层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Autowired
用于对 Bean 的属性变量、属性的 Set 方法及构造函数进行标注，配合对应的注解处理器完成 Bean 的自动配置工作。默认按照 Bean 的类型进行装配。
@Resource
其作用与 Autowired 一样。其区别在于 @Autowired 默认按照 Bean 类型装配，而 @Resource 默认按照 Bean 实例名称进行装配。
@Resource 中有两个重要属性：name 和 type。
Spring 将 name 属性解析为 Bean 实例名称，type 属性解析为 Bean 实例类型。如果指定 name 属性，则按实例名称进行装配；如果指定 type 属性，则按 Bean 类型进行装配。
如果都不指定，则先按 Bean 实例名称装配，如果不能匹配，则再按照 Bean 类型进行装配；如果都无法匹配，则抛出 NoSuchBeanDefinitionException 异常。
@Qualifier
与 @Autowired 注解配合使用，会将默认的按 Bean 类型装配修改为按 Bean 的实例名称装配，Bean 的实例名称由 @Qualifier 注解的参数指定。