SpringAOP面向切面编程详解

SpringAOP模块

一、什么是代理模式？

代理模式（Proxy Pattern）是一种设计模式，它为其他对象提供一种代理以控制对这个对象的访问。代理模式创建了一个代理对象，用来代表实际对象的功能。这种类型的设计模式属于结构型模式，因为此模式以一种方式对对象的结构进行了修改。
总而言之，代理模式就是通过代理对象来访问被代理对象，在代理的过程中可以对方法进行功能的增加。

代理模式主要分为以下两种模式：

1.静态代理（Static Proxy）
2.动态代理（Dynamic Proxy）

二、动态代理与静态代理的区别

静态代理：

在静态代理中，代理类的代码是在编写程序时就已经确定好的，它会在编译时创建并关联到特定的被代理类。
示例代码：

// 抽象接口
public interface IUserService {
    void addUser();
}
 
// 目标对象
public class UserServiceImpl implements IUserService {
    public void addUser() {
        System.out.println("Add User Success!!");
    }
}
 
// 代理对象
public class ServiceProxy implements IUserService {
    private UserServiceImpl userServiceImpl ;
 
    public ServiceProxy(UserServiceImpl userServiceImpl ) {
        this.userServiceImpl =userServiceImpl ;
    }
 
    public void addUser() {
        System.out.println("Find User First");
        userServiceImpl.addUser();
        System.out.println("Close Add User");
    }
}
 
// 客户端代码
public class Client {
    public static void main(String[] args) {
        UserServiceImpl userServiceImpl = new UserServiceImpl ();
        UserServiceImpl proxy = new ServiceProxy(userServiceImpl );
        proxy.addUser();
    }
}

静态代理的主要特点是：

1.代理类在编译时就已经确定：代理类的代码是固定的，不会在运行时改变。
2.需要为每个被代理类创建代理类：这意味着如果有多个被代理类，就需要编写多个对应的代理类。
3.代理类和被代理类实现相同的接口：这是代理模式的基本要求，确保代理类能够替代被代理类。
4.代理类内部持有被代理类的引用：代理类通过这个引用调用被代理类的方法，并可以在调用前后添加额外的逻辑。

动态代理：

动态代理允许开发者在不修改原始类代码的情况下，通过代理对象来间接访问原始对象，并在访问前后执行额外的操作。
示例代码：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
// 抽象接口
public interface Service {
    void performOperation();
}
 
// 目标对象
public class RealService implements Service {
    public void performOperation() {
        System.out.println("Performing operation in RealService");
    }
}
 
// 动态代理处理器
public class ServiceInvocationHandler implements InvocationHandler {
    private Object target;
 
    public ServiceInvocationHandler(Object target) {
        this.target = target;
    }
 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Proxy: Before operation");
        Object result = method.invoke(target, args);
        System.out.println("Proxy: After operation");
        return result;
    }
}
 
// 客户端代码
public class Client {
    public static void main(String[] args) {
        RealService realService = new RealService();
        ServiceInvocationHandler handler = new ServiceInvocationHandler(realService);
        Service proxy = (Service) Proxy.newProxyInstance(realService.getClass().getClassLoader(),
                                                         new Class<?>[]{Service.class},
                                                         handler);
        proxy.performOperation();
    }
}

动态代理的特点
1.运行时生成代理类：动态代理在运行时根据需要动态生成代理类的字节码，并加载到JVM中，而不是在编译时就已经确定。
2.通用性和灵活性：动态代理通常基于接口实现，可以代理实现了特定接口的任意类。这使得动态代理更加通用和灵活，能够应对不同的代理需求。
3.增强的功能：通过代理对象，可以在不修改原始对象代码的情况下，为其添加额外的功能，如日志记录、权限控制、事务管理等。

区别：
1.静态代理：在编译时就已经创建好代理类。
动态代理：在运行时动态生成代理类。
2.静态代理：需要为每个被代理类创建一个代理类，因此被代理类必须事先定义好。
动态代理：可以代理任意实现了接口的类。
3.静态代理：其结构在编译时就确定了，无法在运行时动态地改变代理行为。
动态代理：可以在运行时根据需要改变代理行为。

三、什么是SpringAop？

AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

四、为什么使用SpringAop？

作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强
优势：减少重复代码，提高开发效率，并且便于维护

主要应用场景：
1.日志管理
2.事务管理
3.权限设置

五、SpringAop的主要组件

AOP连接点(Join point)
AOP将所有的方法都视为连接点，不管是接口里面的抽象方法,还是实现类里面的重写方法，都是连接点
AOP切点(Pointcut)
AOP将可能被抽取共性功能的方法称为切入点。切入点是连接点的子集
AOP目标对象(Target): 就是挖掉功能的方法对应的类生的对象，这种对象是无法直接完成最终工作的
AOP织入(Weaving):就是将挖掉的功能回填的动态过程
AOP切面:切点+通知

实现步骤:
1.添加依赖，aop与aspectj表达式的依赖
2.创建spring的主配置文件，bean内的命名空间要添加aop的
3.创建业务代码并编写日志记录代码(事务管理代码)
4.将业务层与日志记录层注入spring容器
5.aop:config–aop配置
aop:aspect–aop切面
aop:before–通知内容与通知类型