接口自定义代理V2—用户权限验证、加密、解密

基于接口自定义代理V1做了升级，加入了用户权限验证、加密、解密

封装端代码：

 /// <summary>
    /// 接口基类（升级版）
    /// </summary>
    public class BaseApiController : ApiController
    {
        #region 代理执行

        /// <summary>
        /// 代理执行
        /// </summary>
        /// <typeparam name="T">请求参数类型</typeparam>
        /// <typeparam name="R">返回参数类型</typeparam>
        /// <param name="func">执行都方法</param>
        /// <param name="request">请求参数</param>
        /// <returns></returns>
        protected ResultMessage<R> ProxyExecute<T, R>(Func<T, ResultMessage<R>> func, T request)
        {
            var result = Activator.CreateInstance<ResultMessage<R>>();
            var logStr = new StringBuilder();
            try
            {
                logStr.AppendFormat("请求参数：{0}", JsonConvert.SerializeObject(request)); // 记录请求日志

                //参数验证
                request = ValidateHelper.ValidateParameter(request);

                //方法执行
                result = func(request);

                logStr.AppendFormat("返回参数：{0}", JsonConvert.SerializeObject(result)); // 记录返回日志
            }
            catch (Exception ex)
            {
                result.ResultCode = ResultCodeEnum.Exception.GetHashCode();
                result.ResultMsg = ex.Message;

                logStr.AppendFormat("异常信息：{0}", ex.Message); // 记录异常日志
            }
            finally
            {
                //记录日志
                //WriteLog(logStr.ToString();) 
            }
            return result;
        }

        #endregion

        #region 代理执行带权限验证

        /// <summary>
        /// 代理执行带权限验证
        /// </summary>
        /// <typeparam name="T">请求参数类型</typeparam>
        /// <typeparam name="R">返回参数类型</typeparam>
        /// <param name="func">执行都方法</param>
        /// <param name="request">请求参数</param>
        /// <returns></returns>
        protected ResultMessage<R> ProxyExecuteWithAuth<T, R>(Func<T, ResultMessage<R>> func, T request)
            where T : BaseRequest
        {
            var result = Activator.CreateInstance<ResultMessage<R>>();
            var logStr = new StringBuilder();
            try
            {
                logStr.AppendFormat("请求参数：{0}", JsonConvert.SerializeObject(request)); // 记录请求日志

                //参数验证
                request.LoginId = AuthService.Validate(request);

                //方法执行
                result = ProxyExecute(func, request);
            }
            catch (Exception ex)
            {
                result.ResultCode = ResultCodeEnum.Exception.GetHashCode();
                result.ResultMsg = ex.Message;

                logStr.AppendFormat("异常信息：{0}", ex.Message); // 记录异常日志
            }
            finally
            {
                //记录日志
                //WriteLog(logStr.ToString();) 
            }
            return result;
        }

        #endregion

        #region 代理执行--请求参数需要解密执行

        /// <summary>
        /// 代理执行--请求参数需要解密执行
        /// </summary>
        /// <typeparam name="T">请求参数类型</typeparam>
        /// <typeparam name="R">返回参数类型</typeparam>
        /// <param name="func">执行都方法</param>
        /// <param name="request">请求参数</param>
        /// <returns></returns>
        protected ResultMessage<R> ProxyExecuteWithDecrypt<T, R>(Func<T, ResultMessage<R>> func, DecryptRequest request)
          where T : BaseRequest
        {
            var result = Activator.CreateInstance<ResultMessage<R>>();
            var logStr = new StringBuilder();
            try
            {
                logStr.AppendFormat("请求参数：{0}", JsonConvert.SerializeObject(request)); // 记录请求日志

                var requestData = EncryptToObject.DPAESDecrypt(request.Data);
                var req = JsonConvert.DeserializeObject<T>(requestData);

                //方法执行
                result = ProxyExecuteWithAuth(func, req);
            }
            catch (Exception ex)
            {
                result.ResultCode = ResultCodeEnum.Exception.GetHashCode();
                result.ResultMsg = ex.Message;

                logStr.AppendFormat("异常信息：{0}", ex.Message); // 记录异常日志
            }
            finally
            {
                //记录日志
                //WriteLog(logStr.ToString();) 
            }

            return result;
        }

        #endregion

        #region 代理执行--返回结果加密

        /// <summary>
        /// 代理执行--返回结果加密
        /// </summary>
        /// <typeparam name="T">请求参数类型</typeparam>
        /// <typeparam name="R">返回参数类型</typeparam>
        /// <param name="func">执行都方法</param>
        /// <param name="request">请求参数</param>
        /// <returns></returns>
        protected EncryptResponse ProxyExecuteForEncrypt<T, R>(Func<T, ResultMessage<R>> func, T request)
            where T : BaseRequest
        {
            var result = new EncryptResponse();
            var logStr = new StringBuilder();
            var myResult = Activator.CreateInstance<ResultMessage<R>>();
            try
            {
                myResult = ProxyExecuteWithAuth(func, request);
            }
            catch (Exception ex)
            {
                myResult.ResultCode = ResultCodeEnum.Exception.GetHashCode();
                myResult.ResultMsg = ex.Message;

                logStr.AppendFormat("异常信息：{0}", ex.Message); // 记录异常日志
            }
            finally
            {
                result.Data = EncryptToObject.DPAESEncrypt(myResult);
                //记录日志
                //WriteLog(logStr.ToString();) 
            }
            return result;
        }

        #endregion
    }

调用端代码：

/// <summary>
    /// 接口案例
    /// </summary>
    public class DemoController : BaseApiController
    {
        private StudentService StuService => new StudentService();

        /// <summary>
        /// 获取用户姓名(普通执行)
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public ResultMessage<StudentEntity> GetStudent(FindStudentRequest request)
        {
            return ProxyExecute(StuService.GetStudent, request);
        }

        /// <summary>
        /// 获取用户姓名(需要权限认证)
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public ResultMessage<StudentEntity> GetStudentByAuth(FindStudentRequest request)
        {
            return ProxyExecuteWithAuth(StuService.GetStudent, request);
        }

        /// <summary>
        /// 获取用户姓名(请求加密)
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public ResultMessage<StudentEntity> GetStudentWithDecrypt(DecryptRequest request)
        {
            return ProxyExecuteWithDecrypt<FindStudentRequest, StudentEntity> (StuService.GetStudent, request);
        }
        
        /// <summary>
        /// 获取用户姓名(返回加密)
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public EncryptResponse GetStudentForEncrypt(FindStudentRequest request)
        {
            return ProxyExecuteForEncrypt(StuService.GetStudent, request);
        }
    }

项目源码：https://pan.baidu.com/s/1por-yp0ABInZRe8B67c4pQ    q9th

当前代理封装其实为升级版，里面加入了用户权限验证、加密、解密等，里面可以继续加入并发控制等，详情见接口自定义代理V3