消息队列、OSS常用操作封装

最新推荐文章于 2024-04-10 01:47:44 发布
最新推荐文章于 2024-04-10 01:47:44 发布
阅读量274 收藏
点赞数
文章标签： c/c++ c#
原文链接：http://www.cnblogs.com/smartsmile/p/6234052.html
版权 
 public class MessageQueue
    {
        #region Private Properties
        private const string _accessKeyId = "";
        private const string _secretAccessKey = "";
        private const string _endpoint = "";

        private static string _queueName;
        private const int _receiveTimes = 1;
        private const int _receiveInterval = 2;
        private const int batchSize = 6;

        #endregion

        #region 设置队列名称
        public string queueName
        {
            set
            {
                _queueName = value;

            }
            get
            {
                return _queueName;
            }
        }
        #endregion

        #region 判断消息队列是否存在
        /// <summary>
        /// 判断消息队列是否存在
        /// </summary>
        /// <returns></returns>
        public static bool QueueIsExist()
        {
            bool flag = false;
            try
            {
                using (IMNS client = new Aliyun.MNS.MNSClient(_accessKeyId, _secretAccessKey, _endpoint))
                {
                    var nativeQueue = client.GetNativeQueue(_queueName);
                    var getQueueAttributesResponse = nativeQueue.GetAttributes();
                    flag = true;
                }
            }
            catch (Exception ex) { Console.WriteLine(ex.ToString()); }
            return flag;
        }
        #endregion

        #region 创建消息队列
        /// <summary>
        /// 创建消息队列
        /// </summary>
        /// <returns></returns>
        public static string CreateQueue()
        {
            /*
                DelaySeconds	发送到该 Queue 的所有消息默认将以DelaySeconds参数指定的秒数延后可被消费，单位为秒。	0-604800秒（7天）范围内某个整数值，默认值为0
                MaximumMessageSize	发送到该Queue的消息体的最大长度，单位为byte。	1024(1KB)-65536（64KB）范围内的某个整数值，默认值为65536（64KB）。
                MessageRetentionPeriod	消息在该 Queue 中最长的存活时间，从发送到该队列开始经过此参数指定的时间后，不论消息是否被取出过都将被删除，单位为秒。	60 (1分钟)-1296000 (15 天)范围内某个整数值，默认值345600 (4 天)
                VisibilityTimeout	消息从该 Queue 中取出后从Active状态变成Inactive状态后的持续时间，单位为秒。	1-43200(12小时)范围内的某个值整数值，默认为30（秒）
                PollingWaitSeconds	当 Queue 中没有消息时，针对该 Queue 的 ReceiveMessage 请求最长的等待时间，单位为秒。	0-30秒范围内的某个整数值，默认为0（秒）
                LoggingEnabled	是否开启日志管理功能，True表示启用，False表示停用	True/False，默认为False             
             */
            string queueName = string.Empty;
            var createQueueRequest = new CreateQueueRequest
            {
                QueueName = _queueName,
                Attributes =
                {
                    DelaySeconds = 0,
                    MaximumMessageSize = 65536,
                    MessageRetentionPeriod = 345600,
                    VisibilityTimeout = 3600,
                    PollingWaitSeconds = 3
                }
            };
            try
            {
                using (IMNS client = new Aliyun.MNS.MNSClient(_accessKeyId, _secretAccessKey, _endpoint))
                {
                    var queue = client.CreateQueue(createQueueRequest);
                    queueName = queue.QueueName;
                }
            }
            catch (Exception ex) { Console.WriteLine(ex.ToString()); }
            Thread.Sleep(2000);
            return queueName;
        }
        #endregion

        #region 删除消息队列
        /// <summary>
        /// 删除消息队列
        /// </summary>
        /// <returns></returns>
        public static bool DeleteQueue()
        {
            bool flag = false;
            var deleteQueueRequest = new DeleteQueueRequest(_queueName);
            deleteQueueRequest.AddHeader("Accept", "IE6"); //Add extra request headers
            //deleteQueueRequest.AddParameter("param1", "value1"); //InvalidQueryString
            try
            {
                using (IMNS client = new Aliyun.MNS.MNSClient(_accessKeyId, _secretAccessKey, _endpoint))
                {
                    var deleteQueueResponse = client.DeleteQueue(deleteQueueRequest);
                    flag = true;
                }
            }
            catch (Exception ex) { Console.WriteLine(ex.ToString()); }
            return flag;
        }
        #endregion

        #region 发送消息(单条或多条)
        /// <summary>
        /// 发送消息(单条或多条)
        /// </summary>
        /// <param name="models">SendMessageRequest集合</param>
        /// <returns></returns>
        public static bool BathSendMessage(List<SendMessageRequest> models)
        {
            bool flag = false;
            try
            {
                using (IMNS client = new Aliyun.MNS.MNSClient(_accessKeyId, _secretAccessKey, _endpoint))
                {
                    var nativeQueue = client.GetNativeQueue(_queueName);
                    List<SendMessageRequest> requests = new List<SendMessageRequest>();
                    for (int i = 0; i < models.Count; i++)
                    {
                        requests.Add(models[i]);
                    }
                    BatchSendMessageRequest batchSendRequest = new BatchSendMessageRequest()
                    {
                        Requests = requests
                    };
                    var sendMessageResponse = nativeQueue.BatchSendMessage(batchSendRequest);
                    flag = true;
                }
            }
            catch (Exception ex) { Console.WriteLine(ex.ToString()); }
            return flag;
        }
        #endregion

        #region 消费消息(单条或多条)
        /// <summary>
        /// 消费消息(单条或多条)
        /// </summary>
        /// <param name="itemNum">数目</param>
        /// <returns></returns>
        public static List<Message> ReceiveMessage(int itemNum)
        {
            List<Message> lists = new List<Message>();
            try
            {
                using (IMNS client = new Aliyun.MNS.MNSClient(_accessKeyId, _secretAccessKey, _endpoint))
                {
                    var nativeQueue = client.GetNativeQueue(_queueName);
                    for (int i = 0; i < itemNum; i++)
                    {
                        var receiveMessageResponse = nativeQueue.ReceiveMessage();
                        Message message = receiveMessageResponse.Message;
                        lists.Add(message);
                    }
                }
            }
            catch (Exception ex) { Console.WriteLine(ex.ToString()); }
            return lists;
        }
        #endregion

        #region 删除消息
        /// <summary>
        /// 删除消息
        /// </summary>
        /// <param name="receiptHandle">receiptHandle</param>
        /// <returns></returns>
        public static bool DeleteMessage(string receiptHandle)
        {
            bool flag = false;
            var deletedReceiptHandle = receiptHandle;
            try
            {
                using (IMNS client = new Aliyun.MNS.MNSClient(_accessKeyId, _secretAccessKey, _endpoint))
                {
                    var nativeQueue = client.GetNativeQueue(_queueName);
                    var deleteMessageResponse = nativeQueue.DeleteMessage(receiptHandle);
                    flag = true;
                }
            }
            catch (Exception ex) { Console.WriteLine(ex.ToString()); }
            return flag;
        }
        #endregion

        #region 修改消息可见时间
        /// <summary>
        /// 修改消息可见时间
        /// </summary>
        /// <param name="receiptHandle">receiptHandle</param>
        /// <param name="visibilityTimeout">从现在到下次可被用来消费的时间间隔</param>
        /// <returns></returns>
        public static bool ChangeMessageVisibility(string receiptHandle, int visibilityTimeout)
        {
            bool flag = false;
            var deletedReceiptHandle = receiptHandle;
            try
            {
                using (IMNS client = new Aliyun.MNS.MNSClient(_accessKeyId, _secretAccessKey, _endpoint))
                {
                    var nativeQueue = client.GetNativeQueue(_queueName);
                    var changeMessageVisibilityRequest = new ChangeMessageVisibilityRequest
                    {
                        ReceiptHandle = receiptHandle,
                        VisibilityTimeout = visibilityTimeout
                    };
                    var changeMessageVisibilityResponse = nativeQueue.ChangeMessageVisibility(changeMessageVisibilityRequest);
                    flag = true;
                }
            }
            catch (Exception ex) { Console.WriteLine(ex.ToString()); }
            return flag;
        }
        #endregion
    }
using System;
using System.IO;
using System.Text;
using System.Threading;
using System.Security.Cryptography;
using Aliyun.OSS.Common;

namespace Aliyun.OSS.Samples
{
    /// <summary>
    /// 获取OSS对象
    /// </summary>
   public static class GetObjectSample
   {
       static string accessKeyId = Config.AccessKeyId;
       static string accessKeySecret = Config.AccessKeySecret;
       static string endpoint = Config.Endpoint;
       static OssClient client = new OssClient(endpoint, accessKeyId, accessKeySecret);

       static string key = "123456.jpg";
       static string fileToUpload = Config.FileToUpload;
       static string dirToDownload = Config.DirToDownload;

       static AutoResetEvent _event = new AutoResetEvent(false);

       public static void GetObjects(string bucketName)
       {
           GetObject(bucketName); //获取文件

           GetObjectByRequest(bucketName);

           AsyncGetObject(bucketName); //异步方式获取文件
       }

       public static void GetObject(string bucketName)
       {
           try
           {
               client.PutObject(bucketName, key, fileToUpload);

               var result = client.GetObject(bucketName, key);

               using (var requestStream = result.Content)
               {
                   using (var fs = File.Open(Path.Combine(dirToDownload, key), FileMode.OpenOrCreate))
                   {
                       int length = 4 * 1024;
                       var buf = new byte[length];
                       do
                       {
                           length = requestStream.Read(buf, 0, length);
                           fs.Write(buf, 0, length);
                       } while (length != 0);
                   }
               }

               Console.WriteLine("Get object succeeded");
           }
           catch (OssException ex)
           {
                Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}", 
                    ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
           }
           catch (Exception ex)
           {
                Console.WriteLine("Failed with error info: {0}", ex.Message);
           }
        }

       public static void GetObjectByRequest(string bucketName)
       {
           try
           {
               client.PutObject(bucketName, key, fileToUpload);

               var request = new GetObjectRequest(bucketName, key);
               request.SetRange(0, 100);

               var result = client.GetObject(request);

               Console.WriteLine("Get object succeeded, length:{0}", result.Metadata.ContentLength);
           }
           catch (OssException ex)
           {
               Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
                   ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
           }
           catch (Exception ex)
           {
               Console.WriteLine("Failed with error info: {0}", ex.Message);
           }
       }

       public static void AsyncGetObject(string bucketName)
       {
           const string key = "AsyncGetObject";
           try
           {
               client.PutObject(bucketName, key, fileToUpload);

               string result = "Notice user: put object finish";
               client.BeginGetObject(bucketName, key, GetObjectCallback, result.Clone());

               _event.WaitOne();
           }
           catch (OssException ex)
           {
               Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
                   ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
           }
           catch (Exception ex)
           {
               Console.WriteLine("Failed with error info: {0}", ex.Message);
           }
       }

       private static void GetObjectCallback(IAsyncResult ar)
       {
           try
           {
               var result = client.EndGetObject(ar);

               using (var requestStream = result.Content)
               {
                   using (var fs = File.Open(dirToDownload + "/sample2.data", FileMode.OpenOrCreate))
                   {
                       int length = 4 * 1024;
                       var buf = new byte[length];
                       do
                       {
                           length = requestStream.Read(buf, 0, length);
                           fs.Write(buf, 0, length);
                       } while (length != 0);
                   }
               }

               Console.WriteLine(ar.AsyncState as string);
           }
           catch (Exception ex)
           {
               Console.WriteLine(ex.Message);
           }
           finally
           {
               _event.Set();
           }
       }
    }
}
using System;
using System.Collections.Generic;
using Aliyun.OSS.Common;

namespace Aliyun.OSS.Samples
{
    /// <summary>
    /// 删除OSS对象
    /// </summary>
    public static class DeleteObjectsSample
    {
        static string accessKeyId = Config.AccessKeyId;
        static string accessKeySecret = Config.AccessKeySecret;
        static string endpoint = Config.Endpoint;
        static OssClient client = new OssClient(endpoint, accessKeyId, accessKeySecret);

        public static void DeleteObject(string bucketName)
        {
            try
            {
                string key = null;
                var listResult = client.ListObjects(bucketName);
                foreach (var summary in listResult.ObjectSummaries)
                {
                    key = summary.Key;
                    break;
                }

                client.DeleteObject(bucketName, key);

                Console.WriteLine("Delete object succeeded");
            }
            catch (OssException ex)
            {
                Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
                    ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed with error info: {0}", ex.Message);
            }
        }

        public static void DeleteObjects(string bucketName)
        {
            try
            {
                var keys = new List<string>();
                var listResult = client.ListObjects(bucketName);
                foreach (var summary in listResult.ObjectSummaries)
                {
                    keys.Add(summary.Key);
                    break; //不跳出删除全部
                }
                var request = new DeleteObjectsRequest(bucketName, keys, false);
                client.DeleteObjects(request);

                Console.WriteLine("Delete objects succeeded");
            }
            catch (OssException ex)
            {
                Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}", 
                    ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed with error info: {0}", ex.Message);
            }
        }
    }
}

using System;
using System.IO;
using System.Threading;
using Aliyun.OSS.Common;
using System.Text;
using Aliyun.OSS.Util;

namespace Aliyun.OSS.Samples
{
    /// <summary>
    /// 上传文件或对象到OSS
    /// </summary>
    public static class PutObjectSample
    {
        static string accessKeyId = Config.AccessKeyId;
        static string accessKeySecret = Config.AccessKeySecret;
        static string endpoint = Config.Endpoint;
        static OssClient client = new OssClient(endpoint, accessKeyId, accessKeySecret);

        static string fileToUpload = Config.FileToUpload;

        static AutoResetEvent _event = new AutoResetEvent(false);

        /// <summary>
        /// sample for put object to oss
        /// </summary>
        public static void PutObject(string bucketName)
        {
            PutObjectFromFile(bucketName); //上传文件

            PutObjectFromString(bucketName); //上传String

            PutObjectWithDir(bucketName); //创建目录上传

            PutObjectWithMd5(bucketName); //MD5验证上传

            PutObjectWithHeader(bucketName); //设置Header上传

            AsyncPutObject(bucketName); //异步上传
        }

        public static void PutObjectFromFile(string bucketName)
        {
            const string key = "PutObjectFromFile";
            try
            {
                client.PutObject(bucketName, key, fileToUpload);
                Console.WriteLine("Put object:{0} succeeded", key);
            }
            catch (OssException ex)
            {
                Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
                    ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed with error info: {0}", ex.Message);
            }
        }

        public static void PutObjectFromString(string bucketName)
        {
            const string key = "PutObjectFromString";
            const string str = "Aliyun OSS SDK for C#";

            try
            {
                byte[] binaryData = Encoding.ASCII.GetBytes(str); 
                var stream = new MemoryStream(binaryData);
                
                client.PutObject(bucketName, key, stream);
                Console.WriteLine("Put object:{0} succeeded", key);
            }
            catch (OssException ex)
            {
                Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
                    ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed with error info: {0}", ex.Message);
            }
        }

        public static void PutObjectWithDir(string bucketName)
        {
            const string key = "folder/sub_folder/PutObjectFromFile";

            try
            {
                client.PutObject(bucketName, key, fileToUpload);
                Console.WriteLine("Put object:{0} succeeded", key);
            }
            catch (OssException ex)
            {
                Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
                    ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed with error info: {0}", ex.Message);
            }
        }

        public static void PutObjectWithMd5(string bucketName)
        {
            const string key = "PutObjectWithMd5";

            string md5;
            using (var fs = File.Open(fileToUpload, FileMode.Open))
            {
                md5 = OssUtils.ComputeContentMd5(fs, fs.Length);
            }

            var meta = new ObjectMetadata() { ContentMd5 = md5 };
            try
            {
                client.PutObject(bucketName, key, fileToUpload, meta);

                Console.WriteLine("Put object:{0} succeeded", key);
            }
            catch (OssException ex)
            {
                Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
                    ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed with error info: {0}", ex.Message);
            }
        }

        public static void PutObjectWithHeader(string bucketName)
        {
            const string key = "PutObjectWithHeader";
            try
            {
                using (var content = File.Open(fileToUpload, FileMode.Open))
                {
                    var metadata = new ObjectMetadata();                    
                    metadata.ContentLength = content.Length;

                    metadata.UserMetadata.Add("github-account", "qiyuewuyi");

                    client.PutObject(bucketName, key, content, metadata);

                    Console.WriteLine("Put object:{0} succeeded", key);
                }
            }
            catch (OssException ex)
            {
                Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
                    ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed with error info: {0}", ex.Message);
            }
        }

        public static void AsyncPutObject(string bucketName)
        {
            const string key = "AsyncPutObject";
            try
            {
                // 1. put object to specified output stream
                using (var fs = File.Open(fileToUpload, FileMode.Open))
                {
                    var metadata = new ObjectMetadata();
                    metadata.UserMetadata.Add("mykey1", "myval1");
                    metadata.UserMetadata.Add("mykey2", "myval2");
                    metadata.CacheControl = "No-Cache";
                    metadata.ContentType = "text/html";

                    string result = "Notice user: put object finish";
                    client.BeginPutObject(bucketName, key, fs, metadata, PutObjectCallback, result.ToCharArray());

                    _event.WaitOne();
                }
            }
            catch (OssException ex)
            {
                Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
                    ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed with error info: {0}", ex.Message);
            }
        }

        private static void PutObjectCallback(IAsyncResult ar)
        {
            try
            {
                client.EndPutObject(ar);

                Console.WriteLine(ar.AsyncState as string);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                _event.Set();
            }
        }
    }
}

转载于:https://www.cnblogs.com/smartsmile/p/6234052.html

diehe5608
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于Redis的MessageQueue队列封装
始终不够
09-16 2万+
Redis的链表List可以用来做链表，高并发的特性非常适合做分布式的并行消息传递。 项目地址：https://github.com/huyanping/Zebra-PHP-Framework
计算机网络消息封装,数据封装
weixin_32349711的博客
06-19 2015
数据封装(Data Encapsulation)，笼统地讲，就是把业务数据映射到某个封装协议的净荷中，然后填充对应协议的包头，形成封装协议的数据包，并完成速率适配。解封装，就是封装的逆过程，拆解协议包，处理包头中的信息，取出净荷中的业务信息数据封装和解封装是一对逆过程。中文名数据封装外文名Data Encapsulation学科信息工程领域工程技术数据封装简介编辑语音数据包利用网络...
MSMQ 消息队列的封装
weixin_30561425的博客
12-21 144
介绍MSMQ 消息队列的文章很多，我不想多说，这里写了个对MSMQ 消息队列操作进行封装的类，做为自己初学MSMQ 消息队列的总结。代码如下： /**////<summary>///接受消息事件的代理///</summary>///<paramname="src"></param>///<param...
消息队列接口的简单封装
柴三少_
01-15 1561
//头文件msgipc_msg.h #ifndef _WBM_MY_MSG_H_ #define _WBM_MY_MSG_H_ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <unistd.h> #include <errno.h> #include <sys/ms
消息队列的应用及自己封装的消息队列类
FreeBird的专栏
01-16 1605
需要包含的头文件： #include #include 消息队列用到的几个函数： 一、创建或者访问一个消息队列 int msgget(key_t key, int msgflg); 参数key:     程序必须提供一个key值Key可以为IPC_PRIVATE创建一个私有队列，该队列理论上只可以为当前     进程访问 参数msgflg:     由9个权限标记组成,
oss上传以及消息队列相关知识activemq
11-22
首先，要进行OSS上传，你需要使用阿里云提供的SDK，如Java、Python、Node.js等，这些SDK封装了与OSS服务交互的接口。在初始化SDK时，需要设置Access Key ID和Access Key Secret，这是阿里云账户的身份凭证，用于验证...
plupload+bootstrap+php队列上传oss
11-16
SDK封装了所有必要的API调用，包括上传、下载、删除文件，设置权限等操作。开发者只需要按照文档指导配置好access key和secret key，就可以方便地在PHP代码中进行OSS操作。 6. **安全性考虑**：在实现此方案时，...
js代码实现图片上传阿里云OSS
11-29
- 初始化Plupload实例：配置参数包括URL（阿里云OSS的上传接口地址）、选择文件的类型限制、上传队列大小等。 - 监听`FileUploaded`事件，当文件上传成功时，获取返回的文件信息。 - 使用`addFile`方法添加待上传...
aliyun_starter.rar
08-31
7. **事件通知**：OSS可以配置事件通知，当文件发生特定操作（如上传、删除）时，可以触发HTTP回调、消息队列等动作。 8. **OSS API**：除了SDK，开发者还可以直接调用RESTful API进行操作，这需要对HTTP请求和JSON...
uploadAliyun.zip
08-15
本教程将深入讲解如何封装一个微信小程序的图片上传组件，并结合阿里云对象存储服务（OSS）进行实践。首先，我们需要了解以下几个关键知识点： 1. **微信小程序**：微信小程序是一种轻量级的应用开发平台，无需安装...
阿里云rocketmq消息队列对接demo
01-24
该资源为在购买了阿里云中间件产品rocketmq消息队列之后，使用的连接rocketmq的demo工程，该程序以 Java 为例，包括普通消息、事务消息、定时消息的测试代码，以及相关 Spring 的配置示例，同时提供tcp连接的程序。
阿里云OSS上传封装
qq_56687451的博客
11-11 846
<?php namespace App\service; use OSS\OssClient; use OSS\Core\OssException; class uploadPic { public function uploadAalilun($file) { $accessKeyId = "LTAI5tA8oBZwBW5qrcjxKCFS"; $accessKeySecret = "EI7txZRDO20fwsUJHpMB.
基于腾讯云tdmq消息队列封装SpringBootStarter（二）
July_whj
01-03 1103
关于腾讯云tdmq的基本使用参见《基于腾讯云tdmq消息队列封装SpringBootStarter（一）》，这里我们基于之前的内容在次进行优化封装。 一、创建消费者注解（TdmqConsumer）和生产者注解（TdmqProducer） 1.1、基础工程回顾 首先我们回顾下上一章完成的基础功能。 工程目录 上一章我们创建了配置目录config、生产者和消费者目录，以及META-INF目录和spring.factories配置文件。 在此基础上我们继续完善我们的工程。 1.2、创建注解 在
springboot实战之oss上传工具封装
sccd2009的专栏
12-12 177
springboot实战之oss上传工具封装
阿里云OSS封装—上传文件工具+调用方法
世 间 尤 物，不 敢 妄 取
05-09 1349
上传工具类 <!-- 阿里云OSS--> <!-- aliyun oss --> <dependency> <groupId>com.aliyun.oss</groupId> <artifactId>aliyun-sdk-oss</artifactId> <version>2.2.1</version&g
SpringBoot通过OSS实现文件上传和下载（包括本地文件的上传和下载）
最新发布
jfgkjhghfdgf的博客
04-10 1017
**@Description：简单常亮定义*/
阿里云OSS文件上传封装
diaobang0776的博客
08-13 865
1.先用composer安装阿里云OSS的PHPSDK 2.配置文件里定义阿里云OSS的秘钥 3.在index控制器里的代码封装 <?php namespace app\index\controller; use OSS\OssClient; use OSS\Core\OssException; use OSS\Core\OssUtil; use...
C#使用阿里云OSS存储过程
ToString的博客
03-13 408
项目需求：由于数据库存储图片二进制导致数据库负荷过大，采用了数据库存取URL的方式减轻数据库负担。（并且有卡顿现象） 参考资料：https://help.aliyun.com/document_detail/32085.html?spm=a2c4g.11174359.6.1142.4ccd65ecpIDWOf //向OSS增加图片并返回URL //file :路径 //filename:图片名称 ...
ASP.NetCore项目使用阿里云OSS对象存储
qq_73375428的博客
03-20 1428
WebAPI .NetCore项目实现阿里云云对象OSS存储操作手册
爱立信-BSC操作基础.docx
12-31
在爱立信的BSC操作中，OSS的常用操作指令具有特定的结构和规律。首先，所有的指令都是由5个字母组成的，并且以分号“；”作为结束标志。这有助于形成统一的输入格式，便于理解和执行。文档中提到了两种主要类型的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值