android把圖片base64

『壹』 android 圖片轉BASE64上傳提示java.lang.OutOfMemoryError

我最近也碰到了這個問題，但是網上沒有找到相關有效的直接解決方法。
後來看到了一篇解釋base64編碼原理的文章，研究了一番後解決了。
一般碰到這個問題的，都涉及到"大文件上傳"的問題，"大文件上傳"過程中除了base64編碼時可能OOM，其實還有其他問題，雖然提問中沒有提出，可能是因為這個問題還沒有解決，所以還沒有遇到其它問題，我就圍繞著"大文件上傳"來解決這個問題吧。
(提問時間在下看的清楚)

————————————————————

做項目的過程中碰到一個需求：
在java客戶端，使用http通信，把客戶端的本地文件通過http發送上傳到伺服器；

請求格式是xml(不管是json還是xml都是字元串，所以這個無所謂)，中間包含[文件流字元串]；

之前的做法是，把文件流通過base64編碼轉換為base64Byte，然後和其它字元串信息放到一起，post的時候通過HttpURLConnection的write方法寫入到伺服器中去，這個上傳的過程就完成了。

——————————
但是碰到一個問題，當文件體積較大時，從文件流轉換成base64Byte後，體積會很大，可能會導致OOM；
(以二進制流的方式保存，體積最小；以byte數組的方式保存，體積會相對變大一些；以String形式保存，體積最大；)

出錯原因是：
FileInputStream fis = new FileInputStream(file); //這一步打開了一個對准file准備進行讀取的文件指針，但是還沒有開始讀寫，file的相關數據沒有從本地載入到內存中來；所以即使file的體積有10G那麼大，這一步也是不會OOM的

//把文件流轉換為位元組數組
byte[] fileBytes;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] byteBuf = new byte[1024];
int count;
while((count=fis.read(buf))!=-1)
{
baos.write(buf,0,count); //實際上，如果文件體積比較大的話，不用轉碼，在這一步就可能OOM了
}
fileBytes= baos.toByteArray();

byte[] base64Bytes = Base64.encodeBase64(fileBytes); //在這一步也可能OOM
(文件轉換為byte[]時，是有可能OOM的；而轉換為base64Bytes後，體積會增大1/3，所以有可能前一步沒有OOM，卻在這一步出現OOM；
為什麼轉碼後體積會增大1/3，後面我會解釋)

——————————
解決方法

既然file在本地沒有載入到內存來的時候不會出現內存溢出的情況，我就想到了一個解決的方法：分段上傳
(加大內存並不能從根本上解決內存溢出的問題，問題的根本原因不是內存不夠大，而是代碼有問題)

在本地的file通過HttpURLConnection的getOutputStream()進行write時，不是一次性全部寫入，而是循環配合flush進行寫入：
FileInputStream fis = new FileInputStream(file);
byte[] buf = new byte[1024];
int count;
while((count = fis.read(buf)) != -1)
{
os.write(Base64.encodeBase64(buf), 0, count);
os.flush();
}
(我從本地讀1024位元組，然後馬上上傳到伺服器，清空本地緩存，然後再從本地讀1024位元組，這樣循環讀取，即使文件有20G，理論上也不有OOM問題出現，因為我從本地文件中讀到的數據不會在內存中駐留)

——————————
解決問題的思路對了，但是出現了其他的細節問題
os.write(Base64.encodeBase64(buf), 0, count); //這一行代碼報錯了，出現了OOM
我搜集了一下資料，發現原因是：
HttpURLConnection的getOutputStream的實際對象是sun.net.<a href="http://www.http.PosterOutputStream" target="_blank">www.http.PosterOutputStream</a>，這個對象的flush方法代碼是空的，write配合flush，並沒有達到即時上傳數據的效果。PosterOutputStream其實是自己在本地維護了一個緩沖區，你通過write寫入的數據其實還是在這個本地的緩沖區里，只有當你getInputStream後，HttpURLConnection才會把這段緩沖區中的數據上傳到伺服器上。而flush達不到上傳數據，清空本地緩存的效果。

——————————
(我是不能通過getInputStream來刷新緩沖流的，因為那就不是分段上傳而是"分次"上傳了)
那這就不是我的思路的問題了。再去搜索解決方法後，得知：
在創建HttpURLConnection對象的時候，要調用一個方法
hurlc.setChunkedStreamingMode(1024); //設置分塊流模式 也就是分塊上傳 1024是getOutputStream維護的本地緩沖區的大小
調用該方法後，只要本地緩存區滿了，HttpURLConnection就會自動把緩沖區里的數據發送到伺服器，同時清空本地緩存(ps：HttpURLConnection的getOutputStream似乎是個抽象的工廠方法，在調用setChunkedStreamingMode方法後，我發現getOutputStream獲取到的實例對象從sun.net.<a href="http://www.http.PosterOutputStream" target="_blank">www.http.PosterOutputStream</a>變成了sun.net.<a href="http://www.protocol.http.HttpURLConnection$StreamingOutputStream" target="_blank">www.protocol.http.HttpURLConnection$StreamingOutputStream</a>)

——————————
果然，調用setChunkedStreamingMode方法後，os.write(Base64.encodeBase64(buf), 0, count);沒有再出現OOM異常了

但是，又出現了一個新的問題
我發現
FileInputStream fis = new FileInputStream(file);
byte[] buf = new byte[1024];
int count;
while((count = fis.read(buf)) != -1)
{
os.write(Base64.encodeBase64(buf), 0, count);
os.flush();
}
這段分段編碼寫入的代碼，其編碼所得結果，與非分段編碼所得結果是不一樣的
通過分段編碼上傳的圖片內容出現了錯誤

我通過下面代碼測試：
//分段編碼
ByteArrayOutputStream os1 = new ByteArrayOutputStream();
InputStream file1 = new FileInputStream(path);
byte[] buf1 = new byte[1024];
int count1;
while((count1 = file1.read(buf1)) != -1)
{
os1.write(Base64.encodeBase64(buf1), 0, count1);
os1.flush();
}
file1.close();
System.out.println(os1.toString());

//非分段編碼
ByteArrayOutputStream os2 = new ByteArrayOutputStream();
InputStream file2 = new FileInputStream(path);
byte[] buf2 = new byte[1024];
int count2;
while((count2 = file2.read(buf2)) != -1)
{
os2.write(buf2, 0, count2);
os2.flush();
}
file2.close();
System.out.println(new String(Base64.encodeBase64(os2.toByteArray())));

兩者的結果：
/9j/4AAQSkZJR...wDtUAVs7eF...
/9j/4AAQSkZJR...wDt89ymnxJ...
前面一段還是相同的，轉到後面，就開始南轅北轍了

——————————
原因我去網上找了一下但是沒有找到直接答案，但是看到一篇解釋base64編碼原理的文章
原文鏈接：<a href="http://www.cnblogs.com/luguo3000/p/3940197.html" target="_blank">http://www.cnblogs.com/luguo3000/p/3940197.html</a>

假設有文件A(txt文件，包含文本內容"ABCDEFG")，轉換為InputStream->byte[]後
它們的ASIIC碼分別對應65、66、67、68、69、70、71
二進製表現形式為：
1000001 1000010 1000011 1000100 1000101 1000110 1000111
對高位補零後：
01000001 01000010 01000011 01000100 01000101 01000110 01000111
在內存中的實際表現：


而base64編碼，使用的字元包括(A-Z、a-z、0-9、+、/、=)這些常規可讀字元，使用base64編碼的原因，用途，在於把一些亂碼字元、不可讀字元轉換為常規可讀字元；
(因為java底層的通信協議、或者說其它的通信協議，很多地方用到遠程通信這一塊的，對一些亂碼字元不支持傳輸，所以需要把亂碼字元轉換成常規可讀字元才能進行傳輸)

比如對於'矙'這個字元，部分傳輸協議的編碼集就不認識它，所以無法直接傳輸，必須base64轉碼
'矙'的UTF-8編碼值為30681，二進製表現形式為111011111011001->(0)111011111011001
需要兩個位元組來存儲01110111 11011001

base64編碼只有(A-Z、a-z、0-9、+、/、=)這些字元來表示。需要強調的是，在base64編碼規范中，字元'A'不等於65、'B'也不是66...。base64字元與數值(二進制值)的對應關系如下：
也就是說，常規字元'A'=65=01000001；而base64字元'A'=0=00000000；

base64字元代表的二進制值是無法直接表示'矙'這個字元的，因為base64字元的值范圍在0~63之間(二進制值在(00)000000~(00)111111之間)。
那如何通過(00)000000~(00)111111之間的數值來表示01110111 11011001呢？

這就是base64的編碼演算法了
一個base64字元的二進制值在(00)000000~(00)111111之間，也就是說它可以表示000000~111111之間的二進制數，一個base64字元的有效位為後6位。如何通過以6bit為單位的base64字元表示以8bit為單位的常規位元組？
6和8的最小公倍數為24，即 每4個base64字元可以表示3個常規位元組；

回到剛才的文件A，編碼過程：
(初始文件A)->"ABCDEFG"
(轉UTF-8碼 int)->65 66 67 68 69 70 71
("ABCDEFG"的二進製表示；7位元組)->1000001 1000010 1000011 1000100 1000101 1000110 1000111
(高位補零)->01000001 01000010 01000011 01000100 01000101 01000110 01000111
(連寫)->
(按6bit為單位對所有bit進行分割；得到10位元組)->010000 010100 001001 000011 010001 000100 010101 000110 010001 11
(按6bit*4=8bit*3的對應關系再分割；得到3組6*4位元組)->(010000 010100 001001 000011) (010001 000100 010101 000110) (010001 11)
(高位補2個零；末尾的低位也補零)->(00010000 00010100 00001001 00000011) (00010001 00000100 00010101 00000110) (00010001 00110000)
(二進制值換算成十進制)->(16 20 9 3) (17 4 21 6) (17 48)
(按base64編碼的值-字元對應表，得出上面的十進制值對應的base64字元)->(Q U J D) (R E V G) (R w)
(每組base64字元都要求是4個，空白的位置補'='字元)->(Q U J D) (R E V G) (R w = =)
(文件A的最終轉碼結果)->QUJDREVGRw==
這里以文本文件作為演示，因為文本文件機器可讀人也可讀；實際情況中，很多時候轉碼的目標文件並不是文本文件，那就不能以可讀字元串形式表示了，會直接以二進制格式表示

體積增大的原因，是因為3位元組=24bit=分割成4個6bit-，對4個6bit高位補零後，就得到4個位元組
也就是說3個常規位元組經base64編碼後會生成4個base64位元組，這就是文件經base64轉碼後體積會增加1/3的原因

——————————
base64編碼原理解釋了，再看剛才的分段編碼
ByteArrayOutputStream os1 = new ByteArrayOutputStream();
InputStream file1 = new FileInputStream(path);
byte[] buf1 = new byte[1024];
int count1;
while((count1 = file1.read(buf1)) != -1)
{
os1.write(Base64.encodeBase64(buf1), 0, count1); //可以發現一個問題：Base64.encodeBase64(buf1)編碼後，體積會增加1/3，所以這里的Base64.encodeBase64(buf1)編碼轉換後的實際長度和count1並不相等，所以實際寫入到os1中的base64字元數只有Base64.encodeBase64(buf1)編碼產生的字元數的3/4
os1.flush();
}
file1.close();
System.out.println(os1.toString());

修改後：
ByteArrayOutputStream os1 = new ByteArrayOutputStream();
InputStream file1 = new FileInputStream(path);
byte[] byteBuf = new byte[1024];
byte[] base64ByteBuf;
while(file1.read(byteBuf) != -1)
{
base64ByteBuf = Base64.encodeBase64(byteBuf);
os1.write(base64ByteBuf, 0, base64ByteBuf.length);
os1.flush();
}
file1.close();
System.out.println(os1.toString());

——————————
修改後，發現分段編碼的結果發生了變化，跟之前不一樣了
但仍然不是正確的結果

原因在於，base64字元的基礎單位是(6bit*4=4位元組)，而3個常規位元組(8bit*3)才能剛好產生4個base64位元組
根本原因在於，如果進行編碼的常規位元組數不是3的倍數，最後就會餘下1或2個位元組，而這1、2個位元組編碼的結果就會產生'='字元；
使用1024作為分段編碼緩沖時，編碼的結果是3+3+3+...+1
也就是每次都會餘1位元組

而沒有使用分段編碼時，當編碼到第1024個位元組時，"餘下"的1位元組會跟後面的位元組形成連續，就不會產生'='字元
(對一段byte字元進行base64編碼時，中間是絕不會產生'='字元的，因為只有在結尾才可能餘下1或2個位元組，所以對一段byte字元進行編碼時，只有結尾才可能產生1或2個'='補全字元)

——————————
解決方法是，使用3的公倍數作為緩沖區大小

修改後：
ByteArrayOutputStream os1 = new ByteArrayOutputStream();
InputStream file1 = new FileInputStream(path);
byte[] byteBuf = new byte[3*1000];
byte[] base64ByteBuf;
while(file1.read(byteBuf) != -1)
{
base64ByteBuf = Base64.encodeBase64(byteBuf);
os1.write(base64ByteBuf, 0, base64ByteBuf.length);
os1.flush();
}
file1.close();
System.out.println(os1.toString());
測試結果再次發生了改變
中間不再有'='字元了，因為中間每次都是3位元組3位元組的編碼，沒有餘下多餘的位元組
對比之後發現，中間段的結果已經正常了

——————————
但是，發現，結尾處兩個轉碼的結果有些許不同

原因在於，假設文件A的長度為3001個位元組；
在第二次循環讀取時，只讀到1個有效位元組，而byteBuf的剩餘2999個位元組都是無效位元組，而此時編碼時，卻把多餘的2999個無效位元組也編碼了進去
(如果是非分段轉碼，就不會出現這種情況)

解決方法：
ByteArrayOutputStream os1 = new ByteArrayOutputStream();
InputStream file1 = new FileInputStream(path);
byte[] byteBuf = new byte[3*1000];
byte[] base64ByteBuf;
int count1; //每次從文件中讀取到的有效位元組數
while((count1=file1.read(byteBuf)) != -1)
{
if(count1!=byteBuf.length) //如果有效位元組數不為3*1000，則說明文件已經讀到尾了，不夠填充滿byteBuf了
{
byte[] = Arrays.Of(byteBuf, count1); //從byteBuf中截取包含有效位元組數的位元組段
base64ByteBuf = Base64.encodeBase64(); //對有效位元組段進行編碼
}
else
{
base64ByteBuf = Base64.encodeBase64(byteBuf);
}

os1.write(base64ByteBuf, 0, base64ByteBuf.length);
os1.flush();
}
file1.close();
System.out.println(os1.toString());

至此，base64分段編碼才算大功告成。大文件上傳核心代碼才算大功告成。
其實代碼改起來非常簡單，但是不知道原因不知道原理的話，是無法無中生有的
對我本人來說原本只是想隨便答一下，但沒想到答的過程中發現自己有很多坑沒有發現。答的過程中把自己不懂的地方沒有發現的坑也完善了。不說碰到一個知識點就要追根究底，但實際開發中，每一個自己能親身碰到的實際問題都是鍛煉自己的絕佳機會，這種近距離觸碰問題、解決問題的機會是難得的。雖然開發中還有很多其它問題也很重要，但你沒有親手碰到過，是無法共鳴的。所以自己在開發中碰到了問題，還是建議大概弄清原因。
弄清原理後，即使以後出現這個問題的其它"變種"，也能找到原因並自己解決，但僅僅粘貼復制無法做到這一點。

『貳』 android,Base64.encodeToString(bitmapBytes, Base64.DEFAULT);內存溢出

如果圖片過大的話，分幾次讀取圖片，每次讀取到數組後轉碼成String，轉碼完成後再拼接String，建議轉換完成的String存儲到文件中，畢竟轉碼後會比源文件到了不少，也會內存溢出吧；如果要上傳文件，每次轉碼完成發送一次，只要服務端處理好就沒有問題，文件不會出錯的。望採納。

『叄』 android 存在資料庫中的動態圖片，如何讀取出來，顯示在ImageView中

實現的功能為從伺服器獲取圖片數據，在布局頁面上顯示。由於圖片的個數是不確定的,因此採用在布局頁面中定義多個ImageView來顯示圖片是不合理的。
(一)首先定義布局

android:id="@+id/id_layout_movie"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
/>
(二)載入圖片顯示時獲取到布局文件
RelativeLayout rl_Movie = (RelativeLayout) findViewById(R.id.id_layout_movie);
(三)依次循環伺服器獲取的圖片數據，一張一張設置圖片顯示的位置
//newWidth為圖片顯示的寬度，newHeight為圖片顯示的高度
RelativeLayout.LayoutParams lp1 = new RelativeLayout.LayoutParams( newWidth, newHeight);
設置lp1.leftMargin和lp1.topMargin的值
(四)最後設置rl_Movie.addView(iv, lp1)將圖片加入布局文件中