JDK的动态代理为什么必须要使用接口与使用CGLIB动态代理

一.JDK的动态代理为什么必须要使用接口

JDK的代理Proxy必须要使用接口，才可以实现对方法的拦截。为什么呢？先让我们看一个JDK动态代理的示例：

接口类：

public
interface IPerson {
public
void sayHi(String nm);
}

接口实现类：

public
class Person implements IPerson{
public Person(){//构造
}
private String
name;
public Person(String name){//构造
this.name=name;
}
public
void sayHi(String str){
System.err.println(name+" Hello:"+str);
}
}

使用JDK代理Person类的方法：

@Test
public
void testJdkProxy() throws Exception{
final Dog dog =
new Dog();
//以下必须返回接口，因为Proxy内部，会根据接口创建一个IAnimal的子类，
//创建的这个子类是Dog类的兄弟关系。子类可以转换成父类，但对于平行的两个转换将失败，
//这就是为什么必须要使用接口的原因
IAnimal dog2 = (IAnimal)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
dog.getClass().getInterfaces(),
newInvocationHandler() {
public Objectinvoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.err.println("Before...");
Object o =method.invoke(dog, args);
return o;
}
});
dog2.eat();
boolean boo = Proxy.isProxyClass(dog2.getClass());
System.err.println("是否是被代理对象："+boo+","+dog2.getClass());
}

代码说明：Proxy返回的对象必须要强转为Ianimal的类型。如果要转成Dog类型则会抛出ClassCastException。

Proxy代理可以使用以下简图加以说明：



上图中，最关键，也是最重要的部分就是Proxy在接收到Person类的实例以后，创建了IPerson类的一个子类取名为$Proxy$，此时$Proxy$类与Person类为同级兄弟关系。所以如果使用以下代码将会抛出ClassCastException：

Person person = (Person)Proxy.newInstance(…..);

但使用接口就不会出现异常，即：

IPerson peson = (IPerson)Proxy.newInstance(…..);

１、为了更加清楚为什么会抛出转换异常，我再做如下测试：



声明一个IAnimal接口类：

public
interface IAnimal {

public Dog(String food){
public void eat();
}

实现IAnimal接口的Dog类：

public
class Dog implements IAnimal {
private String
food;
this.food=food;
}
public
void eat() {
System.err.println("小狗吃："+food);
}
}

实现IAnimal接口的Cat类：

public
class Cat implements IAnimal {
private String
food;
public Cat(String food){
this.food=food;
}
public
void eat() {
System.err.println("小猫吃："+food);
}
}

测试是否可以将Dog类的实例转换成Cat,转换时，将会抛出ClassCastException:

IAnimal dog = new Dog("骨头");
IAnimal cat = new Cat("小鱼");
Dog dog2 = (Dog) cat;//cat与dog是兄弟关系不能转换成功，抛出ClassCastException
　　　　dog = cat; //此时将转换成功，因为dog是IAnimal类型，可以指向自己的子类
2、然后再测试使用反射

IAnimal dog = new Dog("骨头");
IAnimal cat = new Cat("小鱼");
boolean boo = dog.getClass()==cat.getClass();
System.err.println(boo);
Method m = dog.getClass().getMethod("eat");//从dog中获取
m.invoke(cat);//不成功，说明反射从哪儿获取方法，就应该调用谁的实例

//但如果是从最高接口中获取到的方法，则可以执行，如下：
Method m2 = IAnimal.class.getMethod("eat");
m2.invoke(dog);//执行成功
System.err.println("---");
m.invoke(cat);//执行成功

上例中：

Methodm = dog.getClass.getMethod(“eat”);

m.invoke(dog);只可以执行dog的方法，如果填入cat则会执行不成功。因为Dog类拥有自己的字节码。

而如果修改成：

Method m = IAnimal.class.getMethod(“eat”);

m.invoke(dog);

m.invoke(cat);//两个调用都可以执行成功因为，Dog和Cat拥有相同的父类接口，而IAnimal字节码只有一份。

二.使用CGLIB动态代理

Cglib是一个优秀的动态代理框架，它的底层使用ASM在内存中动态的生成被代理类的子类。使用CGLIB即使被代理类没有实现任何接口也可以实现动态代理功能。CGLIB具有简单易用，它的运行速度要远远快于JDK的Proxy动态代理：

使用CGLIB需要导入以下两个jar文件：

asm.jar– CGLIB的底层实现。

cglib.jar– CGLIB的核心jar包。

CGLIB的核心类：

net.sf.cglib.proxy.Enhancer– 主要的增强类

net.sf.cglib.proxy.MethodInterceptor – 主要的方法拦截类，它是Callback接口的子接口，需要用户实现

net.sf.cglib.proxy.MethodProxy – JDK的java.lang.reflect.Method类的代理类，可以方便的实现对源对象方法的调用,如使用：

Objecto = methodProxy.invokeSuper(proxy, args);//虽然第一个参数是被代理对象，也不会出现死循环的问题。

费话少说，上代码：

1、使用CGLIB的代理：

以下测试代理一个没有实现任何接口的Person类：

@Test
public
void testProxy1() throws Exception {
final Person p1 =
new Person();　　 //Person类没有实现任何接口
Enhancer en = new Enhancer();　　　 //声明增加类实例
en.setSuperclass(Person.class);　　 //设置被代理类字节码，CGLIB根据字节码生成被代理类的子类
en.setCallback(new MethodInterceptor() {　　　　//设置回调函数，即一个方法拦截
public Object intercept(Object target, Method method,
Object[] args, MethodProxy proxy) throws Throwable {
Object o = method.invoke(p1,args); 　　　//注意参数p1,仍然为外部声明的源对象，且Method为JDK的Method反射
System.err.println("After...");
return o;
}
});
Person p = (Person) en.create(); 　　　//通过create方法返回Person类的代理
System.err.println(p.getClass());//被代理的对象
p.sayHi("Hello");
}

2、以下测试代理一个拥有接口的类：

IAnimal是接口，Dog是实现类，具体代码如下：

@Test
public
void testProxy2() throws Exception {
final Dog dog =
new Dog();
//声明被代理对象
Enhancer en = new Enhancer();
//声明CGLIB增强类
en.setSuperclass(IAnimal.class);
//设置接口类，也可以设置成dog实现类，会影响create返回的对象
en.setCallback(new MethodInterceptor() {
public Object intercept(Object target, Method method,
Object[] args, MethodProxy proxy) throws Throwable {
System.err.println("Before...");
Object o = method.invoke(dog, args);
System.err.println("After...");
return o;
}
});
//Dog dog2 = (Dog)en.create();//必须转型为接口,否则抛出ClassCastException
IAnimal dog2 = (IAnimal)en.create();
dog2.eat();
}

说明：

由于上例中，设置了en.setSuperclass(IAnimal.class)，所以en.create()方法，返回的对象，必须要转换成IAnimal接口。如果转换成Dog则会抛出ClassCastException。

3、将CGLIB再做一个简单的包装：

class CglibProxy
implements MethodInterceptor{
private Object
srcTarget;
private CglibProxy(Object o){
this.srcTarget = o;
}
@SuppressWarnings("unchecked")
public
static <T>T proxyTarget(T t){
Enhancer en= new Enhancer();
en.setSuperclass(t.getClass());
en.setCallback(new CglibProxy(t));
T tt = (T) en.create();
return tt;
}
@Override
public Object intercept(Object obj, Method method, Object[]args,
MethodProxy proxy) throws Throwable {
System.err.println("拦截前...");
Object o = method.invoke(srcTarget, args);
System.err.println("拦截后....");
return o;
}
}

包装以后的调用代码如下，主要是快速的实现获取被代理类：

Person p = CglibProxy.proxyTarget(new Person());
p.sayHi("HJello");
IAnimal dog = CglibProxy.proxyTarget(new Dog());
dog.eat();

4、使用静态方法代理一个没有接口的对象

以下代码，包含在一个测试方法或是main方法中运行：

final Person
src = new Person();
//直接使用静态方法代理一个对象
Person p = (Person) Enhancer.create(Person.class,newMethodInterceptor(){
public Object intercept(Object proxyedObj, Method method, Object[]args,
MethodProxy proxy) throws Throwable {
System.err.println("Hello");
//使用原生的方法调用，注意里面的src
//Object oo= method.invoke(src,
args);
//使用MethodProxy调用父类的代码，同样有效
Object oo = proxy.invokeSuper(proxyedObj, args);
return oo;
}
});
System.err.println(p.getClass());
p.abc();