AOP相关操作

AOP

基本概念

面向切面编程，可以对业务逻辑各个部分进行隔离，从而使得业务逻辑各个部分耦合度降低，提高可重用性

从业务逻辑代码中分离开来。

不通过修改原代码的方式添加新的功能权限判断模块

底层原理

AOP使用到了动态代理

1.有两种情况的动态代理

一、有接口的情况，使用JDK中的动态代理

创建接口实现类代理对象，增强类的方法

interface UserDao{
    public void login();
}

class UserImpl implements UserDao{
    public void login();
}

JDK的动态代理
    1、创建UserDao接口实现类代理对象

二、没有接口的情况，使用CGLIB动态代理

创建子类的代理对象，用来增强

class User{
    public void add()
    {
        .....
    }
}
//原始方法
class Person extends User{
    public void add()
    {
        super.add;
        增强逻辑
    }
}

//CGLIB动态代理
//创建当前类子类的代理对象
//代理对象

AOP JDK动态代理

//使用Proxy类中的一个方法创建代理对象。
//newProxyInstance方法
//三个参数
//1、classLoad类加载器
//2、增强方法所在的类，这个类实现的接口，可以是多个接口
//3、实现这个接口InvocationHandler,创建代理对象，写增强部分。

//创建接口
public interface UserDao
{
    public int add(int a, int b);
    
    public String update(String id);
}
//创建接口实现类

public class UserDaoImpl implements UserDao
{
    @Override
    public int add(int a, int b)
    {
        return a + b;
    }
    
    
    @Override
    public String update(String id)
    {
        return id;
    }
}

//增强部分
public class JDKProxy
{
    public static void main(String[] args)
    {
       	Class[] interface = {UserDao.class}
        //Proxy.newProxyInstance(JDKProxy.class.getClassLoad, interfaces, )
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoad, interfaces, new UserDaoProxy(userDao));
        int add = dao.add(1, 2);
        System.out.pritnln(add);
    }
}

class UserDaoProxy implements InvocationHandler
{
    //把创建的是谁的代理对象，把谁传递过来
    //有参构造进行传递
    private Objecct obj;
    public UserDaoProxy(Object obj)
    {
        this.obj = obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
    {
        //方法之前
        System.out.println("方法之前。。。。"  + method.getName());
        
        //被增强的方法执行
        Object res = method.invoke(obj, args);
        
        //方法之后
        System.out.println("方法之后执行" + obj);
        return null;
    }
}

AOP术语

1、连接点

哪些方法能被增强，这些方方法就是连接点

2、切入点
实际被真正被增强的方法，成为切入点

3、通知（增强）

实际增强的逻辑部分称为通知（增强）

通知有多种类型

1、前置通知

2、后置通知

3、环绕通知

4、异常通知

5、最终通知 finally

4、切面

是动作

1把通知应用到切入点的过程

class User
{
    add();
    update();
    select();
    delete();
}

AOP操作(准备)

1、Spring框架一般基于AspectJ实现AOP操作

AspectJ

不是Spring组成部分，独立于AOP框架，一般一起使用，进行aop操作

2、基于AspectJ实现AOP操作

• XML文件实现

• 注解方式实现（一般情况下）

引入依赖

4、切入点表达式

知道哪个类里面的哪个方法进行增强

语法结构

execution([权限修饰符] [返回类型] [类全路径] [方法名称] ([参数列表]))

execution(* com.z.dao.BookDao.add(…))

execution(* com.z.dao.BookDao.*(…))

AOP操作（AspectJ注解）

//创建类
@Component
public class User{
    public void add()
    {
        System.out.println("add.....");
    }
}

//创建增强类
//在增强类里面增加方法，代表不同的通知类型


//前置通知
@Component
@Aspect
public class UserProxy
{
    @Before(value="excution(* com.*(..))")
    public void before()
    {
        System.out.println("before..... ");
    }
    
    @After(value="excution(* com.*(..))")
    
    @AfterReturning(value="excution(* com.*(..))")
    
    
  	//异常通知
    @AfterThrowing(value="excution(* com.*(..))")
    
    @Around(value="excution(* com.*(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable
    {
        System.out.println("环绕之前...");
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后")
    }
}
//在sring配置文件中，开启注解扫描
//使用注解创建User和UserProxy对象
//在增强类上面添加注解@Aspect
//开启扫描
//配置不同通知
    //在增强类的里面

开启生成代理对象
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

@Test
public void testAopAnno()
{
	ApplicationContext context = new ClassPathXlApplication("bean1.xml");
    User user = context.getBean("user", User.class);
    user.add();
}

5、细节问题

公共切入点进行抽取

@Pointcut(value="execution(* com.*(..))")
public void pointdemo()
{
    
}

@Before(value = "pointdemo()")
public void before()
{
    ....
}

6、有多个增强类对同一个方法进行增强，可以设置优先级

在增强类上添加注解@Order(数字)数字值越小，优先级越高

@AspectJ
@Component
@Order(0)
public class a{
	@Before(value = "execution()")
    public void before()
    {
        System.out.println("....");
    }
}