回到目录
AOP面向切面的编程，也称面向方面的编程，我更青睐于前面的叫法，将一个大系统切成多个独立的部分，而这个独立的部分又可以方便的插拔在其它领域的系统之中，这种编程的方式我们叫它面向切面，而这些独立的部分，我们很早之前叫它部件，在SOA里，它叫做服务，而我认为叫它模块更加贴切，确实，这些与领域无关的东西，是像是一个个的功能模块。
之前讲过一个日志组件，有兴趣的同学可以查看：第一回 日志记录组件
今天主要说一下缓存组件，就是缓存模块，这些模块可以很方便的为每个方法添加缓存机制，事实上是在方法体执行之前，进行缓存对象的检索，当检索到有缓存，就直接加载缓存对象了，这对于数据高并发情况下，尤其有用，呵呵。
实现缓存的武器：Microsoft.Practices.EnterpriseLibrary.Caching
辅助兵器（IOC）：Microsoft.Practices.Unity
实现的效果：根据在配置文件中对要缓存的部分进行配置后，使它减少对数据库的交互，提高程序的相应能力
下面开始我们的Caching之旅
1 使用nuget添加caching和Unity组件，添加好了之后在引用中自己出现
aaarticlea/png;base64,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" alt="" />
在package.config中有我们的组件的相关说明
<packages>
<package id="Unity" version="3.0.1304.0" targetFramework="net45" />
<package id="Unity.Interception" version="3.0.1304.0" targetFramework="net45" />
<package id="EnterpriseLibrary.Caching" version="5.0.505.0" targetFramework="net45" />
<package id="EnterpriseLibrary.Common" version="5.0.505.0" targetFramework="net45" />
<package id="CommonServiceLocator" version="1.0" targetFramework="net45" />
</packages>
2 在web.config添加相应的unity注入信息和拦截信息的配置
<configSections>
<!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 -->
<section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=5.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
<section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration" />
<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
<section name="cachingConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Caching.Configuration.CacheManagerSettings, Microsoft.Practices.EnterpriseLibrary.Caching, Version=5.0.505.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
</configSections>
<unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
<sectionExtension type="Microsoft.Practices.Unity.InterceptionExtension.Configuration.InterceptionConfigurationExtension, Microsoft.Practices.Unity.Interception.Configuration" />
<container>
<extension type="Interception" />
<register type="Infrastructure.Caching.ICacheProvider, DDD_AOP_WCF" mapTo="Infrastructure.Caching.EntLibCacheProvider, DDD_AOP_WCF" />
<!--Repository Context & Repositories--> <register type="DDD_AOP_WCF.Repository.IProductRepository, DDD_AOP_WCF" mapTo="DDD_AOP_WCF.Repository.ProductRepository, DDD_AOP_WCF">
<!-- <interceptor type="VirtualMethodInterceptor" />-->
<interceptor type="InterfaceInterceptor"/>
<interceptionBehavior type="Infrastructure.InterceptionBehaviors.CachingBehavior,DDD_AOP_WCF" />
<interceptionBehavior type="Infrastructure.InterceptionBehaviors.ExceptionLoggingBehavior, DDD_AOP_WCF" />
</register>
</container>
</unity>
下面是缓存组件的配置：
<!--BEGIN: Caching-->
<cachingConfiguration defaultCacheManager="ByteartRetailCacheManager">
<cacheManagers>
<add name="ByteartRetailCacheManager" type="Microsoft.Practices.EnterpriseLibrary.Caching.CacheManager, Microsoft.Practices.EnterpriseLibrary.Caching, Version=5.0.505.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
expirationPollFrequencyInSeconds="" maximumElementsInCacheBeforeScavenging=""
numberToRemoveWhenScavenging="" backingStoreName="NullBackingStore" />
</cacheManagers>
<backingStores>
<add type="Microsoft.Practices.EnterpriseLibrary.Caching.BackingStoreImplementations.NullBackingStore, Microsoft.Practices.EnterpriseLibrary.Caching, Version=5.0.505.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
name="NullBackingStore" />
</backingStores>
</cachingConfiguration>
<!--END: Caching-->
3 建立一个测试用的IRepository接口和一个个性化操作的接口IProductRepository
public interface IRepository<TEntity> where TEntity : class
{
void Insert(TEntity entity);
string Hello();
IQueryable<TEntity> GetEntities();
}
public interface IProductRepository : IRepository<Product>
{
/// <summary>
/// 获取产品列表
/// </summary>
/// <returns></returns>
[Caching(CachingMethod.Get)]
List<Product> GetProduct(); /// <summary>
/// 建立产品
/// </summary>
[Caching(CachingMethod.Remove, "GetProduct")]
void AddProduct(Product entity); /// <summary>
/// 修改产品
/// </summary>
[Caching(CachingMethod.Remove, "GetProduct")]
void ModifyProduct(Product entity); }
对这个接口进行实现，当然，它可以有多个实现版本，这也是IoC出现的原因
aaarticlea/png;base64,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" alt="" />
4 建立一个本地服务器，它是与IoC实现松耦合的前提，而IoC是我们实现程序代码松耦合的前提，呵呵。
/// <summary>
/// Represents the Service Locator.
/// </summary>
public sealed class ServiceLocator : IServiceProvider
{
#region Private Fields
private readonly IUnityContainer container;
#endregion #region Private Static Fields
private static readonly ServiceLocator instance = new ServiceLocator();
#endregion #region Ctor
/// <summary>
/// Initializes a new instance of ServiceLocator class.
/// </summary>
private ServiceLocator()
{
UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
container = new UnityContainer();
section.Configure(container);
}
#endregion #region Public Static Properties
/// <summary>
/// Gets the singleton instance of the ServiceLocator class.
/// </summary>
public static ServiceLocator Instance
{
get { return instance; }
}
#endregion #region Private Methods
private IEnumerable<ParameterOverride> GetParameterOverrides(object overridedArguments)
{
List<ParameterOverride> overrides = new List<ParameterOverride>();
Type argumentsType = overridedArguments.GetType();
argumentsType.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.ToList()
.ForEach(property =>
{
var propertyValue = property.GetValue(overridedArguments, null);
var propertyName = property.Name;
overrides.Add(new ParameterOverride(propertyName, propertyValue));
});
return overrides;
}
#endregion #region Public Methods
/// <summary>
/// Gets the service instance with the given type.
/// </summary>
/// <typeparam name="T">The type of the service.</typeparam>
/// <returns>The service instance.</returns>
public T GetService<T>()
{
return container.Resolve<T>();
}
/// <summary>
/// Gets the service instance with the given type by using the overrided arguments.
/// </summary>
/// <typeparam name="T">The type of the service.</typeparam>
/// <param name="overridedArguments">The overrided arguments.</param>
/// <returns>The service instance.</returns>
public T GetService<T>(object overridedArguments)
{
var overrides = GetParameterOverrides(overridedArguments);
return container.Resolve<T>(overrides.ToArray());
}
/// <summary>
/// Gets the service instance with the given type by using the overrided arguments.
/// </summary>
/// <param name="serviceType">The type of the service.</param>
/// <param name="overridedArguments">The overrided arguments.</param>
/// <returns>The service instance.</returns>
public object GetService(Type serviceType, object overridedArguments)
{
var overrides = GetParameterOverrides(overridedArguments);
return container.Resolve(serviceType, overrides.ToArray());
}
#endregion #region IServiceProvider Members
/// <summary>
/// Gets the service instance with the given type.
/// </summary>
/// <param name="serviceType">The type of the service.</param>
/// <returns>The service instance.</returns>
public object GetService(Type serviceType)
{
return container.Resolve(serviceType);
} #endregion
}
5 建立一个缓存拦截器，它是与具体领域没有关系的，我们的拦截器Interception，可以有两个，如缓存拦截，日志拦截，异常拦截等等，我会在后面的文章中进
行介绍
/// <summary>
/// 表示用于方法缓存功能的拦截行为。
/// </summary>
public class CachingBehavior : IInterceptionBehavior
{
#region Private Methods
/// <summary>
/// 根据指定的<see cref="CachingAttribute"/>以及<see cref="IMethodInvocation"/>实例，
/// 获取与某一特定参数值相关的键名。
/// </summary>
/// <param name="cachingAttribute"><see cref="CachingAttribute"/>实例。</param>
/// <param name="input"><see cref="IMethodInvocation"/>实例。</param>
/// <returns>与某一特定参数值相关的键名。</returns>
private string GetValueKey(CachingAttribute cachingAttribute, IMethodInvocation input)
{
switch (cachingAttribute.Method)
{
// 如果是Remove，则不存在特定值键名，所有的以该方法名称相关的缓存都需要清除
case CachingMethod.Remove:
return null;
// 如果是Get或者Put，则需要产生一个针对特定参数值的键名
case CachingMethod.Get:
case CachingMethod.Put:
if (input.Arguments != null &&
input.Arguments.Count > )
{
var sb = new StringBuilder();
for (int i = ; i < input.Arguments.Count; i++)
{
sb.Append(input.Arguments[i].ToString());
if (i != input.Arguments.Count - )
sb.Append("_");
}
return sb.ToString();
}
else
return "NULL";
default:
throw new InvalidOperationException("无效的缓存方式。");
}
}
#endregion #region IInterceptionBehavior Members
/// <summary>
/// 获取当前行为需要拦截的对象类型接口。
/// </summary>
/// <returns>所有需要拦截的对象类型接口。</returns>
public IEnumerable<Type> GetRequiredInterfaces()
{
return Type.EmptyTypes;
} /// <summary>
/// 通过实现此方法来拦截调用并执行所需的拦截行为。
/// </summary>
/// <param name="input">调用拦截目标时的输入信息。</param>
/// <param name="getNext">通过行为链来获取下一个拦截行为的委托。</param>
/// <returns>从拦截目标获得的返回信息。</returns>
public IMethodReturn Invoke(IMethodInvocation input, GetNextInterceptionBehaviorDelegate getNext)
{
var method = input.MethodBase;
var key = method.Name;
if (method.IsDefined(typeof(CachingAttribute), false))
{
var cachingAttribute = (CachingAttribute)method.GetCustomAttributes(typeof(CachingAttribute), false)[];
var valKey = GetValueKey(cachingAttribute, input);
switch (cachingAttribute.Method)
{
case CachingMethod.Get:
try
{
if (CacheManager.Instance.Exists(key, valKey))
{
var obj = CacheManager.Instance.Get(key, valKey);
var arguments = new object[input.Arguments.Count];
input.Arguments.CopyTo(arguments, );
return new VirtualMethodReturn(input, obj, arguments);
}
else
{
var methodReturn = getNext().Invoke(input, getNext);
CacheManager.Instance.Add(key, valKey, methodReturn.ReturnValue);
return methodReturn;
}
}
catch (Exception ex)
{
return new VirtualMethodReturn(input, ex);
}
case CachingMethod.Put:
try
{
var methodReturn = getNext().Invoke(input, getNext);
if (CacheManager.Instance.Exists(key))
{
if (cachingAttribute.Force)
{
CacheManager.Instance.Remove(key);
CacheManager.Instance.Add(key, valKey, methodReturn.ReturnValue);
}
else
CacheManager.Instance.Put(key, valKey, methodReturn.ReturnValue);
}
else
CacheManager.Instance.Add(key, valKey, methodReturn.ReturnValue);
return methodReturn;
}
catch (Exception ex)
{
return new VirtualMethodReturn(input, ex);
}
case CachingMethod.Remove:
try
{
var removeKeys = cachingAttribute.CorrespondingMethodNames;
foreach (var removeKey in removeKeys)
{
if (CacheManager.Instance.Exists(removeKey))
CacheManager.Instance.Remove(removeKey);
}
var methodReturn = getNext().Invoke(input, getNext);
return methodReturn;
}
catch (Exception ex)
{
return new VirtualMethodReturn(input, ex);
}
default: break;
}
} return getNext().Invoke(input, getNext);
} /// <summary>
/// 获取一个<see cref="Boolean"/>值，该值表示当前拦截行为被调用时，是否真的需要执行
/// 某些操作。
/// </summary>
public bool WillExecute
{
get { return true; }
} #endregion
}
6 下面是前台程序的调用方法
IProductRepository productRepository = ServiceLocator.Instance.GetService<IProductRepository>();
ViewBag.Product = productRepository.GetProduct();
@{var Model = ViewBag.Product as List<学习陈晴阳的DDD_AOP_WCF.Product>; }
@if (Model != null && Model.Count > )
{
foreach (var item in Model)
{
<p>@item.ProductName</p>
}
}
好了，当我们为程序加上缓存拦截器之后，当它的数据没有发生变化时，会直接从缓存中读取对象，而不会与数据库发生访问！
回到目录
