1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
/*
@VaadinApache2LicenseForJavaFiles@
*/
package com.vaadin.terminal.gwt.server;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import com.vaadin.terminal.gwt.client.Connector;
/**
* Server side RPC manager that handles RPC calls coming from the client.
*
* Each {@link RpcTarget} (typically a {@link ClientConnector}) should have its
* own instance of {@link ServerRpcManager} if it wants to receive RPC calls
* from the client.
*
* @since 7.0
*/
public class ServerRpcManager<T> implements RpcManager {
private final T implementation;
private final Class<T> rpcInterface;
private static final Map<Class<?>, Class<?>> boxedTypes = new HashMap<Class<?>, Class<?>>();
static {
try {
Class<?>[] boxClasses = new Class<?>[] { Boolean.class, Byte.class,
Short.class, Character.class, Integer.class, Long.class,
Float.class, Double.class };
for (Class<?> boxClass : boxClasses) {
Field typeField = boxClass.getField("TYPE");
Class<?> primitiveType = (Class<?>) typeField.get(boxClass);
boxedTypes.put(primitiveType, boxClass);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* Create a RPC manager for an RPC target.
*
* @param target
* RPC call target (normally a {@link Connector})
* @param implementation
* RPC interface implementation for the target
* @param rpcInterface
* RPC interface type
*/
public ServerRpcManager(T implementation, Class<T> rpcInterface) {
this.implementation = implementation;
this.rpcInterface = rpcInterface;
}
/**
* Invoke a method in a server side RPC target class. This method is to be
* used by the RPC framework and unit testing tools only.
*
* @param target
* non-null target of the RPC call
* @param invocation
* method invocation to perform
* @throws RpcInvocationException
*/
public static void applyInvocation(RpcTarget target,
ServerRpcMethodInvocation invocation) throws RpcInvocationException {
RpcManager manager = target.getRpcManager(invocation
.getInterfaceClass());
if (manager != null) {
manager.applyInvocation(invocation);
} else {
getLogger()
.log(Level.WARNING,
"RPC call received for RpcTarget "
+ target.getClass().getName()
+ " ("
+ invocation.getConnectorId()
+ ") but the target has not registered any RPC interfaces");
}
}
/**
* Returns the RPC interface implementation for the RPC target.
*
* @return RPC interface implementation
*/
protected T getImplementation() {
return implementation;
}
/**
* Returns the RPC interface type managed by this RPC manager instance.
*
* @return RPC interface type
*/
protected Class<T> getRpcInterface() {
return rpcInterface;
}
/**
* Invoke a method in a server side RPC target class. This method is to be
* used by the RPC framework and unit testing tools only.
*
* @param invocation
* method invocation to perform
*/
public void applyInvocation(ServerRpcMethodInvocation invocation)
throws RpcInvocationException {
Method method = invocation.getMethod();
Class<?>[] parameterTypes = method.getParameterTypes();
Object[] args = new Object[parameterTypes.length];
Object[] arguments = invocation.getParameters();
for (int i = 0; i < args.length; i++) {
// no conversion needed for basic cases
// Class<?> type = parameterTypes[i];
// if (type.isPrimitive()) {
// type = boxedTypes.get(type);
// }
args[i] = arguments[i];
}
try {
method.invoke(implementation, args);
} catch (Exception e) {
throw new RpcInvocationException("Unable to invoke method "
+ invocation.getMethodName() + " in "
+ invocation.getInterfaceName(), e);
}
}
private static Logger getLogger() {
return Logger.getLogger(ServerRpcManager.class.getName());
}
}
|
