springAOP指的是在spring中的AOP，什么是AOP，相对于java中的面向对象（oop），在面向对象中一些公共的行为，像日志记录，权限验证等如果都使用面向对象来做，会在每个业务方法中都写上重复的代码，造成代码的冗余。而AOP指的是面向切面编程，定义一个切面，用切面去切相应的方法，就可以织入相关的逻辑。面向切面编程使用代理模式
1.代理模式
代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.
这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法
举个例子来说明代理的作用:假设我们想邀请一位明星,那么并不是直接连接明星,而是联系明星的经纪人,来达到同样的目的.明星就是一个目标对象,他只要负责活动中的节目,而其他琐碎的事情就交给他的代理人(经纪人)来解决.这就是代理思想在现实中的一个例子
代理模式的关键点是:代理对象与目标对象.代理对象是对目标对象的扩展,并会调用目标对象
2.静态代理
静态代理，简单点来说就是在程序运行之前，代理类和被代理类的关系已经确定。静态代理的实现方式一般有以下几个步骤，首先要定义一个公共的接口，供代理类和被代理类实现，如下
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("模拟查找用户");
}
}
从被代理类上可以看到，被代理类要做的就是save和find操作，如果不使用代理模式，那么我们的使用方式则是直接使用，如下
public class Test {
public static void main(String[] args) {
IUserDao userDao=new UserDao();
userDao.save();
System.out.println("-------------------");
userDao.find();
}
}
结果:
模拟保存用户
-------------------
模拟查找用户
下面看代理类
public class UserDaoProxy implements IUserDao {
private UserDao userDao = new UserDao();
@Override
public void save() {
System.out.println("代理操作，开启事务");
userDao.save();
System.out.println("代理操作，关闭事务");
}
@Override
public void find() {
System.out.println("代理操作，开启事务");
userDao.find();
System.out.println("代理操作，关闭事务");
}
}
可以看到代理类的实现逻辑是在代理类中持有一个被代理类的实例，通过被代理类实例调用被代理对象的方法，另外在方法之前前后均可加入其它的方法处理逻辑，
最后，看使用代理类的测试方法
public class Test {
public static void main(String[] args) {
IUserDao userdao=new UserDaoProxy();
userdao.save();
System.out.println("-------------------");
userdao.find();
}
}
执行结果:
代理操作，开启事务
模拟保存用户
代理操作，关闭事务
-------------------
代理操作，开启事务
模拟查找用户
代理操作，关闭事务
对比，使用静态代理和不使用静态代理，可以发现使用了代理之后，可以在被代理方法的执行前或后加入别的代码，实现诸如权限及日志的操作。
但，静态代理也存在一定的问题，如果被代理方法很多，就要为每个方法进行代理，增加了代码维护的成本。有没有其他的方式可以减少代码的维护，那就是动态代理。
3.JDK动态代理
JDK提供了动态代理的方式，可以生成代理类，被代理类和接口沿用静态代理中的IUserDao和UserDao，UserDao为被代理类，下面看代理类
public class DynamicProxy implements InvocationHandler{
//被代理类的实例
private IUserDao userDao=null;
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result=null;
System.out.println("开始JDK动态代理");
method.invoke(userDao, args);
System.out.println("结束JDK动态代理");
return result;
}
public DynamicProxy(IUserDao userDao){
this.userDao=userDao;
}
}
需要实现JDK中的InvocationHandler接口，实现其中的invoke方法，在此方法中通过反射的方式调用被代理类的方法，可以在方法执行前或后进行别的处理，下面看测试代码
public class Test {
public static void main(String[] args) {
UserDao ud=new UserDao();
DynamicProxy dp=new DynamicProxy(ud);
//生成代理对象
IUserDao userDao=(IUserDao)Proxy.newProxyInstance(ud.getClass().getClassLoader(), ud.getClass().getInterfaces(), dp);
userDao.save();
System.out.println("--------------");
userDao.find();
}
}
在测试代码中通过Proxy类的newProxyInstance方法，生成代理类的实例userDao
需要三个参数，第一个为被代理类的类加载器，第二个为被代理类实现的接口，第三个则为invocationHandler的实现类
这样就生成了代理对象，然后通过代理对象调用方法执行结果:
开始JDK动态代理
模拟保存用户
结束JDK动态代理
--------------
开始JDK动态代理
模拟查找用户
结束JDK动态代理
另外，由于第三个参数为一个接口，还可以使用匿名内部类的方式进行书写，其实现代码如下
public class Test {
public static void main(String[] args) {
//被代理类的实例
UserDao ud = new UserDao();
IUserDao userDao = (IUserDao) Proxy.newProxyInstance(ud.getClass().getClassLoader(), ud.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
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;
}
});
//使用代理类调用方法
userDao.find();
System.out.println("----------------");
userDao.save();
}
}
执行结果:
模拟查找用户
----------------
开始JDK代理
模拟保存用户
结束JDK代理
从上面可以看出代理类是由Proxy这个类通过newProxyInstance方法动态生成的，生成对象后使用“实例调用方法”的方式进行方法调用，那么代理类的被代理类的关系只有在执行这行代码的时候才会生成，因此成为动态代理。
JDK的动态代理也存在不足，即被代理类必须要有实现的接口，如没有接口则无法使用JDK动态代理（），那么需要使用CGLib动态代理。
5.CGLib动态代理
CGLib动态代理是一个第三方实现的动态代理类库，不要求被代理类必须实现接口，它采用的是继承被代理类，使用其子类的方式，弥补了被代理类没有接口的不足
要使用CGLib必须要引入第三方类库
使用CGLib代理需要实现其MethodInterceptor接口
public class ProxyFactory implements MethodInterceptor{
//维护目标对象
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
//给目标对象创建一个代理对象
public Object getProxyInstance(){
//1.工具类
Enhancer en = new Enhancer();
//2.设置父类
en.setSuperclass(target.getClass());
//3.设置回调函数
en.setCallback(this);
//4.创建子类(代理对象)
return en.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("开始事务...");
//执行目标对象的方法
Object returnValue = method.invoke(target, args);
System.out.println("提交事务...");
return returnValue;
}
}
public class Test {
public static void main(String[] args) {
ProxyFactory proxyFactory = new ProxyFactory(new UserDao());
UserDao userdao = (UserDao) proxyFactory.getProxyInstance();
userdao.find();
System.out.println("----------------");
userdao.save();
}
}
结果:
开始事务...
模拟查找用户
提交事务...
----------------
开始事务...
模拟保存用户
提交事务...
Spring中强制使用Cglib代理
<aop:aspectj-autoproxy proxy-target-class="true" />
SpringBoot中强制使用Cglib代理
@SpringBootApplication
//强制使用cglib代理
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class SpringbootdemoApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootdemoApplication.class, args);
}
}
总结:
如果加入容器的目标对象有实现接口,用JDK代理
如果目标对象没有实现接口,用Cglib代理
如果目标对象实现了接口，且强制使用cglib代理，则会使用cglib代理。
