使用sdn查詢時，當資料量較大並且需要做全庫掃描時，很容易出現超時問題。丟擲如下異常：

Exception in thread "main" com.sun.jersey.api.client.ClientHandlerException: java.net.SocketTimeoutException: Read timed out
    at com.sun.jersey.client.urlconnection.URLConnectionClientHandler.handle(URLConnectionClientHandler.java:149)
    at org.neo
 
4j.rest.graphdb.UserAgent$1.handle(UserAgent.java:68)
    at com.sun.jersey.api.client.filter.HTTPBasicAuthFilter.handle(HTTPBasicAuthFilter.java:81)
    at com.sun.jersey.api.client.Client.handle(Client.java:648)
    at com.sun.jersey.api.client.WebResource.handle(WebResource.java:670)
    at com.sun
 
.jersey.api.client.WebResource.access$200(WebResource.java:74)
    at com.sun.jersey.api.client.WebResource$Builder.post(WebResource.java:553)
    at org.neo4j.rest.graphdb.ExecutingRestRequest.post(ExecutingRestRequest.java:145)
    at org.neo4j.rest.graphdb.RestAPIImpl.query(RestAPIImpl.java:486)

於是考慮加入超時時間，形式如：

System.setProperty("org.neo4j.rest.read_timeout", "80");

但是此時，查詢sql呼叫的形式是，Repository+註解，該System的屬性設定對於Spring託管的client並沒有生效，此時查詢仍然會出現超時問題，接下來會對該問題從原始碼上做分析。如果此時設定超時時間後，新new出一個client，這是超時時間設定就生效了，具體程式碼如：

System.setProperty("org.neo4j.rest.read_timeout", "80");
RestAPI restAPIFacade1 = buildClient(address1, userName1, password1);
CypherResult cr = restAPIFacade1.query("xxx", new HashMap<String, Object>());
System.out.println("cost time: " + (System.currentTimeMillis() - ss));
System.out.println(cr.asMap().get("data"));

為何這樣設定就會生效，我們可以跟進看一下原始碼：
RestAPI restAPIFacade1 = buildClient(address1, userName1, password1) 其實呼叫的是：
restAPIFacade = new RestAPIImpl(address, userName, password);
接下來：

public RestAPIImpl(String uri, String user, String password) {
        this.entityRefetchTimeInMillis = TimeUnit.SECONDS.toMillis(1000L);
        this.entityCache = new RestEntityCache(this);
        this.restEntityExtractor = new RestEntityExtractor(this);
        this.restRequest = this.createRestRequest(uri, user, password);
        this.restIndexAPI = new RestAPIIndexImpl(this);
    }

繼續到 this.createRestRequest(uri, user, password)：

protected RestRequest createRestRequest(String uri, String user, String password) {
        return new ExecutingRestRequest(uri, user, password);
    }

繼續：

public ExecutingRestRequest(String baseUri, String username, String password) {
        this.userAgent = new UserAgent();
        this.baseUri = this.uriWithoutSlash(baseUri);
        this.client = this.createClient();
        this.addAuthFilter(username, password);
    }

繼續createClient內部為：

protected Client createClient() {
        Client client = Client.create();
        client.setConnectTimeout(Integer.valueOf(Config.getConnectTimeout()));
        client.setReadTimeout(Integer.valueOf(Config.getReadTimeout()));
        client.setChunkedEncodingSize(Integer.valueOf(8192));
        this.userAgent.install(client);
        if(Config.useLoggingFilter()) {
            client.addFilter(new LoggingFilter());
        }

        return client;
    }

我們注意到，此時client在構造過程中，會有 設定timeout的步驟，繼續檢視Config.getReadTimeout()，整個Config類不長，貼上全部程式碼：

package org.neo4j.rest.graphdb.util;

import java.util.concurrent.TimeUnit;

public class Config {
    public static final String CONFIG_PREFIX = "org.neo4j.rest.";
    public static final String CONFIG_STREAM = "org.neo4j.rest.stream";
    public static final String CONFIG_BATCH_TRANSACTION = "org.neo4j.rest.batch_transaction";
    public static final String CONFIG_LOG_REQUESTS = "org.neo4j.rest.logging_filter";
    public static final String WRITE_THREADS = "write_threads";

    public Config() {
    }

    public static int getConnectTimeout() {
        return getTimeout("connect_timeout", 30);
    }

    public static int getReadTimeout() {
        return getTimeout("read_timeout", 30);
    }

    public static boolean streamingIsEnabled() {
        return Boolean.parseBoolean(System.getProperty("org.neo4j.rest.stream", "true"));
    }

    public static boolean useBatchTransactions() {
        return System.getProperty("org.neo4j.rest.batch_transaction", "false").equalsIgnoreCase("true");
    }

    public static boolean useLoggingFilter() {
        return System.getProperty("org.neo4j.rest.logging_filter", "false").equalsIgnoreCase("true");
    }

    private static int getTimeout(String param, int defaultValue) {
        return (int)TimeUnit.SECONDS.toMillis((long)Integer.parseInt(System.getProperty("org.neo4j.rest." + param, "" + defaultValue)));
    }

    public static int getWriterThreads() {
        return Integer.parseInt(System.getProperty("org.neo4j.rest.write_threads", "10"));
    }
}

很簡單，在這裡我們看到client生成時，超時時間設定的整個過程，在未設定系統引數時，超時時間取的預設值30s（從程式碼中也可觀察到為什麼我們設定執行環境變數的key為 org.neo4j.rest.read_timeout）。那麼接下來我們如何設定超時時間呢？這個也很簡單，jvm可選引數中做如下設定：

-Dorg.neo4j.rest.read_timeout=150

通常該引數在idea或eclipse中的VM options中。
在有些情況下，我們可能需要直接在tomcat中設定，比如在beta或者生產環境的伺服器上。我們可以tomcat的啟動引數指令碼中設定，通常在tomcat/bin下的catalina.cmd，或catalina.sh，以及startenv.sh等指令碼中設定即可。
如果有多臺伺服器，並且可能部署在虛擬容器上，此時如果生成環境時，就需要額外在tomcat上做上述設定，也是相當的繁瑣的。我們上面遇到的問題是，通過spring容器生成的neo4j client 超時時間設定不生效。其實問題在於spring生成例項時，該系統屬性並未設定。所以，可以藉助spring提供的工具來完成環境引數的設定。
在springContext.xml中做如下配置：

<bean class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
        <property name="targetClass" value="java.lang.System" />
        <property name="targetMethod" value="setProperty" />
        <property name="arguments">
            <list>
                <value>org.neo4j.rest.read_timeout</value>
                <value>${neo4j.read.timeout}</value>
            </list>
        </property>
    </bean>

注意，根據spring bean的生成順序，該bean必須在新增在neo4j client 的bean 配置之前方能生效。該方法是較為優雅的解決方法了。
另外關於org.springframework.beans.factory.config.MethodInvokingFactoryBean 的使用，可以另外再做整理和總結了。