`

代理模式

AOPSpring编程 
阅读更多 


 动态代理实例


     定义一个接口 


package agentMoudle;

public interface SaleInterface {
     void sale();
}



 实现接口


package agentMoudle;

public class WineSale implements SaleInterface{

	public void sale() {
		// TODO Auto-generated method stub
		 System.out.println("我是酒的总供应商");
	}     
}



 实现接口2


package agentMoudle;

public class SmokeSale  implements SaleInterface{

	public void sale() {
		// TODO Auto-generated method stub
           System.out.print("我是烟的总供应商");		
	}

}



  代理类


package agentMoudle;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
   //该动态代理类需要实现  invocationHandle
public class Agent implements InvocationHandler {
    public Object proxy_obj;
    public Agent(){}
    public Agent(Object obj){
    	this.proxy_obj=obj;
    }
      //根据参数来返回代理对象
    public static Object factory(Object obj){
    	Class cl=obj.getClass();
    	//创建代理类的 newProxyInstance  方法
       return Proxy.newProxyInstance(cl.getClassLoader(),cl.getInterfaces(), new Agent(obj));
    }
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// TODO Auto-generated method stub
		//利用发射生成真正的的对象(即烟酒总供应商)
		return method.invoke(proxy_obj, args);
	}
     
}



   通过代理类调用真是对象的类


 


package agentMoudle;

public class Invocation {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        Agent agent=new Agent();
        //只需调用代理类中factory 方法  在方法中传入不同的参数  即可操作真实的对象
        SaleInterface si= (SaleInterface) agent.factory(new SmokeSale());
	    //根据si调用的方法  来动态 管理 代理类的 的invoke方法  
        si.sale();
	}
}



 


 


 


  以下是转自他人博客的内容


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

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






Java代码 复制代码





    

  1. /**  
    2. 

  2. *切面接口,通过实现这个接口,我们可以对指定函数在调用前后进行处理  
    3. 

  3. */  
    4. 

  4. 
public interface AopInterface {   

    5. 

  5. 
   public void before(Object obj);//调用的处理   

    6. 

  6. 
   public void end(Object obj);//调用后的处理   

    7. 

  7. }  
    8. 





/**
*切面接口,通过实现这个接口,我们可以对指定函数在调用前后进行处理
*/
public interface AopInterface {
   public void before(Object obj);//调用的处理
   public void end(Object obj);//调用后的处理
}





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






Java代码 复制代码





    

  1. public class AopInterfaceImp implements AopInterface{   
    2. 

  2.   
    3. 

  3. 
    public void before(Object obj) {   

    4. 

  4. 
        System.out.println("调用前拦截");   

    5. 

  5.     }   
    6. 

  6.   
    7. 

  7. 
    public void end(Object obj) {   

    8. 

  8. 
        System.out.println("调用调用后处理");   

    9. 

  9.     }   
    10. 

  10.   
    11. 

  11. }  
    12. 





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 PeoxyObject implements InvocationHandler {   
    2. 

  2. 
    private AopInterface aop;//定义了切入时调用的方法   

    3. 

  3. 
    private Object proxy_obj;   

    4. 

  4. 
    private String methodName;//指定要切入的方法名   

    5. 

  5.   
    6. 

  6.     PeoxyObject(){}   
    7. 

  7.   
    8. 

  8. 
    public Object factory(Object obj){   

    9. 

  9.         proxy_obj = obj;   
    10. 

  10.         Class cls = obj.getClass();   
    11. 

  11. 
        return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),this);   

    12. 

  12.     }   
    13. 

  13.   
    14. 

  14. 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {   

    15. 

  15. 
        if(this.aop == null)throw new NullPointerException("aop is null");   

    16. 

  16. 
        if(method == null)throw new NullPointerException("method is null");   

    17. 

  17.   
    18. 

  18.         Object o;   
    19. 

  19. 
//如果指定了要拦截方法名,并且调用的方法和指定的方法名相同,则进行拦截处理   

    20. 

  20. 
//否则当正常方法处理   

    21. 

  21. 
        if(methodName != null && method.toString().indexOf(methodName) != -1){   

    22. 

  22. 
            aop.before(proxy_obj);//指定方法调用前的处理   

    23. 

  23.             o = method.invoke(proxy_obj, args);   
    24. 

  24. 
            aop.end(proxy_obj);//指定方法调用后的处理   

    25. 

  25. 
        }else{   

    26. 

  26. 
            //没有指定的方法,以正常方法调用   

    27. 

  27.             o = method.invoke(proxy_obj, args);   
    28. 

  28.         }   
    29. 

  29. 
        return o;   

    30. 

  30.     }   
    31. 

  31.   
    32. 

  32. 
    public AopInterface getAop() {   

    33. 

  33. 
        return aop;   

    34. 

  34.     }   
    35. 

  35.   
    36. 

  36. 
    public void setAop(AopInterface aop) {   

    37. 

  37. 
        this.aop = aop;   

    38. 

  38.     }   
    39. 

  39.   
    40. 

  40. 
    public String getMethodName() {   

    41. 

  41. 
        return methodName;   

    42. 

  42.     }   
    43. 

  43.   
    44. 

  44. 
    public void setMethodName(String methodName) {   

    45. 

  45. 
        this.methodName = methodName;   

    46. 

  46.     }   
    47. 

  47. }  
    48. 





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. 

  2. 
    public void add(String value1,String value2);   

    3. 

  3. 
    public void acc(String value1);   

    4. 

  4. }   
    5. 

  5.   
    6. 

  6. 
public class ImpObject implements SubInterface{   

    7. 

  7.   
    8. 

  8. 
    public void add(String value1,String value2) {   

    9. 

  9. 
        System.out.println("ImpObject add(String value1,String value2)");   

    10. 

  10.     }   
    11. 

  11.   
    12. 

  12. 
    public void acc(String value1){   

    13. 

  13. 
        System.out.println("ImpObject acc(String value1)");   

    14. 

  14.     }   
    15. 

  15.   
    16. 

  16. }  
    17. 





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 static void main(String agr[]){   
    2. 

  2. 
     PeoxyObject po = new PeoxyObject();   

    3. 

  3.   
    4. 

  4. 
     po.setAop(new AopInterfaceImp());//我们实现的拦截处理对象   

    5. 

  5. 
      po.setMethodName("acc");//指定要拦截的函数   

    6. 

  6.         
    7. 

  7. 
      SubInterface si = (SubInterface)po.factory(new ImpObject());   

    8. 

  8. 
   //因为add方法不是我们指定的拦截函数,AopInterfaceImp是不会被执行   

    9. 

  9. 
      si.add("tt","dd");      

    10. 

  10.   
    11. 

  11. 
   //acc是我们指定的拦截方法,所以调用acc的前后会先执行AopInterfaceImp   

    12. 

  12. 
    //对象的两个方法   

    13. 

  13. 
      si.acc("tt");   

    14. 

  14.  }  
    15. 





   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");
    }





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


  


  

    
    
分享到：
      
      
    

  


  

    

      
      |
      转：log4j
    

  

  

        
  

    
  

    
评论

    
    
    
    
  


  

    
发表评论

            
   您还没有登录,请您登录后再发表评论 

      

  

  





  

    
相关推荐

    
    
    
        
        
    
          
    
            
            
    
              
                
                
                
    
                  
    
                    
                      代理模式的使用示例程序
                    
                  
    
                  
    代理模式是一种设计模式，它在软件工程中扮演着重要的角色，允许我们为其他对象提供一个替代接口，以控制对原始对象的访问。这种模式的主要目的是为了增加灵活性、安全性或者在不修改原有对象的情况下，增强或扩展其...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      JAVA设计模式之代理模式实例
                    
                  
    
                  
    代理模式是设计模式的一种，它提供了一种对目标对象进行增强或者控制访问的方式。在本实例中，我们将深入探讨Java中的代理模式及其应用。  代理模式的核心思想是为一个对象创建一个代理对象，这个代理对象在客户端和...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      设计模式之代理模式Proxy
                    
                  
    
                  
    代理模式是设计模式中的一种结构型模式，它在对象交互中起到了中介的作用，允许通过代理对象来控制对原对象的访问。代理模式的核心思想是为一个对象提供一个替身，以便增加新的功能或者控制对原对象的访问。这种模式...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Android设计模式之代理模式（Proxy Pattern）
                    
                  
    
                  
    代理模式是设计模式的一种，它的主要目的是在不改变原有对象的基础上，为一个对象提供额外的功能或者控制对这个对象的访问。在Android开发中，代理模式的应用尤为常见，尤其在处理复杂的业务逻辑、网络请求、界面...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      android使用signalr代理模式和非代理模式
                    
                  
    
                  
    SignalR提供了两种主要的工作模式：代理模式和非代理模式。这两种模式在实现上有所不同，各自具有优缺点，适用于不同的场景。  **1. 代理模式（Proxy Mode）** 在代理模式下，SignalR为每个Hub（服务端的业务逻辑...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      设计模式-代理模式
                    
                  
    
                  
    代理模式是一种常用的设计模式，它在软件开发中扮演着重要的角色，特别是在iOS平台的应用程序设计中。代理模式的核心思想是为一个对象提供一个替身或代理，以控制对这个对象的访问。这种模式允许我们通过代理来间接...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      java中的三种代理模式
                    
                  
    
                  
    在Java编程中，代理模式是一种常用的面向对象设计模式，它允许我们为一个对象提供一个代理以控制对该对象的访问。代理模式通常用于增加额外的功能，如日志、权限检查等，或者为了创建虚拟代理以提高性能。以下是Java...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      JAVA设计模式（代理模式）
                    
                  
    
                  
    **Java设计模式——代理模式详解**  代理模式是软件设计模式中的一个重要组成部分，它在Java编程中扮演着举足轻重的角色。代理模式的核心思想是为一个对象提供一个替身，这个替身即代理对象，代理对象可以控制对原...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      代理模式小例子
                    
                  
    
                  
    代理模式是一种设计模式，它在软件工程中扮演着重要的角色，允许我们为其他对象提供一个替代接口，以控制对原对象的访问。这种模式的主要目的是为了增加灵活性、安全性或者为对象提供额外的功能，同时保持客户端代码...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      设计模式之代理模式proxy
                    
                  
    
                  
    **设计模式之代理模式（Proxy Pattern）**  设计模式是软件工程中的一种最佳实践，它是在特定情境下解决常见问题的模板。代理模式是其中一种行为设计模式，它的核心思想是为一个对象提供一个替身或者代理，以控制对...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      设计模式实现——代理模式
                    
                  
    
                  
    **设计模式实现——代理模式**  在软件工程中，设计模式是一种通用可重用的解决方案，它描述了在特定上下文中经常出现的问题以及该问题的解决方案。代理模式是设计模式的一种，它提供了一种对目标对象的间接访问方式...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      结构型模式之代理模式（Proxy）
                    
                  
    
                  
    代理模式是一种设计模式，属于结构型模式之一，其主要目的是为其他对象提供一个代理，以控制对该对象的访问。在实际应用中，代理模式能够帮助我们实现如下的功能：  1. 远程代理：代理对象可以代表一个位于远程系统...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Java设计模式-代理模式例子
                    
                  
    
                  
    在这个“Java设计模式-代理模式例子”中，我们将深入探讨代理模式的概念、实现方式以及它在实际开发中的应用。  代理模式的核心思想是为一个对象提供一个替身，这个替身即代理对象，代理对象控制对原对象的访问。在...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      android设计模式之代理模式
                    
                  
    
                  
    代理模式在软件设计中是一种常用的设计模式，尤其在Android开发中，它可以帮助我们实现复杂的控制逻辑，隔离复杂性，以及提供额外的功能。在Android上下文中，代理模式常常用于数据加载、权限控制、事件处理等方面。...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      设计模式C++学习之代理模式（Proxy）
                    
                  
    
                  
    代理模式是一种设计模式，它是结构型模式之一，主要用于在客户端和目标对象之间建立一个代理对象，以便控制对目标对象的访问。在C++中，代理模式可以用来为其他对象提供一种代理以控制对这个对象的访问，或者增加...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Java代理模式Java动态代理
                    
                  
    
                  
    ### Java代理模式与Java动态代理详解  #### 一、代理模式概述  代理模式是一种软件设计模式，它在客户端和目标对象之间提供了一种间接层。这种模式的主要目的是控制客户端对目标对象的访问，并且可以在不修改原有...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      设计模式--代理模式
                    
                  
    
                  
    代理模式是一种常用的设计模式，它在软件开发中扮演着重要角色，允许我们通过一个代理类来控制对原对象的访问。在《设计模式：可复用面向对象软件的基础》（通常称为GoF设计模式）中，代理模式被定义为“为其他对象...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      代理模式 C++实现
                    
                  
    
                  
    代理模式(Proxy) 定义： 为其他对象提供一种代理以控制对这个对象的访问  结构： 由三部分组成 1.RealSubject(真实对象):	真正会调用到的对象  2.Proxy(代理对象):	代理真实对象的地方 3.Subject(共同点):	代理对象...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      cas代理模式代码示例
                    
                  
    
                  
    在IT行业中，代理模式是一种常见的设计模式，它允许我们在不修改原有对象的基础上，为对象添加新的功能或控制访问。在本示例中，我们将重点讨论如何在Java环境下使用代理模式来实现代理逻辑，特别是在CAS（Central ...
    
                
    
                
              
            
    
          
    
        
    
    

  





  
    Magicbox
  













      

            
    

    
    
  

  



   Global site tag (gtag.js) - Google Analytics