Tomcat和servlet

已于 2022-05-03 22:18:41 修改
阅读量4.4k 收藏 29
点赞数 9
分类专栏： 笔记 文章标签： tomcat java
于 2022-04-30 22:10:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hnhroot/article/details/124518301
版权

Tomcat：
            个人理解就是部署服务端，相当于封装了socketServer，也是遵守了tcp协议，tomcat有如下目录：
      

bin：脚本目录 *****
    启动脚本(启动服务器)：startup.bat
    停止脚本(停止服务器)：shutdown.bat

conf：配置文件目录 (config /configuration) *****
    核心配置文件：server.xml
    用户权限配置文件：tomcat-users.xml
    所有web项目默认配置文件：web.xml

lib：依赖库，tomcat和web项目中需要使用的jar包 *****

logs：日志文件.
    localhost_access_log.txt tomcat记录用户访问信息，..表示时间。
    例如：localhost_access_log.2017-04-28.txt
    
temp：临时文件目录，文件夹内内容可以任意删除。

webapps：默认情况下发布WEB项目所存放的目录。 *****

work：tomcat处理JSP的工作目录。

其中部署的代码就是放到webapps这个我文件中，而且他的包是war包，java的包是jar包，然后如果将war包放到这里面就会自动给这个解压

创建web工程：在idea中创建web工程有两种方式，第一个方式就是使用骨架，第二个方式就是不适用骨架，具体流程如下
      1：使用骨架：
       1）：  
       2）：
 

 3）：
    

 然后将缺失的resource和Java文件手动创建出来就完事儿了

第二种：不使用骨架：
 1）：
     

2）：
   

 3）：
 

 各个目录功能：
     

 然后他会有一个虚拟路径，比如本来是loclhost.8080/路径                    但是刚创建的时候会有一个虚拟路径也会到这里面所以这里要删除一下
 

 这里的运行的四个选项框分别为：
         

 
Servlet：
     Servlet是一个接口（既规范），他是顶级父接口，如果一个类实现了Servlet的接口就必须实现它里面的所有的方法，但是一般就用service这个接口然而却要实现那么多没用的方法，所以他就有个子类，实现了他的子类也就是只需要实现一个service方法就可以了，servlet的子类就是GenericServlet这个class文件，在GenericServlet的还有一个子类HttpServlet，一般都用HttpServlet重写他的doget和dopost即可。tomcat默认是get请求

      域名是怎么找到这个配置的如下图：
      

在核心文件上配置号好这个想要映射的文件，其中有一个servlet-class这个标签里面是一个路径，他在tomcat中使用的是反色技术
Class clazz = Class.forName("全限定名");
Servlet servlet = clazz.newInstance();//实际上HelloServlet对象，向上转型
servlet.service();

然后再调用service这就是为什么上边说的实现了一个Servlet只用service的原因，因为底层只调用了service这个时候，上边代码也说明了被反射的那个类需要有一个无参构造。

原理：
 

1.当我们点击run运行的时候，tomcat之所以会启动，是因为程序入口(main方法)在tomcat中

2.tomcat开始运行，会加载web项目里面的配置文件web.xml(xml解析，读取数据)

​ 主要是根据url-pattern 找到对应的servlet-class

3.然后tomcat进入等待状态(永不停止，除非手动关闭)

4.当用户在浏览器中输入地址：http://localhost:8080/hello就会定位到tomcat的访问的项目下面的某个servlet中

5.tomcat会根据 /hello 的servlet的虚拟路径 找到HelloServlet的全限定名

6.tomcat底层通过反射创建HelloServlet的对象，并调用HelloServlet的service方法：


Servlet的生命周期：是指一个对象从出生到销毁的过程
        当使用实现顶级父类的时候会重写了好多方法，其中就有init方法还有service还有destroy方法，其中init是初始化，也就是说游览器第一次访问的时候会执行这个方法，当游览器第二次来执行的时候就不会再执行这个方法了，他是在无参构造执行以后来执行init这个方法，然后就是执行service方法，如果关闭这个服务就会执行destroy这个方法。


 

继承HttpServlet方式的执行流程：

当访问自定义类的servlet的时候先访问HttpServlet类实现的Servlet接口的service方法，在service方法中调用重载的service，里面两个service，采用了重载，然后根据不同的请求方式执行对应的方法

网页报错问题：
 

1.500错误

​ 服务器异常

2.404错误

​ 找不到资源

3.405错误

​ 如果我们不重写doGet/doPost方法, 那么父类的doGet/doPost方法会执行(继承)，给浏览器响应一个错误: 状态码405 (http1.1)。


使用注解不用web.xml来哦欸之路径：
      

 这个注解其实可以@WebServlet("/路径")，然后网址就能localhost:8080/路径
注解如果都有默认值就可以直接写一个值就可以，就是给里面的value赋值，这里面还有一个值：urlPatterns和value是一样的作用，两个不可一起使用

servlet映射路径一共有四种：
1：完全路径配置：个人理解就是，写的路径就必须是这个路径，写的比较死，例如 <url-pattern>/user/one</url-pattern>，那么网址就必须http://localhost:8080/hello/one这个路径，
2：目录配置：个人理解，就是写将这个名字目录的子目录都可以匹配到这个映射配置，例如<url-pattern>/user/*</url-pattern>，这样http://localhost:8080/hello/user/*  路径随便只要前边一样就行
3：后缀名匹配：*.do *.action 注意这里不能书写/ 访问以.do或者.action结尾的资源路径，后缀名都属于标识 符      <url-pattern>*.do</url-pattern>  这样然后就可以使用网站http://localhost:8080/....*.do   这样就可以使用，只要是结尾是.do的都可以访问这个配置
4：缺省路径：/ 如果上述三种路径都不满足就访问缺省路径。 <url-pattern>/</url-pattern>，然后就可以随便写
上述访问路径的优先级： 完全路径匹配 > 目录匹配 > 后缀名匹配 > 缺省路径

   

在使用tomcat经常使用的是继承HttpServlet，而重写他的service还是doget还是dopost都会带着两个参数
     

//携带HttpServletRequest req, HttpServletResponse resp参数
@WebServlet("/hello")
public class SendRedirect extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setHeader("Content-type", "text/html;charset=UTF-8");
        PrintWriter writer = resp.getWriter();
        writer.write("<a href='www.baidu.com'>中国</a>");

        writer.flush();
    }


//携带ServletRequest servletRequest, ServletResponse servletResponse这个参数
public class Test extends GenericServlet {
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        
    }
}

而上边连个方法中，ServletRequest是HttpServletRequest这个参数的父类，HttpServletRequest是ServletRequest的扩展，主要是说HttpServletRequest有什么用呢？


1. service方法的两个参数request和response是由tomcat创建的
    void service(ServletRequest var1, ServletResponse var2)
2. request 表示请求数据, tomcat将浏览器发送过来的请求数据解析并封装到request对象中
        servlet开发者可以通过request对象获得请求数据
3. response 表示响应数据,服务器发送给浏览器的数据
        servlet开发者可以通过response对象设置响应数据

Request是游览器将请求发送到后台服务器也就是tomcat，然后tomcat根据请求的数据（请求行+请求头+请求体）处理然后解析保存到一个Resquest对象中

Request是请求对象，Response是响应对象,他的请求继承关系如下

所以ServletRequest和HttpServletRequest是继承关系，并且两个都是接口，接口是无法创建对象，这个时候，我们就需要用到Request继承体系中的RequestFacade 。

  • 该类实现了HttpServletRequest接口，也间接实现了ServletRequest接口。

  • Servlet类中的service方法、doGet方法或者是doPost方法最终都是由Web服务器[Tomcat]来调用的，所以Tomcat提供了方法参数接口的具体实现类，并完成了对象的创建

  • 要想了解RequestFacade中都提供了哪些方法，我们可以直接查看JavaEE的API文档中关于ServletRequest和HttpServletRequest的接口文档，因为RequestFacade实现了其接口就需要重写接口中的方法

对于上述结论，要想验证，可以编写一个Servlet，在方法中把request对象打印下，就能看到最终的对象是不是RequestFacade
 

@WebServlet("/demo2")
public class ServletDemo2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println(request);
    }

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

输出的就是org.apache.catalina.connector.RequstFacade@xxxx;说明这是一个多态
Request的继承体系为ServletRequest(最大父接口)-->HttpServletRequest(可以处理http协议的请求接口)-->RequestFacade(tomcat定义的实现类)
Tomcat需要解析请求数据，封装为request对象,并且创建request对象传递到service方法
而对于Request室友很多API，例如：
获取请求方式（get,post这种）:String getMethod()
获取虚拟目录(项目访问路径): String getContextPath()    
获取URL(统一资源定位符): StringBuffer getRequestURL()     
获取URI(统一资源标识符，也就是url后面的地址个人理解): String getRequestURI()   

获取请求体的数据：get和post中get没有请求体，所以他们分别都有可以读取到数据的方法
GET:  String getQueryString()
POST:BufferedReader getReader();
实例代码：
 

@WebServlet("/req1")
public class RequestDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        String result = req.getQueryString();
        System.out.println(result);

    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        BufferedReader br = req.getReader();
        String result = br.readLine();
        System.out.println(result);
    }
}

使用request的getMethod()来获取请求方式，根据请求方式的不同分别获取请求参数值，这样就可以解决上述问题，但是以后每个Servlet都需要这样写代码，实现起来比较麻烦，这种方案我们不采用
request对象已经将上述获取请求参数的方法进行了封装，并且request提供的方法实现的功能更强大，以后只需要调用request提供的方法即可，在request的方法中都实现了哪些操作?

解决方案二:
1：获取所有参数Map集合：Map<String,String[]> getParameterMap()    第一个为key第二个value集合，因为可能会一个key携带多个value
 

/**
 * request 通用方式获取请求参数
 */
@WebServlet("/req2")
public class RequestDemo2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //GET请求逻辑
        System.out.println("get....");
        //1. 获取所有参数的Map集合
        Map<String, String[]> map = req.getParameterMap();
        for (String key : map.keySet()) {  //也可以用map.foreach(key,value->{..})
            // username:zhangsan lisi
            System.out.print(key+":");

            //获取值
            String[] values = map.get(key);
            for (String value : values) {   
                System.out.print(value + " ");
            }

            System.out.println();
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    }
}


2：根据名称获取参数值（数组）：String[] getParameterValues(String name)
 

/**
 * request 通用方式获取请求参数
 */
@WebServlet("/req2")
public class RequestDemo2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //GET请求逻辑
        //...
        System.out.println("------------");
        String[] hobbies = req.getParameterValues("hobby");
        for (String hobby : hobbies) {
            System.out.println(hobby);
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    }
}


3：根据名称获取参数值(单个值)：String getParameter(String name)
       这个和第二种差不多只是这个是获取一个，如果一个key有好几个value那么久获取第一个value的值

解决post请求的问题，因为tomcat默认是ISO-8859-1编码，而游览器是UTF-8，所以会乱码，解决乱码有三种，如下代码：

package com.itheima.sh.web;

import com.itheima.sh.pojo.User;
import com.itheima.sh.service.UserServcie;

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;
import java.net.URLDecoder;
import java.net.URLEncoder;

@WebServlet("/httpServletRequestDemo04Servlet")
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.获取浏览器的请求数据
//        String username = request.getParameter("username");

        /*
            解决post乱码问题有三种方式：
            【1】方式一
                使用URLEncoder类进行编码:static String encode(String s, String enc)
                                参数：
                                    s:编码的字符串
                                    enc:使用编码表
                使用URLDecoder进行解码：static String decode(String s, String enc)
                                参数：
                                    s:解码的字符串
                                    enc:使用编码表
         */
        //1)编码 ： 使用URLEncoder类进行编码:static String encode(String s, String enc)
//        String encodeUsername = URLEncoder.encode(username, "ISO-8859-1");
//        //2)解码：使用URLDecoder进行解码：static String decode(String s, String enc)
//        username = URLDecoder.decode(encodeUsername, "UTF-8");

        /*
             解决post乱码问题有三种方式：
            【2】方式二：
                使用String类中的方法进行编码：    byte[] getBytes(String charsetName)
                                                  参数表示指定的编码表，返回值表示编码后的字节数组
                使用String类中的构造方法进行解码：String(byte[] bytes, String charsetName)
                                                参数：
                                                    bytes：字节数组
                                                    charsetName：表示指定的编码表
                                                返回值：解码后的字符串

         */
        //1)编码 ： 使用String类中的方法进行编码：    byte[] getBytes(String charsetName)
//        byte[] bytes = username.getBytes("ISO-8859-1");
//        //2)解码：使用String类中的构造方法进行解码：String(byte[] bytes, String charsetName)
//        username = new String(bytes, "UTF-8");

        //username = new String(username.getBytes("ISO-8859-1"), "UTF-8");

        /*
            解决post乱码问题有三种方式：
            【3】方式三：
                如果是get请求，tomcat8底层已经帮助我们解决完了，我们只需要解决post乱码即可，但是上述
                两种方式对于post请求可以解决乱码，对于get请求本身获取到的已经是正确的数据，处理
                后又乱码了。
                我们的想法是：get请求不用我们自己书写代码处理乱码，只需要我们书写代码处理post乱码。
                我们接下来学习第三种解决方案：
                只解决来自于请求体数据的乱码。而get请求体没有数据，post请求体含有数据，所以我们可以理解为第三种处理方案只是用来解决
                post乱码的。使用的api是ServletRequest接口中的：
                    void setCharacterEncoding(String env)
                        参数：指定的编码表
                注意：该方式的代码必须书写在获取请求数据之前
         */
        request.setCharacterEncoding("utf-8");//告知tomcat使用UTF-8解码页面请求数据

        //  1.获取浏览器的请求数据
        String username = request.getParameter("username");
        System.out.println("username = " + username);
    }
}

第三种必须要调用参数之前将编码改为utf-8.

request的转发： request.getRequestDispatcher("/req6").forward(request,response);
这个是将游览器的请求转发到指定的路径，getRequestDispatcher的参数是指定的路径，forward是请求和响应参数。而且这个转发也可以携带数据例如：void setAttribute(String name,Object o);这个是写入数据然后一起转到指定的位置，在那个位置也可以调用Object getAttribute(String name);，这个也可以删除：void removeAttribute(String name);，而且转发在游览器的路径还是原本的路径只不过转发给了指定的路径。因为他是重新来一次请求
 

还有一个重定向：他是游览器访问一个路径，然后再返回给游览器比关切状态码是302，然后再去重新访问指定的路径，这个想到与是重新访问了一次路径，所以request的setAtribute的参数携带不过去并且游览器的路径也会变化，调用方法resp.sendRedirect("/指定的路径");注意：这个是响应调用的response，并且需要加虚拟地址

常见的MIME类型：就是文件在tomcat服务器中的文件类型：



超文本标记语言文本 .html      text/html ***
xml文档 .xml                 text/xml
XHTML文档 .xhtml             application/xhtml+xml
普通文本         .txt        text/plain ***
PDF文档 .pdf                 application/pdf
Microsoft Word文件 .word     application/msword
PNG图像 .png              image/png **
GIF图形 .gif                 image/gif
JPEG图形 .jpeg,.jpg         image/jpeg **
 

request生命周期：

1.何时创建?

浏览器第一次访问tomcat服务器的时候

2.谁创建?

tomcat创建

3.创建对象做什么？

浏览器第一次访问tomcat服务器的时候，tomcat创建request对象和response对象，传递给servlet中的service方法，然后我们可以在servlet中使用request对象调用方法获取请求数据(请求行 头 体)，然后处理业务逻辑，处理完毕，然后tomcat将响应数据给浏览器，浏览器接收到响应之后，tomcat立刻销毁request和response对象。





Response是后端处理完以后需要返回结果给游览器，后端将这些数据封装到response对象中，tomcat解析response对象返回给游览器
reponse响应字节数据：

/**
 * 响应字节数据：设置字节数据的响应体
 */
@WebServlet("/resp4")
public class ResponseDemo4 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1. 读取文件
        FileInputStream fis = new FileInputStream("d://a.jpg");
        //2. 获取response字节输出流
        ServletOutputStream os = response.getOutputStream();
        //3. 完成流的copy
        byte[] buff = new byte[1024];
        int len = 0;
        while ((len = fis.read(buff))!= -1){
            os.write(buff,0,len);
        }
        fis.close();
    }

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

 这个和io流一样的
处理字节流也可以使用common-io这个里面的copy

  //1. 读取文件
        FileInputStream fis = new FileInputStream("d://a.jpg");
        //2. 获取response字节输出流
        ServletOutputStream os = response.getOutputStream();
        //3. 完成流的copy
      	IOUtils.copy(fis,os);
        fis.close();

Session和Cookie：
         cookie：就是比如一个游览器访问那个游览器，然后游览器会返回一个cookie值返回出来，给游览器，游览器会保存一个cookie，比如这次访问的localhost:8080这个域名，然后游览器会把cookie和这个域名保存下来，然后如果下次再访问的时候，如果还是这个域名那么游览器就会将这个cookie带过去，而且cookie也有两种，一种是会话级别cookie-就是游览器关闭以后cookie就会消失，一种是持久性cookie-就是有固定，不管游览器怎么关闭都没事但是服务器不能关闭。具体代码如下：
            发送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);
    }
}

然后比如访问localhost:8080/aServlet就会游览器获得到一个cookie，这样是一个会话级别，然后下次只要还是localhost:8080/...就可以得到这个cookie，获得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);
    }
}

localhost:8080/bServlet这样就可以将localhost:8080这个域名的cookie的值取出来
也可以设置持久层：setMaxAge(int seconds)，其中那个seconds就是秒，比如30分钟就是60*30

如果遇到特殊符号 Cookie cookie = new Cookie("msg", "12 34");的那个有空格所以就会出错，这个时候就可以先进行编码然后再去储存到cookie中
 

package com.itheima.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);
    }
}

然后可以得到了就可以String decode = URLDecoder.decode(value, "utf-8");进行解码。

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中存储特殊符号：多含有特殊符号的字符串进行编码和解码使用

Session:session和cookie都是会话技术，也是多次请求之间可以数据共享。
session是储存到服务端，cookie是储存到游览器，所以session就会给服务端造成压力但是他会很安全，第一次请求会判断有没有session，如果没有那么就是会创建一个如果有数据就会再次创建这个对象，然后再给里面添加值；
代码实现：

//HttpSession session = request.getSession(); 如果是第一次执行那么就是创建session对象，如果不是第一次执行就是获取session
//HttpSession getSession(boolean create) ; 参数是true用法和无参用法一样的，如果参数是false表示如果存在session就获取session，不存在则返回null;

//void setAttribute(String name, Object o)   存储数据到 session 域中
//Object getAttribute(String name)    根据 key，获取值
//void removeAttribute(String name)    根据 key，删除该键值对

//储存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);
    }
}

//取出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);
    }
}



下面是原理：

个人理解原理：就是每个游览器每次第一次访问tomcat底层会创建一个会话级别的cookie，然后这个游览器是第一次游览会创建一个JSESSIONID的session容器的id标识符，然后会将这个值储存到cookie，然后下次访问的时候会根据这个tomcat生成的这个cookie的值然后取出来SESSIONID的值然后就会去找服务器内存中的session容器中的对应的id。这样就可以来识别session容器，但是他是会话级别的，所以就会再游览器关闭了以后失去cookie，但是这个cookie如果想要变成持久的，就可以
 

 //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);

这样就会储存下来规定的时间了

 

Session钝化与活化(了解)：

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

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

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

举个例子说明下，

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

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

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

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

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

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

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

答案是肯定的。

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

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

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

代码实现：
序列化：
 

package com.itheima.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.itheima.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());
    }
}

Session销毁：
1：session销毁有两种方式：默认情况下就是30分钟自动销毁，如果没有配置，默认是30分钟，默认值是在Tomcat的web.xml配置文件中写死的。
2：调用Session对象的invalidate()进行销毁
 

@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);
    }
}


Cookie和Session小结：
      

Cookie 和 Session 都是来完成一次会话内多次请求间==数据共享==的。所需两个对象放在一块，就需要思考:

区别:

存储位置：Cookie 是将数据存储在客户端，Session 将数据存储在服务端

安全性：Cookie不安全，Session安全

数据大小：Cookie最大3KB，Session无大小限制

存储时间：Cookie可以通过setMaxAge()长期存储，Session默认30分钟

服务器性能：Cookie不占服务器资源，Session占用服务器资源

应用场景:

购物车:使用Cookie来存储

以登录用户的名称展示:使用Session来存储

记住我功能:使用Cookie来存储

验证码:使用session来存储

  • Cookie是用来保证用户在未登录情况下的身份识别

  • Session是用来保存用户登录后的数据

小白要变大牛
关注
专栏目录
tomcat&Servlet
errortwo的博客
01-28 1589
JavaWeb技术 JavaWeb技术栈 web：全球广域网，也称万维网，能够通过浏览器访问的网站 B/S架构：browser/server，浏览器服务器架构，它的特点是，客户端只需要浏览器，应用程序的逻辑和数据都存储在服务器端。浏览器只需要请求服务器，获取Web资源，服务器把Web资源发送给浏览器即可 好处：易于维护升级，服务器端升级后，客户端无需任何部署就可以使用到新的版本 静态资源：HTML、CSS、JS、图片等。负责页面展现 动态资源：Servlet、JSP等。负责逻辑处理 数据库：负责存储数据
【计算机网络】Tomcat和Servlet基础知识汇总
qq_68993495的博客
11-19 1169
计算机网络之Tomcat和Servlet的基础知识点和手把手的操作实现servlet打印hello world，很想对大家有所帮助！
Web与Tomcat
weixin_40055163的博客
10-18 415
Web与Tomcat 1.1 Web相关概念回顾 1. 软件架构： 1. C/S：客户端/服务器端。 2. B/S：浏览器/服务器端。 2. 资源分类： 1. 静态资源：所有用户访问后，得到的结果都是一样的，称为静态资源.静态资源可以直接被浏览器解析。 如： html,css,JavaScript 2. 动态资源:每个用户访问相同资源后，得到的结果可能不一样。称为动态资源。动态资源被访问后，需要先转换为静态资源，在返回给浏览器。 如：servlet/jsp,php,asp… 资源分类如图所示： 3. 网络通
Tomcat配置及Servlet相关
最新发布
qq_63161848的博客
09-09 1385
Servlet是Java编写的服务器端程序，用于处理HTTP请求和响应。Servlet运行在Web服务器上，可以接收来自客户端的HTTP请求，并生成相应的HTTP响应。Servlet可以动态生成HTML页面、处理表单数据、访问数据库等。
Tomcat & Servlet
二月
01-28 209
文章目录web相关概念回顾web服务器软件常见的java相关的web服务器软件Tomcat：web服务器软件静态项目和动态项目IDEA集成Tomcat，并创建JavaEE项目，部署项目Servlet： server appletServlet快速入门Servlet执行原理Servlet中的生命周期方法Servlet3.0IDEA与tomcat的相关配置 web相关概念回顾 1. 软件架构 1. C/S：客户端/服务器端 2. B/S：浏览器/服务器端 2. 资源分类 1. 静态资源：所有用户访问后
Tomcat&Servlet
Jack_QT的博客
07-24 979
servlet&tomcat
TomCat与Servlet
qq_56454895的博客
06-04 1000
②端口号被占用,Tomcat一般启动绑定俩个端口号8080,8005如果端口号被占用那么Tomcat一定会启动失败,解决方案:关闭开启占用了8080,8005的端口程序,或者给Tomcat换个端口在之前的conf中找到配置文件修改。HTTP服务器是在TCP服务器的基础上,添加了一些额外的功能,让其能够解析请求中的HTTP报文,并将请求转换为结构化数据(对象),方便构造HTTP的响应.①允许我们注册一个类, 在 Tomcat 收到某个特定的 HTTP请求的时候, 执行这个类中的一些代码.
tomcat和servlet的关系详解
weixin_46378497的博客
07-28 1327
web发展介绍 早期web应用就是用户获取服务器端的静态页面，时间一久，用户想要进行一些交互操作，但是如果基于HTTP协议实现服务器端软件增强功能太过 复杂，所以使用像cgi来作为web服务器的扩展机制。用户单击某个链接或输入网址来访问CGI程序，web服务器接收用户请求，运行该CGI程序，对请求进行处理，然后响应并返回给web服务器，web服务器再进行包装返回给用户。cgi程序编写困难，响应时间长，sun公司使用servlet作为java阵营的cgi解决方案。 Servlet Servlet是用java编
tomcat中Servlet的工作机制详细介绍
01-20
在研究Servlet在tomcat中的工作机制前必须先看看Servlet规范的一些重要的相关规定，规范提供了一个Servlet接口，接口中包含的重要方法是init、service、destroy等方法，Servlet在初始化时要调用init方法，在销毁时要...
容器、web容器、tomcat和servlet
Fponyo的博客
07-03 565
Javaweb中常见基础技术和相关概念概念
Tomcat与Servlet初学
zyh661120的博客
08-09 954
一、Tomcat与Servlet之间的关系 Tomcat 是Web应用服务器,是一个Servlet/JSP容器. Tomcat 作为Servlet容器,负责处理客户请求,把请求传送给Servlet,并将Servlet的响应传送回给客户.而Servlet是一种运行在支持Java语言的服务器上的组件. Servlet最常见的用途是扩展Java Web服务器功能,提供非常安全的,可移植的,易于使用的CGI替代品. 二、软件架构 1.软件架构 (1)c/s客户端/服务器端(客户端需要下载相应的应用程序去访
Tomcat与Servlet
black-ant
03-07 989
这同样是个老生常谈的话题，但是看再多也没有自己梳理一遍清楚，而且每过一遍，对于容器的认知就更加清晰，要知道，框架其实就是将这些底层的东西就行了封装，实际上用来用去的还是这些东西。 这一篇主要梳理一下： Tomcat容器 Servlet容器 容器的交互 1.Tomcat容器 Tomcat在开发之中主要作为web容器，其本身完全由Java代码编写，可以用来作为servlet的容器，并且...
TOMCAT和SERVLET
qq_40707269的博客
11-28 274
TOMCAT相当于把整个web项目部署在了tomcat上面， 可以通过虚拟地址访问这个web项目，访问web项目中某些特定的项目 XML文件相当于，把src下面java文件存储到web项目中作为库，然后调用 相当于xml文件是沟通web和java的桥梁 SERVLET相当于一个接口，实现了接口中方法，就实现了web项目和 java进行交互 web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.
tomcat和servlet
yutiannj的专栏
08-29 1001
最好先了解一下tomcat的源码解析，再阅读下面的文字。 Context的部署配置文件web.xml的说明    一个Context对应于一个Web App，每个Web App是由一个或者多个servlet组成的  当一个Web App被初始化的时候，它将用自己的ClassLoader对象载入“部署配置文件web.xml”中定义的每个servlet类 。 1、 它首先载入在$CATALI
Tomcat和Servlet
01-28 144
Tomcat Tomcat是什么,Tomcat是目前市场上主流Web服务器之一,是用Java语言开发的项目。Tomcat支持Servlet和JSP的规范，它由一组嵌套的层次和组件组成。结构如下图 所有组件都实现lifecycle生命周期方法,里面包含了init,start,stop,destroy等方法,用来控制生命周期 Server是Tomcat最顶层的容器，代表着整个服务器...
Servlet和tomcat
qq_37926623的博客
06-08 380
Servlet和tomcat servlet (1) Servlet（Server Applet），全称Java Servlet。是用Java编写的服务器端程序，其主要功能在于交互 式地浏览和修改数据，生成动态Web内容。狭义的Servlet是指Java语言实现的一个接口，广义的 Servlet是指任何实现了这个Servlet接口的类，一般情况下，人们将Servlet理解为后者。 (2) Servlet运行于支持Java的应用服务器中。从实现上讲，Servlet可以响应任何类型的请求，但绝大多
tomcat和servlet的关系
06-09
Tomcat和Servlet之间有密切的关系，因为Tomcat是一个Java Servlet容器，也就是说它可以运行Java Servlet程序。 Servlet是Java编写的一种服务器端程序，它可以接收客户端请求，并返回动态生成的内容，例如HTML网页。Servlet可以通过Java编写，使用Java Servlet API进行编程，它可以在支持Servlet规范的Web服务器上运行，如Tomcat、Jetty等。 Tomcat是一个Web应用服务器，可以运行Java Servlet和Java Server Pages（JSP）程序。Tomcat本身实现了Servlet容器，它可以加载并运行Servlet程序，提供Servlet程序所需的环境和服务，例如请求和响应对象、会话管理、线程池等。Tomcat还实现了Java Servlet规范，这使得开发人员可以使用标准的Servlet API进行编程，而不必担心底层实现细节。 因此，Tomcat和Servlet之间是一种容器和程序的关系，Tomcat作为Servlet容器提供了运行环境和服务，Servlet则是运行在Tomcat中的Java程序，可以响应客户端请求并生成动态内容。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值