springAOP指的是在spring中的AOP，什么是AOP，相对于java中的面向对象（oop），在面向对象中一些公共的行为，像日志记录，权限验证等如果都使用面向对象来做，会在每个业务方法中都写上重复的代码，造成代码的冗余。而AOP指的是面向切面编程，定义一个切面，用切面去切相应的方法，就可以织入相关的逻辑。面向切面编程使用代理模式
代理模式作为23种经典设计模式之一，其比较官方的定义为“为其他对象提供一种代理以控制对这个对象的访问”，简单点说就是，之前A类自己做一件事，在使用代理之后，A类不直接去做，而是由A类的代理类B来去做。代理类其实是在之前类的基础上做了一层封装。java中有静态代理、JDK动态代理、CGLib动态代理的方式。静态代理指的是代理类是在编译期就存在的，相反动态代理则是在程序运行期动态生成的，
静态代理，简单点来说就是在程序运行之前，代理类和被代理类的关系已经确定。静态代理的实现方式一般有以下几个步骤，首先要定义一个公共的接口，供代理类和被代理类实现，如下
package cn.com.staticProxy; /** * * *<p>Title: IUserDao</p> * <p>Description:公共的接口</p> * <p>Company: </p> * @author Administrator * @date 2019年4月24日 下午4:15:12 */ public interface IUserDao { void save(); void find(); }
然后是代理类和被代理类，先看被代理类，
package cn.com.staticProxy; public class UserDao implements IUserDao{ /** * 被代理类或者叫代理目标类 */ @Override public void save() { // TODO Auto-generated method stub System.out.println("模拟保存用户"); } @Override public void find() { // TODO Auto-generated method stub System.out.println("模拟查找用户"); } }
从被代理类上可以看到，被代理类要做的就是save和find操作，如果不使用代理模式，那么我们的使用方式则是直接使用，如下
package cn.com.staticProxy; /** * * *<p>Title: Test2</p> * <p>Description:直接使用被代理类 </p> * <p>Company: </p> * @author Administrator * @date 2019年4月24日 下午4:18:39 */ public class Test2 { public static void main(String[] args) { // TODO Auto-generated method stub IUserDao udp=new UserDao(); udp.save(); System.out.println("-------------------"); udp.find(); } }
通过测试方法，可以得出执行方法的结果如下，
模拟保存用户 ------------------- 模拟查找用户
下面看代理类，
package cn.com.staticProxy; public class UserDaoProxy implements IUserDao { private UserDao ud = new UserDao(); @Override public void save() { // TODO Auto-generated method stub System.out.println("代理操作，开启事务"); ud.save(); System.out.println("代理操作，关闭事务"); } @Override public void find() { // TODO Auto-generated method stub System.out.println("代理操作，开启事务"); ud.find(); System.out.println("代理操作，关闭事务"); } }
可以看到代理类的实现逻辑是在代理类中持有一个被代理类的实例，通过被代理类实例调用被代理对象的方法，另外在方法之前前后均可加入其它的方法处理逻辑，
最后，看使用代理类的测试方法，
package cn.com.staticProxy; public class Test { public static void main(String[] args) { // TODO Auto-generated method stub IUserDao udp=new UserDaoProxy(); udp.save(); System.out.println("-------------------"); udp.find(); } }
返回的执行结果如下，
代理操作，开启事务 模拟保存用户 代理操作，关闭事务 ------------------- 代理操作，开启事务 模拟查找用户 代理操作，关闭事务
对比，使用静态代理和不使用静态代理，可以发现使用了代理之后，可以在被代理方法的执行前或后加入别的代码，实现诸如权限及日志的操作。
但，静态代理也存在一定的问题，如果被代理方法很多，就要为每个方法进行代理，增加了代码维护的成本。有没有其他的方式可以减少代码的维护，那就是动态代理。
JDK提供了动态代理的方式，可以生成代理类，被代理类和接口沿用静态代理中的IUserDao和UserDao，UserDao为被代理类，下面看代理类，
package cn.com.dynamicProxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import cn.com.staticProxy.IUserDao; import cn.com.staticProxy.UserDao; /** * * *<p>Title: DynamicProxy</p> * <p>Description: 动态代理类</p> * <p>Company: </p> * @author Administrator * @date 2019年4月24日 下午4:35:00 */ public class DynamicProxy implements InvocationHandler{ //被代理类的实例 private IUserDao iud=null; @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // TODO Auto-generated method stub Object result=null; System.out.println("开始JDK动态代理"); method.invoke(iud, args); System.out.println("结束JDK动态代理"); return result; } //构造方法 public DynamicProxy(IUserDao iud){ this.iud=iud; } }
需要实现JDK中的InvocationHandler接口，实现其中的invoke方法，在此方法中通过反射的方式调用被代理类的方法，可以在方法执行前或后进行别的处理，下面看测试代码
package cn.com.dynamicProxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import cn.com.staticProxy.IUserDao; import cn.com.staticProxy.UserDao; public class Test2 { public static void main(String[] args) { // TODO Auto-generated method stub UserDao ud=new UserDao(); DynamicProxy dp=new DynamicProxy(ud); //生成代理对象 IUserDao iud=(IUserDao)Proxy.newProxyInstance(ud.getClass().getClassLoader(), ud.getClass().getInterfaces(), dp); iud.save(); System.out.println("--------------"); iud.find(); } }
在测试代码中通过Proxy类的newProxyInstance方法，生成代理类的实例iud，需要三个参数，第一个为被代理类的类加载器，第二个为被代理类实现的接口，第三个则为invocationHandler的实现类，这样就生成了代理对象，然后通过代理对象调用方法执行结果如下，
开始JDK动态代理 模拟保存用户 结束JDK动态代理 -------------- 开始JDK动态代理 模拟查找用户 结束JDK动态代理
另外，由于第三个参数为一个接口，还可以使用匿名内部类的方式进行书写，其实现代码如下，
package cn.com.dynamicProxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import cn.com.staticProxy.IUserDao; import cn.com.staticProxy.UserDao; public class Test { public static void main(String[] args) { // TODO Auto-generated method stub //被代理类的实例 UserDao ud = new UserDao(); IUserDao iud = (IUserDao) Proxy.newProxyInstance(ud.getClass().getClassLoader(), ud.getClass().getInterfaces(), new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // TODO Auto-generated method stub Object result = null; if ("find".equals(method.getName())) { result = method.invoke(ud, args); } else { System.out.println("开始JDK代理"); result = method.invoke(ud, args); System.out.println("结束JDK代理"); } return result; } }); //使用代理类调用方法 iud.find(); System.out.println("----------------"); iud.save(); } }
执行结果如下，
模拟查找用户 ---------------- 开始JDK代理 模拟保存用户 结束JDK代理
从上面可以看出代理类是由Proxy这个类通过newProxyInstance方法动态生成的，生成对象后使用“实例调用方法”的方式进行方法调用，那么代理类的被代理类的关系只有在执行这行代码的时候才会生成，因此成为动态代理。
JDK的动态代理也存在不足，即被代理类必须要有实现的接口，如没有接口则无法使用JDK动态代理（从newProxyInstance方法的第二个参数可得知，必须传入被代理类的实现接口），那么需要使用CGLib动态代理。
CGLib动态代理是一个第三方实现的动态代理类库，不要求被代理类必须实现接口，它采用的是继承被代理类，使用其子类的方式，弥补了被代理类没有接口的不足，
要使用CGLib必须要引入第三方类库，我这里使用的类库如下，
要使用CGLib代理需要实现其MethodInterceptor接口，
package cn.com.cglib; import java.lang.reflect.Method; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; public class MyMethodInterceptor implements MethodInterceptor { @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { // TODO Auto-generated method stub System.out.println("开始CGLib动态代理"); Object object=proxy.invokeSuper(obj, args); System.out.println("结束CGLib动态代理"); return object; } }
其，测试代码如下，
package cn.com.cglib; import cn.com.staticProxy.UserDao; import net.sf.cglib.proxy.Enhancer; public class Test { public static void main(String[] args) { // TODO Auto-generated method stub Enhancer enhancer=new Enhancer(); enhancer.setSuperclass(UserDao.class); enhancer.setCallback(new MyMethodInterceptor()); //生成代理类 UserDao ud=(UserDao) enhancer.create(); ud.save(); System.out.println("----------------"); ud.find(); } }
可以看出使用Enhancer生成代理类，需要设置被代理类，也就是父类（从这里可以看出是使用继承，生成的子类），设置回调方法。
开始CGLib动态代理 模拟保存用户 结束CGLib动态代理 -------------------- 开始CGLib动态代理 模拟查找用户 结束CGLib动态代理
在设置回调enhancer.setCallback的时候需要传入MethodInterceptor的实例，这里可以使用匿名内部类的方式，可参照上面的。
对静态代理、JDK动态代理、CGLib动态代理做一个总结，静态代理的维护成本比较高，有一个被代理类就需要创建一个代理类，而且需要实现相同的接口。JDK动态代理模式和CGLib动态代理的区别是JDK动态代理需要被代理类实现接口，而CGLib则是生成被代理类的子类，要求被代理类不能是final的，因为final类无法被继承。
下次会基于springAOP梳理相关内容。
有不正之处欢迎指正，感谢！
原文链接：https://www.cnblogs.com/teach/p/10763845.html
