Eine kurze Einführung in Cookies in Servlets in Java (Bilder und Text)

Seit der Geburt der Cookie-Technologie steht sie im Mittelpunkt der Debatte unter Internetnutzern und Webentwicklern. Der folgende Artikel führt Sie hauptsächlich in die relevanten Informationen zur Einführung von Cookies in Servlets ein. Die Einführung im Artikel ist sehr detailliert.

Lassen Sie uns zunächst verstehen, was ein „Gespräch“ ist. Sitzung ist ein Begriff in der Webtechnologie. Er kann einfach so verstanden werden: Der Benutzer öffnet einen Browser, klickt auf mehrere Hyperlinks, greift auf mehrere Webressourcen auf dem Server zu und schließt dann den Browser.

Wenn Sie einen Browser öffnen, um eine Seite zu besuchen, und dann einen Browser öffnen, um dieselbe Seite zu besuchen, gibt es zwei Sitzungen und nach dem Öffnen eines Browsers, um eine Seite zu besuchen, ist die Seite ein Hyperlink Wenn eine Sitzung über einen neuen Browser geöffnet wird, zählt sie immer noch nur als eine Sitzung.

Jeder Benutzer generiert während der Konversation zwischen dem Browser und dem Server zwangsläufig einige Daten, und das Programm muss einen Weg finden, diese Daten für jeden Benutzer zu speichern. Wenn ein Benutzer beispielsweise auf einen Hyperlink klickt, um ein Produkt über ein Produkt-Servlet zu kaufen, sollte das Programm eine Möglichkeit finden, das Produkt zu speichern, sodass der Benutzer, wenn er auf den Zahlungs-Hyperlink klickt, das Produkt über das Zahlungs-Servlet sehen kann dafür bezahlen.

Es ist nicht möglich, Daten mit dem Request-Objekt zu speichern, da die Servlets zum Klicken auf Waren und zum Ausführen von Zahlungen zwei verschiedene Request-Anforderungsobjekte senden und die Verwendung des ServletContext-Objekts für mehrere Benutzer zu Thread-Sicherheitsproblemen führt Die Weiterleitungsfunktion ist theoretisch möglich, das Nutzererlebnis wird jedoch stark eingeschränkt. Jedes Mal, wenn Sie auf einen Artikel klicken, werden Sie zur Zahlung aufgefordert. Basierend auf den oben genannten Anforderungen gibt es daher zwei Technologien zum Speichern der während der Sitzung generierten Daten: eine ist Cookie und die andere ist die Sitzungstechnologie, die in den folgenden Kapiteln vorgestellt wird.

In diesem Artikel geht es hauptsächlich um die Cookie-Technologie in Servlet. Bei der Cookie-Technologie handelt es sich um eine clientseitige Technologie, bei der das Programm die Daten jedes Benutzers in Form eines Cookies in den jeweiligen Browser des Benutzers schreibt. Wenn der Benutzer über den Browser auf den Server zugreift, bringt er seine eigenen Daten mit, sodass der Webserver die eigenen Daten des Benutzers verarbeitet.

Die folgende Abbildung zeigt einen einfachen Vorgang zum Setzen eines Cookies mit der letzten Zugriffszeit während einer Sitzung:

　

Das Erstellen eines Cookie-Objekts ist genau wie das Erstellen eines Java-Objekt normalerweise Genauso einfach:

Übergeben Sie einfach den Cookie-Namen und -Wert, wenn Sie den Konstruktor verwenden. Wir müssen das Cookie vom Browser auf der Serverseite senden lassen. Daten können die request.getCookies-Methode des Anforderungsobjekts verwenden, um ein Cookie-Array zu erhalten, und wenn wir Cookies an den Browser ausgeben möchten, können wir die response.addCookie（Cookie）-Methode des Antwortobjekts verwenden.

Gleichzeitig verfügt das Cookie-Objekt auch über die folgenden Methoden:

　

　Die getName-Methode wird verwendet, um den Namen eines Cookie-Objekts zu erhalten.

Die setValue-Methode und die getValue-Methode werden verwendet, um den Wert eines Cookie-Objekts festzulegen bzw. abzurufen.

　setMaxAge（int expires) Die Methode besteht darin, die Gültigkeitsdauer des Cookies festzulegen. Ohne diesen Code beträgt die Gültigkeitsdauer des Cookies eine Sitzungszeit (d. h. beim Schließen des Browsers ist das Cookie nicht mehr vorhanden). ). Wenn die Gültigkeitsdauer des Cookies festgelegt ist, wird das Cookie in der vom Browser angegebenen Festplattendatei gespeichert und während dieser Zeit wird das Cookie bei jedem Besuch des Servers mitgeführt. Wenn dieser Methodenparameter auf „0“ gesetzt ist, weist der Server den Browser an, das Cookie zu löschen.

Die setPath-Methode ist ein gültiger Pfad zum Setzen von Cookies. Zeigt an, dass Cookies nur beim Besuch bestimmter spezifischer URLs übertragen werden. Angenommen, eine Webanwendung ist [myservlet]. Wenn wir den Parameter in der setPath-Methode auf „/myservlet“ setzen, sendet der Browser beim Zugriff auf alle Ressourcen unter der Webanwendung Cookies Wenn der Parameter auf „/myservlet/pages“ gesetzt ist, wird das Cookie nur durch den Zugriff auf die Ressourcen unter [Seiten] in der Webanwendung übertragen, und durch den Zugriff auf andere Ressourcen in der Webanwendung wird das Cookie nicht zum Server übertragen. Wenn wir die setPath-Methode nicht festlegen, ist der effektive Pfad des Cookies standardmäßig das Verzeichnis, in dem sich das aktuelle Programm befindet, das das Cookie-Objekt erstellt hat. Beachten Sie, dass der Cookie-Pfad vom Browser verwendet wird (Einzelheiten finden Sie unter „Webpfadprobleme beim Servlet-Lernen“)

Die setDomain-Methode dient zum Festlegen des effektiven Domänennamens des Cookies, z. B.: .sina.com ( Beachten Sie, dass sich am vorderen Punkt ein befindet). Zeigt an, dass das Cookie übertragen wird, wenn der Browser auf den Domänennamen zugreift. Aber mittlerweile haben Browser diese möglicherweise als unsicher geltende Funktion im Grunde vollständig blockiert, sodass sie fast aufgegeben wurde.

　　举例：我们访问某个Servlet，而在访问这个Servlet时会将当前访问时间作为Cookie中的值返回给客户端，同时下次再次访问该Servlet时，会显示上一次客户端来访问的时间：

public void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  
  response.setCharacterEncoding("UTF-8");
  response.setContentType("text/html;charset=utf-8");
  
  PrintWriter writer = response.getWriter();
  writer.write("您上次访问的时间是：");
  //获取用户上一次的访问时间并显示
  Cookie[] cookies = request.getCookies();   //从请求中获取客户端发来的Cookie
  for(int i=0;cookies!=null && i<cookies.length;i++) {
   if(cookies[i].getName().equals("lastAccessTime")) { //获取最后访问时间的Cookie
    Long mTime = Long.parseLong(cookies[i].getValue());  
    String lastAccessTime = new Date(mTime).toLocaleString();
    writer.write(lastAccessTime);
   }
  }
  //将本次登录时间重新装载进Cookie中并返回给客户端
  Cookie timeCookie = new Cookie("lastAccessTime", System.currentTimeMillis()+"");
  timeCookie.setMaxAge(1*24*60*60); //将Cookie有效期置为一天
  response.addCookie(timeCookie);  //将Cookie传回客户端
 }

第一次访问是没有Cookie的，所以看不到访问时间：

　　

但是我们通过HttpWatch观察Response响应包中的内容已经有了“Set-Cookie”响应头：

　　

刷新后的第二次访问就可以看到了：

　　

同时观察HttpWatch中Request请求包的“Cookie”请求头可以发现：

　　

　　现在我们再来通过一个案例来学习Cookie，这是一个很常见的案例，比如我们在访问购物网站的时候经常会发现当浏览了这个网站内的某个商品的时候，下次继续来访问这个网站，会有一个上次浏览物品的显示。

　　如果我们不是用登录后将记录保存在服务器端，而是使用Cookie技术来将记录保存在客户端的浏览器中（现实生活中当然很少这样使用，这里只是作为案例学习），那么我们应该怎么做呢？

　　首先我们必须在服务器要有两个Servlet，一个在用户眼中是用来显示所有商品的，一个是用来显示点击某个商品之后详细信息的。

　　⑴．用来显示所有商品的Servlet需要完成如下功能：

　　　① 在一个部分以超链接形式将数据库中所有的商品显示在该Servlet上。

　　　② 在另一个部分获取用户请求中的Cookie将之前浏览过的商品（通过Cookie中的商品id）显示在该Servlet上。

　　⑵. 用来显示点击某个商品之后详细信息的Servlet需要完成如下功能：

　　　① 在页面上通过超链接的URL跟随的参数（即商品id）来获取该商品对象，同时将该商品对象的详细信息输出到Servlet页面上。

　　　② 如果是用户首次访问，将用户浏览商品的id作为Cookie直接返回，而如果是用户再次访问，则需要根据一定的条件来将这些Cookie的值进行调整，以便易于显示和满足用户体验。

　　当然，在这之前我们还需要做些准备工作，我们需要建立商品对象，这里简单的以书为商品建立对象：

public class Product {
 
 private String id;
 private String name;
 private String author;
 
 public Product() {
  super();
  
 }
 public Product(String id, String name, String author) {
  super();
  this.id = id;
  this.name = name;
  this.author = author;
 }
 
 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;
 }
}

我们还需要一个数据库来保存商品，这里我们先用一个类来来保存（数据库还没学嘛T_T！），保存数据采用Map集合，这是因为如果有检索会方便：

public class ProductDatabase {
 
 private static Map<String,Product> map = new HashMap<String, Product>();
 
 static{
  map.put("1", new Product("1","《Java编程思想》","JB"));
  map.put("2", new Product("2","《Java核心技术》","fdaf"));
  map.put("3", new Product("3","《Java并发编程》","什么鬼"));
  map.put("4", new Product("4","《Head first 设计模式》","老王"));
  map.put("5", new Product("5","《HTML5权威手册》","hhaa"));
 }
 
 public static Map<String,Product> getMap() {
 
  return map;
 }
 
}

做完了这两步，那么我们可以安心的去搞Servlet了，首先是在显示所有商品的Servlet：

response.setCharacterEncoding("UTF-8");
  response.setContentType("text/html;charset=utf-8");
  
  PrintWriter writer = response.getWriter();
  //从数据库中取出要显示在购物网站首页的商品
  Map<String,Product> map = ProductDatabase.getMap();
  if(map == null) {
   writer.print("您访问的宝贝已下架");
   return ;
  }
  for(Map.Entry<String, Product> en : map.entrySet()) {
   writer.print("<a href=&#39;/CookieProductProject/servlet/DetailGoodServlet?id="+en.getKey()+"&#39; target=&#39;_blank&#39; >"
              +en.getValue().getName()+" <br/>");
  }
  
  
  //显示用户之前浏览过的商品,要从用户发送的请求中的Cookie里取得
  writer.print("<br/><br/>");
  writer.print("您最近浏览过的商品： <br/>");
  
  Cookie[] cookies = request.getCookies();
  for(int i=0;cookies!=null && i<cookies.length;i++ ) {
   if(cookies[i].getName().equals("productHistory")) {
    Cookie cookie = cookies[i];
    String productId = cookie.getValue();
    String[] splitId = productId.split("\\_");
    for(String sId:splitId) {
     Product book = ProductDatabase.getMap().get(sId);
     writer.print(book.getName()+"<br/>");
    }
   }
  }
}

最后是点击某个商品显示详细信息的Servlet：

response.setCharacterEncoding("UTF-8");
  response.setContentType("text/html;charset=UTF-8");
  PrintWriter writer = response.getWriter();

  //通过用户点击商品的超链接而跟随URL来的ID参数来获取商品的详细信息
  String productId = request.getParameter("id");
  Map<String, Product> map = ProductDatabase.getMap();
  Product book = map.get(productId);
  writer.print("商品名："+book.getName()+"<br />");
  writer.print("作者："+book.getAuthor());
  
  //同时通过Cookie将用户观看的商品以Cookie的形式回传给用户浏览器 
  Cookie[] allCookies = request.getCookies();
  
  Cookie cookie = creCookie(book.getId(),allCookies);
  cookie.setMaxAge(24*60*60);
  response.addCookie(cookie);

其中creCookie（String,Cookie[]）是自定义方法，用于获取用户的cookie并添加本次浏览商品id再作为cookie返回：

private Cookie creCookie(String id, Cookie[] cookies) {
  Cookie cookie = null;
  
  if(cookies == null) { //如果cookies为空，说明用户首次访问
   cookie = new Cookie("productHistory", id);
   System.out.println(cookie.getValue());
   return cookie;
  }
  for(int i=0; i<cookies.length; i++) {
   if(cookies[i].getName().equals("productHistory")){
    cookie = cookies[i];
   }
  }
  
  String historyStr = cookie.getValue(); //此时获取到的之前浏览过数据的历史记录，有多种情况
  String[] produIds = historyStr.split("\\_");
  
  //为了检测数组中是否有包含当前的id，建议使用集合，而且是使用链表结构的集合
  LinkedList<String> list = new LinkedList<String>(Arrays.asList(produIds));
  if(list.contains(id)) {
   list.remove(id);
  }
  else if(list.size()>=3){
    list.removeLast();
  }
  
  list.addFirst(id);
  
  StringBuilder sb = new StringBuilder();
  for(String sId :list) {
   sb.append(sId+"_");
  }
  sb.deleteCharAt(sb.length()-1); 
  cookie.setValue(sb.toString());
  System.out.println(cookie.getValue());
  return cookie;
}

我们在浏览器中进行首次访问：

　　

随便点击个连接，可以看到该商品的详细信息（其实浏览器也偷偷将该商品的id以cookie传回了浏览器）：

　　

我们访问商品显示页面再次【刷新】就可以看到刚才浏览过的商品了：

　　

总结

Das obige ist der detaillierte Inhalt vonEine kurze Einführung in Cookies in Servlets in Java (Bilder und Text). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!