序列化与反序列化

小鱼儿 2023-01-17 04:58 330阅读 0赞

因为TCP/IP协议只支持字节数组的传输，不能直接传对象。对象序列化的结果一定是字节数组！当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为对象。

socket编程使用的是TCP协议

今天偶然看到了之前用java写的一个课设，简单记录一下这个知识点。

下面是我的课程设计的内容：

根据本课程实验材料和各次实验列出的任务要求，完成一个相对完整的小型管理系统，涉及到的核心知识包括数据库访问（JDBC、事务）、配置文件、对象序列化与反序列化、多线程、计时器、网络编程、Swing界面与事件驱动模型、正则表达式和格式化显示等。

3.1 基本模块1：对象序列化与反序列化（订单和订单项对应的类代码）

订单Orders.java

  1. package water.test1.po;
  2. import java.io.Serializable;
  3. import java.sql.Date;
  4. public class Orders implements Serializable { 
  5.     private String orderID;
  6.     private String customerID;
  7.     private Date orderTime;
  8.     private double totalMoney;
  9.     private String orderState;
  10.     private String senderName;
  11.     private String senderPhone;
  12.     public Orders()
  13.     { 
  15.     }
  16.     public Orders(String orderID,String customerID,Date orderTime,double totalMoney,String orderState,String senderName,String senderPhone)
  17.     { 
  18.         this.orderID=orderID;
  19.         this.customerID=customerID;
  20.         this.orderTime=orderTime;
  21.         this.totalMoney=totalMoney;
  22.         this.orderState=orderState;
  23.         this.senderName=senderName;
  24.         this.senderPhone=senderPhone;
  25.     }
  26.     public void setOrderID(String orderID)
  27.     { 
  28.         this.orderID=orderID;
  29.     }
  30.     public void setCustomerID(String customerID)
  31.     { 
  32.         this.customerID=customerID;
  33.     }
  34.     public void setOrderTime(Date orderTime)
  35.     { 
  36.         this.orderTime=orderTime;
  37.     }
  38.     public void setTotalMoney(double totalMoney)
  39.     { 
  40.         this.totalMoney=totalMoney;
  41.     }
  42.     public void setOrderState(String orderState)
  43.     { 
  44.         this.orderState=orderState;
  45.     }
  46.     public void setSenderName(String senderName)
  47.     { 
  48.         this.senderName=senderName;
  49.     }
  50.     public void setSenderPhone(String senderPhone)
  51.     { 
  52.         this.senderPhone=senderPhone;
  53.     }
  54.     public String getOrderID()
  55.     { 
  56.         return this.orderID;
  57.     }
  58.     public String getCustomerID()
  59.     { 
  60.         return this.customerID;
  61.     }
  62.     public Date getOrderTime()
  63.     { 
  64.         return this.orderTime;
  65.     }
  66.     public double getTotalMoney()
  67.     { 
  68.         return this.totalMoney;
  69.     }
  70.     public String getOrderState()
  71.     { 
  72.         return this.orderState;
  73.     }
  74.     public String getSenderName()
  75.     { 
  76.         return this.senderName;
  77.     }
  78.     public String getSenderPhone()
  79.     { 
  80.         return this.senderPhone;
  81.     }
  83.     public String toString() { 
  84.         return this.getOrderID() + "," + this.getCustomerID() + "," + this.getOrderTime() 
  85.         + "," + this.getTotalMoney() + "," + this.getOrderState()+ "," + this.getSenderName() 
  86.         + "," + this.getSenderPhone();
  87.     }
  89. }

订单项OrderItems.java

  1. package water.test1.po;
  2. import java.io.Serializable;
  3. public class OrderItems implements Serializable { 
  4.     private String orderID;
  5.     private String type;
  6.     private double price;
  7.     private int number;
  8.     private double total;
  9.     public OrderItems()
  10.     { 
  12.     }
  13.     public OrderItems(String orderID,String type,double price,int number,double total){ 
  14.         this.orderID=orderID;
  15.         this.type=type;
  16.         this.price=price;
  17.         this.number=number;
  18.         this.total=total;
  19.     }
  20.     public void setOrderID(String orderID)
  21.     { 
  22.         this.orderID=orderID;
  23.     }
  24.     public void setType(String type)
  25.     { 
  26.         this.type=type;
  27.     }
  28.     public void setPrice(double price)
  29.     { 
  30.         this.price=price;
  31.     }
  32.     public void setNumber(int number)
  33.     { 
  34.         this.number=number;
  35.     }
  36.     public void setTotal(double total)
  37.     { 
  38.         this.total=total;
  39.     }
  40.     public String getOrderID()
  41.     { 
  42.         return this.orderID;
  43.     }
  44.     public String getType()
  45.     { 
  46.         return this.type;
  47.     }
  48.     public double getPrice()
  49.     { 
  50.         return this.price;
  51.     }
  52.     public int getNumber()
  53.     { 
  54.         return this.number;
  55.     }
  56.     public double getTotal()
  57.     { 
  58.         return this.total;
  59.     }
  61.     public String toString() { 
  62.         return this.getOrderID() + "," + this.getType()+ "," + this.getPrice()
  63.                 + "," + this.getNumber() + "," + this.getTotal();
  64.     }}

3.2 基本模块2：JDBC下单事务和商品浏览功能的相关代码、必要的方案说明。

对于下单，我采用了购物车的方式，浏览商品后可添加至个人购物车，在购物车中选择需要购买的商品可完成下单操作。对于下单事务，包括3个操作——删除购物车中的商品、生成订单、生成订单对应的所有订单项，一旦3个步骤任意一个出现错误，便进行回滚操作。
对于商品浏览，我采用JTree的方式来对商品进行展示，所以需要获取产品集合，然后在JTree中进行展示。
对于数据库操作的部分，我采用的是存储过程的方式，下单事务以及商品浏览时所需调用的存储过程如下：

调用的存储过程

  1. /*查询所有产品*/
  2. alter procedure selectPro
  3. as
  4. select * from Products order by cast(type as decimal)
  5. go
  6. /*添加订单*/
  7. alter procedure addOrd(@orderID varchar(100),@customerID varchar(20),@orderTime datetime,@totalMoney real,@orderState varchar(20),@senderName varchar(20),@senderPhone varchar(20))
  8. as 
  9. insert into Orders(orderID,customerID,orderTime,totalMoney,orderState,senderName,senderPhone) values(@orderID,@customerID,@orderTime,@totalMoney,@orderState,@senderName,@senderPhone)
  10. GO
  11. /*添加订单项*/
  12. alter procedure addOrderItems(@orderID varchar(100),@type varchar(10),@price real,@number int,@total real)
  13. as
  14. insert into OrderItems(orderID,type,price,number,total) values(@orderID,@type,@price,@number,@total)
  15. go
  16. /*删除购物车的商品*/
  17. alter procedure deleteShopCar(@customerID varchar(50),@type varchar(10))
  18. as
  19. delete ShopCar where customerID=@customerID and type=@type
  20. go

下单事务PlaceOrdTran.java

  1. package water.test1.transaction;
  2. import java.sql.*;
  3. import java.util.*;
  4. import javax.swing.plaf.synth.SynthSeparatorUI;
  5. import water.test1.db.DBUtil;
  6. import water.test1.po.*;
  7. import water.test1.service.OrderItemsService;
  8. import water.test1.service.OrdersService;
  9. public class PlaceOrdTran { 
  10.     public boolean placeOrd(Orders order,ArrayList<OrderItems> ordItem,ArrayList<ShopCar> shopCars)
  11.     { 
  12.         DBUtil db=new DBUtil();
  13.         String sql="{call addOrd(?,?,?,?,?,?,?)}";
  14.         String sql2="{call addOrderItems(?,?,?,?,?)}";
  15.         String sql3="{call deleteShopCar(?,?)}";
  16.         //删除购物车中的购物项
  17.         Connection conn=null;
  18.         try { 
  19.             conn=db.getConnection();
  20.             boolean autoCommit=conn.getAutoCommit();
  22.             if(autoCommit)
  23.             { 
  24.                 conn.setAutoCommit(false);
  25.             }
  26.             Statement stmt=conn.createStatement();
  27.             for(int i=0;i<ordItem.size();i++)
  28.                 { 
  29.                 db.executeUpdate(sql2, new Object[] { ordItem.get(i).getOrderID(),ordItem.get(i).getType(),
  30.                         ordItem.get(i).getPrice(),ordItem.get(i).getNumber(),ordItem.get(i).getTotal()}) ;
  31.                 }
  32.             db.executeUpdate(sql, new Object[] { order.getOrderID(),order.getCustomerID(),
  33.                     order.getOrderTime(),order.getTotalMoney()
  34.                     ,order.getOrderState(),order.getSenderName(),order.getSenderPhone()});
  36.             for(int i=0;i<shopCars.size();i++)
  37.             { 
  38.             db.executeUpdate(sql3, new Object[] { shopCars.get(i).getCustomerID(),shopCars.get(i).getType()}) ;
  39.             }
  40.             conn.commit();
  41.             conn.setAutoCommit(autoCommit);
  42.         }
  43.         catch(Exception e)
  44.         { 
  45.             if(conn!=null)
  46.             { 
  47.                 try { 
  48.                     System.out.println("回滚");
  49.                     conn.rollback();
  50.                     return false;
  51.                 }
  52.                 catch(SQLException e1)
  53.                 { 
  54.                     e1.printStackTrace();
  55.                 }
  56.             }
  57.             e.printStackTrace();
  58.         }
  59.         finally { 
  60.             db.closeAll();
  61.         }
  63.         return true;
  64.     }
  66. }

获取商品集合方法

  1. public ArrayList<Products> select() 
  2.     { 
  3.         ArrayList<Products> pro=new ArrayList<Products>();
  4.         DBUtil db=new DBUtil();
  5.         String sql="{call selectPro}";
  6.         try { 
  7.             db.getConnection();
  8.             ResultSet rs=db.executeQuery(sql, null);
  9.             while(rs.next())
  10.             { 
  11.                 Products product=new Products();
  12.                 System.out.println(rs.getString(1));
  13.                 product.setType(rs.getString(1));
  14.                 product.setPrice(rs.getDouble(2));
  15.                 product.setPath(rs.getString(3));
  16.                 pro.add(product);
  17.             }
  19.         } catch (Exception e) { 
  20.             // TODO Auto-generated catch block
  21.             e.printStackTrace();
  22.         }
  23.         finally { 
  24.             db.closeAll();
  25.         }
  26.         return pro;
  27.     }

商品浏览客户端代码

  1. JTree tree = new JTree();
  2.         tree.setModel(new DefaultTreeModel(
  3.             new DefaultMutableTreeNode("Water") { 
  4.                 { 
  6.                     //请求服务器，读取产品类型集合
  7.                     pro=Client.selectProducts();
  9.                     DefaultMutableTreeNode node_1;
  10.                     node_1 = new DefaultMutableTreeNode("产品类型");
  13.                     for(int i=0;i<pro.size();i++)
  14.                     { 
  15.                         node_1.add(new DefaultMutableTreeNode(pro.get(i).getType()+"L"));
  16.                     }
  17.                add(node_1);
  18.                 }
  19.             }
  20.         ));
  21.         tree.setBounds(0, 0, 122, 369);
  23.         JScrollPane scrollPane_1 = new JScrollPane();
  24.         scrollPane_1.setBounds(0, 0, 122, 369);
  25.         panel.add(scrollPane_1);
  26.         scrollPane_1.setViewportView(tree);
  28.         tree.addTreeSelectionListener(new TreeSelectionListener() { 
  29.             public void valueChanged(TreeSelectionEvent arg0) { 
  31.                 TreePath path=tree.getSelectionPath();
  32.                 if(path==null)
  33.                 { 
  34.                     return ;
  35.                 }
  37.                 DefaultMutableTreeNode selectedNode=(DefaultMutableTreeNode)path.getLastPathComponent();
  38.                 if(selectedNode.getUserObject().toString().equals("产品类型"))
  39.                 { 
  40.                     panel_2.removeAll();
  41.                     panel_2.add(lblNewLabel_1);
  42.                     lblNewLabel_1.setVisible(true);
  43.                     textArea.setText("");
  44.                     repaint();
  45.                 }
  46.                 //浏览商品
  47.                 for(int i=0;i<pro.size();i++)
  48.                 { 
  50.                 if(selectedNode.getUserObject().toString().equals(pro.get(i).getType()+"L"))
  51.                 { 
  52.                 products=pro.get(i);
  53.                 panel_2.removeAll();
  54.                 lblNewLabel_1.setVisible(false);
  55.                 //在文本区添加产品类型的信息
  56.                 double p=pro.get(i).getPrice();
  57.                 Locale cnLocale=new Locale("zh", "CN");
  58.                 NumberFormat cnNumberFormat=NumberFormat.getCurrencyInstance(cnLocale);
  61.                 textArea.setText(selectedNode.getUserObject().toString()+" "+cnNumberFormat.format(p));
  63.                 JLabel lblNewLabel = new JLabel("");
  64.                 String str="./src/images/";
  65.                 lblNewLabel.setIcon(new ImageIcon(str+pro.get(i).getPath()));
  66.                 lblNewLabel.setBounds(0, 0, 347, 302);
  67.                 panel_2.add(lblNewLabel);
  68.                 JButton btnNewButton1 = new JButton("购物车");
  69.                 btnNewButton1.setBounds(452, 115, 93, 23);
  70.                 panel_2.add(btnNewButton1);
  71.                 JLabel label=new JLabel("",JLabel.CENTER);
  72.                 label.setBounds(452, 95, 93, 23);
  73.                 panel_2.add(label);
  74.                 repaint();
  75.                 btnNewButton1.addActionListener(new ActionListener() { 
  76.                     public void actionPerformed(ActionEvent arg0) { 
  77.                         //int number=Integer.parseInt(label.getText());
  78.                         //number++;
  79.                         if(Login.id==null)
  80.                         { 
  81.                             JOptionPane.showMessageDialog(btnNewButton1.getParent(), "请先进行登录","",JOptionPane.ERROR_MESSAGE);
  82.                         }
  83.                         else
  84.                         { 
  85.                         ShopCar shopCar=new ShopCar();
  86.                         shopCar.setCustomerID(Login.id);
  87.                         shopCar.setType(products.getType());
  88.                         shopCar.setNum(1);
  89.                         boolean flag=Client.addShopCar(shopCar);
  90.                         if(flag)
  91.                         label.setText("已加入购物车");
  92.                         else
  93.                             label.setText("添加失败");
  94.                         new UpdateShopCar().start();
  95.                         }
  96.                         //添加到购物车
  97.                     }
  98.                 });
  100.                 }
  101.                 }
  103.             }
  104.         });

3.3 基本模块3：服务器端程序代码（含对模块1和模块2数据相关代码的调用）、必要的方案说明。

对于服务器端，我利用Packet类对客户端传来的数据进封装，根据Packet的flag标志判断用户请求。我利用三个线程：分别是接收socket线程receive、处理客户端请求线程getMess、返回客户端数据的线程sendMess来处理用户请求。接收客户端发来的socket的线程一直处于alive状态用来接收socket，一旦接收到后便开一个处理该socket的线程,处理完请求后开一个返回客户端数据的线程，从而保证支持多用户并发操作。

模块一和模块二的调用：对于下单的操作，我在客户端进行装箱操作（把数据放至ArrayList），在服务器端进行拆箱操作（把ArrayList中数据，利用集合中object的getClass().getName()方法判断是何种类型的数据，从而进行转换），然后传参数到处理下单事务的数中，并调用该函数完成下单，返回Boolean型数据给客户端，表示是否下单成功。对于商品浏览的客户端请求，在服务器端直接调用ProductsService中获取全部产品的方法，保存数据到集合中，将该集合封装到Packet,返回给客户端，在客户端进行展示。

服务器ServerService.java

  1. package water.test2.view;
  2. import java.io.IOException;
  3. import java.io.ObjectInputStream;
  4. import java.io.ObjectOutputStream;
  5. import java.net.ServerSocket;
  6. import java.net.Socket;
  7. import java.util.ArrayList;
  8. import java.util.Iterator;
  9. import java.util.Vector;
  10. import water.test1.po.Customers;
  11. import water.test1.po.OrderItems;
  12. import water.test1.po.Orders;
  13. import water.test1.po.Products;
  14. import water.test1.po.ShopCar;
  15. import water.test1.service.CustomersService;
  16. import water.test1.service.OrderItemsService;
  17. import water.test1.service.OrdersService;
  18. import water.test1.service.ProductsService;
  19. import water.test1.service.ShopCarService;
  20. import water.test1.transaction.AddShopCarTran;
  21. import water.test1.transaction.PlaceOrdTran;
  23. public class ServerService { 
  24.     ServerSocket server;
  25.     public ServerService() { 
  26.         try { 
  27.             server=new ServerSocket(28890);
  28.             System.out.println("服务器已启动");
  29.         } catch (IOException e) { 
  30.             // TODO Auto-generated catch block
  31.             e.printStackTrace();
  32.         }
  33.         new receive().start();
  35.         // TODO Auto-generated constructor stub
  36.     }
  37.     class receive extends Thread
  38.     { 
  39.         public void run()
  40.         { 
  41.             while(this.isAlive()) { 
  42.                 try { 
  44.                     Socket socket=server.accept();
  45.                     if(socket!=null)
  46.                     { 
  47.                     new getMess(socket).start();
  48.                     }
  50.             }catch (Exception e) { 
  51.                 e.printStackTrace();
  52.             }
  53.         }
  54.     }
  55.     }
  56.     class getMess extends Thread
  57.     { 
  58.         Socket socket;
  59.         ObjectInputStream ois;
  60.         public getMess(Socket socket)
  61.         { 
  62.             this.socket=socket;
  63.             try { 
  64.                 ois=new ObjectInputStream(socket.getInputStream());
  65.             } catch (IOException e) { 
  66.                 // TODO Auto-generated catch block
  67.                 e.printStackTrace();
  68.             }
  69.         }
  70.         public void run()
  71.         {     
  72.             //while(this.isAlive()) { 
  73.             try { 
  74.             Packet packet=(Packet)ois.readObject();
  75.             //if(packet!=null) { 
  76.             //注册
  77.             if(packet.getFlag().equals("注册"))    
  78.             { 
  79.             Customers customers=(Customers) packet.getContent();
  80.             CustomersService cs=new CustomersService();
  81.             int flag=0;
  82.             try { 
  83.             flag=cs.add(customers);
  84.             }
  85.             catch(Exception e)
  86.             { 
  87.                 Packet packet2;
  88.                 packet2=new Packet("注册结果", false);
  89.                 new sendMess(socket,packet2).start();
  90.                 e.printStackTrace();
  91.             }
  92.             Packet packet2;
  93.             if(flag==1)
  94.                 packet2=new Packet("注册结果", true);
  95.             else { 
  96.                 packet2=new Packet("注册结果", false);
  97.             }
  98.             new sendMess(socket,packet2).start();
  99.             }
  100.             //登录
  101.             if(packet.getFlag().equals("登录"))    
  102.             { 
  103.             Customers customers=(Customers) packet.getContent();
  104.             CustomersService cs=new CustomersService();
  105.             boolean flag=false;
  106.             try { 
  107.             flag=cs.selectCumLog(customers);
  108.             }
  109.             catch(Exception e)
  110.             { 
  111.                 Packet packet2;
  112.                 packet2=new Packet("登录失败", false);
  113.                 new sendMess(socket,packet2).start();
  114.                 e.printStackTrace();
  115.             }
  116.             Packet packet2;
  117.             if(flag)
  118.                 packet2=new Packet("登录成功", true);
  119.             else { 
  120.                 packet2=new Packet("登录失败", false);
  121.             }
  122.             new sendMess(socket,packet2).start();
  123.             }
  124.             //添加购物车
  125.             if(packet.getFlag().equals("添加购物车"))
  126.             { 
  127.                 ShopCar shopCar=(ShopCar) packet.getContent();
  128.                 AddShopCarTran addShopCarTran=new AddShopCarTran();
  129.                 boolean flag=false;
  130.                 try { 
  131.                 flag=addShopCarTran.addShopCar(shopCar);
  132.                 }
  133.                 catch(Exception e)
  134.                 { 
  135.                     Packet packet2;
  136.                     packet2=new Packet("添加失败", false);
  137.                     new sendMess(socket,packet2).start();
  138.                     e.printStackTrace();
  139.                 }
  140.                 Packet packet2;
  141.                 if(flag)
  142.                     packet2=new Packet("添加成功", true);
  143.                 else { 
  144.                     packet2=new Packet("添加失败", false);
  145.                 }
  146.                 new sendMess(socket,packet2).start();
  147.                 }
  148.             //产品列表
  149.             if(packet.getFlag().equals("产品"))
  150.             { 
  151.                 ProductsService ps=new ProductsService();
  152.                 ArrayList<Products> products =new ArrayList<Products>();
  153.                 products=ps.select();
  154.                 Packet packet2;
  155.                 packet2=new Packet("所有产品", products);
  156.                 new sendMess(socket,packet2).start();
  157.             }
  158.             //显示购物车
  159.             if(packet.getFlag().equals("显示购物车"))
  160.             { 
  161.                 ShopCar shopCar=(ShopCar) packet.getContent();
  162.                 ShopCarService shopCarService=new ShopCarService();
  163.                 Vector<Vector<Object>> data=new  Vector<Vector<Object>>();
  164.                 data=shopCarService.select(shopCar);
  165.                 Packet packet2;
  166.                 packet2=new Packet("购物车内商品", data);
  167.                 new sendMess(socket,packet2).start();
  168.             }
  169.             //下单操作
  170.             if(packet.getFlag().equals("下单"))
  171.             { 
  173.                 ArrayList<Object> a=(ArrayList<Object>)packet.getContent();
  174.                 Iterator<Object> iterator=a.iterator();
  175.                 Orders orders=new Orders();
  176.                 ArrayList<OrderItems> orderItems=new ArrayList<OrderItems>();
  177.                 ArrayList<ShopCar> shopCars=new ArrayList<ShopCar>();
  178.                 while(iterator.hasNext())
  179.                 { 
  180.                     Object object=iterator.next();
  181.                     if(object.getClass().getName().equals("water.test1.po.Orders"))
  182.                     orders=(Orders)object;
  183.                     if(object.getClass().getName().equals("water.test1.po.OrderItems"))
  184.                     { 
  185.                         OrderItems orderItems2=new OrderItems();
  186.                         orderItems2=(OrderItems)object;
  187.                         orderItems.add(orderItems2);
  188.                     }
  189.                     if(object.getClass().getName().equals("water.test1.po.ShopCar"))
  190.                     { 
  191.                         ShopCar shopCar=new ShopCar();
  192.                         shopCar=(ShopCar)object;
  193.                         shopCars.add(shopCar);
  194.                     }
  196.                 }
  197.                 PlaceOrdTran p=new PlaceOrdTran();
  198.                   boolean flag=p.placeOrd(orders, orderItems,shopCars);
  199.                   Packet packet2;
  200.                 if(flag)
  201.                     packet2=new Packet("下单成功", true);
  202.                 else { 
  203.                     packet2=new Packet("下单失败", false);
  204.                 }
  205.                 new sendMess(socket,packet2).start();
  206.             }
  207.             //显示个人订单
  208.             if(packet.getFlag().equals("显示个人订单"))
  209.             { 
  210.                 Customers customers=(Customers) packet.getContent();
  211.                 OrdersService orderService=new OrdersService();
  212.                 Vector<Vector<Object>> data=new  Vector<Vector<Object>>();
  213.                 data=orderService.selectOrdsByPerson(customers);
  214.                 Packet packet2;
  215.                 packet2=new Packet("个人订单", data);
  216.                 new sendMess(socket,packet2).start();
  217.             }
  218.             if(packet.getFlag().equals("订单项"))
  219.             { 
  220.                 Orders orders=(Orders)packet.getContent();
  221.                 OrderItemsService os=new OrderItemsService();
  222.                 ArrayList<OrderItems> orderItems =new ArrayList<OrderItems>();
  223.                 orderItems=os.select(orders);
  224.                 Packet packet2;
  225.                 packet2=new Packet("订单项", orderItems);
  226.                 new sendMess(socket,packet2).start();
  227.             }
  228.             if(packet.getFlag().equals("删除订单"))
  229.             { 
  230.                 Orders orders=(Orders) packet.getContent();
  231.                 OrdersService ordersService=new OrdersService();
  232.                 //方法
  233.                 boolean flag=true;
  234.                 Packet packet2;
  235.                 packet2=new Packet("删除成功否", flag);
  236.                 new sendMess(socket,packet2).start();
  237.             }
  238.             }catch(IOException e)
  239.         { 
  240.             e.printStackTrace();
  241.         } catch (ClassNotFoundException e) { 
  242.             // TODO Auto-generated catch block
  243.             e.printStackTrace();
  244.         }
  246.         }
  247.     }
  249.     class sendMess extends Thread
  250.     { 
  251.         Socket socket;
  252.         Packet packet;
  253.         public sendMess(Socket socket,Packet packet)
  254.         { 
  255.             this.socket=socket;
  256.             this.packet=packet;
  257.         }
  258.         public void run()
  259.         { 
  260.             try { 
  261.                 ObjectOutputStream oos=new ObjectOutputStream(socket.getOutputStream());
  262.                 oos.writeObject(packet);
  263.                 oos.close();
  264.             } catch (IOException e) { 
  265.                 // TODO Auto-generated catch block
  266.                 e.printStackTrace();
  267.             }
  268.         }
  269.     }
  270.     public static void main(String args[])
  271.     { 
  272.         ServerService serverService=new ServerService();
  273.     }
  275. }

3.4 基本模块4：客户端商品浏览（含格式化价格）和下单界面截图，以及下单操作的处理代码（含使用客户端Socket对象与服务端Sockect对象的通信代码）、必要的方案说明。

商品浏览截图如图一，下单过程的界面截图如下图。
下单操作：我将客户端请求封装到Client类的静态方法中，发送下单请求时调用该类中的静态方法即可。对于下单操作，，根据tabel中复选框是否选中，来对要下单的数据进行判断，如果选中就将该行数据加入到订单项并存到OrderItems类型的集合中，将该行数据放到要购物车要删除的shopCar类型的集合中，利用 Orders类型的对象，存放订单。将这三部分数据存放到ArrayList的对象中，进行装箱，然后使用客户端Socket对象向服务发送请求，服务器接收到后进行拆箱，使其变回原来的数据类型，在下单的事务中传入这些参数完成下单。将下单结果返回给客户端，进行提示是否成功下单。
该部分中订单编号我是利用UUID的randomUUID()方法来获取随机订单编号，保证随机生成的订单编号尽量避免重复，对于价格和日期进行了格式化显示，下单时对于价格，因为含有“￥”符号，故利用parse()方法，使其变为原来的数字格式。

图一 商品浏览截图

在这里插入图片描述

图二 购物车界面截图

在这里插入图片描述

图三 结算界面截图

在这里插入图片描述

图四 下单成功界面截图
在这里插入图片描述

图五 下单后购物车界面截图
在这里插入图片描述

图六 下单后个人订单页面截图
在这里插入图片描述

下单操作处理代码：
客户端界面按钮事件提取数据信息

  1. JButton button = new JButton("结算");
  2.         button.addActionListener(new ActionListener() { 
  3.             public void actionPerformed(ActionEvent arg0) { 
  4.                 ArrayList<OrderItems> orderItems=new ArrayList<OrderItems>();
  5.                 ArrayList<ShopCar> shopCarList=new ArrayList<ShopCar>();
  6.                 Orders orders=new Orders();
  7.                 Locale cnLocale=new Locale("zh", "CN");
  8.                 NumberFormat cnNumberFormat=NumberFormat.getCurrencyInstance(cnLocale);
  9.                 //int selectRows = table.getSelectedRows().length;// 取得用户所选行的行数
  10.                 DefaultTableModel tableModel = (DefaultTableModel) table.getModel();
  11.                 int rows=table.getRowCount();
  12.                 double sum=0;
  13.                 String orderID=UUID.randomUUID().toString();
  14.                 Date orderTime=new Date();
  15.                 orders.setCustomerID(Login.id);
  16.                 orders.setOrderID(orderID);
  17.                 orders.setOrderTime(orderTime);
  18.                 orders.setOrderState("0");
  19.                 int flag=0;
  20.                 for(int i=0;i<rows;i++)
  21.                 { 
  22.                     boolean select=(Boolean) tableModel.getValueAt(i,0);
  23.                     if(select)
  24.                     { 
  25.                         flag=1;
  26.                         OrderItems items=new OrderItems();
  27.                         ShopCar shopCar=new ShopCar();
  28.                         //Date date=new Date();
  29.                         //SimpleDateFormat nowdate=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  30.                         String type=tableModel.getValueAt(i,1).toString();
  31.                         double price=0;
  32.                         try { 
  33.                             price = Double.parseDouble(cnNumberFormat.parse(tableModel.getValueAt(i,2).toString()).toString());
  34.                         } catch (NumberFormatException e) { 
  35.                             // TODO Auto-generated catch block
  36.                             e.printStackTrace();
  37.                         } catch (ParseException e) { 
  38.                             // TODO Auto-generated catch block
  39.                             e.printStackTrace();
  40.                         }//.replace('￥',' ')
  41.                         int num=Integer.parseInt(tableModel.getValueAt(i,3).toString());
  42.                         double total=price*num;
  43.                         sum+=total;
  44.                         items.setNumber(num);
  45.                         items.setOrderID(orderID);
  46.                         items.setPrice(price);
  47.                         items.setTotal(total);
  48.                         items.setType(type);
  49.                         orderItems.add(items);
  50.                         shopCar.setCustomerID(Login.id);
  51.                         shopCar.setType(type);
  52.                         shopCarList.add(shopCar);
  53.                     }
  54.                 }
  55.                 if(flag==1)
  56.                 { 
  57.                 int r=JOptionPane.showConfirmDialog(table, "您的订单价格"+sum+"元"+"确定下单","确认",JOptionPane.YES_NO_OPTION);    
  58.                 if(r==JOptionPane.YES_OPTION)
  59.                 { 
  60.                 orders.setTotalMoney(sum);
  61.                 ArrayList<Object> a =new ArrayList<Object>();
  62.                 a.add(orders);
  63.                 for(int i=0;i<orderItems.size();i++)
  64.                 { 
  65.                     a.add(orderItems.get(i));
  66.                 }
  67.                 Iterator iterator=shopCarList.iterator();
  68.                 while(iterator.hasNext())
  69.                 { 
  70.                     a.add(iterator.next());
  71.                 }
  72.                 boolean flag2=Client.placeOrder(a);//调用下单请求函数，同时返回下单
  73.                 Object[] msg= { Login.id,orderTime};
  74.                 Locale locale=Locale.getDefault();
  75.                 String pattern="账号为{0}的用户,您好，您在{1,date,long} {1,time,hh:mm:ss}下单成功";
  76.                 if(flag2)
  77.                 { 
  78.                     JOptionPane.showMessageDialog(button.getParent(), FormatDate.msgFormat(pattern, locale, msg),"",JOptionPane.INFORMATION_MESSAGE);
  79.                     new UpdateShopCar().start();
  80.                     new UpdateOrders2().start();
  81.                 }
  82.                 else
  83.                 { 
  84.                     JOptionPane.showMessageDialog(button.getParent(), "下单失败","",JOptionPane.ERROR_MESSAGE);
  85.                 }
  86.                 }
  87.                 else
  88.                 { 
  89.                     JOptionPane.showMessageDialog(button.getParent(), "取消下单成功","",JOptionPane.INFORMATION_MESSAGE);
  90.                 }
  91.                   }
  92.                 else
  93.                 { 
  94.                     JOptionPane.showMessageDialog(button.getParent(), "请选择商品后进行下单","",JOptionPane.ERROR_MESSAGE);
  95.                 }
  96.             }
  97.         });
  98. Cilent中

客户端发送下单请求调用的方法

  1. public static boolean placeOrder(ArrayList<Object> a)
  2.     { 
  3.         boolean reg=false;
  4.         try { 
  5.             Socket socket=new Socket(Login.ip,Login.port);
  6.             ObjectOutputStream oos=new ObjectOutputStream(socket.getOutputStream());
  7.             Packet packet=new Packet("下单", a);
  8.             oos.writeObject(packet);
  9.             Packet packet2=(Packet)new ObjectInputStream(socket.getInputStream()).readObject();
  10.             reg=(boolean) packet2.getContent();
  11.             oos.close();
  12.             socket.close();
  13.             }catch (Exception e) { 
  14.                 // TODO: handle exception
  15.                 e.printStackTrace();
  16.             }
  17.         return reg;
  19.     }

服务器处理主要代码

  1. if(packet.getFlag().equals("下单"))
  2.             { 
  4.                 ArrayList<Object> a=(ArrayList<Object>)packet.getContent();
  5.                 Iterator<Object> iterator=a.iterator();
  6.                 Orders orders=new Orders();
  7.                 ArrayList<OrderItems> orderItems=new ArrayList<OrderItems>();
  8.                 ArrayList<ShopCar> shopCars=new ArrayList<ShopCar>();
  9.                 while(iterator.hasNext())
  10.                 { 
  11.                     Object object=iterator.next();
  12.                     if(object.getClass().getName().equals("water.test1.po.Orders"))
  13.                     orders=(Orders)object;
  14.                     if(object.getClass().getName().equals("water.test1.po.OrderItems"))
  15.                     { 
  16.                         OrderItems orderItems2=new OrderItems();
  17.                         orderItems2=(OrderItems)object;
  18.                         orderItems.add(orderItems2);
  19.                     }
  20.                     if(object.getClass().getName().equals("water.test1.po.ShopCar"))
  21.                     { 
  22.                         ShopCar shopCar=new ShopCar();
  23.                         shopCar=(ShopCar)object;
  24.                         shopCars.add(shopCar);
  25.                     }
  26.                 }
  27.                 PlaceOrdTran p=new PlaceOrdTran();
  28.                   boolean flag=p.placeOrd(orders, orderItems,shopCars);
  29.                   Packet packet2;
  30.                 if(flag)
  31.                     packet2=new Packet("下单成功", true);
  32.                 else { 
  33.                     packet2=new Packet("下单失败", false);
  34.                 }
  35.                 new sendMess(socket,packet2).start();
  36.             }

3.5 基本模块5：注册界面的正则表达式验证

对于注册验证部分，我采用类似网页注册验证的方式，逐个进行验证，只有当前验证通过才可以填写下一部分信息。该部分验证包括对姓名、电话号码、账号、密码的验证，对于姓名只可输入中文或英文，电话号码要求符合电话号码规则，账号和密码是6-10位的数字或字母的组合，验证用到的方法如下：

  1. public static boolean verifyPhoneno(String input) { 
  2.         boolean ck = false;
  3.         String regex = "^(13[0-9]|14[579]|15[0-3,5-9]|16[6]|17[0135678]|18[0-9]|19[89])\\d{8}$";
  4.         Pattern pattern = Pattern.compile(regex);
  5.         Matcher matcher = pattern.matcher(input);
  6.         if (matcher.matches()) { 
  7.             ck = true;
  8.         }
  9.         return ck;
  10.     }
  11.     public static boolean verifyID(String input) { 
  12.         boolean ck = false;
  13.         String regex = "^[a-zA-Z0-9]{6,10}$";
  14.         Pattern pattern = Pattern.compile(regex);
  15.         Matcher matcher = pattern.matcher(input);
  16.         if (matcher.matches()) { 
  17.             ck = true;
  18.         }
  19.         return ck;
  20.     }
  21.     public static boolean verifyName(String input) { 
  22.         boolean ck = false;
  23.         String regex = "^([\\u4e00-\\u9fa5]{1,20}|[A-Za-z\\.\\s]{1,20})$";
  24.         Pattern pattern = Pattern.compile(regex);
  25.         Matcher matcher = pattern.matcher(input);
  26.         if (matcher.matches()) { 
  27.             ck = true;
  28.         }
  29.         return ck;
  30.     }
  31.     public static boolean verifyPsd(String input) { 
  32.         boolean ck = false;
  33.         String regex = "^[a-zA-Z0-9]{6,10}$";
  34.         Pattern pattern = Pattern.compile(regex);
  35.         Matcher matcher = pattern.matcher(input);
  36.         if (matcher.matches()) { 
  37.             ck = true;
  38.         }
  39.         return ck;
  40.     }

界面调用验证方法（对姓名验证，其余验证操作与之相似，不在罗列）

  1. textField_tel.addFocusListener(new FocusAdapter() { 
  2.             @Override
  3.             public void focusLost(FocusEvent arg0) { 
  4. if (!FormatDate.verifyPhoneno(textField_tel.getText().trim())) {    //调用验证方法
  5.                     textField_tel.selectAll();
  6.                     textField_tel.requestFocus();
  7.                     lblNewLabel_5.setText("输入不合法");
  8.                 }
  9.                 else { 
  10.                     lblNewLabel_5.setText("√")  }}});

发表评论

表情：
评论列表 （有 0 条评论，330人围观）

还没有评论，来说两句吧...

相关阅读

    相关 序列化与反序列化

    一、概念 1、序列化 将数据结构转换称为二进制数据流或者文本流的过程。序列化后的数据方便在网络上传输和在硬盘上存储。 2、反序列化 与序列化相反，是将二进制

    怼烎@怼烎@/ 0 赞/ 125 阅读

    相关 序列化与反序列化

    因为TCP/IP协议只支持字节数组的传输，不能直接传对象。对象序列化的结果一定是字节数组！当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二

    小鱼儿小鱼儿/ 0 赞/ 331 阅读

    相关 序列化与反序列化

    我们知道，和new创建对象，反射创建对象，序列化创建对象也是我们常用的一种对象创建方式，下面就详细的说一说序列化与反序列化。 一.序列化简述 为什么需要序列化与反序列

    叁歲伎倆叁歲伎倆/ 0 赞/ 833 阅读

    相关 序列化与反序列化

    序列化：将对象转化为字节序列 反序列化：将字节序列转化为对象 序列化与反序列化的好处： 1. 进行远程通信传输对象 我们知道数据是以二进制的方式在网络上传输的

    缺乏、安全感缺乏、安全感/ 0 赞/ 426 阅读

    相关 序列化与反序列化

    一、序列化的概念 序列化：首先，用日常生活中的例子来理解一下序列化。在我们日常生活中，运输一个整个的汽车总是不方便的，所以我们会把汽车拆开，当汽车变成一个个零件的时候，我们

    你的名字你的名字/ 0 赞/ 463 阅读

    相关 序列化与反序列化

    概念 -------------------- 把对象的状态信息转换为字节序列的过程称为对象的序列化。 把字节序列恢复为对象的过程称为对象的反序列化。 对象的序列

    朱雀朱雀/ 0 赞/ 648 阅读