概述

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度低,提高程序的可重用性，同时提高了开发的效率。

aop的相关概念

Aspect（切面）：

Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。在Spring AOP中，切面可以使用基于模式或者基于@Aspect注解的方式来实现。

Joint point（连接点）

表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。在Spring AOP中，一个连接点总是表示一个方法的执行。

Pointcut（切点）

表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。匹配连接点的断言。Advice通知和一个Joint point切入点表达式关联，并在满足这个切入点的连接点上运行。切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。

Advice（通知）

Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，许多AOP框架（包括Spring）都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。Advice 的类型有如下几种。

before advice

在 join point 前被执行的 advice. 虽然 before advice 是在 join point 前被执行, 但是它并不能够阻止 join point 的执行, 除非发生了异常(即我们在 before advice 代码中, 不能人为地决定是否继续执行 join point 中的代码)

after return advice

在一个 join point 正常返回后执行的 advice

after throwing advice

当一个 join point 抛出异常后执行的 advice

after(final) advice

无论一个 join point 是正常退出还是发生了异常, 都会被执行的 advice.

around advice

在 join point 前和 joint point 退出后都执行的 advice. 这个是最常用的 advice.

introduction

introduction可以为原有的对象增加新的属性和方法。Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，你可以使用引入来使一个bean实现IsModified接口，以便简化缓存机制。

Target（目标对象）

织入 Advice 的目标对象。既然Spring AOP是通过运行时代理实现的，这个对象永远是一个被代理（proxied）对象。

Weaving（织入）

将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程。把切面连接到其它的应用程序类型或者对象上，并创建一个被通知的对象。这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。

切面类示例

 package com.ambulance.biz.base;
 
 import com.alibaba.fastjson.JSON;
 import lombok.extern.java.Log;
 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.*;
 import org.springframework.stereotype.Component;
 import org.springframework.web.context.request.RequestContextHolder;
 import org.springframework.web.context.request.ServletRequestAttributes;
 
 import javax.servlet.http.HttpServletRequest;
 import java.util.Arrays;
 import java.util.List;
 
 @Aspect //标识切面类
 @Component //加入IOC容器
 @Log //log
 public class AspectConfig {
 
     //execution([可见性]返回类型[声明类型].方法名(参数)[异常]) 其中[]内的是可选的，其它的还支持通配符的使用：
     //*：匹配所有字符
     //..：一般用于匹配多个包，多个参数
     //+：表示类及其子类
     //运算符有：&&,||,!
     @Pointcut("execution(public * com.ambulance.biz.acontroller.UserController.login(..))")
     public void index_log(){}
 
     /**
      * 记录HTTP请求结束时的日志
      * [1]在通知方法中声明一个JoinPoint类型的形参
      * [2]调用JoinPoint对象的getSignature()方法获取目标方法的签名
      * [3]调用JoinPoint对象的getArgs()方法获取目标方法的实际参数列表
      */
     @Before("index_log()")
     public void doBefore(JoinPoint joinPoint) throws Throwable {
         // 接收到请求，记录请求内容
         ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
         HttpServletRequest request = attributes.getRequest();
 
         // 记录下请求内容
         log.info(">>>>>>>>>>Before");
         log.info("URL : " + request.getRequestURL().toString());
         log.info("HTTP_METHOD : " + request.getMethod());
         log.info("IP : " + request.getRemoteAddr());
         log.info("PATH : " +  request.getServletPath());
         log.info("METHOD : " + request.getMethod());
         //jointPoint
         log.info("CLASS_METHOD : " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
         log.info("ARGS : " + Arrays.toString(joinPoint.getArgs()));
    }
 
     /**
      * ②在返回通知中获取方法的返回值
      * [1]在@AfterReturning注解中添加returning属性
      * @param obj
      * @throws Throwable
      */
 
     @AfterReturning(returning = "obj",pointcut = "index_log()")
     public void doAfterReturning(Object obj) throws Throwable {
         //处理完请求，返回内容
         log.info(">>>>>>>>>>AfterReturning");
         log.info("RESPONSE : " + JSON.toJSONString(obj));
    }
 
     /**
      * ③在异常通知中获取异常对象
      *
      * [1]在@ AfterThrowing注解中添加throwing属性
      * [2]在异常通知的通知方法中声明一个形参，形参名和throwing属性值一致
      * @param joinPoint
      * @param exception
      */
     @AfterThrowing(value = "index_log()",throwing = "exception")
     public void doAfterThrowing(JoinPoint joinPoint,Throwable exception){
         //目标方法名：
         log.info(">>>>>>>>>>AfterThrowing");
         log.info(joinPoint.getSignature().getName());
         if(exception instanceof NullPointerException){
             log.info("发生了空指针异常!!!!!");
        }else{
             log.info("发生了未知异常!!!!!");
        }
    }
 
     @Around(value = "index_log()")
     public Object doAroundAdvice(ProceedingJoinPoint proceedingJoinPoint){
         String methodName = proceedingJoinPoint.getSignature ().getName ();
         Object[] args = proceedingJoinPoint. getArgs();
         List<Object > argList = Arrays.asList (args) ;
         Object result = null;
         try {
             // 在方法开始执行之前的操作
             System.out .println( "[环绕日志][" + methodName + "方法开始][参数值：" + argList+"]" );
 
 
             // 调用被代理的目标方法
             result = proceedingJoinPoint. proceed(args );
 
 
             // 在方法正常结束之后的操作
             System.out .println( "[环绕日志][" + methodName + "方法返回][返回值：" + result+"]" );
 
 
        } catch (Throwable e) {
             // 方法抛出异常时的操作
             System.out .println( "[环绕日志][" + methodName + "方法抛异常了][异常对象：" + e +"]" );
        } finally {
             // 方法最终结束时的操作
             System.out .println( "[环绕日志][" + methodName + "方法最终结束了]");
        }
         // 一定要将目标方法的返回值返回，否则外界就获取不到了
         return result ;
    }
 }

说明：

 
 我们使用execution指示器选择Xxx类的xxx方法，方法表达式以 * 号开始，标识我们不关心方法的返回值类型。然后我们指定了全限定类名和方法名。对于方法参数列表，我们使用 .. 标识切点选择任意的xxx方法，无论该方法的入参是什么。
 多个匹配之间我们可以使用链接符 &&、||、！来表示 “且”、“或”、“非”的关系。但是在使用 XML 文件配置时，这些符号有特殊的含义，所以我们使用 “and”、“or”、“not”来表示。
 
 举例：
 限定该切点仅匹配的包是 com.xxx.aopdemo.test1,可以使用
 execution(* com.xxx.aopdemo.test1.IBuy.buy(..)) && within(com.xxx.aopdemo.test1.*)
 在切点中选择 bean,可以使用
 execution(* com.xxx.aopdemo.test1.IBuy.buy(..)) && bean(girl)

注解

Java 中常用注解使用 @Override 表示当前方法覆盖了父类的方法。

@Deprecation 表示方法已经过时,方法上有横线，使用时会有警告。

@SuppressWarnings 表示关闭一些警告信息(通知 java 编译器忽略特定的编译警告)。

SafeVarargs (jdk1.7 更新) 表示：专门为抑制“堆污染”警告提供的。

@FunctionalInterface (jdk1.8 更新) 表示：用来指定某个接口必须是函数式接口， 否则就会编译出错。

注解和反射经常结合在一起使用，在很多框架的代码中都能看到他们结合使用的影子。 可以通过反射来判断类，方法，字段上是否有某个注解以及获取注解中的值, 获取某个 类中方法上的注解代码示例如下：

 
 /////
 Class<?> clz = bean.getClass();
 ///获取所有公共方法，包括自身的publi方法，从基类获取的，从接口获取的
 Method[] methods = clz.getMethods();
 //// 类自身声明的所有方法，包含public、protected和private方法
 clz.getDeclaredMethods();
 for (Method method : methods) {
   if (method.isAnnotationPresent(EnableAuth.class)) {
     EnableAuth annotation = method.getAnnotation(EnableAuth.class);
     // annotation 获取注解对象，并通过其可以获取注解详细信息
  }}
 
 // 通过反射获取字段属性值
 Field standField = bClass.getDeclaredField(name);
 standField.setAccessible(true);
 Object dataBaseValue = standField.get(dataDto);

函数式编程

在函数式语言中，函数作为一等公民，可以在任何地方定义，在函数内或函数外，可以作为函数的参数和返回值，可以对函数进行组合。由于命令式编程语言也可以通过类似函数指针的方式来实现高阶函数，函数式的最主要的好处主要是不可变性带来的。没有可变的状态，函数就是引用透明（Referential transparency）的和没有副作用（No Side Effect）。

副作用，纯函数，引用透明

　副作用的概念：一个带有副作用的函数不仅只是简单的返回一个值，还干了一些其他的事情，比如:

• 修改一个变量
• 直接修改数据结构
• 设置一个对象的成员
• 抛出一个异常或以一个错误终止
• 打印到终端或读取用户的输入
• 读取或写入一个文件
• 在屏幕上绘画

因此我们对于函数式程序的判定边界就在于：函数的副作用。

于是当函数没有副作用，那么我们就说这个函数符合函数式编程（FP）；

再给出纯函数这个概念用来定义一个函数没有副作用，我们可以说纯函数构成的程序风格就是函数式的！

　　　　buyCoffee的例子(p3)：函数只不过是需要返回一杯咖啡，可是却对费用进行了持久化操作（产生副作用），我们可以在buyCoffee方法返回咖啡时也把费用作为值一并返回，将费用这条记录交给其他程序来做持久化，以此来去除副作用 ====》通过把这些副作用推到程序的外层，来转换任何带有副作用的函数（纯的内核和一层很薄的外围来处理副作用）

　　　　引用透明：对于程序p，如果它包含的表达式e满足引用透明，所有e都可以替换为它的运算结果而不会改变程序p的含义（要求函数不论进行任何操作都可以用它的返回值来代替）。

　　　　引用透明与纯函数的关联：假如存在一个函数f，若表达式f(x)对所有引用透明的表达式x也是引用透明，那么这个f是一个纯函数（也就是说，传入引用透明的x表达式给f,函数f(x)的返回值可以代替这个函数在其他程序起的作用）

　　　　纯函数的好处：纯函数是模块化的、可组合的，因为它从“对结果做什么（返回值）”和“如果获取输入（通过参数传递获得输入）”中分离了计算本身的逻辑，就像一个黑盒子。