干掉if..else！Spring Boot+aviator+aop 太絲滑了！

作者：不才陳某 2025-03-12 14:09:56

開發前端

aviator本來是一個輕量級、高性能的基于JVM的表達式引擎。不過從5.0.0版本開始，aviator升級成為了aviatorScript，成為一個高性能、輕量級寄宿于 JVM （包括 Android 平臺）之上的腳本語言。

根據官網的介紹，aviator支持的主要特性：

支持數字、字符串、正則表達式、布爾值、正則表達式等基本類型，完整支持所有 Java 運算符及優先級等。
函數是一等公民，支持閉包和函數式編程
內置 bigint/decimal類型用于大整數和高精度運算，支持運算符重載得以讓這些類型使用普通的算術運算符 +-*/ 參與運算。
完整的腳本語法支持，包括多行數據、條件語句、循環語句、詞法作用域和異常處理等。
函數式編程結合 Sequence 抽象，便捷處理任何集合。
輕量化的模塊系統。
多種方式，方便地調用 Java 方法，完整支持 Java 腳本 API（方便從 Java 調用腳本）。
豐富的定制選項，可作為安全的語言沙箱和全功能語言使用。
輕量化，高性能，ASM 模式下通過直接將腳本翻譯成 JVM 字節碼，解釋模式可運行于 Android 等非標 Java 平臺。

使用場景包括：

規則判斷及規則引擎
公式計算
動態腳本控制
集合數據 ELT 等

Aviator的限制

沒有if else、do while等語句，沒有賦值語句，僅支持邏輯表達式、算術表達式、三元表達式和正則匹配。
不支持八進制數字字面量，僅支持十進制和十六進制數字字面量。

aviator基本使用

基本表達式

要使用aviator，只需要添加相應依賴：

<dependency>
    <groupId>com.googlecode.aviator</groupId>
    <artifactId>aviator</artifactId>
    <version>5.3.3</version>
</dependency>

然后就可以進行表達式求值了：

// 返回值為16
Long r = (Long) AviatorEvaluator.execute("2 * (3 + 5)");

為了提升性能，往往先編譯表達式，然后可以反復執行，進行表達式求值：

Expression expression = AviatorEvaluator.compile("2 * (3 + 5)");
Long r = (Long) expression.execute();

aviator支持數字、字符串、布爾值等基本數據類型，數字類型值都當作long或double類型處理。關注工眾號：碼猿技術專欄，回復關鍵詞：1111 獲取阿里內部java性能調優手冊！所以上面例子的求值結果是Long。

aviator表達式支持大部分的運算操作符，如常用的算術運算操作符(+、-、*、/、%)、邏輯運算操作符（&&、||、！）、比較運算操作符（>、>=、==、!=、<、<=）、位運算操作符（&、|、^、<<、>>）和優先級操作符，還支持三元操作表達(?:)、正則表達式(=~)。

一些例子：

// 返回 hello world
    String r = (String) AviatorEvaluator.execute("'hello' + ' world'");
    
    // 返回 true
    Boolean r = (Boolean) AviatorEvaluator.execute("100 > 80 && 30 < 40");
    
    // 三元表達式，返回 30
    Long r = (Long) AviatorEvaluator.execute("100 > 80 ? 30 : 40");
    
    // 正則表達式，正則表達式放在//之間，返回 true
    Boolean r = (Boolean) AviatorEvaluator.execute("'hello' =~ /[\\w]+/");

表達式變量

跟其他表達式引擎一樣，aviator也是支持表達式求值時傳入參數的：

Long a = 12L;
Boolean r = (Boolean) AviatorEvaluator.exec("a > 10", a);

參數也可以是一個列表，如下：

List<Long> a = new ArrayList<>();
a.add(12L);
a.add(20L);
Boolean r = (Boolean) AviatorEvaluator.exec("a[0] > 10", a);

也可以是一個對象：

public static class Person {
        private String name;
        private Integer age;
    }

Person a = new Person("movee", 25);
Boolean r = (Boolean) AviatorEvaluator.exec("a.age > 10", a);

跟一般地，aviator會將參數放到一個map中

Map<String, Object> env = new HashMap<>();
env.put("person", new Person("movee", 25));
env.put("a", 20L);
Object result = AviatorEvaluator.execute("person.name", env);

這樣一來，aviator可以非常方便的從json字符串中提取子json字符串

String jsonStr = """
        {
            "a": {
                "b": [
                        {
                            "x": 3
                        },
                        {
                            "x": 4
                        }
                    ]
            }
        }
        """;


    JSONObject jsonObj = new JSONObject(jsonStr);
    // 結果返回 3
    Object value = AviatorEvaluator.execute("a.b[0]['x']", jsonObj.toMap());

使用函數

aviator已經提供了很多開箱即用的函數了：

// 返回4
    Long r = (Long) AviatorEvaluator.execute("math.round(4.3)");
    
    // 返回5
    Long r = (Long) AviatorEvaluator.execute("string.length('hello')");
    
    // 返回一個ArrayList：[1,2,3]
    Object r = AviatorEvaluator.execute("seq.list(1,2,3)");

更詳細的內置函數列表請參考：aviator函數庫列表

我們也可以自定義一個java函數，自己編寫一個類，繼承aviator的AbstractFunction類，然后實現相應的方法即可：

public class AddFunction extends AbstractFunction {

        /**
         * 函數實現的功能
         * @param env 參數
         * @param arg1 函數的第一個參數
         * @param arg2 函數的第二個參數
         * @return 返回值
         */
        @Override
        public AviatorObject call(Map<String, Object> env, AviatorObject arg1, AviatorObject arg2) {
            long num1 = FunctionUtils.getNumberValue(arg1, env).longValue();
            long num2 = FunctionUtils.getNumberValue(arg2, env).longValue();
            return AviatorLong.valueOf(num1+num2);
        }

        /**
         * 注冊到aviator的名字
         * @return 函數名字
         */
        @Override
        public String getName() {
            return"add";
        }
    }

然后就可以注冊到aviator中，關注工眾號：碼猿技術專欄，回復關鍵詞：1111 獲取阿里內部java性能調優手冊！像使用內置函數一樣使用自定義函數：

// 注冊
    AviatorEvaluator.addFunction(new AddFunction());
    
    // 使用
    long sum = (Long) AviatorEvaluator.getInstance().execute("add(3,4)");

aviatorScript腳本

aviator已經升級為一個腳本語言，所以不僅僅能進行表達式求值，還可以執行腳本程序。

// 返回1
    Object r = AviatorEvaluator.execute("if (true) { return 1; } else { return 2; }");

aviatorScript腳本一般放到獨立的腳本文件中，文件名后綴一般為.av

例如，我們編寫一個hello.av腳本文件，內容為：

if (a > 10) {
    return 10;
} else {
    return a;
}

然后就可以執行該腳本文件，并傳入參數a的值：

Map<String, Object> env = new HashMap<>();
    env.put("a", 30);
    Expression exp = AviatorEvaluator.getInstance().compileScript("./hello.av", true);
    Object result = exp.execute(env);

實操

利用aviator+aop實現參數校驗

pom.xml

<?xml versinotallow="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springboot-demo</artifactId>
        <groupId>com.et</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>Aviator</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!--AOP-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

        <!--Aviator-->
        <dependency>
            <groupId>com.googlecode.aviator</groupId>
            <artifactId>aviator</artifactId>
            <version>3.3.0</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.56</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.8.1</version>
        </dependency>

    </dependencies>
</project>

controller

在方法上加上aviator校驗規則。

package com.et.controller;

import com.et.annotation.Check;
import com.et.exception.HttpResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@RestController
publicclass HelloWorldController {
    @RequestMapping("/hello")
    public Map<String, Object> showHelloWorld(){
        Map<String, Object> map = new HashMap<>();
        map.put("msg", "HelloWorld");
        return map;
    }
    @GetMapping("/simple")
    @Check(ex = "name != null", msg = "Name cannot be empty")
    @Check(ex = "age != null", msg = "Age cannot be empty")
    @Check(ex = "age > 18", msg = "Age must be over 18 years old")
    @Check(ex = "phone != null", msg = "phone cannot be empty")
    @Check(ex = "phone =~ /^(1)[0-9]{10}$/", msg = "The phone number format is incorrect")
    @Check(ex = "string.startsWith(phone,\"1\")", msg = "The phone number must start with 1")
    @Check(ex = "idCard != null", msg = "ID number cannot be empty")
    @Check(ex = "idCard =~ /^[1-9]\\d{5}[1-9]\\d{3}((0[1-9])||(1[0-2]))((0[1-9])||(1\\d)||(2\\d)||(3[0-1]))\\d{3}([0-9]||X)$/", msg = "ID number format is incorrect")
    @Check(ex = "gender == 1", msg = "sex")
    @Check(ex = "date =~ /^[1-9][0-9]{3}-((0)[1-9]|(1)[0-2])-((0)[1-9]|[1,2][0-9]|(3)[0,1])$/", msg = "Wrong date format")
    @Check(ex = "date > '2019-12-20 00:00:00:00'", msg = "The date must be greater than 2019-12-20")
    public HttpResult simple(String name, Integer age, String phone, String idCard, String date) {
        System.out.println("name = " + name);
        System.out.println("age = " + age);
        System.out.println("phone = " + phone);
        System.out.println("idCard = " + idCard);
        System.out.println("date = " + date);
        return HttpResult.success();
    }
}

annotation

單個規則注解；

package com.et.annotation;

import java.lang.annotation.*;


@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
//add more on a method
@Repeatable(CheckContainer.class)
public @interface Check {

   String ex() default "";

   String msg() default "";

}

多個規則注解；

package com.et.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface CheckContainer {

   Check[] value();
}

AOP攔截注解；

package com.et.annotation;

import com.et.exception.UserFriendlyException;
import com.googlecode.aviator.AviatorEvaluator;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.util.StringUtils;

import java.lang.reflect.Method;
import java.util.*;


@Aspect
@Configuration
publicclass AopConfig {

   /**
    * Aspects monitor multiple annotations, because one annotation is Check and multiple annotations are compiled to CheckContainer
    */
   @Pointcut("@annotation(com.et.annotation.CheckContainer) || @annotation(com.et.annotation.Check)")
   public void pointcut() {
   }

   @Before("pointcut()")
   public Object before(JoinPoint point) {
      //get params
      Object[] args = point.getArgs();
      //get param name
      Method method = ((MethodSignature) point.getSignature()).getMethod();
      LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
      String[] paramNames = u.getParameterNames(method);

      CheckContainer checkContainer = method.getDeclaredAnnotation(CheckContainer.class);
      List<Check> value = new ArrayList<>();

      if (checkContainer != null) {
         value.addAll(Arrays.asList(checkContainer.value()));
      } else {
         Check check = method.getDeclaredAnnotation(Check.class);
         value.add(check);
      }
      for (int i = 0; i < value.size(); i++) {
         Check check = value.get(i);
         String ex = check.ex();
         //In the rule engine, null is represented by nil
         ex = ex.replaceAll("null", "nil");
         String msg = check.msg();
         if (StringUtils.isEmpty(msg)) {
            msg = "server exception...";
         }

         Map<String, Object> map = new HashMap<>(16);
         for (int j = 0; j < paramNames.length; j++) {
            //Prevent index out of bounds
            if (j > args.length) {
               continue;
            }
            map.put(paramNames[j], args[j]);
         }
         Boolean result = (Boolean) AviatorEvaluator.execute(ex, map);
         if (!result) {
            thrownew UserFriendlyException(msg);
         }
      }
      returnnull;
   }
}

全局異常攔截

package com.et.exception;

import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.lang.Nullable;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

import javax.servlet.http.HttpServletRequest;


@Configuration
@ControllerAdvice
publicclass DefaultGlobalExceptionHandler extends ResponseEntityExceptionHandler {
   privatestaticfinal Logger LOGGER = LoggerFactory.getLogger(DefaultGlobalExceptionHandler.class);

   @Override
   protected ResponseEntity<Object> handleExceptionInternal(Exception ex, @Nullable Object body, HttpHeaders headers, HttpStatus status, WebRequest request) {
      HttpResult httpResult = HttpResult.failure(status.is5xxServerError() ? ErrorCode.serverError.getDesc() : ErrorCode.paramError.getDesc());
      LOGGER.error("handleException, ex caught, cnotallow={}, httpResult={}, ex.msg={}", request.getContextPath(), JSON.toJSONString(httpResult), ex.getMessage());
      returnsuper.handleExceptionInternal(ex, httpResult, headers, status, request);
   }

   @ExceptionHandler(Exception.class)
   protected ResponseEntity handleException(HttpServletRequest request, Exception ex) {
      boolean is5xxServerError;
      HttpStatus httpStatus;
      HttpResult httpResult;
      if (ex instanceof UserFriendlyException) {
         UserFriendlyException userFriendlyException = (UserFriendlyException) ex;
         is5xxServerError = userFriendlyException.getHttpStatusCode() >= 500;
         httpStatus = HttpStatus.valueOf(userFriendlyException.getHttpStatusCode());
         httpResult = HttpResult.failure(userFriendlyException.getErrorCode(), userFriendlyException.getMessage());
      } elseif (ex instanceof IllegalArgumentException) {
         // Spring assertions are used in parameter judgment. requireTrue will throw an IllegalArgumentException. The client cannot handle 5xx exceptions, so 200 is still returned.
         httpStatus = HttpStatus.OK;
         is5xxServerError = false;
         httpResult = HttpResult.failure("Parameter verification error or data abnormality!");
      } else {
         httpStatus = HttpStatus.INTERNAL_SERVER_ERROR;
         is5xxServerError = true;
         httpResult = HttpResult.failure(ErrorCode.serverError.getDesc());
      }
      if (is5xxServerError) {
         LOGGER.error("handleException, ex caught, uri={}, httpResult={}", request.getRequestURI(), JSON.toJSONString(httpResult), ex);
      } else {
         LOGGER.error("handleException, ex caught, uri={}, httpResult={}, ex.msg={}", request.getRequestURI(), JSON.toJSONString(httpResult), ex.getMessage());
      }
      returnnew ResponseEntity<>(httpResult, httpStatus);
   }

}

責任編輯：武曉燕來源：碼猿技術專欄