第31篇 实现数据同步的webapi接口

普宁人

调用接口实现数据同步demo讲解

1.demo整体架构如下

2.SynchronizeModel类库

这个类库是主要用于实体对象模型的转换，包括请求参数实体RequestModel，数据库实体DBEntity，响应数据实体ResponseModel等，
2.1 新建一个数据库实体：

1. /// <summary>
2.    /// 被测件（雷达）模块信息表
3.    /// </summary>
4. [SqlSugar.SugarTable("TestRecordModule")]
5. public class TestRecordModule:EntityBase
6. {
7.     /// <summary>
8.     /// 被测件
9.     /// </summary>
10.     public long TaskTestRecordID { get; set; }
12.     /// <summary>
13.     /// 模块编号
14.     /// </summary>
15.     public string ModuleNumber { get; set; }
17.     /// <summary>
18.     /// 映射位
19.     /// </summary>
20.     public int MapPosition { get; set; }
22.     /// <summary>
23.     /// 模块状态
24.     /// </summary>
25.     public int Status { get; set; }
27.     /// <summary>
28.     /// 创建时间
29.     /// </summary>
30.     public DateTime CreatedTime { get; set; }
32.     /// <summary>
33.     /// 备注
34.     /// </summary>
35.     public string Comment { get; set; }
37.     /// <summary>
38.     /// 模块型号
39.     /// </summary>
40.     public string ModuleType { get; set; }
42.     /// <summary>
43.     /// 测试流程控制状态
44.     /// </summary>
45.     public int TestFlowControlStatus { get; set; }
47.     /// <summary>
48.     /// 批次数
49.     /// </summary>
50.     public int BatchCount { get; set; }
52.     /// <summary>
53.     /// 扫码编号
54.     /// </summary>
55.     public string ScanCodeNumber { get; set; }
57.     /// <summary>
58.     /// 用户ID
59.     /// </summary>
60.     public long UserID { get; set; }
62.     /// <summary>
63.     /// 是否同步
64.     /// </summary>
65.     public SynchronizeStatus IsSynchronize { get; set; }
67.     /// <summary>
68.     /// 产线名称
69.     /// </summary>
70.     public string ProductLineName { get; set; }
71. }

复制代码

2.2 新建响应数据实体：

1. public class ResultModel
2.         {
3.                 public bool Success { get; set; }
4.                 public string Message { get; set; }
5.         }

复制代码

2.3 业务逻辑的同步状态枚举：

1. public enum SynchronizeStatus
2.         {
3.                 None = 0,
4.                 Synchronizing = 1,
5.                 Synchronized = 2,
6.         }

复制代码

3.SynchronizeService类库

主要分几层：
3.1 接口层：IRepository，IService

1. public interface ISynchronizeRepository
2.         {
3.                 Task<ResultModel> AddTestRecordModuleAsync(TestRecordModule entity);
4.                 Task<ResultModel> BatchDataSynchronizeAsync(List<TestRecordModule> entities);
5.         }
7. public interface ISynchronizeService
8.         {
9.                 Task<ResultModel> AddTestRecordModuleAsync(TestRecordModule entity);
10.                 Task<ResultModel> BatchDataSynchronizeAsync(List<TestRecordModule> entities);
11.         }

复制代码

3.2 业务逻辑实现层：RepositoryImpl，ServiceImpl

1. public class BaseRepository<T>
2.         {
3.                 protected SqlSugarClient db;
4.                 public BaseRepository()
5.                 {
6.                         //string conStr = ConfigurationManager.ConnectionStrings["SQLiteConnectionString"].ConnectionString.ToString();
7.                         string conStr = @"E:\\定时服务\\WebApiService\\WebApiService\\DB\\RDS.DCDC.db3";
8.                         SqliteConnectionStringBuilder stringBuilder = new SqliteConnectionStringBuilder { DataSource = conStr };
9.                         db = new SqlSugarClient(new ConnectionConfig()
10.                         {
11.                                 ConnectionString = stringBuilder.ToString(),
12.                                 DbType = DbType.Sqlite,
13.                                 IsAutoCloseConnection = true,//自动释放
14.                                 InitKeyType = InitKeyType.Attribute,
15.                         });
16.                 }
17.    }
20. public class SynchronizeRepositoryImpl : BaseRepository<TestRecordModule>, ISynchronizeRepository
21.         {
22.                 public async Task<ResultModel> AddTestRecordModuleAsync(TestRecordModule entity)
23.                 {
24.                         try
25.                         {
26.                                 //先查询是否已同步过，排除同步重复的数据;
27.                                 var items = this.db.Queryable<TestRecordModule>().Where(t => t.ScanCodeNumber == entity.ScanCodeNumber && t.IsSynchronize == SynchronizeStatus.Synchronized);
28.                                 if (items.Count() > 0)
29.                                 {
30.                                         return new ResultModel { Success = false, Message = "数据已同步过" };
31.                                 }
33.                                 //开启事务
34.                                 await this.db.BeginTranAsync();
35.                                 ResultModel responseModel = new ResultModel();   
36.                                 entity.IsSynchronize = SynchronizeStatus.Synchronized;
37.                                 if (db.Insertable(entity).ExecuteReturnBigIdentity() > 0)
38.                                 {
39.                                         responseModel.Success = true;
40.                                         responseModel.Message = "成功";
41.                                 }
42.                                 else
43.                                 {
44.                                         responseModel.Success = false;
45.                                         responseModel.Message = "失败";
46.                                 }
48.                                 //数据同步完，没有报错，更新IsSynchronize状态
50.                                 //entity.IsSynchronize = Entities.SynchronizeStatus.Synchronized;
51.                                 //await this.db.Updateable(entity).UpdateColumns(t=>t.IsSynchronize == Entities.SynchronizeStatus.Synchronized)
52.                                 //    .WhereColumns(t => t.ScanCodeNumber == entity.ScanCodeNumber).ExecuteCommandAsync();
54.                                 // 提交事务
55.                                 await this.db.Ado.CommitTranAsync();
56.                                 return await Task.FromResult(responseModel);
57.                         }
58.                         catch (Exception ex)
59.                         {
60.                                 //事务回滚
61.                                 await this.db.Ado.RollbackTranAsync();
62.                                 return new ResultModel() { Success = false, Message = "同步失败" };
63.                         }
64.                 }
66.                 public async Task<ResultModel> BatchDataSynchronizeAsync(List<TestRecordModule> entities)
67.                 {
68.                         try
69.                         {
70.                                 ResultModel responseModel = new ResultModel();
71.                                 foreach (var entity in entities)
72.                                 {
73.                                         //先查询是否已同步过，排除同步重复的数据;
74.                                         var items = this.db.Queryable<TestRecordModule>().Where(t => t.ScanCodeNumber == entity.ScanCodeNumber && t.IsSynchronize == SynchronizeStatus.Synchronized);
75.                                         if (items.Count() > 0)
76.                                         {
77.                                                 return new ResultModel { Success = false, Message = "数据已同步过" };
78.                                         }
80.                                         //开启事务
81.                                         await this.db.BeginTranAsync();                  
82.                                         entity.IsSynchronize = SynchronizeStatus.Synchronized;
83.                                         if (db.Insertable(entity).ExecuteReturnBigIdentity() > 0)
84.                                         {
85.                                                 responseModel.Success = true;
86.                                                 responseModel.Message = "成功";
87.                                         }
88.                                         else
89.                                         {
90.                                                 responseModel.Success = false;
91.                                                 responseModel.Message = "失败";
92.                                         }
93.                                 }
95.                                 //数据同步完，没有报错，更新IsSynchronize状态
96.                                 //entity.IsSynchronize = Entities.SynchronizeStatus.Synchronized;
97.                                 //await this.db.Updateable(entity).UpdateColumns(t=>t.IsSynchronize == Entities.SynchronizeStatus.Synchronized)
98.                                 //    .WhereColumns(t => t.ScanCodeNumber == entity.ScanCodeNumber).ExecuteCommandAsync();
100.                                 // 提交事务
101.                                 await this.db.Ado.CommitTranAsync();
102.                                 return await Task.FromResult(responseModel);
103.                         }
104.                         catch (Exception ex)
105.                         {
106.                                 //事务回滚
107.                                 await this.db.Ado.RollbackTranAsync();
108.                                 return new ResultModel() { Success = false, Message = "同步失败" };
109.                         }
110.                 }
111.         }
114. public class SynchronizeServiceImpl : ISynchronizeService
115.         {
116.                 private readonly ISynchronizeRepository _testRecordModuleRepository;
117.                 public SynchronizeServiceImpl(ISynchronizeRepository testRecordModuleRepository)
118.                 {
119.                         _testRecordModuleRepository = testRecordModuleRepository;
120.                 }
121.                 public async Task<ResultModel> AddTestRecordModuleAsync(TestRecordModule entity)
122.                 {
123.                         return await _testRecordModuleRepository.AddTestRecordModuleAsync(entity);
124.                 }
126.                 public async Task<ResultModel> BatchDataSynchronizeAsync(List<TestRecordModule> entities)
127.                 {
128.                         return await _testRecordModuleRepository.BatchDataSynchronizeAsync(entities);
129.                 }
130.         }

复制代码

4.WebApiService，表现层Controller

1. [Route("[controller]/[action]")]
2.         [ApiController]
3.         public class SynchronizeController : ControllerBase
4.         {
5.                 private readonly ISynchronizeService _synchronizeService;
6.                 public SynchronizeController(ISynchronizeService synchronizeService )
7.                 {
8.                         this._synchronizeService = synchronizeService;
9.                 }
11.                 /// <summary>
12.                 /// 单个数据同步
13.                 /// </summary>
14.                 /// <param name="entity"></param>
15.                 /// <returns></returns>
16.                 [HttpPost]
17.                 public async Task<ResultModel> DataSynchronize(TestRecordModule entity)
18.                 {
19.                         entity.IsSynchronize = SynchronizeStatus.Synchronizing;
20.                         var result = this._synchronizeService.AddTestRecordModuleAsync(entity);
21.                         return await result;
22.                 }
25.                 /// <summary>
26.                 /// 批次数据同步
27.                 /// </summary>
28.                 /// <param name="entity"></param>
29.                 /// <returns></returns>
30.                 [HttpPost]
31.                 public async Task<ResultModel> BatchDataSynchronize(List<TestRecordModule> entities)
32.                 {
33.                         var result = this._synchronizeService.BatchDataSynchronizeAsync(entities);
34.                         return await result;
35.                 }
36.         }

复制代码

具体可以访问我的代码库：https://gitee.com/chenshibao/web-api-service.git

来源:https://www.cnblogs.com/chenshibao/p/18456165
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！