中國工信部今(22)日發布《車輛生產企業及產品公告》(第254批)，公示了三家新增車輛生產企業的名單，公示時間為22日-28日。其中萬向電動汽車有限公司名列其中。

此前，萬向在電動汽車相關領域投入重資，雖已經初步形成車載電子系統、動力電池和電動汽車領等較完整的產業鏈，但在國內市場上，作為從事電動汽車相關業務的公司，仍缺少工信部認證的資質。

2013年1月，萬向成功收購美國A123，完善了電池產業鏈條，借全球知名企業品牌優勢，擴大了其在美國市場的銷售份額。

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※新北清潔公司,居家、辦公、裝潢細清專業服務

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※超省錢租車方案

※教你寫出一流的銷售文案?

※網頁設計最專業,超強功能平台可客製化

1.簡介

Jmeter官網對邏輯控制器的解釋是：“Logic Controllers determine the order in which Samplers are processed.”。

意思是說，邏輯控制器可以控制採樣器(samplers)的執行順序。由此可知，控制器需要和採樣器一起使用，否則控制器就沒有什麼意義了。放在控制器下面的所有的採樣器都會當做一個整體，執行時也會一起被執行。

JMeter邏輯控制器可以對元件的執行邏輯進行控制，除僅一次控制器外，其他可以嵌套別的種類的邏輯控制器。

2.邏輯控制器分類

JMeter中的Logic Controller分為兩類：
（1）控制測試計劃執行過程中節點的邏輯執行順序，如：Loop Controller、If Controller等；
（2）對測試計劃中的腳本進行分組、方便JMeter統計執行結果以及進行腳本的運行時控制等，如：Throughput Controller、Transaction Controller。

3.預覽邏輯控制器 

首先我們來看一下JMeter的邏輯控制器，路徑：線程組（用戶）->添加->邏輯控制器（Logic Controller）；我們可以清楚地看到JMeter5中共有17個邏輯控制器，如下圖所示：

如果上圖您看得不是很清楚的話，宏哥總結了一個思維導圖，關於JMeter5的邏輯控制器類型，如下圖所示： 

 通過以上的了解，我們對邏輯控制器有了一個大致的了解和認識。下面宏哥就給小夥伴或則童鞋們分享講解一些通常在工作中會用到的邏輯控制器。 

4.常用邏輯控制器詳解

　　這一小節，宏哥就由上而下地詳細地講解一下常用的邏輯控制器。

4.1Runtime Controller

運行控制器用來控制其子元件的執行時長。市場單位是秒。

 1、我們先來看看這個Runtime Controller長得是啥樣子，路徑：線程組 > 添加 > 邏輯控制器 > 運行控制器，如下圖所示：

2、關鍵參數說明如下：

Name：名稱，可以隨意設置，甚至為空；

Comments：註釋，可隨意設置，可以為空；

Runtime：默認為1，去掉1則默認為0，此時不執行其節點下的元件。 與線程組中的調度器的持續時間 效果一致。不填 或 0，不會執行樣例

4.1.1Runtime控制器控制其下取樣器執行2s

1、創建測試計劃，設置 Runtime 控制器的運行時間 為 2，線程組設置默認不變，如下圖所示：

Runtime 控制器設置

線程組設置

2、配置好以後，運行JMeter，然後查看結果樹，如下圖所示：

4.1.2使用線程組中的調度器控制樣例運行3s

1、創建測試計劃，設置 Runtime 控制器的運行時間 為 2，線程組設置運行時間3，如下圖所示：

線程組設置

Runtime 控制器設置

2、配置好以後，運行JMeter，然後查看結果樹，如下圖所示：

線程組設置3,Runtime控制器設置2，但是運行時間是2s。所以從上邊的運行時間得出結論：如果線程組中設置了持續時間，Runtime 控制器也設置了 運行時間，那麼會優先於線程組中的設置。

4.2Simple Controller

Simple Controller用來指定了一個執行單元，它不改變元件的執行順序。在它下邊還可以嵌套其他控制器。簡單控制器可以編輯只有名稱和註釋。就像他的名字一樣，簡單，可以理解為一個文件夾，就是分組用的，沒有其他特殊功能，但相比不添加簡單控制器，區別在於簡單控制器可以被模塊控制器所引用。其作用就是分組，比如QQ好友列表，可分為家人、同學、等。一般是請求較多，需要分組時採用。

 1、我們先來看看這個Simple Controller長得是啥樣子，路徑：線程組 > 添加 > 邏輯控制器 > 簡單控制器，如下圖所示：

2、關鍵參數說明如下：

Name：名稱，可以隨意設置，甚至為空；

Comments：註釋，可隨意設置，可以為空。

4.2.1簡單實例

1、創建測試計劃，線程組設置循環10，如下圖所示：

2、配置好以後，運行JMeter，然後查看結果樹，如下圖所示：

4.3Throughput Controller

用來控制其下元件的執行次數，並無控制吞吐量的功能，想要控制吞吐量可以使用Constant Throughput Timer，後邊會講解到。吞吐量控制器有兩種模式：Total Executions：設置運行次數與Percent Executions：設置運行比例(1~100之間)。

1、我們先來看看這個Throughput Controller長得是啥樣子，路徑：線程組 > 添加 > 邏輯控制器 > 吞吐量控制器，如下圖所示： 

2、關鍵參數說明如下：

Name：名稱，可以隨意設置，甚至為空；

Comments：註釋，可隨意設置，可以為空；

Total Executions：執行百分比（1-100）；

percent Executions：執行數量；

Throughput：根據上邊選擇的方式填寫，百分比為0~100；

Per User：線程數，當選Total Executions時，是線程數；當選percent Executions時，是線程數*循環次數。

4.3.1不勾選Per User

1、線程組中設置 線程數量 2，循環次數 10，吞吐量控制器 設置 Total Executions，吞吐量設置為 2，其下添加一個取樣器，如下圖所示：

2、配置好以後，運行JMeter，然後查看結果樹（執行了2次），如下圖所示：

3、現在將 吞吐量控制器 設置為百分比的控制方式，吞吐量設置為：50%，如下圖所示：

4、配置好以後，點擊“保存”運行JMeter，然後查看結果樹（執行了10次，計算方式：10=吞吐量50% * 循環次數10 * 線程數 2），如下圖所示：

4.3.2勾選Per User

1、線程組中設置 線程數量 2，循環次數 10，吞吐量控制器 設置 Total Executions，吞吐量設置為 2，其下添加一個取樣器，勾選Per User，如下圖所示：

線程組設置

吞吐量控制器

2、配置好以後，點擊“保存”，運行JMeter，然後查看結果樹（總共執行了4次，其中吞吐量設置為2，執行2次，線程設置為2，執行2次，總共4次），函數 __threadNum 只是簡單地返回當前線程的編號，如下圖所示：

3、現在將 吞吐量控制器 設置為百分比的控制方式，吞吐量設置為：50，如下圖所示：

4、配置好以後，點擊“保存”運行JMeter，然後查看結果樹（執行了10次，計算方式：10=吞吐量50% * 循環次數10 * 線程數 2），如下圖所示：

綜上所述：

勾選Per User：

1.線程數*循環次數>=線程數*吞吐量時，Total Executions模式的執行次數=線程數*吞吐量。

2.線程數*循環次數<線程數*吞吐量時，Total Executions模式的執行次數=當線程數*循環次數。

不勾選Per User：

1.線程數*循環次數<=吞吐量時，Total Executions模式的執行次數=線程數*循環次數。

2.線程數*循環次數>吞吐量時，Total Executions模式的執行次數=吞吐量。

l Percent Executions：設置運行比例(1~100之間)，單位為%

不管Per User是否勾選，按Percent Executions模式的執行次數都不受Per User影響，Percent Executions模式的執行次數=線程數*循環次數*吞吐量%。（循環次數=線程組循環次數*循環控制器循環次數）

l Per User：勾選該項的話則按虛擬用戶數（線程數）來計算執行次數，不勾選則按所有虛擬用戶數來計算執行次數

測試計劃

序號	線程數	循環次數	模式	Throughput	Per User	執行次數
1	2	10	Percent	50	Y	10
2	2	10	Percent	50	N	10
3	2	10	Total	7	Y	14
4	2	10	Total	7	N	7
5	2	2	Total	7	Y	4
6	2	2	Total	7	N	4

下面說明一下這6個場景：
（1）序號1和2場景，Per User 對總執行次數沒有影響。
（2）序號3場景，Per User勾選，每個虛擬用戶（線程）執行7次，共執行14次。
（3）序號4場景，Per User不勾選，則所有虛擬用戶執行7次。
（4）序號5場景，Per User勾選，每個虛擬用戶（線程）執行7次，共執行14次，由於Thread Group計劃循環次數是4（2線程*2循環）次，所以最多只能執行4次。
（5）序號6場景，Per User不勾選，所有虛擬用戶執行7次，由於Thread Group計劃循環次數是4（2線程*2循環）次，所以最多只能執行4次。

4.4Module Controller

模塊控制器可以快速的切換腳本，不用來回的新建，方便腳本調試。 

可以理解為引用、調用的意思，執行內容為Module To Run種所選的內容，引用範圍為當前測試計劃內的測試片段、邏輯控制器<模塊控制器除外>
被引用的邏輯控制器、測試片段可以為禁用狀態，被引用后仍然會被執行。
可以將模塊控制器與包括控制器一起學習比較，模塊控制器是從內部文件中引用，引用上相對比較靈活，可以只引用部分測試片段或模塊內容，包括控制器是從外部文件引用，只能引用整個測試片段的內容。
注意：被應用的模塊位置不可隨意變更，變更後會執行時出現提示引用失敗
找到目標元素：快速查找與跳轉的作用，點擊後會立即跳轉到所選的邏輯控制器的內容詳情

1、我們先來看看這個Module Controller長得是啥樣子，路徑：線程組 > 添加 > 邏輯控制器 >  模塊控制器，如下圖所示： 

2、關鍵參數說明如下：

Name：名稱，可以隨意設置，甚至為空；

Comments：註釋，可隨意設置，可以為空；

Forever：勾選上這一項表示一直循環下去。

4.4.1實例

1、創建測試計劃，添加兩個測試片段，並且在每個測試片段下添加一個取樣器，然後，添加線程組，再添加模塊控制器，最後添加查看結果樹，如下圖所示：

2、配置模塊控制器，選擇第一個測試片段，如下圖所示：

3、配置好以後，點擊“保存”運行JMeter，然後查看結果樹（執行了第1個測試片段的取樣器），如下圖所示：

4、配置模塊控制器，選擇第二個測試片段，如下圖所示： 

5、配置好以後，點擊“保存”運行JMeter，然後查看結果樹（執行了第2個測試片段的取樣器），如下圖所示：

4.5Switch Controller

Switch Controller：開關控制器，通過其下樣例順序數值或名稱 控制執行某一個樣例。

 1、我們先來看看這個if Controller長得是啥樣子，路徑：線程組 > 添加 > 邏輯控制器 > 如果 (if) 控制器，如下圖所示：

2、關鍵參數說明如下：

Name：名稱，可以隨意設置，甚至為空；

Comments：註釋，可隨意設置，可以為空；

Switch Value：指定請求的索引或者名稱，索引從0開始，如果沒有賦值，或者索引超過請求個數的話就執行第0個請求。可以是数字，也可以是字符，為字符時匹配取樣器名稱，如果匹配不上就會默認並找取樣器名稱為default的取樣器，如果沒有則不運行。

4.5.1數值

數值：表示將執行其下第 數值+1個取樣器，例如：填1，將執行第2個取樣器；填0或者不填，將執行第1個取樣器；數值超出其下取樣器數目時，執行第1個取樣器。

1、創建一個測試計劃，設置線程組和Switch控制器，如下圖所示：

線程組

Switch控制器

2、配置好以後，點擊“保存”運行JMeter，然後查看結果樹（執行了第3<數值+1>個取樣器），如下圖所示：

3、修改Switch控制器的數值為0或者不填，如下圖所示：

4、配置好以後，點擊“保存”運行JMeter，然後查看結果樹（執行了第1<數值為0或者不填，執行第1個取樣器>個取樣器），如下圖所示：

4.5.2字符

1、創建一個測試計劃，設置線程組和Switch控制器（直接使用取樣器名字），如下圖所示：

線程組

Switch控制器

2、配置好以後，點擊“保存”運行JMeter，然後查看結果樹（執行了使用名字的取樣器），如下圖所示：

5.小結

好了，今天關於邏輯控制器的上篇就講解到這裏，這一篇主要介紹了 Runtime Controller 、 Simple Controller 、Throughput Controller、Module Controller 和  Switch Controller。

 

您的肯定就是我進步的動力。如果你感覺還不錯，就請鼓勵一下吧！記得隨手點波  推薦  不要忘記哦！！！

別忘了點 推薦 留下您來過的痕迹

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

-之動態查詢,查詢邏輯封裝復用

基於領域驅動設計(DDD)超輕量級快速開發架構詳細介紹請看

https://www.cnblogs.com/neozhu/p/13174234.html

需求

1. 配合EasyUI datagird filter實現多字段(任意字段)的篩選
2. 根據業務需求篩選特定的狀態或條件,如:查看結案的訂單,最近30天的訂單,查看屬於我的訂單.等等,這些邏輯是固定也是可以被重用,但又不想每次寫相同的條件,那麼下面我會給我的解決方案.

需求1隻是一個偷懶的實現方式,因為datagrid自帶這個功能,但又不想根據具體的需求來畫查詢條件,如果需求必須要再datagrid上面做一塊查詢條件的輸入那目前只能在前端自己手工添加,在組織後傳入後台,暫時不在這裏討論

需求2可能不太好解釋,看完代碼就自然理解為什麼要這麼做了,這麼做的好處有哪些

具體實現的方式

 

 默認情況下 datagrid 有幾列就可以對這幾列進行篩選,對於日期型的字段會採用between,選擇2個時間之間進行篩選,数字類型會提供大於小於等符號選擇,可以自行嘗試,其原理是datagrid 會根據datagrid 頭部輸入的值生成一個Json字符串發送後台請求數據

JSON:格式

filterRules: [
{field:field,op:op,value:value},

{field:field,op:op,value:value},

] 

• 通常的做法是一個一個判斷加條件

  1 var filters = JsonConvert.DeserializeObject<IEnumerable<filterRule>>(filterRules); 
  2 foreach (var rule in filters)
  3         {
  4           if (rule.field == "Id" && !string.IsNullOrEmpty(rule.value) && rule.value.IsInt())
  5           {
  6             var val = Convert.ToInt32(rule.value);
  7             switch (rule.op)
  8             {
  9               case "equal":
 10                 this.And(x => x.Id == val);
 11                 break;
 12               case "notequal":
 13                 this.And(x => x.Id != val);
 14                 break;
 15               case "less":
 16                 this.And(x => x.Id < val);
 17                 break;
 18               case "lessorequal":
 19                 this.And(x => x.Id <= val);
 20                 break;
 21               case "greater":
 22                 this.And(x => x.Id > val);
 23                 break;
 24               case "greaterorequal":
 25                 this.And(x => x.Id >= val);
 26                 break;
 27               default:
 28                 this.And(x => x.Id == val);
 29                 break;
 30             }
 31           }
 32           if (rule.field == "Name" && !string.IsNullOrEmpty(rule.value))
 33           {
 34             this.And(x => x.Name.Contains(rule.value));
 35           }
 36           if (rule.field == "Code" && !string.IsNullOrEmpty(rule.value))
 37           {
 38             this.And(x => x.Code.Contains(rule.value));
 39           }
 40 
 41           if (rule.field == "Address" && !string.IsNullOrEmpty(rule.value))
 42           {
 43             this.And(x => x.Address.Contains(rule.value));
 44           }
 45 
 46           if (rule.field == "Contect" && !string.IsNullOrEmpty(rule.value))
 47           {
 48             this.And(x => x.Contect.Contains(rule.value));
 49           }
 50 
 51           if (rule.field == "PhoneNumber" && !string.IsNullOrEmpty(rule.value))
 52           {
 53             this.And(x => x.PhoneNumber.Contains(rule.value));
 54           }
 55 
 56           if (rule.field == "RegisterDate" && !string.IsNullOrEmpty(rule.value))
 57           {
 58             if (rule.op == "between")
 59             {
 60               var datearray = rule.value.Split(new char[] { '-' });
 61               var start = Convert.ToDateTime(datearray[0]);
 62               var end = Convert.ToDateTime(datearray[1]);
 63 
 64               this.And(x => SqlFunctions.DateDiff("d", start, x.RegisterDate) >= 0);
 65               this.And(x => SqlFunctions.DateDiff("d", end, x.RegisterDate) <= 0);
 66             }
 67           }
 68           if (rule.field == "CreatedDate" && !string.IsNullOrEmpty(rule.value))
 69           {
 70             if (rule.op == "between")
 71             {
 72               var datearray = rule.value.Split(new char[] { '-' });
 73               var start = Convert.ToDateTime(datearray[0]);
 74               var end = Convert.ToDateTime(datearray[1]);
 75 
 76               this.And(x => SqlFunctions.DateDiff("d", start, x.CreatedDate) >= 0);
 77               this.And(x => SqlFunctions.DateDiff("d", end, x.CreatedDate) <= 0);
 78             }
 79           }
 80 
 81 
 82           if (rule.field == "CreatedBy" && !string.IsNullOrEmpty(rule.value))
 83           {
 84             this.And(x => x.CreatedBy.Contains(rule.value));
 85           }
 86 
 87          if (rule.field == "LastModifiedDate" && !string.IsNullOrEmpty(rule.value))
 88           {
 89             if (rule.op == "between")
 90             {
 91               var datearray = rule.value.Split(new char[] { '-' });
 92               var start = Convert.ToDateTime(datearray[0]);
 93               var end = Convert.ToDateTime(datearray[1]);
 94 
 95               this.And(x => SqlFunctions.DateDiff("d", start, x.LastModifiedDate) >= 0);
 96               this.And(x => SqlFunctions.DateDiff("d", end, x.LastModifiedDate) <= 0);
 97             }
 98           }
 99 
100           if (rule.field == "LastModifiedBy" && !string.IsNullOrEmpty(rule.value))
101           {
102             this.And(x => x.LastModifiedBy.Contains(rule.value));
103           }
104 
105         }

View Code

• 新的做法是動態根據field,op,value生成一個linq 表達式,不用再做繁瑣的判斷,這塊代碼也可以被其它項目使用,非常好用

namespace SmartAdmin
{
 
  public static class PredicateBuilder
  {

    public static Expression<Func<T, bool>> FromFilter<T>(string filtergroup) {
      Expression<Func<T, bool>> any = x => true;
      if (!string.IsNullOrEmpty(filtergroup))
      {
        var filters = JsonSerializer.Deserialize<filter[]>(filtergroup);

          foreach (var filter in filters)
          {
            if (Enum.TryParse(filter.op, out OperationExpression op) && !string.IsNullOrEmpty(filter.value))
            {
              var expression = GetCriteriaWhere<T>(filter.field, op, filter.value);
              any = any.And(expression);
            }
          }
      }

      return any;
    }

    #region -- Public methods --
    public static Expression<Func<T, bool>> GetCriteriaWhere<T>(Expression<Func<T, object>> e, OperationExpression selectedOperator, object fieldValue)
    {
      var name = GetOperand<T>(e);
      return GetCriteriaWhere<T>(name, selectedOperator, fieldValue);
    }

    public static Expression<Func<T, bool>> GetCriteriaWhere<T, T2>(Expression<Func<T, object>> e, OperationExpression selectedOperator, object fieldValue)
    {
      var name = GetOperand<T>(e);
      return GetCriteriaWhere<T, T2>(name, selectedOperator, fieldValue);
    }

    public static Expression<Func<T, bool>> GetCriteriaWhere<T>(string fieldName, OperationExpression selectedOperator, object fieldValue)
    {
      var props = TypeDescriptor.GetProperties(typeof(T));
      var prop = GetProperty(props, fieldName, true);
      var parameter = Expression.Parameter(typeof(T));
      var expressionParameter = GetMemberExpression<T>(parameter, fieldName);
      if (prop != null && fieldValue != null)
      {
       
        BinaryExpression body = null;
        switch (selectedOperator)
        {
          case OperationExpression.equal:
            body = Expression.Equal(expressionParameter, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType)?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(body, parameter);
          case OperationExpression.notequal:
            body = Expression.NotEqual(expressionParameter, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(body, parameter);
          case OperationExpression.less:
            body = Expression.LessThan(expressionParameter, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(body, parameter);
          case OperationExpression.lessorequal:
            body = Expression.LessThanOrEqual(expressionParameter, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(body, parameter);
          case OperationExpression.greater:
            body = Expression.GreaterThan(expressionParameter, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(body, parameter);
          case OperationExpression.greaterorequal:
            body = Expression.GreaterThanOrEqual(expressionParameter, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(body, parameter);
          case OperationExpression.contains:
            var contains = typeof(string).GetMethod("Contains", new[] { typeof(string) });
            var bodyLike = Expression.Call(expressionParameter, contains, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(bodyLike, parameter);
          case OperationExpression.endwith:
            var endswith = typeof(string).GetMethod("EndsWith",new[] { typeof(string) });
            var bodyendwith = Expression.Call(expressionParameter, endswith, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(bodyendwith, parameter);
          case OperationExpression.beginwith:
            var startswith = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });
            var bodystartswith = Expression.Call(expressionParameter, startswith, Expression.Constant(Convert.ChangeType(fieldValue, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType), prop.PropertyType));
            return Expression.Lambda<Func<T, bool>>(bodystartswith, parameter);
          case OperationExpression.includes:
            return Includes<T>(fieldValue, parameter, expressionParameter, prop.PropertyType);
          case OperationExpression.between:
            return Between<T>(fieldValue, parameter, expressionParameter, prop.PropertyType);
          default:
            throw new Exception("Not implement Operation");
        }
      }
      else
      {
        Expression<Func<T, bool>> filter = x => true;
        return filter;
      }
    }

    public static Expression<Func<T, bool>> GetCriteriaWhere<T, T2>(string fieldName, OperationExpression selectedOperator, object fieldValue)
    {


      var props = TypeDescriptor.GetProperties(typeof(T));
      var prop = GetProperty(props, fieldName, true);

      var parameter = Expression.Parameter(typeof(T));
      var expressionParameter = GetMemberExpression<T>(parameter, fieldName);

      if (prop != null && fieldValue != null)
      {
        switch (selectedOperator)
        {
          case OperationExpression.any:
            return Any<T, T2>(fieldValue, parameter, expressionParameter);

          default:
            throw new Exception("Not implement Operation");
        }
      }
      else
      {
        Expression<Func<T, bool>> filter = x => true;
        return filter;
      }
    }



    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr, Expression<Func<T, bool>> or)
    {
      if (expr == null)
      {
        return or;
      }

      return Expression.Lambda<Func<T, bool>>(Expression.OrElse(new SwapVisitor(expr.Parameters[0], or.Parameters[0]).Visit(expr.Body), or.Body), or.Parameters);
    }

    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr, Expression<Func<T, bool>> and)
    {
      if (expr == null)
      {
        return and;
      }

      return Expression.Lambda<Func<T, bool>>(Expression.AndAlso(new SwapVisitor(expr.Parameters[0], and.Parameters[0]).Visit(expr.Body), and.Body), and.Parameters);
    }

    #endregion
    #region -- Private methods --

    private static string GetOperand<T>(Expression<Func<T, object>> exp)
    {
      if (!( exp.Body is MemberExpression body ))
      {
        var ubody = (UnaryExpression)exp.Body;
        body = ubody.Operand as MemberExpression;
      }

      var operand = body.ToString();

      return operand.Substring(2);

    }

    private static MemberExpression GetMemberExpression<T>(ParameterExpression parameter, string propName)
    {
      if (string.IsNullOrEmpty(propName))
      {
        return null;
      }

      var propertiesName = propName.Split('.');
      if (propertiesName.Count() == 2)
      {
        return Expression.Property(Expression.Property(parameter, propertiesName[0]), propertiesName[1]);
      }

      return Expression.Property(parameter, propName);
    }

    private static Expression<Func<T, bool>> Includes<T>(object fieldValue, ParameterExpression parameterExpression, MemberExpression memberExpression ,Type type)
    {
      var safetype= Nullable.GetUnderlyingType(type) ?? type;

      switch (safetype.Name.ToLower())
      {
        case  "string":
          var strlist = (IEnumerable<string>)fieldValue;
          if (strlist == null || strlist.Count() == 0)
          {
            return x => true;
          }
          var strmethod = typeof(List<string>).GetMethod("Contains", new Type[] { typeof(string) });
          var strcallexp = Expression.Call(Expression.Constant(strlist.ToList()), strmethod, memberExpression);
          return Expression.Lambda<Func<T, bool>>(strcallexp, parameterExpression);
        case "int32":
          var intlist = (IEnumerable<int>)fieldValue;
          if (intlist == null || intlist.Count() == 0)
          {
            return x => true;
          }
          var intmethod = typeof(List<int>).GetMethod("Contains", new Type[] { typeof(int) });
          var intcallexp = Expression.Call(Expression.Constant(intlist.ToList()), intmethod, memberExpression);
          return Expression.Lambda<Func<T, bool>>(intcallexp, parameterExpression);
        case "float":
          var floatlist = (IEnumerable<float>)fieldValue;
          if (floatlist == null || floatlist.Count() == 0)
          {
            return x => true;
          }
          var floatmethod = typeof(List<int>).GetMethod("Contains", new Type[] { typeof(int) });
          var floatcallexp = Expression.Call(Expression.Constant(floatlist.ToList()), floatmethod, memberExpression);
          return Expression.Lambda<Func<T, bool>>(floatcallexp, parameterExpression);
        default:
          return x => true;
      }
      
    }
    private static Expression<Func<T, bool>> Between<T>(object fieldValue, ParameterExpression parameterExpression, MemberExpression memberExpression, Type type)
    {
      
      var safetype = Nullable.GetUnderlyingType(type) ?? type;
      switch (safetype.Name.ToLower())
      {
        case "datetime":
          var datearray = ( (string)fieldValue ).Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
          var start = Convert.ToDateTime(datearray[0] + " 00:00:00", CultureInfo.CurrentCulture);
          var end = Convert.ToDateTime(datearray[1] + " 23:59:59", CultureInfo.CurrentCulture);
          var greater = Expression.GreaterThan(memberExpression, Expression.Constant(start, type));
          var less = Expression.LessThan(memberExpression, Expression.Constant(end, type));
          return Expression.Lambda<Func<T, bool>>(greater, parameterExpression)
            .And(Expression.Lambda<Func<T, bool>>(less, parameterExpression));
        case "int":
        case "int32":
          var intarray = ( (string)fieldValue ).Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
          var min = Convert.ToInt32(intarray[0] , CultureInfo.CurrentCulture);
          var max = Convert.ToInt32(intarray[1], CultureInfo.CurrentCulture);
          var maxthen = Expression.GreaterThan(memberExpression, Expression.Constant(min, type));
          var minthen = Expression.LessThan(memberExpression, Expression.Constant(max, type));
          return Expression.Lambda<Func<T, bool>>(maxthen, parameterExpression)
            .And(Expression.Lambda<Func<T, bool>>(minthen, parameterExpression));
        case "decimal":
          var decarray = ( (string)fieldValue ).Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
          var dmin = Convert.ToDecimal(decarray[0], CultureInfo.CurrentCulture);
          var dmax = Convert.ToDecimal(decarray[1], CultureInfo.CurrentCulture);
          var dmaxthen = Expression.GreaterThan(memberExpression, Expression.Constant(dmin, type));
          var dminthen = Expression.LessThan(memberExpression, Expression.Constant(dmax, type));
          return Expression.Lambda<Func<T, bool>>(dmaxthen, parameterExpression)
            .And(Expression.Lambda<Func<T, bool>>(dminthen, parameterExpression));
        case "float":
          var farray = ((string)fieldValue).Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
          var fmin = Convert.ToDecimal(farray[0], CultureInfo.CurrentCulture);
          var fmax = Convert.ToDecimal(farray[1], CultureInfo.CurrentCulture);
          var fmaxthen = Expression.GreaterThan(memberExpression, Expression.Constant(fmin, type));
          var fminthen = Expression.LessThan(memberExpression, Expression.Constant(fmax, type));
          return Expression.Lambda<Func<T, bool>>(fmaxthen, parameterExpression)
            .And(Expression.Lambda<Func<T, bool>>(fminthen, parameterExpression));
        case "string":
          var strarray = ( (string)fieldValue ).Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
          var smin = strarray[0];
          var smax = strarray[1];
        
          var strmethod = typeof(string).GetMethod("Contains");
          var mm = Expression.Call(memberExpression, strmethod, Expression.Constant(smin, type));
          var nn = Expression.Call(memberExpression, strmethod, Expression.Constant(smax, type));


          return Expression.Lambda<Func<T, bool>>(mm, parameterExpression)
            .Or(Expression.Lambda<Func<T, bool>>(nn, parameterExpression));
        default:
          return x => true;
      }

    }



    private static Expression<Func<T, bool>> Any<T, T2>(object fieldValue, ParameterExpression parameterExpression, MemberExpression memberExpression)
    {
      var lambda = (Expression<Func<T2, bool>>)fieldValue;
      var anyMethod = typeof(Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public)
      .First(m => m.Name == "Any" && m.GetParameters().Count() == 2).MakeGenericMethod(typeof(T2));

      var body = Expression.Call(anyMethod, memberExpression, lambda);

      return Expression.Lambda<Func<T, bool>>(body, parameterExpression);
    }

    private static PropertyDescriptor GetProperty(PropertyDescriptorCollection props, string fieldName, bool ignoreCase)
    {
      if (!fieldName.Contains('.'))
      {
        return props.Find(fieldName, ignoreCase);
      }

      var fieldNameProperty = fieldName.Split('.');
      return props.Find(fieldNameProperty[0], ignoreCase).GetChildProperties().Find(fieldNameProperty[1], ignoreCase);

    }
    #endregion
  }

  internal class SwapVisitor : ExpressionVisitor
  {
    private readonly Expression from, to;
    public SwapVisitor(Expression from, Expression to)
    {
      this.from = from;
      this.to = to;
    }
    public override Expression Visit(Expression node) => node == from ? to : base.Visit(node);
  }
  public enum OperationExpression
  {
    equal,
    notequal,
    less,
    lessorequal,
    greater,
    greaterorequal,
    contains,
    beginwith,
    endwith,
    includes,
    between,
    any
  }
}

View Code

 1 public async Task<JsonResult> GetData(int page = 1, int rows = 10, string sort = "Id", string order = "asc", string filterRules = "")
 2     {
 3       try
 4       {
 5         var filters = PredicateBuilder.FromFilter<Company>(filterRules);
 6         var total = await this.companyService
 7                              .Query(filters)
 8                              .AsNoTracking()
 9                              .CountAsync()
10                               ;
11         var pagerows = (await this.companyService
12                              .Query(filters)
13                               .AsNoTracking()
14                            .OrderBy(n => n.OrderBy(sort, order))
15                            .Skip(page - 1).Take(rows)
16                            .SelectAsync())
17                            .Select(n => new
18                            {
19                              Id = n.Id,
20                              Name = n.Name,
21                              Code = n.Code,
22                              Address = n.Address,
23                              Contect = n.Contect,
24                              PhoneNumber = n.PhoneNumber,
25                              RegisterDate = n.RegisterDate.ToString("yyyy-MM-dd HH:mm:ss")
26                            }).ToList();
27         var pagelist = new { total = total, rows = pagerows };
28         return Json(pagelist);
29       }
30       catch(Exception e) {
31         throw e;
32         }
33 
34     }

配合使用的代碼

• 對於固定查詢邏輯的封裝和復用,當然除了復用還可以明顯的提高代碼的可讀性.

public class OrderSalesQuery : QueryObject<Order>
{
    public decimal Amount { get; set; }
    public string Country { get; set; }
    public DateTime FromDate { get; set; }
    public DateTime ToDate { get; set; }

    public override Expression<Func<Order, bool>> Query()
    {
        return (x => 
            x.OrderDetails.Sum(y => y.UnitPrice) > Amount &&
            x.OrderDate >= FromDate &&
            x.OrderDate <= ToDate &&
            x.ShipCountry == Country);
    }
}

查看訂單的銷售情況,條件 金額,國家,日期

var orderRepository = new Repository<Order>(this);
    
var orders = orderRepository
    .Query(new OrderSalesQuery(){ 
        Amount = 100, 
        Country = "USA",
        FromDate = DateTime.Parse("01/01/1996"), 
        ToDate = DateTime.Parse("12/31/1996" )
    })
    .Select();

調用查詢方法

public class CustomerLogisticsQuery : QueryObject<Customer>
{
    public CustomerLogisticsQuery FromCountry(string country)
    {
        Add(x => x.Country == country);
        return this;
    }

    public CustomerLogisticsQuery LivesInCity(string city)
    {   
        Add(x => x.City == city);
        return this;
    }
}

客戶查詢 根據國家和城市查詢

public class CustomerSalesQuery : QueryObject<Customer>
{
    public CustomerSalesQuery WithPurchasesMoreThan(decimal amount)
    {
        Add(x => x.Orders
            .SelectMany(y => y.OrderDetails)
            .Sum(z => z.UnitPrice * z.Quantity) > amount);

        return this;
    }

    public CustomerSalesQuery WithQuantitiesMoreThan(decimal quantity)
    {
        Add(x => x.Orders
            .SelectMany(y => y.OrderDetails)
            .Sum(z => z.Quantity) > quantity);

        return this;
    }
}

客戶的銷售情況,金額和數量

var customerRepository = new Repository<Customer>(this);

var query1 = new CustomerLogisticsQuery()
    .LivesInCity("London");

var query2 = new CustomerSalesQuery()
    .WithPurchasesMoreThan(100)
    .WithQuantitiesMoreThan(10);

customerRepository
    .Query(query1.And(query2))
    .Select()
    .Dump();

復用上面的定義的查詢方法

以上這些都是改項目提供的方法,非常的好用

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計最專業,超強功能平台可客製化

接着上面一篇：三文搞懂學會Docker容器技術（上）

                         三文搞懂學會Docker容器技術（中）

7，Docker容器目錄掛載

  7.1 簡介

容器目錄掛載：

我們可以在創建容器的時候，將宿主機的目錄與容器內的目錄進行映射，這樣我們就可以實現宿主機和容器目錄的雙向數據自動同步；

  7.2 作用

前面學過cp命令來實現數據傳遞，這種方式比較麻煩；

我們通過容器目錄掛載，能夠輕鬆實現代碼上傳，配置修改，日誌同步等需求；

  7.3 實現

語法：

docker run -it -v  /宿主機目錄:/容器目錄 鏡像名

多目錄掛載

docker run -it -v /宿主機目錄:/容器目錄 -v /宿主機目錄2:/容器目錄2  鏡像名

注意：

如果你同步的是多級目錄，可能會出現權限不足的提示；

這是因為Centos7中的安全模塊selinux把權限禁掉了，我們需要添加  –privileged=true 來解決掛載的目錄沒有權限的問題；

  7.4 掛載目錄只讀

docker run -it -v  /宿主機目錄:/容器目錄:ro 鏡像名

 

8，Docker遷移與備份

  8.1 概述

我們開發的時候，經常自定義鏡像，然後commit提交成鏡像到本地倉庫，但是我們發布到客戶服務器的時候，可以用前面講得搞到hub官方，或者阿里雲，但是有些機密性的項目，是禁止公網存儲的，所以我們只能通過docker鏡像備份和遷移實現；

  8.2 實現

備份鏡像：

docker save -o 備份鏡像的名稱  源鏡像名稱:tag版本

 docker save -o mytomcat7.1.tar java1234/tomcat7:7.1

 

恢復鏡像：

docker load -i 鏡像文件

docker load -i mytomcat7.1.tar

 

9，DockerFile詳解

  9.1 DockerFile簡介

Dockerfile是由一系列命令和參數構成的腳本，這些命令應用於操作系統(centos或者Ubuntu)基礎鏡像並最終創建的一個新鏡像；

我們前面講過的用手工的方式，修改配置文件，或者添加，刪除文件目錄的方式，來構建一種新鏡像；這種手工方式麻煩，容易出錯，而且不能復用；

我們這裏講Dockerfile，用腳本方式來構建自動化，可復用的，高效率的創建鏡像方式，是企業級開發的首選方式；

 

再軟件系統開發生命周期中，採用Dockerfile來構建鏡像；

1、對於開發人員:可以為開發團隊提供一個完全一致的開發環境;

2、對於測試人員:可以直接拿開發時所構建的鏡像或者通過Dockerfile文件構建一個新的鏡像開始工作；

3、對於運維人員:在部署時，可以實現應用的無縫移植。

  9.2 DockerFile常用指令

FROM image_name:tag 定義了使用哪個基礎鏡像啟動構建流程
MAINTAINER user_info 聲明鏡像維護者信息
LABEL key value 鏡像描述元信息（可以寫多條）
ENV key value 設置環境變量（可以寫多條）
RUN command 構建鏡像時需要運行的命令（可以寫多條）
WORKDIR path_dir 設置終端默認登錄進來的工作目錄
EXPOSE port 當前容器對外暴露出的端口
ADD source_dir/file dest_dir/file 將宿主機的文件複製到容器內，如果是一個壓縮文件，將會在複製后自動解壓
COPY source_dir/file dest_dir/file 和ADD相似，但是如果有壓縮文件是不能解壓
VOLUME 創建一個可以從本地主機或其他容器掛載的掛載點，一般用來存放數據庫和需要保持的數據等
CMD 指定容器啟動時要運行的命令，假如有多個CMD，最後一個生效
ENTRYPOINT 指定容器啟動時要運行的命令
ONBUILD 當構建一個被繼承的Dockerfile時運行的命令，父鏡像在被子鏡像繼承後父鏡像的onbuild被觸發。可以把ONBUID理解為一個觸發器。

 

10，Docker私有倉庫

  10.1 簡介

Docker私有倉庫主要是企業內部用來存放鏡像的倉庫，相對官方倉庫以及阿里雲倉庫，具有更高的保密安全級別；

  10.2 私有倉庫搭建

第一步：拉取私有倉庫鏡像 （私有倉庫程序本身就是一個鏡像）

docker pull registry

第二步：啟動私有倉庫容器

docker run -di –name=myRegistry -p 5000:5000 registry

第三步：測試

http://192.168.1.112:5000/v2/_catalog

看到這個 說明啟動OK。因為倉庫里還沒有鏡像，所以就是空的；

第四步：etc/docker 修改daemon.json，讓docker信任私有倉庫地址

“insecure-registries”: [“192.168.1.112:5000”]

 

第五步：修改配置后重啟docker；

 systemctl restart docker

  10.3 私有倉庫測試

第一步：標記此鏡像為私有倉庫的鏡像

docker tag tomcat:7 192.168.1.112:5000/mytomcat7

第二步：上傳鏡像到私有倉庫

docker push 192.168.1.112:5000/mytomcat7

此時私有倉庫里已經有了這個鏡像；

第三步：刪除192.168.1.112:5000/mytomcat7本地倉庫鏡像

docker rmi -f 192.168.1.112:5000/mytomcat7

第四步：從私有倉庫拉取192.168.1.112:5000/mytomcat7鏡像，並運行；

docker run -it -p 8080:8080 192.168.1.112:5000/mytomcat7

第五步：瀏覽器運行 http://192.168.1.112:8080測試

 

——————————————————————————————————————————

作者： java1234_小鋒

出處：https://www.cnblogs.com/java688/p/13174647.html

版權：本站使用「CC BY 4.0」創作共享協議，轉載請在文章明顯位置註明作者及出處。

——————————————————————————————————————————

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※南投搬家公司費用需注意的眉眉角角，別等搬了再說!

※新北清潔公司,居家、辦公、裝潢細清專業服務

※教你寫出一流的銷售文案?

lin-cms-dotnetcore功能模塊的設計

先來回答以下問題。可拉到最下面查看預覽圖。

1.什麼是cms？

Content Management System，內容管理系統。

2.dotnetcore是什麼？

.NET Core，是由Microsoft開發，目前在.NET Foundation(一個非營利的開源組織)下進行管理，採用寬鬆的MIT協議，可構建各種軟件，包括Web應用程序、移動應用程序、桌面應用程序、雲服務、微服務、API、遊戲和物聯網應用程序。

3.lin-cms 是什麼？

Lin-CMS 是林間有風團隊經過大量項目實踐所提煉出的一套內容管理系統框架。Lin-CMS 可以有效的幫助開發者提高 CMS 的開發效率,

Lin的定位在於實現一套 CMS的解決方案,管理系統的基礎框架,提供了不同的後端，不同的前端實現，後端也支持不同的數據庫，是一套前後端完整的解決方案

目前官方團隊維護 lin-cms-vue,lin-cms-spring-boot,lin-cms-koa,lin-cms-flask 社區維護了 lin-cms-tp5,lin-cms-react,lin-cms-dotnetcore，即已支持vue,react二種前端框架，java,nodejs,python,php,c#等五種後端語言。

lin-cms-vue（官方）

• https://github.com/TaleLin/lin-cms-vue
• Vue+ElementUI構建的CMS開發框架，
• 林間有風團隊經過大量項目實踐所提煉出的一套內容管理系統框架
• 內置了 CMS 中最為常見的需求：用戶管理、權限管理、日誌系統等

lin-cms-koa（官方）

• python
• https://github.com/TaleLin/lin-cms-koa
• 使用Node.JS KOA構建的CMS開發框架

lin-cms-flask（官方）

• node.js
• https://github.com/TaleLin/lin-cms-flask
• A simple and practical CMS implememted by flask

lin-cms-spring-boot(官方)

• java
• https://github.com/TaleLin/lin-cms-spring-boot
• 基於SpringBoot的CMS/DMS/管理系統開發框架

lin-cms-tp5（社區）

• php 被官方fork。
• https://github.com/TaleLin/lin-cms-tp5
• A simple and practical CMS implememted by ThinkPHP 5.1

lin-cms-react(社區)

• https://github.com/Bongkai/lin-cms-react
• React+Antd構建的CMS開發框架

lin-cms-dotnetcore(社區)

• C#
• A simple and practical CMS implemented by .NET Core 3.1 一個簡單實用、基於.NET Core
• https://github.com/luoyunchong/lin-cms-dotnetcore
• .NET Core 3.1實現的CMS；前後端分離、Docker部署、OAtuh2授權登錄、自動化部署DevOps、GitHub Action同步至Gitee

4.lin-cms-dotnetcore有哪些特點？

基於.NET Core3.1實現的LIN-CMS-VUE後端API，並增加了博客模塊。目前實現簡約的權限管理系統、基礎字典項管理、隨筆專欄，評論點贊、關注用戶、技術頻道（標籤分類）、消息通知，標籤等仿掘金模塊。

功能模塊的設計

基礎權限模塊

• 用戶信息：郵件、用戶名（唯一）、昵稱、頭像、分組、是否激活、手機號、是否是Admin、個性簽名
  • [x] 註冊/登錄
  • [x] 上傳頭像
  • [x] 修改個人密碼
  • [x] 用戶基本信息修改
  • [x] 用戶增刪改，配置分組
• 綁定第三方賬號
  • [x] GitHub登錄
  • [x] QQ 登錄
  • [ ] Gitee登錄
• 分組信息：是否靜態分組（無法刪除，無法修改分組編碼）、名稱可以修改
  • [x] 分組增刪改
  • [x] 分組配置權限
• 文件管理
  • [x] 本地文件上傳
  • [x] 七牛雲存儲
  • [x] 文件去重，秒傳
• 系統日誌：請求方法、路徑、http返回碼、時間、用戶昵稱、用戶id、訪問哪個權限、 日誌信息
  • [x] 記錄系統請求的日誌
  • [ ] 異常日誌
• 設置管理：name(鍵）,value(值),provider_name(提供名),provider_key（提供者值）
  • [x] 設置新增修改刪除
  • [x] 所有設置

比如存某用戶選擇的是markdown還是富文本。

name="Article.Editor",
value="markdown" 或 "富文本"，
provider_name為"User",
provider_key為用戶Id

或存儲七牛雲的某一個配置

name="Qiniu.AK",
value="asfadsfadf23rft66S4XM2GIK7FxfqefauYkcAyNGDAc" ，
provider_name為"Qiniu"或自己定義的字符串
provider_key為空

cms 管理員維護模塊

• [x] 標籤管理：名稱、圖片，是否啟用/禁用，排序、文章數量、用戶關注數量。
  • [x] 標籤增刪改
  • [x] 標籤列表，禁用
  • [x] 校正文章數量
• [x] 技術頻道：封面圖、名稱、是否啟用/禁用、排序、編碼、備註描述、下屬標籤.一個技術頻道對應多個標籤
  • [x] 技術頻道增刪改
  • [x] 列表、禁用
• [x] 隨筆管理：
  • [x] 審核隨筆/拉黑
  • [x] 管理員刪除隨筆
• [x] 評論管理
  • [x] 後台審核通過/拉黑
  • [x] 管理員刪除評論
• [x] 字典類別管理:編碼，名稱，排序
  • [x] 增刪改查
• [x] 字典管理：：編碼，名稱，排序，類別：如隨筆類型（原創、轉載、翻譯）
  • [x] 增刪改查

cms 用戶端模塊

• 技術頻道
  • [x] 首頁展示技術頻道
  • [x] 選擇技術頻道后，可再根據標籤查詢文章
• 分類專欄管理:發布隨筆時可選擇單個分類。
  • [x] 分類增刪改(隨筆數量、圖片、名稱、排序)
  • [x] 分類列表，僅查看、編輯自己創建的分類專欄
• 標籤：統計每個標籤下多少個文章、多少人關注
  • [x] 標籤列表
  • [x] 無限加載
  • [x] 最新/最熱 根據標籤名稱模糊查詢
  • [x] 已關注的標籤
  • [x] 熱門標籤
• 隨筆
  • [x] 支持markdown，增刪改（僅自己的隨筆）,修正分類專欄中的隨筆數量
  • [x] 支持富文本編輯隨筆
  • [x] 列表無限加載，按標籤查詢隨筆
  • [x] 點贊隨筆
  • 隨筆詳情頁
    • [x] 支持目錄導航（滾動時，固定至頂部位置），展示字數統計、預計閱讀時長；
    • [x] 作者介紹：頭像，昵稱，簽名，隨筆數；
    • [x] 展示文章類型：原創、轉載、翻譯
    • [ ] 相關文章
    • [ ] 推薦文章
• 評論
  • [ ] 用戶關閉評論時，無法對隨筆進行評論
  • [ ] 評論隨筆(內容支持超鏈接、emoji)
  • [x] 刪除自己的評論
  • [x] 點贊評論
  • [x] 回複評論
• 關注
  • [x] 關注/取消關注用戶
  • [x] 關注/取消關註標簽
  • [x] 我關注的用戶發隨筆
• 個人主頁
  • 隨筆
    • [x] 用戶專欄分類展示
    • [x] 最新發布的隨筆
  • 關注
    • [x] 關注的用戶
    • [x] 粉絲
    • [x] 關注的標籤
• 設置
  • 個人主頁設置
    • [x] 個人資料更新
  • 安全設置
    • [x] 密碼修改：快速登錄的賬號，初次設置時可留空
  • 博客設置
    • [x] 編輯器設置，(可切換markdown/富文本)
    • [x] 代碼風格配置（tango、native、monokai、github、solarized-light、vs）
• 消息
  • [x] 評論：點贊評論、評論隨筆、回複評論
  • [x] 喜歡和贊：點贊隨筆、點贊評論
  • [x] 關注，誰誰關注了你

腦圖分享

http://naotu.baidu.com/file/6532431a2e1f0c37c93c5ffd1dd5b49c?token=87690a9bc64fbae1

分組

分為三種

id  name        info
1	Admin	    系統管理員
2	CmsAdmin	內容管理員
3	User	    普通用戶

審計日誌

大多數表存在如下8個字段，用於記錄行的變化狀態，is_deleted為軟刪除，執行刪除操作時，將其狀態置為true，默認實體類繼承 FullAduitEntity 即可擁有以下8個字段。該設計參考ABP中的實現。FullAduitEntity為泛型，默認id為long類型，FullAduitEntity<Guid>,即可改變主鍵類型，默認LinUser表主鍵long，保持create_user_id,delete_user_id,update_user_id都與LinUser的主鍵相同

id	                bigint
create_user_id  	bigint
create_time	        datetime
is_deleted	        bit
delete_user_id  	bigint
delete_time	        datetime
update_user_id	    bigint
update_time	        datetime

相關技術

• 數據庫相關：ORM:FreeSql+DataBase:MySQL5.6
• ASP.NET Core3.1+WebAPI+RESTful
• 簡化對象映射：AutoMapper
• 身份認證框架：IdentityServer4
• Json Web令牌:JWT
• 文檔API：Swagger(Swashbuckle.AspNetCore)
• 序列化：Newtonsoft.Json
• 測試框架：Xunit
• 日誌 Serilog
• 依賴注入服務AutoFac
• 通用擴展方法 Z.ExtensionMethods
• 雲存儲：七牛雲 MQiniu.Core
• 分佈式事務、EventBus：DotNeteCore.CAP
• GitHub第三方授權登錄AspNet.Security.OAuth.GitHub
• QQ第三方授權登錄AspNet.Security.OAuth.QQ
• Docker
• Azure DevOps
• 健康檢查AspNetCore.HealthChecks.UI.Client
• GitHub Action同步至Gitee

分層結構（Layers）

• framework
  • IGeekfan.CAP.MySql：為CAP實現了配合FreeSql的事務一致性擴展
• identityserver4
  • LinCms.IdentityServer4:使用id4授權登錄
• src
  • LinCms.Web：接口API（ASP.NET Core)
  • LinCms.Application:應用服務
  • LinCms.Application.Contracts:DTO,數據傳輸對象，應用服務接口
  • LinCms.Infrastructure:基礎設施，數據庫持久性的操作
  • LinCms.Core:該應用的核心，實體類，通用操作類，AOP擴展，分頁對象，基礎依賴對象接口，時間擴展方法，當前用戶信息，異常類，值對象
  • LinCms.Plugins 使用單項目實現某個業務的擴展，不需要主要項目結構，可暫時忽略。
• test
  • LinCms.Test:對倉儲，應用服務或工具類進行測試

功能特性

• [x] Azure Devops CI/CD構建
• [x] GitHub Action實現 GitHub Gitee代碼同步
• [x] .Net Core結合AspNetCoreRateLimit實現限流
• [x] 方法級別權限控制
• 社交賬號管理：支持多種第三社交賬號登錄，不干涉原用戶數據，實現第三方賬號管理
• 多語言
• [x] 全局敏感詞處理
• 日誌記錄，方便線上排查錯誤
• [ ] 支持多種數據庫，並測試，
  • [x] Mysql
  • [ ] Postgresql
  • [ ] Sql Server
  • [ ] SQlite

產品設計-評論模塊的設計

下面我們來設計一個評論模塊，需要注意的是，一個評論模塊也有不同的方式。從展示形式，排序規則，按鈕功能設計，操作等方式都有詳細的分析設計，大家可以參考who shi pm 中的文章http://www.woshipm.com/pd/3548139.html,這裏主要講解下展式方式中的主題式的應用。

1.主題式

相信很多人都刷過抖音，他的評論主題式的強化版。

特點為前三個是熱門評論（喜歡最多的評論），將評論分為二級，第一級採用時間倒序，第二級按照時間正序，有助於理解上下文關係。

可以總結為如下功能點

用戶操作：

• [x] 評論隨筆(內容支持超鏈接、emoji)
• [x] 點贊評論/取消點贊
• [x] 回複評論
• [x] 刪除自己的評論

運營操作：

• [x] 審核通過/拉黑評論
• [x] 刪除任何評論
• [x] 拉黑后的显示邏輯。（保留當前區塊、显示內容為：該評論因違規被拉黑）
• 刪除：（如果是二級評論，直接軟刪除，如果是一級評論，軟刪除子評論和當前評論-需要提前提醒用戶）

交互設計

• 評論的字數長度（500）、emoji。
• 點贊交互-動畫、消息通知/推送
• 評論區域元素，需要有明確可點擊的區域，會跳轉到哪個地方。

優化

• 精選或者叫置頂評論
• 該文章是否開放評論功能。
• 熱門評論（點贊最多的評論）
• 標註哪些評論是作者，標準哪些評論被用戶點贊。
• @邏輯，emoji，舉報等

2 平鋪式

特點是不區分子父節點關係，比如現在博客園（大多數的主題），微信朋友圈,github。
不過博客園，github，回復時，可選擇引用回復，方便用戶理解上下文關係。

3.蓋樓式

這種方式有點這種感覺 》>-,即.net core中間件請求方式。當回復越來越多時，显示的效果就越誇張。一層套一層的显示上下文的關係。下圖是網易新聞的評論效果。

排行榜見解

排行榜從心理學上分析，主要從四個方面影響着您：尋找權威 、參与比較 、關注主流 、自我確認。

如何設計一個簡單的排行榜呢。。

在一個博客隨筆中，我們設計一個3天、七天（周榜）、30天（月榜）、全部的榜單。以瀏覽量（權重1）、點贊量（20）、評論量（30)。權重可自己定義。

1.默認取最新的隨筆

前台傳create_time時，使用如下sql

select * from `blog_article` order by create_time desc;

2.傳排序方式為最近n天的熱榜時。

參數：THREE_DAYS_HOTTEST（三天）、WEEKLY_HOTTEST(七天）、MONTHLY_HOTTEST（一個月）、HOTTEST（全部）

mysql 查詢當前日期時間前三天數據

select date_sub(now() ,interval 3 day);

根據權重查詢

select * from `blog_article` a 
where a.`create_time`>(select date_sub(now() ,interval 3 day))
order by (a.`view_hits` + a.`likes_quantity` * 20 + a.`comment_quantity` * 30) DESC, a.`create_time` DESC

更多參考

• 評論區如何設計？
• 萬字長文深度分析：產品排行榜的設計和玩法
• 想知道誰是你的最佳用戶？基於Redis實現排行榜周期榜與最近N期榜

lin-cms 開源地址分享

• 後端接口 https://github.com/luoyunchong/lin-cms-dotnetcore
• 管理後台UI https://github.com/luoyunchong/lin-cms-vue
• 前端UIhttps://github.com/luoyunchong/lin-cms-vvlog

Demo

• 用戶端 lin-cms-vvlog https://vvlog.baimocore.cn

  • 普通用戶：710277267@qq.com
  • 密碼：123qwe

• 管理員 lin-cms-vue https://cms.baimocore.cn/

  • 管理員： admin
  • 密碼：123qwe

預覽圖

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※想知道最厲害的網頁設計公司"嚨底家"!

※幫你省時又省力,新北清潔一流服務好口碑

※別再煩惱如何寫文案,掌握八大原則!

※產品缺大量曝光嗎?你需要的是一流包裝設計!