Spring AOP 原理 理解
AOP基本概念
1)通知（Advice）:织入到目标类连接点上的一段程序代码。通知分为五种类型：
- Before：在方法被调用之前调用
- After：在方法完成后调用通知，无论方法是否执行成功
- After-returning：在方法成功执行之后调用通知
- After-throwing：在方法抛出异常后调用通知
- Around:通知了好、包含了被通知的方法，在被通知的方法调用之前后调用之后执行自定义的行为
2)切点（Pointcut）：AOP通过“切点”定位特定的连接点
3)连接点（Joinpoint）:程序执行的某个特定位置：如类开始初始化前、类初始化后、类某个方法调用前、调用后、方法抛出异常后。这些代码中的特定点，称为“连接点”。
4) 织入（Weaving）：织入是将增强添加到目标类具体连接点上的过程。AOP有三种织入方式：
- 编译期织入，这要求使用特殊的Java编译器；
- 类装载期织入，这要求使用特殊的类装载器；
- 动态代理织入，在运行期为目标类添加增强生成子类的方式。
Spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。
5)切面（Aspect）切面由切点和通知组成，它既包括了横切逻辑的定义，也包括了连接点的定义
Spring 是切片流程
代理模式
就好比明星和经纪人，经纪人负责接活，负责明星唱歌前会场准备，明星唱歌后收钱。 代理类其实就是在代理对象，前后做了一些其他的处理， 这已经具备 AOP的轮廓了
静态代理模式栗子
// 接口
public interface IUserDao {
void save();
void find();
}
// 目标对象
public class UserDao implements IUserDao {
@Override
public void save() {
System.out.println("模拟：保存用户！");
}
@Override
public void find() {
System.out.println("模拟：查询用户");
}
}
/**
* 静态代理 特点：
* 1. 目标对象必须要实现接口
* 2. 代理对象，要实现与目标对象一样的接口
*/
public class UserDaoProxy implements IUserDao {
// 代理对象，需要维护一个目标对象
private IUserDao target = new UserDao();
@Override
public void save() {
System.out.println("代理操作： 开启事务...");
target.save(); // 执行目标对象的方法
System.out.println("代理操作：提交事务...");
}
@Override
public void find() {
target.find();
}
}
public class StaticProxyTest {
/**
* @param args
*/
public static void main(String[] args) {
IUserDao proxy = new UserDaoProxy();
proxy.save();
}
}可以看到，静态代理是必须要有接口的，代理类和目标类都得事先接口，这样就显得很麻烦了，每次代理一个目标对象，就得做一个代理类，有没有一种方式，可以使用一个代理 ，代理多个目标对象呢？
动态代理模式栗子
动态代理不需要提前建立代理，而是在运行时，为目标对象动态生成代理类
// 接口
public interface IUserDao {
void save();
void find();
}
// 目标对象
public class UserDao implements IUserDao {
@Override
public void save() {
System.out.println("模拟： 保存用户！");
}
@Override
public void find() {
System.out.println("查询");
}
}
/**
* 动态代理：JDK 动态代理采用的是反射机制实现
* 代理工厂，给多个目标对象生成代理对象！
*
*/
public class ProxyFactory {
// 接收一个目标对象
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
// 返回对目标对象(target)代理后的对象(proxy)
public Object getProxyInstance() {
Object proxy = Proxy.newProxyInstance(
target.getClass().getClassLoader(), // 目标对象使用的类加载器
target.getClass().getInterfaces(), // 目标对象实现的所有接口
new InvocationHandler() { // 执行代理对象方法时候触发
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// 获取当前执行的方法的方法名
String methodName = method.getName();
// 方法返回值
Object result = null;
if ("find".equals(methodName)) {
// 直接调用目标对象方法
result = method.invoke(target, args);
} else {
System.out.println("开启事务...");
// 执行目标对象方法
result = method.invoke(target, args);
System.out.println("提交事务...");
}
return result;
}
}
);
return proxy;
}
}
public class JDKDynamicProxyTest {
/**
* @param args
*/
public static void main(String[] args) {
// 目标对象
IUserDao target = new UserDao();
// 创建代理类
IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
System.out.println("代理对象: "+proxy.getClass());
proxy.save();
}
}可以总结一下，JDK 动态代理
// 创建代理类
IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();实际上 隐藏了动态的去实现 目标对象的一个接口
class $jdkProxy implements IUserDao{}
也就是说 使用JDK 反射方式实现动态代理，目标对象必须实现一个接口，这就可能出现问题了，假设一个类，就是没有实现接口怎么办？
因此就有了使用CGLIB实现动态代理
CGLIB是使用继承的方式动态生成代理类，这个代理类是继承目标类的，这个就有个问题，需要目标类不被final修饰。
有点类似
public class UserDao{}
// CGLIB 是以动态生成的子类继承目标的方式实现,程序执行时,隐藏了下面的过程
public class $Cglib_Proxy_class extends UserDao{}CGLIB实现
// 目标对象
public class UserDao {
public void save() {
System.out.println("模拟： 保存用户！");
}
public void find() {
System.out.println("查询");
}
}
public class CGLIBProxyFactory {
static class SimpleInterceptor implements MethodInterceptor {
/**
* @see org.springframework.cglib.proxy.MethodInterceptor#intercept(java.lang.Object,
* java.lang.reflect.Method, java.lang.Object[],
* org.springframework.cglib.proxy.MethodProxy)
*/
@Override
public Object intercept(Object target, Method methmod, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("entering " + methmod.getName());
Object result = proxy.invokeSuper(target, args);
System.out.println("leveaing " + methmod.getName());
return result;
}
}
public static <T> T getProxy(Class<T> cls) {
Enhancer enhancer = new Enhancer();
// 继承目标类
enhancer.setSuperclass(cls);
enhancer.setCallback(new SimpleInterceptor());
return (T) enhancer.create();
}
}
public class CGLIBProxyTest {
public static void main(String[] args) {
//生成代理 没有接口
UserDao proxy = (UserDao) CGLIBProxyFactory.getProxy(UserDao.class);
System.out.println("代理类："+ proxy.getClass());
proxy.save();
}
}JDK和CGLIB的区别
1.上面可以可以看到 CGLIB是不需要 目标对象实现接口的， CGLIB是通过继承来实现的
2. JDK动态代理是需要一个具体的目标对象的，但是CGLIB是不需要这么一个具体对象的
Spring AOP 是怎样实现的呢？
1.AOP 是基于动态代理模式
2.AOP是方法级别的
3.AOP可以分类业务代码和关注点代码（日志，事务等）
AOP 是什么时候生成代理的？
AOP 代理主要分为静态代理和动态代理两大类，静态代理以 AspectJ 为代表；而动态代理则以 Spring AOP 为代表
IOC容器BeanDefinitionMap里面结构看内容是啥
bean: class [org.springframework.aop.aspectj.AspectJPointcutAdvisor];
scope=;
abstract=false;
lazyInit=false;
autowireMode=0;
dependencyCheck=0;
autowireCandidate=true;
primary=false;
factoryBeanName=null;
factoryMethodName=null;
initMethodName=null;
destroyMethodName=null,
org.springframework.aop.aspectj.AspectJPointcutAdvisor#2=Root
bean: class [org.springframework.aop.aspectj.AspectJPointcutAdvisor];
scope=;
abstract=false;
lazyInit=false;
autowireMode=0;
dependencyCheck=0;
autowireCandidate=true;
primary=false;
factoryBeanName=null;
factoryMethodName=null;
initMethodName=null;
destroyMethodName=null,
org.springframework.aop.aspectj.AspectJPointcutAdvisor#3=Root
bean:class [org.springframework.aop.aspectj.AspectJPointcutAdvisor];
scope=;
abstract=false;
lazyInit=false;
autowireMode=0;
dependencyCheck=0;
autowireCandidate=true;
primary=false;
factoryBeanName=null;
factoryMethodName=null;
initMethodName=null;
destroyMethodName=null,
org.springframework.aop.aspectj.AspectJPointcutAdvisor#0=Root 参考：