精华内容
下载资源
问答
  • oss上传图片

    2018-05-22 17:29:53
    在开发APP软件中,boss突然提出想在软件中添加一个多张照片上传的功能,作为菜鸟的我,琢磨了两天,才弄出来,今天特地贴出来。本篇博客主要介绍的是将本地图片上传到服务器的方法技巧。主要技术点是: 一、运用第...

    在开发APP软件中,boss突然提出想在软件中添加一个多张照片上传的功能,作为菜鸟的我,琢磨了两天,才弄出来,今天特地贴出来。本篇博客主要介绍的是将本地图片上传到服务器的方法技巧。主要技术点是: 
    一、运用第三方可以从相册中选取多张图片。 
    二、将图片进行压缩处理。 
    三、上传到阿里云OSS。

    技术相对简单,主要是将这些技术结合起来的例子并不多,而且阿里云OSS的资料也不是很丰富,开发文档也是很简略,因此趁此机会将我的思路共享出来。

    PS:请先配置好应用权限。另外,这是公司项目的一个功能,有些地方只好删除,可能看着不是很完整,有时间我再自己做个Demo共享一下。

    一、图片选择

    android机型几乎每个品牌都有自己的相册,因此为了兼容性,自定义一个图库是比较好的办法,而且这次开发要求选取多张图片,使用自定义的开来也是最佳方案,当然为了开发的简便性,我直接使用的第三方,如果需要自定义的,可以参考下鸿洋大神的博客。 
    Android 超高仿微信图片选择器 图片该这么加载 
    不过目前,支持多图选择的第三方控件也是挺多的,比如MultiImageSelector、MultipleImagePick、PhotoPicker、GalleryPick等等,我大致看了下,使用方法是大同小异的。这次开发中,我们使用的是GalleryPick,基本使用方法可以看看github的介绍。GalleryPick地址 
    这里几乎就没什么好介绍了,需要的注意的地方,YangcyYe也介绍的很详细。代码:

            ImageConfig imageConfig
                            = new ImageConfig.Builder(
                            // GlideLoader 可用自己用的缓存库
                            new GlideLoader())
                            // 如果在 4.4 以上,则修改状态栏颜色 (默认黑色)
                            .steepToolBarColor(getResources().getColor(R.color.blue))
                            // 标题的背景颜色 (默认黑色)
                            .titleBgColor(getResources().getColor(R.color.blue))
                            // 提交按钮字体的颜色  (默认白色)
                            .titleSubmitTextColor(getResources().getColor(R.color.white))
                            // 标题颜色 (默认白色)
                            .titleTextColor(getResources().getColor(R.color.white))
                            // 开启多选   (默认为多选)  (单选 为 singleSelect)
                            .mutiSelect()
                            .crop()
                            // 开启拍照功能 (默认关闭)
                            .showCamera()
                            // 多选时的最大数量   (默认 9 张)
                            .mutiSelectMaxSize(6)
                            // 已选择的图片路径
                            .pathList(path)
                            // 拍照后存放的图片路径(默认 /temp/picture)
                            .filePath("/ImageSelector/Pictures")
                            .requestCode(REQUEST_CODE)
                            .build();
    
    
                    ImageSelector.open(OrderDetailActivity.this, imageConfig);   // 开启图片选择器
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    图片选择后是在onActivityResult函数的回调的,和自带的图库是一样的。

    二、图片压缩

    我们公司的项目主要是上传手机拍的照片,现在的手机像素都是极高的,一不小心就是OOM,更重要的是在天朝流量是“奢侈品”,让用户一不小心就是十几M的流量没了,这也是不行的,所以上传前必须对照片进行压缩优化。

    网上相关介绍也是颇多,我直接贴代码,各位看看,应该是挺好理解的。

    public class BitmapUtils {
    
        //压缩图片尺寸
        public static Bitmap compressBySize(String pathName, int targetWidth,
                                     int targetHeight) {
            BitmapFactory.Options options = new BitmapFactory.Options();
            opts.inJustDecodeBounds = true;// 不去真的解析图片,只是获取图片的头部信息,包含宽高等;
            Bitmap bitmap = BitmapFactory.decodeFile(pathName, options);
    
            // 得到图片的宽度、高度;
            float imgWidth = options.outWidth;
            float imgHeight = options.outHeight;
    
            // 分别计算图片宽度、高度与目标宽度、高度的比例;取大于等于该比例的最小整数;
            int widthRatio = (int) Math.ceil(imgWidth / (float) targetWidth);
            int heightRatio = (int) Math.ceil(imgHeight / (float) targetHeight);
            options.inSampleSize = 1;
    
            // 如果尺寸接近则不压缩,否则进行比例压缩
            if (widthRatio > 1 || widthRatio > 1) {
                if (widthRatio > heightRatio) {
                    options.inSampleSize = widthRatio;
                } else {
                    options.inSampleSize = heightRatio;
                }
            }
    
            //设置好缩放比例后,加载图片进内容;
            options.inJustDecodeBounds = false; // 这里一定要设置false
            bitmap = BitmapFactory.decodeFile(pathName, opts);
            return bitmap;
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    一般而言,大小保持在720P左右即可,至少我是这么设置的。压缩的图片,可以通过适配器实现QQ控件图片上传时展现的效果。代码:

        GridLayoutManager gridLayoutManager = new GridLayoutManager(this, 3);
        recycler.setLayoutManager(gridLayoutManager);
        adapter = new Adapter(this, path);
        recycler.setAdapter(adapter);
    • 1
    • 2
    • 3
    • 4

    其适配器的完整代码

     public class Adapter extends RecyclerView.Adapter<Adapter.ViewHolder> {
    
        private Context context;
        private LayoutInflater mLayoutInflater;
        private List<String> result;
        private final static String TAG = "Adapter";
    
        public Adapter(Context context, List<String> result) {
            mLayoutInflater = LayoutInflater.from(context);
            this.context = context;
            this.result = result;
        }
    
        @Override
        public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
            return new ViewHolder(mLayoutInflater.inflate(R.layout.image, null));
        }
    
        @Override
        public void onBindViewHolder(ViewHolder holder, int position) {
            Glide.with(context)
                    .load(result.get(position))
                    .centerCrop()
                    .into(holder.image);
    
        }
    
        @Override
        public int getItemCount() {
            return result.size();
        }
    
        public class ViewHolder extends RecyclerView.ViewHolder {
    
            ImageView image;
    
            public ViewHolder(View itemView) {
                super(itemView);
                image = (ImageView) itemView.findViewById(R.id.image);
            }
    
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    图片如此处理就可以了,但我们公司使用的是阿里云Oss,因此,我把处理过的文件又重新保存到sd里面去了。也把代码贴出来吧:

            long time = System.currentTimeMillis();
            String t = new SimpleDateFormat("yyyy_MM_dd").format(new Date(time));
            String d = new SimpleDateFormat("HH_mm").format(new Date(time));
    
            // 压缩图片保存的目录路径
            String filePath = MyApplication.getTruename() + "/" + t + "/" + d;
    
            // 压缩后图片保存的文件名
            String fileName = "photo" + "(" + number + ")" + ".jpg";
    
            File file = new File(getSDPath() + "/" + "myApp" + "/" + filePath);
            File dir = new File(file, fileName);//将要保存图片的路径,android推荐这种写法,将目录名和文件名分开,不然容易报错。
    
            try {
                //压缩图片
                Bitmap bitmap = BitmapUtils.compressBySize(srcPath, 1280, 768);
                if (!file.exists()) {
                    file.mkdirs();
                }
                if (!dir.exists()) {
                    try {
                        dir.createNewFile();
                        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dir));
                    bitmap.compress(Bitmap.CompressFormat.JPEG, 30, bos);
                    bos.flush();
                    bos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
            } catch (Exception e) {
                e.printStackTrace();
            } 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    getSdPath就是获取SD的路径,代码如下:

        public static String getSDPath() {
            File sdDir = null;
            boolean sdCardExist = Environment.getExternalStorageState()
                    .equals(android.os.Environment.MEDIA_MOUNTED);//判断sd卡是否存在
            if (sdCardExist) {
                sdDir = Environment.getExternalStorageDirectory();//获取根目录
            } else {
                getBaseContext().getCacheDir().getAbsolutePath(); // 获取内置内存卡目录
            }
            return sdDir.toString();
        }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    这样基本就完成了图片处理的操作,现在可以开始进行上传操作了。

    三、图片上传

    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            if (requestCode == REQUEST_CODE && resultCode == RESULT_OK && data != null) {
               // 处理逻辑,requestcode是自己设置和传过来的,RESULT_OK是常量
                path = data.getStringArrayListExtra(ImageSelectorActivity.EXTRA_RESULT);
                // 如果多张图片,可以采取循环上传
                for(String srcPath, path){
                    Log.i("MyTag", srcPath) ;  // 可以看到每张原始图片的地址
                    // 图片处理和保存的逻辑
                    // 图片上传的逻辑,推荐不要放在循环中,多张图片容易造成线程过多
            };
                    initOss(); // 配置OSS 
                    // 第一张图片的上传
                    OssUpload(path.get(0));
        }
     }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    OSS的配置,建议只实例化一次,即不要放在循环体中。

            // ACCESS_ID,ACCESS_KEY是在阿里云申请的
            OSSCredentialProvider credentialProvider = new OSSPlainTextAKSKCredentialProvider(ACCESS_ID, ACCESS_KEY);
            ClientConfiguration conf = new ClientConfiguration();
            conf.setConnectionTimeout(15 * 1000); // 连接超时,默认15秒
            conf.setSocketTimeout(15 * 1000); // socket超时,默认15秒
            conf.setMaxConcurrentRequest(8); // 最大并发请求数,默认5个
            conf.setMaxErrorRetry(2); // 失败后最大重试次数,默认2次
    
            // oss为全局变量,OSS_ENDPOINT是一个OSS区域地址
            oss = new OSSClient(getApplicationContext(), OSS_ENDPOINT, credentialProvider, conf);
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    实例化后,就要将图片上传了,这个逻辑应该在onActivityResult这个方法中执行

    
    public void ossUpload(String strPath){
    
        // 判断图片是否全部上传
        // 如果已经是最后一张图片上传成功,则跳出
        number++;
        if (number == path.size()) {
        // 结束的处理逻辑,并退出该方法
    
            return;
        }
    
        // 指定数据类型,没有指定会自动根据后缀名判断
        ObjectMetadata objectMeta = new ObjectMetadata();
        objectMeta.setContentType("image/jpeg");
    
        // 构造上传请求
        // 这里的objectKey其实就是服务器上的路径,即目录+文件名
        //因为目录命名逻辑涉及公司信息,被我删去,造成不知道这个objectKey不知为何物,如下是我们公司的大致命名逻辑
        //String objectKey = keyPath + "/" + carArr[times] + ".jpg";
        PutObjectRequest put = new PutObjectRequest(BUCKET_NAME, objectKey,dir.getPath());
        put.setMetadata(objectMeta);
        try {
            PutObjectResult putObjectResult = oss.putObject(put);
        } catch (ClientException e) {
            e.printStackTrace();
        } catch (ServiceException e) {
            e.printStackTrace();
        }
    
        // 异步上传时可以设置进度回调
        put.setProgressCallback(new OSSProgressCallback<PutObjectRequest>() {
            @Override
            public void onProgress(PutObjectRequest request, long currentSize, long totalSize) {
                // 在这里可以实现进度条展现功能
                Log.d("PutObject", "currentSize: " + currentSize + " totalSize: " + totalSize);
            }
       });
        OSSAsyncTask task = oss.asyncPutObject(put, new OSSCompletedCallback<PutObjectRequest, PutObjectResult>() {
            @Override
            public void onSuccess(PutObjectRequest request, PutObjectResult result) {
                Log.d("PutObject", "UploadSuccess");
                Log.d("ETag", result.getETag());
                Log.d("RequestId", result.getRequestId());
    
                // 这里进行递归单张图片上传,在外面判断是否进行跳出
                if (number <= path.size() - 1) {
                    upOss(path.get(number));
                }
            }
    
            @Override
            public void onFailure(PutObjectRequest request, ClientException clientExcepion, ServiceException serviceException) {
                // 请求异常
                if (clientExcepion != null) {
                    // 本地异常如网络异常等
                    clientExcepion.printStackTrace();
                }
                if (serviceException != null) {
                    // 服务异常
                    Log.e("ErrorCode", serviceException.getErrorCode());
                    Log.e("RequestId", serviceException.getRequestId());
                    Log.e("HostId", serviceException.getHostId());
                    Log.e("RawMessage", serviceException.getRawMessage());
                }
                ToastUtils.showShort(mContext, "图片上传失败,请重新上传");
                return;
            }
       });
    }
    展开全文
  • final OSS oss; final AliOssProperties ossProperties; @RequestMapping("/file") public R uploadFile(@RequestPart MultipartFile file) throws IOException { String newFileName = AliyunOssUtil....
  • android 集成OSS 上传图片
  • OSS上传图片

    千次阅读 2017-01-22 16:17:39
    alert(response, 1, "上传图片类型不正确!"); return null; } String fileName = (System.currentTimeMillis() + (new Random(999999).nextLong())) + fileType; try { if (null == imgFile ||...
    后台
    
    package com.xiaohe.qd.controller;
    
    import java.io.File;
    import java.io.InputStream;
    import java.util.Random;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import net.sf.json.JSONObject;
    
    import org.springframework.context.annotation.Scope;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.multipart.MultipartFile;
    import org.springframework.web.multipart.MultipartRequest;
    
    import com.aliyun.openservices.ClientException;
    import com.aliyun.openservices.ServiceException;
    import com.aliyun.openservices.oss.OSSClient;
    import com.aliyun.openservices.oss.OSSErrorCode;
    import com.aliyun.openservices.oss.OSSException;
    import com.aliyun.openservices.oss.model.CannedAccessControlList;
    import com.aliyun.openservices.oss.model.ObjectMetadata;
    import com.xiaohe.qd.util.Constants;
    import com.xiaohe.qd.util.ImageUtil;
    import com.xiaohe.qd.util.Property;
    
    @Controller
    @RequestMapping("/upload")
    @Scope("prototype")
    public class UploadController extends BaseController {
    
    	public final static String savePath = Constants.DIR_TEMP;
    	public final static Double width = 800.0;
    	public final static Double height = 800.0;
    	public final static Boolean largePic = false;
    	public final static String[] types = new String[] { ".bmp", ".png", ".gif", ".jpeg", ".pjpeg", ".jpg" };
    	public final static String[] fileType = new String[] { ".exe", ".jar", ".dll", ".jsp", ".class", ".sh", ".bat" };
    	public final static long maxSize = 10000000;
    	public final static long maxFileSize = 20000000;
    
    	@RequestMapping(value = "/img.html", produces = "text/html;charset=UTF-8")
    	@ResponseBody
    	public String img(HttpServletRequest request, HttpServletResponse response) {
    		MultipartRequest multipartRequest = (MultipartRequest) request;
    		MultipartFile imgFile = multipartRequest.getFile("imgFile");
    		String imgFileFileName = imgFile.getOriginalFilename();
    		try {
    			long size = imgFile.getSize();
    			if (size > maxSize) {
    				alert(response, 1, "图片应小于10M!");
    				return null;
    			}
    			boolean admit = true;
    			String fileType = ".jpg";
    			for (int i = 0; i < types.length; i++) {
    				if (types[i].equalsIgnoreCase(imgFileFileName.substring(imgFileFileName.lastIndexOf(".")))) {
    					admit = false;
    					if (types[i].endsWith(".gif"))
    						fileType = ".gif";
    					if (types[i].endsWith(".png"))
    						fileType = ".png";
    				}
    			}
    			if (admit) {
    				alert(response, 1, "上传图片类型不正确!");
    				return null;
    			}
    			String fileName = (System.currentTimeMillis() + (new Random(999999).nextLong())) + fileType;
    			try {
    				if (null == imgFile || size < 0) // 文件不存在时
    					return null;
    				String bucketName = "hhr360oss";
    				// 使用默认的OSS服务器地址创建OSSClient对象。
    				OSSClient client = new OSSClient(Property.getProperty("OSS_ACCESS_ID"), Property.getProperty("OSS_ACCESS_KEY"));
    				ensureBucket(client, bucketName);
    				ObjectMetadata objectMeta = new ObjectMetadata();
    				objectMeta.setContentLength(imgFile.getSize());
    				InputStream is = imgFile.getInputStream();
    				client.putObject(bucketName, fileName, is, objectMeta);
    				String saveUrl = Property.getProperty("OSS_URL") + fileName;
    				JSONObject obj = new JSONObject();
    				obj.put("fileName", imgFileFileName);
    				obj.put("fileSize", (int) size / 1024);
    				obj.put("error", 0);
    				obj.put("url", saveUrl);
    				obj.put("saveDir", saveUrl);
    				writeJson(response, obj);
    				return null;
    			} catch (Exception e) {
    				e.printStackTrace();
    				alert(response, 1, "上传图片异常!");
    				return null;
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    	private static void ensureBucket(OSSClient client, String bucketName) throws OSSException, ClientException {
    
    		try {
    			// 创建bucket
    			client.createBucket(bucketName);
    			client.setBucketAcl(bucketName, CannedAccessControlList.PublicRead);
    		} catch (ServiceException e) {
    			if (!OSSErrorCode.BUCKES_ALREADY_EXISTS.equals(e.getErrorCode())) {
    				// 如果Bucket已经存在,则忽略
    				throw e;
    			}
    		}
    	}
    
    	/**
    	 * 图片压缩
    	 * 
    	 * @param picFrom
    	 *            待压缩的图片保存路径
    	 * @param picTo
    	 *            压缩后的图片保存路径
    	 * @param width
    	 *            宽度
    	 * @param height
    	 *            高度
    	 * @throws Exception
    	 */
    	public static void comPress(String picFrom, String picTo, double width, double height) throws Exception {
    		ImageUtil.resize(picFrom, picTo, (int) width, (int) height);
    	}
    
    	/**
    	 * 图片压缩 作者:漆传涛
    	 * 
    	 * @param savePath
    	 *            文件保存的真实路径
    	 * @param oldFile
    	 *            压缩文件
    	 * @param width
    	 *            文件压缩宽
    	 * @param height
    	 *            文件压缩高
    	 * @throws Exception
    	 */
    	public void comPress(String savePath, File oldFile, double width, double height, boolean largePic) {
    		try {
    			if (!oldFile.exists()) // 文件不存在时
    				return;
    			String picFrom = oldFile.getAbsolutePath();
    			int quality = (int) ((largePic ? 200000d : 80000d) / oldFile.length() * 100);
    			if (quality >= 100) {
    				quality = 0;
    			} else {
    				if (quality < 70) {
    					quality = 50;
    				}
    			}
    			ImageUtil.resize(picFrom, savePath, (int) width, (int) height, quality);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    	public void alert(HttpServletResponse response, int error, String msg) {
    		try {
    			response.setCharacterEncoding("utf-8");
    			response.setContentType("text/html");
    			JSONObject array = new JSONObject();
    			array.put("error", error);
    			array.put("message", msg);
    			response.getWriter().write(array.toString());
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    	
    }
    


    package com.xiaohe.qd.util;
    
    import java.awt.image.BufferedImage;
    import java.io.File;
    import java.util.ArrayList;
    import java.util.List;
    
    import javax.imageio.ImageIO;
    import javax.servlet.http.HttpServletRequest;
    
    import net.sf.json.JSONObject;
    
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.im4java.core.ConvertCmd;
    import org.im4java.core.IMOperation;
    
    /**
     * 
     * @author 
     * 
     */
    public class ImageUtil {
    
    	private static Log log = LogFactory.getLog(ImageUtil.class);
    	public static String imageMagickPath = null;
    
    	static {
    		imageMagickPath = "C:\\Program Files (x86)\\ImageMagick-6.7.9-Q8";
    	}
    
    	public final static int PHOTO_RATIO = 800; // 缩放图片系数
    
    	/**
    	 * 剪切图片
    	 * 
    	 * @param x
    	 *            坐标x
    	 * @param y
    	 *            坐标y
    	 * @param width
    	 *            宽度
    	 * @param height
    	 *            高度
    	 * @param oldPath
    	 *            相对路径
    	 * @return 返回新的保存路径
    	 * @throws Exception
    	 *             描述: 按照坐标要求裁剪图片。
    	 */
    	public final static String cutImage(HttpServletRequest request, int x, int y, int width, int height,
    			String oldPath) throws Exception {
    		if (oldPath == null)
    			return null;
    		String newPath = oldPath.replace(Constants.DIR_TEMP, Constants.DIR_PIC);
    		String realPath = request.getServletContext().getRealPath(oldPath);
    		String newRealPath = request.getServletContext().getRealPath(newPath);
    		IMOperation op = new IMOperation();
    		op.addImage(realPath);
    		op.crop(width, height, x, y);
    		op.addImage(newRealPath);
    		runOp(op);
    		return newPath;
    	}
    
    	/**
    	 * 计算字的长度
    	 * 
    	 * @param text
    	 * @return
    	 */
    	public static int getLength(String text) {
    		int length = 0;
    		for (int i = 0; i < text.length(); i++) {
    			if ((text.charAt(i) + "").getBytes().length > 1) {
    				length += 2;
    			} else {
    				length += 1;
    			}
    		}
    		return length / 2;
    	}
    
    	/**
    	 * 图片压缩
    	 * 
    	 * @param picFrom
    	 * @param picTo
    	 * @param widthdist
    	 * @param heightdist
    	 */
    	public static void resize(String picFrom, String picTo, int widthdist,
    			int heightdist) {
    		resize(picFrom, picTo, widthdist, heightdist, 0);
    	}
    
    	/**
    	 * 图片压缩
    	 * 
    	 * @param picFrom
    	 * @param picTo
    	 * @param widthdist
    	 * @param heightdist
    	 */
    	public static void resize(String picFrom, String picTo, int widthdist,
    			int heightdist, int quality) {
    		try {
    			BufferedImage bi = ImageIO.read(new File(picFrom));
    			int new_w = bi.getWidth();
    			int new_h = bi.getHeight();
    			double rate = 1;
    			if (new_w > widthdist) {
    				rate = new_w / widthdist;
    				new_h = (int)(new_h / rate);
    				new_w = widthdist;
    			}
    			if (new_h > heightdist) {
    				rate = new_h / heightdist;
    				new_h = heightdist;
    				new_w = (int)(new_w / rate);
    			}
    			resizeImage(picFrom, picTo, new_w, new_h, quality);
    		} catch (RuntimeException e) {
    			log.error(e.getMessage());
    		} catch (Exception ex) {
    			log.error(ex.getMessage());
    		} catch (Throwable e) {
    			log.error(e.getMessage());
    		}
    	}
    
    	public static JSONObject getImgData(String picFrom) {
    		return getImgWidthHeight(picFrom);
    	}
    
    	public static void resize(String picFrom, String picTo, int ratio)
    			throws Exception {
    		BufferedImage bi = ImageIO.read(new File(picFrom));
    		// 原始图片属性
    		int srcWidth = bi.getWidth();
    		int srcHeight = bi.getHeight();
    		// 生成图片属性
    		int newWidth = srcWidth;
    		int newHeight = srcHeight;
    		// 如果超出最大宽或高就压缩
    		if (srcWidth > ratio || newHeight > ratio) {
    			// 生成图片width, height计算
    			if (srcWidth >= srcHeight) {
    				if (srcWidth < ratio) {
    					return;
    				}
    				newWidth = ratio;
    				newHeight = (ratio * srcHeight / srcWidth);
    			} else {
    				if (srcHeight < ratio) {
    					return;
    				}
    				newHeight = ratio;
    				newWidth = (ratio * srcWidth / srcHeight);
    			}
    		}
    		resize(picFrom, picTo, newWidth, newHeight);
    	}
    
    	/**
    	 * 方法描述: 验证文件类型
    	 * 
    	 * @param filename
    	 * @return
    	 */
    	public static boolean validateImage(String filename) {
    		// 定义可上传文件的 类型
    		List<String> fileTypes = new ArrayList<String>();
    
    		// 图片
    		fileTypes.add("jpg");
    		fileTypes.add("jpeg");
    		fileTypes.add("bmp");
    		fileTypes.add("gif");
    		fileTypes.add("png");
    
    		// 得到文件尾数 并 进行小写转换
    		String postfix = filename.substring(filename.lastIndexOf(".") + 1)
    				.toLowerCase();
    		return fileTypes.contains(postfix) ? true : false;
    	}
    
    	public static void resize(String picFrom, String picTo) throws Exception {
    		resize(picFrom, picTo, PHOTO_RATIO);
    	}
    
    	public static void main(String[] args) throws Exception {
    		// resizeImg("G:/xiaoguo/46留言反馈/此方.jpg", "G:/xiaoguo/46留言反馈/此方2.jpg",
    		// 200, 200);
    		resize("G:/xiaoguo/46留言反馈/此方.jpg", "G:/xiaoguo/46留言反馈/此方2.jpg", 200,
    				200);
    		// String img = "/temp/yancheng.jpg";
    		// String imgtemp = img.substring(img.lastIndexOf("/")+1,
    		// img.lastIndexOf("."));
    		// System.out.println(imgtemp);
    	}
    
    	public static JSONObject getImgWidthHeight(String picFrom) {
    		try {
    			JSONObject obj = new JSONObject();
    			BufferedImage bi = ImageIO.read(new File(picFrom));
    			// 原始图片属性
    			int srcWidth = bi.getWidth();
    			int srcHeight = bi.getHeight();
    			obj.put("width", srcWidth);
    			obj.put("height", srcHeight);
    			return obj;
    		} catch (RuntimeException e) {
    			log.error(e.getMessage());
    		} catch (Exception ex) {
    			log.error(ex.getMessage());
    		} catch (Throwable e) {
    			log.error(e.getMessage());
    		}
    		return null;
    	}
    
    	/**
    	 * 根据尺寸缩放图片
    	 * 
    	 * @param width
    	 *            缩放后的图片宽度
    	 * @param height
    	 *            缩放后的图片高度
    	 * @param srcPath
    	 *            源图片路径
    	 * @param newPath
    	 *            缩放后图片的路径
    	 */
    	public static void resizeImage(String srcPath, String newPath, int ratio)
    			throws Exception {
    		BufferedImage bi = ImageIO.read(new File(srcPath));
    		// 原始图片属性
    		int srcWidth = bi.getWidth();
    		int srcHeight = bi.getHeight();
    		// 生成图片属性
    		int newWidth = srcWidth;
    		int newHeight = srcHeight;
    		// 如果超出最大宽或高就压缩
    		if (srcWidth > ratio || newHeight > ratio) {
    			// 生成图片width, height计算
    			if (srcWidth >= srcHeight) {
    				if (srcWidth < ratio) {
    					return;
    				}
    				newWidth = ratio;
    				newHeight = (ratio * srcHeight / srcWidth);
    			} else {
    				if (srcHeight < ratio) {
    					return;
    				}
    				newHeight = ratio;
    				newWidth = (ratio * srcWidth / srcHeight);
    			}
    		}
    		resizeImage(srcPath, newPath, newWidth, newHeight,0);
    	}
    
    	/**
    	 * 根据尺寸缩放图片
    	 * 
    	 * @param width
    	 *            缩放后的图片宽度
    	 * @param height
    	 *            缩放后的图片高度
    	 * @param srcPath
    	 *            源图片路径
    	 * @param newPath
    	 *            缩放后图片的路径
    	 */
    	public static void resizeImage(String srcPath, String newPath, int width,
    			int height,int quality) throws Exception {
    		IMOperation op = new IMOperation();
    		op.addImage(srcPath);
    		op.resize(width, height);
    		if(quality>0&&quality<100){
    			op.quality(quality*1d);
    		}
    		op.addImage(newPath);
    		runOp(op);
    	}
    	
    	public static void resizeImage(String srcPath, String newPath, int width,
    			int height) throws Exception {
    		resize(srcPath, newPath, width, height, 0);
    	}
    	
    	public static void runOp(IMOperation op) throws Exception {
    		ConvertCmd convert = new ConvertCmd();
    //		convert.setSearchPath(imageMagickPath);
    		convert.run(op);
    	}
    }

    html

    	<!-- 上传头像弹窗 -->
    	<div  class="txFc">
    		<div id="uploader-demo">
    			<a class="uploader-clos">X</a>
    		    <!--用来存放item-->
    		    <div id="fileList" class="uploader-list"></div>
    		    <input type="file" name="imgFile" id="filePicker" value="选择图片"/>
    		    <div class="uploader-tip">格式:gif,jpg,jpeg,bmp,png </div>
    		    <input type="hidden" name="userAvatar" id="userAvatar" value=""/>
    		</div>
    	</div>

    js

    <link href="${ctx}/js/uploadify-v2.1.4/uploadify.css" rel="stylesheet" type="text/css" />
    <script type="text/javascript" src="${ctx}/js/uploadify-v2.1.4/swfobject.js"></script>
    <script	type="text/javascript" src="${ctx}/js/uploadify-v2.1.4/jquery.uploadify.v2.1.4.min.js"></script>
    <script type="text/javascript">
    jQuery("#filePicker").uploadify({
    	'uploader' : '${ctx}/js/uploadify-v2.1.4/uploadify.swf?random=' + (new Date()).getTime(),
    	'script' : '${ctx}/upload/img.html',//请求地址
    	'cancelImg' : '${ctx}/js/uploadify-v2.1.4/cancel.png',
    	'fileDataName' : 'imgFile', //相当于  file 控件的 name
    	'auto' : true,
    	'multi' : false,
    	'buttonImg' : '${ctx}/images/fileBtn.png',
    	'height' : '31',
    	'width' : '86',
    	'fileDesc' : '能上传的图片类型:jpg,gif,bmp,jpeg,png', //出现在上传对话框中的文件类型描述
    	'fileExt' : '*.jpg;*.gif;*.bmp;*.jpeg;*.png', //控制可上传文件的扩展名,启用本项时需同时声明fileDesc
    	'sizeLimit' : 3*1024*1024,
    	onComplete:function(event,queueID,fileObj,response,data){
    			var jsondata = eval("("+response+")");
    			if(jsondata.error==1){
    				Dialog.alert(jsondata.message);
    				return false;
    			}
    			$(".txFc").hide();
    			$(".user-tx img").attr("src", jsondata.saveDir);
    			$("#userAvatar").val(jsondata.saveDir);//图片的地址
    			$("#span1").html("已上传文件:"+jsondata.fileName);
    			$.post("${ctx}/ai/editUserAvatar.html",{userAvatar:$("#userAvatar").val()},function(data){
    				if (data.success == 1) {
    					globalTip("上传图片成功!");
    				}
    			}, "json");
    		},
    		'onSelect' : function(event,queueID, fileObj) {
    			if (fileObj.size > 5*1024*1024) {
    				Dialog.alert("图片"+ fileObj.name+ " 应小于5M");
    				jQuery("#filePicker").uploadifyClearQueue();
    			}
    		}
    });
    </script>


    效果图


    展开全文
  • 本篇文章主要介绍了Android Oss上传图片的使用示例,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 阿里云oss上传照片js 、jquery,源代码,下载 阿里云oss上传照片js 、jquery,源代码,下载
  • 阿里云OSS上传图片

    2020-12-30 16:27:38
    一、OSS(对象存储服务) 1、介绍 对象存储服务:阿里云对象存储服务(Object Storage Service,简称 OSS),是阿里云提供的海量、安全、低成本...二、使用OSS上传图片 1、引入Maven依赖 <!--oss--> <depend

    一、OSS(对象存储服务)

    1、介绍

    对象存储服务:阿里云对象存储服务(Object Storage Service,简称 OSS),是阿里云提供的海量、安全、低成本、高可靠的云存储服务。您可以在任何应用、任何时间、任何地点存储和访问任意类型的数据。
    OSS官方介绍地址:https://help.aliyun.com/document_detail/31947.html
    使用前提:必须开通OSS服务

    在这里插入图片描述

    二、使用OSS上传图片

    1、引入Maven依赖

    <!--oss-->
    <dependency>
        <groupId>com.aliyun.oss</groupId>
        <artifactId>aliyun-sdk-oss</artifactId>
        <version>3.10.2</version>
    </dependency>
    

    2、配置yml

    server:
      port: 9999
    
    spring:
      application:
        name: marketing-third
    
    # oss相关配置,需要在阿里云上获取
    oss:
      accessId: LTAI4G2PSmNiCPnqaTdc5JUS
      accessKey: OVmknks3UYf3nKz4dougCrRK6K76NX
      bucketName: marketing-shop
      endPointKey: oss-cn-beijing.aliyuncs.com
      url: https://marketing-shop.oss-cn-beijing.aliyuncs.com
    

    3、启动类

    @SpringBootApplication
    public class MarketingThirdApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(MarketingThirdApplication.class, args);
        }
    
    }
    

    4、config配置类

    package com.itan.config;
    
    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    /**
     * @Date: 2020/12/15
     * oss图片上传服务配置
     */
    @ConfigurationProperties(prefix = "oss")
    @Component
    @Data
    public class OssConfig {
        private String accessId;
    
        private String accessKey;
    
        private String bucketName;
    
        private String endPointKey;
    
        private String url;
    }
    

    5、文件上传工具类

    1、流式文件上传
    2、web直传获取签名后上传
    package com.itan.config;
    
    import com.aliyun.oss.OSS;
    import com.aliyun.oss.OSSClientBuilder;
    import com.aliyun.oss.common.utils.BinaryUtil;
    import com.aliyun.oss.model.CannedAccessControlList;
    import com.aliyun.oss.model.PolicyConditions;
    import java.io.InputStream;
    import java.util.Date;
    import java.util.LinkedHashMap;
    import java.util.Map;
    
    /**
     * @Date: 2020/12/15
     * 阿里oss
     */
    public class AliOss {
        private OSS ossClient;
        private String bucketName;
    
        public AliOss(String accessId, String accessKey, String bucketName, String endPoint) {
            this.bucketName = bucketName;
            //创建ossClient实例
            this.ossClient = new OSSClientBuilder().build(endPoint, accessId, accessKey);
            this.ossClient.setBucketAcl(bucketName, CannedAccessControlList.PublicReadWrite);
        }
    
        /**
         * 文件上传流
         * @param fileName
         * @param inputStream
         */
        public void uploadFileInputStream(String fileName, InputStream inputStream) {
            try {
                this.ossClient.putObject(this.bucketName, fileName, inputStream);
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                //关闭ossClient
                this.ossClient.shutdown();
            }
        }
    
        /**
         * web直传获取签名
         * @param expiration
         * @param policyConds
         * @return
         */
        public Map<String,String> getEncodedPolicyAndSignature(Date expiration, PolicyConditions policyConds) {
            Map<String,String> map = new LinkedHashMap<String, String>();
            try {
                //根据到期时间生成policy策略
                String policy = ossClient.generatePostPolicy(expiration, policyConds);
                //对policy进行UTF-8编码后转base64
                byte[] bytes = policy.getBytes("utf-8");
                String encodedPolicy = BinaryUtil.toBase64String(bytes);
                //生成签名,policy表单域作为填入的值,将该值作为将要签名的字符串
                String postSignature = ossClient.calculatePostSignature(policy);
                map.put("encodedPolicy",encodedPolicy);
                map.put("postSignature",postSignature);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                ossClient.shutdown();
            }
            return map;
        }
    }
    

    6、业务接口类

    package com.itan.service;
    
    import org.springframework.web.multipart.MultipartFile;
    import java.util.Map;
    
    /**
     * @Date: 2020/12/15
     */
    public interface AliOssService {
        /**
         * 上传文件到oss
         * @param file
         * @return
         */
        String uploadFile(MultipartFile file);
    
        /**
         * web直传获取签名
         * @return
         */
        Map<String, String> policy();
    }
    
    package com.itan.service.impl;
    
    import com.aliyun.oss.model.MatchMode;
    import com.aliyun.oss.model.PolicyConditions;
    import com.itan.config.AliOss;
    import com.itan.config.OssConfig;
    import com.itan.service.AliOssService;
    import com.itan.utils.BusinessException;
    import com.itan.utils.ResultCodeAndMessage;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.web.multipart.MultipartFile;
    import java.io.IOException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Map;
    
    /**
     * @Date: 2020/12/15
     */
    @Slf4j
    @Service
    public class AliOssServiceImpl implements AliOssService {
        @Autowired
        private OssConfig ossConfig;
    
        /**
         * 上传文件到oss
         * @param file
         * @return
         */
        @Override
        public String uploadFile(MultipartFile file) {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            if (null == file || file.isEmpty()) {
                throw new BusinessException(ResultCodeAndMessage.build(ResultCodeAndMessage.BUSINESS_ERROR, "上传文件不能为空"));
            }
            //获取文件名
            String originalFilename = file.getOriginalFilename();
            //生成上传文件名(当前时间字符串+文件名后缀)
            String fileName = System.currentTimeMillis() + originalFilename.substring(originalFilename.lastIndexOf("."));
            //同一天上传的文件存放一个文件夹
            String objName = sdf.format(new Date()) + "/" + fileName;
            try {
                AliOss aliOss = new AliOss(ossConfig.getAccessId(), ossConfig.getAccessKey(), ossConfig.getBucketName(), ossConfig.getEndPointKey());
                aliOss.uploadFileInputStream(objName, file.getInputStream());
            } catch (IOException e) {
                throw new BusinessException(ResultCodeAndMessage.build(ResultCodeAndMessage.BUSINESS_ERROR, "上传文件阿里云服务异常"));
            }
            return ossConfig.getUrl() + objName;
        }
    
        /**
         * web直传获取签名
         * @return
         */
        @Override
        public Map<String, String> policy() {
            //用户上传文件时指定的前缀(格式:2020-12-17/)
            String dir = new SimpleDateFormat("yyyy-MM-dd").format(new Date()) + "/";
            // 创建AliOss实例
            AliOss aliOss = new AliOss(ossConfig.getAccessId(), ossConfig.getAccessKey(), ossConfig.getBucketName(), ossConfig.getEndPointKey());
            //设置签名有效期30s
            long expireTime = 30;
            long expireEndTime = System.currentTimeMillis() + expireTime * 1000;
            Date expiration = new Date(expireEndTime);
            //PostObject请求最大可支持的文件大小为5GB,即CONTENT_LENGTH_RANGE为5*1024*1024*1024
            PolicyConditions policyConds = new PolicyConditions();
            policyConds.addConditionItem(PolicyConditions.COND_CONTENT_LENGTH_RANGE, 0, 1048576000);
            //指定此次上传的文件名必须是dir变量的值开头
            policyConds.addConditionItem(MatchMode.StartWith, PolicyConditions.COND_KEY, dir);
            Map<String, String> map = aliOss.getEncodedPolicyAndSignature(expiration, policyConds);
            map.put("accessId",ossConfig.getAccessId());
            //上传目录
            map.put("dir", dir);
            //地址
            map.put("host", ossConfig.getUrl());
            //过期时间
            map.put("expire", String.valueOf(expireEndTime / 1000));
            return map;
        }
    }
    

    7、controller类

    package com.itan.controller;
    
    import com.alibaba.fastjson.JSON;
    import com.itan.service.AliOssService;
    import com.itan.utils.BusinessException;
    import com.itan.utils.CommonResult;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.multipart.MultipartFile;
    
    /**
     * @Date: 2020/12/15
     */
    @Slf4j
    @RestController
    @RequestMapping("oss")
    public class AliOssController {
        @Autowired
        private AliOssService aliOssService;
    
        /**
         * 流式上传文件
         * @param imageFile
         * @return
         */
        @PostMapping("upload")
        public CommonResult upload(MultipartFile imageFile){
            CommonResult result;
            try {
                result = CommonResult.successResult(aliOssService.uploadFile(imageFile));
            } catch (BusinessException te) {
                log.error(te.getErrorMessage(), te);
                result = CommonResult.createResult(te.getResultCodeAndMessage());
            }
            log.info("上传文件到oss - 出参:{}", JSON.toJSONString(result));
            return result;
        }
    
        /**
         * web直传获取签名的原理如下:
         * 1、用户发送上传Policy请求到应用服务器。
         * 2、应用服务器返回上传Policy和签名给用户。
         * 3、用户直接上传数据到OSS。
         * @return
         */
        @RequestMapping("policy")
        public CommonResult policy(){
            CommonResult result;
            try {
                result = CommonResult.successResult(aliOssService.policy());
            } catch (BusinessException te) {
                log.error(te.getErrorMessage(), te);
                result = CommonResult.createResult(te.getResultCodeAndMessage());
            }
            log.info("web直传获取签名 - 出参:{}", JSON.toJSONString(result));
            return result;
        }
    }
    

    8、阿里云OSS配置跨域

    在这里插入图片描述

    9、启动测试

    接口地址:http://localhost:9999/oss/policy
    返回参数:
    {
        "msg": {
            "code": "20000",
            "message": "请求成功"
        },
        "data": {
            "encodedPolicy": "eyJleHBpcmF0aW9uIjoiMjAyMC0xMi0zMFQwODowMjowNC5zOTFaIiwiY29uZGl0aW9ucyI6W1siY29udGVudC1sZW5ndGgtcmFuZ2UiLDAsMTA0ODU3NjAwMF0sWyJzdGFydHMtd2l0aCIsIiRrZXkiLCIyMDIwLTEyLTMwLyJdXX0=",
            "postSignature": "dEhfbmObhsp85c7xIXu0kY6oOC0=",
            "accessId": "LTAI4G2PSmNiCPnqaTdc5JUS",
            "dir": "2020-12-30/",
            "host": "https://marketing-shop.oss-cn-beijing.aliyuncs.com/",
            "expire": "1609315324"
        },
        "success": true
    }
    

    10、前端上传代码

    获取签名
    import http from '@/utils/httpRequest.js'
    export function policy() {
       return  new Promise((resolve,reject)=>{
            http({
                url: http.adornUrl("/thirdparty/oss/policy"),
                method: "get",
                params: http.adornParams({})
            }).then(({ data }) => {
                resolve(data);
            })
        });
    }
    
    上传组件
    <template> 
      <div>
        <el-upload
          action="http://marketing-shop.oss-cn-beijing.aliyuncs.com"
          :data="dataObj"
          list-type="picture"
          :multiple="false" :show-file-list="showFileList"
          :file-list="fileList"
          :before-upload="beforeUpload"
          :on-remove="handleRemove"
          :on-success="handleUploadSuccess"
          :on-preview="handlePreview">
          <el-button size="small" type="primary">点击上传</el-button>
          <div slot="tip" class="el-upload__tip">只能上传 jpg/png 文件,且不超过10MB</div>
        </el-upload>
        <el-dialog :visible.sync="dialogVisible">
          <img width="100%" :src="fileList[0].url" alt="">
        </el-dialog>
      </div>
    </template>
    <script>
       import {policy} from './policy'
       import { getUUID } from '@/utils'
    
      export default {
        name: 'singleUpload',
        props: {
          value: String
        },
        computed: {
          imageUrl() {
            return this.value;
          },
          imageName() {
            if (this.value != null && this.value !== '') {
              return this.value.substr(this.value.lastIndexOf("/") + 1);
            } else {
              return null;
            }
          },
          fileList() {
            return [{
              name: this.imageName,
              url: this.imageUrl
            }]
          },
          showFileList: {
            get: function () {
              return this.value !== null && this.value !== ''&& this.value!==undefined;
            },
            set: function (newValue) {
            }
          }
        },
        data() {
          return {
            dataObj: {
              policy: '',
              signature: '',
              key: '',
              ossaccessKeyId: '',
              dir: '',
              host: '',
              // callback:'',
            },
            dialogVisible: false
          };
        },
        methods: {
          emitInput(val) {
            this.$emit('input', val)
          },
          handleRemove(file, fileList) {
            this.emitInput('');
          },
          handlePreview(file) {
            this.dialogVisible = true;
          },
          beforeUpload(file) {
            let _self = this;
            return new Promise((resolve, reject) => {
              policy().then(response => {
                _self.dataObj.policy = response.data.encodedPolicy;
                _self.dataObj.signature = response.data.postSignature;
                _self.dataObj.ossaccessKeyId = response.data.accessId;
                _self.dataObj.key = response.data.dir + getUUID() + '_${filename}';
                _self.dataObj.dir = response.data.dir;
                _self.dataObj.host = response.data.host;
                console.log("赋值后数据:",this.dataObj);
                resolve(true)
              }).catch(err => {
                reject(false)
              })
            })
          },
          handleUploadSuccess(res, file) {
            console.log("上传成功...")
            this.showFileList = true;
            this.fileList.pop();
            this.fileList.push({name: file.name, url: this.dataObj.host + '/' + this.dataObj.key.replace("${filename}",file.name) });
            this.emitInput(this.fileList[0].url);
          }
        }
      }
    </script>
    <style>
    </style>
    
    展开全文
  • Springboot整合阿里云OSS上传图片第一步: 准备第二步:导入阿里OSS的依赖第三步:创建 allyun.properties第四步: OSS工具类第五步:上传图片OSS工具类Controller层方法 第一步: 准备 aliyun.access-id=自己的 ...

    第一步: 准备

    		aliyun.access-id=自己的
    		aliyun.access-key=自己的
    		aliyun.bucket=自己的
    		aliyun.endpoint=自己的
    		aliyun.dir=自己的
    

    第二步:导入阿里OSS的依赖

    		<dependency>
    			<groupId>com.aliyun.oss</groupId>
    			<artifactId>aliyun-sdk-oss</artifactId>
    			<version>3.5.0</version>
    		</dependency>
    

    第三步:创建 allyun.properties

    	aliyun.access-id=LTAI4FkSy78FtxJEGSYMzEVk
    	aliyun.access-key=vXrfuwNhH2McGkaJQVUXzhoN1r8BpL
    	aliyun.bucket=bj-yys
    	aliyun.endpoint=oss-cn-beijing.aliyuncs.com
    	aliyun.dir=bj-yys/
    

    第四步: OSS工具类

    下面展示 OSS工具类代码

    
    @Component
    @PropertySource("classpath:/allyun.properties")
    public class OSSProperties implements InitializingBean {
        @Value("${aliyun.endpoint}")
        private String aliyun_endpoint;
        @Value("${aliyun.access-id}")
        private String aliyun_access_id;
        @Value("${aliyun.access-key}")
        private String aliyun_access_key;
        @Value("${aliyun.bucket}")
        private String aliyun_bucket;
        @Value("${aliyun.dir}")
        private String aliyun_dir;
    
    
    
        //声明静态变量,
        public static String ALIYUN_ENDPOINT         ;
        public static String ALIYUN_ACCESS_ID     ;
        public static String ALIYUN_ACCESS_KEY  ;
        public static String ALIYUN_BUCKET     ;
        public static String ALIYUN_DIR         ;
    
    
    
        @Override
        public void afterPropertiesSet() throws Exception {
            ALIYUN_ENDPOINT = aliyun_endpoint;
            ALIYUN_ACCESS_ID = aliyun_access_id;
            ALIYUN_ACCESS_KEY = aliyun_access_key;
            ALIYUN_BUCKET = aliyun_bucket;
            ALIYUN_DIR = aliyun_dir;
        }
    }
    
    

    第五步:上传图片

    OSS工具类

    下面展示 OSS工具类

      
    public class OSSUtil {
    
        /**
         * log日志
         */
        public static final Logger logger = LoggerFactory.getLogger(OSSUtil.class);
    
        private String endpoint= OSSProperties.ALIYUN_ENDPOINT;
        private String accessKeyId=OSSProperties.ALIYUN_ACCESS_ID;
        private String accessKeySecret=OSSProperties.ALIYUN_ACCESS_KEY;
        private String bucketName=OSSProperties.ALIYUN_BUCKET;
        private String FOLDER=OSSProperties.ALIYUN_DIR;
    
        /**
         * 上传图片
         *
         * @param url
         * @throws
         */
        public void uploadImg2Oss(String url) throws IOException {
            File fileOnServer = new File(url);
            FileInputStream fin;
            try {
                fin = new FileInputStream(fileOnServer);
                String[] split = url.split("/");
                this.uploadFile2OSS(fin, split[split.length - 1]);
            } catch (FileNotFoundException e) {
                throw new IOException("图片上传失败");
            }
        }
    
        public String uploadImg2Oss(MultipartFile file) throws IOException {
           /* if (file.getSize() > 10 * 1024 * 1024) {
                throw new IOException("上传图片大小不能超过10M!");
            }*/
            String originalFilename = file.getOriginalFilename();
            String substring = originalFilename.substring(originalFilename.lastIndexOf(".")).toLowerCase();
            Random random = new Random();
            String name = random.nextInt(10000)+ System.currentTimeMillis() + substring;
            try {
                InputStream inputStream = file.getInputStream();
                this.uploadFile2OSS(inputStream, name);
                return name;
            } catch (Exception e) {
                throw new IOException("图片上传失败");
            }
        }
    
        /**
         * 获得图片路径
         *
         * @param fileUrl
         * @return
         */
        public String getImgUrl(String fileUrl) {
            System.out.println(fileUrl);
            if (!StringUtils.isEmpty(fileUrl)) {
                String[] split = fileUrl.split("/");
                return this.getUrl(this.FOLDER + split[split.length - 1]);
            }
            return "" ;
        }
    
        /**
         * 上传到OSS服务器 如果同名文件会覆盖服务器上的
         *
         * @param instream
         *            文件流
         * @param fileName
         *            文件名称 包括后缀名
         * @return 出错返回"" ,唯一MD5数字签名
         */
        public String uploadFile2OSS(InputStream instream, String fileName) {
    
            String ret = "";
            try {
                OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
                // 创建上传Object的Metadata
                ObjectMetadata objectMetadata = new ObjectMetadata();
                objectMetadata.setContentLength(instream.available());
                objectMetadata.setCacheControl("no-cache");
                objectMetadata.setHeader("Pragma", "no-cache");
                objectMetadata.setContentType(getcontentType(fileName.substring(fileName.lastIndexOf("."))));
                objectMetadata.setContentDisposition("inline;filename=" + fileName);
                // 上传文件
                PutObjectResult putResult = ossClient.putObject(bucketName, FOLDER + fileName, instream, objectMetadata);
                ret = putResult.getETag();
            } catch (IOException e) {
                logger.error(e.getMessage(), e);
            } finally {
                try {
                    if (instream !=null ) {
                        instream.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return ret;
        }
    
        /**
         * Description: 判断OSS服务文件上传时文件的contentType
         */
        public static String getcontentType(String filenameExtension) {
            if (filenameExtension.equalsIgnoreCase("bmp")) {
                return "image/bmp";
            }
            if (filenameExtension.equalsIgnoreCase("gif")) {
                return "image/gif";
            }
            if (filenameExtension.equalsIgnoreCase("jpeg") || filenameExtension.equalsIgnoreCase("jpg")
                    || filenameExtension.equalsIgnoreCase("png")) {
                return "image/jpeg";
            }
            if (filenameExtension.equalsIgnoreCase("html")) {
                return "text/html";
            }
            if (filenameExtension.equalsIgnoreCase("txt")) {
                return "text/plain";
            }
            if (filenameExtension.equalsIgnoreCase("vsd")) {
                return "application/vnd.visio";
            }
            if (filenameExtension.equalsIgnoreCase("pptx") || filenameExtension.equalsIgnoreCase("ppt")) {
                return "application/vnd.ms-powerpoint";
            }
            if (filenameExtension.equalsIgnoreCase("docx") || filenameExtension.equalsIgnoreCase("doc")) {
                return "application/msword";
            }
            if (filenameExtension.equalsIgnoreCase("xml")) {
                return "text/xml";
            }
            return "image/jpeg";
        }
    
        /**
         * 获得url链接
         *
         * @param key
         * @return
         */
        public String getUrl(String key) {
            // 设置URL过期时间为10年 3600l* 1000*24*365*10
            OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
            Date expiration = new Date(System.currentTimeMillis() + 3600L * 1000 * 24 * 365 * 10);
            // 生成URL
            URL url = ossClient.generatePresignedUrl(bucketName, key, expiration);
    /*        url = "https://" + bucketName + ".oss-cn-beijing.aliyuncs.com/" + bucketName+"/"+ key;*/
            if (url != null) {
    
                String host ="https://"+url.getHost()+url.getPath();
    
                return host;
            }
    
    
            return  "";
        }
    }
    

    Controller层方法

    上传图片

       public Map<String,Object> uploadPhoto(@RequestParam("imgFile") MultipartFile imgFile,HttpServletRequest req) throws Exception {
            OSSUtil ossClient=new OSSUtil();
            Map<String, Object> m = new HashMap<>();
            if (imgFile.isEmpty()) {
                   m.put("error","上传文件不能为空");
             }
                String newsUrl = "";
                if (!((MultipartFile) imgFile).isEmpty()) {
                    try {
                        //将文件上传
                        String name = ossClient.uploadImg2Oss(imgFile);
                        //获取文件的URl地址  以便前台  显示
                        String imgUrl = ossClient.getImgUrl(name);
               
                        m.put("url",imgUrl);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                       }else {
                         m.put("error","上传图片不可为空");
                      }
                return m;
        }
    
    
    展开全文
  • OSS上传图片并验证

    2020-04-26 11:44:01
    使用阿里OSS上传图片,并验证文件格式是否正确 1、Controller /** * 上传图片 */ @RequestMapping(value = "/fAbout/upload") @ResponseBody public ReturnResult upload( @RequestParam(value = "file...
  • vue项目中使用OSS上传图片和附件vue项目中使用OSS上传图片或附件1、新建oss.js文件,封装使用oss2、页面中使用oss.js vue项目中使用OSS上传图片或附件 上传图片和附件这里不做区别;上传的流程都一样; 1、新建oss....
  • summernote集成前端oss上传图片到阿里云服务器 。
  • 问题:oss上传图片,new OSSClient报错

    千次阅读 2018-09-15 11:45:55
    小伙伴们,有没有遇到阿里oss上传图片,报com.aliyun.oss.ClientException: Unknown 的。查了下帮助文档看不懂:网络打满是什么意思。
  • SpringBoot整合OSS上传图片 一、比较通过服务端上传图片到阿里云OSS 和 服务端签名后直传方式(即通过前端上传图片)。 1、服务端上传图片到阿里云OSS,流程图如下: 2、服务端签名后直传方式(即通过前端上传图片...
  • vue中使用上传OSS图片文件等操作。内含备注 直接调用唯一方法传参既可
  • OSS上传图片 java

    2017-07-18 16:10:29
    maven: com.aliyun.oss aliyun-sdk-oss 2.4.0 @Configuration public class SpringConfig { @Autowired Environment env; @Bean(destroyMethod = "shutdown") public OSSClien
  • OSS上传图片无法在线预览的解决方案
  • oss 上传照片失败

    2019-06-14 15:10:00
    文件上传oss时报错 the difference between the request time and the current times is too large, 请求时间和当前时间之间的差异太大 使用 date 命令 看了下服务器时间 确实比当前时间慢了一小时 所以准备...
  • OSS 上传图片详解

    千次阅读 2017-04-19 14:41:50
    上传图片详解" TITLE="OSS 上传图片详解" /> (如果有人给我提供一下如何发布html上来就更好了) 上传图片详解" TITLE="OSS 上传图片详解" /> 注:谷歌,IE10以及以上效果图 js //自定义获取图片路径函数 ...
  • vue oss 上传图片

    千次阅读 2019-03-20 21:12:48
    今天 有人问阿里云的上传图片的问题。 我就去查看了下,阿里云的上传分为表单上传,普通上传,点断上传(分片上传)。 这次主要是使用普通上传,来做上传一个图片功能。 第一步:你的有阿里云账号,然后开辟存储...
  • Java IO流阿里云OSS上传照片 声明:这个为我个人原创 我没有copy别人的代码 但我看他们写的代码块都是一致的 连错误都是 很容易误导别人 我写代码的时候一直想不通 后面解决之后 就想自己写一个给遇到有相同问题的小...
  • 阿里云oss 上传图片

    2020-12-01 21:16:22
    之前使用过阿里云的oss储存服务,也写了一个上传图片的代码,但是最近在写东西的时候发现对这方面又比较陌生,而且发现在官网找文档也有点费劲,所以把代码写出来之后特地写个博客记录一下,以防以后还需要用到。...
  • Java oss上传图片

    2017-12-31 11:39:07
    * @descript:java使用阿里云OSS存储对象上传图片 * @date:2017年3月16日 下午5:58:08 * @author wangqi */ public class AliyunOSSClientUtil { //log日志 private static Logger logger = Logger....
  • 最近刚做了tp集成oss上传图片的功能, 首先下载sdk,官方给定的地址是去git下载,下载地址附上:https://github.com/aliyun/aliyun-oss-php-sdk?spm=a2c4g.11186623.2.11.6fbcc839WhQEfC 下载完后,改名为OSS然后...
  • OSS上传图片 输入路径一直在下载,无法预览,解决办法: 代码块: 把obiectMetadata 放入 oss.Cliect.putObject();里即可 ObjectMetadata objectMetadata = new ObjectMetadata(); objectMetadata....
  • 阿里OSS上传图片

    2020-07-21 15:41:32
    static String endpoint = "oss地址"; static String accessKeyId = "????"; static String accessKeySecret = "????"; static String bucketName = "存到的文件夹"; //这个一个controller中方法 返回值类型...
  • egg-oss 上传图片

    2021-06-02 15:45:19
    一、安装 egg-oss npm install egg-oss --save 二、配置 oss 1、开启 oss 插件 // config/plugin.js exports.oss = { enable: true, package: 'egg-oss', }; 2、填写 oss bucket 信息 // config/config.default....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,924
精华内容 5,569
关键字:

oss上传图片