【Spring】【AOP】【学习笔记】Spring开学很好学1.1

发现尽量控制字数更好1点，这真的不是开摆珞

厦工为什么不上网课

AOP

1、AOP术语2、AOP底层原理

2.1、使用JDK动态代理2.2、没接口，使用CGLIB动态代理 3、基于AspectJ的AOP

3.1、注解方式3.2、配置方式

AOP（Aspect Oriented Programming）面向切面编程，是一种不修改源码的情况下，添加功能的种编程思想，OOP有两个不足：对于没有继承关系类的横向共用性，无法处理，也无法动态增加功能。

目的降低耦合

动态代理

有接口，使用JDK动态代理

Proxy类

newProxyInstance()方法 , 三个参数

类加载增强方法所在的类，这个类实现的接口，支持多个接口实现这个接口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 UserDaoProxy implements InvocationHandler {
    private Object 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() + "传递的参数..." + Arrays.toString(args));
        // 被增强的方法执行
        Object res = method.invoke(obj,args);
        System.out.println("方法之后执行" + obj);
        return res;
    }
}

测试

public class JDKProxy {
    public static void main(String[] args) {
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao =
            (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new UserDaoProxy(userDao));
    }
}

方法执行前...add传递的参数...[1, 2]
方法之后执行com.flzj.dao.UserDaoImpl@2b193f2d
3

创建子类代理对象，增强父类方法

class A extends B{
    public void add(){
        super.add();	// 调用父类的B
        // 增强逻辑
    }
}

AspectJ 不是Spring组成部分，独立AOP框架，一般把 AspectJ 和 Spring 框架一起使用AOP操作

切入点表达式

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

@Before(value = "execution(* com.flzj.proxy.User.add(..))")
public void before(){
    System.out.println("before........");
}
@AfterReturning(value = "execution(* com.flzj.proxy.User.add(..))")
public void afterReturn(){
    System.out.println("afterReturn...");
}
@After(value = "execution(* com.flzj.proxy.User.add(..))")
public void after(){
    System.out.println("after.......");
}
@AfterThrowing(value = "execution(* com.flzj.proxy.User.add(..))")
public void afterThrowing(){
    System.out.println("afterThrowing....");
}
@Around(value = "execution(* com.flzj.proxy.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    System.out.println("环绕之前");
    proceedingJoinPoint.proceed();
    System.out.println("环绕之后");
}

环绕之前
before........
add........
环绕之后
after.......
afterReturn...

加上bug

int i = 16 / 0;

环绕之前
before........
after.......
afterThrowing....

相同切入点，需要先写一个方法

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

@Before(value = "pointdemo()")
public void before(){
    System.out.println("before........");
}
@AfterReturning(value = "pointdemo()")
public void afterReturn(){
    System.out.println("afterReturn...");
}
...

需要

1、使用aop名称空间 2、开启组件扫描 3、开启Aspect生成代理对象

xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
...

标签 配置aop增强

标签 配置切入点 id (给切入点取个名字)和 excution 属性

标签 配置切面 ref 属性

标签 增强作用在具体方法 method 属性 pointcut-ref 属性

 禁止速通， 禁止速通， 禁止速通， 禁止速通 禁止速通， 禁止速通， 禁止速通， 禁止速通 禁止速通， 禁止速通， 禁止速通， 禁止速通