Heim >Java >javaLernprogramm >Der Warenkorb wurde basierend auf dem Servlet+JSP+JavaBean-Modell entwickelt
Der Warenkorb wurde basierend auf dem Servlet+JSP+JavaBean-Modell entwickelt
- 巴扎黑Original
- 2017-08-10 15:16:152227Durchsuche
Im vorherigen Artikel wurde ein am häufigsten verwendetes Benutzeranmelde- und Registrierungsprogramm verwendet, um das Servlet+JSP+JavaBean-Entwicklungsmodell zu erklären, sodass wir auch ein vorläufiges Verständnis des Servlet+JSP+JavaBean (MVC)-Modells haben. Sehen wir uns nun dieses Entwicklungsmodell mit einem Warenkorbprogramm für Online-Einkäufe an.
Erstellen Sie ein Webprojekt mit MVC-Architektur
Erstellen Sie ein neues Day10-Projekt in Eclipse, importieren Sie das für das Projekt erforderliche Entwicklungspaket (JAR-Paket) und erstellen Sie das für das Projekt erforderliche Paket in Java Entwicklung werden die Architekturebenen in Form von Paketen widergespiegelt.
Für das Projekt erforderliches Entwicklungspaket (JAR-Paket):
| 序号 | 开发包名称 | 描述 |
|---|---|---|
| 1 | stl-1.2.jar | jstl标签库和EL表达式依赖包 |
Hinweis: Anders als das Benutzer-Login-Registrierungsprogramm im vorherigen Artikel erstellt dieses Warenkorbprogramm eine Klasse Um die Datenbank darzustellen, ist es nicht erforderlich, andere JAR-Pakete zu verwenden. Verwenden Sie einfach stl-1.2.jar.
Für das Projekt erforderliche Pakete:
| Seriennummer | Paketname | BeschreibungEbene | |||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | cn.itcast.DB | Speichert Klassen, die Datenbanken darstellen |
|
||||||||||||||||||||||||||||||||
| 2 | cn.itcast.domain | speichert die JavaBean-Klasse des Systems (die nur einfache Attribute und die den Attributen entsprechenden Get- und Set-Methoden enthält und keine spezifischen Geschäftsverarbeitungsmethoden enthält) und wird der [Datenzugriffsschicht], [Geschäftslogikschicht] bereitgestellt ] und [Webebene] Verwenden SieDomänenebene (Domänenmodellebene) | |||||||||||||||||||||||||||||||||
| 3 | cn.itcast.dao td> | zum Speichern des Zugriffs Implementierungsklasse der Datenbankbetriebsschnittstelle | Datenzugriffsschicht | ||||||||||||||||||||||||||||||||
| 4 | cn.itcast. service | Speichern Sie die Implementierungsklasse der Geschäftsschnittstelle des Verarbeitungssystems | Geschäftslogikschicht | ||||||||||||||||||||||||||||||||
| 5 | cn.itcast.web.controller td>Speichert das Servlet als Systemcontroller (Servlet, das Anfragen verarbeitet) | Webschicht (Präsentationsschicht) | tr>|||||||||||||||||||||||||||||||||
| 6 | cn.itcast.web.UI | Bietet Benutzern eine Benutzeroberfläche. Denn im strikten MVC-Modus ist JSP geschützt und der direkte Zugriff von außen ist verboten. Wenn sich ein Benutzer registrieren möchte, muss er eine Formularseite abrufen und ein Servlet verwenden, um Benutzer an JSP zu übertragen Benutzeroberfläche, und das heißt, in der tatsächlichen Entwicklung werden einige Servlets zum Verarbeiten von Anforderungen verwendet, und einige Servlets werden speziell zum Empfangen von Anforderungen und dann zum Übertragen an JSP verwendet, um Benutzern eine Benutzeroberfläche bereitzustellen | Webschicht (Präsentationsschicht) | ||||||||||||||||||||||||||||||||
| 7 | cn.itcast.utils | Speichert die allgemeinen Werkzeugklassen des Systems und stellt sie bereit die [Datenzugriffsschicht] und die [Geschäftslogikschicht], die zu verwendende [Webschicht] |
Die oben genannten Pakete basieren auf der tatsächlichen Situation dieses Projekts. Möglicherweise müssen Sie auch andere Pakete erstellen. Dies hängt von den Anforderungen des Projekts ab.
Erstellen Sie eine Klasse, die die Datenbank darstellt :
Angenommen, es handelt sich um ein Online-Buchhandlungsprojekt und die von Benutzern gekauften Produkte sind Bücher, sodass die in der Datenbank gespeicherten Produkte Bücher sind. Erstellen Sie eine DB-Klasse unter dem Paket cn.itcast.DB.
Der spezifische Code der DB-Klasse lautet wie folgt:
public class DB { private static Map<String, Book> map = new LinkedHashMap<String, Book>();
static { map.put("1", new Book("1", "javaweb开发", "老张", 38, "一本好书")); map.put("2", new Book("2", "jdbc开发", "老黎", 18, "一本好书")); map.put("3", new Book("3", "ajax开发", "老佟", 328, "一本好书")); map.put("4", new Book("4", "jbpm开发", "老毕", 58, "一本好书")); map.put("5", new Book("5", "struts开发", "老方", 28, "一本好书")); map.put("6", new Book("6", "spring开发", "老方", 98, "一本好书"));
} public static Map<String, Book> getAll() { return map;
}
}1234567891011121314151617Hinweis: Informationen zum Erstellen einer Klasse, die die Datenbank darstellt – DB.java – finden Sie hier zu meiner Verwendung von Cookies für die Sitzungsverwaltung.
Erstellen Sie ein JSP-Verzeichnis im WEB-INF-Verzeichnis. Im JSP-Verzeichnis werden einige geschützte JSP-Seiten des Systems gespeichert (Benutzer dürfen nicht direkt über URL-Adressen darauf zugreifen). Nur über das Servlet im cn.itcast.web.UI-Paket.
Die erstellte Projektarchitektur ist in der folgenden Abbildung dargestellt:
Der Code für die Schichtarchitektur ist geschrieben.
Der Code für die Schichtarchitektur ist ebenfalls entsprechend geschrieben zur [Domänenmodellschicht (Domäne)] → [Datenzugriffsschicht (dao, dao.impl)] → [Geschäftslogikschicht (service, service.impl)] → [Präsentationsschicht (web.controller, web.UI, web .filter, web.listener)] Es wird in der Reihenfolge → [Tool-Klasse (util)] → [Testklasse (junit.test)] geschrieben.
Entwickeln Sie die Domänenschicht
Erstellen Sie eine Buchklasse unter dem Paket cn.itcast.domain.
Der spezifische Code der Book-Klasse lautet wie folgt:
public class Book { private String id; private String name; private String author; private double price; private String description; public Book() { super(); // TODO Auto-generated constructor stub
} public Book(String id, String name, String author, double price, String description) { super(); this.id = id; this.name = name; this.author = author; this.price = price; this.description = description;
} public String getId() { return id;
} public void setId(String id) { this.id = id;
} public String getName() { return name;
} public void setName(String name) { this.name = name;
} public String getAuthor() { return author;
} public void setAuthor(String author) { this.author = author;
} public double getPrice() { return price;
} public void setPrice(double price) { this.price = price;
} public String getDescription() { return description;
} public void setDescription(String description) { this.description = description;
}
}1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253Entwickeln Sie die Datenzugriffsschicht (dao, dao.impl)
Erstellen Sie eine UserDao-Klasse unter dem Paket cn.itcast.dao .
Der spezifische Code der UserDao-Klasse lautet wie folgt:
public class BookDao { public Map<String, Book> getAll() { return DB.getAll();
} public Book find(String id) { return DB.getAll().get(id);
}
}1234567891011Entwicklung der Serviceschicht (die Serviceschicht stellt alle Geschäftsdienste für die Webschicht bereit)
Im Prozess der Entwicklung einer neuen Projekt zum ersten Mal, und Wir kennen nicht die Funktionen aller zu entwickelnden Projekte, daher können wir zuerst die Funktionen entwickeln, die am einfachsten zu denken sind, und uns dann beim Durchsuchen der Website-Seiten als Benutzer ausgeben. Wir werden sehen, welche Funktionen die Benutzer benötigen, und dann werden wir Programmierer welche Funktion entwickeln und dann Schritt für Schritt daran arbeiten, die Funktion des gesamten Projekts zu vervollständigen.
Als ich beispielsweise dieses Warenkorb-Funktionsmodul zum ersten Mal entwickelte, dachte ich zunächst daran, dem Benutzer alle Bücher anzuzeigen und die Buchinformationen anhand der Buch-ID abzufragen. Ich habe keine anderen Funktionen erwartet, daher kann ich warten, bis diese Funktionen abgeschlossen sind, und anhand der Front-End-Seite sehen, welche Funktionen benötigt werden.
Erstellen Sie eine BusinessService-Klasse unter dem Paket cn.itcast.service. 
Schreiben Sie zunächst die BusinessService-Klasse, die die folgenden beiden Geschäftsdienste implementiert.
Dem Benutzer alle Bücher anzeigen
Buchinformationen basierend auf der Buch-ID abfragen
Spezifisch Der Code lautet wie folgt:
// 业务类，统一对web层提供所有服务public class BusinessService { private BookDao dao = new BookDao(); public Map<String, Book> getAllBook() { return dao.getAll();
} public Book findBook(String id) { return dao.find(id);
}
}12345678910111213Entwickeln Sie die Webebene
Entwickeln Sie die Funktion zum Anzeigen aller Bücher für Benutzer
Geschrieben unter dem cn.itcast.web.controller Paket zum Verarbeiten von ListBookServlet, das dem Benutzer alle Bücher anzeigt. 
Der spezifische Code der ListBookServlet-Klasse lautet wie folgt:
// 获取所有书public class ListBookServlet extends HttpServlet { protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
BusinessService service = new BusinessService();
Map<String, Book> map = service.getAllBook();
request.setAttribute("map", map);
request.getRequestDispatcher("/WEB-INF/jsp/listbook.jsp").forward(request, response);
} protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}12345678910111213141516171819Schreiben Sie die JSP-Seite listbook.jsp in das Verzeichnis /WEB-INF/jsp/, um alle Bücher anzuzeigen an den Benutzer. 
Auf JSP-Seiten im WEB-INF-Verzeichnis kann nicht direkt über die URL-Adresse zugegriffen werden. Wenn das Projekt während der Entwicklung vertrauliche Webressourcen enthält, auf die die Außenwelt nicht direkt zugreifen soll, können Sie erwägen, diese vertraulichen Webressourcen im WEB-INF-Verzeichnis abzulegen, damit Außenstehende nicht darauf zugreifen können sie direkt über URLs. Der Code der Seite
listbook.jsp lautet wie folgt:
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%><%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>书籍列表页面</title></head><body style="text-align: center;"> <h1>书籍列表</h1> <table width="70%" border="1" align="center"> <tr> <td>书名</td> <td>作者</td> <td>售价</td> <td>描述</td> <td>操作</td> </tr> <c:forEach var="entry" items="${map }"> <tr> <td>${entry.value.name }</td> <td>${entry.value.author }</td> <td>${entry.value.price }</td> <td>${entry.value.description }</td> <td> <a href="${pageContext.request.contextPath }/BuyServlet?id=${entry.key }" target="_blank">购买</a> </td> </tr> </c:forEach> </table></body></html>12345678910111213141516171819202122232425262728293031323334Websites haben im Allgemeinen eine Homepage. In diesem Projekt können Benutzer die Website durchsuchen, indem sie auf klicken 浏览书籍Hyperlink. Der Code der Seite
index.jsp lautet wie folgt:
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>网站首页</title></head><body> <a href="${pageContext.request.contextPath }/ListBookServlet">浏览书籍</a></body></html>123456789101112An diesem Punkt ist die Funktion zum Anzeigen aller Bücher für Benutzer abgeschlossen! Testen wir die entwickelte Funktion:
开发购买书籍的功能
在现实中购买商品时，用户都是将商品放到购物车中，所以我们应该按照现实中的情况设计一个代表用户购物车的类——Cart.java。
现在再来思考一个问题：在设计代表用户购物车的Cart类时，应该使用private Book book字段(或属性)来代表用户所购买的商品吗？
答案显然不是。若是使用这样的字段，结果就是不可避免地在购物车中出现重复商品，即用户如果购买一本书多次，那么购物车中就出现一本书多次，显然在现实中这是不合理的。那么到底该怎么做呢？——为了避免在购物车里面出现重复商品，我们这时会设计一个专门的对象——CartItem（购物项，代表某个商品以及这个商品出现的次数）。
在cn.itcast.domain包下创建一个CartItem类，用于代表某个商品，以及商品出现的次数（购物项）。 
CartItem类的具体代码如下：
// 用于代表某个商品，以及商品出现的次数（购物项）public class CartItem { private Book book; private int quantity; private double price; public Book getBook() { return book;
} public void setBook(Book book) { this.book = book;
} public int getQuantity() { return quantity;
} public void setQuantity(int quantity) { this.quantity = quantity; this.price = this.book.getPrice() * this.quantity;
} public double getPrice() { return price;
} public void setPrice(double price) { this.price = price;
}
}12345678910111213141516171819202122232425262728在cn.itcast.domain包中创建一个代表用户购物车的Cart类。 
Cart类的具体代码如下：
// 代表用户的购物车public class Cart { /*
* 为了避免在购物车里面出现重复商品，
* 我们这时会设计一个专门的对象——CartItem(购物项，代表某个商品以及这个商品出现的次数)
*/ private Map<String, CartItem> map = new LinkedHashMap<>(); private double price; // 记住购物车中的所有商品多少钱 public void add(Book book) { // 看购物车中有没有，要添加的书对应的购物项
CartItem item = map.get(book.getId()); if(item==null) {
item = new CartItem();
item.setBook(book);
item.setQuantity(1);
map.put(book.getId(), item);
} else {
item.setQuantity(item.getQuantity()+1);
}
} public Map<String, CartItem> getMap() { return map;
} public void setMap(Map<String, CartItem> map) { this.map = map;
} public double getPrice() { double totalprice = 0; for(Map.Entry<String, CartItem> entry : map.entrySet()) {
CartItem item = entry.getValue();
totalprice += item.getPrice();
} this.price = totalprice; return price;
} public void setPrice(double price) { this.price = price;
}
}12345678910111213141516171819202122232425262728293031323334353637383940414243用户浏览网站首页时，会看到网站所有书籍，用户即可对自己感兴趣的书籍进行购买，点击购物超链接时，跳转到一个servlet对用户的请求进行处理。所以在cn.itcast.web.controller包中创建一个代表完成书籍购买的BuyServlet类。 
BuyServlet类的具体代码如下：
// 完成书籍购买@WebServlet("/BuyServlet")public class BuyServlet extends HttpServlet { protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String id = request.getParameter("id");
BusinessService service = new BusinessService();
Book book = service.findBook(id); // 得到用户的购物车
Cart cart = (Cart) request.getSession().getAttribute("cart"); // 用户第一次购买，为用户创建购物车 if(cart==null) {
cart = new Cart();
request.getSession().setAttribute("cart", cart);
} // 把书加到用户的购物车中，完成购买
cart.add(book); /*
* 浏览器重新访问地址：/WEB-INF/jsp/listcart.jsp
* 但这个地址被保护起来，外面是无法直接访问的，
* 要实现的话，会比较麻烦，需要先跳到servlet，然后再转到jsp。
*/ // response.sendRedirect("/WEB-INF/jsp/listcart.jsp");
request.getRequestDispatcher("/WEB-INF/jsp/listcart.jsp").forward(request, response);
} protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}1234567891011121314151617181920212223242526272829303132333435363738注意：显示购物车时，记住千万不要用请求转发，而应该使用重定向技术。若不是产生的后果可参考我的笔记Session——使用Session完成简单的购物功能。我上面的代码使用的是请求转发，这是不行的，读者要注意了啊！既然要使用重定向技术，下面这行代码可行吗？
response.sendRedirect("/WEB-INF/jsp/listcart.jsp");1答案不言而喻，这是不行的。因为这是浏览器重新访问地址/WEB-INF/jsp/listcart.jsp，listcart.jsp页面是被保护起来了，外界是无法直接访问的。如果一定要实现的话，会比较麻烦，还需要先跳到一个servlet，然后再跳转到listcart.jsp。所以正规的做法是：BuyServlet类中使用重定向技术，即添加如下代码：
response.sendRedirect(request.getContextPath()+"/ListCartUIServlet");1
然后在cn.itcast.web.UI包下创建一个ListCartUIServlet类，专门用来接收请求之后转到jsp，给用户提供用户界面。 
ListCartUIServlet类的具体代码如下：
public class ListCartUIServlet extends HttpServlet { protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.getRequestDispatcher("/WEB-INF/jsp/listcart.jsp").forward(request, response);
} protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}12345678910111213这毕竟不是一个真实项目，所以不想把其搞得这么复杂哈！所以就干脆用了请求转发，但是读者一定要知道这还是不行的，要知道用重定向技术，怎么使用我也已经写的很明白了！
购物车显示页面listcart.jsp代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%><%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>购物车列表</title><script type="text/javascript"> function deleteitem(id) { var b = window.confirm("您确认删除吗？"); if(b) { // window代表当前浏览器窗口，location代表当前浏览器窗口的地址栏
window.location.href = "${pageContext.request.contextPath }/DeleteItemServlet?id="+id;
}
} function clearCart() { var b = window.confirm("您确认清空吗？"); if(b) {
window.location.href = "${pageContext.request.contextPath }/ClearCartServlet"
}
} function changeQuantity(input, id, oldValue) { var quantity = input.value; // 得到要修改的数量 /*
// 检查用户输入的数量是不是一个数字
if(isNaN(quantity)) {
alert("请输入数字！！！");
// 得到输入项原来的值
input.value = oldValue;
return;
}
*/ // 检查用户输入的数量是不是一个正整数 if(quantity<0 || quantity!=parseInt(quantity)) { // 1.1 != 1 parseInt("abc")返回NaN
alert("请输入一个正整数！！！");
input.value = oldValue; return;
} var b = window.confirm("您确定把书的数量修改为"+quantity+"吗？") if(b) {
window.location.href = "${pageContext.request.contextPath }/ChangeQuantityServlet?id="+id+"&quantity="+quantity;
}
}</script></head><body style="text-align: center;"> <h1>购物车列表</h1> <c:if test="${empty(cart.map) }"> <!-- cart.map.empty：map为空，没东西 el表达式的函数：empty()——检测map是否为null或""，若是则返回true -->
您没有购买任何商品！！！ </c:if> <c:if test="${!empty(cart.map) }"> <table width="70%" border="1" align="center"> <tr> <td>书名</td> <td>作者</td> <td>单价</td> <td>数量</td> <td>小计</td> <td>操作</td> </tr> <c:forEach var="entry" items="${cart.map }"> <!-- entry<id, CartItem> --> <tr> <td>${entry.value.book.name }</td> <td>${entry.value.book.author }</td> <td>${entry.value.book.price }</td> <td> <!-- this代表input输入项 -->
<input type="text" name="quantity" value="${entry.value.quantity }" style="width: 35px" onchange="changeQuantity(this, ${entry.key }, ${entry.value.quantity })" /> </td> <td>${entry.value.price }</td> <td> <!-- javascript:void(0)：去掉超链接的默认行为 --> <a href="javascript:void(0)" onclick="deleteitem(${entry.key })">删除</a> </td> </tr> </c:forEach> <tr> <td colspan="3">总价</td> <td colspan="2">${cart.price }元</td> <td colspan="1"> <a href="javascript:void(0)" onclick="clearCart()">清空购物车</a> </td> </tr> </table> </c:if></body></html>123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293至此，用户购买书籍的功能就算是开发完成了！下面测试一下开发好的该功能：
开发删除购物车中购物项的功能
编写实现如下业务服务的BusinessService类。
删除购物车中购物项
此时BusinessService类的具体代码如下：
// 业务类，统一对web层提供所有服务public class BusinessService { private BookDao dao = new BookDao(); public Map<String, Book> getAllBook() { return dao.getAll();
} public Book findBook(String id) { return dao.find(id);
} // 删除购物车中购物项 public void deleteCartItem(String id, Cart cart) {
cart.getMap().remove(id);
}
}12345678910111213141516171819在cn.itcast.web.controller下创建一个DeleteItemServlet类。 
DeleteItemServlet类的具体代码如下：
public class DeleteItemServlet extends HttpServlet { protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String id = request.getParameter("id");
Cart cart = (Cart) request.getSession().getAttribute("cart");
BusinessService service = new BusinessService();
service.deleteCartItem(id, cart); // 删除成功，还是跳转到listcart.jsp页面
request.getRequestDispatcher("/WEB-INF/jsp/listcart.jsp").forward(request, response);
} protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}123456789101112131415161718192021注意：我上面的代码使用的是请求转发，这依然是不行的，读者要注意了啊！仍然要使用请求重定向，考虑到这毕竟不是一个真实项目，所以尽量不要搞得那么复杂，一切从简。
在购物车显示页面listcart.jsp中还要写入以下JavaScript代码：
<script type="text/javascript"> function deleteitem(id) { var b = window.confirm("您确认删除吗？"); if(b) { // window代表当前浏览器窗口，location代表当前浏览器窗口的地址栏
window.location.href = "${pageContext.request.contextPath }/DeleteItemServlet?id="+id;
}
}</script>123456789不然的话，用户手贱，不小心删除了所选的购物项，辛辛苦苦购买的商品又要重新购买，用户的感受肯定巨不爽，所以在用户不小心删除了所选的购物项时，还要问用户是否确认删除。只有用户点击确认按钮才会删除，这样对用户来说，体验会更好。
至此，删除购物车中购物项的功能就算是开发完成了！下面测试一下开发好的该功能：
开发清空购物车的功能
编写实现如下业务服务的BusinessService类。
清空购物车
编写对应的清空购物车的方法时，由于代表用户购物车的Cart类存在session中，是不是可以像下面这样写呢？
public void clearCart(HttpSession session) { ... }123答：不可以。业务逻辑层用到Web层对象——session，业务逻辑层和Web层牢牢绑定在一起了，业务逻辑层离开Web层就跑不起来了，如果这样写，若要对业务层进行测试，需要把Web服务器起起来，传一个session进去，所以在各层之间传递的只能是JavaBean，不能让Web层的特殊对象侵入到业务逻辑层，污染业务逻辑层。
此时BusinessService类的具体代码如下：
// 业务类，统一对web层提供所有服务public class BusinessService { private BookDao dao = new BookDao(); public Map<String, Book> getAllBook() { return dao.getAll();
} public Book findBook(String id) { return dao.find(id);
} // 删除购物车中购物项 public void deleteCartItem(String id, Cart cart) {
cart.getMap().remove(id);
} // 清空购物车 public void clearCart(Cart cart) {
cart.getMap().clear();
}
}123456789101112131415161718192021222324在cn.itcast.web.controller包下创建一个ClearCartServlet类。 
ClearCartServlet类的具体代码如下：
public class ClearCartServlet extends HttpServlet { protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
Cart cart = (Cart) request.getSession().getAttribute("cart");
BusinessService service = new BusinessService();
service.clearCart(cart);
request.getRequestDispatcher("/WEB-INF/jsp/listcart.jsp").forward(request, response);
} protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}12345678910111213141516171819注意：我上面的代码使用的是请求转发，这依然是不行的，读者要注意了啊！仍然要使用请求重定向，考虑到这毕竟不是一个真实项目，所以尽量不要搞得那么复杂，一切从简。
在购物车显示页面listcart.jsp中还要写入以下JavaScript代码：
<script type="text/javascript"> function clearCart() { var b = window.confirm("您确认清空吗？"); if(b) {
window.location.href = "${pageContext.request.contextPath }/ClearCartServlet";
}
}</script>12345678不然的话，用户手贱，不小心清空了购物车，辛辛苦苦购买的商品又要重新购买，用户的感受肯定巨不爽，所以在用户不小心清空了购物车时，还要问用户是否确认清空。只有用户点击确认按钮才会清空，这样对用户来说，体验会更好。
还有一点要注意：如果用户清空了购物车，那么购物车显示页面不能没有任何显示，这也是对用户体验的一种折磨，明智的做法应该是给用户显示您没有购买任何商品！！！，这样用户体验会更好。那怎样判断用户有没有购买商品呢？——可使用el表达式的函数：empty(object)，检测object对象是否为null或”“，若是则返回true。这样购物车显示页面listcart.jsp页面中的关键代码如下：
<h1>购物车列表</h1><c:if test="${empty(cart.map) }"> <!-- cart.map.empty：map为空，没东西 el表达式的函数：empty()——检测map是否为null或""，若是则返回true -->
您没有购买任何商品！！！</c:if><c:if test="${!empty(cart.map) }">
...</c:if>12345678至此，清空购物车的功能就算是开发完成了！下面测试一下开发好的该功能：
开发改变购物车某购物项数量的功能
在现实中的购物中，当用户购买一件商品时，发现还需要购买这件商品，比如数量为100，用户不可能点击这件商品100次，若是这样，那这样的购物网站倒闭1万亿遍了。所以一般来说用户只需要改变其数量即可，这时就需要用到<input>控件，而且用户要输入的数量要是一个正整数，不能是其他乱七八糟的东西。
编写实现如下业务服务的BusinessService类。
改变购物车某购物项的数量
此时BusinessService类的具体代码如下：
// 业务类，统一对web层提供所有服务public class BusinessService { private BookDao dao = new BookDao(); public Map<String, Book> getAllBook() { return dao.getAll();
} public Book findBook(String id) { return dao.find(id);
} // 删除购物车中购物项 public void deleteCartItem(String id, Cart cart) {
cart.getMap().remove(id);
} // 清空购物车 public void clearCart(Cart cart) {
cart.getMap().clear();
} // 改变购物车某购物项的数量 public void changeItemQuantity(String id, String quantity, Cart cart) {
CartItem item = cart.getMap().get(id);
item.setQuantity(Integer.parseInt(quantity));
}
}123456789101112131415161718192021222324252627282930在cn.itcast.web.controller中创建ChangeQuantityServlet类。 
ChangeQuantityServlet类的具体代码如下：
// 把购物车中的书修改为指定数量public class ChangeQuantityServlet extends HttpServlet { protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String id = request.getParameter("id");
String quantity = request.getParameter("quantity");
Cart cart = (Cart) request.getSession().getAttribute("cart");
BusinessService service = new BusinessService();
service.changeItemQuantity(id, quantity, cart);
request.getRequestDispatcher("/WEB-INF/jsp/listcart.jsp").forward(request, response);
} protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}1234567891011121314151617181920212223注意：我上面的代码使用的是请求转发，这依然是不行的，读者要注意了啊！仍然要使用请求重定向，考虑到这毕竟不是一个真实项目，所以尽量不要搞得那么复杂，一切从简。
在购物车显示页面listcart.jsp中还要写入以下JavaScript代码：
<script type="text/javascript"> function changeQuantity(input, id, oldValue) { var quantity = input.value; // 得到要修改的数量 // 检查用户输入的数量是不是一个正整数 if(quantity<0 || quantity!=parseInt(quantity)) { // 1.1 != 1 parseInt("abc")返回NaN
alert("请输入一个正整数！！！");
input.value = oldValue; return;
} var b = window.confirm("您确定把书的数量修改为"+quantity+"吗？") if(b) {
window.location.href = "${pageContext.request.contextPath }/ChangeQuantityServlet?id="+id+"&quantity="+quantity;
}
}</script>1234567891011121314151617完整的购物车显示页面listcart.jsp代码前面已经给出了，这里不再赘写。
至此，改变购物车某购物项数量的功能就算是开发完成了！下面测试一下开发好的该功能：
Das obige ist der detaillierte Inhalt vonDer Warenkorb wurde basierend auf dem Servlet+JSP+JavaBean-Modell entwickelt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!