浅谈实现基于Javabean与JSP的购物车功能

首先呢，在买了东西之后要放在购物车里，当车子里的物品有相同时就叠加，不再创建物品对象，有了物品之后肯 定要有价格，数量等等对象。这些对象我们要封装在JAVABEAN 中的！有了Javabean就需要建立SERVLET来进行与业务层连接，我们就需要有，增加购物车，删除购物车，清楚购物车等一系列的Servlet和SERVICE层连接！SERVICE层调用DAO层，这些步骤正体现出了MVC的设计模式！下面我们看具体的实现基于Javabean与JSP的购物车功能吧！

(1) 1. 代表购物车的ShoppingCart 类

 
 
 
    
  
  
  
  1. public class ShoppingCart {  
    2. 
  
  
  
  2.  //装载 ShoppingCartItem 的数据结构: Map, 键： 书的 id, 值: 书对应的 ShoppingCartItem  
    3. 
  
  
  
  3.  private Map, ShoppingCartItem> books = null;  
    4. 
  
  
  
  4.    
    5. 
  
  
  
  5.  public ShoppingCart(){  
    6. 
  
  
  
  6.   books = new HashMap, ShoppingCartItem>();  
    7. 
  
  
  
  7.  }   
    8. 
  
  
  
  8.  
    9. 
  
  
  
  9.  public Map, ShoppingCartItem> getBooks() {  
    10. 
  
  
  
  10.   return books;  
    11. 
  
  
  
  11.  }  
    12. 
  
  
  
  12.    
    13. 
  
  
  
  13.  public Book getBook(String bookId){  
    14. 
  
  
  
  14.   Book book = null;  
    15. 
  
  
  
  15.     
    16. 
  
  
  
  16.   ShoppingCartItem sci = this.books.get(bookId);  
    17. 
  
  
  
  17.   if (sci == null)  
    18. 
  
  
  
  18.    return null;  
    19. 
  
  
  
  19.     
    20. 
  
  
  
  20.   return sci.getBook ();  
    21. 
  
  
  
  21.  }  
    22. 
  
  
  
  22.    
    23. 
  
  
  
  23.  public float getTotalPrice(){  
    24. 
  
  
  
  24.   float totalPrice = 0.0f;  
    25. 
  
  
  
  25.     
    26. 
  
  
  
  26.   //对 books 中的 value 进行遍历, 取其 price 属性的和   
    27. 
  
  
  
  27.   Iterator iterator = books.values().iterator ();  
    28. 
  
  
  
  28.   while(iterator.hasNext()){  
    29. 
  
  
  
  29.    ShoppingCartItem sci = iterator.next();  
    30. 
  
  
  
  30.    totalPrice += sci.getPrice();  
    31. 
  
  
  
  31.   }   
    32. 
  
  
  
  32.     
    33. 
  
  
  
  33.   return totalPrice;  
    34. 
  
  
  
  34.  }  
    35. 
  
  
  
  35.    
    36. 
  
  
  
  36.  public int getTotalQuantity(){  
    37. 
  
  
  
  37.   int quantity = 0;  
    38. 
  
  
  
  38.     
    39. 
  
  
  
  39.   //对 books 中的 value 进行遍历, 取其 quantity 属性的和  
    40. 
  
  
  
  40.   Iterator iterator = books.values().iterator();  
    41. 
  
  
  
  41.   while(iterator.hasNext()) {  
    42. 
  
  
  
  42.    ShoppingCartItem sci = iterator.next();  
    43. 
  
  
  
  43.    quantity += sci.getQuantity();  
    44. 
  
  
  
  44.   }  
    45. 
  
  
  
  45.     
    46. 
  
  
  
  46.   return quantity;  
    47. 
  
  
  
  47.  }   
    48. 
  
  
  
  48.    
    49. 
  
  
  
  49.  public boolean isExistInShoppingCart(String bookId){  
    50. 
  
  
  
  50.   return this.books.get(bookId) != null;  
    51. 
  
  
  
  51.  }  
    52. 
  
  
  
  52.    
    53. 
  
  
  
  53.  public ShoppingCartItem getShoppingCartItemByBookId(String bookId){  
    54. 
  
  
  
  54.   return this.books.get(bookId);  
    55. 
  
  
  
  55.  }   
    56. 
  
  
  
  56.    
    57. 
  
  
  
  57.  public void addNewItemToShoppingCart(ShoppingCartItem sci) {  
    58. 
  
  
  
  58.   this.books.put(sci.getBook().getId(), sci);  
    59. 
  
  
  
  59.  }  
    60. 
  
  
  
  60. } 
    61.

2. 代表购物车中的物品

 
 
 
    
  
  
  
  1. public class ShoppingCartItem {  
    2. 
  
  
  
  2.  //具体指向某本书  
    3. 
  
  
  
  3.  private Book book;  
    4. 
  
  
  
  4.    
    5. 
  
  
  
  5.  //当前商品在购物车中的数量  
    6. 
  
  
  
  6.  private int quantity;  
    7. 
  
  
  
  7.    
    8. 
  
  
  
  8.  public ShoppingCartItem(Book book) {  
    9. 
  
  
  
  9.   this.book = book;  
    10. 
  
  
  
  10.   this.quantity = 1;  
    11. 
  
  
  
  11.  }  
    12. 
  
  
  
  12.  
    13. 
  
  
  
  13.  //当前商品的总价格  
    14. 
  
  
  
  14.  private float price;  
    15. 
  
  
  
  15.    
    16. 
  
  
  
  16.  public void incrementQuantity(){  
    17. 
  
  
  
  17.   this.quantity++;  
    18. 
  
  
  
  18.  }  
    19. 
  
  
  
  19.  
    20. 
  
  
  
  20.  public Book getBook() {  
    21. 
  
  
  
  21.   return book;  
    22. 
  
  
  
  22.  }  
    23. 
  
  
  
  23.  
    24. 
  
  
  
  24.  public void setBook(Book book) {  
    25. 
  
  
  
  25.   this.book = book;  
    26. 
  
  
  
  26.  }  
    27. 
  
  
  
  27.  
    28. 
  
  
  
  28.  public int getQuantity() {  
    29. 
  
  
  
  29.   return quantity;  
    30. 
  
  
  
  30.  }  
    31. 
  
  
  
  31.  
    32. 
  
  
  
  32.  public void setQuantity(int quantity) {  
    33. 
  
  
  
  33.   this.quantity = quantity;  
    34. 
  
  
  
  34.  }   
    35. 
  
  
  
  35.  
    36. 
  
  
  
  36.  public float getPrice() {  
    37. 
  
  
  
  37.   return this.book.getPrice() * this.quantity;  
    38. 
  
  
  
  38.  }  
    39. 
  
  
  
  39.  
    40. 
  
  
  
  40. } 
    41.

(2)建立DAO,此时有人会问，这次DAO为什么没有购物车呢，因为购物车是没有数据的，而是里面的物品才有 数据的，当有更新购物车里面的物品时才会早DAO里面写方法！

 
 
 
    
  
  
  
  1. public class BookDAO {  
    2. 
  
  
  
  2.    
    3. 
  
  
  
  3.  //  
    4. 
  
  
  
  4.  public void upadateBookQuantityByBookId(Connection conn, String bookId, int quantity){  
    5. 
  
  
  
  5.   String sql = "UPDATE books SET saleAmount = saleAmount + ? WHERE id = ?";  
    6. 
  
  
  
  6.   Object [] params = new Object[]{quantity, bookId};  
    7. 
  
  
  
  7.     
    8. 
  
  
  
  8.   QueryRunner queryRunner = new QueryRunner ();  
    9. 
  
  
  
  9.     
    10. 
  
  
  
  10.   try {  
    11. 
  
  
  
  11.    queryRunner.update(conn, sql, params);  
    12. 
  
  
  
  12.   } catch (SQLException e) {  
    13. 
  
  
  
  13.    // TODO Auto-generated catch block  
    14. 
  
  
  
  14.    e.printStackTrace();  
    15. 
  
  
  
  15.    throw new RuntimeException (MyBookStoreConstants.UPDATE_BOOK_SALEAMOUNT_BY_BOOK_ID_EXCEPTION);  
    16. 
  
  
  
  16.   }  
    17. 
  
  
  
  17.  } 
    18.

(3) 建立业务层,涉及到添加，清空等方法！这边佟刚老师的代码都有详细的解释！

 
 
 
    
  
  
  
  1. public class BookService {  
    2. 
  
  
  
  2.  //根据给定的 ShoppingCart 对象, 调用 DAO 方法进行数据库更新操作  
    3. 
  
  
  
  3.  public void buyBooks(ShoppingCart sc){  
    4. 
  
  
  
  4.   //对 sc 中的 ShoppingCartItem 对象进行遍历, 调用 BookDAO.upadateBookQuantityByBookId 方法  
    5. 
  
  
  
  5.   Connection conn = null;  
    6. 
  
  
  
  6.   conn = DBHelper.getConnection();  
    7. 
  
  
  
  7.     
    8. 
  
  
  
  8.   try {  
    9. 
  
  
  
  9.    Iterator shoppingCartItemSet = sc.getBooks().values ().iterator();  
    10. 
  
  
  
  10.    BookDAO bookDAO = new BookDAO ();  
    11. 
  
  
  
  11.      
    12. 
  
  
  
  12.    while(shoppingCartItemSet.hasNext()) {  
    13. 
  
  
  
  13.     ShoppingCartItem sci = shoppingCartItemSet.next ();  
    14. 
  
  
  
  14.       
    15. 
  
  
  
  15.     String bookId = sci.getBook().getId ();  
    16. 
  
  
  
  16.     int quantity = sci.getQuantity ();  
    17. 
  
  
  
  17.       
    18. 
  
  
  
  18.     bookDAO.upadateBookQuantityByBookId(conn, bookId, quantity);  
    19. 
  
  
  
  19.    }  
    20. 
  
  
  
  20.   }finally {  
    21. 
  
  
  
  21.    DBHelper.releaseDBSource(null, null, conn);  
    22. 
  
  
  
  22.   }   
    23. 
  
  
  
  23.     
    24. 
  
  
  
  24.     
    25. 
  
  
  
  25.  }  
    26. 
  
  
  
  26.    
    27. 
  
  
  
  27.  //参数 items 中的键为 书的 id 号, 值为购 物车中对应的 数量  
    28. 
  
  
  
  28.  public void updateShoppingCart(Map,Integer> items, ShoppingCart sc){  
    29. 
  
  
  
  29.   Set keySet = null;  
    30. 
  
  
  
  30.   keySet = items.keySet ();  
    31. 
  
  
  
  31.     
    32. 
  
  
  
  32.   for(Iterator it = keySet.iterator(); it.hasNext(); ) {  
    33. 
  
  
  
  33.    String bookId = it.next();  
    34. 
  
  
  
  34.    int quantity = items.get (bookId);  
    35. 
  
  
  
  35.      
    36. 
  
  
  
  36.    if(quantity <= 0) {  
    37. 
  
  
  
  37.     sc.getBooks().remove(bookId);  
    38. 
  
  
  
  38.    }else {  
    39. 
  
  
  
  39.     sc.getShoppingCartItemByBookId(bookId).setQuantity (quantity);  
    40. 
  
  
  
  40.    }  
    41. 
  
  
  
  41.       
    42. 
  
  
  
  42.   }  
    43. 
  
  
  
  43.  }   
    44. 
  
  
  
  44.    
    45. 
  
  
  
  45.  //清空购物车  
    46. 
  
  
  
  46.  public void clearShoppingCart(ShoppingCart sc) {  
    47. 
  
  
  
  47.   sc.getBooks().clear();  
    48. 
  
  
  
  48.  }  
    49. 
  
  
  
  49.    
    50. 
  
  
  
  50.  public void deleteShoppingCartItemById(String id, ShoppingCart sc){  
    51. 
  
  
  
  51.   //删除 sc 中的 id 元素   
    52. 
  
  
  
  52.   sc.getBooks().remove(id);  
    53. 
  
  
  
  53.  }  
    54. 
  
  
  
  54.    
    55. 
  
  
  
  55.  //把 id 对应的 ShoppingCartItem 对象放入购物车 ShoppingCart 对象中  
    56. 
  
  
  
  56.  public void addToShoppingCart(String id, ShoppingCart sc) {  
    57. 
  
  
  
  57.     
    58. 
  
  
  
  58.   //1. 查看 sc 中有没有 id 对应的 ShoppingCartItem 对象   
    59. 
  
  
  
  59.   if(sc.isExistInShoppingCart(id)){  
    60. 
  
  
  
  60.    //1.1 有: 把该对象取出, 使其数量 + 1, 调用 sci.increseQuantity(); 方法  
    61. 
  
  
  
  61.    ShoppingCartItem scsci = sc.getShoppingCartItemByBookId(id);  
    62. 
  
  
  
  62.    sci.incrementQuantity();  
    63. 
  
  
  
  63.   }   
    64. 
  
  
  
  64.   //1.2 没有: 创建一个新的 ShoppingCartItem 对象, 并将其放入 sc 中, 以书的 id 作为键   
    65. 
  
  
  
  65.   else{  
    66. 
  
  
  
  66.    //1.2.1 根据 id 获取相应的 Book 对象, 调用 BookDAO 的 selectBookByBookId() 方法  
    67. 
  
  
  
  67.    Book book = null;  
    68. 
  
  
  
  68.    BookDAO bookDAO = null;  
    69. 
  
  
  
  69.      
    70. 
  
  
  
  70.    bookDAO = new BookDAO();  
    71. 
  
  
  
  71.    book = bookDAO.selectBookByBookId(id);  
    72. 
  
  
  
  72.      
    73. 
  
  
  
  73.    ShoppingCartItem sci = null;  
    74. 
  
  
  
  74.    sci = new ShoppingCartItem (book);  
    75. 
  
  
  
  75.      
    76. 
  
  
  
  76.    sc.addNewItemToShoppingCart(sci);  
    77. 
  
  
  
  77.   }   
    78. 
  
  
  
  78.  }  
    79. 
  
  
  
  79. } 
    80.

(4)这段是 检查购物车是有对象的，这里单独拿出来是可以很好的在WEB开发中很好的进行重用 的。

 
 
 
    
  
  
  
  1. public class MyBookStoreUtils {  
    2. 
  
  
  
  2.  private MyBookStoreUtils(){}  
    3. 
  
  
  
  3.    
    4. 
  
  
  
  4.  public static  ShoppingCart getShppingCartForCreateOrExist(HttpServletRequest request) {  
    5. 
  
  
  
  5.   ShoppingCart sc = null;  
    6. 
  
  
  
  6.   //2.1 检查在 HttpSession 对象中有没有购物车对象 , 即检查 session 中是否有 MyBookStoreConstants.SHOOPING_CART_KEY 属性  
    7. 
  
  
  
  7.   //   若 已经存在, 说明购物车存在, 直接取出  
    8. 
  
  
  
  8.   HttpSession session = null;  
    9. 
  
  
  
  9.   session = request.getSession();  
    10. 
  
  
  
  10.     
    11. 
  
  
  
  11.   Object obj = session.getAttribute (MyBookStoreConstants.SHOOPING_CART_KEY);  
    12. 
  
  
  
  12.     
    13. 
  
  
  
  13.   if(obj != null) {  
    14. 
  
  
  
  14.    sc = (ShoppingCart) obj;  
    15. 
  
  
  
  15.   }  
    16. 
  
  
  
  16.   //2.2 若不存在 MyBookStoreConstants.SHOOPING_CART_KEY 属性, 创建一个购物车对象, 并把该对象放入 Session 中   
    17. 
  
  
  
  17.   else{  
    18. 
  
  
  
  18.    sc = new ShoppingCart ();  
    19. 
  
  
  
  19.    session.setAttribute(MyBookStoreConstants.SHOOPING_CART_KEY, sc);  
    20. 
  
  
  
  20.   }  
    21. 
  
  
  
  21.     
    22. 
  
  
  
  22.   return sc;  
    23. 
  
  
  
  23.  }  
    24. 
  
  
  
  24.    
    25. 
  
  
  
  25.  public static  ShoppingCart getShppingCartForExist(HttpServletRequest request) {  
    26. 
  
  
  
  26.   ShoppingCart sc = null;  
    27. 
  
  
  
  27.   //2.1 检查在 HttpSession 对象中有没有购物车对象 , 即检查 session 中是否有 MyBookStoreConstants.SHOOPING_CART_KEY 属性  
    28. 
  
  
  
  28.   //   若 已经存在, 说明购物车存在, 直接取出  
    29. 
  
  
  
  29.   HttpSession session = null;  
    30. 
  
  
  
  30.   session = request.getSession();  
    31. 
  
  
  
  31.     
    32. 
  
  
  
  32.   Object obj = session.getAttribute (MyBookStoreConstants.SHOOPING_CART_KEY);  
    33. 
  
  
  
  33.     
    34. 
  
  
  
  34.   if(obj != null) {  
    35. 
  
  
  
  35.    sc = (ShoppingCart) obj;  
    36. 
  
  
  
  36.   }  
    37. 
  
  
  
  37.   //2.2 若不存在 MyBookStoreConstants.SHOOPING_CART_KEY 属性, 抛出异常, 提示用户还不存在购物车.  
    38. 
  
  
  
  38.   else {  
    39. 
  
  
  
  39.    throw new RuntimeException (MyBookStoreConstants.NO_SHOPPING_CART_EXCETPION);  
    40. 
  
  
  
  40.   }   
    41. 
  
  
  
  41.     
    42. 
  
  
  
  42.   return sc;  
    43. 
  
  
  
  43.  }  
    44. 
  
  
  
  44. } 
    45.

(5)这里是所有与购物车相关的SERVLET.

这个是更新数据的，需要在SERVICE中调用DAO的!

 
 
 
    
  
  
  
  1. public class UpdateShoppingCartServlet extends HttpServlet {  
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.  public void doPost(HttpServletRequest request, HttpServletResponse response)   
    4. 
  
  
  
  4.    throws ServletException, IOException {  
    5. 
  
  
  
  5.   //获取表单信息   
    6. 
  
  
  
  6.   // request.getParameter(""); 方法行不通,　因为表单的　name 是随时变化的   
    7. 
  
  
  
  7.     
    8. 
  
  
  
  8.   //获取表单中的所有 name  
    9. 
  
  
  
  9.   Enumeration nameEnums = request.getParameterNames();  
    10. 
  
  
  
  10.     
    11. 
  
  
  
  11.   Map items = new HashMap, Integer>();  
    12. 
  
  
  
  12.   //遍历 nameEnums, 再取出对应的 Value, 封装到 items 中   
    13. 
  
  
  
  13.     
    14. 
  
  
  
  14.   try {  
    15. 
  
  
  
  15.    while(nameEnums.hasMoreElements()) {  
    16. 
  
  
  
  16.     String bookId = nameEnums.nextElement();  
    17. 
  
  
  
  17.     String quantity = request.getParameter (bookId);  
    18. 
  
  
  
  18.       
    19. 
  
  
  
  19.     items.put(bookId, Integer.parseInt (quantity));  
    20. 
  
  
  
  20.    }  
    21. 
  
  
  
  21.   } catch (NumberFormatException e) {  
    22. 
  
  
  
  22.    // TODO Auto-generated catch block  
    23. 
  
  
  
  23.    e.printStackTrace ();  
    24. 
  
  
  
  24.    throw new RuntimeException (MyBookStoreConstants.QUANTITY_FORMAT_EXCEPTION);  
    25. 
  
  
  
  25.   }  
    26. 
  
  
  
  26.     
    27. 
  
  
  
  27.   //获 取购物车对象  
    28. 
  
  
  
  28.   ShoppingCart sc = null;  
    29. 
  
  
  
  29.   sc = MyBookStoreUtils.getShppingCartForExist(request);  
    30. 
  
  
  
  30.     
    31. 
  
  
  
  31.   //调用 Service 方法   
    32. 
  
  
  
  32.   BookService bookService = new BookService ();  
    33. 
  
  
  
  33.   bookService.updateShoppingCart(items, sc);  
    34. 
  
  
  
  34.     
    35. 
  
  
  
  35.   //派发页面 : showShoppingCart.jsp 页面  
    36. 
  
  
  
  36.   String forwardPage = "/WEB- INF/jsp/showShoppingCart.jsp";  
    37. 
  
  
  
  37.   request.getRequestDispatcher(forwardPage).forward (request, response);  
    38. 
  
  
  
  38.  }  
    39. 
  
  
  
  39.  
    40. 
  
  
  
  40. }  
    41. 
  
  
  
  41.  
    42. 
  
  
  
  42. public class ShowShoppingCartServlet extends HttpServlet {  
    43. 
  
  
  
  43.  
    44. 
  
  
  
  44.  public void doGet(HttpServletRequest request, HttpServletResponse response)   
    45. 
  
  
  
  45.    throws ServletException, IOException {  
    46. 
  
  
  
  46.   //做一个转发   
    47. 
  
  
  
  47.   String forwardPage = null;  
    48. 
  
  
  
  48.     
    49. 
  
  
  
  49.   forwardPage = "/WEB- INF/jsp/showShoppingCart.jsp";  
    50. 
  
  
  
  50.     
    51. 
  
  
  
  51.   RequestDispatcher dispatcher = null;  
    52. 
  
  
  
  52.   dispatcher = request.getRequestDispatcher (forwardPage);  
    53. 
  
  
  
  53.   dispatcher.forward(request, response);  
    54. 
  
  
  
  54.  }  
    55. 
  
  
  
  55.  
    56. 
  
  
  
  56. }  
    57. 
  
  
  
  57. public class ReceiptServlet extends HttpServlet {  
    58. 
  
  
  
  58.  
    59. 
  
  
  
  59.  public void doPost(HttpServletRequest request, HttpServletResponse response)   
    60. 
  
  
  
  60.    throws ServletException, IOException {  
    61. 
  
  
  
  61.   //1. 获取表单信息: name 和 cardId  
    62. 
  
  
  
  62.     
    63. 
  
  
  
  63.   //2. 调用 Service 方法, 更新 books 表各条 book 的 saleAmount 字段   
    64. 
  
  
  
  64.     
    65. 
  
  
  
  65.   //2.1 获取购物车  
    66. 
  
  
  
  66.   ShoppingCart sc = MyBookStoreUtils.getShppingCartForExist(request);  
    67. 
  
  
  
  67.     
    68. 
  
  
  
  68.   BookService bookService = new BookService();  
    69. 
  
  
  
  69.   bookService.buyBooks (sc);  
    70. 
  
  
  
  70.     
    71. 
  
  
  
  71.   //2.1 使 Session 失效  
    72. 
  
  
  
  72.   HttpSession session = null;  
    73. 
  
  
  
  73.   session = request.getSession();  
    74. 
  
  
  
  74.   session.invalidate ();  
    75. 
  
  
  
  75.     
    76. 
  
  
  
  76.   //3. 派发页面: receipt.jsp 页面   
    77. 
  
  
  
  77.   request.getRequestDispatcher("/WEB-INF/jsp/receipt.jsp").forward(request, response);   
    78. 
  
  
  
  78.  }  
    79. 
  
  
  
  79. } 
    80.

这段我先开始很纳闷老师为什么会这样写呢，其实很简单，写个专门的转发的SERVLET这样，在每次转发的时候就只连接一个servlet比连接多个更来的简洁！提高了效率！

 
 
 
    
  
  
  
  1. public class ForwardServlet extends HttpServlet {  
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.  public void doGet(HttpServletRequest request, HttpServletResponse response)   
    4. 
  
  
  
  4.    throws ServletException, IOException {  
    5. 
  
  
  
  5.   //1. 获取 path  
    6. 
  
  
  
  6.   String path = request.getParameter("path");  
    7. 
  
  
  
  7.     
    8. 
  
  
  
  8.   //2. 派 发页面  
    9. 
  
  
  
  9.   request.getRequestDispatcher(path).forward(request, response);  
    10. 
  
  
  
  10.  }  
    11. 
  
  
  
  11.  
    12. 
  
  
  
  12. }  
    13. 
  
  
  
  13. public class DeleteShoppingCartItemServlet extends HttpServlet {  
    14. 
  
  
  
  14.  
    15. 
  
  
  
  15.  public void doGet(HttpServletRequest request, HttpServletResponse response)   
    16. 
  
  
  
  16.    throws ServletException, IOException {  
    17. 
  
  
  
  17.   //1. 获取 id 号   
    18. 
  
  
  
  18.   String id = request.getParameter("bookid");  
    19. 
  
  
  
  19.     
    20. 
  
  
  
  20.   //2. 调用 BookService 方法 deleteShoppingCartItemById：, 进行删除操作  
    21. 
  
  
  
  21.   ShoppingCart sc = MyBookStoreUtils.getShppingCartForExist(request);  
    22. 
  
  
  
  22.     
    23. 
  
  
  
  23.   String bookTitle = sc.getBook(id).getTitle();  
    24. 
  
  
  
  24.     
    25. 
  
  
  
  25.   BookService bookService = new BookService ();  
    26. 
  
  
  
  26.   bookService.deleteShoppingCartItemById(id, sc);  
    27. 
  
  
  
  27.     
    28. 
  
  
  
  28.   //3. 派发页面  
    29. 
  
  
  
  29.   request.setAttribute(MyBookStoreConstants.DELETE_FROM_SHOPPING_CART_BOOK_TITLE, bookTitle);  
    30. 
  
  
  
  30.     
    31. 
  
  
  
  31.   String forwardPage = "/WEB- INF/jsp/showShoppingCart.jsp";  
    32. 
  
  
  
  32.   //4. 判断购物车是否为空,　若为空则派发到　emptyCart.jsp 页面  
    33. 
  
  
  
  33.   if(sc.getBooks().isEmpty())  
    34. 
  
  
  
  34.    forwardPage = "/WEB- INF/jsp/emptyCart.jsp";  
    35. 
  
  
  
  35.     
    36. 
  
  
  
  36.   RequestDispatcher dispatcher = null;  
    37. 
  
  
  
  37.   dispatcher = request.getRequestDispatcher (forwardPage);  
    38. 
  
  
  
  38.   dispatcher.forward(request, response);  
    39. 
  
  
  
  39.  }  
    40. 
  
  
  
  40.  } 
    41.

这里是清空购物车的SERVLET.

 
 
 
    
  
  
  
  1. public class ClearShoppingCartServlet extends HttpServlet {  
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.  public void doGet(HttpServletRequest request, HttpServletResponse response)   
    4. 
  
  
  
  4.    throws ServletException, IOException {  
    5. 
  
  
  
  5.   //1. 调用方法   
    6. 
  
  
  
  6.   BookService bookService = new BookService ();  
    7. 
  
  
  
  7.     
    8. 
  
  
  
  8.   ShoppingCart sc = null;  
    9. 
  
  
  
  9.   sc = MyBookStoreUtils.getShppingCartForExist (request);  
    10. 
  
  
  
  10.     
    11. 
  
  
  
  11.   bookService.clearShoppingCart (sc);  
    12. 
  
  
  
  12.     
    13. 
  
  
  
  13.   //2. 派发页面  
    14. 
  
  
  
  14.   String forwardPage = null;  
    15. 
  
  
  
  15.   forwardPage = "/WEB- INF/jsp/emptyCart.jsp";  
    16. 
  
  
  
  16.     
    17. 
  
  
  
  17.   RequestDispatcher dispatcher = request.getRequestDispatcher(forwardPage);  
    18. 
  
  
  
  18.   dispatcher.forward(request, response);  
    19. 
  
  
  
  19.  }  
    20. 
  
  
  
  20.  
    21. 
  
  
  
  21. }  
    22. 
  
  
  
  22. public class AddToShoppingCartServlet extends HttpServlet {  
    23. 
  
  
  
  23.  
    24. 
  
  
  
  24.  public void doGet(HttpServletRequest request, HttpServletResponse response)   
    25. 
  
  
  
  25.    throws ServletException, IOException {  
    26. 
  
  
  
  26.     
    27. 
  
  
  
  27.     
    28. 
  
  
  
  28.   //1. 获取书的 id 号  
    29. 
  
  
  
  29.   String bookId = null;  
    30. 
  
  
  
  30.   bookId = request.getParameter("bookId");  
    31. 
  
  
  
  31.     
    32. 
  
  
  
  32.   //2. 获取 购物车对象: 调用 getShppingCart 方法  
    33. 
  
  
  
  33.   ShoppingCart sc = null;  
    34. 
  
  
  
  34.   sc = MyBookStoreUtils.getShppingCartForCreateOrExist(request);  
    35. 
  
  
  
  35.     
    36. 
  
  
  
  36.   //3. 调用 Service 方法把 id 对应的 ShoppingCartItem 对象放入购物车 ShoppingCart 对象中： addToShoppingCart(id, shoppingCart);  
    37. 
  
  
  
  37.   BookService bookService = null;  
    38. 
  
  
  
  38.   bookService = new BookService();  
    39. 
  
  
  
  39.     
    40. 
  
  
  
  40.   bookService.addToShoppingCart(bookId, sc);  
    41. 
  
  
  
  41.     
    42. 
  
  
  
  42.   //4. 派发页面  
    43. 
  
  
  
  43.   String forwardPage = "/index.jsp";  
    44. 
  
  
  
  44.     
    45. 
  
  
  
  45.   //4.1 获取书名  
    46. 
  
  
  
  46.   String bookTitle = null;  
    47. 
  
  
  
  47.   //bookTitle = sc.getBooks().get(bookId).getBook().getTitle ();  
    48. 
  
  
  
  48.   bookTitle = sc.getBook(bookId).getTitle();  
    49. 
  
  
  
  49.     
    50. 
  
  
  
  50.   //4.2 将书 名放入请求域中, 以让页面进行显示  
    51. 
  
  
  
  51.   request.setAttribute (MyBookStoreConstants.ADD_TO_SHOPPING_CART_BOOK_TITLE, bookTitle);  
    52. 
  
  
  
  52.     
    53. 
  
  
  
  53.   RequestDispatcher dispatcher = null;  
    54. 
  
  
  
  54.   dispatcher = request.getRequestDispatcher (forwardPage);  
    55. 
  
  
  
  55.   dispatcher.forward(request, response);  
    56. 
  
  
  
  56.  }  
    57. 
  
  
  
  57.  
    58. 
  
  
  
  58. } 
    59.

(6)下面是显示层，对应着其相应的SERVLET.下面的JSP页面运用到了我们前段时间学的JSTL，EL表示.
 'cashier.jsp'

 
 
 
    
  
  
  
  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"% > 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. > 
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5.    
    6. 
  
  
  
  6.     </strong>My JSP 'cashier.jsp' starting page<strong> 
    7. 
  
  
  
  7.    
    8. 
  
  
  
  8.    
    9. 
  
  
  
  9.    
    10. 
  
  
  
  10.     
     
    11. 
  
  
  
  11.      

     
    12. 
  
  
  
  12.      您一共购买 了 ${sessionScope.shoppingcartkey.totalQuantity} 本书  
    13. 
  
  
  
  13.      

     
    14. 
  
  
  
  14.      您应付金额 是:${sessionScope.shoppingcartkey.totalPrice} 元。  
    15. 
  
  
  
  15.      

     
    16. 
  
  
  
  16.       action="receiptServlet" method="POST"> 
    17. 
  
  
  
  17.        
  18.        
    19.  
  19.         
    20.  
  20.         
    21.  
  21.        
    22.  
  22.        
    23.  
  23.         
    24.  
  24.         
    25.           
  25.        
    26.  
  26.         align="center"> 
  27.          colspan="2"> 
  28.           type="submit" value="递交 "/> 
  29.          
  30.         
  31.       
    32. 
  
  
  
    
  
  
  信用卡用户 名:
  
  
   type="text" name="userName"/>
  
  
  
    
  
  
  
    
  
  
  信用卡帐号:
  
  
   type="text" name="cardId"/>
  
  
  
    
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
     
    32. 
  
  
  
  32.       
    33. 
  
  
  
  33.      
    34. 
  
  
  
  34.    
    35. 
  
  
  
  35.  
    36. 
  
  
  
  36.  'receipt.jsp'  
    37. 
  
  
  
  37. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> 
    38. 
  
  
  
  38.  
    39. 
  
  
  
  39. > 
    40. 
  
  
  
  40.  
    41. 
  
  
  
  41.    
    42. 
  
  
  
  42.     </strong>My JSP 'emptyCart.jsp' starting page<strong> 
    43. 
  
  
  
  43.    
    44. 
  
  
  
  44.    
    45. 
  
  
  
  45.    
    46. 
  
  
  
  46.     
     
    47. 
  
  
  
  47.      

     
    48. 
  
  
  
  48.      您的购物车 为空

     
    49. 
  
  
  
  49.       href="${pageContext.request.contextPath }/index.jsp">继续购物 
    50. 
  
  
  
  50.      
    51. 
  
  
  
  51.    
    52. 
  
  
  
  52.  
    53. 
  
  
  
  53. <%@ page language="java" import="java.util.*" pageEncoding="UTF- 8"%> 
    54. 
  
  
  
  54.  
    55. 
  
  
  
  55. > 
    56. 
  
  
  
  56.  
    57. 
  
  
  
  57.    
    58. 
  
  
  
  58.     </strong>My JSP 'receipt.jsp' starting page<strong> 
    59. 
  
  
  
  59.    
    60. 
  
  
  
  60.    
    61. 
  
  
  
  61.    
    62. 
  
  
  
  62.     再见: ${param.userName }

     
    63. 
  
  
  
  63.     href="${pageContext.request.contextPath }/index.jsp">继续购物    
    64. 
  
  
  
  64.    
    65. 
  
  
  
  65.  
    66. 
  
  
  
  66.  
    67. 
  
  
  
  67. 'showShoppingCart.jsp'  
    68. 
  
  
  
  68. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"% > 
    69. 
  
  
  
  69. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> 
    70. 
  
  
  
  70.  
    71. 
  
  
  
  71. > 
    72. 
  
  
  
  72.  
    73. 
  
  
  
  73.    
    74. 
  
  
  
  74.     </strong>My JSP 'showShoppingCart.jsp' starting page<strong> 
    75. 
  
  
  
  75.    
    76. 
  
  
  
  76.    
    77. 
  
  
  
  77.    
    78. 
  
  
  
  78.     
     
    79. 
  
  
  
  79.       test="${requestScope.deleteToShoppingCartBookTitle != null}"> 
    80. 
  
  
  
  80.       

     
    81. 
  
  
  
  81.        您已经把 ${requestScope.deleteToShoppingCartBookTitle} 从购物车中删除了！  
    82. 
  
  
  
  82.       
    83. 
  
  
  
  83.      

     
    84. 
  
  
  
  84.        您的购物车中一共有 ${sessionScope.shoppingcartkey.totalQuantity} 本书  
    85. 
  
  
  
  85.      

     
    86. 
  
  
  
  86.       action="updateShoppingCartServlet" method="POST"> 
    87. 
  
  
  
  87.        cellpadding="10" cellspacing="0"> 
    88. 
  
  
  
  88.         
    89. 
  
  
  
  89.         书名 
    90. 
  
  
  
  90.         价 格 
    91. 
  
  
  
  91.         数量  
    92. 
  
  
  
  92.          
    93. 
  
  
  
  93.         
    94. 
  
  
  
  94.         items="${sessionScope.shoppingcartkey.books}"&n            
    
                当前题目：浅谈实现基于Javabean与JSP的购物车功能
                
    
                文章位置：http://www.hantingmc.com/qtweb/news21/472371.html
            
    
            
    
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联

猜你还喜欢下面的内容

微信小程序知识

同城分类信息

软文营销　　 　企业网站制作　　 　LED亮化工程　　 　网站制作　　 　成都石膏隔墙板　　 　广汉长尔科技　　 　产品包装设计　　 　重庆电商网站建设　　 　高端网站策划　　 　电信机房托管服务器　　 　成都微信二次开发公司　　 　成都网站建设　　 　长城雪茄　　 　温江网站建设　　 　成都广告公司　　 　物流公司网站建设方案　　 　成都响应式网站建设　　 　晟和广告　　 　成都光华电信机房　　 　网站推广营销