1//http://www.baidu.com
2URL realUrl = new URL(urlName);
3URLConnection conn = realUrl.openConnection();
4conn.setRequestProperty("accept", "*/*");
5conn.setRequestProperty("connection", "Keep-Alive");
6conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
7// 建立实际的连接
8conn.connect();

1public URLConnection openConnection() {
2    return handler.openConnection(this);
3}

1protected java.net.URLConnection openConnection(URL u, Proxy p) {
2    //p为空
3    return new HttpURLConnection(u, p, this);
4}

 1protected HttpURLConnection(URL u, Proxy p, Handler handler) {
 2    super(u);
 3    requests = new MessageHeader();
 4    responses = new MessageHeader();
 5    userHeaders = new MessageHeader();
 6    this.handler = handler;
 7    instProxy = p;
 8    if (instProxy instanceof sun.net.ApplicationProxy) {
 9        /* Application set Proxies should not have access to cookies
10         * in a secure environment unless explicitly allowed. */
11        try {
12            cookieHandler = CookieHandler.getDefault();
13        } catch (SecurityException se) { /* swallow exception */ }
14    } else {
15        cookieHandler = java.security.AccessController.doPrivileged(
16            new java.security.PrivilegedAction<CookieHandler>() {
17            public CookieHandler run() {
18                return CookieHandler.getDefault();
19            }
20        });
21    }
22    cacheHandler = java.security.AccessController.doPrivileged(
23        new java.security.PrivilegedAction<ResponseCache>() {
24            public ResponseCache run() {
25            return ResponseCache.getDefault();
26        }
27    });
28}

1public void setRequestProperty(String key, String value) {
2    if (connected)
3        throw new IllegalStateException("Already connected");
4    if (key == null)
5        throw new NullPointerException ("key is null");
6    if (requests == null)
7        requests = new MessageHeader();
8    requests.set(key, value);
9}

1protected HttpClient getNewHttpClient(URL url, Proxy p, int connectTimeout)  {
2    return HttpClient.New(url, p, connectTimeout, this);
3}

 1protected HttpClient(URL url, Proxy p, int to) {
 2    proxy = (p == null) ? Proxy.NO_PROXY : p;
 3    this.host = url.getHost();
 4    this.url = url;
 5    port = url.getPort();
 6    if (port == -1) {
 7        //默认就是80
 8        port = getDefaultPort();
 9    }
10    setConnectTimeout(to);
11    capture = HttpCapture.getCapture(url);
12    openServer();
13}

 1@Override
 2public void openServer(String server, int port) throws IOException {
 3    serverSocket = doConnect(server, port);
 4    try {
 5        OutputStream out = serverSocket.getOutputStream();
 6        if (capture != null) {
 7            out = new HttpCaptureOutputStream(out, capture);
 8        }
 9        serverOutput = new PrintStream(new BufferedOutputStream(out),false, encoding);
10    } catch (UnsupportedEncodingException e) {
11        throw new InternalError(encoding+" encoding not found", e);
12    }
13    serverSocket.setTcpNoDelay(true);
14}

1www\.baidu\.com , baidu%d.log

1capture = HttpCapture.getCapture(url);

 1  public static HttpCapture getCapture(java.net.URL url) {
 2    //读取sun.net.http.captureRules指向的文件并解析
 3    if (!isInitialized()) {
 4        init();
 5    }
 6    if (patterns == null || patterns.isEmpty()) {
 7        return null;
 8    }
 9    String s = url.toString();
10    for (int i = 0; i < patterns.size(); i++) {
11        Pattern p = patterns.get(i);
12        if (p.matcher(s).find()) {
13            String f = capFiles.get(i);
14            File fi;
15            if (f.indexOf("%d") >= 0) {
16                java.util.Random rand = new java.util.Random();
17                do {
18                    //用随机数替代%d
19                    String f2 = f.replace("%d", Integer.toString(rand.nextInt()));
20                    fi = new File(f2);
21                } while (fi.exists());
22            } else {
23                fi = new File(f);
24            }
25            return new HttpCapture(fi, url);
26        }
27    }
28    return null;
29}

1@Override
2public Map<String, List<String>> getHeaderFields() {
3    try {
4        getInputStream();
5    } catch (IOException e) {}
6    return getFilteredHeaderFields();
7}

1public void writeRequests(MessageHeader head,PosterOutputStream pos) {
2    requests = head;
3    requests.print(serverOutput);
4    serverOutput.flush();
5}

1public synchronized void print(PrintStream p) {
2    for (int i = 0; i < nkeys; i++)
3        if (keys[i] != null) {
4            p.print(keys[i] +
5                (values[i] != null ? ": "+values[i]: "") + "\r\n");
6        }
7    p.print("\r\n");
8    p.flush();
9}

1public native InetAddress[]
2        lookupAllHostAddr(String hostname) throws UnknownHostException;

1public static HttpClient New(URL url, Proxy p, int to, boolean useCache,
2        HttpURLConnection httpuc) throws IOException {
3    HttpClient ret = null;
4    /* see if one's already around */
5    if (useCache) {
6        ret = kac.get(url, null);
7    }
8    // ...
9}

1/* where we cache currently open, persistent connections */
2protected static KeepAliveCache kac = new KeepAliveCache();

 1/**
 2 * A class that implements a cache of idle Http connections for keep-alive
 3 *
 4 * @author Stephen R. Pietrowicz (NCSA)
 5 * @author Dave Brown
 6 */
 7public class KeepAliveCache
 8    extends HashMap<KeepAliveKey, ClientVector>
 9    implements Runnable {
10	
11    static final int MAX_CONNECTIONS = 5;
12    static int result = -1;
13    static int getMaxConnections() {
14        if (result == -1) {
15            result = AccessController.doPrivileged(
16                new GetIntegerAction("http.maxConnections", MAX_CONNECTIONS))
17                .intValue();
18            if (result <= 0) {
19                result = MAX_CONNECTIONS;
20            }
21        }
22        return result;
23    }
24    
25}

1static final int LIFETIME = 5000;

1AccessController.doPrivileged(new PrivilegedAction<>() {
2	public Void run() {
3		keepAliveTimer = InnocuousThread.newSystemThread("Keep-Alive-Timer", cache);
4		keepAliveTimer.setDaemon(true);
5		keepAliveTimer.setPriority(Thread.MAX_PRIORITY - 2);
6		keepAliveTimer.start();
7		return null;
8	}
9});

 1@Override
 2public void run() {
 3	do {
 4		try {
 5			Thread.sleep(LIFETIME);
 6		} catch (InterruptedException e) {}
 7
 8		// Remove all outdated HttpClients.
 9		synchronized (this) {
10			long currentTime = System.currentTimeMillis();
11			List<KeepAliveKey> keysToRemove = new ArrayList<>();
12
13			for (KeepAliveKey key : keySet()) {
14				ClientVector v = get(key);
15				synchronized (v) {
16					KeepAliveEntry e = v.peek();
17					while (e != null) {
18						if ((currentTime - e.idleStartTime) > v.nap) {
19							v.poll();
20							e.hc.closeServer();
21						} else {
22							break;
23						}
24						e = v.peek();
25					}
26
27					if (v.isEmpty()) {
28						keysToRemove.add(key);
29					}
30				}
31			}
32
33			for (KeepAliveKey key : keysToRemove) {
34				removeVector(key);
35			}
36		}
37	} while (!isEmpty());
38}

 1/**
 2 * Register this URL and HttpClient (that supports keep-alive) with the cache
 3 * @param url  The URL contains info about the host and port
 4 * @param http The HttpClient to be cached
 5 */
 6public synchronized void put(final URL url, Object obj, HttpClient http) {
 7    if (v == null) {
 8        int keepAliveTimeout = http.getKeepAliveTimeout();
 9        v = new ClientVector(keepAliveTimeout > 0 ?
10                             keepAliveTimeout * 1000 : LIFETIME);
11        v.put(http);
12        super.put(key, v);
13    } else {
14        v.put(http);
15    }
16}