java代理模式

最新推荐文章于 2024-06-16 11:15:34 发布
最新推荐文章于 2024-06-16 11:15:34 发布
阅读量478 收藏
点赞数
分类专栏： 设计模式 文章标签： java object string aop class interface

代理模式:给某一对象提供代理对象,并由代理对象控制具体对象的引用.

代理,指的就是一个角色代表另一个角色采取行动,就象生活中,一个红酒厂商,是不会直接把红酒零售客户的,都是通过代理来完成他的销售业务的.而客户,也不用为了喝红酒而到处找工厂,他只要找到厂商在当地的代理就行了,具体红酒工厂在那里,客户不用关心,代理会帮他处理.

代理模式涉及的角色:
1:抽象主题角色.声明了代理主题和真实主题的公共接口,使任何需要真实主题的地方都能用代理主题代替.

2:代理主题角色.含有真实主题的引用,从而可以在任何时候操作真实主题,代理主题功过提供和真实主题相同的接口,使它可以随时代替真实主题.代理主题通过持有真实主题的引用,不但可以控制真实主题的创建或删除,可以在真实主题被调用前进行拦截,或在调用后进行某些操作.

3:真实代理对象.定义了代理角色所代表的具体对象.

下面是代理模式的实现类图:


根据上图的关系,我们可以用客户买红酒来模拟代理模式的实现,

红酒代理商和红酒厂商都有销售红酒的只能,我们可以为他们定义一个共同的抽象主题角色,

Java代码 复制代码 收藏代码
  1. /**
  2. *抽象主题角色,定义了真实角色和代理角色的公共接口
  3. */
  4. public interface SellInterface{
  5. public Object sell();
  6. } 
/**
*抽象主题角色,定义了真实角色和代理角色的公共接口
*/
public interface SellInterface{
     public Object sell();
}



接着,我们定义真实主题角色(这里就是红酒工厂),它必须实现了SellInterface接口的.

Java代码 复制代码 收藏代码
  1. /**
  2. *真实主题角色,这里指红酒工厂角色,它实现了SellInterface接口
  3. */
  4. public class RedWineFactoryimplements SellInterface{
  5. public Object sell(){
  6. System.out.println("真实主题角色RedWineFactory 被调用了");
  7. return new Object();
  8. }
  9. } 
/**
*真实主题角色,这里指红酒工厂角色,它实现了SellInterface接口
*/
public class RedWineFactory implements SellInterface{
     public Object sell(){
         System.out.println("真实主题角色RedWineFactory 被调用了");
         return new Object();
     }
}



下面是代理主题角色(这里指红酒代理商),同样,代理主题也必须实现SellInterface接口.

Java代码 复制代码 收藏代码
  1. /**
  2. *代理主题角色,这里指红酒代理商.它除了也要实现了sellInterface接口外,还持有红酒
  3. *厂商RedWineFactory 对象的引用,从而使它能在调用真实主题前后做一些必要处理.
  4. */
  5. public class RedWineProxyimplements SellInterface{
  6. //持有一个RedWineFactory对象的引用
  7. private RedWineFactory redWineFactory;
  9. //销售总量
  10. private staticint sell_count =0;
  12. public Object sell(){
  13. if(checkUser()){//在通过代理主题角色,我们可以在真实主题角色被调用前做一些诸如权限判断的事情
  14. Object obj = redWineFactory.sell();
  15. count ++;//同样,在调用后我们也可以执行一些额外的动作.
  16. return obj ;
  17. }else{
  18. throw new RuntimeException();
  19. }
  20. }
  22. protected boolean checkUser(){
  23. //do something
  24. return true;
  25. }
  26. } 
/**
*代理主题角色,这里指红酒代理商.它除了也要实现了sellInterface接口外,还持有红酒
*厂商RedWineFactory 对象的引用,从而使它能在调用真实主题前后做一些必要处理.
*/
public class RedWineProxy implements SellInterface{
     //持有一个RedWineFactory对象的引用
      private RedWineFactory redWineFactory;

     //销售总量
      private static int sell_count = 0;

     public Object sell(){
         if(checkUser()){//在通过代理主题角色,我们可以在真实主题角色被调用前做一些诸如权限判断的事情
             Object obj = redWineFactory.sell();
             count ++;//同样,在调用后我们也可以执行一些额外的动作.
             return obj ;
         }else{
             throw new RuntimeException();
         }
     }

     protected boolean checkUser(){
            //do something
            return true;
     }
}



接下来看看调用代理对象的代码

Java代码 复制代码 收藏代码
  1. public staticvoid main(String agr[])
  2. {
  3. SellInterface sell = new RedWineProxy();
  4. sell.sell();
  5. } 
public static void main(String agr[])
{
     SellInterface sell = new RedWineProxy();
     sell.sell();
}



从上面的例子可以看出代理模式的工作方式,首先,因为代理主题和真实主题都实现了共同的接口,这使我们可以在不改变原来接口的情况下,只要用真实主题对象的地方,都可以用代理主题来代替.其次,代理主题在客户和真实主题之间起了一个中介作用,利用这个中介平台,我们可以在把客户请求传递给真实主题之前,做一些必要的预处理.

java对代理模式的支持 ---动态代理
上面的代理,我们强迫代理类RedWineProxy实现了抽象接口SellInterface.这导致我们的代理类无法通用于其他接口,所以不得不为每一个接口实现一个代理类.幸好,java为代理模式提供了支持.
java主要是通过Proxy类和InvocationHandler接口来给实现对代理模式的支持的.
下面用java的代理机制来实现上面的例子

Java代码 复制代码 收藏代码
  1. import java.lang.reflect.InvocationHandler;
  2. import java.lang.reflect.Method;
  3. import java.lang.reflect.Proxy;
  4. /**
  5. *代理类一定要实现了InvocationHandler接口
  6. */
  7. public class ProxyObjectimplements InvocationHandler{
  8. private Object proxy_obj;
  10. ProxyObject(Object obj){
  11. this.proxy_obj = obj;
  12. }
  14. public static Object factory(Object obj){
  15. Class cls = obj.getClass();
  16. //通过Proxy类的newProxyInstance方法来返回代理对象
  17. return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),new ProxyObject(obj));
  18. }
  20. /**
  21. *实现InvocationHandler接口的invoke
  22. */
  23. public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
  24. System.out.println("函数调用前被拦截了: " + method);
  25. if(args != null){
  26. //打印参数列表
  27. System.out.println("方法有 " + args.length +" 个参数");
  28. for(int i =0; i < args.length; i ++){
  29. System.out.println(args[i]);
  30. }
  31. }
  32. //利用反射机制动态调用原对象的方法
  33. Object mo = method.invoke(proxy_obj, args);
  34. System.out.println("函数调用后进行处理 : " + method);
  35. return mo;
  36. }
  38. //测试代码
  39. public staticvoid main(String agr[]){
  40. SellInterface si = (SellInterface)factory(new RedWineFactory());
  41. si.sell();
  42. }
  43. } 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
*代理类一定要实现了InvocationHandler接口
*/
public class ProxyObject implements InvocationHandler{
    private Object proxy_obj;

    ProxyObject(Object obj){
        this.proxy_obj = obj;
    }

    public static Object factory(Object obj){
        Class cls = obj.getClass();
        //通过Proxy类的newProxyInstance方法来返回代理对象
        return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),new ProxyObject(obj));
    }

/**
*实现InvocationHandler接口的invoke
*/
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("函数调用前被拦截了:   " + method);
        if(args != null){
            //打印参数列表
            System.out.println("方法有  " + args.length + "    个参数");
            for(int i = 0; i < args.length; i ++){
                System.out.println(args[i]);
            }
        }
        //利用反射机制动态调用原对象的方法
         Object mo = method.invoke(proxy_obj, args);
        System.out.println("函数调用后进行处理 :   " + method);
        return mo;
    }

    //测试代码    
    public static void main(String agr[]){
        SellInterface si = (SellInterface)factory(new RedWineFactory());
        si.sell();
    }
}


通过上面的代码可以看出,代理主题ProxyObject类并没有实现我们定义的SellInterface借口,
而是实现了java的InvocationHandler接口,这样就把代理主题角色和我们的业务代码分离开来,使代理对象能通用于其他接口.
其实InvocationHandler接口就是一种拦截机制,当系统中有了代理对象以后,对原对象(真实主题)方法的调用,都会转由InvocationHandler接口来处理,并把方法信息以参数的形式传递给invoke方法,这样,我们就可以在invoke方法中拦截原对象的调用,并通过反射机制来动态调用原对象的方法.这好象也是spring aop编程的基础吧

接着,用代理模式实现一个超级简单的aop拦截机制
这个例子可以拦截我们指定的函数,并在拦截前后根据需要进行处理

Java代码 复制代码 收藏代码
  1. /**
  2. *切面接口,通过实现这个接口,我们可以对指定函数在调用前后进行处理
  3. */
  4. public interface AopInterface {
  5. public void before(Object obj);//调用的处理
  6. public void end(Object obj);//调用后的处理
  7. } 
/**
*切面接口,通过实现这个接口,我们可以对指定函数在调用前后进行处理
*/
public interface AopInterface {
   public void before(Object obj);//调用的处理
   public void end(Object obj);//调用后的处理
}



这个是实现了AopInterface 接口,在这里我们实现了我们的处理逻辑

Java代码 复制代码 收藏代码
  1. public class AopInterfaceImpimplements AopInterface{
  3. public void before(Object obj) {
  4. System.out.println("调用前拦截");
  5. }
  7. public void end(Object obj) {
  8. System.out.println("调用调用后处理");
  9. }
  11. } 
public class AopInterfaceImp implements AopInterface{

    public void before(Object obj) {
        System.out.println("调用前拦截");
    }

    public void end(Object obj) {
        System.out.println("调用调用后处理");
    }

}



接着是代理类

Java代码 复制代码 收藏代码
  1. public class PeoxyObjectimplements InvocationHandler {
  2. private AopInterface aop;//定义了切入时调用的方法
  3. private Object proxy_obj;
  4. private String methodName;//指定要切入的方法名
  6. PeoxyObject(){}
  8. public Object factory(Object obj){
  9. proxy_obj = obj;
  10. Class cls = obj.getClass();
  11. return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),this);
  12. }
  14. public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
  15. if(this.aop ==null)thrownew NullPointerException("aop is null");
  16. if(method == null)thrownew NullPointerException("method is null");
  18. Object o;
  19. //如果指定了要拦截方法名,并且调用的方法和指定的方法名相同,则进行拦截处理
  20. //否则当正常方法处理
  21. if(methodName != null && method.toString().indexOf(methodName) != -1){
  22. aop.before(proxy_obj);//指定方法调用前的处理
  23. o = method.invoke(proxy_obj, args);
  24. aop.end(proxy_obj);//指定方法调用后的处理
  25. }else{
  26. //没有指定的方法,以正常方法调用
  27. o = method.invoke(proxy_obj, args);
  28. }
  29. return o;
  30. }
  32. public AopInterface getAop() {
  33. return aop;
  34. }
  36. public void setAop(AopInterface aop) {
  37. this.aop = aop;
  38. }
  40. public String getMethodName() {
  41. return methodName;
  42. }
  44. public void setMethodName(String methodName) {
  45. this.methodName = methodName;
  46. }
  47. } 
public class PeoxyObject implements InvocationHandler {
    private AopInterface aop;//定义了切入时调用的方法
    private Object proxy_obj;
    private String methodName;//指定要切入的方法名

    PeoxyObject(){}

    public Object factory(Object obj){
        proxy_obj = obj;
        Class cls = obj.getClass();
        return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if(this.aop == null)throw new NullPointerException("aop is null");
        if(method == null)throw new NullPointerException("method is null");

        Object o;
//如果指定了要拦截方法名,并且调用的方法和指定的方法名相同,则进行拦截处理
//否则当正常方法处理
        if(methodName != null && method.toString().indexOf(methodName) != -1){
            aop.before(proxy_obj);//指定方法调用前的处理
            o = method.invoke(proxy_obj, args);
            aop.end(proxy_obj);//指定方法调用后的处理
        }else{
            //没有指定的方法,以正常方法调用
            o = method.invoke(proxy_obj, args);
        }
        return o;
    }

    public AopInterface getAop() {
        return aop;
    }

    public void setAop(AopInterface aop) {
        this.aop = aop;
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }
}



这里定义一个用来测试用的类

Java代码 复制代码 收藏代码
  1. public interface SubInterface {
  2. public void add(String value1,String value2);
  3. public void acc(String value1);
  4. }
  6. public class ImpObjectimplements SubInterface{
  8. public void add(String value1,String value2) {
  9. System.out.println("ImpObject add(String value1,String value2)");
  10. }
  12. public void acc(String value1){
  13. System.out.println("ImpObject acc(String value1)");
  14. }
  16. } 
public interface SubInterface {
    public void add(String value1,String value2);
    public void acc(String value1);
}

public class ImpObject implements SubInterface{

    public void add(String value1,String value2) {
        System.out.println("ImpObject add(String value1,String value2)");
    }

    public void acc(String value1){
        System.out.println("ImpObject acc(String value1)");
    }

}



这里是测试代码

Java代码 复制代码 收藏代码
  1. public staticvoid main(String agr[]){
  2. PeoxyObject po = new PeoxyObject();
  4. po.setAop(new AopInterfaceImp());//我们实现的拦截处理对象
  5. po.setMethodName("acc");//指定要拦截的函数
  7. SubInterface si = (SubInterface)po.factory(new ImpObject());
  8. //因为add方法不是我们指定的拦截函数,AopInterfaceImp是不会被执行
  9. si.add("tt","dd");
  11. //acc是我们指定的拦截方法,所以调用acc的前后会先执行AopInterfaceImp
  12. //对象的两个方法
  13. si.acc("tt");
  14. } 
   public static void main(String agr[]){
        PeoxyObject po = new PeoxyObject();

        po.setAop(new AopInterfaceImp());//我们实现的拦截处理对象
         po.setMethodName("acc");//指定要拦截的函数
        
         SubInterface si = (SubInterface)po.factory(new ImpObject());
      //因为add方法不是我们指定的拦截函数,AopInterfaceImp是不会被执行
         si.add("tt","dd");   

      //acc是我们指定的拦截方法,所以调用acc的前后会先执行AopInterfaceImp
       //对象的两个方法
         si.acc("tt");
    }



通过上面可以看出,拦截机制是代理模式的重要使用方式之一,
除了拦截,代理模式还常用于资源加载,当我们要加载的资源很大时,我们可以让真实主题角色在后台加载资源,让代理主题角色负责处理前台的等待提示信息.
还有就是授权机制,通过代理能拦截真实主题的能力,来控制真实主题的访问权限.

michael8239
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 代理模式
cxyYeChen的博客
07-23 371
什么是代理模式？无法访问目标对象，通过代理对象进行访问，而且增强式的访问。适合进行业务的扩展。代理模式是指，为其他对象提供一种代理，以控制对这个（目标）对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户和目标对象之间起到中介的作用。使用代理对象，是为了在不修改目标对象的基础上，增强主业务逻辑。例如A类想要访问B类，但他不能直接访问，必须通过Proxy代理来来访问功能增强功能限制目标对象的访问分类静态代理。...
设计模式--代理模式
追梦者
11-16 161
代理模式:给某一对象提供代理对象,并由代理对象控制具体对象的引用. 代理,指的就是一个角色代表另一个角色采取行动,就象生活中,一个红酒厂商,是不会直接把红酒零售客户的,都是通过代理来完成他的销售业务的.而客户,也不用为了喝红酒而到处找工厂,他只要找到厂商在当地的代理就行了,具体红酒工厂在那里,客户不用关心,代理会帮他处理. [size=large][color=red]代理模式涉及的角...
JAVA实现代理模式
yiqin的专栏
04-04 379
环境：一个红酒厂商，是不会直接把红酒零售给客户的，都是通过代理来完成他的销售业务。而客户也不用为了购买红酒而到处找工厂，他只要找到厂商在当地的代理就行，具体红酒工厂在那里，客户不用关心，代理会帮他处理。问题：一个客户不想或者不能直接引用另一个对象，此时可以通过一个“中介”来实现间接引用，这个起中介作用的对象就是代理对象。可以通过代理对象去掉客户不能看到的内容和服务或者添加客户需要的额外服务。解决方...
Java代理详解
最新发布
Azhuzhu_chaste的博客
06-16 409
Javassist是一个用于操作Java字节码的指令库，可以分析、编辑和创建Java字节码，通过对.class文件的修改，实现对类的修改和创建。CGLIB 动态代理的实现机制是生成目标类的子类，通过调用父类（目标类）的方法实现，在调用父类方法时在代理中进行增强。在代理方面，CGLIB代理不要求目标对象实现接口，因此它的使用范围更广，不过性能相比JDK动态代理要差一点（但不多）使用代理的场景基本是为了实现一些通用逻辑，个性化逻辑大部分情况下没必要使用代理来处理。JDK动态代理要求目标对象必须实现接口。
代理模式 -- 通过代理对象间接访问对象
智多牛 - 俯首甘为孺子牛！
01-15 2171
代理模式是常用的结构型设计模式之一，当无法直接访问某个对象或访问某个对象存在困难时可以通过一个代理对象来间接访问，为了保证客户端使用的透明性，所访问的真实对象与代理对象需要实现相同的接口。根据代理模式的使用目的不同，代理模式又可以分为多种类型，例如保护代理、远程代理、虚拟代理、缓冲代理等，它们应用于不同的场合，满足用户的不同需求。   15.1 代理模式概述        近年来
Spring 对某个对象进行代理（aop的功能，可以对某个功能进行开关）
Dcwjh的博客
04-04 419
EnableLuban @Retention(RetentionPolicy.RUNTIME) @Import(MyImportSelector.class) public @interface EnableLuban { } Appconfig @ComponentScan("com.luban") @EnableLuban //开启代理功能，去掉就不会对IndexDao进行代理 ...
Java 代理模式详解
12-22
代理模式是我们比较常用的设计模式之一。其中新思想是为了提供额外的处理或者不同的操作而在实际对象与调用者之间插入一个代理对象。这些额外的操作通常需要与实际对象进行通信，代理模式一般涉及到的角色有： 　...
java代理模式示例源码
06-05
在给定的“java代理模式示例源码”中，我们可以通过房产中介的例子来理解这种模式。 房产中介在现实生活中，是客户与房东之间的桥梁，它可以代表客户处理租赁事宜，也可以在房东和客户之间传递信息，这与代理模式的...
16-Java代理模式的学习笔记1
08-08
Java代理模式是一种设计模式，它允许我们为一个对象创建一个代理，这个代理对象可以在调用原始对象的方法之前或之后执行额外的操作。代理模式在软件工程中有多种应用，例如：增加安全控制、性能监控、事务管理等。...
设计模式之代理模式
weixin_30817749的博客
05-19 47
代理模式定义 代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。 举个例子来说明：假如说我现在想买一辆二手车，虽然我可以自己去找车源，做质量检测等一系列的车辆过户流程，但是这确实太浪费我得时间和精力了。我只是想买一辆车而已为什么我还要额外做这么多事呢？于是我就通过中介公司来买车，他们来给我找车源，帮我办理车辆过户流程，我...
《JAVA与模式》之代理模式
weixin_30919235的博客
04-23 173
在阎宏博士的《JAVA与模式》一书中开头是这样描述代理（Proxy）模式的： 　　代理模式是对象的结构模式。代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。 代理模式的结构 　　所谓代理，就是一个人或者机构代表另一个人或者机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 　　代理模式类图如下：...
java设计模式之代理模式
wxhcr912的博客
12-19 242
代理模式的定义：给某一个对象提供一个代理，并由代理对象控制对原对象的引用。在实际生活中，也有代理，例如：房地产中介，明星的经纪人。 代理模式包含如下角色： ISubject：抽象主题角色，是一个接口。该接口是对象和它的代理共用的接口。 RealSubject：真实主题角色，是实现抽象主题接口的类。 Proxy：代理角色，内部含有对真实对象RealSubject的引用，从而可以操作真实对象。
Proxy代理模式之应用
热门推荐
学会改变自己——才能突破
02-18 1万+
一，定义：   代理模式（Proxy）:为其他对象提供一种代理以控制对这个对象的访问。            二，其类图：            三，分类一：静态代理                  1,介绍：也就是需要我们为目标对象编写一个代理对象，在编译期就生成了这个代理对象，然后通过访问这个代理，来实现目标对象某些功能。
Java设计模式之代理模式
红日
05-05 553
代理模式是开发中经常用到的设计模式，代理模式的定义如下： 代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。它使得客户不能直接与真正的目标对象通信。代理对象是目标对象的代表，其他需要与这个目标对象打交道的操作都是和这个代理对象在交涉。 优点： 解耦合性--降低了不同类之间的依赖性。 职责清晰--真实角色只需关注业务逻辑的实现，非业务逻辑部分，后期通过代理类完...
设计模式-8.代理模式
qq_38669394的博客
07-07 218
1.代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。用户可以在代理对象中操作原对象。 2.代理模式的一般应用：提供了对目标对象的间接访问方式，即通过代理访问目标对象。如此便于在目标实现的基础上增加额外的功能操作，前拦截，后拦截等，以满足自身的业务需求。 3.代理模式分为静态代理和动态代理 现在用一个小需求展示：给所有方法添加日志打印功能 打印请求参数。 public class Calculator { //加 public int add(int a, int b.
设计模式之代理模式（借刀杀人！）
lcgoing的博客
02-10 304
一.什么是代理模式？ 给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。 抽象角色：定义代理角色和真实角色的公共对外方法 真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑， 供代理角色调用。 代理角色：实现抽象角色，是真实角色的代理，通过真实角色 的业务逻辑方法来实现抽象方法，并可以附加 自己的操作。 二.代理模式的优势 1.职责清晰：真实的角色就是实现自己的业务...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值