小A:“代理分为哪些类?”
大B:“代理分为静态代理与动态代理。”
小A:“按功能怎么分类哩?”
大B:“按功能将代理的组成类分为:标的类、标的接口、拦截类、耦合类。”
下面以具本代码举例说明。
1、静态与动态代理的公共部分
package proxy。common;
/ *
**AngelSoftware,Inc。
*Copyright(C):
*Description:
*TODO 标的类
*
*Revision History:
*
*/
public class TargetImpl implements Target1,Target2
{
public void doSomething()
{
System。out。println(“doSomething!”);
}
public String do1(String msg)
{
//TODO Auto-generated method stub
System。out。println(do1: msg);
return“this is String Mehtod!”;
}
public int do2()
{
System。out。println(“do2!”);
return 1000;
}
}
package proxy。common;
/ *
*
*
*Copyright(C):
*
*Description:
*TODO 标的接口
*
*Revision History:
*wanginitial version。
*
*
*/
public interface Target1
{
void doSomething();
}
package proxy。common;
/ *
*
*
*Copyright(C):
*
*Description:
*TODO 标的接口
*
*Revision History:
*wang initial version。
*
*
*/
public interface Target2
{
String do1(String msg);
int do2();
}
package proxy。common;
/ *
*
*
*Description:
*TODO 拦载类
*
*Revision History:
*wang initial version。
*
*
*/
public class Intercept
{
public void before()
{
System。out。println(“Before……”);
}
public void after()
{
System。out。println(“After。”);
}
}
2、静态代理特征部分
package proxy。jingtai;
import proxy。common。Intercept;
import proxy。common。TargetImpl;
/ *
**AngelSoftware,Inc。
*Copyright(C):
*
*Description:
*TODO 耦合类(耦合是为了解耦)
*
*
*
*/
public class Invocation
{
public Object invokeDoSomething()
{
TargetImpl t=new TargetImpl();
Intercept p=new Intercept();
//调用真实的标的类的方法之前置入拦载类的方法
p。before();
//调用真实的标的类的方法
t。doSomething();
//调用真实的标的类的方法之后置入拦载类的方法
p。after();
return null;
}
}
package proxy。jingtai;
/ *
*
*
*Description:
*TODO 静态代理(这理只简单地讲一下,着重讲动态代理)
*
*Revision History:
*wang initial version。
*
*
*/
public class Test
{
public static void main(String args[])
{
new Invocation()。invokeDoSomething();
}
}
3、动态代理特征部分
package proxy。dongtai;
import java。lang。reflect。InvocationHandler;
import java。lang。reflect。Method;
import proxy。common。Intercept;
import proxy。common。TargetImpl;
/ *
**AngelSoftware,Inc。
*Copyright(C):
*
*Description:
*TODO 耦合类(耦合是为了解耦)
*
*Revision History:
*wang initial version。
*
*
*/
public class Invocation implements InvocationHandler
{
public Object invoke(Object proxy,Method method,Object[]args)
throws Throwable
{
TargetImpl t=new TargetImpl();
Intercept p=new Intercept();
if(args!=null&args。length……1)
{
//更改参数
args[0]=“param value has changed”;
}
//调用真实的标的类的方法之前置入拦载类的方法
p。before();
//调用真实的标的类的方法
Object o=method。invoke(t,args);
//调用真实的标的类的方法之后置入拦载类的方法
p。after();
return o;
}
}
package proxy。dongtai;
import proxy。common。Target1;
import proxy。common。Target2;
/ *
*
*
*Copyright(C):
*
*Description:
*TODO 测试类
*
*
*
*/
public class Test
{
/ *logic1与logic的共同逻辑
*@param proxy 代理
*/
private static void publicLogic(Object proxy)
{
//对目标接口Target1代理的调用
System。out。println(“对目标接口Target1代理的调用”);
Target1 t1=(Target1)proxy;
t1.doSomething();
System。out。println();
//对目标接口Target2的调用
System。out。println(“对目标接口Target2代理的调用”);
Target2 t2=(Target2)proxy;
System。out。println(Target Mehod do1 return:“ t2.do1(”hello!));
System。out。println(Target Mehod do2 return: t2.do2());
System。out。println();
System。out。println();
}
/ *new Class[]{Target2.class,Target1.class}
*正常
*@return
*/
public static void logic1()
{
Invocation iv=new Invocation();
/*
*Proxy。newProxyInstance的参数说明
*参数1:类加载器(个人感觉这个参数有点多佘,这个参数完成可以去掉,不知当初他们为何要设这个参数干么)
*参数2:代理的标的接口。就是说,你要代理的标的类可能会实现多个接口,你可以有选择性地代理这些接口
*参数3:InvocationHandler的实现类。InvocationHandler接口做用就是解耦,解开标的类与拦载类之间的耦合,使它们之间可以互不关心
*/
Object proxy=java。lang。reflect。Proxy。newProxyInstance(Thread。currentThread()。getContextClassLoader(),new Class[]{Target2.class,Target1.class},iv);
publicLogic(proxy);
}
/ *new Class[]{Target1.class}
*将会出异常,因为他没有在参数中声时自己要调用Target2接口,而后面却又去调用
*@return
*/
public static void logic2()
{
Invocation iv=new Invocation();
/*
*Proxy。newProxyInstance的参数说明
*参数1:类加载器(个人感觉这个参数有点多佘,这个参数完成可以去掉,不知当初他们为何要设这个参数干么)
*参数2:代理的标的接口。就是说,你要代理的标的类可能会实现多个接口,你可以有选择性地代理这些接口
*参数3:InvocationHandler的实现类。InvocationHandler接口做用就是解耦,解开标的类与拦载类之间的耦合,使它们之间可以互不关心
*/
Object proxy=java。lang。reflect。Proxy。newProxyInstance(Thread。currentThread()。getContextClassLoader(),new Class[]{Target1.class},iv);
publicLogic(proxy);
}
public static void main(String args[])
{
logic1();
logic2();
}
}