Technologie de plateforme-Introduction à l'utilisation des services de messagerie
Le service de messagerie est un service push actif (De Taobao) lancé par la plateforme ouverte pour améliorer l'efficacité des appels d'API d'application. Le contenu push comprend (transactions Taobao, produits, remboursements et autres informations basées sur ce service push). , l'application obtient les données Taobao n'a plus besoin d'interroger constamment l'API. Il vous suffit d'appeler l'API pour l'obtenir lors de la réception de messages poussés par Taobao, ce qui améliore considérablement l'efficacité des appels API et réduit les coûts d'utilisation de l'API. Dans le même temps, il fournit également un service de retour de messages (Vers Taobao). L'application peut renvoyer des informations à Taobao et fournir des services de source de données sur les produits, etc.
De Taobao : Taobao diffuse des informations officielles sur les transactions, les produits, les remboursements, etc. de Taobao (y compris Tmall).
Vers Taobao : Renvoyez les messages à Taobao.
Alors comment utiliser le service de messagerie ? Veuillez consulter les instructions détaillées suivantes pour utiliser le service de messagerie De Taobao et Vers Taobao.
Depuis le service de messagerie Taobao, utilisez le
message d'abonnement à l'application
Entrez dans la console ISV, sur la page "Gestion des applications->Service de messages->Message d'abonnement", sélectionnez le message requis pour vous abonner, cliquez sur "S'abonner" derrière le message correspondant pour vous abonner avec succès au message. Vous pouvez afficher les messages souscrits avec succès dans "Mes abonnements". Si vous devez annuler l'abonnement aux messages, cliquez directement sur « Annuler l'abonnement ». Cliquez sur le nom du message pour afficher les informations de champ détaillées renvoyées par chaque message.
Remarque : Si le message n'a pas d'autorisation, cela signifie que l'application n'a pas ouvert l'autorisation d'appel API appropriée. Cliquez sur "Demander l'autorisation" pour demander le package d'autorisation correspondant. De plus, si vous devez activer le service de messagerie dans le bac à sable, vous pouvez vous référer au chapitre [Activation du service de messagerie du bac à sable] de cet article
taobao.tmc .user.permit pour l'utilisateur (c'est-à-dire les marchands Taobao ou Tmall), vous pouvez choisir d'activer uniquement certains types de messages pour les utilisateurs, ou vous pouvez les activer tous. Pour plus de détails, veuillez consulter la description du paramètre API.
- La condition préalable à l'activation des messages pour les utilisateurs est que l'utilisateur ait autorisé l'application. Sinon, veuillez vous référer aux instructions Obtenir l'autorisation utilisateur.
- Pour annuler le service de messagerie de l'utilisateur, appelez l'interface taobao.tmc.user.cancel.
- Vous pouvez obtenir le message activé de l'utilisateur via l'interface taobao.tmc.user.get. Les paramètres d'entrée doivent être is_valid, sujets, modifiés pour déterminer si le message d'autorisation de l'utilisateur a réussi
- Document API du service de messagerie : Cliquez ici. pour voir
Le code implémente la réception de messages
Adresse formelle du service d'environnement : ws://mc.api.taobao.com/
Adresse du service d'environnement Sandbox : ws://mc.api.tbsandbox.com/
Réception de messages, la méthode d'implémentation est : Deux types : Recevoir des messages via le SDK, Recevoir des messages via l'API Il est recommandé d'utiliser le SDK pour recevoir des messages.
Recevoir des messages via le SDK
Prend actuellement en charge les langages JAVA et .NET Pour les autres langages, il est recommandé d'utiliser l'API pour recevoir des messages. Lorsque vous recevez des messages via le SDK, vous n'avez qu'à vous concentrer sur le traitement métier. Vous n'avez pas à vous soucier du renvoi des messages, de la confirmation, de la reconnexion des longues connexions, etc. Le SDK gérera automatiquement tout.
Instructions d'utilisation de l'interface JAVA
public interface MessageHandler {
/**
* 消息通道客户端收到消息后，会回调该方法处理具体的业务，处理结果可以通过以下两种方式来表述：
* <ul>
* <li>抛出异常或设置status.fail()表明消息处理失败，需要消息通道服务端重发
* <li>不抛出异常，也没有设置status信息，则表明消息处理成功，消息通道服务端不会再投递此消息
*
* @param message 消息内容
* @param status 处理结果，如果调用status.fail()，消息通道将会择机重发消息；否则，消息通道认为消息处理成功
* @throws Exception 消息处理失败，消息通道将会择机重发消息
*/
public void onMessage(Message message, MessageStatus status) throws Exception;
}Exemples de code d'utilisation JAVA
TmcClient client = new TmcClient("app_key", "app_secret", "default"); // 关于default参考消息分组说明
client.setMessageHandler(new MessageHandler() {
public void onMessage(Message message, MessageStatus status) {
try {
System.out.println(message.getContent());
System.out.println(message.getTopic());
} catch (Exception e) {
e.printStackTrace();
status.fail(); // 消息处理失败回滚，服务端需要重发
// 重试注意：不是所有的异常都需要系统重试。
// 对于字段不全、主键冲突问题，导致写DB异常，不可重试，否则消息会一直重发
// 对于，由于网络问题，权限问题导致的失败，可重试。
// 重试时间 5分钟不等，不要滥用，否则会引起雪崩
}
}
});
client.connect("ws://mc.api.taobao.com"); // 消息环境地址：ws://mc.api.tbsandbox.com/Remarque : lorsque vous utilisez la méthode principale Java pour exécuter le test de code ci-dessus dans Eclipse, veuillez ajouter Thread.sleep après client.connect() Le principal Le thread attend un certain temps pour observer la réception des messages en temps réel, sinon, une fois le thread principal terminé, la longue connexion TMC sera également déconnectée. Si vous exécutez le code ci-dessus sur un serveur Web, vous n'avez pas besoin d'ajouter de code Thread.sleep après client.connect(), ni d'enrouler une boucle while (true) à l'extérieur, car le thread principal sur le Web le serveur n'a besoin que d'être fermé. La fermeture ne se terminera pas et la longue connexion de TMC sera toujours maintenue. Exemple de code d'utilisation C#
TmcClient client = new TmcClient("appkey", "appsecret", "default"); // 关于default参考消息分组说明
client.OnMessage += (s, e) =>
{
try
{
Console.WriteLine(e.Message.Topic);
Console.WriteLine(e.Message.Content);
// 默认不抛出异常则认为消息处理成功
}
catch (Exception exp)
{
Console.WriteLine(exp.StackTrace);
e.Fail(); // 消息处理失败回滚，服务端需要重发
// 重试注意：不是所有的异常都需要系统重试。
//对于字段不全、主键冲突问题，导致写DB异常，不可重试，否则消息会一直重发
// 对于，由于网络问题，权限问题导致的失败，可重试。
// 重试时间 5分钟不等，不要滥用，否则会引起雪崩
}
};
client.Connect("ws://mc.api.taobao.com/"); // 消息环境地址：ws://mc.api.tbsandbox.com/Remarque : lorsque vous utilisez la méthode C# Main pour exécuter le test de code ci-dessus dans le projet de console VS, veuillez ajouter Console.Read() ou Thread.Sleep après client.Connect pour empêcher le thread principal de se terminer temporairement afin que vous puissiez observer l'état de réception des messages en temps réel, sinon après la fin du fil principal, la longue connexion TMC sera également déconnectée. Si vous exécutez le code ci-dessus sur un serveur IIS ou une application C#, vous n'avez pas besoin d'ajouter de code en attente après client.Connect, ni d'enrouler une boucle while (true) à l'extérieur tant que le serveur IIS ou. L'application C# ne fonctionne pas lorsqu'elle est fermée, la longue connexion de TMC sera maintenue. Recevoir des messages via l'API
Le but de fournir une API pour recevoir des messages est destiné aux langages peu pratiques pour le multithread et le traitement des connexions longues, tels que PHP et Python. Ces langages n'ont pas de SDK officiels. pour le moment, vous pouvez utiliser les deux méthodes suivantes. L'API peut également être utilisée ensemble pour atteindre l'objectif de réception et de confirmation des messages. Il est recommandé d'utiliser la méthode SDK autant que possible. Si l'API doit être utilisée, il est recommandé d'appeler l'interface taobao.tmc.messages.consume sans concurrence ou avec trop de concurrence. les performances temporelles de l'utilisation de l'API ne sont pas très élevées. Si les exigences en temps réel sont élevées, il est toujours recommandé d'utiliser le SDK.
Étapes de base :
- Consommation d'abord du message : Nom de l'API : taobao.tmc.messages.consumeUne fois le message consommé, le pointeur recule automatiquement et l'appel suivant obtiendra automatiquement le message non consommé, mais après la confirmation de consommation. Le message ne peut plus être récupéré.
- Ensuite, confirmez le message : Nom de l'API : taobao.tmc.messages.confirmAprès avoir reçu le message, s'il n'est pas confirmé, le service de messagerie choisira l'heure de renvoi. Le nombre de renvois est contrôlé par le service de messagerie. . Si le message n'est pas confirmé dans les 3 jours, il sera supprimé.
exemple de code JAVA
TaobaoClient client = new DefaultTaobaoClient("http://gw.api.taobao.com/router/rest", "app_key", "app_secret", "json");
do {
long quantity = 100L;
TmcMessagesConsumeResponse rsp = null;
do {
TmcMessagesConsumeRequest req = new TmcMessagesConsumeRequest();
req.setQuantity(quantity);
req.setGroupName("default");
rsp = client.execute(req);
if (rsp.isSuccess() && rsp.getMessages() != null) {
for (TmcMessage msg : rsp.getMessages()) {
// handle message
System.out.println(msg.getContent());
System.out.println(msg.getTopic());
// confirm message
TmcMessagesConfirmRequest cReq = new TmcMessagesConfirmRequest();
cReq.setGroupName("default");
cReq.setsMessageIds(String.valueOf(msg.getId()));
TmcMessagesConfirmResponse cRsp = client.execute(cReq);
System.out.println(cRsp.getBody());
}
}
System.out.println(rsp.getBody());
} while (rsp != null && rsp.isSuccess() && rsp.getMessages() != null && rsp.getMessages().size() == quantity);
Thread.sleep(1000L);
} while (true);exemple de code C#
ITopClient client = new DefaultTopClient("http://gw.api.taobao.com/router/rest", "app_key", "app_secret", "json");
do
{
long quantity = 100L;
TmcMessagesConsumeResponse rsp = null;
do
{
TmcMessagesConsumeRequest req = new TmcMessagesConsumeRequest();
req.GroupName = "default";
req.Quantity = quantity;
rsp = client.Execute(req);
if (!rsp.IsError && rsp.Messages != null)
{
foreach (TmcMessage msg in Messages)
{
// handle message
Console.WriteLine(msg.Topic);
Console.WriteLine(msg.Content);
// confirm message
TmcMessagesConfirmRequest cReq = new TmcMessagesConfirmRequest();
cReq.GroupName = "default";
cReq.SMessageIds = msg.Id.ToString();
TmcMessagesConfirmResponse cRsp = client.Execute(cReq);
Console.WriteLine(cRsp.Body);
}
}
Console.WriteLine(rsp.Body);
} while (rsp != null && !rsp.IsError && rsp.Messages != null && rsp.Messages.Count == quantity);
Thread.Sleep(new TimeSpan(0, 0, 1));
} while (true);Remarque : le RT moyen d'extraction de messages via l'API peut atteindre environ 10 millisecondes lorsque le réseau est bon et que le message obtenu à chaque fois est vide. , assurez-vous de faire une pause d'au moins 1 seconde avant d'exécuter la boucle suivante pour extraire des messages, sinon de nombreuses requêtes inutiles seront générées, gaspillant les ressources du serveur et les propres paquets de trafic API de l'application. Introduction à l'utilisation du regroupement de messages
Lorsque le nombre d'utilisateurs est important, plusieurs machines doivent former un cluster pour recevoir des messages, ou les commerçants sont isolés pour recevoir des messages indépendamment. Le SDK et l'API peuvent recevoir des messages via plusieurs connexions.
Le service de messagerie prend en charge plusieurs connexions de deux manières : Ⅰ Créez plusieurs groupes d'utilisateurs et chaque groupe d'utilisateurs établit une connexion. Ⅱ. Établissez plusieurs connexions dans le même groupe
- Créer un groupe : Appelez l'interface taobao.tmc.group.add pour créer un groupe personnalisé. Remarque : Le service de messagerie créera un groupe par défaut pour l'application. Les utilisateurs qui ne sont pas affectés au groupe spécifié [groupe] appartiennent au groupe par défaut lors de la consommation de messages via le SDK ou l'API, si aucun groupe n'est spécifié, le groupe par défaut. la connexion de groupe est utilisée.
- Supprimer un groupe : appelez l'interface taobao.tmc.group.delete pour supprimer le ou les utilisateurs spécifiés sous le groupe. Remarque : Chaque application peut créer jusqu'à 50 groupes et il n'y a aucune limite quant au nombre d'utilisateurs dans chaque groupe.
Pour utiliser le service de messagerie Taobao
Message de retour des données d'abonnement
Dans l'arrière-plan de gestion de l'application, cliquez sur "S'abonner au message". Si le message n'a pas d'autorisation, cliquez sur "Appliquer l'autorisation" pour accéder à l'application. correspondant Le package à valeur ajoutée
le code implémente les messages push
Pour le retour des messages, il existe deux manières : Publier des messages via l'API, Publier des messages via le SDK Il est recommandé d'utiliser l'API. pour publier des messages.
Publier des messages via l'API
Pour des instructions spécifiques, veuillez vous référer au document API : taobao.tmc.message.produce
Publier des messages via le SDK (non recommandé)
Prend actuellement en charge JAVA et .NET langues, Pour les autres langues, il est recommandé d'utiliser l'API pour publier des messages.
Exemple de code JAVA
TmcClient client = new TmcClient("app_key", "app_secret", "default");
client.connect("ws://mc.api.taobao.com/");
for (int i = 0; i < 10; i++) {
client.send("helloworld-topic", "{helloworld-content}", "session_key");
}Exemple de code C#
TmcClient client = new TmcClient("app_key", "app_secret", "default");
client.Connect("ws://mc.api.taobao.com/");
for (int i = 0; i < 10; i++)
{
client.Send("helloworld-topic", "{helloworld-content}", "session_key");
}Description du type de message commun
La plateforme a fourni un document de description de message structuré, cliquez ici pour saisir le Document de message, vous pouvez également entrez le contrôle Abonnez-vous et désabonnez-vous dans la messagerie de la station.
Le service de messagerie Sandbox est activé
1. Visitez http://mini.tbsandbox.com/ et connectez-vous au bac à sable [Vous pouvez créer vous-même un compte sandbox ou utiliser le compte par défaut. www.tbsandbox.com /doc/Introduction à "Test de création de compte"】
Deuxièmement, sélectionnez l'outil de test sandbox - gestion des canaux de messages
3. Sandbox pour obtenir l'opération de raccourci SessionKey, entrez l'AppKey du bac à sable et cliquez sur Rechercher pour obtenir la SessionKey. Comme le montre la figure ci-dessous, l'application d'autorisation sandbox_c_1 1021719331 peut obtenir ses données. Le code d'autorisation est la valeur correspondant à la SessionKey. Appelez ensuite l'interface taobao.tmc.user.permit pour autoriser 1021719331 à recevoir son message.
4. Exécutez le code (demande à ws://mc.api.tbsandbox.com/, utilisez la clé d'application sandbox, le secret, le compte sandbox, reportez-vous à l'environnement officiel ci-dessus pour la partie code). commencé, vous pouvez accéder au centre du vendeur sandbox Modification Inventory Test Verification.
FAQ sur le service de messagerie
Qu'est-ce que le regroupement et si le regroupement est nécessaire ?
Le regroupement de messages est un moyen d'isoler les messages des utilisateurs du groupe qui ne seront envoyés qu'aux connexions portant le même nom de groupe. Le même groupe prend en charge plusieurs connexions et les messages du même groupe sont envoyés de manière aléatoire à une certaine connexion du groupe. Si vous souhaitez traiter les messages différemment en fonction des types d'utilisateurs, par exemple en donnant la priorité aux utilisateurs payants puis aux utilisateurs gratuits, vous pouvez recevoir des messages de différents utilisateurs via le regroupement de messages. Chaque application peut créer jusqu'à 50 groupes et il n'y a aucune limite quant au nombre d'utilisateurs dans chaque groupe.
Qu'est-ce que la réception de messages multi-connexions et comment établir plusieurs connexions
La réception de messages multi-connexions signifie que le serveur ISV du même groupe établit plusieurs connexions avec le serveur de messages TOP pour recevoir des messages. Multi-lien signifie que pour le même groupe, lorsqu'un message est remis, une connexion est sélectionnée au hasard parmi plusieurs connexions du groupe pour transmettre le message. Les multi-liens ont pour fonction de transmettre des messages de manière aléatoire, et plusieurs connexions dans le même groupe peuvent être utilisées pour implémenter des fonctions de clustering et de chargement.
L'établissement de plusieurs liens nécessite uniquement le redémarrage d'une instance TmcClient avec le même code. Plusieurs liens du même groupe peuvent être établis sur le même serveur ISV ou sur différents serveurs ISV.
Quand utiliser plusieurs connexions ?
Le serveur du service de messagerie a une fonction d'accumulation de messages. Cela dépend de la capacité de traitement de votre client, s'il peut le gérer. ne peut pas être traité, il sera empilé sur le serveur. Généralement Dans ce cas, il n'est pas nécessaire d'établir plusieurs connexions. Une seule connexion peut remplir la carte réseau de la machine. La multi-connexion du nouveau service de messagerie est plus couramment utilisée dans les scénarios de regroupement d'utilisateurs ou de déploiement de cluster.
Quelle est la logique de renvoi des messages ?
En cas de déconnexion (comme la suspension de l'application), le serveur accumulera des messages, et après la reconnexion de l'application, les messages accumulés seront transmis au client dans l'ordre. A partir de la naissance d'un message, si l'application ne le reçoit pas, la durée maximale de rétention sur le serveur est de 3 jours. Si elle dépasse 3 jours, elle sera automatiquement effacée. Si la connexion est normale mais que le traitement du message échoue, le serveur renverra le message pour la première fois toutes les 10 minutes au plus tôt. Si l'application continue d'échouer, le serveur renverra le message régulièrement jusqu'à ce que le message soit effacé.
Problème de dépassement d'entier de json_decode en PHP
Dans la version PHP 5.3, json_decode s'appuie sur le nombre de chiffres du système d'exploitation pour interpréter les nombres. Sur les systèmes 32 bits, il ne prend en charge qu'un maximum de 2^32 interprétations de nombres, et sur les systèmes 64 bits, il prend en charge un maximum de 2 ^ 32. Explication du nombre 2 ^ 64. Étant donné que l'ID de message du service de messagerie dépasse la valeur maximale du système 32 bits, s'il n'est pas mis à niveau vers la version PHP 5.3 ou supérieure, un ID de message incorrect sera confirmé, entraînant une livraison répétée du message. La solution est la suivante : 1. Mettez à niveau PHP vers la version 5.3 ou supérieure ; 2. Déployez l'application sur un système 64 bits ; 3. Remplacez les nombres dans le message JSON par des chaînes via des expressions régulières et d'autres moyens.
Déconnexion du message et test de battement de cœur
Le client doit déconnecter le message directement : TmcClient.close(); Test de battement de cœur pour voir si la connexion est normale : TmcClient.isOnline();
Remboursement Tmall et remboursement Taobao La différence
Le remboursement Tmall inclut uniquement les commandes de Tmall, tandis que le remboursement Taobao inclut les commandes de Taobao et Tmall. Cependant, le statut du remboursement Tmall est un peu plus riche et nécessite plus de processus. S'il n'est pas utilisé, il est recommandé d'utiliser le message de remboursement Taobao. Si nécessaire, vous devez demander l'autorisation de l'API de remboursement Tmall, qui peut être activée après l'application.
Y aura-t-il un délai dans le service de messagerie ?
Il faut 10 secondes pour activer le service de messagerie taobao.tmc.user.permit pour que l'utilisateur prenne effet. Il n'y a pratiquement aucun délai dans l'utilisation des messages et ils seront reçus dans un délai d'une seconde. S'il y a des messages accumulés ou si le programme n'est pas traité à temps, il y aura un retard. Le temps de retard est lié aux capacités de traitement du programme. L'annulation du service de messagerie pour l'utilisateur prendra effet dans la seconde qui suit taobao.tmc.user.cancel. Après l'annulation, les messages accumulés continueront à être envoyés et aucun nouveau message ne sera envoyé.
Est-il normal que le pseudo dans le message du produit message.getContent() soit vide ? Comment puis-je savoir à quel magasin appartient le message ?
Dans les informations sur le produit, il existe des cas où le pseudo est vide. Vous pouvez utiliser une couche externe pour obtenir message.getUserNick() ou message.getUserId().
Service de messagerie, si l'utilisateur expire, recevra-t-il toujours des messages ?
Il y a deux conditions pour juger du service de messagerie : 1. Si l'autorisation de l'utilisateur est dans la période de validité ; 2. Si l'utilisateur a activé le service de messagerie (toabao.tmc.user.permit). Ce n’est que lorsque les deux seront satisfaits en même temps qu’il sera poussé. Au contraire, si l'autorisation de l'utilisateur expire, elle ne sera pas poussée. De plus, dans un délai d'un mois après l'expiration de l'autorisation de l'utilisateur, la relation d'activation de l'utilisateur sera enregistrée et sera effacée après un mois. Si l'utilisateur réautorise dans un délai d'un mois, il n'est pas nécessaire de réactiver le service de messagerie pour l'utilisateur.
Après avoir reçu le message, s'il n'est pas confirmé, le service de messagerie choisira une opportunité pour le renvoyer. Le nombre de renvois est contrôlé par le service de messagerie. Combien de fois sera-t-il renvoyé jusqu'à présent ?
Le service de messagerie vérifie toutes les dix minutes les messages non traités puis les envoie à un moment approprié. Si le message n'est pas confirmé dans les 3 jours, il sera supprimé
Le message n'a pas été reçu. Comment confirmer si le service de messagerie l'a manqué ?
Grâce aux commentaires quotidiens, il n'y a aucune fuite de message dans le service de messagerie. Généralement, le programme ISV ne reçoit pas le message ou la capacité de traitement du programme entraîne le blocage du message. Le message de dépannage peut être confirmé sous les aspects suivants :
* Confirmez d'abord si l'autorisation (SessionKey) est valide ;
* Appelez taobao.tmc.user.get pour confirmer l'utilisateur actuel et les messages activés, et transmettez les paramètres de retour dans les sujets ; ; appelez TmcClient.isOnline() pour tester Le battement de cœur est-il connecté normalement ? Si le dépannage ci-dessus échoue, vous pouvez soumettre le problème au centre d'assistance et joindre : AppKey, pseudo d'utilisateur, statut du message, heure approximative du message, numéro de commande et numéro_iid du produit.
Notes sur les paramètres de configuration du client
.NET SDK : ReconnectIntervalSeconds temps de reconnexion, identifie l'intervalle de temps de reconnexion lorsque TmcClient est déconnecté. Cette valeur doit être >10s. Si cette valeur est trop petite, le lien échouera. La raison est que si le serveur détecte une reconnexion dans les 500 ms, il déconnectera le nouveau lien.
Remarques sur les modifications de l'inventaire des produits
- Lorsque l'inventaire des produits est modifié via l'API (taobao.item.quantity.update, ou taobao.item.sku.update pour modifier la quantité), le message taobao_item_ItemStockChanged sera généré .
- Lors de la mise à jour de la quantité de produit via l'API (taobao.item.update) ou de la modification de l'inventaire du produit via la page, seul le message de changement de produit (taobao_item_ItemUpdate) sera généré, mais le message taobao_item_ItemStockChanged ne sera pas envoyé. contient la quantité en stock du produit, aucun montant de modification.
Dans l'opération suivante, la quantité en stock du produit est directement restituée :
- Lorsque le produit est photographié (photographié pour réduire le stock) ou payé (paiement pour réduire le stock) (y compris la création d'une transaction via l'API), le message ci-dessus sera généré.
- Ce message sera généré lors de la clôture d'une commande ou d'une sous-commande (y compris la clôture des transactions via l'API).
- Lorsque l'acheteur effectue le paiement et que le vendeur modifie le SKU du produit commandé via la page, l'inventaire SKU du produit correspondant changera également et le message ci-dessus sera généré (le message de changement de transaction taobao_trade_TradeChanged sera également généré à cette fois).
Explication des messages liés au remboursement
Aucun message lié au remboursement ne sera généré lors du remboursement via l'interface taobao.trade.fastrefund (remboursement rapide). Seuls les remboursements avec un processus de remboursement généreront des informations relatives au remboursement. L'interface de remboursement rapide (taobao.trade.fastrefund) paie directement l'acheteur puis clôture la transaction. Le processus de remboursement ne sera pas créé, donc aucun message de remboursement ne sera généré. Actuellement, seules les catégories virtuelles prennent en charge l'interface taobao.trade.fastrrefund.
Description du champ lié au message Heure, heure d'absence et heure locale
- time est l'heure de génération du message
- outtime est l'heure actuelle de transmission du message
- localtime est l'heure de la machine locale
- outtime - time représente le délai de traitement ou de retransmission du serveur
- localtime - outtime représente l'heure de la machine locale et le décalage horaire TOP, ou le délai du réseau, ou le délai de traitement après réception du message
erreur du service de messagerie isp.system-error : erreurs inconnues, isv.tmc-switch-off : appkey, le l'application n'active pas la fonctionnalité de canal de messagerie
Si l'application n'est pas abonnée (activée) au service de messagerie, elle utilise TmcClient pour recevoir des messages.
FAQ
- Il n'y a pas encore de FAQ sur ce document
