Java tutorial
package spring.test.web; /* * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import net.sf.json.JSONObject; import net.sf.json.JSONSerializer; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.beans.factory.BeanClassLoaderAware; import org.springframework.remoting.rmi.CodebaseAwareObjectInputStream; import spring.test.RemoteInvocation; import spring.test.RemoteInvocationResult; import org.springframework.util.Assert; import com.alibaba.dubbo.common.ParamObject; import com.alibaba.dubbo.common.utils.XmlBeanConvert; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.OutputStream; import java.rmi.RemoteException; /** * Abstract base implementation of the HttpInvokerRequestExecutor interface. * * <p>Pre-implements serialization of RemoteInvocation objects and * deserialization of RemoteInvocationResults objects. * * @author Juergen Hoeller * @since 1.1 * @see #doExecuteRequest */ public abstract class AbstractHttpInvokerRequestExecutor implements HttpInvokerRequestExecutor, BeanClassLoaderAware { /** * Default content type: "application/x-java-serialized-object" */ public static final String CONTENT_TYPE_SERIALIZED_OBJECT = "application/x-java-serialized-object"; protected static final String HTTP_METHOD_POST = "POST"; protected static final String HTTP_HEADER_ACCEPT_LANGUAGE = "Accept-Language"; protected static final String HTTP_HEADER_ACCEPT_ENCODING = "Accept-Encoding"; protected static final String HTTP_HEADER_CONTENT_ENCODING = "Content-Encoding"; protected static final String HTTP_HEADER_CONTENT_TYPE = "Content-Type"; protected static final String HTTP_HEADER_CONTENT_LENGTH = "Content-Length"; protected static final String ENCODING_GZIP = "gzip"; private static final int SERIALIZED_INVOCATION_BYTE_ARRAY_INITIAL_SIZE = 1024; protected final Log logger = LogFactory.getLog(getClass()); private String contentType = CONTENT_TYPE_SERIALIZED_OBJECT; private boolean acceptGzipEncoding = true; private ClassLoader beanClassLoader; /** * Specify the content type to use for sending HTTP invoker requests. * <p>Default is "application/x-java-serialized-object". */ public void setContentType(String contentType) { Assert.notNull(contentType, "'contentType' must not be null"); this.contentType = contentType; } /** * Return the content type to use for sending HTTP invoker requests. */ public String getContentType() { return this.contentType; } /** * Set whether to accept GZIP encoding, that is, whether to * send the HTTP "Accept-Encoding" header with "gzip" as value. * <p>Default is "true". Turn this flag off if you do not want * GZIP response compression even if enabled on the HTTP server. */ public void setAcceptGzipEncoding(boolean acceptGzipEncoding) { this.acceptGzipEncoding = acceptGzipEncoding; } /** * Return whether to accept GZIP encoding, that is, whether to * send the HTTP "Accept-Encoding" header with "gzip" as value. */ public boolean isAcceptGzipEncoding() { return this.acceptGzipEncoding; } public void setBeanClassLoader(ClassLoader classLoader) { this.beanClassLoader = classLoader; } /** * Return the bean ClassLoader that this executor is supposed to use. */ protected ClassLoader getBeanClassLoader() { return this.beanClassLoader; } public final RemoteInvocationResult executeRequest(HttpInvokerClientConfiguration config, RemoteInvocation invocation) throws Exception { // ByteArrayOutputStream baos = getByteArrayOutputStream(invocation); String invocationStr = XmlBeanConvert.toXml(invocation); // if (logger.isDebugEnabled()) { // logger.debug("Sending HTTP invoker request for service at [" + // config.getServiceUrl() + "], with size " + baos.size()); // } return doExecuteRequest(config, invocationStr); } /** * Serialize the given RemoteInvocation into a ByteArrayOutputStream. * @param invocation the RemoteInvocation object * @return a ByteArrayOutputStream with the serialized RemoteInvocation * @throws IOException if thrown by I/O methods */ protected ByteArrayOutputStream getByteArrayOutputStream(RemoteInvocation invocation) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(SERIALIZED_INVOCATION_BYTE_ARRAY_INITIAL_SIZE); writeRemoteInvocation(invocation, baos); return baos; } /** * Serialize the given RemoteInvocation to the given OutputStream. * <p>The default implementation gives {@code decorateOutputStream} a chance * to decorate the stream first (for example, for custom encryption or compression). * Creates an {@code ObjectOutputStream} for the final stream and calls * {@code doWriteRemoteInvocation} to actually write the object. * <p>Can be overridden for custom serialization of the invocation. * @param invocation the RemoteInvocation object * @param os the OutputStream to write to * @throws IOException if thrown by I/O methods * @see #decorateOutputStream * @see #doWriteRemoteInvocation */ protected void writeRemoteInvocation(RemoteInvocation invocation, OutputStream os) throws IOException { ObjectOutputStream oos = new ObjectOutputStream(decorateOutputStream(os)); try { doWriteRemoteInvocation(invocation, oos); } finally { oos.close(); } } /** * Return the OutputStream to use for writing remote invocations, * potentially decorating the given original OutputStream. * <p>The default implementation returns the given stream as-is. * Can be overridden, for example, for custom encryption or compression. * @param os the original OutputStream * @return the potentially decorated OutputStream */ protected OutputStream decorateOutputStream(OutputStream os) throws IOException { return os; } /** * Perform the actual writing of the given invocation object to the * given ObjectOutputStream. * <p>The default implementation simply calls {@code writeObject}. * Can be overridden for serialization of a custom wrapper object rather * than the plain invocation, for example an encryption-aware holder. * @param invocation the RemoteInvocation object * @param oos the ObjectOutputStream to write to * @throws IOException if thrown by I/O methods * @see java.io.ObjectOutputStream#writeObject */ protected void doWriteRemoteInvocation(RemoteInvocation invocation, ObjectOutputStream oos) throws IOException { oos.writeObject(invocation); } /** * Execute a request to send the given serialized remote invocation. * <p>Implementations will usually call {@code readRemoteInvocationResult} * to deserialize a returned RemoteInvocationResult object. * @param config the HTTP invoker configuration that specifies the * target service * @param baos the ByteArrayOutputStream that contains the serialized * RemoteInvocation object * @return the RemoteInvocationResult object * @throws IOException if thrown by I/O operations * @throws ClassNotFoundException if thrown during deserialization * @throws Exception in case of general errors * @see #readRemoteInvocationResult(java.io.InputStream, String) */ protected abstract RemoteInvocationResult doExecuteRequest(HttpInvokerClientConfiguration config, String invocaionStr) throws Exception; /** * Deserialize a RemoteInvocationResult object from the given InputStream. * <p>Gives {@code decorateInputStream} a chance to decorate the stream * first (for example, for custom encryption or compression). Creates an * {@code ObjectInputStream} via {@code createObjectInputStream} and * calls {@code doReadRemoteInvocationResult} to actually read the object. * <p>Can be overridden for custom serialization of the invocation. * @param is the InputStream to read from * @param codebaseUrl the codebase URL to load classes from if not found locally * @return the RemoteInvocationResult object * @throws IOException if thrown by I/O methods * @throws ClassNotFoundException if thrown during deserialization * @see #decorateInputStream * @see #createObjectInputStream * @see #doReadRemoteInvocationResult */ protected RemoteInvocationResult readRemoteInvocationResult(InputStream is, String codebaseUrl) throws IOException, ClassNotFoundException { ObjectInputStream ois = createObjectInputStream(decorateInputStream(is), codebaseUrl); try { return doReadRemoteInvocationResult(ois); } finally { ois.close(); } } /** * Return the InputStream to use for reading remote invocation results, * potentially decorating the given original InputStream. * <p>The default implementation returns the given stream as-is. * Can be overridden, for example, for custom encryption or compression. * @param is the original InputStream * @return the potentially decorated InputStream */ protected InputStream decorateInputStream(InputStream is) throws IOException { return is; } /** * Create an ObjectInputStream for the given InputStream and codebase. * The default implementation creates a CodebaseAwareObjectInputStream. * @param is the InputStream to read from * @param codebaseUrl the codebase URL to load classes from if not found locally * (can be {@code null}) * @return the new ObjectInputStream instance to use * @throws IOException if creation of the ObjectInputStream failed * @see org.springframework.remoting.rmi.CodebaseAwareObjectInputStream */ protected ObjectInputStream createObjectInputStream(InputStream is, String codebaseUrl) throws IOException { return new CodebaseAwareObjectInputStream(is, getBeanClassLoader(), codebaseUrl); } /** * Perform the actual reading of an invocation object from the * given ObjectInputStream. * <p>The default implementation simply calls {@code readObject}. * Can be overridden for deserialization of a custom wrapper object rather * than the plain invocation, for example an encryption-aware holder. * @param ois the ObjectInputStream to read from * @return the RemoteInvocationResult object * @throws IOException if thrown by I/O methods * @throws ClassNotFoundException if the class name of a serialized object * couldn't get resolved * @see java.io.ObjectOutputStream#writeObject */ protected RemoteInvocationResult doReadRemoteInvocationResult(ObjectInputStream ois) throws IOException, ClassNotFoundException { Object obj = ois.readObject(); if (!(obj instanceof RemoteInvocationResult)) { throw new RemoteException("Deserialized object needs to be assignable to type [" + RemoteInvocationResult.class.getName() + "]: " + obj); } return (RemoteInvocationResult) obj; } }