首页 技术 正文

AOP缓存实现

技术 2022年11月16日
0 收藏 484 点赞 4,891 浏览 12777 个字

输入参数索引作为缓存键的实现

using MJD.Framework.CrossCutting;
using MJD.Framework.ICache;
using System;
using System.Collections.Generic;
using System.Linq;namespace MJD.Framework.Aop.Cache
{
    /// <summary>
    /// 方法的缓存属性(线性不安全)
    /// </summary>
    [AttributeUsage(AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public class CacheAttribute : AopAttribute
    {
        #region fields
        private short _index1 = -;
        private short _index2 = -;
        private short _index3 = -;
        #endregion        #region protected fields
        protected string Prefix = string.Empty;//缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀
        protected string Key = string.Empty;
        protected string BucketName = string.Empty;
        #endregion        #region Otors
        /// <summary>
        /// 定义缓存关键字来缓存
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        protected CacheAttribute(string bucketName, string prefix)
        {
            BucketName = bucketName;
            Prefix = prefix;
        }
        /// <summary>
        /// 定义缓存关键字来缓存
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="key">缓存键</param>
        public CacheAttribute(string bucketName, string prefix, string key)
            : this(bucketName, prefix)
        {
            if (string.IsNullOrEmpty(key)) throw new ArgumentException("缓存键不能为空");
            Key = string.Format("{0}:{1}", Prefix, key);
        }        /// <summary>
        /// 使用当前参数来缓存，索引位置从0开始
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="keyIndex">对应的当前参数的缓存键所在的参数索引位置</param>
        public CacheAttribute(string bucketName, string prefix, short keyIndex)
            : this(bucketName, prefix)
        {
            if (keyIndex < ) throw new ArgumentException("关键值的参数索引需大于0");
            _index1 = keyIndex;
        }        /// <summary>
        /// 使用多个当前参数来缓存，索引位置从0开始
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="keyIndex1">对应的当前参数的缓存键所在的参数索引位置1</param>
        /// <param name="keyIndex2">对应的当前参数的缓存键所在的参数索引位置2</param>
        public CacheAttribute(string bucketName, string prefix, short keyIndex1, short keyIndex2)
            : this(bucketName, prefix)
        {
            if (keyIndex1 <  || keyIndex2 < ) throw new ArgumentException("关键值的参数索引需大于0");
            _index1 = keyIndex1;
            _index2 = keyIndex2;
        }        /// <summary>
        /// 使用多个当前参数来缓存，索引位置从0开始
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="keyIndex1">对应的当前参数的缓存键所在的参数索引位置1</param>
        /// <param name="keyIndex2">对应的当前参数的缓存键所在的参数索引位置2</param>
        /// <param name="keyIndex3">对应的当前参数的缓存键所在的参数索引位置3</param>
        public CacheAttribute(string bucketName, string prefix, short keyIndex1, short keyIndex2, short keyIndex3)
            : this(bucketName, prefix)
        {
            if (keyIndex1 <  || keyIndex2 <  || keyIndex3 < ) throw new ArgumentException("关键值的参数索引不能小于零");
            _index1 = keyIndex1;
            _index2 = keyIndex2;
            _index3 = keyIndex3;
        }
        #endregion        #region override        public override object PreCall(object[] inputArgs, out object[] outputs)
        {
            outputs = new object[];            var result = IocContainer.Resolve<ICacheService>(BucketName).Get<object>(GetKey(inputArgs));
            return result.Success ? result.Value : null;
        }        public override void Called(object resultValue, object[] inputArgs, object[] outputs)
        {
            IocContainer.Resolve<ICacheService>(BucketName).Upsert<object>(GetKey(inputArgs), resultValue);
        }        public override void OnException(Exception e, Dictionary<string, object> inputArgs)
        {
        }        protected virtual string GetKey(object[] inputArgs)
        {
            if (string.IsNullOrEmpty(Key))
            {
                if (Math.Max(Math.Max(_index1, _index2), _index3) >= inputArgs.Count()) throw new ArgumentException("关键值的参数索引不能大于参数总个数");
                string prefix1 = _index1 >=  ? inputArgs[_index1].ToJson() : "";
                string prefix2 = _index2 >=  ? "-" + inputArgs[_index2].ToJson() : "";
                string prefix3 = _index3 >=  ? "-" + inputArgs[_index3].ToJson() : "";
                Key = string.Format("{0}:{1}{2}{3}",Prefix, prefix1, prefix2, prefix3);
            }
            return Key;
        }        #endregion
    }
}

输入参数是对象，通过输入参数对象的属性的值来作为缓存键

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;namespace MJD.Framework.Aop.Cache
{
    /// <summary>
    /// 根据属性来设置缓存的关键字
    /// </summary>
    public class CacheWithPropertyAttribute : CacheAttribute
    {
        #region fields
        private List<string> _properties = null;
        private byte _index = ;
        #endregion        #region Octors
        /// <summary>
        /// 根据方法的第一个参数的属性设置
        /// </summary>
        /// <param name="bucketName">缓存Bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="properties">属性名</param>
        public CacheWithPropertyAttribute(string bucketName, string prefix, params string[] properties)
            : base(bucketName, prefix)
        {
            if (properties == null || properties.Length == ) throw new ArgumentException("设置的properties个数必须大于1");
            _properties = properties.ToList();
        }
        /// <summary>
        /// 根据方法的第一个参数的属性设置
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="index">要设置为缓存的方法参数的索引，索引下标从0开始</param>
        /// <param name="properties">属性名</param>
        public CacheWithPropertyAttribute(string bucketName, string prefix, byte index, params string[] properties)
            : base(bucketName, prefix)
        {
            if (index < ) throw new ArgumentException("关键值的参数索引不能小于零");
            if (properties == null || properties.Length == ) throw new ArgumentException("设置的properties个数必须大于1");
            _properties = properties.ToList();
            _index = index;
        }
        #endregion        #region override
        public override object PreCall(object[] inputArgs, out object[] outputs)
        {
            return base.PreCall(inputArgs, out outputs);
        }
        #endregion        protected override string GetKey(object[] inputArgs)
        {
            if (string.IsNullOrEmpty(Key))
            {
                Key += base.Prefix + ":";
                object instance = inputArgs[_index];
                foreach (var property in _properties)
                {
                    Key += GetPropertyValue(instance, property) + "-";
                }
            }
            return Key.TrimEnd('-');
        }        private object GetPropertyValue(object instance, string propertyName)
        {
            BindingFlags flag = BindingFlags.Instance | BindingFlags.GetProperty | BindingFlags.IgnoreCase | BindingFlags.Public;
            Type type = instance.GetType();
            var property = type.GetProperty(propertyName, flag);
            if (property == null) throw new ArgumentException(string.Format("获取缓存出错,类型{0}中没有找到属性{1}", type, propertyName));
            return property.GetValue(instance, null);
        }
    }
}

通过输入参数索引位置移除缓存的aop属性

using MJD.Framework.CrossCutting;
using MJD.Framework.ICache;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace MJD.Framework.Aop.Cache
{
    /// <summary>
    /// 移除缓存特性
    /// </summary>
    public class RemoveCacheAttribute : CacheAttribute
    {
        #region Otors
        /// <summary>
        /// 定义缓存关键字来缓存
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        protected RemoveCacheAttribute(string bucketName, string prefix)
            : base(bucketName, prefix)
        {
        }
        /// <summary>
        /// 定义缓存关键字来缓存
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="key">缓存键</param>
        public RemoveCacheAttribute(string bucketName, string prefix, string key)
            : base(bucketName, prefix, key)
        {
        }        /// <summary>
        /// 使用当前参数来缓存，索引位置从0开始
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="keyIndex">对应的当前参数的缓存键所在的参数索引位置</param>
        public RemoveCacheAttribute(string bucketName, string prefix, short keyIndex)
            : base(bucketName, prefix, keyIndex)
        {
        }        /// <summary>
        /// 使用多个当前参数来缓存，索引位置从0开始
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="keyIndex1">对应的当前参数的缓存键所在的参数索引位置1</param>
        /// <param name="keyIndex2">对应的当前参数的缓存键所在的参数索引位置2</param>
        public RemoveCacheAttribute(string bucketName, string prefix, short keyIndex1, short keyIndex2)
            : base(bucketName, prefix, keyIndex1, keyIndex2)
        {
        }        /// <summary>
        /// 使用多个当前参数来缓存，索引位置从0开始
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="keyIndex1">对应的当前参数的缓存键所在的参数索引位置1</param>
        /// <param name="keyIndex2">对应的当前参数的缓存键所在的参数索引位置2</param>
        /// <param name="keyIndex3">对应的当前参数的缓存键所在的参数索引位置3</param>
        public RemoveCacheAttribute(string bucketName, string prefix, short keyIndex1, short keyIndex2, short keyIndex3)
            : base(bucketName, prefix, keyIndex1, keyIndex2, keyIndex3)
        {
        }
        #endregion        #region override
        public override void Called(object resultValue, object[] inputArgs, object[] outputs)
        {
        }        public override object PreCall(object[] inputArgs, out object[] outputs)
        {
            IocContainer.Resolve<ICacheService>(BucketName).Remove(GetKey(inputArgs));
            outputs = new object[];
            return null;
        }
        #endregion
    }
}

通过输入参数属性的值作为缓存键来移除缓存

using MJD.Framework.CrossCutting;
using MJD.Framework.ICache;namespace MJD.Framework.Aop.Cache
{
    /// <summary>
    /// 移除缓存特性(调用成功后移除)
    /// </summary>
    public class RemoveCacheWithPropertyAttribute : CacheWithPropertyAttribute
    {
        #region Octors
        /// <summary>
        /// 根据方法的第一个参数的属性设置
        /// </summary>
        /// <param name="bucketName">缓存Bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="properties">属性名</param>
        public RemoveCacheWithPropertyAttribute(string bucketName, string prefix, params string[] properties)
            : base(bucketName, prefix, properties)
        {
        }
        /// <summary>
        /// 根据方法的第一个参数的属性设置
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="index">要设置为缓存的方法参数的索引，索引下标从0开始</param>
        /// <param name="properties">属性名</param>
        public RemoveCacheWithPropertyAttribute(string bucketName, string prefix, byte index, params string[] properties)
            : base(bucketName, prefix, index, properties)
        {
        }
        #endregion        #region override
        public override void Called(object resultValue, object[] inputArgs, object[] outputs)
        {
            IocContainer.Resolve<ICacheService>(BucketName).Remove(GetKey(inputArgs));
        }        public override object PreCall(object[] inputArgs, out object[] outputs)
        {
            //IocContainer.Resolve<ICacheService>(BucketName).Remove(GetKey(inputArgs));
            outputs = new object[];
            return null;
        }
        #endregion
    }
}

更新1

using MJD.Framework.CrossCutting;
using MJD.Framework.ICache;namespace MJD.Framework.Aop.Cache
{
    /// <summary>
    /// 更新缓存特性
    /// </summary>
    public class UpdateCacheAttribute : CacheAttribute
    {
        #region Otors
        /// <summary>
        /// 定义缓存关键字来缓存
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        protected UpdateCacheAttribute(string bucketName, string prefix)
            : base(bucketName, prefix)
        {
        }
        /// <summary>
        /// 定义缓存关键字来缓存
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="key">缓存键</param>
        public UpdateCacheAttribute(string bucketName, string prefix, string key)
            : base(bucketName, prefix, key)
        {
        }        /// <summary>
        /// 使用当前参数来缓存，索引位置从0开始
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="keyIndex">对应的当前参数的缓存键所在的参数索引位置</param>
        public UpdateCacheAttribute(string bucketName, string prefix, short keyIndex)
            : base(bucketName, prefix, keyIndex)
        {
        }        /// <summary>
        /// 使用多个当前参数来缓存，索引位置从0开始
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="keyIndex1">对应的当前参数的缓存键所在的参数索引位置1</param>
        /// <param name="keyIndex2">对应的当前参数的缓存键所在的参数索引位置2</param>
        public UpdateCacheAttribute(string bucketName, string prefix, short keyIndex1, short keyIndex2)
            : base(bucketName, prefix, keyIndex1, keyIndex2)
        {
        }        /// <summary>
        /// 使用多个当前参数来缓存，索引位置从0开始
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="keyIndex1">对应的当前参数的缓存键所在的参数索引位置1</param>
        /// <param name="keyIndex2">对应的当前参数的缓存键所在的参数索引位置2</param>
        /// <param name="keyIndex3">对应的当前参数的缓存键所在的参数索引位置3</param>
        public UpdateCacheAttribute(string bucketName, string prefix, short keyIndex1, short keyIndex2, short keyIndex3)
            : base(bucketName, prefix, keyIndex1, keyIndex2, keyIndex3)
        {
        }
        #endregion        #region override
        public override void Called(object resultValue, object[] inputArgs, object[] outputs)
        {
            IocContainer.Resolve<ICacheService>(BucketName).Upsert<object>(GetKey(inputArgs), resultValue);
        }        public override object PreCall(object[] inputArgs, out object[] outputs)
        {
            outputs = new object[];
            return null;
        }
        #endregion
    }
}

更新2

using MJD.Framework.CrossCutting;
using MJD.Framework.ICache;namespace MJD.Framework.Aop.Cache
{
    /// <summary>
    /// 更新缓存特性
    /// </summary>
    public class UpdateCacheWithPropertyAttribute : CacheWithPropertyAttribute
    {        #region Octors
        /// <summary>
        /// 根据方法的第一个参数的属性设置
        /// </summary>
        /// <param name="bucketName">缓存Bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="properties">属性名</param>
        public UpdateCacheWithPropertyAttribute(string bucketName, string prefix, params string[] properties)
            : base(bucketName, prefix, properties)
        {
        }
        /// <summary>
        /// 根据方法的第一个参数的属性设置
        /// </summary>
        /// <param name="bucketName">缓存bucket</param>
        /// <param name="prefix">缓存的前缀，避免使用ID作为缓存键时与其他缓存冲突，必须是独一无二的前缀</param>
        /// <param name="index">要设置为缓存的方法参数的索引，索引下标从0开始</param>
        /// <param name="properties">属性名</param>
        public UpdateCacheWithPropertyAttribute(string bucketName, string prefix, byte index, params string[] properties)
            : base(bucketName, prefix, index, properties)
        {
        }
        #endregion        #region override
        public override void Called(object resultValue, object[] inputArgs, object[] outputs)
        {
            IocContainer.Resolve<ICacheService>(BucketName).Upsert<object>(GetKey(inputArgs), resultValue);
        }        public override object PreCall(object[] inputArgs, out object[] outputs)
        {
            outputs = new object[];
            return null;
        }
        #endregion
    }
}
点赞 484

贡献者

上一篇： ListView实现下拉动态渲染数据
下一篇： [20180801]insert导致死锁.txt
相关推荐
python开发_常用的python模块及安装方法
python开发_常用的python模块及安装方法
adodb：我们领导推荐的数据库连接组件bsddb3：BerkeleyDB的连接组件Cheetah-1.0：我比较喜欢这个版本的cheeta…
技术
日期：2022-11-24 点赞：878 阅读：9,492
Educational Codeforces Round 11 C. Hard Process 二分
Educational Codeforces Round 11 C. Hard Process 二分
C. Hard Process题目连接：http://www.codeforces.com/contest/660/problem/CDes…
技术
日期：2022-11-24 点赞：807 阅读：5,907
下载Ubuntn 17.04 内核源代码
下载Ubuntn 17.04 内核源代码
zengkefu@server1:/usr/src$ uname -aLinux server1 4.10.0-19-generic #21…
技术
日期：2022-11-24 点赞：569 阅读：6,740
可用Active Desktop Calendar V7.86 注册码序列号
可用Active Desktop Calendar V7.86 注册码序列号
可用Active Desktop Calendar V7.86 注册码序列号Name: www.greendown.cn Code: &nb…
技术
日期：2022-11-24 点赞：733 阅读：6,495
Android调用系统相机、自定义相机、处理大图片
Android调用系统相机、自定义相机、处理大图片
Android调用系统相机和自定义相机实例本博文主要是介绍了android上使用相机进行拍照并显示的两种方式，并且由于涉及到要把拍到的照片显…
技术
日期：2022-11-24 点赞：512 阅读：8,132
Struts的使用
Struts的使用
一、Struts2的获取　　Struts的官方网站为：http://struts.apache.org/　　下载完Struts2的jar包,…
技术
日期：2022-11-24 点赞：671 阅读：5,297
Lomu

贡献者

这家伙很懒，只想把你留下。

文章
34
收藏
0
人气
117,515
粉丝
进主页
文章展示
  • [ 技术 ] python开发_常用的python模块及安装方法
  • [ 技术 ] Educational Codeforces Round 11 C. Hard Process 二分
  • [ 技术 ] 下载Ubuntn 17.04 内核源代码
  • [ 技术 ] 可用Active Desktop Calendar V7.86 注册码序列号
  • [ 技术 ] Android调用系统相机、自定义相机、处理大图片
  • [ 技术 ] Struts的使用
    • 个人收藏笔记记录
    我的笔记
    首页 首页 菜单 首页 首页