Beispielcodedetails für einen XML-basierten Warenkorb

Warenkörbe sind ein unverzichtbarer Bestandteil von E-Commerce-Websites, aber derzeit können die meisten Einkaufskörbe nur zur Anzeige der vom Kunden ausgewählten Produkte verwendet werden. Der Kunde kann den Inhalt des Einkaufswagens nicht extrahieren, um seine eigenen Transaktionsverarbeitungsanforderungen zu erfüllen . Dies ist bei einigen E-Commerce-Aktivitäten notwendig. Das Aufkommen von XML macht die im Netzwerk übertragenen Daten aussagekräftig. Wir können den Inhalt eines Warenkorbs je nach Anforderung in verschiedenen Stilen anzeigen.

In diesem Artikel wird ein in Java implementierter XML-basierter Warenkorb detailliert analysiert. Das Folgende ist die interne XML-Struktur eines Warenkorbs mit fünf Artikeln: Sein Stammelement ist Warenkorb, das Gesamtelement stellt den Gesamtbetrag im Warenkorb dar, jedes Artikelelement stellt ein Produkt dar und die Unterelemente im Artikel sind markiert Die spezifischen Informationen des Produkts können entsprechend der tatsächlichen Situation hinzugefügt, geändert oder gelöscht werden.

Hier müssen Sie eine Klasse erstellen, die den Warenkorb darstellt: XMLCart.java Es ist eine JavaBean und enthält daher einen leeren Konstruktor. Diese Klasse enthält einige Grundfunktionen des Warenkorbs: Erzeugen eines leeren Warenkorbs, Hinzufügen von Artikeln zum Warenkorb, Löschen von Artikeln im Warenkorb, Ändern der Anzahl der Artikel im Warenkorb, Leeren des Warenkorbs usw. Es verfügt über eine globale private Variable „PRivate XMLDocument myCart“, die zum Speichern des detaillierten Inhalts des Warenkorbs verwendet wird. Die Grundfunktion des Warenkorbs besteht darin, ihn zu bedienen. Auf diese Weise wird die Bedienung des Warenkorbs in das Hinzufügen und Löschen von Unterelementen in myCart sowie in die Berechnung und Änderung von Elementwerten umgewandelt.

1． Warenkorb leeren

Durch das Löschen des Warenkorbs wird ein leerer Warenkorb generiert. Hier ist der leere Warenkorb ein XML-Dokument, das das Stammelement „cart“ und sein Element „total“ enthält. Das Gesamtelement ist der Gesamtbetrag des Warenkorbs und sein Anfangswert ist 0. Seine spezifische XML-Form ist wie folgt:

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

wird Dieser XML-String wird von der parseString-Funktion in ein XML-Dokument konvertiert und in myCart gespeichert.
Der Code lautet wie folgt:

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

2. Fügen Sie ein Produkt hinzu
Fügen Sie ein Produkt hinzu, d. h. fügen Sie das eingehende Artikelelement zum Stammelement-Warenkorb hinzu,
wobei der Artikel Produktdetails enthält,
und berechnen Sie gleichzeitig den Gesamtwert. Der Code lautet wie folgt:

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. Löschen Sie ein Produkt
Löschen Sie ein Produkt, d. h. löschen Sie das Artikelelement
des Produkts aus dem Stammelement Warenkorb von myCart gemäß dem Produktcode,
und berechnen Sie den Gesamtwert neu:

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． Ändern Sie die Menge des Produkts
Ändern Sie entsprechend der vom Kunden auf der Seite eingegebenen Menge die Menge in myCart,
und berechnen Sie die Gesamtsumme neu:

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. Die Berechnung des Gesamtbetrags
bedeutet, den Gesamtwert zu berechnen, wobei Gesamt = ∑ (Preis * Menge):

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. Stellen Sie fest, ob der Warenkorb leer ist.
Normalerweise müssen Sie beim Hinzufügen neuer Produkte auch wissen, ob der Warenkorb leer ist.
Wenn er leer ist, muss ein neuer Warenkorb erstellt werden.

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

7． Stellen Sie fest, ob sich das ausgewählte Produkt bereits im Warenkorb befindet.
Das heißt, stellen Sie fest, ob der Artikel des neu übertragenen Produkts bereits in myCart vorhanden ist. Wenn er vorhanden ist, geben Sie „true“ zurück.

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;
    }

Zusätzlich zu den oben genannten Methoden enthält XMLCart auch die Methode parseString, die den XML-String bei der Eingabe von String in XMLDocument konvertiert, bei der Ausgabe XSL an myCart zuweist und den String-Typ zurückgibt . Die Methode „cartTurnToStringWithXSL“ von XML-Strings wird verwendet, um die Implementierung der Hauptoperationen des Warenkorbs zu unterstützen, die hier nicht im Detail beschrieben werden.

Oben finden Sie die Beispielcodedetails des XML-basierten Warenkorbs. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).