android图片base64解码
❶ Android base64string转bitmap
"data:image/jpeg;base64,/9j/4........H/k/wD/2Q==" 是后台传的图片资源，安卓的
/**
* base64转为bitmap
*
* @param base64Data
* @return
*/
public static Bitmap base64ToBitmap(String base64Data) {
byte[] bytes = android.util.Base64.decode(base64Data, android.util.Base64.DEFAULT);
return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
}
方法转图片的时候需要去掉头部的“data:image/jpeg;base64,”再调用这个方法，网上的在线base64转图片就可以不去掉这个头部也能成功。
head_iv.setImageBitmap(Tools.base64ToBitmap(img.split(",")[1]));
❷ Android 将图片转成base64,小图片可以正常转换,当遇到大图片是拿到的字符串是null
因为太大了，一般超过2M就不要用这种方式直接存储处理图片，建议使用缩略图。
❸ java的base64在安卓解码不了，怎么回事
估计是代码的问题，示例如下：
Android端：编码：
String oneBaseEncoder = Base64.encode(msg.getBytes());
解码：
String oneBaseDecoder = new String(Base64.decode(msg));
JAVA WEB端：编码：
String oneBaseEncoder = new BASE64Encoder().encode(jsonString.getBytes("utf-8"));
解码：
String oneBaseDecoder = new String(new BASE64Decoder().decodeBuffer(jsonString));
❹ android,Base64.encodeToString(bitmapBytes, Base64.DEFAULT);内存溢出
如果图片过大的话，分几次读取图片，每次读取到数组后转码成String，转码完成后再拼接String，建议转换完成的String存储到文件中，毕竟转码后会比源文件到了不少，也会内存溢出吧；如果要上传文件，每次转码完成发送一次，只要服务端处理好就没有问题，文件不会出错的。望采纳。
❺ android Base64.decode 报错
android 解码 Base64 图片数据时报错
data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAkACQAAD/AxNDQ0Hyc5PTgyPC4zNDL/IyMjIyMjIyMjIyMjIyMjL/wAARCAK2AyADASIAAhEBAxEB//8
Base64.decode(data, Base64.DEFAULT)
经过测试把开头的 data:image/jpeg;base64, 去掉就好了
❻ 如何在Android用FFmpeg解码图像
CC libavcodec/log2_tab.o
CC libavutil/log2_tab.o
CC libswresample/log2_tab.o
AR libavcodec/libavcodec.a
LD libavutil/libavutil.so.52
AR libavutil/libavutil.a
AR libswresample/libswresample.a
LD libavcodec/libavcodec.so.55
LD libswresample/libswresample.so.0
LD libswscale/libswscale.so.2
LD libavformat/libavformat.so.55
INSTALL libavformat/libavformat.a
INSTALL libavformat/libavformat.so
STRIP install-libavformat-shared
INSTALL libavcodec/libavcodec.a
INSTALL libavcodec/libavcodec.so
STRIP install-libavcodec-shared
INSTALL libswresample/libswresample.a
INSTALL libswresample/libswresample.so
STRIP install-libswresample-shared
INSTALL libswscale/libswscale.a
INSTALL libswscale/libswscale.so
STRIP install-libswscale-shared
INSTALL libavutil/libavutil.a
INSTALL libavutil/libavutil.so
STRIP install-libavutil-shared
INSTALL libavformat/avformat.h
INSTALL libavformat/avio.h
INSTALL libavformat/version.h
INSTALL libavformat/libavformat.pc
INSTALL libavcodec/avcodec.h
INSTALL libavcodec/avfft.h
INSTALL libavcodec/dxva2.h
INSTALL libavcodec/old_codec_ids.h
INSTALL libavcodec/vaapi.h
INSTALL libavcodec/vda.h
INSTALL libavcodec/vdpau.h
INSTALL libavcodec/version.h
INSTALL libavcodec/xvmc.h
INSTALL libavcodec/libavcodec.pc
INSTALL libswresample/swresample.h
INSTALL libswresample/version.h
INSTALL libswresample/libswresample.pc
INSTALL libswscale/swscale.h
INSTALL libswscale/version.h
INSTALL libswscale/libswscale.pc
INSTALL libavutil/adler32.h
INSTALL libavutil/aes.h
INSTALL libavutil/attributes.h
INSTALL libavutil/audio_fifo.h
INSTALL libavutil/audioconvert.h
INSTALL libavutil/avassert.h
INSTALL libavutil/avstring.h
INSTALL libavutil/avutil.h
INSTALL libavutil/base64.h
INSTALL libavutil/blowfish.h
INSTALL libavutil/bprint.h
INSTALL libavutil/bswap.h
INSTALL libavutil/buffer.h
INSTALL libavutil/channel_layout.h
INSTALL libavutil/common.h
INSTALL libavutil/cpu.h
INSTALL libavutil/crc.h
INSTALL libavutil/error.h
INSTALL libavutil/eval.h
INSTALL libavutil/fifo.h
INSTALL libavutil/file.h
INSTALL libavutil/frame.h
INSTALL libavutil/hmac.h
INSTALL libavutil/imgutils.h
INSTALL libavutil/intfloat.h
INSTALL libavutil/intfloat_readwrite.h
INSTALL libavutil/intreadwrite.h
INSTALL libavutil/lfg.h
INSTALL libavutil/log.h
INSTALL libavutil/mathematics.h
INSTALL libavutil/md5.h
INSTALL libavutil/mem.h
INSTALL libavutil/murmur3.h
INSTALL libavutil/dict.h
INSTALL libavutil/old_pix_fmts.h
INSTALL libavutil/opt.h
INSTALL libavutil/parseutils.h
INSTALL libavutil/pixdesc.h
INSTALL libavutil/pixfmt.h
INSTALL libavutil/random_seed.h
INSTALL libavutil/rational.h
INSTALL libavutil/ripemd.h
INSTALL libavutil/samplefmt.h
INSTALL libavutil/sha.h
INSTALL libavutil/sha512.h
INSTALL libavutil/time.h
INSTALL libavutil/timecode.h
INSTALL libavutil/timestamp.h
INSTALL libavutil/version.h
INSTALL libavutil/xtea.h
INSTALL libavutil/lzo.h
INSTALL libavutil/avconfig.h
INSTALL libavutil/libavutil.pc
link ffmpeg.
二、新建一个Android工程，在工程目录下新建一个jni文件夹，在文件夹下新建一个ffmpeg文件夹，用来放ffmpeg相关的头文件。在ffmpeg文件夹下新建Android.mk文件用来预先加载ffmpeg动态库。Android.mk文件内容如下：
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := ffmpeg
LOCAL_SRC_FILES := /path/to/build/output/libffmpeg.so
include $(PREBUILT_SHARED_LIBRARY)
三、在jni下新建Android.mk文件和Application.mk两个文件用来指定编译的顺序和编译的平台以及对应的cpu指令集。
Application.mk
APP_ABI := armeabi
APP_PLATFORM := android-9
Android.mk
include $(call all-subdir-makefiles)
四、编写JNI文件，用来绑定java文件与.c文件的交互，文件内容如下：
/*
* ffmpeg_jni.c
*
* Created on: Sep 1, 2014
* Author: clarck
*/
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <jni.h>
#include "../include/ffmpeg_logger.h"
#include "../include/ffmpeg.h"
// 指定要注册的类，对应完整的java类名
#define JNIREG_CLASS "com/clarck/android/ffmpeg/MainActivity"
JNIEXPORT void JNICALL native_setDataSource(JNIEnv *env, jclass classzz, jstring path) {
char *filepath = ffmpeg_jstringTostr(env, path);
ffmpeg_setDataSource(filepath);
}
//Java和JNI函数的绑定
static JNINativeMethod method_table[] = {
{ "setDataSource", "(Ljava/lang/String;)V", native_setDataSource }
};
//注册native方法到java中
static int registerNativeMethods(JNIEnv *env, const char *className,
JNINativeMethod *gMethods, int numMethods) {
jclass clazz;
clazz = (*env)->FindClass(env, className);
if (clazz == NULL) {
return JNI_FALSE;
}
if ((*env)->RegisterNatives(env, clazz, gMethods, numMethods) < 0) {
return JNI_FALSE;
}
return JNI_TRUE;
}
//调用注册方法
int register_ndk_load(JNIEnv *env) {
return registerNativeMethods(env, JNIREG_CLASS, method_table,
(int) (sizeof(method_table) / sizeof(method_table[0])));
}
JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved) {
JNIEnv *env = NULL;
jint result = -1;
if ((*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_6) != JNI_OK) {
return result;
}
register_ndk_load(env);
//返回JNI的版本
return JNI_VERSION_1_6;
}
五、编写ffmpeg调用函数，内容如下：
/*
* ffmpeg.c
*
* Created on: Sep 1, 2014
* Author: clarck
*/
#include <jni.h>
#include <android/native_window_jni.h>
#include "../include/ffmpeg.h"
#include "../include/ffmpeg_logger.h"
#include "../ffmpeg/include/libavcodec/avcodec.h"
#include "../ffmpeg/include/libavformat/avformat.h"
#include "../ffmpeg/include/libavutil/pixfmt.h"
#include "../ffmpeg/include/libswscale/swscale.h"
char* ffmpeg_jstringTostr(JNIEnv* env, jstring jstr) {
char* pStr = NULL;
jclass jstrObj = (*env)->FindClass(env, "java/lang/String");
jstring encode = (*env)->NewStringUTF(env, "utf-8");
jmethodID methodId = (*env)->GetMethodID(env, jstrObj, "getBytes",
"(Ljava/lang/String;)[B");
jbyteArray byteArray = (jbyteArray) (*env)->CallObjectMethod(env, jstr,
methodId, encode);
jsize strLen = (*env)->GetArrayLength(env, byteArray);
jbyte *jBuf = (*env)->GetByteArrayElements(env, byteArray, JNI_FALSE);
if (jBuf > 0) {
pStr = (char*) malloc(strLen + 1);
if (!pStr) {
return NULL ;
}
memcpy(pStr, jBuf, strLen);
pStr[strLen] = 0;
}
(*env)->ReleaseByteArrayElements(env, byteArray, jBuf, 0);
return pStr;
}
void ffmpeg_setDataSource(char *file_path) {
LOGI("ffmpeg_setDataSource:%s", file_path);
AVFormatContext *pFormatCtx;
AVCodecContext *pCodecCtx;
AVCodec *pCodec;
AVFrame *pFrame, *pFrameYUV;
AVPacket *packet;
uint8_t *out_buffer;
static struct SwsContext *img_convert_ctx;
int videoStream, i, numBytes;
int ret, got_picture;
av_register_all();
pFormatCtx = avformat_alloc_context();
if (avformat_open_input(&pFormatCtx, file_path, NULL, NULL) != 0) {
LOGE("can‘t open the file. \n");
return;
}
if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
LOGE("Could‘t find stream infomation.\n");
return;
}
videoStream = 1;
for (i = 0; i < pFormatCtx->nb_streams; i++) {
if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
videoStream = i;
}
}
if (videoStream == -1) {
LOGE("Didn‘t find a video stream.\n");
return;
}
pCodecCtx = pFormatCtx->streams[videoStream]->codec;
pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
if (pCodec == NULL) {
LOGE("Codec not found.\n");
return;
}
if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
LOGE("Could not open codec.\n");
return;
}
pFrame = av_frame_alloc();
pFrameYUV = av_frame_alloc();
numBytes = avpicture_get_size(AV_PIX_FMT_YUV420P, pCodecCtx->width,
pCodecCtx->height);
out_buffer = (uint8_t *) av_malloc(numBytes * sizeof(uint8_t));
avpicture_fill((AVPicture *) pFrameYUV, out_buffer, AV_PIX_FMT_YUV420P,
pCodecCtx->width, pCodecCtx->height);
int y_size = pCodecCtx->width * pCodecCtx->height;
packet = (AVPacket *) malloc(sizeof(AVPacket));
av_new_packet(packet, y_size);
av_mp_format(pFormatCtx, 0, file_path, 0);
while (av_read_frame(pFormatCtx, packet) >= 0) {
if (packet->stream_index == videoStream) {
ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture,
packet);
LOGI("avcodec_decode_video2 ret:%d", ret);
if (ret < 0) {
LOGE("decode error.\n");
return;
}
if (got_picture) {
//TODO 此处可以将解码出来的图片保存起来。
}
}
av_free_packet(packet);
}
av_free(out_buffer);
av_free(pFrameYUV);
avcodec_close(pCodecCtx);
avformat_close_input(&pFormatCtx);
}
六、编写Android.mk用来编译相关的.c文件，内容如下：
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
FFMPEG_PATH := ../ffmpeg
LOCAL_C_INCLUDES := $(LOCAL_PATH)/$(FFMPEG_PATH)/include
LOCAL_MODULE := ffmpeg_player
LOCAL_SRC_FILES += ffmpeg_jni.c
LOCAL_SRC_FILES += ffmpeg.c
LOCAL_SHARED_LIBRARIES := ffmpeg
LOCAL_LDLIBS := -llog
include $(BUILD_SHARED_LIBRARY)
七、编写java文件中相关执行调用方法
package com.clarck.android.ffmpeg;
import android.app.Activity;
import android.os.Bundle;
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
setDataSource("/sdcard/a.mp4");
}
public native void setDataSource(String path);
static {
System.loadLibrary("ffmpeg");
System.loadLibrary("ffmpeg_player");
}
}
❼ 手机端用android.util.Base64编码，服务端我该导入哪个包解码
Base 64是通用算法 所有语言的算法都是一样的, 服务端可以用这个包, jar包已经上传直接导入即可使用. javabase64-1.3.1.jar大小：4.26K所需财富值：5 已经过网络安全检测,放心下载 点击下载下载量:19
❽ Android 根据文件路径base64字符串和文件互相转换
android 本地存文件,通过base64转码文件存储到本地
2.Base64字符串转文件
先通过BASE64Decoder 将base64字符串解码转为字节数组,在通过字节流将字节数组写入文件中,通过bytes.length 属性可查看base64字符串转字节是否有缺失,比对文件大小查看是否一样
3.将文件转为Base64字符串
这个没什么可说的,跟上面的流程相反,通过字节流读文件,然后将读出的字节数组通过BASE64Encoder 编码
❾ 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，java 通用的加密解密方式有几种
移动端越来越火了，我们在开发过程中，总会碰到要和移动端打交道的场景，比如.NET和android或者iOS的打交道。为了让数据交互更安全，我们需要对数据进行加密传输。今天研究了一下，把几种语言的加密都实践了一遍，实现了.NET，java(android)，iOS都同一套的加密算法，下面就分享给大家。
AES加密有多种算法模式，下面提供两套模式的可用源码。
加密方式：
先将文本AES加密
返回Base64转码
解密方式：
将数据进行Base64解码
进行AES解密
一、CBC（Cipher Block Chaining，加密块链）模式
是一种循环模式，前一个分组的密文和当前分组的明文异或操作后再加密，这样做的目的是增强破解难度.
密钥
密钥偏移量
java/adroid加密AESOperator类：
package com.bci.wx.base.util;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
/**
* AES 是一种可逆加密算法，对用户的敏感信息加密处理 对原始数据进行AES加密后，在进行Base64编码转化；
*/
public class AESOperator {
/*
* 加密用的Key 可以用26个字母和数字组成 此处使用AES-128-CBC加密模式，key需要为16位。
*/
private String sKey = "smkldospdosldaaa";//key，可自行修改
private String ivParameter = "0392039203920300";//偏移量,可自行修改
private static AESOperator instance = null;
private AESOperator() {
}
public static AESOperator getInstance() {
if (instance == null)
instance = new AESOperator();
return instance;
}
public static String Encrypt(String encData ,String secretKey,String vector) throws Exception {
if(secretKey == null) {
return null;
}
if(secretKey.length() != 16) {
return null;
}
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
byte[] raw = secretKey.getBytes();
SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
IvParameterSpec iv = new IvParameterSpec(vector.getBytes());// 使用CBC模式，需要一个向量iv，可增加加密算法的强度
cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
byte[] encrypted = cipher.doFinal(encData.getBytes("utf-8"));
return new BASE64Encoder().encode(encrypted);// 此处使用BASE64做转码。
}
// 加密
public String encrypt(String sSrc) throws Exception {
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
byte[] raw = sKey.getBytes();
SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
IvParameterSpec iv = new IvParameterSpec(ivParameter.getBytes());// 使用CBC模式，需要一个向量iv，可增加加密算法的强度
cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
byte[] encrypted = cipher.doFinal(sSrc.getBytes("utf-8"));
return new BASE64Encoder().encode(encrypted);// 此处使用BASE64做转码。
}
// 解密
public String decrypt(String sSrc) throws Exception {
try {
byte[] raw = sKey.getBytes("ASCII");
SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
IvParameterSpec iv = new IvParameterSpec(ivParameter.getBytes());
cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
byte[] encrypted1 = new BASE64Decoder().decodeBuffer(sSrc);// 先用base64解密
byte[] original = cipher.doFinal(encrypted1);
String originalString = new String(original, "utf-8");
return originalString;
} catch (Exception ex) {
return null;
}
}
public String decrypt(String sSrc,String key,String ivs) throws Exception {
try {
byte[] raw = key.getBytes("ASCII");
SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
IvParameterSpec iv = new IvParameterSpec(ivs.getBytes());
cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
byte[] encrypted1 = new BASE64Decoder().decodeBuffer(sSrc);// 先用base64解密
byte[] original = cipher.doFinal(encrypted1);
String originalString = new String(original, "utf-8");
return originalString;
} catch (Exception ex) {
return null;
}
}
public static String encodeBytes(byte[] bytes) {
StringBuffer strBuf = new StringBuffer();
for (int i = 0; i < bytes.length; i++) {
strBuf.append((char) (((bytes[i] >> 4) & 0xF) + ((int) 'a')));
strBuf.append((char) (((bytes[i]) & 0xF) + ((int) 'a')));
}
return strBuf.toString();
}