小编Max*_*ler的帖子

我从HttpClient获得了奇怪的行为,参数CoreConnectionPNames.CONNECTION_TIMEOUT设置为1.我希望HttpGet请求失败,抛出连接超时异常,但它们是成功的.这似乎是不合理的,因为它实际上意味着TCP握手在不到1毫秒内完成.

我正在使用的httpclient版本可以在这个pom.xml中看到

    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.0.1</version>
        <type>jar</type>
    </dependency>

这是代码:

import java.io.IOException;
import java.util.Random;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;

public class TestNodeAliveness {
    private static Logger log = Logger.getLogger(TestNodeAliveness.class);

    public static boolean nodeBIT(String elasticIP) throws ClientProtocolException, IOException {
        try {
            HttpClient client = new DefaultHttpClient();

            // The time it takes to open TCP connection.
            client.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 1);

            // Timeout when server does not send data.
            client.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, 5000); …

我正在寻找一个轻量级的REST库.

它必须很小(kb大小)一个Fast(总执行时间).最佳解决方案是单个jar,没有任何依赖性.

该应用程序旨在在AppEngine上运行,因此该库应该在GAE/J平台上运行.

致力于提高决策中心的绩效,我们确定的瓶颈之一就是数据库.

所以我想知道,oracle是否为其视图编制了执行计划？

让我们假设我10000在请求期间使用了定义的查询次数.查询看起来像:

select A, B, C 
from aTbl, bTbl left join cTbl on bTbl.cTblID = cTbl.objectkey
where aTbl.objectkey = bTbl.parentkey

在代码中我想用额外的过滤参数获取上面查询的结果,例如: WHERE aTbl.flag1 = <<NUMBER>>

现在我有两个选择:

1. 使用上面的内容创建预准备语句SQL,然后重用该对象.
2. 将上述内容select (aTbl, bTbl, cTbl)放入a VIEW,然后在此视图上创建预准备语句,从而使预编译的Oracle执行计划受益.

你会建议什么？

对于以下代码,为什么要打印A,B？我希望它能打印B,B.此外,JVM执行的方法调用是动态还是静态评估的？

public class Main {
    class A {

    }

    class B extends A {

    }

    public void call(A a) {
        System.out.println("I'm A");
    }

    public void call(B a) {
        System.out.println("I'm B");
    }


    public static void main(String[] args) {

        Main m = new Main();
        m.runTest();
    }

    void runTest() {
        A a = new B();
        B b = new B();

        call(a);
        call(b);
    }

}

我很难在以下两个实现之间做出决定.我想缓存每个线程的javax.xml.parsers.DocumentBuilder对象.我主要担心的是运行时性能--Hench我很乐意避免使用尽可能多的GC.记忆不是问题.

我已经写了两个POC实现,很高兴听到社区PROS/CONS关于每个实现.

谢谢你的帮助.

选项#1 - WeakHashMap

import java.io.IOException;
import java.io.StringReader;
import java.util.WeakHashMap;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;


public class DocumentBuilder_WeakHashMap {
    private static final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    private static final WeakHashMap<Thread, DocumentBuilder> CACHE = new WeakHashMap<Thread, DocumentBuilder>();

    public static Document documentFromXMLString(String xml) throws SAXException, IOException, ParserConfigurationException {
        DocumentBuilder builder = CACHE.get(Thread.currentThread());
        if(builder == null) {
            builder = factory.newDocumentBuilder();
            CACHE.put(Thread.currentThread(), builder);
        }

        return builder.parse(new InputSource(new StringReader(xml)));
    }

}

选项#2 - ThreadLocal

import java.io.IOException; …

开发和生产环境之间的GAE/J关键差异是什么？

• 什么应该在生产中重新检查？
• 我应该期待什么样的数据存储差异？

以下字节流由UTF-8标识,它包含希伯来语句子:????? ??????? ??? ???? - ?????.我正在尝试理解编码.

ubuntu@ip-10-126-21-104:~$ od -t x1 homeless-title-fromwireshark_followed_by_hexdump.txt
0000000 0a 09 d7 93 d7 99 d7 a8 d7 95 d7 aa 20 d7 9c d7
0000020 a9 d7 95 d7 aa d7 a4 d7 99 d7 9d 20 20 d7 91 d7
0000040 aa d7 9c 20 d7 90 d7 91 d7 99 d7 91 20 2d 20 d7
0000060 94 d7 95 d7 9e d7 9c d7 a1 0a
0000072
ubuntu@ip-10-126-21-104:~$ file -i homeless-title-fromwireshark_followed_by_hexdump.txt …

假设我有2个字符串常量

KEY1 = "Hello"
KEY2 = "World"

我想使用这些常量作为键值创建一个哈希.

尝试这样的事情:

stories = {
  KEY1: { title: "The epic run" },
  KEY2: { title: "The epic fail" }
}

似乎没有用

stories.inspect
#=> "{:KEY1=>{:title=>\"The epic run\"}, :KEY2=>{:title=>\"The epic fail\"}}"

而stories[KEY1]显然行不通.

我正在编写一个理论上可以在不同环境中使用的Java客户端:Java main(),servlet容器或依赖注入.

客户端实现内部连接线程池.

这种方法的问题在于,客户端的用户不知道实现内部线程池的事实将使他或她的应用程序在关闭时"挂起".我的用户需要知道向库发送shutdown()消息.

我想知道是否可以采取任何其他替代方法,一方面,允许我为我的连接启动一个线程池; 而且,另一方面,捕获一些事件,可能是一个JVM事件,表明JVM正在关闭,这将允许我调用我的shutdown()实现.

尝试使用通过函数参数提供的键来构建字典.

var progres_mark = function(progress_state) {
  var now = Date();
  console.log({ progress_state : now })
}

progres_mark("encode")

预期

{ 'encode': 'Sun Oct 19 2014 18:22:33 GMT+0300 (IDT)' }

实际

{ progress_state: 'Sun Oct 19 2014 18:22:33 GMT+0300 (IDT)' }

这是怎么回事？