3cookie&session

最新推荐文章于 2024-07-22 15:19:55 发布
最新推荐文章于 2024-07-22 15:19:55 发布
阅读量856 收藏 14
点赞数 35
分类专栏： 3-web 文章标签： 前端 web java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76721962/article/details/136637060
版权 
1.request:处理浏览器向服务器发送请求的数据的（请求行 请求头 请求体）
2.request继承体系：
    	ServletRequest(父接口)==== HttpServletRequest(子接口) === RequestFacade(实现类，tomcat定义)
3.获取请求参数：
    1）Map<String,String[]> getParameterMap();页面中所有的请求参数 name属性值或者key作为map集合的键，提交的数据作为map集合的值
    2）String[] getParameterValues(String name) 获取指定的name的值，是一个数组
    3）String getParameter(String name)获取指定的name的值，一个值
4.处理请求乱码：
    1）
    	URLEncoder.encode(字符串，编码表); 编码
    	URLDecoder.decode(字符串，编码表); 解码
    2）
    	Byte[] 字符串.getBytes("编码表");编码
    	String s = new String(字节数组,编码表);解码
    3)
    	只是解决请求体乱码的，即解决post
    	request.setCharacterEncoding(编码表);
5.请求转发：属于服务器内部跳转。地址不发生改变，只有一次请求一次响应，可以共享request数据
    request.getRequestDispatcher("/loginServlet").forward(request,response); 只要通过浏览器访问必须加虚拟路径day03
		补充：绝对路径：
            	1）http://localhost:8080/day03/loginServlet
				2）/day03/loginServlet 省略三要素，必须加/
                    
                    
6.response:处理服务器响应数据（响应行 响应头 响应体）给浏览器
7.继承体系：
    	ServletResponse(父接口)==== HttpServletResponse(子接口) === ResponseFacade(实现类，tomcat定义)
    
8.响应行：状态码  200 404 500 302 304(从浏览器缓存中获取)
	

9.设置响应头：response.setHeader("content-type","text/html;charset=utf-8") MIME:文件在tomcat服务器中的类型
    		response.setContentType("text/html;charset=utf-8")//告知浏览器文件的MIME类型并解决响应乱码问题
10.响应体：
    	1）响应字符数据：response.getWriter().print();
		2) 响应字节数据：response.getOutputStream()响应字节数据
11.重定向：实现服务器外部跳转，多次请求和响应，不能共享request数据，地址发生改变
            1)
            response.setStatus(302);
			response.setHeader("location","/day03/loginServlet");必须加虚拟路径，因为属于服务器外部，经过浏览器再次向服务器发送请求
                
             2）
                response.sendRedirect("/day03/loginServlet");

会话技术

今日目标

  • 理解什么是会话跟踪技术

  • 掌握Cookie的使用

  • 掌握Session的使用

  • 完善用户登录注册案例的功能

1.会话跟踪技术的概述

对于会话跟踪这四个词，我们需要拆开来进行解释，首先要理解什么是会话，然后再去理解什么是会话跟踪:

  • 会话:用户打开浏览器，访问web服务器的资源，会话建立，直到有一方断开连接，会话结束。在一次会话中可以包含多次请求和响应。

    • 从浏览器发出请求到服务端响应数据给前端之后，一次会话(在浏览器和服务器之间)就被建立了
    • 会话被建立后，如果浏览器或服务端都没有被关闭，则会话就会持续建立着
    • 浏览器和服务器就可以继续使用该会话进行请求发送和响应，上述的整个过程就被称之为会话。

    用实际场景来理解下会话，比如在我们访问京东的时候，当打开浏览器进入京东首页后，浏览器和京东的服务器之间就建立了一次会话，后面的搜索商品,查看商品的详情,加入购物车等都是在这一次会话中完成。

    思考:下图中总共建立了几个会话?

    在这里插入图片描述

    每个浏览器都会与服务端建立了一个会话，加起来总共是3个会话。

  • 会话跟踪:一种维护浏览器状态的方法，服务器需要识别多次请求是否来自于同一浏览器，以便在同一次会话的多次请求间共享数据。

    • 服务器会收到多个请求，多个请求可能来自多个浏览器，如上图中的6个请求来自3个浏览器
    • 服务器需要用来识别请求是否来自同一个浏览器
    • 服务器用来识别浏览器的过程，这个过程就是会话跟踪
    • 服务器识别浏览器后就可以在同一个会话中多次请求之间来共享数据

    那么我们又有一个问题需要思考，一个会话中的多次请求为什么要共享数据呢?有了这个数据共享功能后能实现哪些功能呢?

    • 购物车: 加入购物车和去购物车结算是两次请求，但是后面这次请求要想展示前一次请求所添加的商品，就需要用到数据共享。
      在这里插入图片描述

    • 页面展示用户登录信息:很多网站，登录后访问多个功能发送多次请求后，浏览器上都会有当前登录用户的信息[用户名]，比如百度、京东、码云等。

      在这里插入图片描述

    • 网站登录页面的记住我功能:当用户登录成功后，勾选记住我按钮后下次再登录的时候，网站就会自动填充用户名和密码，简化用户的登录操作，多次登录就会有多次请求，他们之间也涉及到共享数据

      在这里插入图片描述

    • 登录页面的验证码功能:生成验证码和输入验证码点击注册这也是两次请求，这两次请求的数据之间要进行对比，相同则允许注册，不同则拒绝注册，该功能的实现也需要在同一次会话中共享数据。

      在这里插入图片描述

通过这几个例子的讲解，相信大家对会话追踪技术已经有了一定的理解，该技术在实际开发中也非常重要。那么接下来我们就需要去学习下会话跟踪技术，在学习这些技术之前，我们需要思考:为什么现在浏览器和服务器不支持数据共享呢?

  • 浏览器和服务器之间使用的是HTTP协议来进行数据传输
  • HTTP协议是无状态的，每次浏览器向服务器请求时，服务器都会将该请求视为新的请求
  • HTTP协议设计成无状态的目的是让每次请求之间相互独立，互不影响
  • 请求与请求之间独立后，就无法实现多次请求之间的数据共享

分析完具体的原因后，那么该如何实现会话跟踪技术呢? 具体的实现方式有:

(1)客户端会话跟踪技术：Cookie

(2)服务端会话跟踪技术：Session

这两个技术都可以实现会话跟踪，它们之间最大的区别:Cookie是存储在浏览器端而Session是存储在服务器端

具体的学习思路为:

  • CooKie的基本使用、原理、使用细节
  • Session的基本使用、原理、使用细节
  • Cookie和Session的综合案例

小结

在这节中，我们主要介绍了下什么是会话和会话跟踪技术，需要注意的是:

  • HTTP协议是无状态的，靠HTTP协议是无法实现会话跟踪
  • 想要实现会话跟踪，就需要用到Cookie和Session

这个Cookie和Session具体该如何使用，接下来就先从Cookie来学起。

2.Cookie

学习Cookie，我们主要解决下面几个问题:

  • 什么是Cookie?
  • Cookie如何来使用?
  • Cookie是如何实现的?
  • Cookie的使用注意事项有哪些?

2.1 Cookie的基本使用

1.概念

Cookie：客户端会话技术，将数据保存到客户端，以后每次请求都携带Cookie数据进行访问。

Cookie作用：

  • 保存会话的状态
  • cookie将会话的状态保存在浏览器客户端上
  • session是将会话的状态保存在服务器端上

为什么要有cookie和session机制？因为HTTP协议是无状态的，需要通过会话来让他保存数据

2.Cookie的工作流程

在这里插入图片描述

  • 服务端提供了两个Servlet，分别是ServletA和ServletB
  • 浏览器发送HTTP请求1给服务端，服务端ServletA接收请求并进行业务处理
  • 服务端ServletA在处理的过程中可以创建一个Cookie对象并将name=zs的数据存入Cookie
  • 服务端ServletA在响应数据的时候，会把Cookie对象响应给浏览器
  • 浏览器接收到响应数据，会把Cookie对象中的数据存储在浏览器内存中，此时浏览器和服务端就建立了一次会话
  • 在同一次会话中浏览器再次发送HTTP请求2给服务端ServletB，浏览器会携带Cookie对象中的所有数据
  • ServletB接收到请求和数据后，就可以获取到存储在Cookie对象中的数据，这样同一个会话中的多次请求之间就实现了数据共享
  • 注意：cookie是创建在服务器端，存在浏览器端
  • Cookie是由服务器创建,然后通过响应(Response)发送给客户端的一个键值对。客户端会保存Cookie,并会标注出Cookie的来源(哪个服务器的Cookie)
  • 好处：减轻服务器压力，但是不安全。
3.Cookie的基本使用

对于Cookie的使用，我们更关注的应该是后台代码如何操作Cookie，对于Cookie的操作主要分两大类，分别是发送Cookie和获取Cookie,对于上面这两块内容，分别该如何实现呢?

3.1 发送Cookie
  • 创建Cookie对象，并设置数据
Cookie cookie = new Cookie("key","value");
  • 发送Cookie到客户端：使用response对象
response.addCookie(cookie);

介绍完发送Cookie对应的步骤后，接下面通过一个案例来完成Cookie的发送，具体实现步骤为:

需求:在Servlet中生成Cookie对象并存入数据，然后将数据发送给浏览器

1.创建Maven项目,项目名任意，并在pom.xml添加依赖

2.编写Servlet类，名称为AServlet

3.在AServlet中创建Cookie对象，存入数据，发送给前端

4.启动测试，在浏览器查看Cookie对象中的值

(1)创建Maven项目cookie-demo，并在pom.xml添加依赖

<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
</properties>

<dependencies>
    <!--servlet-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

(2)编写Servlet类，名称为AServlet

@WebServlet("/aServlet")
public class AServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

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

(3)在Servlet中创建Cookie对象，存入数据，发送给前端

@WebServlet("/aServlet")
public class AServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //发送Cookie
        //1. 创建Cookie对象
        Cookie cookie = new Cookie("username","zs");
        //2. 发送Cookie，response
        response.addCookie(cookie);
    }

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

（4）启动测试，在浏览器查看Cookie对象中的值

访问http://localhost:8080/cookie-demo/aServlet

chrome浏览器查看Cookie的值，有两种方式,分布式:

方式一:

在这里插入图片描述

方式二:选中打开开发者工具或者 使用快捷键F12 或者 Ctrl+Shift+I

在这里插入图片描述

3.2 获取Cookie
  • 获取客户端携带的所有Cookie，使用request对象
Cookie[] cookies = request.getCookies();
  • 遍历数组，获取每一个Cookie对象：for
  • 使用Cookie对象方法获取数据 [Cookie](…/…/…/javax/servlet/http/Cookie.html#Cookie(java.lang.String, java.lang.String))(String name, String value)
cookie.getName(); 获取Cookie类构造方法的第一个参数 name
cookie.getValue();获取Cookie类构造方法的第二个参数value

介绍完获取Cookie对应的步骤后，接下面再通过一个案例来完成Cookie的获取，具体实现步骤为:

需求:在Servlet中获取前一个案例存入在Cookie对象中的数据

1.编写一个新Servlet类，名称为BServlet

2.在BServlet中使用request对象获取Cookie数组，遍历数组，从数据中获取指定名称对应的值

3.启动测试，在控制台打印出获取的值

(1)编写一个新Servlet类，名称为BServlet

@WebServlet("/bServlet")
public class BServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

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

（2）在BServlet中使用request对象获取Cookie数组，遍历数组，从数据中获取指定名称对应的值

@WebServlet("/bServlet")
public class BServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取Cookie
        //1. 获取Cookie数组
        Cookie[] cookies = request.getCookies();
        //2. 遍历数组
        for (Cookie cookie : cookies) {
            //3. 获取数据
            String name = cookie.getName();
            if("username".equals(name)){
                String value = cookie.getValue();
                System.out.println(name+":"+value);
                break;
            }
        }

    }

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

（3）启动测试，在控制台打印出获取的值

访问http://localhost:8080/cookie-demo/bServlet

在这里插入图片描述

在IDEA控制台就能看到输出的结果:

在这里插入图片描述

==思考:==测试的时候

  • 在访问AServlet和BServlet的中间把关闭浏览器,重启浏览器后访问BServlet能否获取到Cookie中的数据?

这个问题，我们会在Cookie的使用细节中讲，大家可以动手先试下。

小结

在这节中，我们主要讲解了Cookie的基本使用,包含两部分内容

  • 发送Cookie:
    • 创建Cookie对象，并设置值:Cookie cookie = new Cookie(“name”,“value”);
    • 发送Cookie到客户端使用的是Reponse对象:response.addCookie(cookie);
  • 获取Cookie:
    • 使用Request对象获取Cookie数组:Cookie[] cookies = request.getCookies();
    • 遍历数组
    • 获取数组中每个Cookie对象的值:cookie.getName()和cookie.getValue()

介绍完Cookie的基本使用之后，那么Cookie的底层到底是如何实现一次会话两次请求之间的数据共享呢?

2.2 Cookie的原理分析

对于Cookie的实现原理是基于HTTP协议的,其中设计到HTTP协议中的两个请求头信息:

  • 响应头:set-cookie
  • 请求头: cookie

在这里插入图片描述

  • 前面的案例中已经能够实现，AServlet给前端发送Cookie,BServlet从request中获取Cookie的功能
  • 对于AServlet响应数据的时候，Tomcat服务器都是基于HTTP协议来响应数据
  • 当Tomcat发现后端要返回的是一个Cookie对象之后，Tomcat就会在响应头中添加一行数据==Set-Cookie:username=zs==
  • 浏览器获取到响应结果后，从响应头中就可以获取到Set-Cookie对应值username=zs,并将数据存储在浏览器的内存中
  • 浏览器再次发送请求给BServlet的时候，浏览器会自动在请求头中添加==Cookie: username=zs==发送给服务端BServlet
  • Request对象会把请求头中cookie对应的值封装成一个个Cookie对象，最终形成一个数组
  • BServlet通过Request对象获取到Cookie[]后，就可以从中获取自己需要的数据

接下来，使用刚才的案例，把上述结论验证下:

(1)访问AServlet对应的地址http://localhost:8080/cookie-demo/aServlet

使用Chrom浏览器打开开发者工具(F12或Crtl+Shift+I)进行查看响应头中的数据

在这里插入图片描述

（2）访问BServlet对应的地址`http://localhost:8080/cookie-demo/bServlet

使用Chrom浏览器打开开发者工具(F12或Crtl+Shift+I)进行查看请求头中的数据

在这里插入图片描述

2.3 Cookie的使用细节

在这节我们主要讲解两个知识，第一个是Cookie的存活时间，第二个是Cookie如何存储特殊符号，首先来学习下Cookie的存活时间。

2.3.1 Cookie的存活时间

cookie有两种：

​ 1.会话级别的cookie：会话结束，那么cookie消失

​ 2.持久化级别的cookie：当前会话结束，cookie并没有消失，而是保存，下次访问同一个服务器，cookie数据依然存在

前面让大家思考过一个问题:

在这里插入图片描述

(1)浏览器发送请求给AServlet,AServlet会响应一个存有usernanme=zs的Cookie对象给浏览器

(2)浏览器接收到响应数据将cookie存入到浏览器内存中

(3)当浏览器再次发送请求给BServlet,BServlet就可以使用Request对象获取到Cookie数据

(4)在发送请求到BServlet之前，如果把浏览器关闭再打开进行访问，BServlet能否获取到Cookie数据?

注意：浏览器关闭再打开不是指打开一个新的选显卡，而且必须是先关闭再打开，顺序不能变。

针对上面这个问题，通过演示，会发现，BServlet中无法再获取到Cookie数据，这是为什么呢?

  • 默认情况下，Cookie存储在浏览器内存中，当浏览器关闭，内存释放，则Cookie被销毁

这个结论就印证了上面的演示效果，但是如果使用这种默认情况下的Cookie,有些需求就无法实现，比如:

在这里插入图片描述

上面这个网站的登录页面上有一个记住我的功能，这个功能大家都比较熟悉

  • 第一次输入用户名和密码并勾选记住我然后进行登录
  • 下次再登陆的时候，用户名和密码就会被自动填充，不需要再重新输入登录
  • 比如记住我这个功能需要记住用户名和密码一个星期，那么使用默认情况下的Cookie就会出现问题
  • 因为默认情况，浏览器一关，Cookie就会从浏览器内存中删除，对于记住我功能就无法实现

所以我们现在就遇到一个难题是如何将Cookie持久化存储?

Cookie其实已经为我们提供好了对应的API来完成这件事，这个API就是setMaxAge,

  • 设置Cookie存活时间
setMaxAge(int seconds)

参数值为:

1.正数：将Cookie写入浏览器所在电脑 的硬盘，持久化存储。到时间自动删除

2.负数：默认值，表示Cookie不会被存储。Cookie在当前浏览器内存中，当浏览器关闭，则Cookie被销毁

3.零：删除对应Cookie 主要应用这种方式删除浏览器上同名cookie

接下来，咱们就在AServlet中去设置Cookie的存活时间。

@WebServlet("/aServlet")
public class AServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //发送Cookie
        //1. 创建Cookie对象
        Cookie cookie = new Cookie("username","zs");
        //设置存活时间   ，1周 7天
        cookie.setMaxAge(60*60*24*7); //易阅读，需程序计算
		//cookie.setMaxAge(604800); //不易阅读(可以使用注解弥补)，程序少进行一次计算
        //2. 发送Cookie，response
        response.addCookie(cookie);
    }

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

修改完代码后，启动测试，访问http://localhost:8080/cookie-demo/aServlet

  • 访问一个AServlet后，把浏览器关闭重启后，再去访问http://localhost:8080/cookie-demo/bServet,能在控制台打印出username:zs,说明Cookie没有随着浏览器关闭而被销毁
  • 通过浏览器查看Cookie的内容，会发现Cookie的相关信息

在这里插入图片描述

2.3.2 关于cookie中存储特殊字符问题 (理解原理即可)
学习目标
  • 能够向cookie中存储特殊字符
内容讲解

如果直接向cookie中存储特殊字符，例如空格,分号(😉,逗号(,),等号(=)等特殊字符。那么就会出现问题。在向cookie中存储特殊字符之前必须要先进行编码处理，然后从cookie中取出之后在进行解码处理。

【1】向cookie中存储特殊字符问题演示

package com.lystar.sh.b_cookie_02;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/specialCookie01Servlet")
public class SpecialCookie01Servlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        /*
            向cookie中存储特殊字符问题演示
         */
        //1.创建Cookie类的对象
        Cookie cookie = new Cookie("msg", "12 34");
        //2.将cookie存储到浏览器端
        response.addCookie(cookie);
    }
}

在这里插入图片描述

【2】解决向cookie中存储特殊字符的问题

方案：在向cookie中存储特殊字符前进行编码，然后取出之后需要解码。

package com.lystar.sh.b_cookie_02;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLEncoder;

@WebServlet("/specialCookie01Servlet")
public class SpecialCookie01Servlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        /*
            向cookie中存储特殊字符问题演示
         */
        //1.创建Cookie类的对象
//        Cookie cookie = new Cookie("msg", "12 34");报错
        String str = "12 34";
        //编码
        String encode = URLEncoder.encode(str, "utf-8");
        Cookie cookie = new Cookie("msg", encode);
        //2.将cookie存储到浏览器端
        response.addCookie(cookie);
    }
}


package com.lystar.sh.b_cookie_02;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLDecoder;

@WebServlet("/specialCookie02Servlet")
public class SpecialCookie02Servlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.获取浏览器的cookie
        Cookie[] cookies = request.getCookies();
        //2.遍历cookie数组
        for (Cookie cookie : cookies) {
            //3.取出cookie的name
            String cookieName = cookie.getName();
            //4.判断cookieName的值是否是msg
            if("msg".equals(cookieName)){
                //5.取出value
                String value = cookie.getValue();
                //6.解码并输出
                String decode = URLDecoder.decode(value, "utf-8");
                System.out.println(decode);
            }
        }
    }
}
内容小结

1.cookie中不能直接存储特殊字符：空格 分号等，如果存储必须先编码在存储：

 String encode = URLEncoder.encode(str, "utf-8");

2.在获取的时候需要解码：

 String decode = URLDecoder.decode(value, "utf-8");

2.4 cookie小结

  • cookie：创建服务器端，存在浏览器端。减轻服务器压力，但是不安全
  • cookie能够在多次请求的时候实现数据共享的原因：

第一次请求服务器的时候，tomcat服务器将cookie响应给浏览器的时候会设置响应头：set-cookie:name=value.

下次再次向服务器发送请求的时候浏览器会设置请求头：cookie:name=value 将cookie携带到服务器端既可以实现数据的共享

  • cookie的使用：
1.创建cookie对象： new Cookie(name,value)
2.设置cookie为持久化cookie：cookie对象.setMaxAge(秒); 默认是会话级别的，会话结束cookie消失‘
3.响应cookie给浏览器：response.addCookie(cookie);
4.从请求中获取cookie：Cookie[] cookies = request.getCookies();
5.获取cookie的name:cookie对象.getName()
6.获取cookie的value:cookie对象.getValue()
7.向cookie中存储特殊符号：多含有特殊符号的字符串进行编码和解码使用

3.Session

Cookie已经能完成一次会话多次请求之间的数据共享，之前我们还提到过Session也可以实现，那么:

  • 什么是Session?
  • Session如何来使用?
  • Session是如何实现的?
  • Session的使用注意事项有哪些?

3.1 Session的基本使用

1.概念

Session：服务端会话跟踪技术：将数据保存到服务端。

  • Session是存储在服务端而Cookie是存储在客户端
  • 存储在客户端的数据容易被窃取和截获，存在很多不安全的因素
  • 存储在服务端的数据相比于客户端来说就更安全

2.Session的工作流程
在这里插入图片描述

  • 在服务端的AServlet获取一个Session对象，把数据存入其中
  • 在服务端的BServlet获取到相同的Session对象，从中取出数据
  • 就可以实现一次会话中多次请求之间的数据共享了
  • 现在最大的问题是如何保证AServlet和BServlet使用的是同一个Session对象(在原理分析会讲解)?

3.Session的基本使用

在JavaEE中提供了HttpSession接口，来实现一次会话的多次请求之间数据共享功能。

具体的使用步骤为:

  • 获取Session对象,使用的是request对象
HttpSession session = request.getSession();

  • Session对象提供的功能:

    • 存储数据到 session 域中

      void setAttribute(String name, Object o)

    • 根据 key，获取值

      Object getAttribute(String name)

    • 根据 key，删除该键值对

      void removeAttribute(String name)

介绍完Session相关的API后，接下来通过一个案例来完成对Session的使用，具体实现步骤为:

需求:在一个Servlet中往Session中存入数据，在另一个Servlet中获取Session中存入的数据

1.创建名为SessionDemo1的Servlet类

2.创建名为SessionDemo2的Servlet类

3.在SessionDemo1的方法中:获取Session对象、存储数据

4.在SessionDemo2的方法中:获取Session对象、获取数据

5.启动测试

(1)创建名为SessionDemo1的Servlet类

@WebServlet("/demo1")
public class SessionDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    
    }

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

(2)创建名为SessionDemo2的Servlet类

@WebServlet("/demo2")
public class SessionDemo2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    
    }

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

(3)SessionDemo1:获取Session对象、存储数据

@WebServlet("/demo1")
public class SessionDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    	//存储到Session中
        //1. 获取Session对象
        HttpSession session = request.getSession();
        //2. 存储数据
        session.setAttribute("username","zs");
    }

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

(4)SessionDemo2:获取Session对象、获取数据

@WebServlet("/demo2")
public class SessionDemo2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取数据，从session中
        //1. 获取Session对象
        HttpSession session = request.getSession();
        //2. 获取数据
        Object username = session.getAttribute("username");
        System.out.println(username);
    }

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

(5)启动测试，

  • 先访问http://localhost:8080/cookie-demo/demo1,将数据存入Session
  • 在访问http://localhost:8080/cookie-demo/demo2,从Session中获取数据
  • 查看控制台

在这里插入图片描述

通过案例的效果，能看到Session是能够在一次会话中两次请求之间共享数据。

小结

至此Session的基本使用就已经完成了，重点要掌握的是:

  • Session的获取/创建

    HttpSession session = request.getSession();//在一次会话中：第一次执行request.getSession()就是创建session，以后在执行就是获取

  • Session常用方法的使用

    void setAttribute(String name, Object o)
Object getAttribute(String name)

    **注意:**Session中可以存储的是一个Object类型的数据，也就是说Session中可以存储任意数据类型。

介绍完Session的基本使用之后，那么Session的底层到底是如何实现一次会话两次请求之间的数据共享呢?

3.2 Session的原理分析

学习目标
  • 掌握Session的运行原理
内容讲解

在这里插入图片描述

在这里插入图片描述

session实现原理

1.在web服务器中有一个session列表类似于map集合。这个map集合的key存储的是sessionId value存的是对应的session对象

2.用户第一次发起请求的时候：服务器会创建一个新的session对象，同时给session对象生成一个id，然后web服务器会将session的id发送给浏览器。用户再次访问，tomcat中取出session并从cookie中取出之前保存的唯一标识JSESSIONID进行比较查找自己的session容器

3.介绍完Session的原理，我们只需要记住:Session是基于Cookie来实现的

4.session和浏览器没有任何关系，存在服务器端的。

3.3 Session的使用细节

1 浏览器关闭后，session持久化方案(重要)
学习目标
  • 能够掌握浏览器关闭后，为什么持久化session
  • 能够解决session持久化方案
内容讲解

【1】tomcat在创建cookie的时候属于会话级别的cookie，关闭浏览器，cookie消失，下次打开浏览器不会携带之前的cookie即cookie中的JSESSIONID到tomcat服务器中了，那么这样会造成tomcat服务器中会有很多个不能使用的session容器(session依然还在，只是找不到了)。严重的话会造成服务器宕机。

package com.lystar.sh.e_session_05;

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

@WebServlet("/sessionPersis01Servlet")
public class SessionPersis01Servlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.获取session
        HttpSession session = request.getSession();
        System.out.println(session.getId());


    }
}

【2】持久化session来解决上述问题

主要问题是cookie是会话级别的，我们只需要将会话级别的cookie变为持久化级别的即可。

步骤：

1.创建session

2.获取session的JSESSIOID的值

3.创建Cookie ,Cookie(“JSESSIOID”,值)

4.使用cookie对象调用方法setMaxAge()进行cookie的持久化，存活时间建议30min

5.将cookie响应给浏览器

package com.lystar.sh.e_session_05;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;
import java.io.IOException;

@WebServlet("/sessionPersis01Servlet")
public class SessionPersis01Servlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.创建session
        HttpSession session = request.getSession();
        //2.获取session的JSESSIOID的值
        String sessionId = session.getId();
        System.out.println(sessionId);
        //3.创建Cookie ,Cookie("JSESSIOID",值)
        Cookie cookie = new Cookie("JSESSIONID", sessionId);
        //4.使用cookie对象调用方法setMaxAge()进行cookie的持久化，存活时间建议30min
        cookie.setMaxAge(60*30);
        //5.将cookie响应给浏览器
        response.addCookie(cookie);

    }
}
内容小结

1.持久化session就是持久化cookie

2 Session钝化与活化(了解)
学习目标
  • 能够说出什么是Session的钝化与活化技术并且独立完成钝化和活化技术
内容讲解
1.介绍

首先需要大家思考的问题是:

服务器重启后，Session中的数据是否还在?

要想回答这个问题，我们可以先看下下面这幅图，

在这里插入图片描述

(1)服务器端AServlet和BServlet共用的session对象应该是存储在服务器的内存中

(2)服务器重新启动后，内存中的数据应该是已经被释放，对象也应该都销毁了

所以session数据应该也已经不存在了。但是如果session不存在会引发什么问题呢?

举个例子说明下，

(1)用户把需要购买的商品添加到购物车，因为要实现同一个会话多次请求数据共享，所以假设把数据存入Session对象中

(2)用户正要付钱的时候接到一个电话，付钱的动作就搁浅了

(3)正在用户打电话的时候，购物网站因为某些原因需要重启

(4)重启后session数据被销毁，购物车中的商品信息也就会随之而消失

(5)用户想再次发起支付，就会出为问题

所以说对于session的数据，我们应该做到就算服务器重启了，也应该能把数据保存下来才对。

分析了这么多，那么Tomcat服务器在重启的时候，session数据到底会不会保存？

答案是肯定的。

钝化：就是正常关闭tomcat服务器，会将session容器中的数据长久保存到硬盘上。底层原理是序列化。

活化：就是启动tomcat服务器，将之前钝化的session容器读取到内存中。底层原理是反序列化。

注意：

1.由于钝化和活化的原理是序列化和反序列，所以要求存储在session容器中的对象所属类必须实现序列化接口Serializable。

2.演示钝化和活化效果不能在idea中演示，我们需要将当前项目打成war包放到tomcat服务器中的webapps目录下进行演示。

2.钝化和活化的演示

【1】代码：

package com.lystar.sh.b_session_02;

import java.io.Serializable;

public class Product implements Serializable {
    //成员变量
    private String pname;
    private double price;

    public Product(String pname, double price) {
        this.pname = pname;
        this.price = price;
    }

    public String getPname() {
        return pname;
    }

    public void setPname(String pname) {
        this.pname = pname;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Product{" +
                "pname='" + pname + '\'' +
                ", price=" + price +
                '}';
    }
}


package com.lystar.sh.f_session_06;

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

@WebServlet("/setSessionServlet")
public class SetSessionServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8");
        //1.创建session
        HttpSession session = request.getSession();
        //2.获取session的id
        String sessionId = session.getId();
        //3.创建商品对象
        Product p = new Product("笔记本", 9999);
        //4.将商品对象存储到session中
        session.setAttribute("p",p);
        //5.响应数据
        response.getWriter().print("setSessionServlet.....当前JSESSIONID="+sessionId);
    }
}


package com.lystar.sh.f_session_06;

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

@WebServlet("/getSessionServlet")
public class GetSessionServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8");
        //1.获取session
        HttpSession session = request.getSession();
        //2.获取session的id
        String sessionId = session.getId();
        //3.从session中取出商品
        Product p = (Product) session.getAttribute("p");
        //4.响应数据
        response.getWriter().print("getSessionServlet.....当前JSESSIONID="+sessionId+",p="+p.toString());
    }
}

【2】打war包

在这里插入图片描述

7.将上述生成的war包复制到tomcat的webapps目录下：

在这里插入图片描述

8.到tomcat的bin目录下启动tomcat

在这里插入图片描述

注意：这里启动一定将idea中的tomcat关闭。

9.在浏览器中访问servlet

在这里插入图片描述在这里插入图片描述

10.正常关闭tomcat:bin目录下面的shutdown.bat

11.在如下目录生成session的钝化文件：

在这里插入图片描述

12.正常启动tomcat

钝化文件就会被加载到内存，文件自动消失

内容小结

1.钝化：就是正常关闭tomcat服务器，将session中的的数据长久保存到硬盘上，会在work\Catalina\localhost\项目名下生成一个钝化文件。该文件中保存的就是session中的数据。实现原理是序列化。

2.活化：启动tomcat服务器将之前钝化的文件读取内存中，文件会自动消失。原理是反序列化。

3.要求对象所属类必须实现序列化接口Serializable。

3 Session销毁

session的销毁会有两种方式:

  • 默认情况下，无操作，30分钟自动销毁

    • 对于这个失效时间，是可以通过配置进行修改的

      • 在项目的web.xml中配置

        <?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">

    <session-config>
        <session-timeout>10</session-timeout>
    </session-config>
</web-app>

      • 如果没有配置，默认是30分钟，默认值是在Tomcat的web.xml配置文件中写死的

        在这里插入图片描述

  • 调用Session对象的invalidate()进行销毁

    • 在SessionDemo2类中添加session销毁的方法

      @WebServlet("/demo2")
public class SessionDemo2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取数据，从session中

        //1. 获取Session对象
        HttpSession session = request.getSession();
        System.out.println(session);

        // 销毁
        session.invalidate();
        //2. 获取数据
        Object username = session.getAttribute("username");
        System.out.println(username);
    }

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

    • 启动访问测试，先访问demo1将数据存入到session，再次访问demo2从session中获取数据

      在这里插入图片描述

    • 该销毁方法一般会在用户退出的时候，需要将session销毁掉。

Cookie和Session小结

  • Cookie 和 Session 都是来完成一次会话内多次请求间数据共享的。

所需两个对象放在一块，就需要思考:

Cookie和Session的区别是什么?

Cookie和Session的应用场景分别是什么?

  • 区别:
    • 存储位置：Cookie 是将数据存储在客户端，Session 将数据存储在服务端
    • 安全性：Cookie不安全，Session安全
    • 数据大小：Cookie最大3KB，Session无大小限制
    • 存储时间：Cookie可以通过setMaxAge()长期存储，Session默认30分钟
    • 服务器性能：Cookie不占服务器资源，Session占用服务器资源
  • 应用场景:
    • 购物车:使用Cookie来存储
    • 以登录用户的名称展示:使用Session来存储
    • 记住我功能:使用Cookie来存储
    • 验证码:使用session来存储
  • 结论
    • Cookie是用来保证用户在未登录情况下的身份识别
    • Session是用来保存用户登录后的数据

介绍完Cookie和Session以后，具体用哪个还是需要根据具体的业务进行具体分析。

4.用户注册验证码案例

1 需求分析

展示验证码：展示验证码图片，并可以点击切换

在这里插入图片描述

在这里插入图片描述

2.实现步骤

1.创建登录页面login.html

2.定义一个CheckCodeServlet用来生成验证码图片

3.定义一个LoginServlet用来登录时校验验证码是否正确

3.代码实现

1.创建登录页面login.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录页面</title>
</head>
<body>
<h2>登录页面</h2>
<form action="/loginServlet" method="post">
    账号<input type="text" name="username"><br>
    密码<input type="password" name="password"><br>
    验证码<input type="text" name="code">
    <!--页面一加载就向checkCodeServlet发送请求-->
    <img src="/checkCodeServlet" alt="验证码" style="cursor: pointer" onclick="changeCheckCode(this);"><br>
    <input type="submit" value="登录">
</form>
<script type="text/javascript">
    //定义函数更改验证码图片
    //obj 表示img标签对象
    function changeCheckCode(obj) {//obj=this
        /*
            每次点击验证码图片重新向后台checkCodeServlet发送新的请求
            问题：当我们点击验证码图片，发现浏览器并没有向后台发送请求，因为浏览器认为当前发送的请求的路径是同一个，那么浏览器直接将当前浏览器的图片显示了
            解决问题：
            我们可以在请求的路径后面增加一个时间，告知浏览器这是一个新的请求，和原来的请求不一样
         */
        // obj.src = "/checkCodeServlet";//同一个请求，不会发送新的请求
        obj.src = "/checkCodeServlet?t="+new Date().getTime();//每次请求都不一样
    }
</script>
</body>
</html>
2.定义一个CheckCodeServlet用来生成验证码图片
package com.lystar.sh.a_session_checkcode_01;

import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Random;

/*
     说明：验证码是一张图片，而这个图片中的内容是使用代码生成的。
        分析和步骤：
        1）创建一个可以存放图片的缓冲区BufferedImage作为画布；
        2）通过画布获取到针对这个画布的画笔；
        3）修改画布的背景颜色为白色；
        4）设置画布的边框，画边框的时候需要注意下，如果这里写画布的宽width和高height ，就会超出画布就会看不见，所以width和height 分别-1；
        5）创建一个获取随机数的对象；
        6）给画布上写数据；
        7）给画布上画干扰线；
        8）需要把画布中的内容响应给浏览器；ImageIO.write(bi,"JPG",response.getOutputStream());
 */
@WebServlet("/checkCodeServlet")
public class CheckCodeServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //定义画布的宽和高
        int width = 120;
        int height = 30;
        //创建一个可以存放图片的缓冲区，作为画布
        //BufferedImage.TYPE_INT_RGB 表示生成图片的类型
        BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        //通过画布获取到针对这个画布的画笔
        Graphics g = bi.getGraphics();
        //修改画布的背景颜色  每次使用画笔的时候都得给画笔指定颜色
        g.setColor(Color.WHITE);
        //填充画布
        g.fillRect(0, 0, width, height);
        //设置画布的边框
        //给画笔指定颜色
        g.setColor(Color.RED);
        //给画布画边框 如果这里写width height 就会超过画布，因为边框也会占一个像素，所以这里宽和高都需要-1
        g.drawRect(0, 0, width - 1, height - 1);
        //创建一个获取随机数的对象
        Random r = new Random();
        //给画布上画干扰线
        //循环控制画多条线
        for (int i = 1; i <= 3; i++) {
            //设置画笔的颜色
            g.setColor(new Color(r.nextInt(255), r.nextInt(255), r.nextInt(255)));
            //向画布上画干扰线
            //drawLine(x1, y1, x2, y2) 这里四个参数是因为两个点画成一条线
            g.drawLine(r.nextInt(width), r.nextInt(height), r.nextInt(width), r.nextInt(height));
        }
        //定义数据准备向画布中写数据
        String data = "abcdefghigklmnpqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ123456789";
        //创建字符串缓冲区
        StringBuilder sb = new StringBuilder();

        //循环控制画四个字符
        for (int i = 1; i <= 4; i++) {
            //设置画笔的颜色 Color.BLUE这里的颜色固定了，只能是蓝色，我们可以让颜色随机变化
//			g.setColor(Color.BLUE);
            g.setColor(new Color(r.nextInt(255), r.nextInt(255), r.nextInt(255)));
            //设置字体  Font.ITALIC表示斜体
            g.setFont(new Font("宋体", Font.ITALIC, 20));
            //给画布上写内容 20表示从x轴的位置开始书写 25表示y轴位置开始书写
//			g.drawString("哈哈哈哈", 20, 25);
            /*
             * data.charAt()表示根据函数的参数进行查找字符
             * data.length()表示字符串的长度
             * r.nextInt()表示生成随机数，但是随机数的范围在0~data字符串的长度
             */
            String str = data.charAt(r.nextInt(data.length())) + "";
            g.drawString(str, 20 * i, 25);
            //将验证码内容拼接到字符串缓冲区中
            sb.append(str);
        }
        //  验证码保存到session中
        request.getSession().setAttribute("checkcode", sb.toString());
        //将生成的验证码图片响应给浏览器
        ImageIO.write(bi, "JPG", response.getOutputStream());
    }
}
3.定义一个LoginServlet用来登录时校验验证码是否正确
package com.lystar.sh.a_session_checkcode_01;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/loginServlet")
public class LoginServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.处理post请求乱码
        request.setCharacterEncoding("utf-8");
        //2.获取用户名和密码以及输入框的验证码
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        //页面的输入框的验证码
        String input_code = request.getParameter("code");
        //3.从session中获取验证码图片
        // request.getSession().setAttribute("checkcode", sb.toString());
        String session_checkcode = (String) request.getSession().getAttribute("checkcode");
        //4.比较从session中获取的验证码和从页面获取的验证码是否相等：
        if(input_code!=null && input_code.equalsIgnoreCase(session_checkcode)){
            //相等：将用户名和密码传递到dao层向数据库查询
            System.out.println("验证码校验通过");
        }else{
            //不相等：响应给浏览器客户端提示验证码输入有误
            System.out.println("验证码校验没有通过");
        }
    }
}
内容小结

1.验证码校验整体思路：

​ 1）页面一加载就向CheckCodeServlet发送请求获取验证码图片上的验证码

​ 2）每次点击验证码图片重新向CheckCodeServlet发送请求获取验证码图片上的验证码

​ 3）点击登录按钮将输入框输入的验证码和后台存储到session中的验证码进行比较

2.通过验证码案例我们知道session的应用场景，可以在多次请求中共享session中的数据

5. MVC模式和三层架构

MVC 模式和三层架构是一些理论的知识，将来我们使用了它们进行代码开发会让我们代码维护性和扩展性更好。

5.1 MVC模式

MVC 是一种分层开发的模式，其中：

  • M：Model，业务模型，处理业务
  • V：View，视图，界面展示
  • C：Controller，控制器，处理请求，调用模型和视图
    在这里插入图片描述

控制器（serlvlet）用来接收浏览器发送过来的请求，控制器调用模型（JavaBean）来获取数据，比如从数据库查询数据；控制器获取到数据后再交由视图（JSP）进行数据展示。

MVC 好处：

  • 职责单一，互不影响。每个角色做它自己的事，各司其职。
  • 有利于分工协作。
  • 有利于组件重用

5.2 三层架构

三层架构是将我们的项目分成了三个层面，分别是 表现层、业务逻辑层、数据访问层。
在这里插入图片描述

  • 数据访问层：对数据库的CRUD基本操作
  • 业务逻辑层：对业务逻辑进行封装，组合数据访问层层中基本功能，形成复杂的业务逻辑功能。例如 注册业务功能 ，我们会先调用 数据访问层 的 selectByName() 方法判断该用户名是否存在，如果不存在再调用 数据访问层 的 insert() 方法进行数据的添加操作
  • 表现层：接收请求，封装数据，调用业务逻辑层，响应数据

而整个流程是，浏览器发送请求，表现层的Servlet接收请求并调用业务逻辑层的方法进行业务逻辑处理，而业务逻辑层方法调用数据访问层方法进行数据的操作，依次返回到serlvet，然后servlet将数据交由 JSP 进行展示。

三层架构的每一层都有特有的包名称：

  • 表现层： com.lystar.controller 或者 com.lystar.web
  • 业务逻辑层：com.lystar.service
  • 数据访问层：com.lystar.dao 或者 com.lystar.mapper

后期我们还会学习一些框架，不同的框架是对不同层进行封装的
在这里插入图片描述

5.3 MVC 和 三层架构

通过 MVC 和 三层架构 的学习，有些人肯定混淆了。那他们有什么区别和联系？

在这里插入图片描述

如上图上半部分是 MVC 模式，上图下半部分是三层架构。 MVC 模式 中的 C（控制器）和 V（视图）就是 三层架构 中的表现层，而 MVC 模式 中的 M（模型）就是 三层架构 中的 业务逻辑层 和 数据访问层。

可以将 MVC 模式 理解成是一个大的概念，而 三层架构 是对 MVC 模式 实现架构的思想。 那么我们以后按照要求将不同层的代码写在不同的包下，每一层里功能职责做到单一，将来如果将表现层的技术换掉，而业务逻辑层和数据访问层的代码不需要发生变化。

ly_stars
关注
  • 35
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day16_cookie&session源代码.zip
11-03
在IT行业中，尤其是在Web开发领域，Cookie和Session是两种非常重要的技术，用于管理用户状态和保持会话。这里我们深入探讨这两个概念以及它们在Java Web中的应用。 首先，Cookie是客户端存储的小型文本文件，由...
Cookie&Session
12-22
总结，Cookie和Session都是用来跟踪用户状态的技术，它们各有优缺点。Cookie适合存储较小量的数据，且数据存储在客户端，减轻服务器负担，但可能受到浏览器的限制。而Session存储在服务器端，数据安全性较高，但随着...
cookie&session.pdf
03-05
一天掌握cookie&session技术。基本使用+技术原理分析+session的应用场+案例 免费下载 - cookie&session.pdf
Cookie&Session笔记.md
05-25
cookie$session
前端面试题日常练-day97 【Less】
qq_44640575的博客
07-20 435
border-radius()函数用于在Less中生成圆形边框效果。通过设置border-radius()函数，我们可以为元素的边框添加圆角效果，使边框呈现圆形的外观，从而美化页面元素的边框样式。
python爬虫基础——Webbot库介绍
最新发布
qq_56262770的博客
07-22 610
Webbot是一个专为Python设计的库，用于简化网页自动化任务。它基于Selenium WebDriver，提供了一系列高级接口，使自动化任务更加直观和易于管理。Webbot库的设计理念是将复杂的网页交互抽象为简单的API调用，从而减少开发者在编写自动化脚本时的工作量。Webbot库的核心功能包括自动化表单填写、点击操作、数据抓取等，同时支持处理JavaScript渲染的页面和模拟用户行为。这些功能使得Webbot库成为自动化测试、数据收集和网页监控等领域的理想选择。
LG 选择 Flutter 来增强其智能电视操作系统 webOS
恋猫de小郭的博客
07-17 1803
总的来说，LG 是 Flutter 在 TV 领域的一次新的尝试，并且它是在脱离了 Android 平台的场景下实现的支持，虽然 webOS 并不是什么流行的系统，但是这也体现出了 Flutter 的特点：可以用较低的成本实现较好性能的跨平台。后续，在 LG 的主导下，WebOS 经过进一步修改，转变为智能电视操作系统，于是 WebOS TV 就诞生了，此后 LG 的 TV 基本路线定为 webOS ，在应用层面，WebOS TV 以基于 Web 的技术为基础。然后 LG 为什么选择 webOS？
纯前端小游戏，4096小游戏，有音效，Html5，可学习使用
m0_62996549的博客
07-18 527
【代码】纯前端小游戏，4096小游戏，有音效，Html5，可学习使用。
前端性能优化--懒加载
weixin_43799793的博客
07-19 177
3、同时还可结合 lazy loading 属性，利用浏览器的原生属性，进一步优化图片加载，不过其延迟加载机制完全是由浏览器自身决定的，在不同浏览器上效果不同(BTW，部分浏览器可能并不支持)。2、然后对元素进行监听，当图片进入可视区域时，提取元素的 data-src 即真实的图片地址赋值给 src 属性，就会去发送请求加载图片，实现了懒加载。设置为 1 张 1px*1px 的透明图片用作占位符，以防止出现出错图标。TinyPNG 网站: https://tinypng.com/
[web]-反序列化-绕过__wakeup(转)
mails2008的专栏
07-18 397
终点：很直接是echo $flag,在__destruct中，username==='admin' 和 password==100。反序列化过程中发现起点在终点之前调用，反而是捣乱的，那我们就不需要自动执行__wakeup，绕过的方法，设置的字段数量比实际字段大的值。其实简单的很简单，难得也很难，慢慢学习就好，没必要焦虑，觉得很难，纯粹一个兴趣爱好就行。起点：_wakeup函数中是$this->username='guest',是给赋值；按照常规思路，寻找起点、终点、跳板。
谷粒商城实战笔记-35-前端基础-ES6-模块化
epitomizelu的专栏
07-20 492
模块化就是把代码进行拆分，方便重复利用。类似 java 中的导包：要使用一个包，必须先导包。JS 中没有包的概念，JS中类似的概念是模块。export和import。export命令用于规定模块的对外接口。import命令用于导入其他模块提供的功能。
Web Pages 表单
07-20 291
Web pages 表单是现代网页设计中不可或缺的组成部分，它们允许用户与网站进行交互，提交信息，如注册、登录、反馈、预订等。表单的设计和功能对用户体验和网站的业务目标有着直接的影响。本文将深入探讨Web pages表单的各个方面，包括设计原则、常用元素、验证机制和最佳实践。
前端小项目-强调鼠标悬停时效果的名片
关注收藏，可以私信解决问题！
07-19 1064
在学习完HTML和CSS之后，我们就可以开始做一些小项目了。本篇文章所讲的小项目为——动态效果名片。通过这个项目，你将学会如何使用HTML和CSS来创建一个具有动态效果的名片。
web前端 React 框架面试200题（三）
柯晓楠
07-21 421
纯组件是可以编写的最简单和最快的组件。它们可以替换任何只有 render() 的组件。这些组件增强了代码的简单性和应用程序的性能。Context 通过组件树提供了一个传递数据的方法，从而避免了在每一个层级手动的传递 props 属性在JSX表达式中，一个开始标签(比如)和一个关闭标签(比如)之间的内容会作为一个特殊的属性props.children被自动传递给包含着它的组件。
Linux上的系统服务——DNS、WEB、NFS 和 AutoFS 服务的详细配置步骤
qq_68600196的博客
07-17 724
现有主机 node01 和 node02，完成如下需求：1、在 node01 主机上提供 DNS 和 WEB 服务2、dns 服务提供本实验所有主机名解析3、web服务提供 www.rhce.com 虚拟主机4、该虚拟主机的documentroot目录在 /nfs/rhce 目录5、该目录由 node02 主机提供的NFS服务共享6、该目录可以通过autofs服务实现自动挂载7、所有服务应该在重启之后依然可以正常使用。
前端使用webSocket与后台建立连接并进行心跳监测机制
On the way
07-18 529
2.在页面初始化的时候调用getWebSocket此方法。首先项目中需要引入websocket。
【芯片设计- RTL 数字逻辑设计入门 番外篇 12 -- SoC 设计中的 ECO】
CodingCos的博客
07-17 637
在芯片设计中，ECO，工程变更订单）是一个关键的环节，用于在芯片设计后期对设计进行必要的调整和优化。ECO通常应用于数字芯片的版图设计，它是对设计的layout进行局部的小范围修改和重新布线的过程，而不影响设计的其他部分的布局布线。ECO的目的是为了节省时间和成本，特别是在芯片设计的后期阶段，当RTL（寄存器传输级）代码冻结后，通过ECO来修正设计中的问题。
了解 JSON Web 令牌 (JWT)
技术探索驿站
07-18 684
在现代 Web 开发领域，确保客户端和服务器之间的通信安全至关重要。JSON Web Tokens (JWT) 已成为确保安全高效数据交换的流行解决方案。本文将深入探讨 JWT 是什么、它们的工作原理以及它们为何对于 Web 应用程序中的安全身份验证和授权至关重要。JSON Web Token (JWT) 是一种紧凑且 URL 安全的表示双方之间传输声明的方式。
vue3前端开发-小兔鲜项目-一级页面banner图渲染
yrldjsbk的博客
07-19 360
其实，首页的banner渲染代码可以拿来复用的，只是区别在于，传递的接口参数不一样而已。我们的一级页面就可以成功拿到了后端接口反馈过来的一级栏目的banner图信息了。我们增加了一个参数对象params.而且做好了默认值的设置。（用的是一种解构赋值的模式）1：改造一下之前的获取banner的接口调用函数，增加一个参数对象。2：把之前HomeBanner.vue里面的代码，拿过来，在template里面新增banner的渲染模块内容。写好默认的值1.（不赋值的情况下，就是这个默认值1）3：修改完善页面内容。
Cookie与Session的原理与安全对比
3. 对于敏感信息，如密码，应避免直接存储在cookie中，而应存储在服务器端的session中，并通过安全的通信协议传输。 总结来说，cookie和session各有优劣，适用于不同的应用场景。cookie适合存储较小量且非敏感的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值