NET Core AOP基础讲解

AOP

基础知识

假设这是一个U型管道，污水水从一端流入，另一端流出。

现在我们要对污水进行过滤，A负责过滤B负责消毒。显然有四个处理点，他们的顺序分别是：1->2->3->4。其中1，4是A过滤器的处理点，2，3是B过滤器的处理点。显然3个过滤器就有6个处理点。我们可以随意调整A，B过滤器的顺序，可随意插拔。这就是AOP的思想。

执行顺序：先进后出（栈）

执行点数：过滤器数 * 2

AOP是对OOP的一种补充，即面向切面编程，一种编程思想。我们管A，B为切面。1~4为切入点。AOP的优势是面向切面编程，每个切面负责独立的系统逻辑，降低代码的复杂度，提高代码的复用率。可以随意调整顺序，随意插拔。用于对业务逻辑进行增强。面向切面编程可以使得系统逻辑和业务逻辑进行分离。

系统逻辑：比如身份认证，异常处理，参数校验

业务逻辑：就是我们真正关心不得不写的业务逻辑。

public class Demo
{
    //A可以拦截所有异常
    public void A()
    {
        try
        {
            Console.WriteLine(1);
            B();
            Console.WriteLine(4);
        }
        catch(Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }
    //B只能拦截自己和C的异常
    public void B()
    {
        Console.WriteLine(2);
        C();
        Console.WriteLine(3);
    }
    public void C()
    {
        Console.WriteLine("水变清澈了");
    }
}
//这段代码没有实际意义，但是它展示了函数调用的执行过程。（先进后出）

静态代理

假设我们需要实现一个IList接口，我们知道IList接口有很多方法，实现成本非常高。我们可以通过代理模式来实现

代理模式可以降低实现的成本，还可以对目标对象进行加强。代理者不需要实现具体的业务逻辑，只需要编写加强逻辑即可。

//实现IEnumerable接口只能加强两个方法，但是实现IList接口可以加强很多方法
class MyCollection : IEnumerable<object>
{
    private IEnumerable<object> _target;

    public MyCollection(IEnumerable<object> target)
    {
        _target = target;
    }

    public IEnumerator<object> GetEnumerator()
    {
        //编写加强逻辑比如打印
        Console.WriteLine("调用迭代器了");
        //通过target来实现，代理类之关系加强逻辑，不关心接口实现
        return _target.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return ((IEnumerable)_target).GetEnumerator();
    }
}

//测试
var target= new List<object>();
//可以看到MyCollection对target进行了代理，加强了GetEnumerator函数（可以打印消息）
var collection = new MyCollection(target);
//此时GetEnumerator就会被加强，返回target的迭代器。
var it = collection.GetEnumerator();

我们可以通过静态代理来实现链式调用，完成污水处理问题。

public interface IWater
{
     void Invoke();
}
public class Water : IWater
{
    public void Invoke()
    {
        //业务逻辑
        Console.WriteLine("水已经净化了");
    }
}
//实现目标对象的接口IWater
public class WaterProxy1 : IWater
{
    private readonly IWater _target;
    
    public WaterProxy1(IWater target)
    {
        _target = target;
    }
   
    public void Invoke()
    {
        Console.WriteLine("开始消毒杀菌");//系统逻辑
        _target = target;
        Console.WriteLine("完成消毒杀菌");//系统逻辑
    }
}
public class WaterProxy2 : IWater
{
    private readonly IWater _target;
    
    public WaterProxy2(IWater target)
    {
        _target = target;
    }
   
    public void Invoke()
    {
        Console.WriteLine("开始去除杂质");//系统逻辑
        _target = target;
        Console.WriteLine("完成去除杂质");//系统逻辑
    }
}
//此时是先去除杂质后在消毒
//p1的target是Water，p2的target是p1
var target = new Water();
var p1 = new WaterProxy1(target);
var p2 = new WaterProxy2(p1);
p2.Invoke();
//此时是先消毒后在去除杂质
//p2的target是Water，p1的target是p2
var target = new Water();
var p2 = new WaterProxy2(target);
var p1 = new WaterProxy1(p2);
p2.Invoke();

可以看到系统逻辑和业务逻辑进行了分离，系统逻辑写到了不同的切面。切面之间何以随意组合，增减。这就是AOP思想的一种呈现方式。代码服用度很高，可以代理所有的IWater的实现。（假设Mercury也实现了IWater接口，那么WaterProxy1和WaterProxy2也能对他进行增强）

静态代理的本质是子类继承父类，或者实现接口，对目标对象进行增强。

静态代理的弊端是只能实现一个接口（标准），无法代理其他类型的实列。他的切面的可复用率有限，限定在它实现的接口。

管道模式

这是aspnetcore管道的核心代码

public class HttpContext
{
    //表示请求参数
    public string Request { get; }
    //表示响应数据
    public string Response { get; }
}

//定义一个委托
public delegate void RequestDelegate(HttpContext context);

public class ApplicationBuilder
{
    private readonly List<Func<RequestDelegate, RequestDelegate>> _components = n

    public void Use(Func<RequestDelegate, RequestDelegate> middleware)
    {
        _components.Add(middleware);
    }

    public RequestDelegate Build()
    {
        //负责兜底
        WaterDelegate app = c =>
        {
            throw new InvalidOperationException("无效的管道");
        };
        for (int i = _components.Count - 1; i > -1; i--)
        {
            app = _components[i](app);//完成嵌套
        }
        return app;
    }    
}    

测试

var builder = new ApplicationBuilder();
//过滤器1
builder.Use(next => 
{
    return context =>
    {
        Console.WriteLine("开始去污");
        next(context);
        Console.WriteLine("完成去污");
    };
});
//过滤器2
builder.Use(next =>
{
    return context =>
    {
        Console.WriteLine("开始