Einführung in die Verwendung der Json-Formatierung in der ABP-Einführungsreihe

, JSON (JavaScript Object Notation) ist ein leichtes Datenaustauschformat. Dieser Artikel konzentriert sich auf die Einführung der Json-Formatierung in der ABP-Einführungsserie. Freunde, die sie benötigen, können sich auf

beziehen. Nachdem wir über die Paging-Funktion gesprochen haben, haben wir es in diesem Abschnitt nicht eilig. Lassen Sie uns kurz die Verwendung von Json in Abp vorstellen. Warum sprechen wir in diesem Abschnitt darüber? Dies soll natürlich den Weg ebnen. Die folgende Artikelserie befasst sich häufig mit Json.

1. Was macht Json?

JSON (Javascript Object Notation) ist ein leichtes Datenaustauschformat. Für Menschen leicht zu lesen und zu schreiben. Es ist auch für Maschinen einfach zu analysieren und zu generieren. JSON verwendet ein völlig sprachunabhängiges Textformat, verwendet aber auch Konventionen ähnlich der C-Sprache-Familie (einschließlich C, C++, C#, Java, Javascript, Perl, Python usw.). Diese Eigenschaften machen JSON zu einer idealen Datenaustauschsprache.

Json wird im Allgemeinen verwendet, um Folgendes darzustellen:

Name/Wert-Paar:

{"firstName":"Brett","lastName":"McLaughlin","email":"aaaa"}

Array:

{ "people":[
  {"firstName":"Brett","lastName":"McLaughlin","email":"aaaa"},
  {"firstName":"Jason","lastName":"Hunter","email":"bbbb"},
  {"firstName":"Elliotte","lastName":"Harold","email":"cccc"}
 ]
}

Zweitens stellt JsonResult in Asp.net Mvc

Asp.net mvc standardmäßig JsonResult bereit, um Situationen zu bewältigen, in denen Daten im Json-Format vorliegen müssen zurückgegeben.

Im Allgemeinen können wir es so verwenden:

public ActionResult Movies()
{
 var movies = new List<object>();
 movies.Add(new { Title = "Ghostbusters", Genre = "Comedy", ReleaseDate = new DateTime(2017,1,1) });
 movies.Add(new { Title = "Gone with Wind", Genre = "Drama", ReleaseDate = new DateTime(2017, 1, 3) });
 movies.Add(new { Title = "Star Wars", Genre = "Science Fiction", ReleaseDate = new DateTime(2017, 1, 23) });
 return Json(movies, JsonRequestBehavior.AllowGet);
}

wobei Json() die virtuelle Methode ist, die in der Controller-Basisklasse bereitgestellt wird.

Das zurückgegebene JSON-Ergebnis ist wie folgt formatiert:

[
 {
 "Title": "Ghostbusters",
 "Genre": "Comedy",
 "ReleaseDate": "\/Date(1483200000000)\/"
 },
 {
 "Title": "Gone with Wind",
 "Genre": "Drama",
 "ReleaseDate": "\/Date(1483372800000)\/"
 },
 {
 "Title": "Star Wars",
 "Genre": "Science Fiction",
 "ReleaseDate": "\/Date(1485100800000)\/"
 }
]

Wenn man sich das zurückgegebene JSON-Ergebnis genau anschaut, gibt es die folgenden Mängel:

Das zurückgegebene Feld schreibt Groß- und Kleinschreibung vor Vereinbarung. Dies erfordert, dass wir im Frontend die gleiche Groß-/Kleinschreibung verwenden wie im Code (item.Title, item.Genre, item.ReleaseDate).

enthält keine Erfolgs- oder Fehlerinformationen: Wenn wir feststellen möchten, ob die Anfrage erfolgreich ist, müssen wir die Länge des JSON-Datenpakets manuell ermitteln.

Das zurückgegebene Datum ist nicht formatiert und muss im Frontend

formatiert und ausgegeben werden.

3. Kapselung von Json in Abp

Abp kapselt also AbpJsonResult

erbt von JsonResult, das hauptsächlich zwei Attribute hinzufügt :

CamelCase: Größe Camel Case (Standard ist true, d. h. kleines Camel Case-Format)

Indented: ob eingerückt werden soll (Standard ist false, d. h. nicht formatiert)

Und

überladen die Json()-Methode des Controllers in AbpController, wodurch alle zurückgegebenen Json-Formatdaten den Typ AbpJsonResult haben müssen und eine virtuelle Methode von AbpJson() bereitgestellt wird.

/// <summary>
/// Json the specified data, contentType, contentEncoding and behavior.
/// </summary>
/// <param name="data">Data.</param>
/// <param name="contentType">Content type.</param>
/// <param name="contentEncoding">Content encoding.</param>
/// <param name="behavior">Behavior.</param>
protected override JsonResult Json(object data, string contentType, 
 Encoding contentEncoding, JsonRequestBehavior behavior)
{
 if (_wrapResultAttribute != null && !_wrapResultAttribute.WrapOnSuccess)
 {
  return base.Json(data, contentType, contentEncoding, behavior);
 }
 return AbpJson(data, contentType, contentEncoding, behavior);
}
protected virtual AbpJsonResult AbpJson(
 object data,
 string contentType = null,
 Encoding contentEncoding = null,
 JsonRequestBehavior behavior = JsonRequestBehavior.DenyGet,
 bool wrapResult = true,
 bool camelCase = true,
 bool indented = false)
{
 if (wrapResult)
 {
  if (data == null)
  {
   data = new AjaxResponse();
  }
  else if (!(data is AjaxResponseBase))
  {
   data = new AjaxResponse(data);
  }
 }
 return new AbpJsonResult
 {
  Data = data,
  ContentType = contentType,
  ContentEncoding = contentEncoding,
  JsonRequestBehavior = behavior,
  CamelCase = camelCase,
  Indented = indented
 };
}

In ABP verwenden Sie Controller, um von AbpController zu erben, verwenden Sie return Json() direkt und formatieren Sie das zurückgegebene Json-Ergebnis:

{
 "result": [
 {
  "title": "Ghostbusters",
  "genre": "Comedy",
  "releaseDate": "2017-01-01T00:00:00"
 },
 {
  "title": "Gone with Wind",
  "genre": "Drama",
  "releaseDate": "2017-01-03T00:00:00"
 },
 {
  "title": "Star Wars",
  "genre": "Science Fiction",
  "releaseDate": "2017-01-23T00:00:00"
 }
 ],
 "targetUrl": null,
 "success": true,
 "error": null,
 "unAuthorizedRequest": false,
 "abp": true
}

wobei result die im angegebene Rückgabe ist Codedaten. Mehrere andere Schlüssel-Wert-Paare werden von ABP gekapselt, darunter Authentifizierung, Erfolg, Fehlerinformationen und Ziel-URL. Sind diese Parameter sehr süß?

Sie können auch Parameter für die JSON-formatierte Ausgabe angeben, indem Sie return AbpJson() aufrufen.

Wenn Sie genau hinschauen, werden Sie feststellen, dass das Datumsformat immer noch seltsam ist. 23.01.2017T00:00:00, noch ein T. Beim Betrachten des AbpJsonReult-Quellcodes haben wir festgestellt, dass JsonConvert.SerializeObject(obj, Settings); in der Newtonsoft.

Json Serialization-Komponente für die Serialisierung aufgerufen wird.

Sehen Sie sich die Einführung auf der offiziellen Website von Newtonsoft.Json an. Für die Ausgabe der Datumsformatierung müssen Sie das DateTimeFormat von IsoDateTimeConverter angeben.

IsoDateTimeConverter timeFormat = new IsoDateTimeConverter();
   timeFormat.DateTimeFormat = "yyyy-MM-dd HH:mm:ss";
JsonConvert.SerializeObject(dt, Formatting.Indented, timeFormat)

Wie geben wir dann dieses DateTimeFormat in unserem Abp an?

Die in ABP bereitgestellte AbpDateTimeConverter-Klasse erbt von IsoDateTimeConverter.

Aber schauen Sie sich die in ABP integrierte Json-Serialisierungserweiterungsklasse an:

public static class JsonExtensions
 {
 /// <summary>Converts given object to JSON string.</summary>
 /// <returns></returns>
 public static string ToJsonString(this object obj, bool camelCase = false, bool indented = false)
 {
  JsonSerializerSettings settings = new JsonSerializerSettings();
  if (camelCase)
  settings.ContractResolver = (IContractResolver) new CamelCasePropertyNamesContractResolver();
  if (indented)
  settings.Formatting = Formatting.Indented;
  settings.Converters.Insert(0, (JsonConverter) new AbpDateTimeConverter());
  return JsonConvert.SerializeObject(obj, settings);
 }
 }

Offensichtlich ist kein DateTimeFormat angegeben, daher müssen wir es selbst tun. Für spezifische Codes siehe bitte 4 Möglichkeiten JSON-Daten lösen Die vierte Methode zur Lösung des Formatproblems.

当有异常发生时，Abp返回的Json格式化输出以下结果：

{
 "targetUrl": null,
 "result": null,
 "success": false,
 "error": {
 "message": "An internal error occured during your request!",
 "details": "..."
 },
 "unAuthorizedRequest": false
}

当不需要abp对json进行封装包裹怎么办？

简单。只需要在方法上标记[DontWrapResult]特性即可。这个特性其实是一个快捷方式用来告诉ABP不要用AbpJsonResult包裹我，看源码就明白了：

namespace Abp.Web.Models
{
 [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Method)]
 public class DontWrapResultAttribute : WrapResultAttribute
 {
  /// <summary>
  /// Initializes a new instance of the <see cref="DontWrapResultAttribute"/> class.
  /// </summary>
  public DontWrapResultAttribute()
   : base(false, false)
  {
  }
 }
 /// <summary>
 /// Used to determine how ABP should wrap response on the web layer.
 /// </summary>
 [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Method)]
 public class WrapResultAttribute : Attribute
 {
  /// <summary>
  /// Wrap result on success.
  /// </summary>
  public bool WrapOnSuccess { get; set; }
  /// <summary>
  /// Wrap result on error.
  /// </summary>
  public bool WrapOnError { get; set; }
  /// <summary>
  /// Log errors.
  /// Default: true.
  /// </summary>
  public bool LogError { get; set; }
  /// <summary>
  /// Initializes a new instance of the <see cref="WrapResultAttribute"/> class.
  /// </summary>
  /// <param name="wrapOnSuccess">Wrap result on success.</param>
  /// <param name="wrapOnError">Wrap result on error.</param>
  public WrapResultAttribute(bool wrapOnSuccess = true, bool wrapOnError = true)
  {
   WrapOnSuccess = wrapOnSuccess;
   WrapOnError = wrapOnError;
   LogError = true;
  }
 }
}

在AbpResultFilter和AbpExceptionFilter过滤器中会根据WrapResultAttribute、DontWrapResultAttribute特性进行相应的过滤。

四、Json日期格式化

第一种办法：前端JS转换：

 //格式化显示json日期格式
 function showDate(jsonDate) {
  var date = new Date(jsonDate);
  var formatDate = date.toDateString();
  return formatDate;
 }

第二种办法：在Abp的WepApiModule（模块）中指定JsonFormatter的时间序列化时间格式。

GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.DateFormatString ="yyyy-MM-dd HH:mm:ss";

PS：这种方法仅对WebApi有效。

总结

本节主要讲解了以下几个问题：

Asp.net中JsonResult的实现。

ABP对JsonResult的再封装，支持指定大小驼峰及是否缩进进行Json格式化。

如何对DateTime类型对象进行格式化输出。

Web层通过拓展AbpJsonResult，指定时间格式。

前端，通过将Json日期转换为js的Date类型，再格式化输出。

WebApi，通过在Moduel中指定DateFormatString。

Das obige ist der detaillierte Inhalt vonEinführung in die Verwendung der Json-Formatierung in der ABP-Einführungsreihe. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!