• 面向过程编程
• 面向对象编程
• 函数式编程
• 事件驱动编程
• 面向切面编程

解耦分离（关注点分离、Separation of Concerns）

• 项目角度

水平分离：展示层 ==> 服务层 ==> 持久层

• 业务角度

• 功能角度

• 集中处理某一关注点/横切逻辑
• 可以很方便地添加/删除关注点
• 侵入性少，增强代码可读性及可维护性

• 权限控制（@PreAuthorize）
• 缓存控制（@Cacheable）
• 事务控制（@Transtacional）
• 异常处理（@AfterThrowing）
  
• 审计日志、性能监控、分布式追踪

补充概念

• @PointCut：用expression表达式，描述在哪些类/方法注入代码

• @Advice：执行方法的什么时机注入

@PointCut的expression表达式

designators（指示器）：

•    *     ：匹配任意数量的字符
•    ..    ：匹配任意数量的子包、参数
•    +    ：指定类及其子类

• &&：与
• ||：或
• ！：非

• “execution（public * com.demo.service.*.*(..)）”

• “execution（public * com.demo.service..*.*(..)）”

• @Before：前置通知
• @After（finally）:后置通知，方法执行完之后
• @AfterReturning：返回通知，成功执行之后
• @AfterThrowing：异常通知，抛出异常之后
• @Around：环绕通知

package com.example.springaop.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

/**
 * @author SHshuo
 * @data 2021/10/25--9:33
 */
@Data
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
public class Product {

    private Long id;
    private String name;
}

package com.example.springaop.service;

import com.example.springaop.pojo.Product;

/**
 * @author SHshuo
 * @data 2021/10/25--9:35
 */
public interface ProductService {

    void insert(Product product);
    void delete(Long id);
}

package com.example.springaop.service.Impl;

import com.example.springaop.pojo.Product;
import org.springframework.stereotype.Service;

/**
 * @author SHshuo
 * @data 2021/10/25--9:36
 */
@Service
public class ProductServiceImpl implements com.example.springaop.service.ProductService {

//    @Autowired
//    private CheckAccess checkAccess;

    @Override
    public void insert(Product product) {
//        checkAccess.checkAccess();
        System.out.println("insert Product");
    }

    @Override
    public void delete(Long id) {
//        checkAccess.checkAccess();
        System.out.println("delete Product");
    }
}

package com.example.springaop.service.Impl;

import com.example.springaop.security.CurrentUserHolder;
import org.springframework.stereotype.Component;

/**
 * @author SHshuo
 * @data 2021/10/25--9:51
 */
@Component
public class CheckAccess {

    public void checkAccess(){
        String user = CurrentUserHolder.get();
        if(!"admin".equals(user)){
            System.out.println("operation not allow");
        }else{
            System.out.println("operation allow");
        }
    }
}

package com.example.springaop.security;

/**
 * @author SHshuo
 * @data 2021/10/25--9:47
 * 将对象暴露出来、共有资源
 */
public class CurrentUserHolder {
    private static final ThreadLocal<String> holder = new ThreadLocal<>();

    public static String get(){
        return holder.get() == null ? "unknown" : holder.get();
    }

    public static void set(String user){
        holder.set(user);
    }
}

package com.example.springaop.security;

import com.example.springaop.service.Impl.CheckAccess;
import org.aspectj.lang.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author SHshuo
 * @data 2021/10/25--10:08
 * 声明Aop
 */

@Component
@Aspect
public class SecurityAspect {

    @Autowired
    private CheckAccess checkAccess;

//    service目录下、包含子目录。。后缀为Impl的类里面已insert开头的方法的任意参数
    @Pointcut("execution(* com.example.springaop.service..*Impl.insert*(..))")
    public void insert(){

    }

    //    service目录下、包含子目录。。后缀为Impl的类里面已delete开头的方法的任意参数
    @Pointcut("execution(* com.example.springaop.service..*Impl.delete*(..))")
    public void delete(){

    }

    @Before("insert() || delete()")
    public void check(){
        checkAccess.checkAccess();
    }
}

package com.example.springaop;

import com.example.springaop.pojo.Product;
import com.example.springaop.security.CurrentUserHolder;
import com.example.springaop.service.ProductService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class SpringAopApplicationTests {

    @Autowired
    private ProductService productService;

    @Test()
    public void deleteTest() {
        try {
//            创建共有对象
            CurrentUserHolder.set("admin");
//            创建对象
            Product product = new Product();
            product.setId(2L).setName("admin");
//            调用方法
            productService.insert(product);
            productService.delete(1L);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

}

Spring AOP 代理的生成过程：

1. 通过ProxyFactoryBean（FactoryBean接口的实现）来去配置相应的代理对象的信息 
2. 在获取ProxyFactoryBean实例时，本质上并未获取到ProxyFactoryBean的对象，而是获取到由ProxyFactoryBean所返回的那个对象实例（getObject方法）
3. 在整个ProxyFactoryBean实例的构建与缓存的过程中，其流程与普通bean的对象完全一致
4. 差别在于，当创建完成ProxyFactoryBean对象后，Spring会判断当前所创建的对象是否是一个FactoryBean实例；如果不是，那么Spring就直接将其返回
5. 如果是，Spring会根据我们在配置信息中所指定的各种元素，如目标对象是否实现了接口以及Advisor等信息，使用动态代理或是CGLIB等方式来为目标对象创建相应的代理对象
6. 当相应的代理对象创建完毕后，Spring就会通过ProxyFactoryBean的getObject方法将所创建的代理对象返回
7. 对象返回到调用端，它本质上是一个代理对象，可以代理对目标对象的访问与调用，这个代理对象对用户来说，就好像是一个目标对象一样
8. 客户在使用代理对象时，可以正常调用目标对象的方法，同时在执行过程中，会根据我们在配置文件中所配置的信息来在调用前后执行额外的附加逻辑

• 编译期（AspectJ）
• 类加载时（AspectJ5 + ）
• 运行时（SpringAOP）

• 静态代理类似于代理模式的实现（具体看设计模式里面的代理模式）
• 参考：https://blog.nowcoder.net/n/dffcbae4c4dd4a389872a0ff34fc4e37

• 缺点：

• proxy代理类不需要一个一个手动的增加新的委托，基本不需要更改。利用反射实现，给我的感觉就是动态的与真实的类里面所有方法进行委托
• JDK代理：基于接口的代理实现
• Cglib代理：基于继承的代理实现

• 通过proxy类动态生成代理类（Proxy.newProxyInstance）
• 实现接口，实现织入的逻辑（invocationHandler）

代码实现：

package com.example.jdkproxy.pojo;

/**
 * @author SHshuo
 * @data 2021/10/31--14:56
 */
public interface Subject {
    void request();
    void newRequest();
}

package com.example.jdkproxy.pojo;

/**
 * @author SHshuo
 * @data 2021/10/31--14:44
 */
public class RealSubject implements Subject{

    @Override
    public void request(){
        System.out.println("hshuo");
    }

    @Override
    public void newRequest() {
        System.out.println("new Hshuo");
    }
}

package com.example.jdkproxy.proxy;

import com.example.jdkproxy.pojo.RealSubject;
import org.springframework.beans.factory.annotation.Autowired;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * @author SHshuo
 * @data 2021/10/31--14:43
 * 相当于Aspect、jdk动态代理。不需要实现subject接口、再委托对应的方法了
 * method.invoke()感觉是直接与对应的真实类联系起来、而不需要每次都委托具体的方法
 */
public class JdkProxy implements InvocationHandler {

    @Autowired
    private RealSubject realSubject;

//    传入参数
    public JdkProxy (RealSubject realSubject){
        this.realSubject = realSubject;
    }

//    动态反射方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        try {
            result = method.invoke(realSubject, args);
        }catch (Exception e){
            System.out.println("e:" + e.getMessage());
            throw e;
        }finally {
            System.out.println("反射结束");
        }
        return result;
    }
}

package com.example.jdkproxy.controller;

import com.example.jdkproxy.pojo.RealSubject;
import com.example.jdkproxy.pojo.Subject;
import com.example.jdkproxy.proxy.JdkProxy;

import java.lang.reflect.Proxy;

/**
 * @author SHshuo
 * @data 2021/10/31--14:44
 * 使用Proxy.newProxyInstance反射创建对象
 */
public class ClentController {
    public static void main(String[] args) {
        Subject subject = (Subject) Proxy.newProxyInstance(ClentController.class.getClassLoader(),
                new Class[]{Subject.class}, new JdkProxy(new RealSubject()));

        subject.request();
        subject.newRequest();
    }
}

Cglib动态代理：

• 调用enhancer.create()
• 织入实现MethodInterceptor里面的intercept
• 给我感觉的区别：将代理类实现的代码部分移动到client设置

package com.example.cglibproxy.service;

/**
 * @author SHshuo
 * @data 2021/10/31--16:01
 */
public interface Subject {

    void request();
    void newRequest();
}

package com.example.cglibproxy.service.Impl;

import com.example.cglibproxy.service.Subject;

/**
 * @author SHshuo
 * @data 2021/10/31--16:02
 * 真实对象
 */
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("hshuo");
    }

    @Override
    public void newRequest() {
        System.out.println("new Hshuo");
    }
}

package com.example.cglibproxy.proxy;

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @author SHshuo
 * @data 2021/10/31--16:03
 * 基于MethodInterceptor实现
 */
public class CglibProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        Object result = null;
        try {
            result = methodProxy.invokeSuper(o, objects);
        }catch (Exception e){
            System.out.println("e:" + e.getMessage());
            throw e;
        }finally {
            System.out.println("反射结束");
        }
        return result;
    }
}

package com.example.cglibproxy.controller;

import com.example.cglibproxy.proxy.CglibProxy;
import com.example.cglibproxy.service.Impl.RealSubject;
import com.example.cglibproxy.service.Subject;
import org.springframework.cglib.proxy.Enhancer;

/**
 * @author SHshuo
 * @data 2021/10/31--16:01
 * Enhancer调用
 */
public class ClientController {
    public static void main(String[] args) {
//        相当于proxy.newProxyInstance()
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(RealSubject.class);
        enhancer.setCallback(new CglibProxy());
        Subject subject = (Subject) enhancer.create();

//        调用
        subject.request();
        subject.newRequest();
    }
}

Cglib与JDK代理的区别：

• JDK代理只能针对有接口（InvocationHandler）的类的接口方法进行动态代理
• Cglib基于继承来实现代理，无法对static（方法+类）、final类进行代理
• JDK、Cglib无法对private方法进行代理

• 由AopProxyFactory根据AdvisedSupport对象的配置类决定；
• 默认的策略是如果目标类是接口，则使用JDK代理；否则使用Cglib代理。