思享工具箱

通过jQuery和C#分别实现对.NET Core Web Api的访问以及文件上传

摘要：
.身份证？？
建立.NET Core Web Api项目

建立请求模型

    public class UserInfo
    {
        public int Age { get; set; }
        public string Name { get; set; }
        public bool Sex { get; set; }
        public Guid Id { get; set; }
    }

建立控制器

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
​
namespace AspNetCore.Api.Controllers
{
    [Route("api/[controller]/[action]")]
    [ApiController]
    public class DefaultController : ControllerBase
    {
        /// <summary>
        /// 用户信息
        /// </summary>
        public static UserInfo UserInfo = new UserInfo
        {
            Id = Guid.NewGuid(),
            Age = 23,
            Name = "Jon",
            Sex = true
        };
​
        [HttpGet]
        public IActionResult Test()
        {
            return new JsonResult("OK");
        }
​
        /// <summary>
        /// API GET
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public ActionResult<UserInfo> GetUser([FromBody]UserInfo user)
        {
            return new JsonResult(user);
        }
​
        /// <summary>
        /// API POST
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public ActionResult<UserInfo> Upload()
        {
            var files = Request.Form.Files;
            return new JsonResult($"Read {string.Join(Environment.NewLine,files.Select(x=>x.FileName))} Success !");
        }
    }
}

建立.NET Core Web项目

建立控制器

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using AspNetCore.Web.Models;
using Microsoft.Extensions.Caching.Memory;
using System.IO;
using Microsoft.AspNetCore.Http;
using System.Threading;
using System.Net.Http;
using System.Net;
​
namespace AspNetCore.Web.Controllers
{
    public class HomeController : Controller
    {
        private readonly ILogger<HomeController> _logger;
        private readonly IMemoryCache _cache;
        public HomeController(ILogger<HomeController> logger, IMemoryCache cache)
        {
            _logger = logger;
            _cache = cache;
        }
​
        public IActionResult Index()
        {
            return View();
        }
​
        public IActionResult Privacy()
        {
            return View();
        }
​
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public IActionResult Error()
        {
            return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
        }
​
        /// <summary>
        /// 上传文件
        /// </summary>
        /// <returns></returns>
        [RequestSizeLimit(1_073_741_824)]
        public IActionResult Upload()
        {
            var url = "http://localhost:9001/Api/Default/Upload";
​
            var data = new MultipartFormDataContent();
            if (Request.HasFormContentType)
            {
                var request = Request.Form.Files;
                foreach (var item in request)
                {
                    data.Add(new StreamContent(item.OpenReadStream()), item.Name, item.FileName);
                }
​
                foreach (var item in Request.Form)
                {
                    data.Add(new StringContent(item.Value), item.Key);
                }
            }
            string jsonString = string.Empty;
            using (var client = new HttpClient(new HttpClientHandler() { AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip }))
            {
                var taskResponse = client.PostAsync(url, data);
                taskResponse.Wait();
                if (taskResponse.IsCompletedSuccessfully)
                {
                    var taskStream = taskResponse.Result.Content.ReadAsStreamAsync();
                    taskStream.Wait();
                    using (var reader = new StreamReader(taskStream.Result))
                    {
                        jsonString = reader.ReadToEnd();
                    }
                }
            }
            return new JsonResult(jsonString);
        }
​
        /// <summary>
        /// 保存文件
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [RequestSizeLimit(1_073_741_824)]
        public async Task<IActionResult> Save()
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            var form = await Request.ReadFormAsync();
            int saveCount = 0;
            long totalCount = form.Files.Sum(x => x.Length);
            foreach (var item in form.Files)
            {
                var fileSavePath = Environment.CurrentDirectory + "\Files\" + item.Name;
                using (FileStream fs = new FileStream(fileSavePath, FileMode.Create))
                {
                    using (BinaryWriter bw = new BinaryWriter(fs))
                    {
                        using (BinaryReader br = new BinaryReader(item.OpenReadStream()))
                        {
                            var customReadLength = item.Length;
                            byte[] buffer = new byte[customReadLength];
                            int readCount = 0;
                            while ((readCount = br.Read(buffer, 0, buffer.Length)) > 0)
                            {
                                bw.Write(buffer, 0, readCount);
                                saveCount += readCount;
                                var progress = (saveCount * 1.0 / totalCount).ToString("0.00");
                                _cache.Set<string>("UploadSpeed", progress, DateTimeOffset.Now.AddMinutes(60));
                                Thread.Sleep(1000);
                            }
                        }
                    }
                }
            }
            sw.Stop();
            return new JsonResult($"Read {string.Join(Environment.NewLine, Request.Form.Files.Select(x => x.FileName))} Success !耗时：{sw.ElapsedMilliseconds}");
        }
​
        /// <summary>
        /// 读取进度
        /// </summary>
        /// <returns></returns>
        public IActionResult UploadProgress()
        {
            var progress = _cache.Get<string>("UploadSpeed");
            return Json(progress);
        }
    }
}
​
目录结构

通过jQuery和C#分别实现对.NET Core Web Api的访问以及文件上传第1张

设置解决方案为多个项目启动

通过jQuery和C#分别实现对.NET Core Web Api的访问以及文件上传第2张

一、使用jQuery Ajax访问

（一）、表单传参( [FromForm])

数据类型：Object

ContenyType类型：application/x-www-form-urlencoded

 var model = { name: "刘大大", age: 23, sex: true };

前台请求

        var model = { name: "刘大大", age: 23, sex: true };       
        $.ajax({
            url: "http://localhost:9001/API/Default/FormCall",
            type: "POST",
            async: true,
            dataType: "json",
            data: model,
            contentType: "application/x-www-form-urlencoded",
            success: function (data) {
                console.log("data:");
                console.log(data);
            }
        });

(二）、JSON字符串[FromBdy]

数据类型：Json

ContenyType类型：application/json

   var json = '{"name":"刘大大","age":23,"sex":true}';

也可以使用JSON.stringify(Object)将Object转换为JSON字符串

前端请求

        var model = { name: "刘大大", age: 23, sex: true };       
        $.ajax({
            url: "http://localhost:9001/API/Default/BodyCall",
            type: "POST",
            async: true,
            dataType: "json",
            data: JSON.stringify(model),
            contentType: "application/json",
            success: function (data) {
                console.log("data:");
                console.log(data);
            }
        });

（三）、文件上传

建立FormData对象

数据类型：FromData

ContenyType类型false, //必须false才会避开jQuery对 formdata 的默认处理processData类型: false, //必须false才会自动加上正确的Content-Type

html

 <input type="file" multiple   />

JS获取文件对象

        var file = document.getElementById("file");
        var files = file.files;
        var formData = new FormData();
        for (var i = 0; i < files.length; i++) {
            formData.append(files[i].name, files[i]);
        }　　　　
       formData.append("name", "刘大大");//可追加参数

AJAX请求

 $.ajax({
            url: "http://localhost:9001/API/Default/Upload",
            type: "POST",
            async: true,
            dataType: "json",
            data: formData,
            contentType: false, 
            processData: false,
            success: function (data) {
                console.log(data);
            }
        });

完整HTML源码

<div class="text-center">
    <h1 class="display-4">Welcome</h1>
    <p>Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
</div>
<div>
    <input type="button"   value="Form传参" /><hr />
    <input type="button"   value="Body传参" /><hr />
    <input type="file" multiple   name="上传文件" /><hr />
</div>
<script src="https://cdn.bootcss.com/jquery/3.3.0/jquery.js"></script>
<script>

    /**
     * FromForm
     * */
    var fromform = document.getElementById("fromform");
    $(fromform).click(function () {
        var url = 'http://localhost:9001/API/Default/FormCall';
        var model = { name: "刘大大", age: 23, sex: true };
        $.ajax({
            url: url,
            type: "POST",
            async: true,
            data: model,
            contentType: "application/x-www-form-urlencoded",
            success: function (data) {
                console.log(data);
                alert(JSON.stringify(data));
            },
            error: function (result) {
                console.log(result);
            }
        });
    });

    /**
     * FromBody
     * */
    $('#frombody').click(function () {
        var url = 'http://localhost:9001/API/Default/BodyCall';
        var json = '{"name":"刘大大","age":23,"sex":true}';
        $.ajax({
            url: url,
            type: "POST",
            async: true,
            data: json,
            contentType: "application/json",
            success: function (data) {
                console.log(data);
                alert(JSON.stringify(data));
            },
            error: function (result) {
                console.log(result);
            }
        });
    });

    /**
     * FormData
     * */
    var file = document.getElementById("file");
    file.onchange = function () {
        var file = document.getElementById("file");
        var files = file.files;
        var formData = new FormData();
        for (var i = 0; i < files.length; i++) {
            formData.append(files[i].name, files[i]);
        }
        formData.append("name", "刘大大");
        var isUploadByJs = true;
        var url = isUploadByJs ? 'http://localhost:9001/API/Default/Upload' : 'http://localhost:9002/Home/Upload';
        $.ajax({
            url: url,
            type: "POST",
            async: true,
            dataType: "json",
            data: formData,
            contentType: false, //必须false才会避开jQuery对 formdata 的默认处理
            processData: false, //必须false才会自动加上正确的Content-Type
            headers: { ReadTime: Date.now() },
            beforeSend: function (xhr) {
                xhr.setRequestHeader('Author', 'liudada');
            },
            success: function (data) {
                console.log(data);
                alert(JSON.stringify(data));
            },
            error: function (result) {
                console.log(result);
            }
        });
    }
</script>　　
二、使用C#后台访问

（一）、Get访问

 var url = "http://localhost:57954/API/Default/Test";
using (var client = new HttpClient(new HttpClientHandler() { AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip }))
{
var taskResponse = client.GetAsync(url);
taskResponse.Wait();
if (taskResponse.IsCompletedSuccessfully)
{
var taskStream = taskResponse.Result.Content.ReadAsStreamAsync();
taskStream.Wait();
using (var reader = new StreamReader(taskStream.Result))
{
jsonString = reader.ReadToEnd();
}
}
}

（二）、Post访问

            var url = "http://localhost:57954/API/Default/BodyCall";            
            var data = new {name="刘大大",age=23,sex=true };
            using (var client = new HttpClient(new HttpClientHandler() { AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip }))
            {
                var jsonToSend = JsonConvert.SerializeObject(data, Formatting.None, new IsoDateTimeConverter());
                var body = new StringContent(jsonToSend, Encoding.UTF8, "application/json");
                var taskResponse = client.PostAsync(url, body);
                taskResponse.Wait();
                if (taskResponse.IsCompletedSuccessfully)
                {
                    var taskStream = taskResponse.Result.Content.ReadAsStreamAsync();
                    taskStream.Wait();
                    using (var reader = new StreamReader(taskStream.Result))
                    {
                        jsonString = reader.ReadToEnd();
                    }
                }
            }

（三）、上传文件

/// <summary>
    /// 上传文件
    /// </summary>
    /// <returns></returns>
    [RequestSizeLimit(1_073_741_824)]
    public IActionResult Upload()
    {
        var url = "http://localhost:9001/Api/Default/Upload";
​
        var data = new MultipartFormDataContent();
        if (Request.HasFormContentType)
        {
            var request = Request.Form.Files;
            foreach (var item in request)
            {
                data.Add(new StreamContent(item.OpenReadStream()), item.Name, item.FileName);
            }
​
            foreach (var item in Request.Form)
            {
                data.Add(new StringContent(item.Value), item.Key);
            }
        }
        string jsonString = string.Empty;
        using (var client = new HttpClient(new HttpClientHandler() { AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip }))
        {
            var taskResponse = client.PostAsync(url, data);
            taskResponse.Wait();
            if (taskResponse.IsCompletedSuccessfully)
            {
                var taskStream = taskResponse.Result.Content.ReadAsStreamAsync();
                taskStream.Wait();
                using (var reader = new StreamReader(taskStream.Result))
                {
                    jsonString = reader.ReadToEnd();
                }
            }
        }
        return new JsonResult(jsonString);
    }

WebHelper

这里包含了WebRequest和HttpClient两种请求方式，以及包含了将Object对象序列化为HttpCotnent对象的方法。

/***************************************************************************************************************************************************
 * *文件名：WebHelper.cs
 * *创建人：Jon
 * *日 期 ：2018年5月25日
 * *描 述 ：实现HTTP协议中的GET、POST请求
 * *MVC使用HttpClient上传文件实例：      
        public IActionResult Upload()
        {

            var url = "http://localhost:57954/API/Default/values";
            var data = new MultipartFormDataContent();
            if (Request.HasFormContentType)
            {
                var request = Request.Form.Files;
                foreach (var item in request)
                {
                    data.Add(new StreamContent(item.OpenReadStream()), item.Name, item.FileName);
                }

                foreach (var item in Request.Form)
                {
                    data.Add(new StringContent(item.Value), item.Key);
                }
            }
            WebHelper.PostByHttpClientFromHttpContent(url, data);
            return Json("OK");
        }
*****************************************************************************************************************************************************/using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;

namespace Expansion.Helper
{
    public static class WebHelper
    {
        /// <summary>
        /// 通过WebRequest发起Get请求
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <returns>JSON字符串</returns>
public static string GetByWebRequest(string url)
        {
            string jsonString =string.Empty;
            var request =(HttpWebRequest)WebRequest.Create(url);
            request.Method = "GET";
            request.ContentType = "application/json";
            request.AutomaticDecompression = DecompressionMethods.Deflate |DecompressionMethods.GZip;
            var response =(HttpWebResponse)request.GetResponse();
            using (var stream = newStreamReader(response.GetResponseStream()))
            {
                jsonString =stream.ReadToEnd();
            }
            returnjsonString;
        }

        /// <summary>
        /// 通过WebRequest发起Post请求
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="data">请求参数</param>
        /// <returns>JSON字符串</returns>
public static string PostByWebRequest(string url, object data)
        {
            string jsonString =string.Empty;
            var request =(HttpWebRequest)WebRequest.Create(url);
            request.ContentType = "application/json";
            request.Method = "POST";
            request.Timeout =Int32.MaxValue;
            request.AutomaticDecompression = DecompressionMethods.Deflate |DecompressionMethods.GZip;
            var jsonToSend = JsonConvert.SerializeObject(data, Formatting.None, newIsoDateTimeConverter());
            byte[] btBodys =Encoding.UTF8.GetBytes(jsonToSend);
            request.ContentLength =btBodys.Length;
            request.GetRequestStream().Write(btBodys, 0, btBodys.Length);
            var response =(HttpWebResponse)request.GetResponse();
            using (var stream = newStreamReader(response.GetResponseStream()))
            {
                jsonString =stream.ReadToEnd();
            }
            returnjsonString;
        }


        /// <summary>
        /// 通过HttpClient发起Get请求
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <returns>JSON字符串</returns>
public static string GetByHttpClient(string url)
        {
            string jsonString =string.Empty;
            using (var client = new HttpClient(new HttpClientHandler() { AutomaticDecompression = DecompressionMethods.Deflate |DecompressionMethods.GZip }))
            {
                var taskResponse =client.GetAsync(url);
                taskResponse.Wait();
                if(taskResponse.IsCompletedSuccessfully)
                {
                    var taskStream =taskResponse.Result.Content.ReadAsStreamAsync();
                    taskStream.Wait();
                    using (var reader = newStreamReader(taskStream.Result))
                    {
                        jsonString =reader.ReadToEnd();
                    }
                }
            }
            returnjsonString;
        }

        /// <summary>
        /// 通过HttpClient发起Post请求
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="data">请求参数</param>
        /// <returns>JSON字符串</returns>
public static string PostByHttpClient(string url, object data)
        {
            string jsonString =string.Empty;
            using (var client = new HttpClient(new HttpClientHandler() { AutomaticDecompression = DecompressionMethods.Deflate |DecompressionMethods.GZip }))
            {
                var jsonToSend = JsonConvert.SerializeObject(data, Formatting.None, newIsoDateTimeConverter());
                var body = new StringContent(jsonToSend, Encoding.UTF8, "application/json");
                var taskResponse =client.PostAsync(url, body);
                taskResponse.Wait();
                if(taskResponse.IsCompletedSuccessfully)
                {
                    var taskStream =taskResponse.Result.Content.ReadAsStreamAsync();
                    taskStream.Wait();
                    using (var reader = newStreamReader(taskStream.Result))
                    {
                        jsonString =reader.ReadToEnd();
                    }
                }
            }
            returnjsonString;
        }

        /// <summary>
        /// 通过数据来自HttpContent的HttpClient发起Post请求
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="content">请求参数</param>
        /// <returns>JSON字符串</returns>
public static string PostByHttpClientFromHttpContent(string url, HttpContent content)
        {
            string jsonString =string.Empty;
            using (var client = new HttpClient(new HttpClientHandler() { AutomaticDecompression = DecompressionMethods.Deflate |DecompressionMethods.GZip }))
            {
                var taskResponse =client.PostAsync(url, content);
                taskResponse.Wait();
                if(taskResponse.IsCompletedSuccessfully)
                {
                    var taskStream =taskResponse.Result.Content.ReadAsStreamAsync();
                    taskStream.Wait();
                    using (var reader = newStreamReader(taskStream.Result))
                    {
                        jsonString =reader.ReadToEnd();
                    }
                }
            }
            returnjsonString;
        }

        /// <summary>
        /// Object转换为StreamContent
        /// </summary>
        /// <param name="data">请求参数</param>
        /// <returns>StreamContent</returns>
        public static HttpContent ToStreamContent(thisobject data)
        {

            var json = JsonConvert.SerializeObject(data, Formatting.None, newIsoDateTimeConverter());
            byte[] bytes =Encoding.UTF8.GetBytes(json);
            MemoryStream ms = newMemoryStream();
            ms.Write(bytes, 0, bytes.Length);
            ms.Position = 0;
            HttpContent streamContent = newStreamContent(ms);
            returnstreamContent;
        }

        /// <summary>
        /// Object转换为StringContent
        /// </summary>
        /// <param name="data">请求参数</param>
        /// <returns>StringContent</returns>
        public static HttpContent ToStringContent(thisobject data)
        {
            HttpContent stringContent = newStringContent(JsonConvert.SerializeObject(data));
            returnstringContent;
        }

        /// <summary>
        /// Object转换为MultipartFormDataContent
        /// </summary>
        /// <param name="data"></param>
        /// <returns>MultipartFormDataContent</returns>
        public static HttpContent ToMultipartFormDataContent(thisobject data)
        {
            var json = JsonConvert.SerializeObject(data, Formatting.None, newIsoDateTimeConverter());
            var body = new StringContent(json, Encoding.UTF8, "application/json");
            var multipartFormDataContent = newMultipartFormDataContent();
            multipartFormDataContent.Add(body);
            returnmultipartFormDataContent;
        }

        /// <summary>
        /// Object转换为FormUrlEncodedContent
        /// </summary>
        /// <param name="data">请求参数</param>
        /// <returns>FormUrlEncodedContent</returns>
        public static HttpContent ToFormUrlEncodedContent(thisobject data)
        {
            var param = new List<KeyValuePair<string, string>>();
            var values =JObject.FromObject(data);
            foreach (var item invalues)
            {
                param.Add(new KeyValuePair<string, string>(item.Key, item.Value.ToString()));
            }
            HttpContent formUrlEncodedContent = newFormUrlEncodedContent(param);
            returnformUrlEncodedContent;
        }


        /// <summary>
        /// Object转换为ByteArrayContent
        /// </summary>
        /// <param name="data">请求参数</param>
        /// <returns>FormUrlEncodedContent</returns>
        public static HttpContent ToByteArrayContent(thisobject data)
        {
            var json = JsonConvert.SerializeObject(data, Formatting.None, newIsoDateTimeConverter());
            byte[] bytes =Encoding.UTF8.GetBytes(json);
            HttpContent byteArrayContent = newByteArrayContent(bytes);
            returnbyteArrayContent;
        }

        /// <summary>
        /// Url编码
        /// </summary>
        /// <param name="content">内容</param>
        /// <param name="encode">编码类型</param>
        /// <returns></returns>
        private static string Encode(string content, Encoding encode = null)
        {
            if (encode == null) returncontent;

            returnSystem.Web.HttpUtility.UrlEncode(content, Encoding.UTF8);

        }


        /// <summary>
        /// Url解码
        /// </summary>
        /// <param name="content">内容</param>
        /// <param name="encode">编码类型</param>
        /// <returns></returns>
        private static string Decode(string content, Encoding encode = null)
        {
            if (encode == null) returncontent;

            returnSystem.Web.HttpUtility.UrlDecode(content, Encoding.UTF8);

        }

        /// <summary>
        /// 将键值对参数集合拼接为Url字符串
        /// </summary>
        /// <param name="paramArray">键值对集合</param>
        /// <param name="encode">转码类型</param>
        /// <returns></returns>
        private static string BuildParam(List<KeyValuePair<string, string>> paramArray, Encoding encode = null)
        {
            string url = "";

            if (encode == null) encode =Encoding.UTF8;

            if (paramArray != null && paramArray.Count > 0)
            {
                var parms = "";
                foreach (var item inparamArray)
                {
                    parms += string.Format("{0}={1}&", Encode(item.Key, encode), Encode(item.Value, encode));
                }
                if (parms != "")
                {
                    parms = parms.TrimEnd('&');
                }
                url +=parms;

            }
            returnurl;
        }
    }
}
View Code

时间仓促，没能说的太详细，有时间再做补充。如本文中的有错误示范，欢迎指正

源码地址：https://github.com/lwc1st/AspNetCore.UploadDemo.git

标签：#js获取url参数#data#string#url#formdata#httpclient#jquery#var#encode#content | 浏览：524 | 发布日期：

免责声明：文章转载自《通过jQuery和C#分别实现对.NET Core Web Api的访问以及文件上传》仅用于学习参考。如对内容有疑问，请及时联系本站处理。

上篇关于iframe中的js跨站快速搭建Hadoop及HBase分布式环境下篇

宿迁高防，2C2G15M，22元/月；香港BGP，2C5G5M，25元/月 雨云优惠码：MjYwNzM=

相关文章

Asp.net mvc与PHP的Session共享的实现

最近在做的一个ASP.NET MVC的项目，要用到第三方的php系统，为了实现两个系统的互联互通。决定将两者的session打通共享。让asp.net mvc 和php 都能正常访问和修改Session内容。 在决定实现之前，先搜索了一下院子里有没有相类似的文章，对于跨语言的程序互通，有两种方案： （1） SSO单点登录，其实就是把用户名和密码传给另一个系...

PHP单点登陆

本文主要介绍了利用webservice,session,cookie技术，来进行通用的单点登录系统的分析与设计。具体实现语言为PHP。单点 登录，英文名为Single Sign On，简称为 SSO，是目前企业，网络业务的用户综合处理的重要组成部分。而SSO的定义，是在多个应用系统中，用户只需要登陆一次就可以访问所有相互信任的应用系 统。 动机： 用过uc...

jquery datatable 参数

DataTables(http://www.datatables.net/)应该是我到目前为止见过的，功能最强大的表格解决方案（当然，不计算其它整套框架中的table控件在内）。 先把它主页上写的特性翻译罗列如下： 可变长度分页；动态过滤；多列排序，带数据类型检测功能；列宽度的智能处理；从多种数据源获取数据（DOM，js Array, ajax file,...

jmeter：BeanShell 预处理程序（引用java脚本，实现参数化）

这里以为本地的注册接口为例子： 如图：这个注册接口需要传2个参数，用户名和密码，用户名是唯一的，密码可以一样，需要对用户名进行参数化。 首先在jmeter里面添加BeanShell 预处理程序，如图： 这里需要编写java代码，对用户名实现参数化： 调试好以后，运行效果如图： 代码如下： package com.mg.java.study; imp...

Auto Mapper02《demo》

学习这些基本上网上都有一些教程或者别人做的demo，我是按照这个方式去学习的。先做个demo，学会如何去使用它，接着去慢慢的了解它是如何的运行的，理解里面的一些基本的基础知识。我们不可以再像学校里面的那样，先去学习基本的结构，那样我们会很烦脑的，我们应该先学会使用它，接着再去慢慢的了解。 “高内聚低耦合，尽量依赖抽象而不依赖于具体”，这个在面向对象的开发中...

go语言——实现函数名到函数处理的映射关系（反射的应用）

模拟这样一个场景：当我们知道我们要执行操作的名字，让其作为参数传入，如何通过这个名字取执行相应的函数处理呢？ 解决方法：(这里设定一个结构A，其变量a，实现相应函数为fun1、fun2) 　　①：首先在编码过程中，我们可以将相应的处理函数进行“同一结构”实现，让其函数名和相应处理函数用map结构形成映射； 　　②：通过创建该结构体的变量，通过反射（vf :...

最新文章

随机推荐

思享工具箱导航