（7）学习笔记 ） ASP.NET CORE微服务 Micro-Service ---- 利用Polly+AOP+依赖注入封装的降级框架

public class Person { [HystrixCommand("HelloFallBackAsync")] 
 public virtual async Task<string> HelloAsync(string name) { Console.WriteLine("hello"+name);
 return "ok"; } public async Task<string> HelloFallBackAsync(string name) { Console.WriteLine("执行失败"+name); 
 return "fail"; }
}

using AspectCore.DynamicProxy; using System; using System.Threading.Tasks; namespace hystrixtest1 { //限制这个特性只能标注到方法上  [AttributeUsage(AttributeTargets.Method)] public class HystrixCommandAttribute : AbstractInterceptorAttribute { public HystrixCommandAttribute(string fallBackMethod) { this.FallBackMethod = fallBackMethod; } public string FallBackMethod { get; set; } public override async Task Invoke(AspectContext context, AspectDelegate next) { try { await next(context);//执行被拦截的方法  } catch (Exception ex) { //context.ServiceMethod被拦截的方法。context.ServiceMethod.DeclaringType被拦截方法所在的类 //context.Implementation实际执行的对象p //context.Parameters方法参数值 //如果执行失败，则执行FallBackMethod //调用降级方法 //1.调用降级的方法（根据对象获取类，从类获取方法） var fallBackMethod = context.ServiceMethod.DeclaringType.GetMethod(this.FallBackMethod); //2.调用降级的方法 Object fallBackResult = fallBackMethod.Invoke(context.Implementation, context.Parameters); //3.把降级方法的返回值返回 context.ReturnValue = fallBackResult; } } } }

public class Person//需要public类 { [HystrixCommand(nameof(HelloFallBackAsync))] 
 public virtual async Task<string> HelloAsync(string name)//需要是虚方法 { Console.WriteLine("hello"+name); String s = null; // s.ToString(); 
 return "ok"; } public async Task<string> HelloFallBackAsync(string name) { Console.WriteLine("执行失败"+name); 
 return "fail"; } [HystrixCommand(nameof(AddFall))] 
 public virtual int Add(int i,int j) { String s = null; 
 //s.ToArray(); 
 return i + j; } public int AddFall(int i, int j) { return 0; } }

ProxyGeneratorBuilder proxyGeneratorBuilder = new ProxyGeneratorBuilder(); 
using (IProxyGenerator proxyGenerator = proxyGeneratorBuilder.Build()) { Person p = proxyGenerator.CreateClassProxy<Person>(); Console.WriteLine(p.HelloAsync("yzk").Result); Console.WriteLine(p.Add(1, 2)); }

public class Person//需要public类 { [HystrixCommand(nameof(Hello1FallBackAsync))]
 public virtual async Task<string> HelloAsync(string name)//需要是虚方法 { Console.WriteLine("hello" + name); 
 String s = null; 
 s.ToString(); 
 return "ok"; } [HystrixCommand(nameof(Hello2FallBackAsync))] 
 public virtual async Task<string> Hello1FallBackAsync(string name) { Console.WriteLine("Hello降级1" + name); 
 String s = null; 
 s.ToString(); 
 return "fail_1"; } public virtual async Task<string> Hello2FallBackAsync(string name) { Console.WriteLine("Hello降级2" + name); return "fail_2"; } [HystrixCommand(nameof(AddFall))] 
 public virtual int Add(int i, int j) { String s = null;
 s.ToString(); 
 return i + j; } public int AddFall(int i, int j) { return 0; } }

using System; using AspectCore.DynamicProxy; using System.Threading.Tasks; using Polly; namespace RuPeng.HystrixCore { [AttributeUsage(AttributeTargets.Method)] public class HystrixCommandAttribute : AbstractInterceptorAttribute { /// <summary> /// 最多重试几次，如果为0则不重试 /// </summary> public int MaxRetryTimes { get; set; } = 0; /// <summary> /// 重试间隔的毫秒数 /// </summary> public int RetryIntervalMilliseconds { get; set; } = 100; /// <summary> /// 是否启用熔断 /// </summary> public bool EnableCircuitBreaker { get; set; } = false; /// <summary> /// 熔断前出现允许错误几次 /// </summary> public int ExceptionsAllowedBeforeBreaking { get; set; } = 3; /// <summary> /// 熔断多长时间（毫秒） /// </summary> public int MillisecondsOfBreak { get; set; } = 1000; /// <summary> /// 执行超过多少毫秒则认为超时（0表示不检测超时） /// </summary> public int TimeOutMilliseconds { get; set; } = 0; /// <summary> /// 缓存多少毫秒（0表示不缓存），用“类名+方法名+所有参数ToString拼接”做缓存Key /// </summary> public int CacheTTLMilliseconds { get; set; } = 0; //由于CircuitBreaker要求同一段代码必须共享同一个Policy对象。 //而方法上标注的Attribute 对于这个方法来讲就是唯一的对象，一个方法对应一个方法上标注的Attribute对象。 //一般我们熔断控制是针对一个方法，一个方法无论是通过几个 Person 对象调用，无论是谁调用，只要全局出现ExceptionsAllowedBeforeBreaking次错误，就会熔断，这是框架的实现，你如果认为不合理，自己改去。 //我们在Attribute上声明一个Policy的成员变量，这样一个方法就对应一个Policy对象。 private Policy policy; private static readonly Microsoft.Extensions.Caching.Memory.IMemoryCache memoryCache = new Microsoft.Extensions.Caching.Memory.MemoryCache(new Microsoft.Extensions.Caching.Memory.MemoryCacheOptions()); /// <summary> /// /// </summary> /// <param name="fallBackMethod">降级的方法名</param> public HystrixCommandAttribute(string fallBackMethod) { this.FallBackMethod = fallBackMethod; } public string FallBackMethod { get; set; } public override async Task Invoke(AspectContext context, AspectDelegate next) { //一个HystrixCommand中保持一个policy对象即可 //其实主要是CircuitBreaker要求对于同一段代码要共享一个policy对象 //根据反射原理，同一个方法就对应一个HystrixCommandAttribute，无论几次调用， //而不同方法对应不同的HystrixCommandAttribute对象，天然的一个policy对象共享 //因为同一个方法共享一个policy，因此这个CircuitBreaker是针对所有请求的。 //Attribute也不会在运行时再去改变属性的值，共享同一个policy对象也没问题 lock (this)//因为Invoke可能是并发调用，因此要确保policy赋值的线程安全  { if (policy == null) { policy = Policy.NoOpAsync();//创建一个空的Policy if (EnableCircuitBreaker) //先保证熔断  { policy = policy.WrapAsync(Policy.Handle<Exception>().CircuitBreakerAsync(ExceptionsAllowedBeforeBreaking, TimeSpan.FromMilliseconds(MillisecondsOfBreak))); } if (TimeOutMilliseconds > 0) //控制是否超时  { policy = policy.WrapAsync(Policy.TimeoutAsync(() => TimeSpan.FromMilliseconds(TimeOutMilliseconds), Polly.Timeout.TimeoutStrategy.Pessimistic)); } if (MaxRetryTimes > 0) //如果出错等待MaxRetryTimes时间在执行  { policy = policy.WrapAsync(Policy.Handle<Exception>().WaitAndRetryAsync(MaxRetryTimes, i => TimeSpan.FromMilliseconds(RetryIntervalMilliseconds))); } Policy policyFallBack = Policy .Handle<Exception>() //出错了报错 如果出错就尝试调用降级方法 .FallbackAsync(async (ctx, t) => { //这里拿到的就是ExecuteAsync(ctx => next(context), pollyCtx);这里传的 pollyCtx AspectContext aspectContext = (AspectContext)ctx["aspectContext"]; var fallBackMethod = context.ServiceMethod.DeclaringType.GetMethod(this.FallBackMethod); Object fallBackResult = fallBackMethod.Invoke(context.Implementation, context.Parameters); //不能如下这样，因为这是闭包相关，如果这样写第二次调用Invoke的时候context指向的 //还是第一次的对象，所以要通过Polly的上下文来传递AspectContext //context.ReturnValue = fallBackResult; aspectContext.ReturnValue = fallBackResult; }, async (ex, t) => { }); policy = policyFallBack.WrapAsync(policy); } } //把本地调用的AspectContext传递给Polly，主要给FallbackAsync中使用，避免闭包的坑 Context pollyCtx = new Context();//Context是polly中通过Execute给FallBack、Execute等回调方法传上下文对象使用的 pollyCtx["aspectContext"] = context;//context是aspectCore的上下文 //Install-Package Microsoft.Extensions.Caching.Memory if (CacheTTLMilliseconds > 0) { //用类名+方法名+参数的下划线连接起来作为缓存key string cacheKey = "HystrixMethodCacheManager_Key_" + context.ServiceMethod.DeclaringType + "." + context.ServiceMethod + string.Join("_", context.Parameters); //尝试去缓存中获取。如果找到了，则直接用缓存中的值做返回值 if (memoryCache.TryGetValue(cacheKey, out var cacheValue)) { context.ReturnValue = cacheValue; } else { //如果缓存中没有，则执行实际被拦截的方法 await policy.ExecuteAsync(ctx => next(context), pollyCtx); //存入缓存中 using (var cacheEntry = memoryCache.CreateEntry(cacheKey)) { cacheEntry.Value = context.ReturnValue;//返回值放入缓存 cacheEntry.AbsoluteExpiration = DateTime.Now + TimeSpan.FromMilliseconds(CacheTTLMilliseconds); } } } else//如果没有启用缓存，就直接执行业务方法  { await policy.ExecuteAsync(ctx => next(context), pollyCtx); } } } }

Install-Package AspectCore.Extensions.DependencyInjection

using AspectCore.Extensions.DependencyInjection; public IServiceProvider ConfigureServices(IServiceCollection services) { services.AddMvc(); services.AddSingleton<Person>(); return services.BuildAspectCoreServiceProvider(); }

public class ValuesController : Controller { private Person p; public ValuesController(Person p) { this.p = p; } }

public IServiceProvider ConfigureServices(IServiceCollection services) { services.AddMvc(); RegisterServices(this.GetType().Assembly, services); return services.BuildAspectCoreServiceProvider(); } private static void RegisterServices(Assembly asm, IServiceCollection services) { //遍历程序集中的所有public类型 foreach (Type type in asm.GetExportedTypes()) { //判断类中是否有标注了CustomInterceptorAttribute的方法 bool hasCustomInterceptorAttr = type.GetMethods().Any(m => m.GetCustomAttribute(typeof(CustomInterceptorAttribute)) != null); if (hasCustomInterceptorAttr) { services.AddSingleton(type); } } }