一、原理区别:
java动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理。
而cglib动态代理是利用asm开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理。
1、如果目标对象实现了接口,默认情况下会采用JDK的动态代理实现AOP
2、如果目标对象实现了接口,可以强制使用CGLIB实现AOP
3、如果目标对象没有实现了接口,必须采用CGLIB库,spring会自动在JDK动态代理和CGLIB之间转换
如何强制使用CGLIB实现AOP?
(1)添加CGLIB库,SPRING_HOME/cglib/*.jar
(2)在spring配置文件中加入
JDK动态代理和CGLIB字节码生成的区别?
(1)JDK动态代理只能对实现了接口的类生成代理,而不能针对类
(2)CGLIB是针对类实现代理,主要是对指定的类生成一个子类,覆盖其中的方法
因为是继承,所以该类或方法最好不要声明成final
二、代码实现
用户管理接口
package com.lf.shejimoshi.proxy.entity;
//用户管理接口
public interface UserManager {
//新增用户抽象方法
void addUser(String userName,String password);
//删除用户抽象方法
void delUser(String userName);
}
用户管理接口实现类
package com.lf.shejimoshi.proxy.entity;
//用户管理实现类,实现用户管理接口
public class UserManagerImpl implements UserManager{
//重写新增用户方法
@Override
public void addUser(String userName, String password) {
System.out.println("调用了新增的方法!");
System.out.println("传入参数为 userName: "+userName+" password: "+password);
}
//重写删除用户方法
@Override
public void delUser(String userName) {
System.out.println("调用了删除的方法!");
System.out.println("传入参数为 userName: "+userName);
}
}
JDK动态代理
package com.lf.shejimoshi.proxy.jdk;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import com.lf.shejimoshi.proxy.entity.UserManager;
import com.lf.shejimoshi.proxy.entity.UserManagerImpl;
//JDK动态代理实现InvocationHandler接口
public class JdkProxy implements InvocationHandler {
private Object target ;//需要代理的目标对象
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("JDK动态代理,监听开始!");
Object result = method.invoke(target, args);
System.out.println("JDK动态代理,监听结束!");
return result;
}
//定义获取代理对象方法
private Object getJDKProxy(Object targetObject){
//为目标对象target赋值
this.target = targetObject;
//JDK动态代理只能针对实现了接口的类进行代理,newProxyInstance 函数所需参数就可看出
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(), this);
}
public static void main(String[] args) {
JdkProxy jdkProxy = new JdkProxy();//实例化JDKProxy对象
UserManager user = (UserManager) jdkProxy.getJDKProxy(new UserManagerImpl());//获取代理对象
user.addUser("admin", "123123");//执行新增方法
}
}
JDK动态代理运行结果
静态代理
面向接口的编程,代理类与真实类继承自同一个接口(或者继承某个类),下面是具体的代码
public interface Subject {
void doSomething();
}
public class RealSubject implements Subject {
@Override
public void doSomething() {
System.out.println("I'm watching s8 in Korea!");
}
}
public class Proxy implements Subject {
Subject subImp = new RealSubject();
@Override
public void doSomething() {
subImp.doSomething();
after();
}
public void after(){
System.out.println("Congratulations to IG for winning the championship!");
}
}
这里我们可以看到,代理类不仅实现了原有类中的功能在看s8,同时它又在为IG加油。下面进行测试:
public class Main {
public static void main(String[] args) {
Subject sub = new Proxy();
sub.doSomething();
}
}
得到结果如下:
I'm watching s8 in Korea!
Congratulations to IG for winning the championship!
那么什么是动态代理呢,它通过java反射机制(关于java反射请看这里),获取某个被代理类的所有接口,并创建代理类。接口类和被代理类同上
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Proxy1 implements InvocationHandler {
private Object tar;
//绑定委托对象并返回代理类
public Object bind(Object tar) {
this.tar = tar;
return Proxy.newProxyInstance(tar.getClass().getClassLoader(),
tar.getClass().getInterfaces(),
this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
//这里可以进行类似于AOP的操作
System.out.println(this.getClass().getSimpleName()+":G2 enters the quarterfinals"); //在调用具体函数方法前,执行功能扩展
result = method.invoke(tar,args);
System.out.println("EDG lost to AFS");//在调用具体函数方法后,执行功能处理
return result;
}
}
编写测试类:
public static void main(String[] args) {
Proxy1 proxy = new Proxy1();
//返回一个实现该类所有接口的代理类
Subject sub = (Subject) proxy.bind(new RealSubject());
sub.doSomething();
}
}
可得到如下结果:
结果输出
可以看到,动态代理使我们免于去重写接口中的方法,而着重于去扩展相应的功能或是方法的增强,与静态代理相比简单了不少,减少了项目中的业务量
动态代理
动态代理涉及了一个非常重要的类Proxy。正是通过Proxy的静态方法newProxyInstance才会动态创建代理
Proxy
public static Object newProxyInstance(ClassLoader loader,
Class>[] interfaces,
InvocationHandler h)
InvocationHandler
InvacationHandler为一个接口,每一个动态代理的实例都要继承自该接口,如果代理的方法被调用,那么代理便会通知和转发给内部的InvocationHandler实现类,由它决定处理
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}