智慧城市>> EasyJsonToSql>> 返回
项目作者： grissomlau

项目描述 ：
把 json 结构数据解析成标准的 sql， 实现标准化和自动化的增删改查
高级语言： C#
项目地址: git://github.com/grissomlau/EasyJsonToSql.git
创建时间： 2017-02-28T09:20:10Z
项目社区：https://github.com/grissomlau/EasyJsonToSql
开源协议：MIT License
下载


EasyJsonToSql

把 json 结构数据解析成标准的 sql， 实现标准化和自动化的增删改查

Kick Start

  1. 假设有一张表
    1. CREATE TABLE `BasUser` (
    2. `Id` bigint(20) NOT NULL AUTO_INCREMENT,
    3. `Name` varchar(64) DEFAULT NULL,
    4. PRIMARY KEY (`Id`)
    5. );

  2. 后台配置 sqlconfig

    1.  const string sqlJson = @"
    2.  {
    3.      ""Select"":""user.*"",
    4.      ""From"":""BasUser user"",
    5.      ""Where"":{
    6.          ""Fields"":[
    7.              {""Name"":""Name"",""Cp"":""like""}
    8.          ]
    9.      },
    10.      ""OrderBy"":{""Default"":""Id""},
    11.      ""ID"":""Id"",
    12.      ""Table"":""BasUser"",
    13.      ""Insert"":{
    14.          ""Fields"":[
    15.              {""Name"":""Name"",""IsIgnore"":""false""}
    16.              ]
    17.          }
    18.      }
    19.  ";

  3. 查询 reqeust url: `http://localhost:9819/api/user/get?name=test 

    1.      public dynamic Get(string name)
    2.      {
    3.          var dt = new DataTable(); 
    5.          // 用 json 的配置
    6.          var sqlconfig = JsonConvert.DeserializeObject<SqlConfig>(sqlJson);
    7.          var sqlSb = new StringBuilder();
    8.          var nameValues = new NameValueCollection();
    9.          nameValues.Add("name", name);
    10.          var builder = new Proxy().ToSelectBuilder(sqlconfig, nameValues);
    11.          var builderData = builder.Data;
    12.          sqlSb.AppendFormat("Select {0} From {1} Where {2}", builderData.Select, builderData.From, builderData.Where);
    14.          using (var da = new MySqlDataAdapter(sqlSb.ToString(), cnnStr))
    15.          {
    16.              da.Fill(dt);
    17.          }
    18.          return dt;
    19.      }

    返回结果： [{"Id":1,"Name":"test4"},{"Id":2,"Name":"test1"},{"Id":3,"Name":"test1"},{"Id":4,"Name":"test7"}]

  4. 新增 post url: http://localhost:9819/api/user/post ， form data: {"master":{"inserted":[{"data":{"Name":"test1"}}]}}
  1.   public dynamic Post()
  2.         {
  3.             var json = "";
  4.             using (StreamReader sr = new StreamReader(HttpContext.Current.Request.InputStream))
  5.             {
  6.                 json = sr.ReadToEnd();
  7.             }
  8.             var jobj = JObject.Parse(json); 
  10.             // json 的配置
  11.             var sqlconfig = JsonConvert.DeserializeObject<SqlConfig>(sqlJson);
  12.             var builder = new Proxy().ToDbBuilders(sqlconfig, jobj);
  14.             var insertSqlSb = new StringBuilder();
  15.             //获取第一个sqlconfig
  16.             var data = builder[0].Data;
  17.             insertSqlSb.AppendFormat("insert into {0}(", data.TableName);
  18.             var valueSqlSb = new StringBuilder();
  19.             var paras = new List<MySqlParameter>();
  20.             foreach (var dbField in data.Fields)
  21.             {
  22.                 // 不是自增的字段才添加
  23.                 if (!dbField.IsId)
  24.                 {
  25.                     insertSqlSb.AppendFormat("{0}", dbField.DbName);
  26.                     valueSqlSb.AppendFormat("@{0}", dbField.DbName);
  27.                     paras.Add(new MySqlParameter("@" + dbField.DbName, dbField.Value));
  28.                 }
  29.             }
  30.             insertSqlSb.AppendFormat(") values({0})", valueSqlSb);
  32.             var affectCount = 0;
  33.             using (var cnn = new MySqlConnection(cnnStr))
  34.             {
  35.                 using (var cmd = new MySqlCommand(insertSqlSb.ToString(), cnn))
  36.                 {
  37.                     cnn.Open();
  38.                     cmd.Parameters.AddRange(paras.ToArray());
  39.                     affectCount = cmd.ExecuteNonQuery();
  40.                 }
  41.             }
  42.             return affectCount;
  43.         }

上面可看到 get 和 post 方法是脱离业务的，所有业务都在 sqlJson 配置和 前端返回的 json 数据，从而实现了后台配置化操作数据库，不需创建额外的对象，就可以把前端返回的json 数据， 直接持久化到数据库了。

简介

Proxy

这个类是 EasyJsonToSql 入口，用来获取 SelectBuilder 和 DbBuilder 对象。

方法

  1. 获取 SelectBuilder
  1.     const string sqlJson = @"
  2.     {
  3.         ""Select"":""user.*"",
  4.         ""From"":""BasUser user"",
  5.         ""Where"":{
  6.             ""Fields"":[
  7.                 {""Name"":""Name"",""Cp"":""like""}
  8.             ]
  9.         },
  10.         ""OrderBy"":{""Default"":""Id""},
  11.         ""ID"":""Id"",
  12.         ""Table"":""BasUser"",
  13.         ""Insert"":{
  14.             ""Fields"":[
  15.                 {""Name"":""Name"",""IsIgnore"":""false""}
  16.                 ]
  17.             }
  18.         }
  19.     ";
  21.     var sqlconfig = JsonConvert.DeserializeObject<SqlConfig>(sqlJson);
  22.     var builder = new Proxy().ToSelectBuilder(sqlconfig, nameValues);
  1. 获取 DbBuilder
  2.    // 插入数据
  3.     var postJson = @"{""master"":{""inserted"":[{""data"":{""Name"":""abc1""}}]}}";
  5.      var jobj = JObject.Parse(postJson);
  6.     var sqlconfig = JsonConvert.DeserializeObject<SqlConfig>(sqlJson);
  7.     var builder = new Proxy().ToDbBuilders(sqlconfig, jobj);

SelectBuilder

该类负责处理查询分析，把 json 转换成查询的 sql。

关键属性

  1. Data[SelectBuilderData]： 生成的 sql 对象。

常用方法

  1. AddWhere: 添加 where 条件 sql, 
  1.  builder.AddWhere("And table1.Id = 1");
  2.  builder.AddWhere("And table1.Id = @Id").AddParam（"Id",1);
  1. AddParam: 添加参数, builder.AddParam("Id",1)

用法演示

  2. var data = builder.Data;
  3. var sql = string.format("Select {0} From {1} Where {2}", data.Select, data.From, data.Where);

DbBuilder

该类负责处理增删改分析，把 json 转换成增删改的 sql。

关键属性

  1. Data[BuilderData]: 生成的 sql 对象。

常用方法

  1. AddChild: 添加子表对象。
  2. AddWhere: 添加 where 条件 sql; 
    1. builder.AddWhere("And table1.Id = 1");
    2. builder.AddWhere("And table1.Id = @Id").AddParam("Id", 1);
  3. AddParam: 添加参数， builder.AddParam("Id",1);

SqlConfig

该类保存 select、from、where、insert、update、delete， 以及子表、依赖关系、自增字段、主键等 sql 相关对象，标准化 sql 配置以便脱离具体业务。
用来初始化 SelectBuilder 和 DBBuilder， 实现标准化的增删改查操作。
上面就是用 json 配置的来反射出 SqlConfig, var sqlconfig = JsonConvert.DeserializeObject<SqlConfig>(sqlJson);

关键字段

  1. public class SqlConfig
  2. {
  3.     public SqlConfig()
  4.     {
  5.         this.Where = new Where();
  6.         this.Children = new List<SqlConfig>();
  7.         this.OrderBy = new OrderBy();
  8.         this.GroupBy = new GroupBy();
  9.         this.Dependency = new Dependency();
  10.         this.Insert = new Insert();
  11.         this.Update = new Update();
  12.         this.Delete = new Delete();
  13.         this.SingleQuery = new SingleQuery();
  14.         this.Export = new Export();
  15.         this.Import = new Import();
  16.         this.BillCodeRule = new BillCodeRule();
  17.     }
  19.     private string _settingName;
  20.     /// <summary>
  21.     /// 配置名称，默认和表名一致，一般不会用到，方法以后扩展,如一个配置文件出现相同的表时，用来区分不同的配置
  22.     /// </summary>
  23.     public string SettingName
  24.     {
  25.         get
  26.         {
  27.             if (string.IsNullOrEmpty(_settingName))
  28.             {
  29.                 _settingName = Table;
  30.             }
  31.             return _settingName;
  32.         }
  33.         set
  34.         {
  35.             _settingName = value;
  36.         }
  37.     }
  39.     #region 查询配置
  40.     /// <summary>
  41.     /// 查询的字段
  42.     /// </summary>
  43.     public string Select { get; set; }
  44.     /// <summary>
  45.     /// 查询的表名以及关联的表名，如 left join, right join
  46.     /// </summary>
  47.     public string From { get; set; }
  48.     /// <summary>
  49.     /// 查询的条件
  50.     /// 前端返回的查询条件，只有出现在这些配置好的字段，才会生成为了 sql 的 where 条件，
  51.     /// 没出现的字段会被忽略
  52.     /// </summary>
  53.     public Where Where { get; set; }
  54.     /// <summary>
  55.     /// 分页时必须会乃至的排序规则
  56.     /// </summary>
  57.     public OrderBy OrderBy { get; set; }
  59.     public GroupBy GroupBy { get; set; }
  60.     /// <summary>
  61.     /// 页码
  62.     /// </summary>
  63.     public int PageNumber { get; set; }
  64.     /// <summary>
  65.     /// 页大小
  66.     /// </summary>
  67.     public int PageSize { get; set; }
  70.     #endregion 查询配置
  72.     /// <summary>
  73.     /// 指定该配置所属于的表
  74.     /// </summary>
  75.     public string Table { get; set; }
  77.     #region 增删改配置
  78.     /// <summary>
  79.     /// 对应前端返回的 json 格式数据的键名
  80.     /// e.g.: {master:{inserted:[{data:{}}]}} 中的 master 就是这里要对应的 JsonName
  81.     /// 注意默认主表的 jsonName 是 master， 所以主表一般可省略不写, 但子表必须得指定
  82.     /// </summary>
  83.     public string JsonName { get; set; }
  84.     /// <summary>
  85.     /// 自增的字段,指定了自增的字段，在 insert 时会自动忽略该字段
  86.     /// </summary>
  87.     public string ID { get; set; }
  88.     /// <summary>
  89.     /// 主键, 在保存成功后会返回主键的值; 
  90.     /// </summary>
  91.     public string PKs { get; set; }
  92.     /// <summary>
  93.     /// 唯一值的字段，对应数据库 unique, 在 insert,update 前会判断是否已存在
  94.     /// </summary>
  95.     public string Uniques { get; set; }
  96.     /// <summary>
  97.     /// 唯一值的字段的值是否允许为空
  98.     /// </summary>
  99.     public string UniqueAllowEmptys { get; set; }
  100.     /// <summary>
  101.     /// 所属的父级配置, 在 xml 中不用指定，程序会自动分析
  102.     /// </summary>
  103.     public SqlConfig Parent { get; set; }
  104.     /// <summary>
  105.     /// 包含的子级配置, 即子表的配置，需要在 xml 中配置
  106.     /// </summary>
  107.     public List<SqlConfig> Children { get; set; }
  108.     /// <summary>
  109.     /// 依赖父表的字段
  110.     /// </summary>
  111.     public Dependency Dependency { get; set; }
  112.     /// <summary>
  113.     /// insert 的配置
  114.     /// </summary>
  115.     public Insert Insert { get; set; }
  116.     /// <summary>
  117.     /// update 的配置
  118.     /// </summary>
  119.     public Update Update { get; set; }
  120.     /// <summary>
  121.     /// delete 的配置
  122.     /// </summary>
  123.     public Delete Delete { get; set; }
  124.     #endregion
  125.     /// <summary>
  126.     /// 单条记录查询的配置，一般用在配置列表双击弹出那条记录的获取的 sql 
  127.     /// </summary>
  128.     public SingleQuery SingleQuery { get; set; }
  129.     /// <summary>
  130.     /// 导出配置
  131.     /// </summary>
  132.     public Export Export { get; set; }
  133.     /// <summary>
  134.     /// 导入配置
  135.     /// </summary>
  136.     public Import Import { get; set; }
  137.     /// <summary>
  138.     /// 是否物理删除?
  139.     /// </summary>
  140.     public bool DeleteAnyway { get; set; }
  141.     /// <summary>
  142.     /// 表单编码的生成配置
  143.     /// </summary>
  144.     public BillCodeRule BillCodeRule { get; set; }
  147. }

用法

  1. xml 配置

    1. string sqlXml = @"
    2. <SqlConfig>
    3.  <Select>
    4.      user.*
    5.  </Select>
    6.  <From>
    7.      BasUser user
    8.  </From>
    9.  <Where>
    10.      <Fields>
    11.          <Field Name=""Name"" Cp=""like""></Field>
    12.      </Fields>
    13.  </Where>
    14.  <OrderBy>
    15.      <Default>Id</Default>
    16.  </OrderBy>
    17.  <IDs>Id</IDs>
    18.  <PKs>Id</PKs>
    19.  <Table>BasUser</Table>
    20.  <Insert>
    21.      <Fields>
    22.          <Field Name=""Name"" IsIgnore=""false""></Field>
    23.      </Fields>
    24.  </Insert>
    25. </SqlConfig>
    26.          ";
  2. json 配置 
    1. string sqlJson = @"
    2. {
    3.  ""Select"":""user.*"",
    4.  ""From"":""BasUser user"",
    5.  ""Where"":{
    6.      ""Fields"":[
    7.          {""Name"":""Name"",""Cp"":""like""}
    8.      ]
    9.  },
    10.  ""OrderBy"":{""Default"":""Id""},
    11.  ""ID"":""Id"",
    12.  ""PKs"":""Id"",
    13.  ""Table"":""BasUser"",
    14.  ""Insert"":{
    15.      ""Fields"":[
    16.          {""Name"":""Name"",""IsIgnore"":""false""}
    17.          ]
    18.      }
    19.  }
    20. ";
    21. var sqlconfig = JsonConvert.DeserializeObject<SqlConfig>(sqlJson);