首页 > 代码库 > HttpURLConnection

HttpURLConnection

2024-07-23 13:20:49   219人阅读

HttpURLConnection  实现网络访问文件，并且将获取到的数据存放到字节数组中

 

 1 public class HttpURLConnHelper { 2     private final static String TAG = "MyHttpHelperUtil"; 3  4     /** 5      * 作用：实现网络访问文件，将获取到的数据存在字节数组中 6      *  7      * @param url 8      *            ：访问网络的url地址 9      * @return byte[]10      */11     public static byte[] downLoadByteFromURL(String url) { 12         Log.i(TAG, "==以get方式访问网络");13         HttpURLConnection httpConn = null;14         //BufferedInputStream 是一个带有缓冲区域的inputStream15         BufferedInputStream bis = null;16         ByteArrayOutputStream baos = null;17         try {18             Log.i(TAG, "==1、创建URL对象，url-->" + url);19             URL urlObj = new URL(url);20             Log.i(TAG, "==2、创建连接，openConnection");21             httpConn = (HttpURLConnection) urlObj.openConnection();22             // 以下两项都是默认值。虽然可以不写，但是建议写上。23             httpConn.setRequestMethod("GET");24             // // 设置将服务器返回数据写入到httpConn对象25             // httpConn.setDoInput(true);26             // 设置访问超时时间27             httpConn.setConnectTimeout(1000);28             // // 设置是否使用缓存29             // httpConn.setUseCaches(false);30             // // 建立远程对象实际连接31             // httpConn.connect();32             Log.i(TAG,33                     "==3、getResponseCode()方法获取服务器的返回码:"34                             + httpConn.getResponseCode());35             if (httpConn.getResponseCode() == 200) {36                 Log.i(TAG,37                         "==4、调用 HttpURLConnection对象的getInputStream()方法获取服务器返回的流信息");38                 bis = new BufferedInputStream(httpConn.getInputStream());39                 Log.i(TAG, "==5、执行标准的IO流操作");40                 baos = new ByteArrayOutputStream();41                 int c = 0;42                 byte[] buffer = new byte[8 * 1024];43                 while ((c = bis.read(buffer)) != -1) {44                     baos.write(buffer, 0, c);45                     baos.flush();46                 }47                 byte[] result = baos.toByteArray();48                 Log.i(TAG, "result==" + result.length);49                 return result;50             }51         } catch (Exception e) {52             e.printStackTrace();53         } finally {54             try {55                 if (bis != null) {56                     bis.close();57                 }58                 if (baos != null) {59                     baos.close();60                 }61                 if (httpConn != null) {62                     httpConn.disconnect();63                 }64             } catch (IOException e) {65                 e.printStackTrace();66             }67         }68         return null;69     }

 

 

BufferedInputStream是一个带有缓冲区域的InputStream,它的继承体系如下：

InputStream 
|__FilterInputStream 
        |__BufferedInputStream 

FilterInputStream： 
FilterInputStream通过装饰器模式将InputStream封装至内部的一个成员变量：

Java代码  收藏代码
  1. protected volatile InputStream in; 

 

需要注意的是该成员变量使用了volatile关键字进行修饰，这意味着该成员变量的引用的内存可见性为多线程即时可见的。 
其它地方FilterInputStream将所有的操作委托给了in这个成员进行操作。 

了解了这些过后，来仔细看看BufferedInputStream的成员变量： 

 1 private static int defaultBufferSize = 8192 //该变量定义了默认的缓冲大小   2    3 protected volatile byte buf[]; //缓冲数组，注意该成员变量同样使用了volatile关键字进行修饰，作用为在多线程环境中，当对该变量引用进行修改时保证了内存的可见性。   4    5 private static final AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater = AtomicReferenceFieldUpdater.newUpdater(BufferedInputStream.class,  byte[].class, "buf")//缓存数组的原子更新器，该成员变量与buf数组的volatile关键字共同组成了buf数组的原子更新功能实现。   6    7 protected int count;//该成员变量表示目前缓冲区域中有多少有效的字节。   8    9 protected int pos;//该成员变量表示了当前缓冲区的读取位置。  10   11 protected int markpos = -1;/*表示标记位置，该标记位置的作用为：实现流的标记特性，即流的某个位置可以被设置为标记，允许通过设置reset()，将流的读取位置进行重置到该标记位置，但是InputStream注释上明确表示，该流不会无限的保证标记长度可以无限延长，即markpos=15,pos=139734，该保留区间可能已经超过了保留的极限（如下）*/  12   13 protected int marklimit;/*该成员变量表示了上面提到的标记最大保留区间大小，当pos-markpos> marklimit时，mark标记可能会被清除（根据实现确定）。*/  
 
 
 
通过构造函数可以看到：初始化了一个byte数组作为缓冲区域 
 
1 public BufferedInputStream(InputStream in, int size) {  2     super(in);  3         if (size <= 0) {  4             throw new IllegalArgumentException("Buffer size <= 0");  5         }  6     buf = new byte[size];  7 }  
 
这个类中最为重要的方法是fill()方法，它提供了缓冲区域的读取、写入、区域元素的移动更新等。下面着重分析一下该方法： 
 1 private void fill() throws IOException { 2         byte[] buffer = getBufIfOpen(); 3     if (markpos < 0) ｛ 4           /*如果不存在标记位置（即没有需要进行reset的位置需求） 5             则可以进行大胆地直接重置pos标识下一可读取位置,但是这样 6             不是会读取到以前的旧数据吗？不用担心，在后面的代码里☆会实现输入流的新  7             数据填充*/ 8         pos = 0;         9     ｝else if (pos >= buffer.length)｛10        /* 位置大于缓冲区长度，这里表示已经没有可用空间了 */11         if (markpos > 0) {    12              /* 表示存在mark位置，则要对mark位置到pos位置的数据予以保留，13                 以确保后面如果调用reset()重新从mark位置读取会取得成功*/14         int sz = pos - markpos;15                 /*该实现是通过将缓冲区域中markpos至pos部分的移至缓冲区头部实现*/16         System.arraycopy(buffer, markpos, buffer, 0, sz);17         pos = sz;18         markpos = 0;19         } else if (buffer.length >= marklimit) {20                 /* 如果缓冲区已经足够大，可以容纳marklimit，则直接重置*/21                 markpos = -1;    22         pos = 0;/* 丢弃所有的缓冲区内容 */23         } else {        24                 /* 如果缓冲区还能增长的空间，则进行缓冲区扩容*/25         int nsz = pos * 2;26                 /*新的缓冲区大小设置成满足最大标记极限即可*/27         if (nsz > marklimit)28             nsz = marklimit;29         byte nbuf[] = new byte[nsz];30                 //将原来的较小的缓冲内容COPY至增容的新缓冲区中31         System.arraycopy(buffer, 0, nbuf, 0, pos);32                 //这里使用了原子变量引用更新，确保多线程环境下内存的可见性33                 if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {34                     // Can‘t replace buf if there was an async close.35                     // Note: This would need to be changed if fill()36                     // is ever made accessible to multiple threads.37                     // But for now, the only way CAS can fail is via close.38                     // assert buf == null;39                     throw new IOException("Stream closed");40                 }41                 buffer = nbuf;42         }43         count = pos;44         //从原始输入流中读取数据，填充缓冲区45     int n = getInIfOpen().read(buffer, pos, buffer.length - pos);46         //根据实际读取的字节数更新缓冲区中可用字节数47         if (n > 0)48             count = n + pos;49     }
整个fill的过程，可以看作是BufferedInputStream对外提供滑动读取的功能实现，通过预先读入一整段原始输入流数据至缓冲区中，而外界对BufferedInputStream的读取操作实际上是在缓冲区上进行，如果读取的数据超过了缓冲区的范围，那么BufferedInputStream负责重新从原始输入流中载入下一截数据填充缓冲区，然后外界继续通过缓冲区进行数据读取。这样的设计的好处是：避免了大量的磁盘IO，因为原始的InputStream类实现的read是即时读取的，即每一次读取都会是一次磁盘IO操作（哪怕只读取了1个字节的数据），可想而知，如果数据量巨大，这样的磁盘消耗非常可怕。而通过缓冲区的实现，读取可以读取缓冲区中的内容，当读取超过缓冲区的内容后再进行一次磁盘IO，载入一段数据填充缓冲，那么下一次读取一般情况下就直接可以从缓冲区读取，减少了磁盘IO。减少的磁盘IO大致可以通过以下方式计算（限read()方式）： 

length  流的最终大小 
bufSize 缓冲区大小 

则通过缓冲区实现的输入流BufferedInputStream的磁盘IO数为原始InputStream磁盘IO的 
1/(length/bufSize) 

read方法解析：该方法返回当前位置的后一位置byte值（int表示）. 
 1 public synchronized int read() throws IOException { 2     if (pos >= count) { 3            /*表示读取位置已经超过了缓冲区可用范围，则对缓冲区进行重新填充*/ 4         fill(); 5            /*当填充后再次读取时发现没有数据可读，证明读到了流末尾*/ 6         if (pos >= count) 7         return -1; 8     } 9         /*这里表示读取位置尚未超过缓冲区有效范围，直接返回缓冲区内容*/10     return getBufIfOpen()[pos++] & 0xff;11 }
一次读取多个字节（尽量读，非贪婪) 
 1 private int read1(byte[] b, int off, int len) throws IOException { 2     int avail = count - pos; 3     if (avail <= 0) { 4         /*这里使用了一个巧妙的机制，如果读取的长度大于缓冲区的长度 5               并且没有markpos，则直接从原始输入流中进行读取，从而避免无谓的 6               COPY（从原始输入流至缓冲区，读取缓冲区全部数据，清空缓冲区， 7               重新填入原始输入流数据）*/ 8         if (len >= getBufIfOpen().length && markpos < 0) { 9         return getInIfOpen().read(b, off, len);10         }11             /*当无数据可读时，从原始流中载入数据到缓冲区中*/12         fill();13         avail = count - pos;14         if (avail <= 0) return -1;15     }16     int cnt = (avail < len) ? avail : len;17         /*从缓冲区中读取数据，返回实际读取到的大小*/18     System.arraycopy(getBufIfOpen(), pos, b, off, cnt);19     pos += cnt;20     return cnt;21     }
以下方法和上面的方法类似，唯一不同的是，上面的方法是尽量读，读到多少是多少，而下面的方法是贪婪的读，没有读到足够多的数据（len）就不会返回，除非读到了流的末尾。该方法通过不断循环地调用上面read1方法实现贪婪读取
 
 1 public synchronized int read(byte b[], int off, int len) 2     throws IOException 3     { 4         getBufIfOpen(); // Check for closed stream 5         if ((off | len | (off + len) | (b.length - (off + len))) < 0) { 6         throw new IndexOutOfBoundsException(); 7     } else if (len == 0) { 8             return 0; 9         }10 11     int n = 0;12         for (;;) {13             int nread = read1(b, off + n, len - n);14             if (nread <= 0) 15                 return (n == 0) ? nread : n;16             n += nread;17             if (n >= len)18                 return n;19             // if not closed but no bytes available, return20             InputStream input = in;21             if (input != null && input.available() <= 0)22                 return n;23         }24     }
略过多少字节 
 1 public synchronized long skip(long n) throws IOException { 2         getBufIfOpen(); // Check for closed stream 3     if (n <= 0) { 4         return 0; 5     } 6     long avail = count - pos; 7       8         if (avail <= 0) { 9             // If no mark position set then don‘t keep in buffer10             //从上面的注释可以知道，这也是一个巧妙的方法，如果没有mark标记，11             // 则直接从原始输入流中skip12             if (markpos <0) 13                 return getInIfOpen().skip(n);14             15             // Fill in buffer to save bytes for reset16             fill();17             avail = count - pos;18             if (avail <= 0)19                 return 0;20         }21         //该方法的实现为尽量原则，不保证一定略过规定的字节数。22         long skipped = (avail < n) ? avail : n;23         pos += skipped;24         return skipped;25     }
 
估计目前可用的字节数，原始流中可用的字节数+缓冲区中可用的字节数 
1 public synchronized int available() throws IOException {2     return getInIfOpen().available() + (count - pos);3     }
标记位置： 
1 public synchronized void reset() throws IOException {2         getBufIfOpen(); // Cause exception if closed3     if (markpos < 0)4         throw new IOException("Resetting to invalid mark");5     pos = markpos;6     }
重置位置：该实现清晰的表明下一读取位置被推到了以前的标记位置，以实现重新读取区段的功能 
1 public synchronized void reset() throws IOException {2         getBufIfOpen(); // Cause exception if closed3     if (markpos < 0)4         throw new IOException("Resetting to invalid mark");5     pos = markpos;6     }
关闭流：首先通过线程安全的方式设置了内部的缓冲区引用为空，然后再对原始输入流进行关闭。 
 1 public void close() throws IOException { 2         byte[] buffer; 3         while ( (buffer = buf) != null) { 4             if (bufUpdater.compareAndSet(this, buffer, null)) { 5                 InputStream input = in; 6                 in = null; 7                 if (input != null) 8                     input.close(); 9                 return;10             }11             // Else retry in case a new buf was CASed in fill()12         }13     }
 
HttpURLConnection






























        

            
                
                  
                
                

                    联系

                    我们