Java RemoteInvocation类代码示例

import org.springframework.remoting.support.RemoteInvocation; //导入依赖的package包/类
@Override
public void execute(RemoteInvocationRequest request, StreamObserver<RemoteInvocationResponse> responseObserver) {
    try {
        ByteArrayInputStream in = new ByteArrayInputStream(request.getData().toByteArray());
        ObjectInputStream is = new ObjectInputStream(in);
        RemoteInvocation remoteInvocation = (RemoteInvocation) is.readObject();
        RemoteInvocationResult remoteInvocationResult = exporter.invokeForInvocation(remoteInvocation);
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ObjectOutputStream os = new ObjectOutputStream(out);
        os.writeObject(remoteInvocationResult);
        responseObserver.onNext(RemoteInvocationResponse.newBuilder().setData(ByteString.copyFrom(out.toByteArray())).build());
        responseObserver.onCompleted();
    } catch (Exception e) {
        responseObserver.onError(e);
    }
}
 

import org.springframework.remoting.support.RemoteInvocation; //导入依赖的package包/类
@Override
protected Object invoke(final RemoteInvocation invocation, final Object targetObject)
	throws NoSuchMethodException, IllegalAccessException, InvocationTargetException
{
	Throwable unwrapped = null;
	try
	{
		Object rval = super.invoke(invocation, targetObject);
		rval = initialiser.unwrapHibernate(rval);
		rval = initialiser.initialise(rval, new RemoteSimplifier());
		return rval;
	}
	catch( InvocationTargetException e )
	{
		unwrapped = e.getTargetException();
		Throwable t2 = unwrapped;
		// We want to determine if hibernate exception is thrown at any
		// point
		while( t2 != null )
		{
			if( t2 instanceof NestedRuntimeException )
			{
				logger.error(unwrapped.getMessage(), unwrapped);
				throw new RuntimeApplicationException(unwrapped.getMessage());
			}
			t2 = t2.getCause();
		}
		logger.error("Error invoking " + invocation.getMethodName(), unwrapped);
		throw e;
	}
}
 

import org.springframework.remoting.support.RemoteInvocation; //导入依赖的package包/类
/**
 * Execute the given remote invocation, sending an invoker request message
 * to this accessor's target queue and waiting for a corresponding response.
 * @param invocation the RemoteInvocation to execute
 * @return the RemoteInvocationResult object
 * @throws JMSException in case of JMS failure
 * @see #doExecuteRequest
 */
protected RemoteInvocationResult executeRequest(RemoteInvocation invocation) throws JMSException {
	Connection con = createConnection();
	Session session = null;
	try {
		session = createSession(con);
		Queue queueToUse = resolveQueue(session);
		Message requestMessage = createRequestMessage(session, invocation);
		con.start();
		Message responseMessage = doExecuteRequest(session, queueToUse, requestMessage);
		if (responseMessage != null) {
			return extractInvocationResult(responseMessage);
		}
		else {
			return onReceiveTimeout(invocation);
		}
	}
	finally {
		JmsUtils.closeSession(session);
		ConnectionFactoryUtils.releaseConnection(con, getConnectionFactory(), true);
	}
}
 

import org.springframework.remoting.support.RemoteInvocation; //导入依赖的package包/类
@Override
public RemoteInvocation createRemoteInvocation(MethodInvocation methodInvocation) {
    SecurityContext securityContext = AppContext.getSecurityContext();

    CubaRemoteInvocation remoteInvocation = new CubaRemoteInvocation(methodInvocation,
            securityContext == null ? null : securityContext.getSessionId());

    if (securityContext != null) {
        UserSession session = securityContext.getSession();

        if (session instanceof ClientBasedSession && ((ClientBasedSession) session).hasRequestScopedInfo()) {
            remoteInvocation.setLocale(session.getLocale() != null ? session.getLocale().toLanguageTag() : null);
            remoteInvocation.setTimeZone(session.getTimeZone());
            remoteInvocation.setAddress(session.getAddress());
            remoteInvocation.setClientInfo(session.getClientInfo());
        }
    }

    return remoteInvocation;
}
 

import org.springframework.remoting.support.RemoteInvocation; //导入依赖的package包/类
/**
 * Execute the given remote invocation, sending an invoker request message
 * to this accessor's target queue and waiting for a corresponding response.
 * @param invocation the RemoteInvocation to execute
 * @return the RemoteInvocationResult object
 * @throws JMSException in case of JMS failure
 * @see #doExecuteRequest
 */
protected RemoteInvocationResult executeRequest(RemoteInvocation invocation) throws JMSException {
	Connection con = createConnection();
	Session session = null;
	try {
		session = createSession(con);
		Queue queueToUse = resolveQueue(session);
		Message requestMessage = createRequestMessage(session, invocation);
		con.start();
		Message responseMessage = doExecuteRequest(session, queueToUse, requestMessage);
		return extractInvocationResult(responseMessage);
	}
	finally {
		JmsUtils.closeSession(session);
		ConnectionFactoryUtils.releaseConnection(con, getConnectionFactory(), true);
	}
}
 

import org.springframework.remoting.support.RemoteInvocation; //导入依赖的package包/类
@SuppressWarnings("unchecked")
protected <T> T doRefer(final Class<T> serviceType, final URL url) throws RpcException {
    final RmiProxyFactoryBean rmiProxyFactoryBean = new RmiProxyFactoryBean();
    //RMI传输时使用自定义的远程执行对象，从而传递额外的参数
    rmiProxyFactoryBean.setRemoteInvocationFactory(new RemoteInvocationFactory() {
        public RemoteInvocation createRemoteInvocation(MethodInvocation methodInvocation) {
            return new RmiRemoteInvocation(methodInvocation);
        }
    });
    rmiProxyFactoryBean.setServiceUrl(url.toIdentityString());
    rmiProxyFactoryBean.setServiceInterface(serviceType);
    rmiProxyFactoryBean.setCacheStub(true);
    rmiProxyFactoryBean.setLookupStubOnStartup(true);
    rmiProxyFactoryBean.setRefreshStubOnConnectFailure(true);
    rmiProxyFactoryBean.afterPropertiesSet();
    return (T) rmiProxyFactoryBean.getObject();
}
 

import org.springframework.remoting.support.RemoteInvocation; //导入依赖的package包/类
public void test_for_issue() throws Exception {
    RemoteInvocation remoteInvocation = new RemoteInvocation();
    remoteInvocation.setMethodName("test");
    remoteInvocation.setParameterTypes(new Class[] { int.class, Date.class,
            String.class });
    remoteInvocation.setArguments(new Object[] { 1, new Date(),
            "this is a test" });
    String json = JSON.toJSONString(remoteInvocation);
    remoteInvocation = JSON.parseObject(json, RemoteInvocation.class);
    System.out.println(remoteInvocation);
}
 

import org.springframework.remoting.support.RemoteInvocation; //导入依赖的package包/类
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
    RemoteInvocation remoteInvocation = new RemoteInvocation(invocation);
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    ObjectOutputStream os = new ObjectOutputStream(out);
    os.writeObject(remoteInvocation);
    RemoteInvocationResponse remoteInvocationResponse = remotingServiceBlockingStub.execute(RemoteInvocationRequest.newBuilder().setData(ByteString.copyFrom(out.toByteArray())).build());
    ByteArrayInputStream in = new ByteArrayInputStream(remoteInvocationResponse.getData().toByteArray());
    ObjectInputStream is = new ObjectInputStream(in);
    RemoteInvocationResult remoteInvocationResult = (RemoteInvocationResult) is.readObject();
    return remoteInvocationResult.getValue();
}
 

import org.springframework.remoting.support.RemoteInvocation; //导入依赖的package包/类
/*******************
 * Stub to call the remote invoke() method.
 ******************/
public Object invoke(RemoteInvocation ri) throws RemoteException {
	try {
		Object result = this.ref.invoke(this, RmiInvocationHandler.class.getMethod("invoke", new Class[] {RemoteInvocation.class}), new Object[] { ri }, -5752512342587169831L);
		return result;
	} catch(RuntimeException | RemoteException ex1) {
		throw ex1;
	} catch(Exception ex2) {
		throw new RemoteException("Unexpected exception.", ex2);
	}
}
 

import org.springframework.remoting.support.RemoteInvocation; //导入依赖的package包/类
@Override
protected void writeRemoteInvocation(RemoteInvocation invocation, OutputStream os) throws IOException
{
	ObjectOutputStream oos = new PluginAwareObjectOutputStream(decorateOutputStream(os));
	try
	{
		doWriteRemoteInvocation(invocation, oos);
		oos.flush();
	}
	finally
	{
		oos.close();
	}
}
 

import org.springframework.remoting.support.RemoteInvocation; //导入依赖的package包/类
/**
 * Delegates the actual invocation handling to the RMI exporter.
 * @see RmiBasedExporter#invoke(org.springframework.remoting.support.RemoteInvocation, Object)
 */
@Override
public Object invoke(RemoteInvocation invocation)
	throws RemoteException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {

	return this.rmiExporter.invoke(invocation, this.wrappedObject);
}
 

import org.springframework.remoting.support.RemoteInvocation; //导入依赖的package包/类
/**
 * Redefined here to be visible to RmiInvocationWrapper.
 * Simply delegates to the corresponding superclass method.
 */
@Override
protected Object invoke(RemoteInvocation invocation, Object targetObject)
		throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {

	return super.invoke(invocation, targetObject);
}
 

import org.springframework.remoting.support.RemoteInvocation; //导入依赖的package包/类
@Override
public final RemoteInvocationResult executeRequest(
		HttpInvokerClientConfiguration config, RemoteInvocation invocation) throws Exception {

	ByteArrayOutputStream baos = getByteArrayOutputStream(invocation);
	if (logger.isDebugEnabled()) {
		logger.debug("Sending HTTP invoker request for service at [" + config.getServiceUrl() +
				"], with size " + baos.size());
	}
	return doExecuteRequest(config, baos);
}
 

import org.springframework.remoting.support.RemoteInvocation; //导入依赖的package包/类
/**
 * Reads a remote invocation from the request, executes it,
 * and writes the remote invocation result to the response.
 * @see #readRemoteInvocation(HttpServletRequest)
 * @see #invokeAndCreateResult(org.springframework.remoting.support.RemoteInvocation, Object)
 * @see #writeRemoteInvocationResult(HttpServletRequest, HttpServletResponse, RemoteInvocationResult)
 */
@Override
public void handleRequest(HttpServletRequest request, HttpServletResponse response)
		throws ServletException, IOException {

	try {
		RemoteInvocation invocation = readRemoteInvocation(request);
		RemoteInvocationResult result = invokeAndCreateResult(invocation, getProxy());
		writeRemoteInvocationResult(request, response, result);
	}
	catch (ClassNotFoundException ex) {
		throw new NestedServletException("Class not found during deserialization", ex);
	}
}
 

import org.springframework.remoting.support.RemoteInvocation; //导入依赖的package包/类
/**
 * Reads a remote invocation from the request, executes it,
 * and writes the remote invocation result to the response.
 * @see #readRemoteInvocation(com.sun.net.httpserver.HttpExchange)
 * @see #invokeAndCreateResult(org.springframework.remoting.support.RemoteInvocation, Object)
 * @see #writeRemoteInvocationResult(com.sun.net.httpserver.HttpExchange, org.springframework.remoting.support.RemoteInvocationResult)
 */
@Override
public void handle(HttpExchange exchange) throws IOException {
	try {
		RemoteInvocation invocation = readRemoteInvocation(exchange);
		RemoteInvocationResult result = invokeAndCreateResult(invocation, getProxy());
		writeRemoteInvocationResult(exchange, result);
		exchange.close();
	}
	catch (ClassNotFoundException ex) {
		exchange.sendResponseHeaders(500, -1);
		logger.error("Class not found during deserialization", ex);
	}
}