备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

简单对七牛.Net API管理文件进行简单封装的类

2015-04-14 1111
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： //封装类代码 using System;using System.Collections.Generic;using System.Linq;using System.

//封装类代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Qiniu.Conf;
using Qiniu.RS;
using Qiniu.RPC;
using Qiniu.RSF;
using Qiniu.IO;
using Qiniu.IO.Resumable;
using System.IO;
using System.Web;
using System.Drawing.Imaging;
using Qiniu.FileOp;
using System.Net;
//要先引用qiniu的dll文件

namespace ypsuit.common.QiniuHelper
{
    public class QiniuHelper
    {
        /// <summary>
        /// cdnPath为网站服务器本地路径，本地备份一份，再上传到七牛空间一份
        /// </summary>
        private static readonly string cdnPath = DataHelper.GetAbsolutePath(CommonFun.GetConfigData(DataConfigKey.Qiniu.ToString(), DataConfigAttr.CDN_PATH.ToString()));
        /// <summary>
        /// 空间名
        /// </summary>
        public static readonly string bucket = CommonFun.GetConfigData(DataConfigKey.Qiniu.ToString(), DataConfigAttr.BUCKET.ToString());
        /// <summary>
        /// 七牛外域名
        /// </summary>
        public static readonly string Domain = CommonFun.GetConfigData(DataConfigKey.Qiniu.ToString(), DataConfigAttr.DOMAIN.ToString());
        /// <summary>
        /// 在网站/程序初始化时调用一次
        /// </summary>
        public static void Init()
        {
            //设置权限key
            Qiniu.Conf.Config.ACCESS_KEY = CommonFun.GetConfigData(DataConfigKey.Qiniu.ToString(), DataConfigAttr.ACCESS_KEY.ToString());
            //设置密匙key
            Qiniu.Conf.Config.SECRET_KEY = CommonFun.GetConfigData(DataConfigKey.Qiniu.ToString(), DataConfigAttr.SECRET_KEY.ToString());
        }

        #region 查看单个文件属性信息
        /// <summary>
        /// 查看单个文件属性信息
        /// </summary>
        /// <param name="bucket">七牛云存储空间名</param>
        /// <param name="key">文件key</param>
        public static void Stat(string bucket, string key)
        {
            RSClient client = new RSClient();
            Entry entry = client.Stat(new EntryPath(bucket, key));
            if (entry.OK)
            {
                Console.WriteLine("Hash: " + entry.Hash);
                Console.WriteLine("Fsize: " + entry.Fsize);
                Console.WriteLine("PutTime: " + entry.PutTime);
                Console.WriteLine("MimeType: " + entry.MimeType);
                Console.WriteLine("Customer: " + entry.Customer);
            }
            else
            {
                Console.WriteLine("Failed to Stat");
            }
        }
        #endregion

        /// <summary>
        /// 复制单个文件
        /// </summary>
        /// <param name="bucketSrc">需要复制的文件所在的空间名</param>
        /// <param name="keySrc">需要复制的文件key</param>
        /// <param name="bucketDest">目标文件所在的空间名</param>
        /// <param name="keyDest">标文件key</param>
        public static void Copy(string bucketSrc, string keySrc, string bucketDest, string keyDest)
        {
            RSClient client = new RSClient();
            CallRet ret = client.Copy(new EntryPathPair(bucketSrc, keySrc, bucketDest, keyDest));
            if (ret.OK)
            {
                Console.WriteLine("Copy OK");
            }
            else
            {
                Console.WriteLine("Failed to Copy");
            }
        }

        /// <summary>
        /// 移动单个文件
        /// </summary>
        /// <param name="bucketSrc">需要移动的文件所在的空间名</param>
        /// <param name="keySrc">需要移动的文件</param>
        /// <param name="bucketDest">目标文件所在的空间名</param>
        /// <param name="keyDest">目标文件key</param>
        public static void Move(string bucketSrc, string keySrc, string bucketDest, string keyDest)
        {
            Console.WriteLine("\n===> Move {0}:{1} To {2}:{3}",
            bucketSrc, keySrc, bucketDest, keyDest);
            RSClient client = new RSClient();
            new EntryPathPair(bucketSrc, keySrc, bucketDest, keyDest);
            CallRet ret = client.Move(new EntryPathPair(bucketSrc, keySrc, bucketDest, keyDest));
            if (ret.OK)
            {
                Console.WriteLine("Move OK");
            }
            else
            {
                Console.WriteLine("Failed to Move");
            }
        }

        /// <summary>
        /// 删除单个文件
        /// </summary>
        /// <param name="bucket">文件所在的空间名</param>
        /// <param name="key">文件key</param>
        public static void Delete(string bucket, string key)
        {
            //Console.WriteLine("\n===> Delete {0}:{1}", bucket, key);
            RSClient client = new RSClient();
            CallRet ret = client.Delete(new EntryPath(bucket, key));
            //if (ret.OK)
            //{
            //    Console.WriteLine("Delete OK");
            //}
            //else
            //{
            //    Console.WriteLine("Failed to delete");
            //}
        }
        /// <summary>
        /// 批量获取文件信息
        /// </summary>
        /// <param name="bucket"></param>
        /// <param name="keys"></param>
        public static void BatchStat(string bucket, string[] keys)
        {
            RSClient client = new RSClient();
            List<EntryPath> EntryPaths = new List<EntryPath>();
            foreach (string key in keys)
            {
                Console.WriteLine("\n===> Stat {0}:{1}", bucket, key);
                EntryPaths.Add(new EntryPath(bucket, key));
            }
            client.BatchStat(EntryPaths.ToArray());
        }
        /// <summary>
        /// 批量复制
        /// </summary>
        /// <param name="bucket"></param>
        /// <param name="keys"></param>
        public static void BatchCopy(string bucket, string[] keys)
        {
            List<EntryPathPair> pairs = new List<EntryPathPair>();
            foreach (string key in keys)
            {
                EntryPathPair entry = new EntryPathPair(bucket, key, Guid.NewGuid().ToString());
                pairs.Add(entry);
            }
            RSClient client = new RSClient();
            client.BatchCopy(pairs.ToArray());
        }

        /// <summary>
        /// 批量移动
        /// </summary>
        /// <param name="bucket"></param>
        /// <param name="keys"></param>
        public static void BatchMove(string bucket, string[] keys)
        {
            List<EntryPathPair> pairs = new List<EntryPathPair>();
            foreach (string key in keys)
            {
                EntryPathPair entry = new EntryPathPair(bucket, key, Guid.NewGuid().ToString());
                pairs.Add(entry);
            }
            RSClient client = new RSClient();
            client.BatchMove(pairs.ToArray());
        }
        /// <summary>
        /// 批量删除
        /// </summary>
        /// <param name="bucket"></param>
        /// <param name="keys"></param>
        public static void BatchDelete(string bucket, string[] keys)
        {
            RSClient client = new RSClient();
            List<EntryPath> EntryPaths = new List<EntryPath>();
            foreach (string key in keys)
            {
                //Console.WriteLine("\n===> Stat {0}:{1}", bucket, key);
                EntryPaths.Add(new EntryPath(bucket, key));
            }
            client.BatchDelete(EntryPaths.ToArray());
        }
        /// <summary>
        /// 列出所有文件信息
        /// </summary>
        /// <param name="bucket"></param>
        public static List<DumpItem> List(int limit = 100, string prefix = "")
        {
            RSFClient rsf = new RSFClient(bucket);
            rsf.Prefix = prefix;
            rsf.Limit = limit;
            List<DumpItem> list = new List<DumpItem>();
            List<DumpItem> items;
            while ((items = rsf.Next()) != null)
            {
                list.AddRange(items);
                //todo
            }
            return list;
        }


        /// <summary>
        /// 普通上传文件
        /// key必须采用utf8编码，如使用非utf8编码访问七牛云存储将反馈错误
        /// </summary>
        /// <param name="bucket"></param>
        /// <param name="key">上传后的路径</param>
        /// <param name="fname">要上传的文件路径（文件必须存在）</param>
        public static PutRet PutFile(string key, string fname)
        {
            if (key.IndexOf('.') == -1) key += Path.GetExtension(fname);
            var policy = new PutPolicy(bucket, 3600);
            string upToken = policy.Token();
            PutExtra extra = new PutExtra();
            IOClient client = new IOClient();
            //client.PutFinished += (o, retTemp) =>
            //{
            //    if (retTemp.StatusCode == HttpStatusCode.OK)
            //    {
            //    }
            //    else if (retTemp.StatusCode == HttpStatusCode.BadGateway ||
            //        retTemp.StatusCode == HttpStatusCode.BadRequest ||
            //        retTemp.StatusCode == HttpStatusCode.GatewayTimeout ||
            //        retTemp.StatusCode == HttpStatusCode.GatewayTimeout ||
            //        retTemp.StatusCode == HttpStatusCode.InternalServerError)
            //    {
            //    }
            //};
            PutRet ret = client.PutFile(upToken, key, fname, extra);

            return ret;
        }
        /// <summary>
        /// 普通上传图片
        /// key必须采用utf8编码，如使用非utf8编码访问七牛云存储将反馈错误
        /// </summary>
        /// <param name="bucket"></param>
        /// <param name="key">上传后的路径</param>
        /// <param name="fname">要上传的文件路径（文件必须存在）</param>
        public static PutRet PutImage(string key, string fname, string mimeType = "image/jpg")
        {
            if (key.IndexOf('.') == -1) key += Path.GetExtension(fname);
            if (mimeType == "") mimeType = GetMimeTypeByExtension(Path.GetExtension(fname));
            var policy = new PutPolicy(bucket, 3600);
            string upToken = policy.Token();
            PutExtra extra = new PutExtra
            {
                MimeType = mimeType,
                Crc32 = 123,
                CheckCrc = CheckCrcType.CHECK,
                Params = new Dictionary<string, string>()
            };
            IOClient client = new IOClient();
            PutRet ret = client.PutFile(upToken, key, fname, extra);
            return ret;
        }

        /// <summary>
        /// 上传文件到网站服务器，再上传到七牛服务器
        /// </summary>
        /// <param name="fileData">页面/swf传过来的文件数据</param>
        /// <param name="fileType">预留</param>
        /// <param name="path">文件加逻辑路径，如：images/ </param>
        /// <param name="isOriginal">是否保留文件原名</param>
        /// <param name="prefix">不保留原名时，文件名的前缀部分</param>
        /// <returns></returns>
        public static PutRet UploadFile(HttpPostedFileBase fileData, string fileType = "", string path = "", string isOriginal = "",string prefix="")
        {
            PutRet ret = null;
            if (fileData != null)
            {

                var fileExt = Path.GetExtension(fileData.FileName);
                var fileName = "";
                if (isOriginal != "1")
                {
                    fileName = DataHelper.CreateRandomName(fileExt);
                    if (prefix != "") fileName = prefix + fileName;
                }
                else fileName = Path.GetFileName(fileData.FileName).Replace(" ", "");

                var fileFullPath = "";
                bool isImage = false;
                string mimeType = GetMimeTypeByExtension(fileExt);
                if (mimeType == "")
                {
                    if (path.Len() == 0) path = "files/";
                    fileFullPath = Path.Combine(path, fileType);
                }
                else if (mimeType.StartsWith("image"))
                {
                    if (path.Len() == 0) path = "images/";
                    fileFullPath = Path.Combine(path, fileType);
                    isImage = true;
                }
                else
                {
                    if (path.Len() == 0) path = "other/";
                    fileFullPath = Path.Combine(path, fileType);
                }
                if (!Directory.Exists(cdnPath + fileFullPath))
                {
                    Directory.CreateDirectory(cdnPath + fileFullPath);
                }
                var fileFullName = cdnPath + fileFullPath + "/" + fileName;
                fileData.SaveAs(fileFullName);

                string key = string.Empty;
                //上传图片到七牛
                if (System.IO.File.Exists(fileFullName))
                {
                    // long len = fileData.ContentLength / 1024;
                    key = fileFullName.Replace(cdnPath, "").Replace("\\", "/").Replace("//", "/");
                    if (isImage) ret = PutImage(key, fileFullName, mimeType);
                    else ret = PutFile(key, fileFullName);
                }
            }
            return ret;
        }

        /// <summary>
        /// 通过后缀获取mime类型
        /// </summary>
        /// <param name="extension"></param>
        /// <returns></returns>
        private static string GetMimeTypeByExtension(string extension)
        {
            string mimeType = "";
            extension = extension.TrimStart('.').ToLowerInvariant();
            switch (extension)
            {
                case "gif":
                    mimeType = "image/gif";
                    break;
                case "png":
                    mimeType = "image/png";
                    break;
                case "bmp":
                    mimeType = "image/bmp";
                    break;
                case "jpeg":
                case "jpg":
                    mimeType = "image/jpg";
                    break;

            }
            return mimeType;
        }

        /// <summary>
        /// 断点续传
        /// </summary>
        /// <param name="bucket"></param>
        /// <param name="key"></param>
        /// <param name="fname"></param>
        public static void ResumablePutFile(string bucket, string key, string fname)
        {
            Console.WriteLine("\n===> ResumablePutFile {0}:{1} fname:{2}", bucket, key, fname);
            PutPolicy policy = new PutPolicy(bucket, 3600);
            string upToken = policy.Token();
            Settings setting = new Settings();
            ResumablePutExtra extra = new ResumablePutExtra();
            // extra.Notify += PutNotifyEvent;//(int blkIdx, int blkSize, BlkputRet ret);//上传进度通知事件
            ResumablePut client = new ResumablePut(setting, extra);
            client.PutFile(upToken, fname, Guid.NewGuid().ToString());
        }

        /// <summary>
        /// 得到文件的外链地址 
        /// </summary>
        /// <param name="key"></param>
        /// <param name="isPublic"></param>
        /// <returns></returns>
        public static string GetUrl(string key, bool isPublic = true)
        {
            string baseUrl = GetPolicy.MakeBaseUrl(Domain, key);
            if (isPublic) return baseUrl;
            string private_url = GetPolicy.MakeRequest(baseUrl);
            return private_url;
        }

        /// <summary>
        /// 获取图片信息
        /// </summary>
        /// <param name="key"></param>
        /// <param name="isPublic"></param>
        /// <returns></returns>
        public static ImageInfoRet GetImageInfo(string key, bool isPublic = true)
        {
            string url = GetPolicy.MakeBaseUrl(Domain, key);
            //生成fop_url
            string imageInfoURL = ImageInfo.MakeRequest(url);
            //对其签名，生成private_url。如果是公有bucket此步可以省略
            if (!isPublic) imageInfoURL = GetPolicy.MakeRequest(imageInfoURL);
            ImageInfoRet infoRet = ImageInfo.Call(imageInfoURL);
            if (infoRet.OK)
            {
                Console.WriteLine("Format: " + infoRet.Format);
                Console.WriteLine("Width: " + infoRet.Width);
                Console.WriteLine("Heigth: " + infoRet.Height);
                Console.WriteLine("ColorModel: " + infoRet.ColorModel);
            }
            else
            {
                Console.WriteLine("Failed to ImageInfo");
            }
            return infoRet;
        }

        public static string GetImagePreviewUrl(string key, bool isPublic = true)
        {
            string url = GetPolicy.MakeBaseUrl(Domain, key);

            ImageView imageView = new ImageView { Mode = 0, Width = 200, Height = 200, Quality = 90, Format = "jpg" };
            string viewUrl = imageView.MakeRequest(url);
            if (!isPublic) viewUrl = GetPolicy.MakeRequest(viewUrl);//私链
            return viewUrl;
        }

        /// <summary>
        /// 获取水印图片
        /// </summary>
        /// <param name="key"></param>
        /// <param name="type"></param>
        /// <param name="waterString"></param>
        /// <param name="isPublic"></param>
        /// <param name="waterColor"></param>
        /// <returns></returns>
        public static string GetWaterMarker(string key, WaterType type = WaterType.No, string waterString = "", bool isPublic = true, string waterColor = "red")
        {
            string url = GetUrl(key);
            string markerUrl = string.Empty;
            switch (type)
            {
                case WaterType.Text:
                    {
                        //文字水印
                        WaterMarker marker = new TextWaterMarker(waterString, "", waterColor);
                        markerUrl = marker.MakeRequest(url);
                    }
                    break;
                case WaterType.Image:
                    {
                        //图片水印
                        WaterMarker marker = new ImageWaterMarker(waterString);
                        markerUrl = marker.MakeRequest(url);
                    }
                    break;
            }
            if (!isPublic && !string.IsNullOrEmpty(markerUrl)) markerUrl = GetPolicy.MakeRequest(markerUrl);
            return markerUrl;


        }
        /// <summary>
        /// 水印类型枚举
        /// </summary>
        public enum WaterType
        {
            /// <summary>
            /// 无水印
            /// </summary>
            No,
            /// <summary>
            /// 文字水印
            /// </summary>
            Text,
            /// <summary>
            /// 图片水印
            /// </summary>
            Image
        }




    }
}


.Net MVC控制器调用上传：

        /// <summary>
        /// 上传文件到七牛服务器
        /// </summary>
        /// <param name="fileData"></param>
        /// <param name="uploadDir">目录</param>
        /// <param name="original">是否保留原名(1：保留，其他不保留)</param>
        /// <returns></returns>
        public ActionResult UploadFile(HttpPostedFileBase fileData, string uploadDir = "", string isOriginal = "")
        {
            Qiniu.IO.PutRet ret = QiniuHelper.UploadFile(fileData, "", uploadDir, isOriginal);
            if (ret != null && ret.StatusCode == HttpStatusCode.OK)
            {
                QiniuFile newFile = new QiniuFile()
                {
                    FileKey = ret.key,
                    Hash = ret.Hash,
                    FSize = fileData.ContentLength,
                    Mime = "application/file",
                    PutTime = DateTime.Now,
                    CreatedById = LoginId
                };
                Contract.Add(newFile);
            }

            return Json(ret);
        }


.NET MVC页面使用 uploadify进行文件上传(uploadify插件我就不详细说了，这里是简单说下使用方法，说太多了就没研究价值了 )：

@model ypsuit.model.QiniuFile
@using System.Web.Mvc
@using System.Web.Mvc.Html
@using ypsuit.common
@{
    string QiniuUrl = CommonFun.GetConfigData(DataConfigKey.QiniuUrl.ToString());
    Layout = null;

}

@using (Ajax.BeginForm("UploadFile", "QiniuFile", new AjaxOptions { HttpMethod = "POST", OnSuccess = "editSuccess" }, new { @class = "form-horizontal", id = "form-create" }))
{
    <div class="modal-content">
        <div class="modal-header">
            <button type="button" class="close" data-dismiss="modal" aria-hidden="true"></button>
            <h4 class="modal-title">添加七牛文件</h4>
        </div>
        <div class="modal-body">
            <div class="form-group">
                <label class="control-label col-md-3" for="uploadDir">上传目录</label>
                <span style="color:red"></span>
                <div class="col-md-8">
                    <input type="text" id="uploadDir" value="" placeholder="不填自动选择目录" />
                    <input type="checkbox" value="1" name="isOriginal" id="isOriginal" checked="checked" />保留原名
                </div>
            </div>
            <div class="form-group">
                <label class="control-label col-md-3" for="file_upload_list">文件(可多选)</label>
                <span style="color:red"></span>
                <div class="col-md-8">
                    <input type="button" id="file_upload_list" value="请选择文件" />
                </div>
            </div>
            <div class="form-group">
                <label class="control-label col-md-3" for="file_upload_list">提示：</label>
                <span style="color:red"></span>
                <div class="col-md-8">
                    上传成功后，随时可点击 从七牛服务器更新 获取最新的文件信息
                </div>
                
            </div>


        </div>
        <div class="modal-footer">
            <button type="button" class="btn btn-default" data-dismiss="modal" id="btnClose">关闭窗口</button>
        </div>
    </div>
}
<script src="/Assets/plugins/uploadify-v3.1/jquery.uploadify-3.1.min.js"></script>
<link href="@(QiniuUrl)/Assets/plugins/uploadify-v3.1/uploadify.css" rel="stylesheet" />
<script type="text/javascript">
    $(function () {
        $('#file_upload_list').uploadify({
            'auto': true,
            'buttonText': '请选择上传文件',
            'fileTypeDesc': '静态文件',
            'fileTypeExts': '*.gif; *.jpg; *.png; *.bmp; *.jpeg; *.tif;*.js;*.txt;*.mp3;',
            'swf': "/assets/plugins/uploadify-v3.1/uploadify.swf?a=23",
            'uploader': '/Admin/QiniuFile/UploadFile',
            'multi': true,
            'onUploadStart': function (file) {
                $("#file_upload_list").uploadify("settings", 'formData', {
                    uploadDir: $("#uploadDir").val(),
                    isOriginal: $("#isOriginal").is(":checked")?"1":"0"
                });
            },
            'onUploadSuccess': function (file, data, response) {

            }
        });
    })
</script>



最后出一张页面图：




附：

七牛开发文档中心：http://developer.qiniu.com/docs/v6/index.html

如果大家觉得不错，注册一个，我能得到点好处。

推荐注册地址： https://portal.qiniu.com/signup?code=3lqg1obz73y36


认证成为标准用户后，有很大好处，个人网站一般用不完：




文章标签：
API
数据安全/隐私保护
前端开发
JavaScript
计算机视觉
数据格式
存储
JSON
关键词：
API封装
API文件
.NET类
API类
.NET封装
真爱无限
目录
相关文章
技术交流18179014480
|
15天前
|
缓存 前端开发 API
API接口封装系列
API（Application Programming Interface）接口封装是将系统内部的功能封装成可复用的程序接口并向外部提供，以便其他系统调用和使用这些功能，通过这种方式实现系统之间的通信和协作。下面将介绍API接口封装的一些关键步骤和注意事项。
技术交流18179014480
31 2
hsfxuebao
|
2月前
|
API
Poi 中文API文档 「40种操作 Excel文件的姿势」
Poi 中文API文档 「40种操作 Excel文件的姿势」
hsfxuebao
117 0
你都不懂
|
3月前
|
JavaScript API
【vue实战项目】通用管理系统：api封装、404页
【vue实战项目】通用管理系统：api封装、404页
你都不懂
37 3
柠檬叶子C
|
5月前
|
Unix 程序员 Linux
【OSTEP】动态内存开辟 | 内存API常见错误 | UNIX: brk/sbrk 系统调用 | mmap创建匿名映射区域 | mmap创建以文件为基础的映射区域
【OSTEP】动态内存开辟 | 内存API常见错误 | UNIX: brk/sbrk 系统调用 | mmap创建匿名映射区域 | mmap创建以文件为基础的映射区域
柠檬叶子C
175 0
尘觉
|
4月前
|
Java Unix 程序员
java 8 新特性讲解Optional类--Fork/Join 框架--新时间日期API--以及接口的新特性和注解
java 8 新特性讲解Optional类--Fork/Join 框架--新时间日期API--以及接口的新特性和注解
尘觉
62 1
小万哥丶
|
1月前
|
Java 数据库连接 API
Java 学习路线：基础知识、数据类型、条件语句、函数、循环、异常处理、数据结构、面向对象编程、包、文件和 API
Java 是一种广泛使用的、面向对象的编程语言，始于1995年，以其跨平台性、安全性和可靠性著称，应用于从移动设备到数据中心的各种场景。基础概念包括变量（如局部、实例和静态变量）、数据类型（原始和非原始）、条件语句（if、else、switch等）、函数、循环、异常处理、数据结构（如数组、链表）和面向对象编程（类、接口、继承等）。深入学习还包括包、内存管理、集合框架、序列化、网络套接字、泛型、流、JVM、垃圾回收和线程。构建工具如Gradle、Maven和Ant简化了开发流程，Web框架如Spring和Spring Boot支持Web应用开发。ORM工具如JPA、Hibernate处理对象与数
小万哥丶
92 3
hhzz
|
1月前
|
前端开发 API 数据处理
uni-app 封装api请求
uni-app 封装api请求
hhzz
14 0
三分钟热度的鱼
|
1月前
|
分布式计算 DataWorks 大数据
DataWorks常见问题之使用API删除之前的部署文件失败如何解决
DataWorks是阿里云提供的一站式大数据开发与管理平台，支持数据集成、数据开发、数据治理等功能；在本汇总中，我们梳理了DataWorks产品在使用过程中经常遇到的问题及解答，以助用户在数据处理和分析工作中提高效率，降低难度。
三分钟热度的鱼
22 0
技术交流13627902019
|
2月前
|
缓存 监控 测试技术
ERP系统对接方案与API接口封装系列（高并发）
企业资源规划（ERP）系统是现代企业管理的核心，它集成了企业内部的各个部门和业务流程。为了实现ERP系统与其他外部系统或应用程序之间的数据交换和协作，需要对接方案。API（应用程序编程接口）是实现系统对接的常用方法之一。
技术交流13627902019
133 2
左边的天堂
|
2月前
|
API
使用commons-io-2.0 API来实现监听文件变化
使用commons-io-2.0 API来实现监听文件变化
左边的天堂
48 0

热门文章

最新文章

  • 1
    C#/.NET/.NET Core优秀项目和框架2024年3月简报
  • 2
    【干货】Java开发者快速上手.NET指南
  • 3
    MQTT常见问题之调用.net sdk 报“不知道这样的主机”如何解决
  • 4
    .NET智慧手术室管理平台源码
  • 5
    r语言中对LASSO回归，Ridge岭回归和弹性网络Elastic Net模型实现-4
  • 6
    .NET开源、免费、强大的交互式绘图库
  • 7
    .NET开源免费、功能强大的 Windows 截图录屏神器
  • 8
    对象存储oss使用问题之OSS SDK .net 使用下载例程报错如何解决
  • 9
    .NET开源、免费、跨平台的Git可视化管理工具
  • 10
    .NET开源免费的Windows快速文件搜索和应用程序启动器
  • 1
    IMAP邮箱API接收收取邮件的方法和步骤
    11
  • 2
    SMTP邮件邮箱API发送邮件的方法和步骤
    5
  • 3
    [NDK/JNI系列04] JNI接口方法表、基础API与异常API
    11
  • 4
    Relay邮件邮箱API发送邮件的方法和步骤
    15
  • 5
    ZooKeeper【基础 03】Java 客户端 Apache Curator 基础 API 使用举例（含源代码）
    23
  • 6
    使用Go语言通过API获取代理IP并使用获取到的代理IP
    19
  • 7
    第7章 Spring Security 的 REST API 与微服务安全（2024 最新版）（上）
    24
  • 8
    快速淘宝商品详情页面API接口传输 php
    9
  • 9
    SendCloud和Aoksend邮箱API发送邮件的方法
    13
  • 10
    java借助代理ip，解决访问api频繁导致ip被禁的问题
    26

    • 相关课程

    更多
  • 体验-K8S API 基础及Pod 基本应用

    • 相关电子书

    更多
  • CUDA MATH API
  • API PLAYBOOK
  • 传统企业的“+互联网”-API服务在京东方的实践

    • 相关实验场景

    更多
  • 快速体验智能体API应用
  • Elasticsearch Java API Client 开发
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）