java代理模式
静态代理
首先我们有一个接口:
public interface Subject
{
public void hello(String str);
}
然后一个实现类(即真实对象):
public class RealSubject implements Subject
{
public void hello(String str)
{
System.out.println(str);
}
}
接着我们搞一个代理类(代理我们的真实对象):
public class SubjectProxy implements Subject
{
Subject subimpl = new RealSubject();
public void hello(String str)
{
subimpl.hello();
}
}
最后我们调用:
public class TestProxy
{
public static void main(String args[])
{
Subject sub = new SubjectProxy();
sub.hello("hello world");
}
}
以上便是静态代理了,有人便问了“我要那个SubjectProxy代理类有毛用?我这直接调用真实对象不就好了?”
我这里是最简单的例子说明一下代理,但是如果考虑实际情况,你的Subject对象的hello方法不方便改动,但是你又需要在hello之前执行某些代码,(比如say hello之前捋捋发型什么的,保持帅气的造型,咳咳)这时候你最好不就使用代理么,如下:
public class SubjectProxy implements Subject
{
Subject subimpl = new RealSubject();
public void hello(String str)
{
System.out.println("让我先捋捋发型");
subimpl.hello();
}
}
嗯,代理的真正作用就提现在这里了,在不方便改动真实对象方法时候,可以使用代理模式去在执行方法前或之后执行某些代码。
我这再举个栗子:
你要买国外的东西,找代购,你要知道,代购不仅仅只是单纯帮你买东西回来,他还要在买东西之前或者之后收一定的手续费的,是不是?(这就相当于代理在调用目标对象方法之前或者之后执行某些操作)不然,哪个傻子给你去代购?
动态代理
学习动态代理之前我们先来看看为什么使用动态代理?
静态代理我们上面学习过了,可是它有很明显的缺陷,如果我有多个真实的对象,如SubjectOne,SubjectTwo,SubjectThree等等,同样我也得有代理对象ProxyOne,ProxyTwo,ProxyThree等等,这时候我如果都得在hello方法之前捋捋发型(咳咳,淡定),那我不得在ProxyOne,ProxyTwo,ProxyThree等等代理对象里面都修改同样的代码了,那不又得加班到十点,简直不能忍。动态代理就是来解决这个问题的!
好,接下来我们就来学习学习动态代理。
在学习动态代理之前我们先看看下面这两个方法(怎么又是之前之前?还学不学了?!咳咳,别急别急,看完这2个方法就上来了,看管莫要急躁):
Object invoke(Object proxy, Method method, Object[] args) throws Throwable
proxy: 指代我们所代理的那个真实对象
method: 指代的是我们所要调用真实对象的某个方法的Method对象
args: 指代的是调用真实对象某个方法时接受的参数
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
loader:一个ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载
interfaces:一个Interface对象的数组,表示的是我将要给我需要代理的对象提供一组什么接口,如果我提供了一组接口给它,那么这个代理对象就宣称实现了该接口(多态),这样我就能调用这组接口中的方法了
h:一个InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上
先记着这2个方法参数的意义,待会我们就会使用到了。
那我们现在还是有一个接口:
public interface Subject
{
public void hello(String str);
}
还是一个实现类:
public class RealSubject implements Subject
{
@Override
public void hello(String str)
{
System.out.println("hello: " + str);
}
}
这里我们就来介绍介绍动态代理类了,动态代理类必须实现InvocationHandler接口,同时实现invoke()方法,这个方法就是我们去调用真实对象say hello的地方了。
public class DynamicProxy implements InvocationHandler
{
// 这个就是我们要代理的真实对象
private Object subject;
// 构造方法,给我们要代理的真实对象赋初值
public DynamicProxy(Object subject)
{
this.subject = subject;
}
@Override
public Object invoke(Object object, Method method, Object[] args)
throws Throwable
{
//在代理真实对象前我们可以添加一些自己的操作
System.out.println("hello之前让我先捋捋发型");
//当代理对象调用真实对象的方法时,其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
method.invoke(subject, args);
//在代理真实对象后我们也可以添加一些自己的操作
System.out.println("说完之后要保持微笑^-^");
return null;
}
}
最后我们来看看我们怎么去调用:
public class Client
{
public static void main(String[] args)
{
//我们要代理的真实对象
Subject realSubject = new RealSubject();
//我们要代理哪个真实对象,就将该对象传进去,最后是通过该真实对象来调用其方法的
InvocationHandler handler = new DynamicProxy(realSubject);
/*
* 通过Proxy的newProxyInstance方法来创建我们的代理对象,我们来看看其三个参数
* 第一个参数 handler.getClass().getClassLoader() ,我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
* 第二个参数realSubject.getClass().getInterfaces(),我们这里为代理对象提供的接口是真实对象所实行的接口,表示我要代理的是该真实对象,这样我就能调用这组接口中的方法了
* 第三个参数handler, 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
*/
Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject
.getClass().getInterfaces(), handler);
System.out.println(subject.getClass().getName());
subject.hello("hello 美女");
}
}
如上,我们便实现了动态代理模式,这个时候,我们再来想想动态代理开头我说的问题,如果我有多个真实对象,每个在hello之前都想捋捋发型,那我只要把对应的真实对象给丢到这个DynamicProxy里面即可,避免我们去大批量的修改代理对象。
总结:
代理对象通常在客户端调用传递给目标对象 之前
或 之后
,执行某个操作,而不是单纯地将调用传递给目标对象(如果单纯的传递调用对象,那何必用代理?直接用实例对象不就可以了),同时,代理对象可以在执行真实对象操作时,附加其他的操作,相当于对真实对象进行封装。