很多文章说只要知道某个A请求sessionid，在B请求进来的时候设置

Cookie c2=new Cookie("JSESSIONID", "A请求的id")；

c2.setMaxAge(10000*60);

response.addCookie(c2);

下次回话B在进servlet时，就会用的session时会渠道A的session，这里我在服务器是tomact，验证是不行的。

正确的应该是用

response.setHeader("Set-Cookie", "JSESSIONID="+id+"; Path=/spring-mybatis-mysql; HttpOnly");

id是A的sessionid，path是项目的根路径。

在下次B请求在进来的时候 发现

System.out.println("sessionid==" + session.getId()); 此时是A的session id了，

根据这个思路,可自行设计验证

我是这么验证的，浏览器1：A请求不传id，浏览器2：第一次B请求传id=A的sessionid，第二次，B请求不送id,从第三次可以看出 输出的session1值为A请求设置的session1值。

为什么B第一次请求传id没有呢，因为这时候tomact得到请求时没拿到sessionid，自动生成了一个，第二次请求的最后set-cookie，下次在进来的时候，jession id已经变成了A的sessionid了，至于为什么直接

Cookie c2=new Cookie("JSESSIONID", "A请求的id")；

response.addCookie(c2);

这样不行，我猜可能是浏览器跟tomact底层交互的，这里我还没弄清楚，希望明白的人帮我解答夏

@RequestMapping(value="/testCookieAndSession1.do")
public String testCookieAndSession1(HttpServletRequest request,HttpServletResponse response,String id) throws Exception{
Cookie[] cc=request.getCookies();
if(cc!=null){
for(int i=0;i<cc.length;i++){
System.out.println("##################"+cc[i].getName());
System.out.println("##################"+cc[i].getValue());
}
}
HttpSession session=request.getSession();
System.out.println("the first session1====="+session.getAttribute("session1"));
System.out.println("requestid==" + session.getId());
session.setAttribute("session1", "wuhaojie"+System.currentTimeMillis());

System.out.println("the first second====="+session.getAttribute("session1"));
if(id!=null&&!"".equals(id)){
response.setHeader("Set-Cookie", "JSESSIONID="+id+"; Path=/spring-mybatis-mysql; HttpOnly");
}
return "success";
}

类似关闭浏览器session持久化，还有分布式项目session会话管理 都可以用这种思路解决；

当然在分布式系统下面，session只在A服务器，B服务器必须要根据sessionid去数据库或者缓存服务器里面查出序列化的session

  
  前面说了Cookie，那么为什么还要说Session呢？因为在使用Cookie有一个非常大的局限，就是如果Cookie很多，则无形的增加了客户端与服务端的数据传输量。而且由于浏览器对Cookie数量的限制，注定我们不能再Cookie中保存过多的信息，于是Session出现。
  Session的作用就是在服务器端保存一些用户的数据，然后传递给用户一个名字为JSESSIONID的Cookie，这个JESSIONID对应这个服务器中的一个Session对象，通过它就可以获取到保存用户信息的Session。
那我们具体来看看Session是个什么鬼。
  

1. Session是什么

  Session是jsp中九大内置对象之一。其次Session是一个域对象。Session是在服务器端用来保存用户数据的一种技术。并且Session会话技术是基于Cookie实现的。

2.Session的使用

1.1 Session的创建和获取

Session的创建时机是在request.getSession()方法第一次被调用时。

• 补充：request.getSession()之后的调用都是获取已经创建了的Session对象。

Session被创建后，同时还会有一个名为JSESSIONID的Cookie被创建。
这个Cookie的默认时效就是当前会话。

下面是创建Session和获取Session。以及获取Session的 ID编号，获取Session是否是新创建的示例代码：

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class SessionServlet extends BaseServlet {
	private static final long serialVersionUID = 1L;

	public SessionServlet() {
	}

	protected void getSession(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println(request.getHeader("Cookie"));
		
		// 第一次调用就是创建一个新的Session。如果Session已经创建过。就获取原来的会话。
		HttpSession session = request.getSession();
		// 输出会话id号，和是否是新创建
		// session.getId()返回Session的唯一编号
		// session.isNew()返回当前Session是否是刚创建的
		response.getWriter().write("session ID:" + session.getId() + "<br/>是否是新的：" + session.isNew());
	}
}

在web.xml文件中的配置：

<servlet>
		<servlet-name>SessionServlet</servlet-name>
		<servlet-class>com.javaWeb.servlet.SessionServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>SessionServlet</servlet-name>
		<url-pattern>/sessionServlet</url-pattern>
	</servlet-mapping>

第一次访问的结果：

之后每次访问的结果：

  

2.2 Session的工作原理

  Session被创建后，对应的Cookie被保存到浏览器中，之后浏览器每次访问项目时都会携带该Cookie。

  当我们再次调用时会根据该JSESSIONID获取已经存在的Cookie，而不是再创建一个新的Cookie。

  如果Cookie中有JSESSIONID，但是JSESSIONID没有对应的Session存在，则会重新创建一个HttpSession对象，并重新设置JSESSIONID。

2.3 Session数据的存取

Session域对象数据的存取和其他三个域对象PageContext、Request、ServletContext是一样的。只需要调用下面两个方法：

• setAttribute 设置属性
• getAttribute 获取属性

编写下面的java代码去访问，就可以在Session域中设置属性，和获取属性。

protected void setAttribute(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		// 第一个调用就是获取一个新的Session。如果Session已经创建过。就获取原来的会话。
		HttpSession session = request.getSession();
		// 设置数据
		session.setAttribute("abc", "abc value");
		response.getWriter().write("设置属性值成功！");
	}
	
	protected void getAttribute(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		// 第一个调用就是获取一个新的Session。如果Session已经创建过。就获取原来的会话。
		HttpSession session = request.getSession();
		// 设置数据
		String value = (String) session.getAttribute("abc");
		response.getWriter().write("获取abc的属性值：" + value);
	}

修改session.html 中访问的连接地址，然后点击访问。

<li>
	<a href="sessionServlet?action=setAttribute" target="target">Session域数据的存储</a>
</li>

<li>
	<a href="sessionServlet?action=getAttribute" target="target">Session域数据的获取</a>
</li>

访问后效果图：


  

2.4 Session 的有效时间

基本原则：

  Session对象在服务器端不能长期保存，它是有时间限制的，超过一定时间没有被访问过的Session对象就应该释放掉，以节约内存。所以Session的有效时间并不是从创建对象开始计时，到指定时间后释放。而是从最后一次被访问开始计时，统计其“空闲”的时间。

默认时效：

在tomcat的conf目录下web.xml配置文件中能够找到如下配置：

 <!-- ==================== Default Session Configuration ================= -->
   <!-- You can set the default session timeout (in minutes) for all newly   -->
   <!-- created sessions by modifying the value below.                       -->
 
     <session-config>
         <session-timeout>30</session-timeout>
     </session-config>
 

说明：Session对象默认的最长有效时间为30分钟。

手动设置1：全局：

  也可以在自己工程的web.xml文件中配置Session会话的超时时间为10分钟。在web.xml文件中配置的Session会话超时时间是对所有Session都生效的。

<!-- 设置Session默认的过期时间  -->
<session-config>
	<!-- 以分钟为单位。10分钟超时  -->
    <session-timeout>10</session-timeout>
</session-config>

手动设置2：局部：

• int getMaxInactiveInterval() 获取超时时间。以秒为单位。
• setMaxInactiveInterval (int seconds) 设置用户多长时间没有操作之后就会Session过期。以秒为单位。
  • 如果是正数。表示用户在给定的时间内没有任意操作，Session会话就会过期。
  • 如果是负数。表示Session永不过期。

强制失效：

• invalidate()

示例代码：

Session在3秒之后超时
// 第一个调用就是获取一个新的Session。如果Session已经创建过。就获取原来的会话。
HttpSession session = request.getSession();
// 设置过期时间为3秒 
session.setMaxInactiveInterval(3);

Session在1分钟之后超时
// 第一个调用就是获取一个新的Session。如果Session已经创建过。就获取原来的会话。 
HttpSession session = request.getSession();
// 设置过期时间为1分钟
session.setMaxInactiveInterval(60);

Session在1小时之后超时
// 第一个调用就是获取一个新的Session。如果Session已经创建过。就获取原来的会话。
HttpSession session = request.getSession();
// 设置过期时间为1小时
session.setMaxInactiveInterval(60 * 60);

Session在1天之后超时
// 第一个调用就是获取一个新的Session。如果Session已经创建过。就获取原来的会话。
HttpSession session = request.getSession();
// 设置过期时间为1天
session.setMaxInactiveInterval(60 * 60 * 24);

Session在1周之后超时
// 第一个调用就是获取一个新的Session。如果Session已经创建过。就获取原来的会话。
HttpSession session = request.getSession();
// 设置过期时间为1周
session.setMaxInactiveInterval(60 * 60 * 24 * 7);

Session永远不超时
// 第一个调用就是获取一个新的Session。如果Session已经创建过。就获取原来的会话。
HttpSession session = request.getSession();
// 设置永远不超时
session.setMaxInactiveInterval(-1);

Session马上超时（失效）
// 第一个调用就是获取一个新的Session。如果Session已经创建过。就获取原来的会话。
HttpSession session = request.getSession();
// 让Session对象立即过期
session.invalidate();

2.4 Session对象的释放

1. Session对象空闲时间达到了目标设置的最大值，自动释放。
2. Session对象被强制失效。
3. Web应用卸载。
4. 服务器进程停止。

2.5 Session的活化和钝化

  Session机制很好的解决了Cookie的不足，但是当访问应用的用户很多时，服务器上就会创建非常多的Session对象，如果不对这些Session对象进行处理，那么在Session失效之前，这些Session一直都会在服务器的内存中存在。那么就，就出现了Session活化和钝化的机制。

Session钝化：Session在一段时间内没有被使用时，会将当前存在的Session对象序列化到磁盘上，而不再占用内存空间。

Session活化：Session被钝化后，服务器再次调用Session对象时，将Session对象由磁盘中加载到内存中使用。

  如果希望Session域中的对象也能够随Session钝化过程一起序列化到磁盘上，则对象的实现类也必须实现java.io.Serializable接口。不仅如此，如果对象中还包含其他对象的引用，则被关联的对象也必须支持序列化，否则会抛出异常：java.io.NotSerializableException。

2.6 浏览器和Session关联的技术底层内幕

  在前面的演示中我们发现一旦浏览器关闭之后，我们再去获取Session对象就会创建一个新的Session对象。这是怎么回事呢。现在来看一下这一系列操作过程中的内幕细节。

  通过上图的分析，我们不难发现。当浏览器关闭之后。只是因为浏览器无法再通知服务器，之前创建的Session的会话id是多少了。所以服务器没办法找到对应的Session对象之后，就以为这是第一次访问服务器。就创建了新的Session对象返回。

3.URL重写

  在整个会话控制技术体系中，保持JSESSIONID的值主要通过Cookie实现。但Cookie在浏览器端可能会被禁用，所以我们还需要一些备用的技术手段，例如：URL重写。

  URL重写其实就是将JSESSIONID的值以固定格式附着在URL地址后面，以实现保持JSESSIONID，进而保持会话状态。这个固定格式是：URL;jsessionid=xxxxxxxxx

例如：

targetServlet;jsessionid=F9C893D3E77E3E8329FF6BD9B7A09957

实现方式：

• response.encodeURL(String)

• response.encodeRedirectURL(String)

示例：

//1.获取Session对象
HttpSession session = request.getSession(); 		
//2.创建目标URL地址字符串
String url = "targetServlet";	
//3.在目标URL地址字符串后面附加JSESSIONID的值
url = response.encodeURL(url); 		
//4.重定向到目标资源
response.sendRedirect(url);

HttpSession  和 客户端浏览器： 

 session与浏览器
session保存在服务器，而sessionId通过Cookie发送给客户端，但这个Cookie的生命是-1，即只在浏览器内存中存在，也就是说如果用户关闭了浏览器，那么这个Cookie就丢失了。
当用户再次打开浏览器访问服务器时，就不会有sessionId发送给服务器，那么服务器会认为你没有session，所以服务器会创建一个session，并在响应中把sessionId中到Cookie中发送给客户端。　　　　　
你可能会说，那原来的session对象会怎样？

当一个session长时间没人使用的话，服务器会把session删除了！这个时长在Tomcat中配置是30分钟，可以在${CATALANA}/conf/web.xml找到这个配置，当然你也可以在自己的web.xml中覆盖这个配置！
 

session的其他API

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>


<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>My JSP '01-session.jsp' starting page</title>
    
	<meta http-equiv="pragma" content="no-cache">
	<meta http-equiv="cache-control" content="no-cache">
	<meta http-equiv="expires" content="0">    
	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
	<meta http-equiv="description" content="This is my page">
	<!--
	<link rel="stylesheet" type="text/css" href="styles.css">
	-->

  </head>
  
  <body>
  <%
  	String id=  session.getId();
  	out.println(id);
  	
  	
  	// 获得session 的上次访问的时间： 
  	long time = session.getLastAccessedTime();
  	String timeStrr = new Date(time).toString();
  	out.println(timeStrr);
  	
  	//获得最大的不活动时间“ 
  	int num = session.getMaxInactiveInterval();
  	out.println(num);
  	
  	
  	// session 对象的销毁： 
  	session.invalidate() ;
  	
  	
   %>
  </body>
</html>

URL重写：

如果客户端浏览器禁用cookie，那么调用下面这个方法可以智能判断

客户端禁用cookie： 携带参数

客户端没有禁用：    不携带参数