← Back to branch summary

~ubuntu-branches/ubuntu/precise/classpath/precise

« back to all changes in this revision

Viewing changes to java/rmi/server/RemoteObjectInvocationHandler.java

  • Committer: Bazaar Package Importer
  • Author(s): Michael Koch
  • Date: 2006-05-27 16:11:15 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20060527161115-h6e39eposdt5snb6
Tags: 2:0.91-3
http://bugs.debian.org/368172
* Install header files to /usr/include/classpath.
* debian/control: classpath: Conflict with jamvm < 1.4.3 and
  cacao < 0.96 (Closes: #368172).

Show diffs side-by-side

added added

removed removed

Lines of Context:
java/rmi/server/RemoteObjectInvocationHandler.java
 
1
/* RemoteObjectInvocationHandler.java -- RMI stub replacement.
 
2
 Copyright (C) 2005 Free Software Foundation, Inc.
 
3
 
 
4
 This file is part of GNU Classpath.
 
5
 
 
6
 GNU Classpath is free software; you can redistribute it and/or modify
 
7
 it under the terms of the GNU General Public License as published by
 
8
 the Free Software Foundation; either version 2, or (at your option)
 
9
 any later version.
 
10
 
 
11
 GNU Classpath is distributed in the hope that it will be useful, but
 
12
 WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
 General Public License for more details.
 
15
 
 
16
 You should have received a copy of the GNU General Public License
 
17
 along with GNU Classpath; see the file COPYING.  If not, write to the
 
18
 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 
19
 02110-1301 USA.
 
20
 
 
21
 Linking this library statically or dynamically with other modules is
 
22
 making a combined work based on this library.  Thus, the terms and
 
23
 conditions of the GNU General Public License cover the whole
 
24
 combination.
 
25
 
 
26
 As a special exception, the copyright holders of this library give you
 
27
 permission to link this library with independent modules to produce an
 
28
 executable, regardless of the license terms of these independent
 
29
 modules, and to copy and distribute the resulting executable under
 
30
 terms of your choice, provided that you also meet, for each linked
 
31
 independent module, the terms and conditions of the license of that
 
32
 module.  An independent module is a module which is not derived from
 
33
 or based on this library.  If you modify this library, you may extend
 
34
 this exception to your version of the library, but you are not
 
35
 obligated to do so.  If you do not wish to do so, delete this
 
36
 exception statement from your version. */
 
37
 
 
38
 
 
39
package java.rmi.server;
 
40
 
 
41
import gnu.java.rmi.server.RMIHashes;
 
42
 
 
43
import java.io.Serializable;
 
44
import java.lang.reflect.InvocationHandler;
 
45
import java.lang.reflect.Method;
 
46
import java.lang.reflect.Proxy;
 
47
import java.rmi.Remote;
 
48
import java.rmi.RemoteException;
 
49
import java.rmi.UnexpectedException;
 
50
import java.rmi.registry.Registry;
 
51
import java.rmi.server.RemoteObject;
 
52
import java.rmi.server.RemoteRef;
 
53
import java.rmi.server.UnicastRemoteObject;
 
54
import java.util.Hashtable;
 
55
 
 
56
/**
 
57
 * Together with dynamic proxy instance, this class replaces the generated RMI
 
58
 * stub (*_Stub) classes that (following 1.5 specification) should be no longer
 
59
 * required. It is unusual to use the instances of this class directly in the
 
60
 * user program. Such instances are automatically created and returned by
 
61
 * {@link Registry} or {@link UnicastRemoteObject} methods if the remote
 
62
 * reference is known but the corresponding stub class is not accessible.
 
63
 * 
 
64
 * @see Registry#lookup
 
65
 *
 
66
 * @author Audrius Meskauskas (AudriusA@Bioinformatics.org)
 
67
 */
 
68
public class RemoteObjectInvocationHandler extends RemoteObject implements
 
69
    InvocationHandler, Remote, Serializable
 
70
{
 
71
  /**
 
72
   * Use the jdk 1.5 SUID for interoperability.
 
73
   */
 
74
  static final long serialVersionUID = 2L;
 
75
  
 
76
  /**
 
77
   * The RMI method hash codes, computed once as described in the section 8.3
 
78
   * of the Java Remote Method Invocation (RMI) Specification.
 
79
   */
 
80
  static Hashtable methodHashCodes = new Hashtable();
 
81
  
 
82
  /**
 
83
   * The empty class array to define parameters of .hashCode and .toString.
 
84
   */
 
85
  static final Class[] noArgsC = new Class[0];
 
86
  
 
87
  /**
 
88
   * The class array to define parameters of .equals
 
89
   */
 
90
  static final Class[] anObjectC = new Class[] { Object.class };
 
91
  
 
92
  /**
 
93
   * The empty object array to replace null when no args are passed.
 
94
   */
 
95
  static final Object[] noArgs = new Object[0];
 
96
  
 
97
  /**
 
98
   * Construct the remote invocation handler that forwards calls to the given
 
99
   * remote object.
 
100
   * 
 
101
   * @param reference the reference to the remote object where the method
 
102
   * calls should be forwarded.
 
103
   */
 
104
  public RemoteObjectInvocationHandler(RemoteRef reference)
 
105
  {
 
106
    super(reference);
 
107
  }
 
108
 
 
109
  /**
 
110
   * Invoke the remote method. When the known method is invoked on a created RMI
 
111
   * stub proxy class, the call is delivered to this method and then transferred
 
112
   * to the {@link RemoteRef#invoke(Remote, Method, Object[], long)} of the
 
113
   * remote reference that was passed in constructor. The methods are handled as
 
114
   * following:
 
115
   * <ul>
 
116
   * <li> The toString() method is delegated to the passed proxy instance.</li>
 
117
   * <li>The .equals method only returns true if the passed object is an
 
118
   * instance of proxy class and its invocation handler is equal to this
 
119
   * invocation handles.</li>
 
120
   * <li>The .hashCode returns the hashCode of this invocation handler (if the.</li>
 
121
   * <li>All other methods are converted to remote calls and forwarded to the
 
122
   * remote reference. </li>
 
123
   * </ul>
 
124
   * 
 
125
   * @param proxyInstance
 
126
   *          the instance of the proxy stub
 
127
   * @param method
 
128
   *          the method being invoked
 
129
   * @param parameters
 
130
   *          the method parameters
 
131
   * @return the method return value, returned by RemoteRef.invoke
 
132
   * @throws IllegalAccessException
 
133
   *           if the passed proxy instance does not implement Remote interface.
 
134
   * @throws UnexpectedException
 
135
   *           if remote call throws some exception, not listed in the
 
136
   *           <code>throws</code> clause of the method being called.
 
137
   * @throws Throwable
 
138
   *           that is thrown by remote call, if that exception is listend in
 
139
   *           the <code>throws</code> clause of the method being called.
 
140
   */
 
141
  public Object invoke(Object proxyInstance, Method method, Object[] parameters)
 
142
      throws Throwable
 
143
  {
 
144
    if (!(proxyInstance instanceof Remote))
 
145
      {
 
146
        String name = proxyInstance == null ? "null"
 
147
                                           : proxyInstance.getClass().getName();
 
148
        throw new IllegalAccessException(name + " does not implement "
 
149
                                         + Remote.class.getName());
 
150
      }
 
151
    
 
152
    if (parameters == null)
 
153
      parameters = noArgs;
 
154
 
 
155
    String name = method.getName();
 
156
    switch (name.charAt(0))
 
157
      {
 
158
      case 'e':
 
159
        if (parameters.length == 1 && name.equals("equals")
 
160
            && method.getParameterTypes()[0].equals(Object.class))
 
161
          {
 
162
            if (parameters[0] instanceof Proxy)
 
163
              {
 
164
                Object handler = Proxy.getInvocationHandler(parameters[0]);
 
165
                if (handler == null)
 
166
                  return Boolean.FALSE;
 
167
                else
 
168
                  return handler.equals(this) ? Boolean.TRUE : Boolean.FALSE;
 
169
              }
 
170
            else
 
171
              return Boolean.FALSE;
 
172
          }
 
173
        break;
 
174
      case 'h':
 
175
        if (parameters.length == 0 && name.equals("hashCode"))
 
176
          {
 
177
            int hashC = Proxy.getInvocationHandler(proxyInstance).hashCode();
 
178
            return new Integer(hashC);
 
179
          }
 
180
        break;
 
181
      case 't':
 
182
        if (parameters.length == 0 && name.equals("toString"))
 
183
          return "Proxy stub:"+ref.remoteToString();
 
184
        break;
 
185
      default:
 
186
        break;
 
187
      }
 
188
 
 
189
    Long hash = (Long) methodHashCodes.get(method);
 
190
    if (hash == null)
 
191
      {
 
192
        hash = new Long(RMIHashes.getMethodHash(method));
 
193
        methodHashCodes.put(method, hash);
 
194
      }
 
195
 
 
196
    try
 
197
      {
 
198
        return getRef().invoke((Remote) proxyInstance, method, parameters,
 
199
                               hash.longValue());
 
200
      }
 
201
    catch (RuntimeException exception)
 
202
      {
 
203
        // RuntimeException is always supported.
 
204
        throw exception;
 
205
      }
 
206
    catch (RemoteException exception)
 
207
      {
 
208
        // All remote methods can throw RemoteException.
 
209
        throw exception;
 
210
      }
 
211
    catch (Error exception)
 
212
      {
 
213
        throw exception;
 
214
      }
 
215
    catch (Exception exception)
 
216
      {
 
217
        Class[] exceptions = method.getExceptionTypes();
 
218
        Class exceptionClass = exception.getClass();
 
219
 
 
220
        for (int i = 0; i < exceptions.length; i++)
 
221
          {
 
222
            if (exceptions[i].equals(exceptionClass))
 
223
              throw exception;
 
224
          }
 
225
        throw new UnexpectedException(method.getName(), exception);
 
226
      }
 
227
  }
 
228
 
 
229
}