Exemple de détails de code pour un panier d'achat basé sur XML

Les paniers d'achat sont un élément indispensable des sites Web de commerce électronique, mais actuellement, la plupart des paniers d'achat ne peuvent être utilisés que comme affichage pour les produits sélectionnés par un client. Le client ne peut pas extraire le contenu du panier pour répondre à ses propres besoins de traitement des transactions. . Ceci est nécessaire dans certaines activités de commerce électronique. L'émergence du XML donne du sens aux données transmises sur le réseau. Nous pouvons afficher le contenu d'un panier dans différents styles selon différentes exigences.

Cet article analysera en détail un panier d'achat basé sur XML implémenté en Java. Voici la structure interne XML d'un panier contenant cinq articles : son élément racine est cart, l'élément total représente le montant total dans le panier, chaque élément article représente un produit et les sous-éléments de l'article sont marqués respectivement. Les informations spécifiques du produit peuvent être ajoutées, modifiées ou supprimées en fonction de la situation réelle.

Ici, vous devez créer une classe qui représente le panier : XMLCart.java C'est un JavaBean, il contient donc un constructeur vide. Cette classe contient quelques fonctions de base du panier : générer un panier vide, ajouter des articles au panier, supprimer des articles dans le panier, modifier le nombre d'articles dans le panier, vider le panier, etc. Il possède une variable privée globale "PRivate XMLDocument myCart". myCart est utilisé pour stocker le contenu détaillé du panier. La fonction de base du panier est de le faire fonctionner. Son type est XMLDocument, qui est un document XML. De cette manière, le fonctionnement du panier est converti en ajout et suppression de sous-éléments dans myCart, ainsi qu'en calcul et modification des valeurs des éléments.

1． Vider le panier

Effacer le panier générera un panier vide. Ici, le panier vide est un document XML contenant l'élément racine panier et son élément total. L'élément total est le montant total du panier, et sa valeur initiale est 0. Sa forme XML spécifique est la suivante :

< ?xml version=‘1.0’ encoding=‘gb2312’?>
< cart>
< total>0< /total>
< /cart>

will Cette chaîne XML est convertie en XMLDocument par la fonction parseString et stockée dans myCart.
Le code est le suivant :

public void emptyCart() throws IOException,SAXException{
    String stringCart=“< ?xml version=‘1.0’encoding=‘gb2312’?> ”+
       “< cart>< total>0< /total>< /cart>”;
      myCart=parseString(stringCart);
    }

2. Ajouter un produit
Ajouter un produit, c'est-à-dire ajouter l'élément d'article entrant au panier d'éléments racine,
où l'article comprend les détails du produit,
et calculer la valeur du total en même temps. Le code est le suivant :

public void addItemToCart(String stringItem)
throws IOException,SAXException{
//将item由String转换为XMLDocument
XMLDocument itemAdded=parseString(stringItem);
//取出item节点，并复制它
NodeList itemList=itemAdded.getElementsByTagName(“item”);
Node item=itemList.item(0);
Node cloneItem=item.cloneNode(true);
//如果购物车为空，则构造一个新的购物车
if(isCartEmpty()){
     myCart.emptyCart();
}
//如果该商品不在购物车中，则插入该商品，并计算总金额
if(!isItemExist(item,myCart)){
//取myCart的根元素，并将复制的item节点添加到后面
Element cartRoot=myCart.getDocumentElement();
Node cartNode=cartRoot.appendChild(cloneItem);        
computeTotal();    //计算总金额
        }
    }

3. Supprimer un produit
Supprimer un produit, c'est-à-dire supprimer l'élément article
du produit du panier d'éléments racine de myCart en fonction du code produit,
et recalculer la valeur du total :

public void moveItemFromCart(String id){
//取出以item为单位的节点集cartList以及根元素cartRoot
  NodeList cartList=myCart.getElementsByTagName(“item”);
     Element cartRoot=myCart.getDocumentElement();
      //在cartList中查找代码为选中id的商品
    for(int x=0;x< cartList.getLength();x++){
      Node itemNode=cartList.item(x);
      String  idValue=itemNode.getFirstChild().
      getFirstChild().getNodeValue();
      //如果找到，则从cartRoot中删除该节点，并跳出循环
if(idValue.equals(id)){
      itemNode=cartRoot.removeChild(itemNode);
       break;
            }
        }
        computeTotal();    //计算总金额
    }

4． Changer la quantité du produit
Selon la quantité renseignée par le client sur la page, modifier la quantité dans monCart,
et recalculer le total :

public void addQuantityToCart(String qnty) throws 
IOException,SAXException{
    //将传过来的包含商品数量的一组XML字符串转换为XML文档
XMLDocument quantityChanged=parseString(qnty);
//取出包含新数量的quantity节点集和myCart中的quantity节点集
NodeList quantityList=quantityChanged.getElementsByTagName(“quantity”);
NodeList cartList=myCart.getElementsByTagName(“quantity”);
//循环改变商品的数量
for(int x=0;x< cartList.getLength();x++){
//将新quantity的值赋给myCart中相应的quantity中去
String quantity=quantityList.item(x).getFirstChild().getNodeValue();
cartList.item(x).getFirstChild().setNodeValue(quantity);
}
computeTotal();    //计算总金额
    }

5. Calculer le montant total
revient à calculer la valeur du total, où total=∑(prix*quantité) :

public void computeTotal(){
    NodeList quantityList=myCart.getElementsByTagName(“quantity”);
    NodeList priceList=myCart.getElementsByTagName(“price”);
    float total=0;
    //累加总金额
for(int x=0;x< priceList.getLength();x++){
    float quantity=Float.parseFloat(quantityList.item(x)
    .getFirstChild().getNodeValue());
  float price=Float.parseFloat(priceList.item(x).getFirstChild().getNodeValue());
    total=total+quantity*price;
    }
    //将total附给myCart的total
String totalString=String.valueOf(total);
    myCart.getElementsByTagName(“total”).
    item(0).getFirstChild().setNodeValue(totalString);
  }

6. Déterminez si le panier est vide
Habituellement, lors de l'ajout de nouveaux produits, vous devez également savoir si le panier est vide
S'il est vide, un nouveau panier doit être généré.

public boolean isCartEmpty(){
//item的节点集，如果该节点集包含的节点数为0，则购物车内没有商品，返回true
NodeList itemList=myCart.getElementsByTagName(“item”);
if(itemList.getLength()==0) return true;
else return false;
}

7． Déterminez si le produit sélectionné est déjà dans le panier
Autrement dit, déterminez si l'article du produit nouvellement transféré existe déjà dans myCart. S'il existe, renvoyez true.

public boolean isItemExist(Node item, XMLDocument cart){
  NodeList itemList=cart.getElementsByTagName(“item”);
      Node id=item.getFirstChild();
      String idValue=id.getFirstChild().getNodeValue();
      if(itemList.getLength()!=0){
          for(int x=0;x< itemList.getLength();x++){
           Node itemTemp = itemList.item(x);
          7Node idTemp=itemTemp.getFirstChild();
           String idTempValue=idTemp.getFirstChild().getNodeValue();
            if(idValue.equals(idTempValue)) return true;
            }
          return false;
        }
      return false;
    }

En plus des méthodes ci-dessus, XMLCart inclut également la méthode parseString, qui convertit la chaîne XML de String lors de la saisie en XMLDocument, et attribue XSL à myCart lors de la sortie et renvoie le type String. . La méthode cartTurnToStringWithXSL des chaînes XML est utilisée pour aider à la mise en œuvre des principales opérations du panier, qui ne seront pas décrites en détail ici.

Ce qui précède est un exemple de code détaillé du panier d'achat basé sur XML. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !