上文[url]http://gwbasic.iteye.com/admin/show/39079[/url]提到的GWTSpringController.java,继承的是GWT中的RemoteServiceServlet类,在使用过程中发现这个类不支持AOP,原因
于是参照RemoteServiceServlet重新写了一个在Spring中使用的Controller
GWTServiceController
// delegate 用法参照 org.springframework.web.servlet.mvc.multiaction.MultiActionController
开源真好:D
public String processCall(String payload) throws SerializationException {
// .............
// ............
// Actually get the service interface, so that we can query its methods.
//
Class serviceIntf;
try {
// 此处的serviceIntf,是用getClassForName获取的,没有经过proxy代理
serviceIntf = getClassFromName(serviceIntfName);
} catch (ClassNotFoundException e) {
throw new SerializationException("Unknown service interface class '"
+ serviceIntfName + "'", e);
}
// Read the method name.
//
String methodName = streamReader.readString();
// Read the number and names of the parameter classes from the stream.
// We have to do this so that we can find the correct overload of the
// method.
//
int paramCount = streamReader.readInt();
Class[] paramTypes = new Class[paramCount];
for (int i = 0; i < paramTypes.length; i++) {
String paramClassName = streamReader.readString();
try {
paramTypes[i] = getClassOrPrimitiveFromName(paramClassName);
} catch (ClassNotFoundException e) {
throw new SerializationException("Unknown parameter " + i + " type '"
+ paramClassName + "'", e);
}
}
// For security, make sure the method is found in the service interface
// and not just one that happens to be defined on this class.
//
Method serviceIntfMethod = findInterfaceMethod(serviceIntf, methodName,
paramTypes, true);
}
于是参照RemoteServiceServlet重新写了一个在Spring中使用的Controller
GWTServiceController
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.zip.GZIPOutputStream;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.context.ServletContextAware;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
import com.google.gwt.user.client.rpc.RemoteService;
import com.google.gwt.user.client.rpc.SerializationException;
import com.google.gwt.user.server.rpc.impl.ServerSerializableTypeOracle;
import com.google.gwt.user.server.rpc.impl.ServerSerializableTypeOracleImpl;
import com.google.gwt.user.server.rpc.impl.ServerSerializationStreamReader;
import com.google.gwt.user.server.rpc.impl.ServerSerializationStreamWriter;
public class GWTServiceController implements ServletContextAware, Controller {
private ServletContext servletContext;
/** Object we'll invoke methods on. Defaults to this. */
private Object delegate;
public void setServletContext(ServletContext servletContext) {
this.servletContext = servletContext;
}
public ServletContext getServletContext() {
return servletContext;
}
public Object getDelegate() {
return delegate;
}
public void setDelegate(Object delegate) {
this.delegate = delegate;
registerImplementedRemoteServiceInterface(this.delegate);
}
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)
throws Exception {
doPost(request, response);
return null;
}
/*
* These members are used to get and set the different HttpServletResponse and
* HttpServletRequest headers.
*/
private static final String ACCEPT_ENCODING = "Accept-Encoding";
private static final String CHARSET_UTF8 = "UTF-8";
private static final String CONTENT_ENCODING = "Content-Encoding";
private static final String CONTENT_ENCODING_GZIP = "gzip";
private static final String CONTENT_TYPE_TEXT_PLAIN_UTF8 = "text/plain; charset=utf-8";
private static final String GENERIC_FAILURE_MSG = "The call failed on the server; see server log for details";
private static final HashMap TYPE_NAMES;
/**
* Controls the compression threshold at and below which no compression will
* take place.
*/
private static final int UNCOMPRESSED_BYTE_SIZE_LIMIT = 256;
static {
TYPE_NAMES = new HashMap();
TYPE_NAMES.put("Z", boolean.class);
TYPE_NAMES.put("B", byte.class);
TYPE_NAMES.put("C", char.class);
TYPE_NAMES.put("D", double.class);
TYPE_NAMES.put("F", float.class);
TYPE_NAMES.put("I", int.class);
TYPE_NAMES.put("J", long.class);
TYPE_NAMES.put("S", short.class);
}
/**
* Return true if the response object accepts Gzip encoding. This is done by
* checking that the accept-encoding header specifies gzip as a supported
* encoding.
*/
private static boolean acceptsGzipEncoding(HttpServletRequest request) {
assert (request != null);
String acceptEncoding = request.getHeader(ACCEPT_ENCODING);
if (null == acceptEncoding) {
return false;
}
return (acceptEncoding.indexOf(CONTENT_ENCODING_GZIP) != -1);
}
/**
* This method attempts to estimate the number of bytes that a string will
* consume when it is sent out as part of an HttpServletResponse. This really
* a hack since we are assuming that every character will consume two bytes
* upon transmission. This is definitely not true since some characters
* actually consume more than two bytes and some consume less. This is even
* less accurate if the string is converted to UTF8. However, it does save us
* from converting every string that we plan on sending back to UTF8 just to
* determine that we should not compress it.
*/
private static int estimateByteSize(final String buffer) {
return (buffer.length() * 2);
}
/**
* Find the invoked method on either the specified interface or any super.
*/
private static Method findInterfaceMethod(Class intf, String methodName, Class[] paramTypes,
boolean includeInherited) {
try {
return intf.getDeclaredMethod(methodName, paramTypes);
} catch (NoSuchMethodException e) {
if (includeInherited) {
Class[] superintfs = intf.getInterfaces();
for (int i = 0; i < superintfs.length; i++) {
Method method = findInterfaceMethod(superintfs[i], methodName, paramTypes, true);
if (method != null) {
return method;
}
}
}
return null;
}
}
private final ServerSerializableTypeOracle serializableTypeOracle;
/**
* The default constructor.
*/
public GWTServiceController() {
serializableTypeOracle = new ServerSerializableTypeOracleImpl(getPackagePaths());
this.delegate = this;
registerImplementedRemoteServiceInterface(this.delegate);
}
/**
* This is called internally.
*/
public final void doPost(HttpServletRequest request, HttpServletResponse response) {
Throwable caught;
try {
// Read the request fully.
//
String requestPayload = readPayloadAsUtf8(request);
// Invoke the core dispatching logic, which returns the serialized
// result.
//
String responsePayload = processCall(requestPayload);
// Write the response.
//
writeResponse(request, response, responsePayload);
return;
} catch (IOException e) {
caught = e;
} catch (ServletException e) {
caught = e;
} catch (SerializationException e) {
caught = e;
} catch (Throwable e) {
caught = e;
}
respondWithFailure(response, caught);
}
/**
* This is public so that it can be unit tested easily without HTTP.
*/
public String processCall(String payload) throws SerializationException {
// Let subclasses see the serialized request.
//
onBeforeRequestDeserialized(payload);
// Create a stream to deserialize the request.
//
ServerSerializationStreamReader streamReader = new ServerSerializationStreamReader(serializableTypeOracle);
streamReader.prepareToRead(payload);
// Read the service interface
//
String serviceIntfName = streamReader.readString();
// TODO(mmendez): need a way to check the type signature of the service intf
// Verify that this very servlet implements the specified interface name.
// 从delegate中获取serviceIntf
Class serviceIntf = getImplementedRemoteServiceInterface(serviceIntfName);
if (serviceIntf == null) {
// Bad payload, possible hack attempt.
//
throw new SecurityException(
"Blocked attempt to access interface '"
+ serviceIntfName
+ "', which is either not implemented by this servlet or which doesn't extend RemoteService; this is either misconfiguration or a hack attempt");
}
// Read the method name.
//
String methodName = streamReader.readString();
// Read the number and names of the parameter classes from the stream.
// We have to do this so that we can find the correct overload of the
// method.
//
int paramCount = streamReader.readInt();
Class[] paramTypes = new Class[paramCount];
for (int i = 0; i < paramTypes.length; i++) {
String paramClassName = streamReader.readString();
try {
paramTypes[i] = getClassOrPrimitiveFromName(paramClassName);
} catch (ClassNotFoundException e) {
throw new SerializationException("Unknown parameter " + i + " type '" + paramClassName + "'", e);
}
}
// For security, make sure the method is found in the service interface
// and not just one that happens to be defined on this class.
//
Method serviceIntfMethod = findInterfaceMethod(serviceIntf, methodName, paramTypes, true);
// If it wasn't found, don't continue.
//
if (serviceIntfMethod == null) {
// Bad payload, possible hack attempt.
//
throw new SecurityException("Method '" + methodName + "' (or a particular overload) on interface '"
+ serviceIntfName + "' was not found, this is either misconfiguration or a hack attempt");
}
// Deserialize the parameters.
//
Object[] args = new Object[paramCount];
for (int i = 0; i < args.length; i++) {
args[i] = streamReader.deserializeValue(paramTypes[i]);
}
// Make the call via reflection.
//
String responsePayload = GENERIC_FAILURE_MSG;
ServerSerializationStreamWriter streamWriter = new ServerSerializationStreamWriter(serializableTypeOracle);
Throwable caught = null;
try {
Class returnType = serviceIntfMethod.getReturnType();
Object returnVal = serviceIntfMethod.invoke(this.delegate, args);
responsePayload = createResponse(streamWriter, returnType, returnVal, false);
} catch (IllegalArgumentException e) {
caught = e;
} catch (IllegalAccessException e) {
caught = e;
} catch (InvocationTargetException e) {
// Try to serialize the caught exception if the client is expecting it,
// otherwise log the exception server-side.
caught = e;
Throwable cause = e.getCause();
if (cause != null) {
// Update the caught exception to the underlying cause
caught = cause;
// Serialize the exception back to the client if it's a declared
// exception
if (isExpectedException(serviceIntfMethod, cause)) {
Class thrownClass = cause.getClass();
responsePayload = createResponse(streamWriter, thrownClass, cause, true);
// Don't log the exception on the server
caught = null;
}
}
}
if (caught != null) {
responsePayload = GENERIC_FAILURE_MSG;
ServletContext servletContext = getServletContext();
// servletContext may be null (for example, when unit testing)
if (servletContext != null) {
// Log the exception server side
servletContext.log("Exception while dispatching incoming RPC call", caught);
}
}
// Let subclasses see the serialized response.
//
onAfterResponseSerialized(responsePayload);
return responsePayload;
}
/**
* Override this method to examine the serialized response that will be
* returned to the client. The default implementation does nothing and need
* not be called by subclasses.
*/
protected void onAfterResponseSerialized(String serializedResponse) {
}
/**
* Override this method to examine the serialized version of the request
* payload before it is deserialized into objects. The default implementation
* does nothing and need not be called by subclasses.
*/
protected void onBeforeRequestDeserialized(String serializedRequest) {
}
/**
* Determines whether the response to a given servlet request should or should
* not be GZIP compressed. This method is only called in cases where the
* requestor accepts GZIP encoding.
* <p>
* This implementation currently returns <code>true</code> if the response
* string's estimated byte length is longer than 256 bytes. Subclasses can
* override this logic.
* </p>
*
* @param request the request being served
* @param response the response that will be written into
* @param responsePayload the payload that is about to be sent to the client
* @return <code>true</code> if responsePayload should be GZIP compressed,
* otherwise <code>false</code>.
*/
protected boolean shouldCompressResponse(HttpServletRequest request, HttpServletResponse response,
String responsePayload) {
return estimateByteSize(responsePayload) > UNCOMPRESSED_BYTE_SIZE_LIMIT;
}
/**
* @param stream
* @param responseType
* @param responseObj
* @param isException
* @return response
*/
private String createResponse(ServerSerializationStreamWriter stream, Class responseType,
Object responseObj, boolean isException) {
stream.prepareToWrite();
if (responseType != void.class) {
try {
stream.serializeValue(responseObj, responseType);
} catch (SerializationException e) {
responseObj = e;
isException = true;
}
}
String bufferStr = (isException ? "{EX}" : "{OK}") + stream.toString();
return bufferStr;
}
/**
* Returns the {@link Class} instance for the named class.
*
* @param name the name of a class or primitive type
* @return Class instance for the given type name
* @throws ClassNotFoundException if the named type was not found
*/
private Class getClassFromName(String name) throws ClassNotFoundException {
return Class.forName(name, false, this.getClass().getClassLoader());
}
/**
* Returns the {@link Class} instance for the named class or primitive type.
*
* @param name the name of a class or primitive type
* @return Class instance for the given type name
* @throws ClassNotFoundException if the named type was not found
*/
private Class getClassOrPrimitiveFromName(String name) throws ClassNotFoundException {
Object value = TYPE_NAMES.get(name);
if (value != null) {
return (Class) value;
}
return getClassFromName(name);
}
/**
* Obtain the special package-prefixes we use to check for custom serializers
* that would like to live in a package that they cannot. For example,
* "java.util.ArrayList" is in a sealed package, so instead we use this prefix
* to check for a custom serializer in
* "com.google.gwt.user.client.rpc.core.java.util.ArrayList". Right now, it's
* hard-coded because we don't have a pressing need for this mechanism to be
* extensible, but it is imaginable, which is why it's implemented this way.
*/
private String[] getPackagePaths() {
return new String[] { "com.google.gwt.user.client.rpc.core" };
}
/**
* Returns true if the {@link java.lang.reflect.Method Method} definition on
* the service is specified to throw the exception contained in the
* InvocationTargetException or false otherwise. NOTE we do not check that the
* type is serializable here. We assume that it must be otherwise the
* application would never have been allowed to run.
*
* @param serviceIntfMethod
* @param e
* @return is expected exception
*/
private boolean isExpectedException(Method serviceIntfMethod, Throwable cause) {
assert (serviceIntfMethod != null);
assert (cause != null);
Class[] exceptionsThrown = serviceIntfMethod.getExceptionTypes();
if (exceptionsThrown.length <= 0) {
// The method is not specified to throw any exceptions
//
return false;
}
Class causeType = cause.getClass();
for (int index = 0; index < exceptionsThrown.length; ++index) {
Class exceptionThrown = exceptionsThrown[index];
assert (exceptionThrown != null);
if (exceptionThrown.isAssignableFrom(causeType)) {
return true;
}
}
return false;
}
private final Map<String, Class> knownImplementedInterfacesMap = new HashMap<String, Class>();
private void registerImplementedRemoteServiceInterface(Object delegate) {
this.knownImplementedInterfacesMap.clear();
if (delegate != null) {
Class cls = delegate.getClass();
if (cls.isInterface()) {
addImplementedRemoteServiceInterfaceRecursive(cls);
} else {
while (cls != null) {
Class[] intfs = cls.getInterfaces();
for (int i = 0; i < intfs.length; i++) {
addImplementedRemoteServiceInterfaceRecursive(intfs[i]);
}
// we look in the superclass
cls = cls.getSuperclass();
}
}
}
}
private void addImplementedRemoteServiceInterfaceRecursive(Class intfToCheck) {
assert (intfToCheck.isInterface());
if (RemoteService.class.equals(intfToCheck))
return;
if (RemoteService.class.isAssignableFrom(intfToCheck)) {
this.knownImplementedInterfacesMap.put(intfToCheck.getName(), intfToCheck);
}
Class[] intfs = intfToCheck.getInterfaces();
for (int i = 0; i < intfs.length; i++) {
addImplementedRemoteServiceInterfaceRecursive(intfs[i]);
}
}
private Class getImplementedRemoteServiceInterface(String intfName) {
return this.knownImplementedInterfacesMap.get(intfName);
}
private String readPayloadAsUtf8(HttpServletRequest request) throws IOException, ServletException {
int contentLength = request.getContentLength();
if (contentLength == -1) {
// Content length must be known.
throw new ServletException("Content-Length must be specified");
}
String contentType = request.getContentType();
boolean contentTypeIsOkay = false;
// Content-Type must be specified.
if (contentType != null) {
// The type must be plain text.
if (contentType.startsWith("text/plain")) {
// And it must be UTF-8 encoded (or unspecified, in which case we assume
// that it's either UTF-8 or ASCII).
if (contentType.indexOf("charset=") == -1) {
contentTypeIsOkay = true;
} else if (contentType.indexOf("charset=utf-8") != -1) {
contentTypeIsOkay = true;
}
}
}
if (!contentTypeIsOkay) {
throw new ServletException(
"Content-Type must be 'text/plain' with 'charset=utf-8' (or unspecified charset)");
}
InputStream in = request.getInputStream();
try {
byte[] payload = new byte[contentLength];
int offset = 0;
int len = contentLength;
int byteCount;
while (offset < contentLength) {
byteCount = in.read(payload, offset, len);
if (byteCount == -1) {
throw new ServletException("Client did not send " + contentLength + " bytes as expected");
}
offset += byteCount;
len -= byteCount;
}
return new String(payload, "UTF-8");
} finally {
if (in != null) {
in.close();
}
}
}
/**
* Called when the machinery of this class itself has a problem, rather than
* the invoked third-party method. It writes a simple 500 message back to the
* client.
*/
private void respondWithFailure(HttpServletResponse response, Throwable caught) {
ServletContext servletContext = getServletContext();
servletContext.log("Exception while dispatching incoming RPC call", caught);
try {
response.setContentType("text/plain");
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
response.getWriter().write(GENERIC_FAILURE_MSG);
} catch (IOException e) {
servletContext.log("sendError() failed while sending the previous failure to the client", caught);
}
}
private void writeResponse(HttpServletRequest request, HttpServletResponse response, String responsePayload)
throws IOException {
byte[] reply = responsePayload.getBytes(CHARSET_UTF8);
String contentType = CONTENT_TYPE_TEXT_PLAIN_UTF8;
if (acceptsGzipEncoding(request) && shouldCompressResponse(request, response, responsePayload)) {
// Compress the reply and adjust headers.
//
ByteArrayOutputStream output = null;
GZIPOutputStream gzipOutputStream = null;
Throwable caught = null;
try {
output = new ByteArrayOutputStream(reply.length);
gzipOutputStream = new GZIPOutputStream(output);
gzipOutputStream.write(reply);
gzipOutputStream.finish();
gzipOutputStream.flush();
response.setHeader(CONTENT_ENCODING, CONTENT_ENCODING_GZIP);
reply = output.toByteArray();
} catch (UnsupportedEncodingException e) {
caught = e;
} catch (IOException e) {
caught = e;
} finally {
if (null != gzipOutputStream) {
gzipOutputStream.close();
}
if (null != output) {
output.close();
}
}
if (caught != null) {
getServletContext().log("Unable to compress response", caught);
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
return;
}
}
// Send the reply.
//
response.setContentLength(reply.length);
response.setContentType(contentType);
response.setStatus(HttpServletResponse.SC_OK);
response.getOutputStream().write(reply);
}
}
// delegate 用法参照 org.springframework.web.servlet.mvc.multiaction.MultiActionController
/*
For GWT 1.4.60
*/
public class GwtRemoteServiceController extends RemoteServiceServlet implements
Controller, ServletContextAware {
private static final long serialVersionUID = 8175888785480720736L;
private Object delegate;
private ServletContext servletContext;
@Override
public void setServletContext(ServletContext servletContext) {
this.servletContext = servletContext;
}
@Override
public ServletContext getServletContext() {
return servletContext;
}
@Override
public ModelAndView handleRequest(HttpServletRequest request,
HttpServletResponse response) throws Exception {
super.doPost(request, response);
return null;
}
@Override
public String processCall(String payload) throws SerializationException {
Object delegateToUse = this.delegate;
if (delegateToUse == null) {
return super.processCall(payload);
} else {
try {
RPCRequest rpcRequest = RPC.decodeRequest(payload,
delegateToUse.getClass(), this);
return RPC.invokeAndEncodeResponse(delegateToUse, rpcRequest
.getMethod(), rpcRequest.getParameters(), rpcRequest
.getSerializationPolicy());
} catch (IncompatibleRemoteServiceException ex) {
getServletContext()
.log(
"An IncompatibleRemoteServiceException was thrown while processing this call.",
ex);
return RPC.encodeResponseForFailure(null, ex);
}
}
}
public Object getDelegate() {
return delegate;
}
public void setDelegate(Object delegate) {
this.delegate = delegate;
}
}
开源真好:D
扫一扫
263
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
