实现拍照上传-图片压缩-base64上传网页 亲测

最新推荐文章于 2024-04-27 21:37:32 发布
最新推荐文章于 2024-04-27 21:37:32 发布
阅读量257 收藏
点赞数
分类专栏： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hejias/article/details/116644107
版权

 

魅族note6（android 7） png jpg测试正常

文件大小测试正常

0.文件大小349(kb)            通过Options获取到的图片大小width:450 height: 1920

新文件大小51(kb)            通过Options获取到的图片大小width:187 height: 800

1.文件大小3520(kb)            通过Options获取到的图片大小width:3120 height: 4208

新文件大小531(kb)            通过Options获取到的图片大小width:800 height: 1078

2. 文件大小197(kb)            通过Options获取到的图片大小width:640 height: 415

新文件大小198(kb)            通过Options获取到的图片大小width:640 height: 415

 

 

代码

package com.by.yuquan.app.webview;

import android.Manifest;
import android.app.Activity;
import android.app.Dialog;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.PixelFormat;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.provider.MediaStore;
import android.support.annotation.Nullable;
import android.support.annotation.RequiresApi;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v4.content.FileProvider;
import android.text.TextUtils;
import android.util.Log;
import android.view.Gravity;
import android.view.View;
import android.webkit.JavascriptInterface;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.Toast;

import com.bumptech.glide.Glide;
import com.by.yuquan.app.R;
import com.by.yuquan.app.base.ActivityInterface;
import com.by.yuquan.app.base.CallBackIntent;
import com.by.yuquan.app.base.baichuan.BaiChuanUtils;
import com.by.yuquan.app.base.dialog.TaoBaoQuanDaoDialog;
import com.by.yuquan.app.base.utils.Logi;
import com.by.yuquan.app.base.utils.ToastUtils;
import com.by.yuquan.app.base.zxing.android.CaptureActivity;
import com.by.yuquan.app.webview.base.JsApi;
import com.by.yuquan.app.webview.base.WebViewBaseObject1;
import com.by.yuquan.app.webview.base1.BaseWebViewActivity1;
import com.by.yuquan.app.webview.base1.CompletionHandler;
import com.by.yuquan.app.webview.base1.OnReturnValue;
import com.by.yuquan.app.webview.google.AutoTitleWebViewActiuvity;
import com.by.yuquan.app.wxapi.WXPayEntryActivity;
import com.by.yuquan.base.AppUtils;
import com.by.yuquan.base.ImageBase64;
import com.by.yuquan.base.SharedPreferencesUtils;
import com.by.yuquan.base.ZpImageUtils;
import com.tencent.smtt.sdk.WebView;

import org.json.JSONException;
import org.json.JSONObject;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigDecimal;
import java.util.ArrayList;

import static android.os.Environment.DIRECTORY_PICTURES;

public class AutoWebViewActivity1 extends BaseWebViewActivity1 implements ActivityInterface {

    //activity回调方法
    public CallBackIntent mCallBackIntent;
    private final int REQUEST_TAKE_CODE = 51;
    private final int REQ_CHOOSE = 50;
    private File mTakePhotoFile;
    private File mFileFromCamera;
    public LinearLayout topbar_layout;
    private CompletionHandler<String> albc_handler;
    private CompletionHandler<String> completeHandler;

    private static final int REQUEST_CODE_SCAN = 0x0001;
    private CompletionHandler<String> scan_handler;
    private static final String DECODED_CONTENT_KEY = "codedContent";

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        webView = findViewById(R.id.webView);
        webView.addJavascriptInterface(new AutoWebViewActivity1.InJavaScriptLocalObj(), "java_obj");
        getWindow().setFormat(PixelFormat.TRANSLUCENT);
        topbar_layout = findViewById(R.id.topbar_layout);
        int barHeight = getStateBarHeight();
        if (barHeight != 0) {
            RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, barHeight);
            topbar_layout.setLayoutParams(layoutParams);
            topbar_layout.setVisibility(View.VISIBLE);
        }
    }

    @Override
    public WebViewBaseObject1 getObjcet1() {
        return new MyWebViewBaseObject(this);
    }

    @Override
    public JsApi getObjcet2() {
        return new JsApi(this);
    }

    @Override
    public WebViewBaseObject1 getObjcet() {
        return new MyWebViewBaseObject(this);
    }


    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        switch (requestCode) {
            case 5:
                int taAuth = (Integer) SharedPreferencesUtils.get(this, "TBAUTH", 1);//0:不需要授权(已授权) 1:需要授权(未授权)
                if (taAuth == 0) {
                    albc_handler.complete("success");
                } else {
                    albc_handler.complete("fail");
                }
                break;
            case REQ_CHOOSE://选择图片回调
                try {
                    String imageStr = "";
                    if (resultCode == Activity.RESULT_OK) {
                        if (data != null) {
                            String dataString = data.getDataString();
                            if (dataString != null) {
                                Uri uri = Uri.parse(dataString);
//                                File imgFile = ZpImageUtils.compressImage(this, getRealPathFromURI(uri), 200, 200, 150);
                                //                            imageStr = ImageBase64.getImageStr(getRealPathFromURI(uri));
                                //                            results = new Uri[]{Uri.parse(dataString)};
                                File imgFile = new File(getRealPathFromURI(uri));
                                if (imgFile.getName().toLowerCase().contains(".jpg") || imgFile.getName().toLowerCase().contains(".png") || imgFile.getName().toLowerCase().contains(".jpeg") || imgFile.getName().toLowerCase().contains(".gif")) {
                                    compressImage(imgFile.getAbsolutePath(),AutoWebViewActivity1.this);
//                                    imgFile=new File(tmpPath);
//                                    imageStr = "data:image/jpeg;base64," + ImageBase64.fileToBase64(imgFile);
                                } else {
                                    com.by.yuquan.base.ToastUtils.show(AutoWebViewActivity1.this, "请选择图片");
                                    return ;
                                }

                            }
                        }
                    }
                  //  completeHandler.complete(imageStr);
                } catch (Exception e) {
                }
                break;
            case REQUEST_TAKE_CODE://拍照回调
                try {
                    String imageStr = "";
                    if (resultCode == Activity.RESULT_OK) {
                        if (mFileFromCamera != null) {
                            String filePath = mTakePhotoFile.getAbsolutePath();
                            // 压缩图片到指定大小
//                            File imgFile = ZpImageUtils.compressImage(this, filePath, 100, 100, 100);
                            File imgFile = new File(filePath);
                            Uri localUri = Uri.fromFile(imgFile);
                            Intent localIntent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, localUri);
                            this.sendBroadcast(localIntent);
                            Uri result = Uri.fromFile(imgFile);
                            if (imgFile.getName().toLowerCase().contains(".jpg") || imgFile.getName().toLowerCase().contains(".jpeg") || imgFile.getName().toLowerCase().contains(".png") || imgFile.getName().toLowerCase().contains(".gif")) {
                                compressImage(imgFile.getAbsolutePath(),AutoWebViewActivity1.this);
                            } else {
                                com.by.yuquan.base.ToastUtils.show(AutoWebViewActivity1.this, "请选择图片");
                                return ;
                            }

                        }
                    }

                } catch (Exception e) {
                }
                break;
            case REQUEST_CODE_SCAN://扫码
                if (resultCode == this.RESULT_OK) {
                    if (data != null) {
                        //返回的文本内容
                        String content = data.getStringExtra(DECODED_CONTENT_KEY);
                        //返回的BitMap图像
//                Bitmap bitmap = data.getParcelableExtra(DECODED_BITMAP_KEY);
                        if (scan_handler != null) {
                            scan_handler.complete(content);
                        }
                    }
                }
                break;
        }
    }
    long x=0;
    long y=0;
    /**
     * 压缩 图片 ，
     * @param path 绝对路径
     * @param context 对象
     * @return
     */
    private void compressImage(final String path,final Context context) {
        //500kb 最大 [由于1半]
        int maxlenth=1024*1024;
        try{
            //如果设置为空，则获取的bitmap为空,
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;//这个参数设置为true才有效，
            Bitmap bmp = BitmapFactory.decodeFile(path, options);//这里的bitmap是个空
            if (bmp == null) {//这里说明没去获取，只获取宽高参数
               // Logi.e( "通过options获取到的bitmap为空 ===");
            }

           // double g= 12.35; BigDecimal bigG=new BigDecimal(g).setScale(1, BigDecimal.ROUND_HALF_UP); //期望得到12.4

            int outHeight = options.outHeight;
            int outWidth = options.outWidth;
//          换算逻辑
//          1mb=1024*1024 byte
            long len=new File(path).length();
            Logi.i( path+" 文件大小"+len/1024+"(kb)            通过Options获取到的图片大小" + "width:" + outWidth + " height: " + outHeight);
            //如果宽大于800 按800算
            final int totalMax=800;
            if(outWidth>=totalMax){
                x=totalMax;
                y=outHeight*x/(outWidth);
            }else if(outHeight>=totalMax){
                y=totalMax;
                x=outWidth*y/(outHeight);
            }else{
                //原来尺寸
                x=outWidth;
               y=outHeight;
            }

//
//            //.divide(new BigDecimal(len)); 会Non-terminating decimal expansion; no exact representable decimal result。 所以必须要 具体多少小数点
//            BigDecimal tmp=(new BigDecimal(outWidth*maxlenth)).divide(new BigDecimal(len),2,BigDecimal.ROUND_HALF_UP);
//             x=tmp.intValue();
//            tmp=(new BigDecimal(outHeight*maxlenth)).divide(new BigDecimal(len),2,BigDecimal.ROUND_HALF_UP);
//             y=tmp.intValue();
             //防止文件少于500k 就不压缩了
//            if(maxlenth>=len){
//                x=outWidth;
//                y=outHeight;
//            }
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try{
                        Bitmap bitmap = Glide.with(context)
                                .asBitmap()
                                .load(path)
                                .submit(Integer.parseInt(""+x),Integer.parseInt(""+y))
                                .get();



                        Bitmap.CompressFormat format=Bitmap.CompressFormat.PNG;
                        String ext=""+System.currentTimeMillis();
                        ext=ext.substring(ext.length()-3);//之所以要加个字符串 因为有时候bitmap.recycle()然后用户又同时上传
                        String stringImage=ext+".hash";//这里本来.jpg要跟文件一样 奈何小米android 10 删除图片会显示提示
                        //选同一张图片 连续选
                        if(path.toLowerCase().endsWith(".jpg")){
//                            stringImage=".jpg";
                            format=Bitmap.CompressFormat.JPEG;
                        }

                        final String tmpPath=path+""+stringImage;
                        FileOutputStream out = new FileOutputStream(tmpPath+"");

                        bitmap.compress(format, 100, out);
                        out.flush();
                        out.close();
                        bitmap.recycle();

                        Logi.i( tmpPath+""+"新文件大小"+new File(tmpPath+"").length()/1024+"(kb)            通过Options获取到的图片大小" + "width:" + x + " height: " + y);
                        Activity activity= (Activity) context;
                        activity.runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                try{
                                    File imgFile=new File(tmpPath);
                                    String imageStr = "data:image/jpeg;base64," + ImageBase64.getImageStr(imgFile.getAbsolutePath());
                                    completeHandler.complete(imageStr);
                                    new File(tmpPath).delete();
                                }catch (Exception e){
                                    Logi.e(e);
                                }

                            }
                        });
                    }catch (Exception e){
                        Logi.e(e);
                    }
                }
            }).start();

        }catch (Exception e){
            Logi.e(e);
        }


}
//    private Bitmap compressImage(Bitmap image) {
//
//        ByteArrayOutputStream baos = new ByteArrayOutputStream();
//        image.compress(Bitmap.CompressFormat.JPEG, 100, baos);//质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
//        int options = 100;
//        while ( baos.toByteArray().length / 1024>100) { //循环判断如果压缩后图片是否大于100kb,大于继续压缩
//            baos.reset();//重置baos即清空baos
//            image.compress(Bitmap.CompressFormat.JPEG, options, baos);//这里压缩options%，把压缩后的数据存放到baos中
//            options -= 10;//每次都减少10
//        }
//        ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());//把压缩后的数据baos存放到ByteArrayInputStream中
//        Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);//把ByteArrayInputStream数据生成图片
//        return bitmap;
//    }

    protected void onRestart() {
        super.onRestart();
        if (mBaseObject.payCallBack != null && WXPayEntryActivity.ERRCORD != -10) {
            if (WXPayEntryActivity.ERRCORD == 0) {
                mBaseObject.payCallBack.complete("0");
            } else {
                mBaseObject.payCallBack.complete("-1");
            }
            WXPayEntryActivity.ERRCORD = -10;
        }
    }

    @Override
    public void success() {
        try {
            //避免A标签不能点击跳转问题
            String touchFromA = "var href=document.getElementsByTagName('a');" +
                    "for(var i=0;i<href.length;i++){\n" +
                    " if(href[i].href=='' || href[i].href=='null' || href[i].href=='javascript:;' || href[i].href=='javascript:'){continue;}" +
                    "href[i].onclick=function()" +
                    "{" +
                    "window.location.href=this.getAttribute(\"href\");" +
                    "}" +
                    "};";
            webView.loadUrl("javascript:" + touchFromA + "");
            if (!TextUtils.isEmpty(injection_js)) {
                webView.loadUrl("javascript:" + injection_js + "");
            }
            webView.callHandler("deviceType", new Object[]{"android"}, new OnReturnValue<Integer>() {
                @Override
                public void onValue(Integer retValue) {

                }
            });
            //--------------
//            webView.loadUrl("javascript:window.java_obj.getSource('<head>'+" +
//                    "document.getElementsByTagName('html')[0].innerHTML+'</head>');");
        } catch (Exception e) {
        }

        try {
            webView.callHandler("getVersion", new Object[]{AppUtils.getVerName(this)}, new OnReturnValue<Integer>() {
                @Override
                public void onValue(Integer retValue) {

                }
            });
        } catch (Exception e) {
        }
    }


    @Override
    public int initInflater() {
        return R.layout.basewebviewactivity_layout1;
    }

    @Override
    public void onClick(View v) {

    }

    @Override
    public void setIsFullScreen(boolean isFullScreen) {
        if (isFullScreen) {
            topbar_layout.setVisibility(View.GONE);
        }
    }

    @Override
    public void startActivityForResultInf(Intent intent, CallBackIntent callBackIntent) {
        this.mCallBackIntent = callBackIntent;
        startActivityForResult(intent, REQUEST_TAKE_CODE);
    }

    class MyWebViewBaseObject extends WebViewBaseObject1 {
        String oauth_url = "";

        public MyWebViewBaseObject(Context context) {
            super(context);
        }

        private TaoBaoQuanDaoDialog taoBaoQuanDaoDialog;

        /**
         * 阿里百川授权
         */
        @JavascriptInterface
        public void albcAuth(Object params, CompletionHandler<String> handler) {
            albc_handler = handler;
            if (taoBaoQuanDaoDialog == null) {
                taoBaoQuanDaoDialog = new TaoBaoQuanDaoDialog(AutoWebViewActivity1.this, R.style.dialog, "由于淘宝需要对渠道加强精细化管理，邀请您进行淘宝身份认证操作，届时没有进行身份认证得，将可能无法分享推广淘宝商品功能，请您提前认证。", new TaoBaoQuanDaoDialog.OnCloseListener() {
                    @Override
                    public void onClick(Dialog dialog, boolean confirm) {
                        try {
                            oauth_url = ((JSONObject) params).getString("url");
                        } catch (JSONException e) {
                            e.printStackTrace();
                        }
                        if (TextUtils.isEmpty(oauth_url)) {
                            albc_handler.complete("fail");
                            return;
                        }
                        if (confirm) {//开始认证
                            BaiChuanUtils.getInstance(AutoWebViewActivity1.this).auth(oauth_url);
                        }
                    }
                }).setTitle("淘宝渠道认证");
            }
            if (!taoBaoQuanDaoDialog.isShowing()) {
                taoBaoQuanDaoDialog.show();
            }
        }

        /**
         * 相册选择图片
         */
        @JavascriptInterface
        public void getPicture(Object params, CompletionHandler<String> handler) {
            completeHandler = handler;
            selectImage();
        }

        /**
         * 拍图片
         *
         * @param params
         */
        @JavascriptInterface
        public void getCamera(Object params, CompletionHandler<String> handler) {
            completeHandler = handler;
            takeCameraPhoto();
        }


        @JavascriptInterface
        public void FNScanner(Object parms, CompletionHandler<String> handler) {
            if (ContextCompat.checkSelfPermission(AutoWebViewActivity1.this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
                ActivityCompat.requestPermissions(AutoWebViewActivity1.this, new String[]{Manifest.permission.CAMERA}, 1);
            } else {
                scan_handler = handler;
                Intent intent = new Intent(AutoWebViewActivity1.this, CaptureActivity.class);
                startActivityForResult(intent, REQUEST_CODE_SCAN);
            }
        }
    }

    /**
     * 选择照片
     */
    private void selectImage() {
        Intent intent;
        if (Build.VERSION.SDK_INT < 19) {
            intent = new Intent(Intent.ACTION_GET_CONTENT);
            intent.setType("image/*");
            startActivityForResult(intent, REQ_CHOOSE);
        } else {
            intent = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
            Intent wrapperIntent = Intent.createChooser(intent, null);
            startActivityForResult(wrapperIntent, REQ_CHOOSE);
        }
    }

    /**
     * 拍照方案1
     */
    public void takeCameraPhoto() {
        if (!getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA_ANY)) {
            ToastUtils.showCenter(this, "设备无摄像头");
            return;
        }

        String filePath = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM).getAbsolutePath();

        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        mFileFromCamera = new File(filePath, System.nanoTime() + ".jpg");
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
            intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(mTakePhotoFile));
            startActivityForResult(intent, REQUEST_TAKE_CODE);
        } else {
            try {
                mTakePhotoFile = File.createTempFile("Zp" + System.nanoTime(), ".jpg", new File(filePath));
                Uri contentUri = FileProvider.getUriForFile(this,
                        getPackageName() + ".fileProvider", mTakePhotoFile);
                intent.putExtra(MediaStore.EXTRA_OUTPUT, contentUri);
                intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION
                        | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
                startActivityForResult(intent, REQUEST_TAKE_CODE);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 拍照方案2
     */
    public void takePic() {
        try {
            String state = Environment.getExternalStorageState();
            if (state.equals(Environment.MEDIA_MOUNTED)) {
                Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                File mFile = new File(Environment.getExternalStoragePublicDirectory(DIRECTORY_PICTURES), "temp.jpg");
                ///storage/emulated/0/Pictures/temp.jpg
                Uri mImageUri = Uri.fromFile(mFile);
                if (Build.VERSION.SDK_INT > Build.VERSION_CODES.N) {
                    //content://com.example.shinelon.takephotodemo.provider/camera_photos/Pictures/temp.jpg
                    mImageUri = FileProvider.getUriForFile(this, getPackageName() + ".fileProvider", mFile);
                }
                //指定照片保存路径（SD卡），temp.jpg为一个临时文件，每次拍照后这个图片都会被替换
                cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, mImageUri);
                cameraIntent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
                startActivityForResult(cameraIntent, REQUEST_TAKE_CODE);
            } else {
                ToastUtils.showCenter(this, "请确认已经插入SD卡");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 根据uri获取真实路径
     *
     * @param contentUri
     * @return
     */
    public String getRealPathFromURI(Uri contentUri) {
        String res = null;
        String[] proj = {MediaStore.Images.Media.DATA};
        Cursor cursor = getContentResolver().query(contentUri, proj, null, null, null);
        if (cursor.moveToFirst()) {
            int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
            res = cursor.getString(column_index);
        }
        cursor.close();
        return res;
    }


    final class InJavaScriptLocalObj {
        @JavascriptInterface
        public void getSource(String html) {
            Log.d("html=", html);
        }
    }
}

 

jiaxi的天空
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android图片的Base64编码与解码及解码Base64图片方法
08-28
Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法。接下来通过本文给大家分享Android图片的Base64编码与解码及解码Base64图片，需要的朋友参考下吧
base64图片压缩上传
lzc255的博客
11-03 1113
图片上传
Android图片压缩、Drawable和Bitmap转换、bitmap和base64转换
最新发布
qq_36158551的博客
04-27 1078
1. Android图片压缩、Drawable和Bitmap转换、bitmap和base64转换 1.1. Drawable和Bitmap之间的转化 1.1.1. bitmap和Drawable间的区别   Bitmap - 称作位图，一般位图的文件格式后缀为bmp，当然编码器也有很多如RGB565、RGB888。作为一种逐像素的显示对象执行效率高，但是缺点也很明显存储效率低。我们理解为一种存储对象比较好。 Drawable - 作为Android平下通用的图形对象，它可以装载常用格式的图像，比如GIF、P
重要: 千万不要使用Base64存储大图片
木目木的博客
08-27 4640
在使用wangeditor的时候，看到了一个参数，可以指定上传图片为base64。咋一看，这次挺方便，还在为自己可以少写一个上传接口而庆幸时，悲剧来了。 前端调试各种加载缓慢，超过5~6秒都没有数据，在小程序上还出现了完全没数据显示的状态。经过调试，发现接口请求很快出数据了。但是前端渲染加载出事了…… 上网看了一些其他人的介绍，最后找到了问题所在。base64相当于把图片转文本了，一张超过1M的图，文本长度就超过了一些论文的长度，这还是加载给一张图片，问题太严重。 最后只能改成普通的上传当时，看来道路上真
利用图片与Base64互转，实现图片的上传下载
weixin_47366305的博客
06-14 2617
提示：前端进行文件图片的转码可减小后端处理的压力，推荐此方式。代码如下（示例）： 2.2.2.前端console日志 前端进行图片的Base64转码，传入后端，后端用String接收 入库即可。 2.1、库表 2.1.1、建表语句 2.1.2、ER图 2.2.2、controller 2.2.3、Base64工具类（需自取） 2.2.4、Http测试(http文件) 2.2.5、控制台输出......
TinyMCE富文本编辑器，实现粘贴进来的Base64图片自动上传、图片压缩上传
m0_60312580的博客
07-17 1913
TinyMCE富文本编辑器，实现粘贴进来的Base64图片自动上传、图片压缩上传
android base64 大图片上传,Base64实现android端图片上传到服务器端
weixin_32376927的博客
05-28 192
将代码拷贝到工程中。然后上代码：android端代码：private void setPicToView(Intent picdata) {Bundle extras = picdata.getExtras();if (extras != null) {mBitmap = extras.getParcelable("data");view_images.setImageBitmap(mBitmap...
h5上传图片压缩并且转为base64并且上传阿里云（对ios相机拍照旋转90度处理）
07-22
上传图片压缩并且转为base64并且上传阿里云（对ios相机拍照旋转90度处理）
vue2实现移动端上传、预览、压缩图片解决拍照旋转问题
08-30
4. 图片压缩：对于较大的图片，使用Canvas进行尺寸压缩，降低图片大小。 5. 图片上传：处理完成后，将图片数据发送到后台。 在实际开发中，还需要考虑其他因素，例如错误处理、进度显示、多图上传等，以提供更好的...
js+html5拍照压缩图片上传.rar_Base64 js插件_html5图片上传_js 拍照_js 拍照证件_js拍照上传
09-20
插件说明 1、利用html5 input file 上传图片，获取的图片为base64位图片流 2、将图片流利用画布原理将原图片缩小成小图 3、用ajax将图片流上传到后台接收
HTML5 和小程序实现拍照图片旋转、压缩和上传功能
09-22
在H5中，可以使用Canvas API的`toDataURL()`方法将图片转换为Base64编码，然后通过调整`toDataURL()`方法的第二个参数（质量系数）来实现压缩。在小程序中，可以使用`wx.getImageInfo()`获取图片信息，再用`wx....
移动端利用H5实现压缩图片上传功能
08-31
在移动端开发中，为了优化用户体验和减少网络传输的数据量，H5提供了图片压缩上传的功能。本文将详细介绍如何利用H5的API实现这一功能，主要包括Filereader、Canvas和FormData这三个核心组件。 首先，用户通过input...
python上传大图时以base64形式导致参数过长，后端迟迟接收不到请求
neverstopforcode的博客
11-01 4316
上传大图这个问题，断断续续困扰了一个月今天终于解决了！！撒花~ 下图里base64_data是经过转换的，类型是str f = open(origin_path, 'rb') base64_data = base64.b64encode(f.read()).decode('utf-8') name就是图片的名称,这个图是之前的写法。 以上这种方式对于1M左右的小图可以正常操作，但稍大...
Base64位图片过大导致上传到后台值为Null的解决方式
流水的风的博客
03-11 2377
server: tomcat: max-http-post-size: 104857600//100M 把最大的上传参数的大小改为100M，因为本来的上传参数的默认大小就是2M，所以当你超过2M的时候，后台接收到的参数就可能是null，具体可以看下源码，这里只是对遇到的这个问题做个记录。 ...
解决webSocket中传输base64图片过大时的过慢问题
pgLi
10-14 9563
1、背景 公司项目有个需求，将发生的事件使用webSocket推送到前端（包括一张高清图），要求1秒之内在web上显示，且不能失真。 方案1：首先是将图片转换成base64，作为字符串推送给前端，但是推送过来的信息量太大，导致接收信息延时。 方案2：改为推送文件路径，但是web请求图片会有0.6-0.7毫秒的时间，一旦推送过多，会更慢，且web加载图片时会有短暂的闪烁。 2、解决方案 ...
Base64图片上传
chenqinghu98的博客
08-04 799
Base64上传文件前端写法
直播电商平台开发，实现图片压缩上传（base64格式）
云豹网络科技
11-04 222
但在实际开发中，用户上传的图片有可能很大，上传时间就会变长，这样就会影响用户体验，这个时候就需要我们对图片进行压缩。创建canvas，注意canvas标签中对于id的定义（刚开始尝试了2d写法，在画图片时候失败了）以上就是直播电商平台开发，实现图片压缩上传（base64格式）， 更多内容欢迎关注之后的文章。直播电商平台开发，实现图片压缩上传（base64格式）导出canvas画出的图片资源url；2.将图片转换为base64格式；将缩放后的图片画到canvas上；取得图片的原始尺寸；
Android中的图片如何转换成Base64格式
金戈鐡馬
02-24 3860
Android手机客户端的图片数据上传到服务器中保存，首先需要将客户端的图片转换成Base64格式，然后才能通过网络上传到服务器中。
Android中Bitmap(图片)和Base64互相转换
ocean__yang的博客
02-07 7644
Bitmap和Base64的相互转换-用于节省服务器存储
js实现压缩base64图片压缩并上传
05-25
以下是一个示例代码，使用canvas将图片压缩为指定大小，然后将压缩后的base64字符串上传到服务器。 HTML代码： ```html <input type="file" id="file-input"> ``` JavaScript代码： ```javascript // 获取文件...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值