java动态代理应用于RMI

最新推荐文章于 2025-04-08 16:37:45 发布
最新推荐文章于 2025-04-08 16:37:45 发布
阅读量1.5k 收藏 1
点赞数
文章标签： java object class import classloader string

动态代理是指客户通过代理类来调用其它对象的方法
动态代理使用场合:
•远程方法调用(RMI)
• 
1.创建一个实现接口InvocationHandler的类，它必须实现invoke方法
2.创建被代理的类以及接口
3.通过Proxy的静态方法
newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 创建一个代理
4.通过代理调用方法
 
参见程序VectorProxy.java
 
view plaincopy to clipboardprint?
package com.langsin.dynamicproxy;  
 
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
import java.util.List;  
import java.util.Vector;  
 
public class VectorProxy implements InvocationHandler  
{  
    private Object proxyobj;  
 
    public VectorProxy(Object obj)  
    {  
        proxyobj = obj;  
    }  
 
    public static Object factory(Object obj)  
    {  
        Class<?> cls = obj.getClass();  
 
        return Proxy.newProxyInstance(cls.getClassLoader(),  
                cls.getInterfaces(), new VectorProxy(obj));  
    }  
 
    public Object invoke(Object proxy, Method method, Object[] args)  
            throws Throwable  
    {  
        System.out.println("before calling " + method);  
 
        if (args != null)  
        {  
            for (int i = 0; i < args.length; i++)  
            {  
                System.out.println(args[i] + "");  
            }  
        }  
        Object object = method.invoke(proxyobj, args);  
 
        System.out.println("after calling " + method);  
        return object;  
    }  
 
    @SuppressWarnings("unchecked")  
    public static void main(String[] args)  
    {  
        List<String> v = (List<String>) factory(new Vector<String>(10));  
 
        v.add("New");  
        v.add("York");  
        System.out.println(v);  
 
        v.remove(0);  
        System.out.println(v);  
    }  
} 
package com.langsin.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.List;
import java.util.Vector;

public class VectorProxy implements InvocationHandler
{
 private Object proxyobj;

 public VectorProxy(Object obj)
 {
  proxyobj = obj;
 }

 public static Object factory(Object obj)
 {
  Class<?> cls = obj.getClass();

  return Proxy.newProxyInstance(cls.getClassLoader(),
    cls.getInterfaces(), new VectorProxy(obj));
 }

 public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable
 {
  System.out.println("before calling " + method);

  if (args != null)
  {
   for (int i = 0; i < args.length; i++)
   {
    System.out.println(args[i] + "");
   }
  }
  Object object = method.invoke(proxyobj, args);

  System.out.println("after calling " + method);
  return object;
 }

 @SuppressWarnings("unchecked")
 public static void main(String[] args)
 {
  List<String> v = (List<String>) factory(new Vector<String>(10));

  v.add("New");
  v.add("York");
  System.out.println(v);

  v.remove(0);
  System.out.println(v);
 }
}
 
参见程序Foo.java
参见程序FooImpl.java
参见程序FooImpl2.java
参见程序CommonInvocationHandler.java
参见程序Demo.java
view plaincopy to clipboardprint?
package com.langsin.dynamicproxy;  
 
public interface Foo  
{  
    void doAction();  
}  
 
 
package com.langsin.dynamicproxy;  
 
public class FooImpl implements Foo  
{  
    public FooImpl()  
    {  
    }  
 
    public void doAction()  
    {  
        System.out.println("in FooImp1.doAction()");  
    }  
}  
 
 
 
package com.langsin.dynamicproxy;  
 
public class FooImpl2 implements Foo  
{  
    public FooImpl2()  
    {  
    }  
 
    public void doAction()  
    {  
        System.out.println("in FooImp2.doAction()");  
    }  
 
}  
 
 
 
 
package com.langsin.dynamicproxy;  
 
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
 
public class CommonInvocationHandler implements InvocationHandler  
{  
 
    // 动态执行对象，需要回调的对象  
    private Object target;  
 
    // 支持构造子注射  
    public CommonInvocationHandler()  
    {  
 
    }  
 
    // 支持构造子注射  
    public CommonInvocationHandler(Object target)  
    {  
        setTarget(target);  
    }  
 
    /** 
     *  
     * 采用setter方法注射 
     *  
     * @param target 
     *  
     */ 
    public void setTarget(Object target)  
    {  
        this.target = target;  
    }  
 
    /** 
     *  
     * 调用proxy中指定的方法method，并传入参数列表args 
     *  
     * @param proxy 
     *            代理类的类型，例如定义对应method的代理接口 
     *  
     * @param method 
     *            被代理的方法 
     *  
     * @param args 
     *            调用被代理方法的参数 
     *  
     * @return 
     *  
     * @throws java.lang.Throwable 
     *  
     */ 
 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable  
    {  
        return method.invoke(target, args);  
    }  
 
}  
 
 
package com.langsin.dynamicproxy;  
 
import java.lang.reflect.Proxy;  
 
public class Demo  
{  
    public static void main(String[] args)  
    {  
 
        // 1.通用的动态代理实现  
 
        CommonInvocationHandler handler = new CommonInvocationHandler();  
 
        Foo f;  
 
        // 2.接口实现1  
 
        handler.setTarget(new FooImpl());  
 
        // 方法参数说明：代理类、代理类实现的接口列表、代理类的处理器  
 
        // 关联代理类、代理类中接口方法、处理器，当代理类中接口方法被调用时，会自动分发到处理器的invoke方法  
 
        // 如果代理类没有实现指定接口列表，会抛出非法参数异常  
 
        f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),  
 
        new Class[] { Foo.class },  
 
        handler);  
 
        f.doAction();  
 
        // 3.接口实现2  
 
        handler.setTarget(new FooImpl2());  
 
        f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),  
 
        new Class[] { Foo.class },  
 
        handler);  
 
        f.doAction();  
    }  
} 
package com.langsin.dynamicproxy;

public interface Foo
{
    void doAction();
}


package com.langsin.dynamicproxy;

public class FooImpl implements Foo
{
    public FooImpl()
    {
    }

    public void doAction()
    {
        System.out.println("in FooImp1.doAction()");
    }
}

 

package com.langsin.dynamicproxy;

public class FooImpl2 implements Foo
{
    public FooImpl2()
    {
    }

    public void doAction()
    {
        System.out.println("in FooImp2.doAction()");
    }

}

 


package com.langsin.dynamicproxy;

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

public class CommonInvocationHandler implements InvocationHandler
{

    // 动态执行对象，需要回调的对象
    private Object target;

    // 支持构造子注射
    public CommonInvocationHandler()
    {

    }

    // 支持构造子注射
    public CommonInvocationHandler(Object target)
    {
        setTarget(target);
    }

    /**
     *
     * 采用setter方法注射
     *
     * @param target
     *
     */
    public void setTarget(Object target)
    {
        this.target = target;
    }

    /**
     *
     * 调用proxy中指定的方法method，并传入参数列表args
     *
     * @param proxy
     *            代理类的类型，例如定义对应method的代理接口
     *
     * @param method
     *            被代理的方法
     *
     * @param args
     *            调用被代理方法的参数
     *
     * @return
     *
     * @throws java.lang.Throwable
     *
     */

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
    {
        return method.invoke(target, args);
    }

}


package com.langsin.dynamicproxy;

import java.lang.reflect.Proxy;

public class Demo
{
 public static void main(String[] args)
 {

  // 1.通用的动态代理实现

  CommonInvocationHandler handler = new CommonInvocationHandler();

  Foo f;

  // 2.接口实现1

  handler.setTarget(new FooImpl());

  // 方法参数说明：代理类、代理类实现的接口列表、代理类的处理器

  // 关联代理类、代理类中接口方法、处理器，当代理类中接口方法被调用时，会自动分发到处理器的invoke方法

  // 如果代理类没有实现指定接口列表，会抛出非法参数异常

  f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),

  new Class[] { Foo.class },

  handler);

  f.doAction();

  // 3.接口实现2

  handler.setTarget(new FooImpl2());

  f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),

  new Class[] { Foo.class },

  handler);

  f.doAction();
 }
}
 
调试


本文来自优快云博客，转载请标明出处：http://blog.youkuaiyun.com/dabizime/archive/2010/05/06/5563574.aspx

Kerry的天空
关注
Java RMI和Java Dynamic Proxy 动态代理的分析
走在前往架构师的路上
12-03 3479
最近准备学习Hadoop RFC的模块架构学习，但是这个模块用到了比较多的java中的比较新颖的知识，比如RMI，和动态代理的了，以及还有在jdk1.4中新添加的额NIO的知识。所以决定先花一点时间，复习一下前2个模块的知识。这样对于Hadoop的RPC通信会比较了解。java RMI和Proxy动态代理我不会高谈阔论，我主要简单的举出两个例子，分析他的调用步骤，，再结合一下他的源码，达到理解，会
java反射机制（2）- 实践：反射机制+动态代理实现模拟RMI远程方法调用
SunnyMarkLiu
11-29 4708
转载请注明出处：反射机制+动态代理实现模拟RMI远程方法调用 1 涉及主要知识点  1、RMI(Remote Method Invocation)：远程方法调用是一种计算机之间利用远程对象互相调用实现双方通讯的一种通讯机制。使用这种机制，某一台计算机上的对象可以调用另外 一台计算机上的对象来获取远程数据。RMI是Enterprise JavaBeans的支柱，是建立分布式Java应用程序的方便途径。
动态代理与RMI远程调用
06-15
动态代理与RMI远程调用附有源码文件，以及ppt讲解
java rmi stub 反编译以后， 动态代理
bingjing12345的专栏
02-13 1803
源文件： /**  *  * User: xingxiaobing  * Date: 2015-02-13  * 远程的接口的实现  */  public class HelloImpl extends UnicastRemoteObject implements IHello {      /**       * 因为UnicastRemoteObject的构造方法抛出了Rem
用JAVA动态代理实现RPC框架
benluobobo的专栏
08-17 5378
先贴一段看到的对动态代理的比较不错的解释 动态代理其实就是Java.lang.reflect.Proxy类动态的根据指定的所有接口生成一个class byte，该class会继承Proxy类，并实现所有指定的接口（在参数中传入的接口数组），也就 是说，返回的对象可以转换类型为接口数组中的任何一个接口类型。然后再利用第一个参数的classloader将class byte加载进系统，最后
Java RMI应用
假装你是大灰狼的专栏
12-10 725
RMI的定义 RPC (Remote Procedure Call):远程方法调用，用于一个进程调用另一个进程中的过程，从而提供了过程的分布能力。 RMI（Remote Method Invocation):远程方法调用，即在RPC的基础上有向前迈进了一步，提供分布式对象间的通讯。允许运...
JAVA的动态代理详解
BASK2311的博客
04-29 757
代理模式是一种设计模式，它允许通过代理对象来控制对另一个对象（称为主题或被代理对象）的访问。代理模式可以在不改变被代理对象的情况下，为被代理对象添加额外的功能，例如访问控制、延迟初始化、日志记录等。
Java中的代理模式：理解与应用
xycxycooo的博客
08-13 812
代理模式的核心思想是创建一个代理对象，作为客户端和真实对象之间的中介。代理对象控制对真实对象的访问，可以在不改变真实对象的情况下，增加额外的功能或逻辑。代理模式是Java中一种强大的设计模式，通过创建代理对象来控制对真实对象的访问，可以在不改变真实对象的情况下，增加额外的功能或逻辑。代理模式分为静态代理和动态代理，动态代理又包括基于接口的动态代理（JDK动态代理）和基于类的动态代理（CGLIB动态代理）。理解并应用代理模式，有助于构建灵活、可维护的软件系统，提高代码的复用性和扩展性。
Java动态代理源码详解
个人博客
08-21 2269
  前言：动态代理在很多底层框架中都会用得到，比如Spring等都用到了动态代理。它的作用很简单，就是将你要使用的类，重新生成一个子类或本类。这样框架就可以利用这个新生成的类做一些事情，比如在该类的方法前后加一些代码。这样的话，你就可以不用修改任何已经编写好的代码，只要使用代理就可以灵活的加入任何东西，将来不用了，也不会影响原来的代码。   Spring的AOP中用到的两种动态代理。   AO...
Java设计模式之代理模式
cl617287的博客
03-28 1166
代理模式是一种结构型设计模式，其目的是在不改变原始类（被代理类）的前提下，通过引入代理类来间接访问原始类，并且可以在代理类中添加额外的逻辑或控制访问原始类的方式。
RMI.rar_Java RMI_java.rmi_java.rmi.Remot_remote
09-20
总之，Java RMI是构建分布式Java应用的重要工具，它简化了网络通信的复杂性，让开发者可以专注于业务逻辑，而不是底层网络实现。虽然现代的Java框架如Spring、EJB等提供了更高级别的分布式服务，但理解RMI的基本原理...
JAVA RMI.rar_Java RMI_ME_RMI java_rmi
09-23
Java Remote Method Invocation (RMI) 是Java平台中用于构建分布式应用程序的一种重要技术。RMI允许Java对象在不同的Java虚拟机（JVM）之间调用方法，从而实现了远程对象的透明访问。这个RAR文件"JAVA RMI.rar"包含...
RMI-Java.rar_Java RMI
09-14
这种特性使得开发者能够构建可扩展的、分布式的Java应用程序。 在"RMI-Java.rar"这个压缩包中，我们可以推测包含的是关于Java RMI的一些示例代码。通过学习和理解这些示例，我们可以深入理解RMI的工作原理和实现...
RMI.zip_Java RMI_RMI java_rmi
09-14
RMI是Java多层架构中的重要组成部分，尤其适用于构建分布式应用程序，如服务器端应用、分布式数据库系统或网格计算环境。 RMI的工作原理基于以下几个核心概念： 1. **远程接口（Remote Interface）**：这是定义...
rmi.rar_Java RMI_RMI java_RMI policy.all_rmi
09-23
描述中提到的"java rmi例子"表明其中可能包含了一个或多个实际的RMI应用实例，这对于学习和理解RMI的工作原理非常有帮助。 首先，让我们详细了解Java RMI的核心概念和组件： 1. **远程接口（Remote Interface）**...
第四十三篇 会计数据仓库建模实战指南- 维度建模在财务系统的深度应用
qq_39991788的博客
04-07 691
关账后仍有数据变更请求。财务数据仓库实施计划。
C++：了解string类的重要函数及模拟实现
2301_81791624的博客
04-08 762
对于常用的一些string的函数，掌握上面的足以应对遇到的绝大部分情况了，并且我们可以看出封装了一个这样的字符串类后，我们以后再使用字符串就可以更加简洁更加方便了。后面会写一篇文章来进行对一些重要函数的模拟实现来帮助大家更加深入的了解这些函数的底层封装。
JavaMath类+设计一个小计算器
Eugene__Chen的博客
04-07 345
(✪ω✪) 曼波来啦！Java的Math类就像哆啦A梦的数学口袋呢~ 准备好接收知识能量了吗？(๑˃̵ᴗ˂̵)و。
TreeMap源码分析与红黑树实现原理
最新发布
m0_71749752的博客
04-08 748
TreeMap通过红黑树保证数据的有序性，同时提供 O(log n) 级别的查找、插入和删除操作。掌握红黑树的旋转（左旋、右旋）及平衡调整机制，可以更好地理解TreeMap的内部实现！
Java动态代理技术解析与应用
动态代理技术在Java中的引入，源自J2SE 1.3版本，但其广泛的应用和重要性却是随着时间的推移逐渐显现的。它对于容器、框架以及服务调用等场景有着重要的作用。 动态代理主要由Java的`java.lang.reflect.Proxy`类和`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值