动态数据源 @UseDataSource 的value值扩展支持表达式解析处理 · Pull Request !507 · MyBatis-Flex/MyBatis-Flex

## 该 PR 关联的 Issue

关联 Issue 的解决说明

无 Issue 关联
关联 Issue 的解决说明
## 修改描述

- 第一部分
如果有需要自定义扩展需求自行扩展；如下通过session 读取：
```java
public class InSessionDataSourceProcessor implements DataSourceProcessor {
    private static final String SESSION_PREFIX = "#session";

@Override
    public String process(String dataSourceKey, Object mapper, Method method, Object[] arguments) {
        if (StrUtil.isBlank(dataSourceKey)) return null;
        if (!dataSourceKey.startsWith(SESSION_PREFIX)) return null;

HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        return request.getSession().getAttribute(dataSourceKey.substring(9)).toString();
    }

}
```

- 第二部分
实例化处理器，可以单个解析处理器实例化，如果多个实例化，建议通过 DelegatingDataSourceProcessor.with(多个解析处理器实例) 方式进行实例化。
需要注意的是表达式之间有先后顺序，一旦排列前面的解析处理器正常处理后，将直接返回处理值，不再往下传递处理。

```java
      // 注入顺序既为执行时的先后顺序(前面的处理器一旦正确处理，将不会再往下传递处理)
        DelegatingDataSourceProcessor dataSourceProcessor = DelegatingDataSourceProcessor.with(
                // 参数索引快速取值的
                new ParamIndexDataSourceProcessor(),
                // Spel 表达式的
                new SpelExpressionDataSourceProcessor()
        );
        // 实例 setter 赋值
        DataSourceManager.setDataSourceProcessor(dataSourceProcessor);
```

- 第三部分
```java
@Mapper
public interface MyMapper extends BaseMapper<MyEntity >{
    /**
     * 取值第一个参数的值（arg0的值）
     */
    @UseDataSource(value = "#first")
    MyEntity test1(String arg0, String arg1, String arg2);

/**
     * 取值索引1(第二个参数 arg1 )的值
     */
    @UseDataSource(value = "#index1")
    MyEntity test2(String arg0, String arg1, String arg2);

/**
     * 取值最后一个参数的值(arg3的值)
     */
    @UseDataSource(value = "#last")
    MyEntity test3(String arg0, String arg1, String arg2, String arg3);

/**
     * Spel 表达式取值数据源
     */
    @UseDataSource(value = "#condition.getDsId()")
    MyEntity test4(String arg0, MyDsParam condition);
}
```

## 测试用例
### 测试用例1，注解@UseDataSource 使用到Mapper 上使用
如果同一个调佣链多处使用注解 @UseDataSource 则越接近Dao层优先级越高，如 Service 和 Mapper 上同时使用了，则 Service 中解析出来后，当执行 Mapper 时再次解析，会覆盖之前的值。
以下演示为 非 Spring 情况和 Spring 情况都支持，即不区分场景,但是引入了 Spring 场景的情况 DataSourceInterceptor  优先被执行，FlexMapperProxy就不会被执行。(DataSourceInterceptor 优先级高于FlexMapperProxy)
```java
public class MyServiceImpl {

private final MyMapper myMapper;

public void test(){

// mapper中的注解 @UseDataSource(value = "#first")
        myMapper.test1("my-tenant1", "arg1", "arg2");

// 取值索引1(第二个参数)的值；mapper中的注解 @UseDataSource(value = "#index1")
        myMapper.test2("arg0", "my-tenant2", "arg2");

// mapper中的注解 @UseDataSource(value = "#last")
        myMapper.test3("arg0", "arg1", "arg2","my-tenant3");

MyDsParam condition = new MyDsParam();
        condition.setDsId("my-tenant4");
        // mapper中的注解 @UseDataSource(value = "#condition.getDsId()")
        myMapper.test4("my-tenant1",condition );
    }
}
```
### 测试用例2,使用Spring情况下
通过切面处理 DataSourceInterceptor 或者 FlexMapperProxy 类中调用处理 DataSourceInterceptor 优先级高于FlexMapperProxy ；FlexMapperProxy 主要针对 非Spring项目，以下场景为 Spring场景演示，Spring下，只要切面生效，不限制注解使用的位置(Controller 、Service、Mapper 都可以)，但是推荐还是使用到 Mapper (Dao) 层，其更接近数据操作，更符合控制粒度，使用在 Controller 和 Service 层则其下层调用的所有操作都会受影响，控制粒度会比较粗，受影响面大。

##### controller
```java

@GetMapping("/test/first")
    @Operation(summary = "first测试", description = "first测试")
    public R firstTest(ColumnTestModel columnTestModel) {
        List<TableColumn> tableColumns = datasourceTestService.firstTest(columnTestModel.getTableName(), columnTestModel.getDsId());
        return R.ok(tableColumns);
    }

@GetMapping("/test/last")
    @Operation(summary = "last测试", description = "last测试")
    public R lastTest(ColumnTestModel columnTestModel) {
        TableSchema tableSchema = datasourceTestService.lastTest(columnTestModel.getTableName(), columnTestModel.getDsId());
        return R.ok(tableSchema);
    }

@GetMapping("/test/index")
    @Operation(summary = "测试Column查询", description = "测试Column查询")
    public R indexTest(ColumnTestModel columnTestModel) {
        TableSchema tableSchema = datasourceTestService.indexTest(columnTestModel.getTableName(), columnTestModel.getDsId(), null);
        return R.ok(tableSchema);
    }

@GetMapping("/test/spel")
    @Operation(summary = "SPEL测试Column查询", description = "SPEL测试Column查询")
    public R spelTest(ColumnTestModel columnTestModel) {
        TableSchema tableSchema = datasourceTestService.spelTest(columnTestModel);
        return R.ok(tableSchema);
    }
```
参数Model
```java
public class ColumnTestModel implements Serializable {
    @Serial
    private static final long serialVersionUID = 1L;

private String dsId;
    private String tableName;
}
```
##### Service
接口
```java
public interface DatasourceTestService {

List<TableColumn> firstTest(String dsId, String tableName);

TableSchema lastTest(String tableName, String dsId);

TableSchema indexTest(String tableName, String dsId, String arg2);

TableSchema spelTest(ColumnTestModel columnTestModel);
}
```
实现类
```java
public class DatasourceTestServiceImpl implements DatasourceTestService {

private final InSQLSchemaMapper inSQLSchemaMapper;

@Override
    @UseDataSource(value = "#first")
    public List<TableColumn> firstTest(String dsId, String tableName) {
        return inSQLSchemaMapper.selectColumn(tableName, dsId);
    }

@Override
    @UseDataSource(value = "#last")
    public TableSchema lastTest(String tableName, String dsId) {
        return inSQLSchemaMapper.selectSchema(tableName, dsId);
    }

@Override
    @UseDataSource(value = "#index1")
    public TableSchema indexTest(String tableName, String dsId, String arg2) {
        return inSQLSchemaMapper.selectSchema(tableName, dsId);
    }

@Override
    @UseDataSource(value = "#columnTestModel.getDsId()")
    public TableSchema spelTest(ColumnTestModel columnTestModel) {
        return inSQLSchemaMapper.selectSchema(columnTestModel.getTableName(), null);
    }
}
```
##### Mapper 
```java
    /**
     * 查询表全部列信息
     *
     * @param dsId      数据源Id
     * @param tableName 表名称
     * @return
     */
    List<TableColumn> selectColumn(@Param("tableName") String tableName, String dsId);

/**
     * 查询表信息
     *
     * @param tableName 表名称
     * @param dsId      数据源Id
     * @return
     */
    TableSchema selectSchema(@Param("tableName") String tableName, String dsId);
```
XML,基于MySQL的

```java

<sql id="columnSql">
        SELECT `table_schema`,
               `table_name`,
               `column_name`,
               `data_type`,
               `ordinal_position`,
               `column_default`,
               IF(`is_nullable` = 'YES', 1, 0) AS `is_nullable`,
               `column_comment`,
               `column_key`,
               `extra`,
               `column_type`
        FROM `information_schema`.`columns`
    </sql>

<select id="selectSchema" resultMap="schemaMap">
        <include refid="schemaSql"/>
        WHERE `table_schema` = (SELECT database() AS `db`)
        AND `table_name` = #{tableName}
        ORDER BY `create_time` DESC
    </select>

<select id="selectColumn" resultMap="columnMap">
        <include refid="columnSql"/>
        WHERE `table_schema` = (SELECT DATABASE() AS `db` )
        <if test="tableName !=null and tableName != ''">
            AND `table_name` = #{tableName}
        </if>
        ORDER BY `ordinal_position`
    </select>

```
##### 实体
```java
public class TableSchema implements Serializable {
    @Serial
    private static final long serialVersionUID = 1L;
    /**
     * 数据库库名
     */
    private String tableSchema;
    /**
     * 表名
     */
    private String tableName;
    /**
     * 表类型(BASE TABLE / SYSTEM VIEW)
     */
    private String tableType;
    /**
     * 引擎（InnoDB）
     */
    private String engine;
    /**
     * 行格式
     */
    private String rowFormat;
    /**
     * 表注释
     */
    private String tableComment;
    /**
     * 排序规则
     */
    private String tableCollation;
    /**
     * 版本
     */
    private Integer version;
    /**
     * 创建时间
     */
    private LocalDateTime createTime;

}
```
```java
public class TableColumn implements Serializable {
    @Serial
    private static final long serialVersionUID = 1L;
    /**
     * 库名
     */
    private String tableSchema;
    /**
     * 表名
     */
    private String tableName;
    /**
     * 字段名称(下划线格式名称)
     */
    private String columnName;
    /**
     * 字段数据类型（VARCHAR,INT 等等）
     */
    private String dataType;
    /**
     * 排序位置（从 1 开始）
     */
    private Integer ordinalPosition;
    /**
     * 默认值（CURRENT_TIMESTAMP，0，b'0'）
     */
    private String columnDefault;
    /**
     * 是否允许为 null
     */
    private Boolean isNullable;
    /**
     * 字段注释
     */
    private String columnComment;

/**
     * 字段索引类型(PRI,MUL,UNI等)
     */
    private String columnKey;
    /**
     * 其他信息（DEFAULT_GENERATED on update CURRENT_TIMESTAMP,AUTO_INCREMENT）
     */
    private String extra;
    /**
     * 字段定义数据类型 （varchar(31)）
     */
    private String columnType;

}
```

类型	指派人员	状态
审查	Michael Yang 已审查通过	已完成 (1/1人)
测试	Michael Yang 已测试通过	已完成 (1/1人)

MyBatis-Flex/MyBatis-Flex .gitee-modal { width: 500px !important; }

搜索帮助

MyBatis-Flex/MyBatis-Flex