当前位置：首页 > CN2资讯 > 正文内容

Java静态代理与动态代理java 动态代理

20小时前CN2资讯

什么是代理

代理是指由委托人与代理人签订代理协议，授权代理人在一定范围内代表其向第三者进行商品买卖或处理有关事务。

代理模式

代理模式是面向对象编程中比较常见的设计模式。

1. 用户只关心接口功能，而不在乎谁提供了功能。上图中接口是 Subject。

2. 接口真正实现者是上图的 RealSubject，但是它不与用户直接接触，而是通过代理。

3. 代理就是上图中的 Proxy，由于它实现了 Subject 接口，所以它能够直接与用户接触。

4. 用户调用 Proxy 的时候，Proxy 内部调用了 RealSubject。所以，Proxy 是中介者，它可以增强 RealSubject 操作。

理解：Subject相当于酒类行业,RealSubject相当于酒类企业,比如茅台、五粮液等。用户去酒类企业授权的代理商那里买酒,而不是直接去企业那里买酒。代理商需要从企业进货。

静态代理

1. 定义一个Subject

package staticProxyDemo;

/**
* Subject(主题)
*/
public interface SellWine {
void maiJiu();
}

2. 定义一个RealSubject

package staticProxyDemo;

/**
* RealSubject
*/
public class SellWuliangye implements SellWine {
@Override
public void maiJiu() {
System.out.println("只见瓶身上写着：正宗五粮液，统一零售价，不卖九毛九，不要卖九毛八，只卖一块九毛九！");
}
}

3. 定义一个静态代理类

package staticProxyDemo;

/**
* Proxy
*/
public class StaticProxy implements SellWine{
private SellWine target;

public StaticProxy(SellWine target){
this.target=target;
}

@Override
public void maiJiu() {
System.out.println("代理商摆摊卖酒中……");
System.out.println("有人来卖酒。");
target.maiJiu();
System.out.println("代理商把酒卖了出去。");
}
}

4. 测试

package staticProxyDemo;

public class ProxyTest {
public static void main(String[] args) {
//主题是卖酒，卖的是五粮液
SellWine sellWine =new SellWuliangye();
//代理商获取卖酒的许可证
StaticProxy staticProxy=new StaticProxy(sellWine);
//代理商摆摊卖酒
staticProxy.maiJiu();
}
}

动态代理

1.定义两个Subject

package dynamicProxyDemo;

/**
* Subject1
*/
public interface SellSomething {
void sell();
}

package dynamicProxyDemo;

/**
* Subject2
*/
public interface BuySomething {
void buy();
}

3. 定义对应的RealSubject

package dynamicProxyDemo;

public class SellWuliangye implements SellSomething {
@Override
public void sell() {
System.out.println("只见招牌上写着：正宗五粮液，统一零售价，不卖九毛九，不要卖九毛八，只卖一块九毛九！");
}
}

package dynamicProxyDemo;

public class BuyAppliance implements BuySomething{
@Override
public void buy() {
System.out.println("只听喇叭中喊着：回收彩电，冰箱，电视机，洗衣机！");
}
}

4. 定义代理商创建类

package dynamicProxyDemo;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
* 动态生成代理对象
*/
public class CreateProxy implements InvocationHandler {
private Object target;//被代理的对象，如：Subject

/**
* 用于创建代理对象
*
* @return 代理对象
*/
public Object proxy(Object target){
this.target=target;
//动态创建代理对象
Object myProxy=Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
return myProxy;
}

/**
*
* @param proxy 代理对象
* @param method 被代理对象的方法
* @param args 被代理对象的方法的参数
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("-------------------------------------------------------");
System.out.println("代理商在摆摊……");
System.out.println("有人走了过来。");
method.invoke(target,args);
System.out.println("那人有走开了。");
return null;
}
}

5. 测试

package dynamicProxyDemo;

public class TestDynamicProxy {
public static void main(String[] args) {
//Subject是SellSomething、BuySomething
//RealSubject是SellWuliangye、BuyAppliance
SellSomething sellWuliangye = new SellWuliangye();
BuySomething buyAppliance = new BuyAppliance();

//创建代理商的工厂
CreateProxy createProxy = new CreateProxy();
//创建代理商1，并授予卖五粮液的许可证
SellSomething proxy1 = (SellSomething) createProxy.proxy(sellWuliangye);//这里必须使用SellSomething，不能使用SellWuliangye
proxy1.sell();//必须在创建proxy2之前调用，否则报错。
//创建代理商2，并授予回收家电的经营证
BuySomething proxy2 = (BuySomething) createProxy.proxy(buyAppliance);//这里必须使用SBuySomething，不能使用BuyAppliance
proxy2.buy();
}
}