Java 8 has reached end of support and will be deprecated on January 31, 2026. After deprecation, you won't be able to deploy Java 8 applications, even if your organization previously used an organization policy to re-enable deployments of legacy runtimes. Your existing Java 8 applications will continue to run and receive traffic after their deprecation date. We recommend that you migrate to the latest supported version of Java.

ApiProxy (Google App Engine API for Java)

java.lang.Object
- com.google.apphosting.api.ApiProxy

```
public class ApiProxy
extends java.lang.Object
```
ApiProxy is a static class that serves as the collection point for all API calls from user code into the application server. It is responsible for proxying makeSyncCall() calls to a delegate, which actually implements the API calls. It also stores an Environment for each thread, which contains additional user-visible information about the request.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ApiProxy.ApiConfig` `ApiConfig` encapsulates one or more configuration parameters scoped to an individual API call.
`static class`	`ApiProxy.ApiDeadlineExceededException`
`static class`	`ApiProxy.ApiProxyException`
`static interface`	`ApiProxy.ApiResultFuture<T>` A subtype of `Future` that provides more detailed information about the timing and resource consumption of particular API calls.
`static class`	`ApiProxy.ApplicationException`
`static class`	`ApiProxy.ArgumentException`
`static class`	`ApiProxy.CallNotFoundException`
`static class`	`ApiProxy.CancelledException`
`static class`	`ApiProxy.CapabilityDisabledException`
`static interface`	`ApiProxy.Delegate<E extends ApiProxy.Environment>` This interface can be used to provide a class that actually implements API calls.
`static interface`	`ApiProxy.Environment` Environment is a simple data container that provides additional information about the current request (e.g.
`static interface`	`ApiProxy.EnvironmentFactory` Used to create an Environment object to use if no thread local Environment is set.
`static class`	`ApiProxy.FeatureNotEnabledException`
`static class`	`ApiProxy.LogRecord` `LogRecord` represents a single apphosting log entry, including a Java-specific logging level, a timestamp in microseconds, and a message, which is a formatted string containing the rest of the logging information (e.g.
`static class`	`ApiProxy.OverQuotaException`
`static class`	`ApiProxy.RequestTooLargeException`
`static class`	`ApiProxy.ResponseTooLargeException`
`static class`	`ApiProxy.RPCFailedException`
`static class`	`ApiProxy.UnknownException`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`clearEnvironmentForCurrentThread()` Removes any environment associated with the current thread.
`static void`	`flushLogs()` Synchronously flush all pending application logs.
`static ApiProxy.Environment`	`getCurrentEnvironment()` Gets the environment associated with this thread.
`static ApiProxy.Delegate`	`getDelegate()` Gets the delegate to which we will proxy requests.
`static ApiProxy.EnvironmentFactory`	`getEnvironmentFactory()`
`static java.util.List<java.lang.Thread>`	`getRequestThreads()` Returns a list of all threads which are currently running requests.
`static void`	`log(ApiProxy.LogRecord record)`
`static java.util.concurrent.Future<byte[]>`	`makeAsyncCall(java.lang.String packageName, java.lang.String methodName, byte[] request)`
`static java.util.concurrent.Future<byte[]>`	`makeAsyncCall(java.lang.String packageName, java.lang.String methodName, byte[] request, ApiProxy.ApiConfig apiConfig)` Make an asynchronous call to the specified method in the specified API package.
`static byte[]`	`makeSyncCall(java.lang.String packageName, java.lang.String methodName, byte[] request)`
`static byte[]`	`makeSyncCall(java.lang.String packageName, java.lang.String methodName, byte[] request, ApiProxy.ApiConfig apiConfig)` Make a synchronous call to the specified method in the specified API package.
`static void`	`setDelegate(ApiProxy.Delegate aDelegate)` Sets a delegate to which we will proxy requests.
`static void`	`setEnvironmentFactory(ApiProxy.EnvironmentFactory factory)` Set the EnvironmentFactory instance to use, which will be used to create Environment instances when a thread local one is not set.
`static void`	`setEnvironmentForCurrentThread(ApiProxy.Environment environment)` Sets an environment for the current thread.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - makeSyncCall
```
public static byte[] makeSyncCall(java.lang.String packageName,
                                  java.lang.String methodName,
                                  byte[] request)
                           throws ApiProxy.ApiProxyException
```
    Throws:
    
    ApiProxy.ApiProxyException
    
    See Also:
    
    makeSyncCall(String,String,byte[],ApiConfig)
  - makeSyncCall
```
public static byte[] makeSyncCall(java.lang.String packageName,
                                  java.lang.String methodName,
                                  byte[] request,
                                  ApiProxy.ApiConfig apiConfig)
                           throws ApiProxy.ApiProxyException
```
    Make a synchronous call to the specified method in the specified API package.
    Note: if you have not installed a Delegate and called setEnvironmentForCurrentThread in this thread before calling this method, it will act like no API calls are available (i.e. always throw CallNotFoundException).
    
    Parameters:
    
    packageName - the name of the API package.
    
    methodName - the name of the method within the API package.
    
    request - a byte array containing the serialized form of the request protocol buffer.
    
    apiConfig - that specifies API-specific configuration parameters.
    
    Returns:
    
    a byte array containing the serialized form of the response protocol buffer.
    
    Throws:
    
    ApiProxy.ApplicationException - For any error that is the application's fault.
    
    ApiProxy.RPCFailedException - If we could not connect to a backend service.
    
    ApiProxy.CallNotFoundException - If the specified method does not exist, or if the thread making the call is neither a request thread nor a thread created by ThreadManager.
    
    ApiProxy.ArgumentException - If the request could not be parsed.
    
    ApiProxy.ApiDeadlineExceededException - If the request took too long.
    
    ApiProxy.CancelledException - If the request was explicitly cancelled.
    
    ApiProxy.CapabilityDisabledException - If the API call is currently unavailable.
    
    ApiProxy.OverQuotaException - If the API call required more quota than is available.
    
    ApiProxy.RequestTooLargeException - If the request to the API was too large.
    
    ApiProxy.ResponseTooLargeException - If the response to the API was too large.
    
    ApiProxy.UnknownException - If any other error occurred.
    
    ApiProxy.ApiProxyException
  - makeAsyncCall
```
public static java.util.concurrent.Future<byte[]> makeAsyncCall(java.lang.String packageName,
                                                                java.lang.String methodName,
                                                                byte[] request)
```
    See Also:
    
    makeAsyncCall(String,String,byte[],ApiConfig)
  - makeAsyncCall
```
public static java.util.concurrent.Future<byte[]> makeAsyncCall(java.lang.String packageName,
                                                                java.lang.String methodName,
                                                                byte[] request,
                                                                ApiProxy.ApiConfig apiConfig)
```
    Make an asynchronous call to the specified method in the specified API package.
    Note: if you have not installed a Delegate and called setEnvironmentForCurrentThread in this thread before calling this method, it will act like no API calls are available (i.e. the returned Future will throw CallNotFoundException).
    There is a limit to the number of simultaneous asynchronous API calls (currently 100). Invoking this method while this number of API calls are outstanding will block.
    
    Parameters:
    
    packageName - the name of the API package.
    
    methodName - the name of the method within the API package.
    
    request - a byte array containing the serialized form of the request protocol buffer.
    
    apiConfig - that specifies API-specific configuration parameters.
    
    Returns:
    
    a Future that will resolve to a byte array containing the serialized form of the response protocol buffer on success, or throw one of the exceptions documented for makeSyncCall(String, String, byte[], ApiConfig) on failure.
  - log
```
public static void log(ApiProxy.LogRecord record)
```
  - flushLogs
```
public static void flushLogs()
```
    Synchronously flush all pending application logs.
  - getCurrentEnvironment
```
public static ApiProxy.Environment getCurrentEnvironment()
```
    Gets the environment associated with this thread. This can be used to discover additional information about the current request. The value returned is the Environment that this thread most recently set with setEnvironmentForCurrentThread(com.google.apphosting.api.ApiProxy.Environment). If that is null and setEnvironmentFactory(com.google.apphosting.api.ApiProxy.EnvironmentFactory) has set an ApiProxy.EnvironmentFactory, that EnvironmentFactory is used to create an Environment instance which is returned by this call and future calls. If there is no EnvironmentFactory either, then null is returned.
  - setDelegate
```
public static void setDelegate(ApiProxy.Delegate aDelegate)
```
    Sets a delegate to which we will proxy requests. This should not be used from user-code.
  - getDelegate
```
public static ApiProxy.Delegate getDelegate()
```
    Gets the delegate to which we will proxy requests. This should really only be called from test-code where, for example, you might want to downcast and invoke methods on a specific implementation that you happen to know has been installed.
  - setEnvironmentForCurrentThread
```
public static void setEnvironmentForCurrentThread(ApiProxy.Environment environment)
```
    Sets an environment for the current thread. This should not be used from user-code.
  - clearEnvironmentForCurrentThread
```
public static void clearEnvironmentForCurrentThread()
```
    Removes any environment associated with the current thread. This should not be used from user-code.
  - getEnvironmentFactory
```
public static ApiProxy.EnvironmentFactory getEnvironmentFactory()
```
  - setEnvironmentFactory
```
public static void setEnvironmentFactory(ApiProxy.EnvironmentFactory factory)
```
    Set the EnvironmentFactory instance to use, which will be used to create Environment instances when a thread local one is not set. This should not be used from user-code, and it should only be called once, with a value that must not be null.
  - getRequestThreads
```
public static java.util.List<java.lang.Thread> getRequestThreads()
```
    Returns a list of all threads which are currently running requests.

Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License. For details, see the Google Developers Site Policies. Java is a registered trademark of Oracle and/or its affiliates.

Last updated 2025-06-16 UTC.

ApiProxy (Google App Engine API for Java)

Class ApiProxy

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

makeSyncCall

makeSyncCall

makeAsyncCall

makeAsyncCall

log

flushLogs

getCurrentEnvironment

setDelegate

getDelegate

setEnvironmentForCurrentThread

clearEnvironmentForCurrentThread

getEnvironmentFactory

setEnvironmentFactory

getRequestThreads