理解SpringIOC和SpringAOP（6.16）

关于SpringIOC和AOP之前也看了很多博客，但是总感觉始终没有一个很清楚的认识，现在对之前看到的一些博客做一个小总结以及自己的一点理解。

一、Spring IOC（底层实现：反射）

1、SpringIOC是什么？

即“控制反转”，控制反转另外一种说法叫DI，即依赖注入，是利用反射机制，不是什么技术，而是一种设计思想。在Java开发中，IOC意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。通俗点说许多应用都是通过彼此间的相互合作来实现业务逻辑的，如类A要调用类B的方法，以前我们都是在类A中，通过自身new一个类B，然后再调用类B的方法，现在我们把new类B的事情交给Spring来做，在我们调用的时候，容器会为我们实例化。

2、IOC 能做什么？

IoC不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。

IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

3、形象理解

IOC： 所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。这是什么意思呢，举个简单的例子，我们是如何找女朋友的？常见的情况是，我们到处去看哪里有长得漂亮身材又好的mm，然后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………，想办法认识她们，投其所好送其所要，然后嘿嘿……这个过程是复杂深奥的，我们必须自己设计和面对每个环节。传统的程序开发也是如此，在一个对象中，如果要使用另外的对象，就必须得到它（自己new一个，或者从JNDI中查询一个），使用完之后还要将对象销毁（比如Connection等），对象始终会和其他的接口或类藕合起来。
那么IoC是如何做的呢？有点像通过婚介找女朋友，在我和女朋友之间引入了一个第三者：婚姻介绍所。婚介管理了很多男男女女的资料，我可以向婚介提出一个列表，告诉它我想找个什么样的女朋友，比如长得像李嘉欣，身材像林熙雷，唱歌像周杰伦，速度像卡洛斯，技术像齐达内之类的，然后婚介就会按照我们的要求，提供一个mm，我们只需要去和她谈恋爱、结婚就行了。简单明了，如果婚介给我们的人选不符合要求，我们就会抛出异常。整个过程不再由我自己控制，而是有婚介这样一个类似容器的机构来控制。Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。

DI(依赖注入)： IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？ Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。

4、实现原理

IOC容器的实现利用了反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。

二、Spring AOP（底层实现：动态代理）

1、SpringAOP是什么？

面向切面编程（AOP）就是纵向的编程。比如业务A和业务B现在需要一个相同的操作，传统方法我们可能需要在A、B中都加入相关操作代码，而应用AOP就可以只写一遍代码，A、B共用这段代码。并且，当A、B需要增加新的操作时，可以在不改动原代码的情况下，灵活添加新的业务逻辑实现。

2、形象理解

比如银行系统会有一个取款流程

我们可以把方框里的流程合为一个，另外系统还会有一个查询余额流程，我们先把这两个流程放到一起

有没有发现，这个两者有一个相同的验证流程，我们先把它们圈起来再说下一步

有没有想过可以把这个验证用户的代码是提取出来，不放到主流程里去呢，这就是AOP的作用了，有了AOP，你写代码时不要把这个验证用户步骤写进去，即完全不考虑验证用户，你写完之后，在另我一个地方，写好验证用户的代码，然后告诉Spring你要把这段代码加到哪几个地方，Spring就会帮你加过去，而不要你自己Copy过去，这里还是两个地方，如果你有多个控制流呢，这个写代码的方法可以大大减少你的时间，不过AOP的目的不是这样，这只是一个“副作用”，真正目的是，你写代码的时候，事先只需考虑主流程，而不用考虑那些不重要的流程，懂C的都知道，良好的风格要求在函数起始处验证参数，如果在C上可以用AOP，就可以先不管校验参数的问题，事后使用AOP就可以隔山打牛的给所有函数一次性加入校验代码，而你只需要写一次校验代码。不知道C的没关系，举一个通用的例子，经常在debug的时候要打log吧，你也可以写好主要代码之后，把打log的代码写到另一个单独的地方，然后命令AOP把你的代码加过去，注意AOP不会把代码加到源文件里，但是它会正确的影响最终的机器代码。
现在大概明白了AOP了吗，我们来理一下头绪，上面那个方框像不像个平面，你可以把它当块板子，这块板子插入一些控制流程，这块板子就可以当成是AOP中的一个切面。所以AOP的本质是在一系列纵向的控制流程中，把那些相同的子流程提取成一个横向的面，这句话应该好理解吧，我们把纵向流程画成一条直线，然把相同的部分以绿色突出，如下图左，而AOP相当于把相同的地方连一条横线，如下图右，这个图没画好，大家明白意思就行。

3、AOP涉及名词

1、切面（Aspect）：共有功能的实现。如日志切面、权限切面、验签切面等。在实际开发中通常是一个存放共有功能实现的标准Java类。当Java类使用了@Aspect注解修饰时，就能被AOP容器识别为切面。

2、通知（Advice）：切面的具体实现。就是要给目标对象织入的事情。以目标方法为参照点，根据放置的地方不同，可分为前置通知（Before）、后置通知（AfterReturning）、异常通知（AfterThrowing）、最终通知（After）与环绕通知（Around）5种。在实际开发中通常是切面类中的一个方法，具体属于哪类通知，通过方法上的注解区分。

3、连接点（JoinPoint）：程序在运行过程中能够插入切面的地点。例如，方法调用、异常抛出等。Spring只支持方法级的连接点。一个类的所有方法前、后、抛出异常时等都是连接点。

4、切入点（Pointcut）：用于定义通知应该切入到哪些连接点上。不同的通知通常需要切入到不同的连接点上，这种精准的匹配是由切入点的正则表达式来定义的。比如，在上面所说的连接点的基础上，来定义切入点。我们有一个类，类里有10个方法，那就产生了几十个连接点。但是我们并不想在所有方法上都织入通知，我们只想让其中的几个方法，在调用之前检验下入参是否合法，那么就用切点来定义这几个方法，让切点来筛选连接点，选中我们想要的方法。切入点就是来定义哪些类里面的哪些方法会得到通知。

5、目标对象（Target）：那些即将切入切面的对象，也就是那些被通知的对象。这些对象专注业务本身的逻辑，所有的共有功能等待AOP容器的切入。

6、代理对象（Proxy）：将通知应用到目标对象之后被动态创建的对象。可以简单地理解为，代理对象的功能等于目标对象本身业务逻辑加上共有功能。代理对象对于使用者而言是透明的，是程序运行过程中的产物。目标对象被织入共有功能后产生的对象。

7、织入（Weaving）：将切面应用到目标对象从而创建一个新的代理对象的过程。这个过程可以发生在编译时、类加载时、运行时。Spring是在运行时完成织入，运行时织入通过Java语言的反射机制与动态代理机制来动态实现。

4、实现原理: 动态代理

三、Spring 常用注解

1、@Controller：用于标注控制器层组件

2、@Service：用于标注业务层组件

3、@Component : 用于标注这是一个受 Spring 管理的组件，组件引用名称是类名，第一个字母小写。可以使用@Component(“beanID”) 指定组件的名称

4、@Repository：用于标注数据访问组件，即DAO组件

5、@Bean：方法级别的注解，主要用在@Configuration和@Component注解的类里，@Bean注解的方法会产生一个Bean对象，该对象由Spring管理并放到IoC容器中。引用名称是方法名，也可以用@Bean(name = “beanID”)指定组件名

6、@Scope(“prototype”)：将组件的范围设置为原型的（即多例）。保证每一个请求有一个单独的action来处理，避免action的线程问题。由于Spring默认是单例的，只会创建一个action对象，每次访问都是同一个对象，容易产生并发问题，数据不安全。

7、@Autowired：默认按类型进行自动装配。在容器查找匹配的Bean，当有且仅有一个匹配的Bean时，Spring将其注入@Autowired标注的变量中。

8、@Resource：默认按名称进行自动装配，当找不到与名称匹配的Bean时会按类型装配。

小结：简单点说，就是，能够明确该类是一个控制器类组件的，就用@Controller；能够明确是一个服务类组件的，就用@Service；能够明确该类是一个数据访问组件的，就用@Repository；不知道他是啥或者不好区分他是啥，但是就是想让他动态装配的就用@Component。@Controller、@Service、@Component、@Repository都是类级别的注解，如果一个方法也想动态装配，就用@Bean。当我们想按类型进行自动装配时，就用@Autowired；当我们想按名称（beanID）进行自动装配时，就用@Resource；当我们需要根据比如配置信息等来动态装配不同的组件时，可以getBean(“beanID”)。

四、依赖注入的方式。

Spring有4种依赖注入方式，按照实现方式分为两类：注解和配置文件

1、Set方法注入方式（Set方法注入是最简单、最常用的注入方式。）

（1）注解注入

package com.obob.dao;

public class UserDao {
     
	public void login() {
     
		System.out.println("login...");
	}
}

package com.obob.service;
import org.springframework.beans.factory.annotation.Autowired;
import com.obob.dao.UserDao;

public class UserService {
     
	
	//注解注入（autowire注解默认使用类型注入）
	@Autowired
	private UserDao userDao;
	
	public void login() {
     
		userDao.login();
	}
}

（2）配置文件注入

UserDao定义不变，UserService去掉注解

package com.obob.service;
import org.springframework.beans.factory.annotation.Autowired;
import com.obob.dao.UserDao;

public class UserService {
     
	private UserDao userDao;
	public void login() {
     
		userDao.login();
	}
}

配置文件

<bean name="userService" class="com.obob.service.UserService">
	<property name="userDao" ref="userDao" />
</bean>
<bean name="userDao" class="com.obob.dao.UserDao"></bean>

2、构造器注入方式（构造方法注入是指带有参数的构造函数注入）

（1）注解注入

package com.obob.service;

import org.springframework.beans.factory.annotation.Autowired;

import com.obob.dao.UserDao;

public class UserService {
     
	
	private UserDao userDao;
	
	//注解到构造方法处
	@Autowired
	public UserService(UserDao userDao) {
     
		this.userDao = userDao;
	}
	
	public void login() {
     
		userDao.login();
	}
}

（2）配置文件注入

UserService.java

package com.obob.service;

import org.springframework.beans.factory.annotation.Autowired;

import com.obob.dao.UserDao;

public class UserService {
     
	
	private UserDao userDao;
	
	public UserService(UserDao userDao) {
     
		this.userDao = userDao;
	}
	
	
	public void login() {
     
		userDao.login();
	}
}

配置文件

<bean name="userService" class="com.obob.service.UserService">
	<constructor-arg index="0" ref="userDao"></constructor-arg> 
</bean>
<bean name="userDao" class="com.obob.dao.UserDao"></bean>

3、 静态工厂的方法注入（静态工厂顾名思义，就是通过调用静态工厂的方法来获取自己需要的对象。为了使用Spring的依赖注入IOC，我们不直接通过"工程类.静态方法()"来获取对象，而是依然通过spring注入的形式获取。此种方式无通过注解注入）

配置文件注入

UserService.java

package com.obob.service;

import com.obob.dao.UserDao;

public class UserService {
     
	
	private UserDao userDao;
	
	public void login() {
     
		userDao.login();
	}
}

Factory.java

package com.obob;

import com.obob.dao.UserDao;

public class Factory {
     
	
	public static UserDao initUserDao() {
     
		return new UserDao();
	}
}

配置文件

<bean name="userService" class="com.obob.service.UserService">
	<property name="staticUserDao" ref="staticUserDao" />
</bean>
<bean name="staticUserDao" class="com.obob.Factory" factory-method="initUserDao"></bean>

4、实例工厂的方法注入（实例工厂的意思是获取对象实例的方法不是静态的，所以你需要首先new工厂类，再调用普通的实例方法。此种方式无通过注解注入）

配置文件注入

UserService.java

package com.obob.service;

import com.obob.dao.UserDao;

public class UserService {
     
	
	private UserDao userDao;
	
	public void login() {
     
		userDao.login();
	}
}

Factory.java

package com.obob;

import com.obob.dao.UserDao;

public class Factory {
     
	
	public UserDao initUserDao() {
     
		return new UserDao();
	}
}

配置文件

<bean name="userService" class="com.obob.service.UserService">
	<property name="staticUserDao" ref="staticUserDao" />
</bean>
<bean name="staticUserDao" factory-bean="factory" factory-method="initUserDao"></bean>
<bean name="factory" class="com.obob.Factory"></bean>