在掌握会话的相关概念后，本篇完成一个创建会话的实例。

1. 目标

创建一个新会话，该会话中只有一个进程，就是创建该会话的进程。

2. 思路

创建会话的一个必要条件就是创建会话的进程不能是进程组组长。


  
这样做的理由是：假设该进程是进程组组长，创建完该会话后，该进程成为了其它会话中的 session leader。然而，其组员（如果存在的话）仍然存在于原来的会话中，这将导致同一个进程组中的进程处在不同会话中，显然这是不允许的。


直接在 bash 中执行进程，默认情况下，bash 会将该进程设置为进程组组长。

所以为了防止进程是进程组组长，有两种做法：一、将你的进程加入到当前会话中的其它组中；二、让你的进程 fork 出一个子进程，再 kill 掉父进程（不 kill 也没关系）。

第一种做法通常不太适合，因为你并不知道当前会话中有哪些组；其次，你怎么能随便把你的进程加到其它不相干的组呢？

所以这里就只有第二种做法了。



3. 程序清单

代码
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
  pid_t sid, pid;
  pid = fork();
  if (pid == 0) {
    // 子进程不可能是进程组组长，可以让其创建新的会话，
    // 同时它成为 session leader, group leader

    // 先查看子进程从属于哪个会话
    sid = getsid(getpid());
    printf("sid = %d\n", sid);

    // 让子进程创建新会话
    sid = setsid();
    if (sid < 0) {
      perror("setsid");
    }   
    // 查看子进程当前从属于哪个会话
    printf("sid = %d\n", sid);
  }

  while(1) sleep(1);
  return 0;
}

注意，上面的程序并没有 kill 掉父进程，这不是必须的。但是通常会 kill 掉，因为父进程已经没什么用了，除非你另作它用。

编译和运行
$ gcc session.c -o session
$ ./session

运行结果
 


图1 session 进程运行的结果 


通过使用命令  ps ajx | sed -n '1p;/\/session$/p;/bash/p;/ps ajx/p' 可以查看当前相关的会话。

 


图2 通过命令查看会话 


图 2 中一共显示了 3 个会话，分别是 2874、2294、2925.

我们理一下这些会话之间的关系：

|- session 2874
    |- group 2874
        |- process 2874 [./session](session leader, group leader)
|- session 2294
    |- group 2294
        |- process 2294 [-bash](session leader, group leader)
    |- group 2873
        |- process 2873 [./session](group leader)
|- session 2925
    |- group 2925
        |- process 2925 [-bash](session leader, group leader)
    |- group 3414
        |- process 3414 [ps ajx](group leader)
        |- process 3415 [sed -n ...]

从上面的树型图可以很清晰的理清各个会话、进程组以及进程间的关系。

进程 2874 就是我们 fork 出来的子进程，它创建了一个新的会话 2874，同时任该会话的 session leader，同时也是进程组的组长。注意到进程 2874 已经脱离的终端了，在图 2 中的 TTY 一栏显示的是一个问号。

在会话 2294 中，进程 2294 是 session leader，也就是 bash 进程，我们执行 ./sesion 程序时，就是在这个 bash 中。其中，父进程 2873 仍然还在该会话中。

会话 2925 的 session leader 是 bash 2925 进程，也就是是我们执行命令ps ajx | sed -n '1p;/\/session$/p;/bash/p;/ps ajx/p'的那个地方，该会话中有两个进程组，其中一个进程组就只有 bash 进程组自己，另一个进程组，就是我们执行的命令，该进程组中有两个进程，分别是 ps 和 sed，而 ps 是该进程组的组长。



4. 总结

理解会话
掌握创建会话的方法
理解进程组组长为什么不能创建新会话

  
练习1：完成本文中的实验，分析进程间关系。 

  练习2：直接关闭掉执行 ./sesion 程序的终端，再使用 ps 命令查看结果。

Flask Sessions（会话）

与 Cookie 不同，Session（会话）数据存储在服务器上。会话是客户端登录到服务器并注销服务器的时间间隔。需要在该会话中保存的数据会存储在服务器上的临时目录中。
为每个客户端的会话分配会话 ID。会话数据存储在 cookie 的顶部，服务器以加密方式对其进行签名。对于此加密，Flask 应用程序需要一个定义的 SECRET_KEY。
Session 对象也是一个字典对象，包含会话变量和关联值的键值对。
例如，要设置一个 ‘username’ 会话变量，请使用以下语句：
Session[‘username’] = ’admin’

要释放会话变量，请使用 pop() 方法。
session.pop('username', None)

以下代码是 Flask 中的会话工作的简单演示。URL ‘/’ 只是提示用户登录，因为未设置会话变量 ‘username’。
@app.route('/')
def index():
    if 'username' in session:
        username = session['username']
        return 'Logged in as ' + username + '<br>' + \
               "<b><a href = '/logout'>click here to log out</a></b>"
    else:
        return "You are not logged in <br><a href = '/login'></b>" + \
               "click here to log in</b></a>"


当用户浏览到 “/login” login() 视图函数时，因为它是通过 GET 方法调用的，所以将打开一个登录表单。
表单发送回 ‘/login’，现在会话变量已设置。应用程序重定向到 ‘/’。此时会话变量 ‘username’ 被找到。
@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        session['username'] = request.form['username']
        return redirect(url_for('index'))
    else:
        return '''
   <form action = "" method = "post">
      <p><input type = text name = username /></p>
      <p><input type = submit value = Login /></p>
   </form>'''

应用程序还包含一个 logout() 视图函数，它会弹出 ‘username’ 会话变量。因此，’/’ URL 再次显示开始页面。
@app.route('/logout')
def logout():
   # remove the username from the session if it is there
   session.pop('username', None)
   return redirect(url_for('index'))

运行应用程序并访问主页。（确保设置应用程序的 secret_key ）
from flask import Flask, session, redirect, url_for, escape, request
app = Flask(__name__)
app.secret_key = 'any random string’

输出将显示如下。



点击“点击此处登录”链接，输入 name 并点击登陆。



程序将跳转回首页，并显示登陆信息：



点击退出，程序将清除登陆状态

什么是会话？

  会话可简单理解为：用户开一个浏览器，点击多个超链接，访问服务器多个web资源，然后关闭浏览器，整个过程称之为一个会话。

•会话过程中要解决的一些问题？

–每个用户不可避免各自会产生一些数据，程序要想办法为每个用户保存这些数据。

–例如：用户点击超链接通过一个servlet购买了一个商品，程序应该想办法保存用户购买的商品，以便于用户点结帐servlet时，结帐servlet可以得到用户购买的商品为用户结帐。

•Cookie

–Cookie是客户端技术，程序把每个用户的数据以cookie的形式写给用户各自的浏览器。当用户使用浏览器再去访问服务器中的web资源时，就会带着各自的数据去。这样，web资源处理的就是用户各自的数据了。

•HttpSession

–Session是服务器端技术，利用这个技术，服务器在运行时可以为每一个用户的浏览器创建一个其独享的HttpSession对象，由于session为用户浏览器独享，所以用户在访问服务器的web资源时，可以把各自的数据放在各自的session中，当用户再去访问服务器中的其它web资源时，其它web资源再从用户各自的session中取出数据为用户服务。

总结：cookie存在客户端，session存在服务器端

 通常结合使用。



我们先用sprintboot演示一下cookie和session操作

    @RequestMapping(path = "/cookie/set",method = RequestMethod.GET)
    @ResponseBody
    public String setCookie(HttpServletResponse httpServletResponse){
        Cookie cookie=new Cookie("code", CommunityUtil.generateUUID());
        cookie.setPath("/community/alpha");
        cookie.setMaxAge(60*10);
        httpServletResponse.addCookie(cookie);
        return "set cookie";
    }


    @RequestMapping(path = "/cookie/get",method = RequestMethod.GET)
    @ResponseBody
    public String getCookie(@CookieValue("code") String code){
        System.out.println(code);
        return "get cookie";
    }


    @RequestMapping(path = "/session/set", method = RequestMethod.GET)
    @ResponseBody
    public String setSession(HttpSession session){
        session.setAttribute("id",1);
        session.setAttribute("name","Test");
        return "set session";
    }


    @RequestMapping(path = "/session/get", method = RequestMethod.GET)
    @ResponseBody
    public String getSession(HttpSession session) {
        System.out.println(session.getAttribute("id"));
        System.out.println(session.getAttribute("name"));
        return "get session";
    }

随着服务器要处理的请求越来越多，我们不得不分布式部署，减小服务器压力。

为了负载均衡，我们一般采用nginx来分发请求给各个服务器处理



但是这样session是无法共享的。

（粘性session）

你可以设置nginx的分配策略，下次同一个还让同一个服务器来处理

但是很显然，这就和分布式和nginx初衷违背了：负载很难保证均衡。

（同步session）

一台服务器的session给所有服务器复制一份

第一，性能不好。第二，产生了一定的耦合

（专门session）

专门一台服务器来解决，存session，其它服务器来这个服务器取session再用。



但是也有问题：你这个服务器挂了怎么办？别的服务器都是依赖这个服务器工作的。我们分布式部署本来就是为了解决性能的瓶颈啊。

很容易想到，我们把那个处理session的服务器搞个集群：



更不行，想想就知道，本来就是为了解决分布式部署的问题，你把单独解决session的服务器又搞集群，和之前有什么区别呢？还不如一个服务器存一份简单呢。

（存数据库）



可以，但是传统的关系数据库是存到硬盘里，速度太慢。

（nosql）

最终，我们的主流办法使用nosql数据库，比如redis，来解决这个问题的。

 


JavaWeb之会话技术

会话技术

Cookie：

1. 概念：客户端会话技术，将数据保存到客户端

2. 快速入门：

3. 实现原理

4.注意事项：

5. Cookie的特点和作用

代码实现

Session：

1. 概念：服务器端会话技术，在一次会话的多次请求间共享数据，将数据保存在服务器端的对象中。HttpSession

2. 快速入门：

3. 原理

4. 细节：

5. session的特点

代码实现

session与Cookie的区别：

创作不易，如果本篇博客对您有一定的帮助，大家记得留言+点赞哦。



会话技术

    1. 会话：一次会话中包含多次请求和响应。

           一次会话：浏览器第一次给服务器资源发送请求，会话建立，直到有一方断开为止

    2. 功能：在一次会话的范围内的多次请求间，共享数据

    3. 方式：

          1. 客户端会话技术：Cookie

          2. 服务器端会话技术：Session

Cookie：

1. 概念：客户端会话技术，将数据保存到客户端

2. 快速入门：

            1. 创建Cookie对象，绑定数据

                 new Cookie(String name, String value) 

            2. 发送Cookie对象

                 response.addCookie(Cookie cookie) 

            3. 获取Cookie，拿到数据

                 Cookie[]  request.getCookies()  

3. 实现原理

             基于响应头set-cookie和请求头cookie实现

4.注意事项：

              1.一次可以发送多个cookie。可以创建多个Cookie对象，使用response调用多次addCookie方法发送cookie即可。

              2. cookie在浏览器中保存的保存时间。使用setMaxAge(int seconds)方法可以将Cookie数据写到硬盘的文件中，并指定cookie存活时间

              3. 默认情况下一个tomcat服务器中，部署了多个web项目，那么在这些web项目中cookie不能共享。如果要共享通过setPath(String path)设置当前虚拟目录：path设置为"/"

              4. 不同的tomcat服务器间cookie共享问题？使用setDomain(String path)方法:如果设置一级域名相同，那么多个服务器之间cookie可以共享

5. Cookie的特点和作用

        1. cookie存储数据在客户端浏览器

        2. 浏览器对于单个cookie 的大小有限制(4kb) 以及 对同一个域名下的总cookie数量也有限制(20个)

        a. cookie一般用于存出少量的不太敏感的数据

        b. 在不登录的情况下，完成服务器对客户端的身份识别

代码实现

//记录电脑上次打开网页的时间

@WebServlet("/CookieTest")
public class CookieTest extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //设置响应体格式与编码
        resp.setContentType("text/html;charset=utf-8");
        //获取cookie
        Cookie[] cookies = req.getCookies();
        boolean flag=false;
        //遍历cookie数据
        if (cookies!=null && cookies.length>0){
            for (Cookie cookie : cookies) {
                String name = cookie.getName();
                //判断名称中是否有:lastTime
                if ("lastTime".equals(name)){
                    //设置Cookie的value，下一次使用
                    flag=true;
                    Date date=new Date();
                    SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
                    String str_date = sdf.format(date);
                    //tomcat不支持特殊字符，需要通过URL编码
                    System.out.println("编码前 "+str_date);
                    str_date=URLEncoder.encode(str_date,"utf-8");
                    System.out.println("编码后"+str_date);

                    //新值串回去，设置存活时间
                    cookie.setValue(str_date);
                    cookie.setMaxAge(60*60*24);
                    resp.addCookie(cookie);
                    //有，欢迎光临，上次登录时间
                    String value = cookie.getValue();
                    //URL 解码
                    value=URLDecoder.decode(value,"utf-8");
                    resp.getWriter().write("<h1>欢迎回来，您上一次的访问时间是:"+value+"</h1>");
                    break;
                }
            }
        }
        if (cookies==null || cookies.length==0 || flag==false){
            //第一次访问
            Date date=new Date();
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
            String str_date = sdf.format(date);

            //tomcat不支持特殊字符，需要通过URL编码
            System.out.println("编码前 "+str_date);
            str_date=URLEncoder.encode(str_date,"utf-8");
            System.out.println("编码后"+str_date);

            Cookie cookie=new Cookie("lastTime",str_date);
            //新值串回去，设置存活时间
            cookie.setValue(str_date);
            cookie.setMaxAge(60*60*24);
            resp.addCookie(cookie);

            resp.getWriter().write("<h1>您好，欢迎您首次访问</h1>");
        }

    }
  }

Session：

1. 概念：服务器端会话技术，在一次会话的多次请求间共享数据，将数据保存在服务器端的对象中。HttpSession

2. 快速入门：

        1. 获取HttpSession对象：

            HttpSession session = request.getSession();

        2. 使用HttpSession对象：

            Object getAttribute(String name)  

            void setAttribute(String name, Object value)

            void removeAttribute(String name)  

3. 原理

           Session的实现是依赖于Cookie的。

4. 细节：

        1. 当客户端关闭后，服务器不关闭，两次获取session是否为同一个？

                默认情况下。不是。

                如果需要相同，则可以创建Cookie,键为JSESSIONID，设置最大存活时间，让cookie持久化保存。

                    Cookie c = new Cookie("JSESSIONID",session.getId());

                    c.setMaxAge(60*60);

                    response.addCookie(c);

        2. 客户端不关闭，服务器关闭后，两次获取的session是同一个吗？

            不是同一个，但是要确保数据不丢失。tomcat自动完成以下工作

                  session的钝化： 在服务器正常关闭之前，将session对象系列化到硬盘上

                  session的活化： 在服务器启动后，将session文件转化为内存中的session对象即可。

        3.session什么时候被销毁？

            1. 服务器关闭

            2. session对象调用invalidate() 。

            3. session默认失效时间 30分钟

5. session的特点

           1. session用于存储一次会话的多次请求的数据，存在服务器端

           2. session可以存储任意类型，任意大小的数据

代码实现

@WebServlet("/SessionDemo1")
public class SessionDemo1 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //session
        HttpSession session = request.getSession();
        session.setAttribute("msg","hello session");
        //请求转发(这个是在一个URL中)
        request.setAttribute("reqmsg","hello req.session");
        request.getRequestDispatcher("/SessionDemo3").forward(request,response);


    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            this.doPost(request,response);
    }
}


@WebServlet("/SessionDemo3")
public class SessionDemo3 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       //获取数据
        HttpSession session = request.getSession();
        Object msg = session.getAttribute("msg");
        System.out.println(msg);
        //请求转发
        Object reqmsg = request.getAttribute("reqmsg");
        System.out.println(reqmsg);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            this.doPost(request,response);
    }
}

session与Cookie的区别：

         1.session存储数据在服务器端，Cookie在客户端

         2.session没有数据大小限制，Cookie有

         3.session数据安全，Cookie相对于不安全

         4.session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能,考虑到减轻服务器性能方面，应当使用cookie。

创作不易，如果本篇博客对您有一定的帮助，大家记得留言+点赞哦。