[request_definition]
r = sub, obj, act

[policy_definition]
p =sub_rule,obj_rule,act

[policy_effect]
e = some(where (p.eft == allow))

[matchers]
m = r.act==p.act && eval(p.sub_rule) && eval(p.obj_rule)

{
    "sub": "",
    "obj": "\"let test=seq.set('n3','n4');include(test,r.sub.name)\"",
    "act": "read"
}

{
    "sub": {
        "name": "n3",
        "age": 1
    },
    "obj": {
        "field": [
            "f1",
            "f2"
        ]
    },
    "act": "read"
}

package org.example.controller;


import com.googlecode.aviator.AviatorEvaluatorInstance;
import com.googlecode.aviator.Options;
import org.casbin.jcasbin.main.EnforceResult;
import org.casbin.jcasbin.main.ManagementEnforcer;
import org.example.model.Policy;
import org.example.model.Request;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
@RequestMapping({"/_api/casbin"})
public class JCasbin {

    @Autowired
    private ManagementEnforcer enforcer;
    
    @PostMapping("/verify")
    public Object findByProcName2(@RequestBody Request request) {
        AviatorEvaluatorInstance aviatorEval = enforcer.getAviatorEval();
        aviatorEval.setOption(Options.TRACE_EVAL, true);
        EnforceResult enforceResult = enforcer.enforceEx(request.getSub(), request.getObj(), request.getAct());
        System.out.println(enforceResult);
        return enforceResult;
    }

    @PostMapping("/policy")
    public void addPolicy(@RequestBody Policy policy) {
        boolean flag = enforcer.addPolicy(policy.rule());
        System.out.println("add policy:" + flag);
    }
}

package org.example.model;

import lombok.Data;

import java.util.List;


@Data
public class Request {

    private Sub sub;

    private Obj obj;

    private String act;

    @Data
    class Sub {
        private String name;

        private int age;

        private String role;

        private String tenant;
    }

    @Data
    class Obj {

        private String name;

        private List<String> field;
    }
}

package org.example.model;


import com.mysql.jdbc.StringUtils;
import lombok.Data;

import java.util.ArrayList;
import java.util.List;


@Data
public class Policy {

    private String sub;

    private String obj;

    private String act;

    public List<String> rule() {
        List<String> rule = new ArrayList<>();
        rule.add(StringUtils.isNullOrEmpty(sub) ? "true" : sub);
        rule.add(StringUtils.isNullOrEmpty(obj) ? "true" : obj);
        rule.add(StringUtils.isNullOrEmpty(act) ? "true" : act);
        return rule;
    }
}

<dependency>
<groupId>org.casbin</groupId>
<artifactId>casbin-spring-boot-starter</artifactId>
<version>1.7.0</version>
</dependency>

casbin:
  #Whether to enable Casbin, it is enabled by default.
  enableCasbin: true
  #Whether to use thread-synchronized Enforcer, default false
  useSyncedEnforcer: false
  #Whether to use distributed Enforcer, default false.
  #If both useSyncedEnforcer and useDistributedEnforcer are set to true, useDistributedEnforcer will take effect.
  useDistributedEnforcer: false
  #Whether to enable automatic policy saving, if the adapter supports this function, it is enabled by default.
  autoSave: true
  #Storage type [file, jdbc], currently supported jdbc database [mysql (mariadb), h2, oracle, postgresql, db2]
  #Welcome to write and submit the jdbc adapter you are using, see: org.casbin.adapter.OracleAdapter
  #The jdbc adapter will actively look for the data source information you configured in spring.datasource
  #Default use jdbc, and use the built-in h2 database for memory storage
  storeType: jdbc
  #Customized policy table name when use jdbc, casbin_rule as default.
  tableName: casbin_rule
  #Data source initialization policy [create (automatically create data table, no longer initialized if created), never (always do not initialize)]
  initializeSchema: create
  #Local model configuration file address, the default reading location: classpath: casbin/model.conf
  model: classpath:casbin/model.conf
  #If the model configuration file is not found in the default location and casbin.model is not set correctly, the built-in default rbac model is used, which takes effect by default.
  useDefaultModelIfModelNotSetting: true
  #Local policy configuration file address, the default reading location: classpath: casbin/policy.csv
  #If the configuration file is not found in the default location, an exception will be thrown.
  #This configuration item takes effect only when casbin.storeType is set to file.
  policy: classpath:casbin/policy.csv
  #Whether to enable the CasbinWatcher mechanism, the default is not enabled.
  #If the mechanism is enabled, casbin.storeType must be jdbc, otherwise the configuration is invalid.
  enableWatcher: false
  #CasbinWatcher notification mode, defaults to use Redis for notification synchronization, temporarily only supports Redis
  #After opening Watcher, you need to manually add spring-boot-starter-data-redis dependency.
  watcherType: redis
  #Watcher to support spring tx, the default is not enable.
  #If the mechanism is enabled, When updating policy in a spring transaction, watcher will trigger the update after commit
  watcherTxSupport: false