动态api设计文档

{% assign param1 = 'value1' %}
{% assign param2 = 'value2' %}
{% assign param3 = null %}

{% assign sql_query = "SELECT * FROM your_table WHERE 1=1" %}

{% if param1 != null %}
    {% assign sql_query = sql_query | append: " AND column1 = '" | append: param1 | append: "'" %}
{% endif %}

{% if param2 != null %}
    {% assign sql_query = sql_query | append: " AND column2 = '" | append: param2 | append: "'" %}
{% endif %}

{% if param3 != null %}
    {% assign sql_query = sql_query | append: " AND column3 = '" | append: param3 | append: "'" %}
{% endif %}

{{ sql_query }}

{{#with params}}
SELECT * FROM your_table WHERE 1=1
{{#if param1}} AND column1 = '{{param1}}'{{/if}}
{{#if param2}} AND column2 = '{{param2}}'{{/if}}
{{#if param3}} AND column3 = '{{param3}}'{{/if}}
{{/with}}

string template = @"
            @{
                var param1 = Model.param1;
                var param2 = Model.param2;
                var param3 = Model.param3;

                // 构造 SQL 查询语句
                var sqlQuery = ""SELECT * FROM your_table WHERE 1=1 order by "";
                if (!string.IsNullOrEmpty(param1))
                {
                    sqlQuery += "" AND column1 = '"" + param1 + ""'"";
                }
                if (!string.IsNullOrEmpty(param2))
                {
                    sqlQuery += "" AND column2 = '"" + param2 + ""'"";
                }
                if (!string.IsNullOrEmpty(param3))
                {
                    sqlQuery += "" AND column3 = '"" + param3 + ""'"";
                }
            }
            @sqlQuery";

var model = new { param1 = "value1", param2 = (string)null, param3 = "value3" };
string result = Engine.Razor.RunCompile(template, "templateKey", null, model);

{
    "totalCount": 100,
    "items":[{
        // ... 具体的实体
    }]
}

{
   // 具体的实体结构
}

public interface ITemplateEngine{
    public string Name { get; }
    Task<string> Render(string template, IDictionary<string, object> input = null);
}

public class JsTemplateEngine: ITemplateEngine{
}
public class LiquidTemplateEngine: ITemplateEngine{
}
public class TemplateEngineManager {
    public void RegisterEngine(string engineName){}
    public ITemplateEngine GetEngine(string engineName);
}

public class ConnectionManager{
    // 先实现 Oracle和 mysql的 连接池获取
    // 需要用到连接池 ConnectionPool
    public IDbConnection GetConnection(Guid connectionPoolId){
    }
    
    public void ReturnConnection(IDbConnection connection){}
}

public class ExecutionContext{
    public ExecutionContext(string apiName, ApiDefinition definition, IEnumerable<ApiParameter>  parameters){
        ApiName = apiName;
        Definition = definition;
        Parameters = parameters;
    }
    public string ApiName{get; protected set;}
    public ApiDefinition Definition{get; protected set;}
    public IEnumerable<ApiParameter> Parameters{ get; protected set;}
    public bool CheckParameters(IDictionary<string, object> input){
        return true;
    }
}

public interface IDynamicApiExecutor{
    Task<object> ExecuteAsync(IDictionary<string, object> input);
}

public class DefaultDynamicApiExecutor: IDynamicApiExecutor{
    
     protected readonly TemplateEngineManager _templateEngineManager;
     protected readonly  ConnectionManager _connectionManager;
    
     public async Task<object> ExecuteAsync(ExecutionContext context, IDictionary<string, object> input = null){
        // 1.检查入参：根据传入的input和Parameters定义，检查 input的类型以及是否必需等信息，若不满足则抛出异常
         bool isSuccess = context.CheckParameters(input);
         
        // 2.渲染模板： 根据定义和对应的引擎类型，传入input获得渲染后的sql语句或调用存储过程的语句
         var engine = _templateEngineManager.GetEngine(context.Definition.TemplateEngine);
         string sqlQuery = engine.Render(context.Definition.ScriptTemplate, input);
         
        // 3.获取链接：根据Definition的ConnectionPoolId从连接池中获得链接
         IDbConnection connection = _connectionManager.GetConnection(context.Definition.ConnectionPoolId);
              
        // 4.执行sql： 建立链接，并启动调用。根据定义返回对应的结果
          var result =  connection.ExecuteSql(sqlQuery);
        // 5.归还链接：归还到连接池中
         _connectionManager.ReturnConnection(connection);
         
         return result;
    }
}

public class DynamicApiManager{
      protected IDynamicApiExecutor _executor;
      private async Task<ExecutionContext> BuildContext(string apiName){
          // var definition = _apiDefinitionRepository.FindAsync(s=>s.Name == apiName);
            return new ExecutionContext();
       }
    
      public async Task<object> ExecuteAsync(string apiName, IDictionary<string, object> input = null){ 
      	  var context = await BuildContext(apiName);
          return await _executor.ExecuteAsync(context, input);
      }
    
    public async Task<bool> CheckPermission(string apiName, string userId){
        var permissions = await repository.GetApiPermissions(apiName);
        return await _permissionManager.CheckPermissions(permissions, userId);
    }
}

using Microsoft.AspNetCore.Http;

protected DynamicApiManager _dynamicApiManager;

[HttpPost("invoke/{apiName}")]
public IActionResult InvokePost(string apiName, IFormCollection formData, IQueryCollection queryParameters)
{
    var input = new Dictionary<string, object>(2);
    // 处理请求体参数
    formData.ForEach(s => input[s.Key] = s.Value);
    // 处理查询参数
    queryParameters.ForEach(s => input[s.Key] = s.Value);
    var result = _dynamicApiManager.ExecuteAsync(apiName, input);
    return Ok(result);
}

[HttpGet("invoke/{apiName}")]
public IActionResult InvokeGet(string apiName,  IQueryCollection queryParameters)
{
    var input = new Dictionary<string, object>(2);
    queryParameters.ForEach(s => input[s.Key] = s.Value);
    var result = _dynamicApiManager.ExecuteAsync(apiName, input);
    return Ok(result);
}

[HttpPut("invoke/{apiName}")]
public IActionResult InvokePut(string apiName, IFormCollection formData, IQueryCollection queryParameters)
{}

[HttpDelete("invoke/{apiName}")]
public IActionResult InvokeDelete(string apiName, IFormCollection formData, IQueryCollection queryParameters)
{}