001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: *
015: * See the License for the specific language governing permissions and
016: * limitations under the License.
017: */
018:
019: /**
020: * @author Mikhail A. Markov
021: * @version $Revision: 1.4.4.3 $
022: */package java.rmi.server;
023:
024: import java.io.InvalidObjectException;
025: import java.lang.reflect.InvocationHandler;
026: import java.lang.reflect.Method;
027: import java.lang.reflect.Proxy;
028: import java.rmi.Remote;
029: import java.rmi.UnexpectedException;
030:
031: import org.apache.harmony.rmi.common.RMIHash;
032: import org.apache.harmony.rmi.internal.nls.Messages;
033:
034: /**
035: * @com.intel.drl.spec_ref
036: *
037: * @author Mikhail A. Markov
038: * @version $Revision: 1.4.4.3 $
039: */
040: public class RemoteObjectInvocationHandler extends RemoteObject
041: implements InvocationHandler {
042:
043: private static final long serialVersionUID = 2L;
044:
045: /**
046: * @com.intel.drl.spec_ref
047: */
048: public RemoteObjectInvocationHandler(RemoteRef ref) {
049: super (ref);
050:
051: if (ref == null) {
052: // rmi.20=RemoteRef parameter could not be null.
053: throw new NullPointerException(Messages.getString("rmi.20")); //$NON-NLS-1$
054: }
055: }
056:
057: /**
058: * @com.intel.drl.spec_ref
059: */
060: public Object invoke(Object proxy, Method m, Object[] args)
061: throws Throwable {
062: Class mClass = m.getDeclaringClass();
063:
064: if (m.getDeclaringClass() == Object.class) {
065: return invokeObjectMethod(proxy, m, args);
066: } else if (!(proxy instanceof Remote)) {
067: // rmi.21=Proxy does not implement Remote interface.
068: throw new IllegalArgumentException(Messages
069: .getString("rmi.21")); //$NON-NLS-1$
070: } else {
071: return invokeRemoteMethod(proxy, m, args);
072: }
073: }
074:
075: /**
076: * @com.intel.drl.spec_ref
077: */
078: private void readObjectNoData() throws InvalidObjectException {
079: // rmi.22=No data in stream for class {0}
080: throw new InvalidObjectException(Messages.getString("rmi.22", //$NON-NLS-1$
081: this .getClass().getName()));
082: }
083:
084: /*
085: * Invokes methods from Object class.
086: */
087: private Object invokeObjectMethod(Object proxy, Method m,
088: Object[] args) {
089: String mName = m.getName();
090:
091: if (mName.equals("hashCode")) { //$NON-NLS-1$
092: // return result of hashCode method call from RemoteObject class
093: return new Integer(hashCode());
094: } else if (mName.equals("equals")) { //$NON-NLS-1$
095: Object obj = args[0];
096: return new Boolean(
097: (proxy == obj) // the same object?
098: || (obj != null
099: && Proxy.isProxyClass(obj
100: .getClass()) && equals(Proxy
101: .getInvocationHandler(obj))));
102: } else if (mName.equals("toString")) { //$NON-NLS-1$
103: Class[] interf = proxy.getClass().getInterfaces();
104:
105: if (interf.length == 0) {
106: return "Proxy[" + toString() + "]"; //$NON-NLS-1$ //$NON-NLS-2$
107: }
108: String str = "Proxy[interf:["; //$NON-NLS-1$
109:
110: for (int i = 0; i < interf.length - 1; ++i) {
111: str += interf[i].getName() + ", "; //$NON-NLS-1$
112: }
113: return str + interf[interf.length - 1].getName() + "], " //$NON-NLS-1$
114: + toString() + "]"; //$NON-NLS-1$
115: } else {
116: // rmi.23=Illegal method from Object class: {0}
117: throw new IllegalArgumentException(Messages.getString(
118: "rmi.23", m)); //$NON-NLS-1$
119: }
120: }
121:
122: /*
123: * Invokes Remote methods.
124: */
125: private Object invokeRemoteMethod(Object proxy, Method m,
126: Object[] args) throws Throwable {
127: try {
128: return ref.invoke((Remote) proxy, m, args, RMIHash
129: .getMethodHash(m));
130: } catch (RuntimeException re) {
131: throw re;
132: } catch (Exception ex) {
133: Method m1 = proxy.getClass().getMethod(m.getName(),
134: m.getParameterTypes());
135: Class[] declaredEx = m1.getExceptionTypes();
136:
137: for (int i = 0; i < declaredEx.length; ++i) {
138: if (declaredEx[i].isAssignableFrom(ex.getClass())) {
139: throw ex;
140: }
141: }
142: // rmi.24=Unexpected exception
143: throw new UnexpectedException(
144: Messages.getString("rmi.24"), ex); //$NON-NLS-1$
145: }
146: }
147: }
|