说说Spring(2)

上一篇我们聊了聊spring中最重要的IOC控制反转以及依赖注入，以及一些常用的配置。今天我们说一说spirng的另一个很重要的东西AOP。

什么是 AOP
AOP：全称是 Aspect Oriented Programming 即：面向切面编程。简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

AOP 的作用及优势
作用： 在程序运行期间，不修改源码对已有方法进行增强。 优势： 减少重复代码 提高开发效率 维护方便。

AOP实现方式：动态代理。

动态代理

动态代理的特点
字节码随用随创建，随用随加载。它与静态代理的区别也在于此，因为静态代理是字节码一上来就创建好了，并完成加载。

动态代理常用的有两种方式
基于接口的动态代理 提供者：JDK 官方的 Proxy 类。 要求：被代理类最少实现一个接口。
基于子类的动态代理 提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。 要求：被代理类不能用 final 修饰的类（最终类）。

JDK动态代理
此处我们使用的是一个演员的例子： 在很久以前，演员和剧组都是直接见面联系的。没有中间人环节。 而随着时间的推移，产生了一个新兴职业：经纪人（中间人），这个时候剧组再想找演员就需要通过经纪 人来找了。下面我们就用代码演示出来

/**
* 一个经纪公司的要求:  *   能做基本的表演和危险的表演 */

public interface IActor {  /**
* 基本演出   *
* @param money
**/
public void basicAct(float money);
/**
* 危险演出   * @param money
**/
public void dangerAct(float money);
}

/**
* 一个演员
*/
//实现了接口，就表示具有接口中的方法实现。即：符合经纪公司的要求
public class Actor implements IActor{
public void basicAct(float money){
System.out.println("拿到钱，开始基本的表演："+money);
}
public void dangerAct(float money){
System.out.println("拿到钱，开始危险的表演："+money);
}
}

public class Client {
public static void main(String[] args) {
//一个剧组找演员：
final Actor actor = new Actor();//直接
/**
*代理：
*  间接。
*  获取代理对象：
* 要求：
*   被代理类最少实现一个接口
* 创建的方式
*   Proxy.newProxyInstance(三个参数)
* 参数含义：
*  ClassLoader：和被代理对象使用相同的类加载器。
*  Interfaces：和被代理对象具有相同的行为。实现相同的接口。
*  InvocationHandler：如何代理。
*    策略模式：使用场景是：
*                        数据有了，目的明确。
*                        如何达成目标，就是策略。
*
*/

IActor proxyActor = (IActor) Proxy.newProxyInstance(
actor.getClass().getClassLoader(),
actor.getClass().getInterfaces(),
new InvocationHandler() {
/**
* 执行被代理对象的任何方法，都会经过该方法。
* 此方法有拦截的功能。
*
* 参数：
*  proxy：代理对象的引用。不一定每次都用得到
*  method：当前执行的方法对象
*  args：执行方法所需的参数
* 返回值：
*  当前执行方法的返回值
*/

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String name = method.getName();
Float money = (Float) args[0];
Object rtValue = null;
//每个经纪公司对不同演出收费不一样，此处开始判断
if("basicAct".equals(name)){
//基本演出，没有 2000 不演
if(money > 2000){
//看上去剧组是给了 8000，实际到演员手里只有 4000
//这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
rtValue = method.invoke(actor, money/2);
}

}
if("dangerAct".equals(name)){
//危险演出,没有 5000 不演       if(money > 5000){
//看上去剧组是给了 50000，实际到演员手里只有 25000
//这就是我们没有修改原来 dangerAct 方法源码，对方法进行了增强
rtValue = method.invoke(actor, money/2);
}
}
return rtValue;
}
});
//没有经纪公司的时候，直接找演员。
//  actor.basicAct(1000f);
//  actor.dangerAct(5000f);
//剧组无法直接联系演员，而是由经纪公司找的演员
proxyActor.basicAct(8000f);
proxyActor.dangerAct(50000f);
}
}

cglib动态代理

还是那个演员的例子，只不过不让他实现接口。
/**
* 一个演员
*/
public class Actor{//没有实现任何接口
public void basicAct(float money){
System.out.println("拿到钱，开始基本的表演："+money);
}
public void dangerAct(float money){
System.out.println("拿到钱，开始危险的表演："+money);
｝
｝

public class Client {
/**
* 基于子类的动态代理
*  要求：
*   被代理对象不能是最终类
*  用到的类：
*            Enhancer
*  用到的方法：
*          create(Class, Callback)
*  方法的参数：
*         Class：被代理对象的字节码
*        Callback：如何代理
* @param args
*/
public static void  main(String[] args) {
final Actor actor = new Actor();
Actor cglibActor = (Actor) Enhancer.create(actor.getClass(),
new MethodInterceptor() {
/**
* 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何 方法进行增强。
*
* 参数：
*  前三个和基于接口的动态代理是一样的。
*  MethodProxy：当前执行方法的代理对象。
* 返回值：
*  当前执行方法的返回值
*/
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
String    name = method.getName();
Float money = (Float) args[0];
Object rtValue = null;
if("basicAct".equals(name)){
//基本演出
if(money > 2000){
rtValue = method.invoke(actor, money/2);
}
}
if("dangerAct".equals(name)){
//危险演出      if(money > 5000){
rtValue = method.invoke(actor, money/2);
}
}
return rtValue;
}
});
cglibActor.basicAct(10000);
cglibActor.dangerAct(100000);
}
}

Spring中的AOP

AOP 相关术语
Joinpoint(连接点): 所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的 连接点。
Pointcut(切入点): 所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
Advice(通知/增强): 所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。 通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
Introduction(引介): 引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方 法或 Field。
Target(目标对象): 代理的目标对象。
Weaving(织入): 是指把增强应用到目标对象来创建新的代理对象的过程。 spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
Proxy（代理）: 一个类被 AOP 织入增强后，就产生一个结果代理类。
Aspect(切面): 是切入点和通知（引介）的结合。

在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

AOP的XML配置

第一步：把通知类用 bean 标签配置起来
<-- 配置通知 -->

第二步：使用 aop:config 声明 aop 配置
aop:config
<-- 配置的代码都写在此处 -->
</aop:config>

第三步：使用 aop:aspect 配置切面
属性： id：给切面提供一个唯一标识。 ref：引用配置好的通知类 bean 的 id。
<aop:aspect id=“txAdvice” ref=“txManager”>
<–配置通知的类型要写在此处–>
</aop:aspect>

第四步：使用 aop:pointcut 配置切入点表达式
属性： expression：用于定义切入点表达式。 id：用于给切入点表达式提供一个唯一标识
<aop:pointcut expression=“execution( public void com.itheima.service.impl.AccountServiceImpl.transfer( java.lang.String, java.lang.String, java.lang.Float) )” id=“pt1”/>

第五步：使用 aop:xxx 配置对应的通知类型
前置通知。指定增强的方法在切入点方法之前执行
属性： method:用于指定通知类中的增强方法名称 ponitcut-ref：用于指定切入点的表达式的引用 poinitcut：用于指定切入点表达式
<aop:before method=“beginTransaction” pointcut-ref=“pt1”/>

后置通知。切入点方法正常执行之后。它和异常通知只能有一个执行
属性： method:用于指定通知类中的增强方法名称 ponitcut-ref：用于指定切入点的表达式的引用 poinitcut：用于指定切入点表达式
<aop:after-returning method=“commit” pointcut-ref=“pt1”/>

异常通知。切入点方法执行产生异常后执行。它和后置通知只能执行一个
属性： method:用于指定通知类中的增强方法名称 ponitcut-ref：用于指定切入点的表达式的引用 poinitcut：用于指定切入点表达式
<aop:after-throwing method=“rollback” pointcut-ref=“pt1”/>

最终通知。无论切入点方法执行时是否有异常，它都会在其后面执行。
属性： method:用于指定通知类中的增强方法名称 ponitcut-ref：用于指定切入点的表达式的引用 poinitcut：用于指定切入点表达式
<aop:after method=“release” pointcut-ref=“pt1”/>

环绕通知
aop:config
<aop:pointcut expression=“execution(* com.itheima.service.impl..(…))” id=“pt1”/>
<aop:aspect id=“txAdvice” ref=“txManager”>
<-- 配置环绕通知 -->
<aop:around method=“transactionAround” pointcut-ref=“pt1”/>
</aop:aspect>
</aop:config>

/**
* 环绕通知  * @param pjp
*  spring 框架为我们提供了一个接口：ProceedingJoinPoint，它可以作为环绕通知的方法参数。
*  在环绕通知执行时，spring 框架会为我们提供该接口的实现类对象，我们直接使用就行。
* @return
*/
public Object transactionAround(ProceedingJoinPoint pjp) {
//定义返回值
Object rtValue = null;
try {   //获取方法执行所需的参数
Object[] args = pjp.getArgs();
//前置通知：开启事务
beginTransaction();
//执行方法
rtValue = pjp.proceed(args);
//后置通知：提交事务
commit();
}catch(Throwable e) {
//异常通知：回滚事务
rollback();
e.printStackTrace();
}finally {
//最终通知：释放资源
release();
}
return rtValue;
}

基于注解的AOP

第一步：把通知类也使用注解配置

@Component("txManager")
public class TransactionManager {
//定义一个 DBAssit
@Autowired
private DBAssit dbAssit ;
}

第二步：在通知类上使用@Aspect 注解声明为切面

@Component("txManager")
@Aspect//表明当前类是一个切面类
public class TransactionManager {
//定义一个 DBAssit
@Autowired
private DBAssit dbAssit ;
}

第三步：在增强的方法上使用注解配置通知

@Before
作用： 把当前方法看成是前置通知。属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用。

//开启事务
@Before("execution(* com.itheima.service.impl.*.*(..))")
public void beginTransaction() {
try {
dbAssit.getCurrentConnection().setAutoCommit(false);
} catch (SQLException e) {
e.printStackTrace();
}
}

@AfterReturning
作用： 把当前方法看成是后置通知。 属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用 。

//提交事务
@AfterReturning("execution(* com.itheima.service.impl.*.*(..))")
public void commit() {
try {
dbAssit.getCurrentConnection().commit();
} catch (SQLException e) {
e.printStackTrace();   }
}

@AfterThrowing
作用： 把当前方法看成是异常通知。 属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用 。

//回滚事务
@AfterThrowing("execution(* com.itheima.service.impl.*.*(..))")
public void rollback() {
try {
dbAssit.getCurrentConnection().rollback();
} catch (SQLException e) {
e.printStackTrace();
}
}

@After
作用： 把当前方法看成是最终通知。 属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用 。

//释放资源
@After("execution(* com.itheima.service.impl.*.*(..))")
public void release() {
try {
dbAssit.releaseConnection();   }
catch (Exception e) {
e.printStackTrace();
}
}

@Around
作用： 把当前方法看成是环绕通知。 属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用。

/**
* 环绕通知
* @param pjp
* @return
*/
@Around("execution(* com.itheima.service.impl.*.*(..))")
public Object transactionAround(ProceedingJoinPoint pjp) {
//定义返回值
Object rtValue = null;
try {
//获取方法执行所需的参数
Object[] args = pjp.getArgs();
//前置通知：开启事务
beginTransaction();
//执行方法
rtValue = pjp.proceed(args);
//后置通知：提交事务
commit();
}catch(Throwable e) {
//异常通知：回滚事务
rollback();
e.printStackTrace();
}finally {
//最终通知：释放资源
release();
}
return rtValue;
}