动态代理是java反射机制的重要的应用。总结动态代理这一篇也算是对上一篇反射机制的扩展吧。那我们就先从静态代理说起。
静态代理
问题描述
一个品牌衣服工厂,拥有很多方法,如购买布料,购买染料,生产衣服,设计款式等等,现在需要一个对象(代理对象,俗称秘书)代替工厂来完成生产衣服这一工作。而其他的工作也可以由其他的代理对象(秘书)来完成对应的工作,这样就不用工厂自己完成工作了,就如同生活中,老板赋予秘书某种权利,秘书代理老板的某项工作一样。
具体的类
工厂生产衣服的接口
interface ClothFactory{//创建一个生产衣服的工厂的接口,所有品牌的衣服工厂,都必须继承这个接口来生产衣服
void ProductCloth();//工厂生产衣服的抽象方法
}
工厂的实现类
class NikeClothFactory implements ClothFactory{//创建Nike工厂,此工厂可能还需要实现其他的接口,购买染料,布料等方法的接口
@Override
public void ProductCloth() {//Nike工厂生产衣服的方法
System.out.println("Nike工厂生产一批衣服");//Nike工厂生产衣服的动作
}
//此工厂其他方法就不一一列出,比如实现的其它接口的方法:购买染料,布料等
}
代理类
说明:当Nike工厂生产衣服时,Nike工厂不亲自生产,而需要一个代理对象来代替它完成生产衣服的工作,这个代理对象充当秘书的角色,来代理这一个功能(相当于老板赋予秘书一项权利,代替老板完成任务),所以代理类必须也实现对应的接口,但不需要实现Nike工厂所实现的其他接口。
class ProxyFactory implements ClothFactory{//代理类,实现对应的接口(生产衣服的接口)
ClothFactory cf;//被代理的对象
public ProxyFactory(ClothFactory cf) {//创建代理类的对象时,实际传入一个被代理类的对象,这就相当于工厂(被代理对象)把自己的权利赋予别人
this.cf = cf;
}
@Override
public void ProductCloth() {
System.out.println("代理类开始执行,收代理费$1000");//收取代理所需的劳动费用
cf.ProductCloth();//执行自己的代理职责
}
}
主程序
public class TestClothProduct {
public static void main(String[] args) {
NikeClothFactory nike = new NikeClothFactory();//创建被代理类的对象
ProxyFactory proxy = new ProxyFactory(nike);//创建代理类的对象
proxy.ProductCloth();//代理对象(秘书)开始工作
}
}
执行结果
静态代理的缺点:每当被代理的对象要求代理对象代替他去完成某项工作时(运行某个方法),代理对象就必须实现对应的接口,并且实现对应的方法,而动态代理的出现,很优雅的就解决了这一问题。
动态代理
问题描述
在这里就不论述怎么让代理对象代替工厂完成生产衣服的工作了,论述同一个问题是乏味的,是没有意义的,这样总结的java知识就失去了灵魂,失去了优雅,大家可以私下偷偷地用动态代理实现上述静态代理的问题。接下来不用动态代理解决某一特定的问题,就是很平常,很通用的问题:代理对象代理被代理对象完成自己所代理的方法(注意这句话的断句:代理对象-代理-被代理对象-完成-代理对象-所代理的方法)
具体的类
接口
interface Subject{
void action();
}
被代理的类(老板)
class RealSubject implements Subject{//此类希望具有action方法,所以继承了Subject接口,当然,它还可以有其他方法,甚至继承其他接口,这里就不一个个写到类里面了
public void action() {//方法的实现
System.out.println("我是被代理的方法,记得要执行我哦!木~~啊~");
}
}
MyInvocationHandler 类(注意:不是代理类,这个类的实例化对象可以动态的产生代理类,或直接获得代理对象。此类必须实现InvocationHandler接口;产生代理类或代理对象用到Proxy类的静态方法)
class MyInvocationHandler implements InvocationHandler{
Object obj;//声明被代理的对象,因为所有Object是所有类的根父类,所以被代理的对象被声明为Object
public Object blind(Object obj) {//①给被代理的对象实例化,传入被代理的对象
this.obj = obj;//前面声明的obj引用被代理的对象
/*
②下面这一句返回一个代理类的对象,调用Proxy类的静态方法newProxyInstance(),
传入参数(被代理对象的类加载器,被代理对象的所有接口,当前对象)-----这里就用到了反射,获得了obj对象的类的信息(类的加载器和实现的接口)
*/
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);//返回一个代理对象(秘书)
}
//当通过代理对象发起对被重写的方法的调用时,都会转化为对如下的invoke方法的调用
@Override//实现InvocationHandler接口,所需要实现的方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//实现方法
//当通过代理对象发起对代理的方法的调用时,都会转化为invoke方法的调用,而method.invoke(obj, args)才是真正执行的代理方法(秘书代替老板完成工作的实际动作,obj为老板,args是完成被代理的方法所需要的参数),此方法是有返回值的,当被代理的方法有返回值,则此方法返回相应的值,如果被代理方法无返回值,则返回null
Object returnVal = method.invoke(obj, args);
return returnVal;
}
}
主程序
public static void main(String[] args) {
RealSubject real = new RealSubject();//1.创建被代理类的对象
MyInvocationHandler handler = new MyInvocationHandler();//2.创建一个实现InvocationHandler接口的类的对象
Object obj = handler.blind(real);//3.动态地获取real对象(被代理对象)的代理对象,返回值为Object类型
Subject sub = (Subject)obj;//此时的sub就是代理对象,类型转化为Subject(这就说明sub代理了Subject接口的方法);如果要代理其他方法,也可以类型转化为其他接口
//4.用代理类的对象调用方法
sub.action();//转到对MyInvocationHandler对象的invoke()方法的调用
/*
如果上述方法需要传入参数,最终经过底层的实现,
无论多少参数,都会在代理对象的method.invoke(obj, args)方法的args里
*/
//再举一例,就是上述静态代理的问题
NikeClothFactory nike = new NikeClothFactory();//创建被代理类对象
ClothFactory proxyCloth = (ClothFactory)handler.blind(nike);//获取代理对象invoke方法的
proxyCloth.ProductCloth();//调用需要被代理的方法
}
运行结果
以上就是动态代理的基本内容,动态代理的一个重要应用就是AOP(Aspect-Oriented Programming)编程