Spring的Aop

Aop(Aspect-Object Programmign面向切面编程)是Oop(Orientied-Object Programming)面向对象编程的延续；
面向过程----->面向对象------->面向切面

public interface UserDao{

​     public void add();

​     public void delete();

​    public void update();

}

public class UserDaoImpl implements UserDao{

​	 public void add(){

​	  System.out.println("添加");

 	}

 	public void delete(){

​	  System.out.println("删除");

 	}

​	 public void update(){

​	  System.out.println("修改");

 	}

}

目前有一个需求：在不改变代码的时候，添加事务
第一种解决方法是编写目标类的子类，重写方法，完成需求，但是代码冗余，耦合度高，及其不方便。
上边是解决了问题，解决的不是很恰当，这时候就有了一种思想
动态代理思想(找人帮你做，不自己做了)
1.jdk代理：proxy代理对象，这种代理比较慢，以为过程是java–>字节码—>类，还有局限性，必须是接口和实现类同时存在
2.cglib(Code Generator Library他是基于asm字节码增强框架)：快，没有局限性，有没有接口都可以，他是由字节码–>类
区别：jdk性能慢，jdk必须基于接口，cglib性能快，基于目标类子类

1.必须掌握aop术语：

• 目标类：Target—>UserDaoImpl
• 链接点：JoinPoint—>是UserDaoImpl中没有添加通知的方法
• 切面类：Aspect 存储功能的类
• 通知/增强 ：advice，切面类中的具体方法
• 切入点：PointCut—>是UserDaoImpl中添加通知的方法
• 代理类：Proxy 代理类
• 织入：weaving，将目标中的方法和通知放到代理类的过程

spring提供了切面类中的增强的类型
1.before前置通知：在目标方法前执行
2.after-Returning后置通知：在目标方法后执行
3.around环绕：前后都执行
4.after-Throwing：异常通知，有异常时候在通知
5.after：最终通知，无论如何都执行

答：提供一个表达式叫切入点表达式

访问修饰符 	包名.包名.包名.类名.方法名 (参数列表) 异常
	execution("* com.oracle.daoImpl.*.* (..) ”)
	execution("* com.oracle.daoImpl.*.* (int,int) ")
	execution("* com.oracle.daoImpl.*.* (int,String)")
	execution("* com.oracle.daoImpl.*Impl.* (int,String)") 
	execution("* com.oracle.daoImpl.*.*Impl (int,String)")
	execution("* com.*.daoImpl.*.* (..) ")

1.导入jar包
2.编写spring的配置文件

public interface UserDao {

    public void add();
    public int delete(int id);
    public void update();

}

public class UserDaoImpl implements UserDao {
    @Override
    public void add() {
        //int i = 1/0;
        System.out.println("添加");
    }

    @Override
    public int delete(int id) {
        System.out.println("删除");
        return id;
    }

    @Override
    public void update() {
        System.out.println("修改");
    }
}

public class Aspect {

    //1.前置通知
    public void before(JoinPoint joinPoint){
        //通过连接点 可以获取 基本信息
        Signature signature = joinPoint.getSignature();

        String name = signature.getName();
        System.out.println("链接点的方法名： " + name);
        //
        Object[] args = joinPoint.getArgs();
        for (Object arg : args) {
            System.out.println(arg);
        }

        System.out.println("开启事务");
    }

    //2.后置通知 afterReturning 必须有
    public void afterReturning(Object obj){
        System.out.println(obj); //返回的是方法参数值
        System.out.println("关闭事务");
    }

    //3.环绕通知  around         1.元生jdk，2.spring 半自动， 3。spring全自动
                                 //   4.spring Aop  Aspectj  ，5.注解
    public Object around(ProceedingJoinPoint joinPoint){

        Object obj = null;
        try {

            System.out.println("开启事务");

            obj = joinPoint.proceed();//  跟 invoke(Object ，args);  用于执行目标方法

            System.out.println("关闭事务");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return obj;
    }

    //4. 异常通知  只有出现异常的时候 才会执行
    public void afterThrowing(Throwable throwable){
        System.out.println("异常通知");
    }

    //5. 最终通知  after
    public  void  after(){
        System.out.println("最终通知");
    }
}

public interface UserDao {

    public void add();
    public int delete(int id);
    public void update();

}

public class UserDaoImpl implements UserDao {
    @Override
    public void add() {
        //int i = 1/0;
        System.out.println("添加");
    }

    @Override
    public int delete(int id) {
        System.out.println("删除");
        return id;
    }

    @Override
    public void update() {
        System.out.println("修改");
    }
}

package com.oracle.AopAnnotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyAspect {

    //单独提取切入点表达式  公共的
    @Pointcut(value = "execution(* com.oracle.AopAnnotation.*.* (..))")
    public void pointcut(){}

    //前置通知
//    @Before(value = "pointcut()")
    public void before(JoinPoint joinPoint){
        System.out.println("开启事务");
    }

    //后置通知
//    @AfterReturning(value = "pointcut()",returning = "obj")
    public void afterReturning(Object obj){
        System.out.println("目标方法的返回值： "+obj);
    }
//
    @Around(value = "pointcut()")
    public Object around(ProceedingJoinPoint joinPoint){
        Object object = null;
        try {
            //前置通知
            before(joinPoint);

           object  = joinPoint.proceed(); //invoke返回对象

            //后置通知
            afterReturning(object);

        } catch (Throwable throwable) {
            //异常通知
            afterThrowing(throwable);
        }finally {
            //最终通知
            after();
        }
        return object;
    }
//
//    @AfterThrowing(value = "pointcut()",throwing = "e")
    public void afterThrowing(Throwable e){
        System.out.println("异常通知");
    }
//
//    @After(value = "pointcut()")
    public void after(){
        System.out.println("最终通知");
    }
}