从“追求尽量不出错”，到正视“出错是必然”的|
收藏闪存小组博问

如此而已~~~

园龄：3年3个月粉丝：0关注：12

第一天

第一天

HTTP

概念：Hyper Text Transfer Protocol，超文本传输协议，规定了浏览器和服务器之间数据传输的规则

HTTP协议特点：

​ 基于TCP协议：面向连接，安全

​ 基于请求-响应模型的：一次请求对应一次响应

​ HTTP协议是无状态的协议：对于事务处理没有记忆能力。每次请求-响应都是独立的。

​ 缺点：多次请求间不能共享数据。Java中使用会话技术（Cookie、Seesion）来解决这个问题

​ 优点：速度快

HTTP-请求数据格式：

浏览器：开发者工具———NetWork———headers———Request中查看（payload中看请求体）

请求数据分为3部分：

​ 请求行：请求数据的第一行。其中GET表示请求方式，/表示请求资源路径（URL），HTTP/1.1表示协议版本

​ 请求头：第二行开始，格式为key:value形式。

​ 请求体：POST请求的最后一部分，存放请求参数

GET /（表示请求路径） HTTP/1.1
...:...
...:...
User-Agent:Mozilla/5.0Chrome/91.0.4472.106
...
 
//POST请求方式
POST / HTTP/1.1
...:...
...:...
User-Agent:Mozilla/5.0Chrome/91.0.4472.106
//空格隔开
username=superbaby&password=123456

常见的HTTP请求头：

​ Host：表示请求的主机名；

​ User-Agent：浏览器版本，例如Chrome浏览器的标识类似Mozilla/5.0...Chrome/79，IE浏览器的标识类似Mozilla/5.0（Windows NT ...）like Gecko；

​ Accept：表示浏览器能接受的资源类型；

如text/*, image/* 或者 */* 表示所有

​ Accept-Language：表示浏览器偏好的语言，服务器可以据此返回不同的语言的网页；

​ Accept-Encoding：表示浏览器可以支持的压缩文件，例如gzip，deflate等。

GET请求和POST请求区别：

​ 1、GET请求请求参数在请求行中（即跟在第一行的请求路径后），没有请求体。

​ POST请求请求参数在请求体中

​ 2、GET请求请求参数大小有限制，POST没有

HTTP-响应数据格式

响应数据分为3部分：

​ 响应行：响应数据的第一行。其中HTTP/1.1表示协议版本，200表示响应状态码，OK表示状态码描述

​ 响应头：第二行开始，格式为key：value形式

​ 响应体：最后一部分。存放响应数据

常见的HTTP响应头：

​ Content-Type：表示该响应内容的类型，例如text/html，image/jpeg;

​ Content-Length：表示该响应内容长度（字节数）；

​ Content-Encoding：表示该响应压缩算法，例如gzip；

​ Cache-Control：指示客户端应如何缓存，例如max-age=300表示可以最多缓存300秒

HTTP/1.1 200 OK
Server: Tengine
Content-Type:text.html
Transfer-Encoding: chunked...
 
<html>
	<head>
		<title></title>
	</head>
	<body>
	</body>
</html>
状态码分类 说明
1xx 响应中——临时状态码，表示请求已经接受，告诉客户端应该继续请求或者如果它已经完成则忽略它
2xx 成功——表示请求已经被成功接收，处理已完成
3xx 重定向——重定向到其它地方：它让客户端再发起一个请求以完成整个处理。
4xx 客户端错误——处理发生错误，责任在客户端，如：客户端的请求一个不存在的资源，客户端未被授权，禁止访问等
5xx 服务器端错误——处理发生错误，责任在服务端，如：服务端抛出异常，路由出错，HTTP版本不支持等

状态码大全：https://cloud.tencent.com/developer/chapter/13553

常见的状态响应码

状态码 英文描述 解释
200 OK 客户端请求成功，即处理成功，这是我们最想看到的状态码
302 Found 指示所请求的资源已移动到由Location响应头给定的 URL，浏览器会自动重新访问到这个页面
304 Not Modified 告诉客户端，你请求的资源至上次取得后，服务端并未更改，你直接用你本地缓存吧。隐式重定向
400 Bad Request 客户端请求有语法错误，不能被服务器所理解
403 Forbidden 服务器收到请求，但是拒绝提供服务，比如：没有权限访问相关资源
404 Not Found 请求资源不存在，一般是URL输入有误，或者网站资源被删除了
428 Precondition Required 服务器要求有条件的请求，告诉客户端要想访问该资源，必须携带特定的请求头
429 Too Many Requests 太多请求，可以限制客户端请求某个资源的数量，配合 Retry-After(多长时间后可以请求)响应头一起使用
431 Request Header Fields Too Large 请求头太大，服务器不愿意处理请求，因为它的头部字段太大。请求可以在减少请求头域的大小后重新提交。
405 Method Not Allowed 请求方式有误，比如应该用GET请求方式的资源，用了POST
500 Internal Server Error 服务器发生不可预期的错误。服务器出异常了，赶紧看日志去吧
503 Service Unavailable 服务器尚未准备好处理请求，服务器刚刚启动，还未初始化好
511 Network Authentication Required 客户端需要进行身份验证才能获得网络访问权限
Web服务器

​ Web服务器是一个应用程序（软件），对HTTP协议的操作进行封装，使得程序员不必直接对协议进行操作，让Web开发更加便捷。主要功能是“提供网上信息浏览服务”。

Tomcat

1、简介：

​ Tomcat是Apache软件基金会一个核心项目，是一个开源免费的轻量级Web服务器，支持Servlet/JSP少量JavaEE规范。

​ JavaEE：Java Enterprise Edition，Java企业版。指Java企业级开发的技术规范的总和。包含13项技术规范：JDBC、JNDI、EJB、 RMI、JSP、Servlet、XML、JMS、Java IDL、JTS、JTA、JavaMail、JAF。

​ Tomcat也被称为Web容器、Servlet容器。Servlet需要依赖于Tomcat才能运行

​ 官网：https://tomcat.apache.org/

Web服务的作用？

​ 封装HTTP协议操作，简化开发

​ 可以将web项目部署到服务器中，对外提供网上浏览服务

Tomcat是一个轻量级的Web服务器，支持Servlet/JSP少量JavaEE规范，也称Web容器，Servlet容器

2、基本使用：安装、卸载、启动、关闭：

下载：官网下载

安装：绿色版，直接解压即可

卸载：直接删除目录即可

启动：双击 bin\startup.bat

​ 控制台中文乱码（应用默认UTF-8，window默认GBK）：修改conf/logging.properties

​ java.util.logging.ConsoleHandler.encoding = UTF-8 或 GBK

关闭：

​ 直接x掉运行窗口：强制关闭

​ bin\shutdown.bat：正常关闭

​ Ctrl + C：正常关闭

bin 可执行文件存放目录
conf 配置文件存在目录
lib tomcat依赖的jar包
logs 日志文件
temp 临时文件
webapps 应用发布目录
work 工作目录

配置：

修改启动端口号：conf/server.xml

<Connector prot="8080" protocol="HTTP/1.1"
		   connectionTimeout="20000"
		   redirectPort="8443"/>

​ 注：HTTP协议默认端口号为80，如果将Tomcat端口号改为80，则将来访问Tomcat时，将不用输入端口号

启动时可能出现的问题：

​ 端口号冲突：找到对应程序，将其关闭掉

Caused by: java.net.BindException: Address already in use: bind

​ 启动窗口一闪而过：检查Java_HOME环境变量是否正确配置

部署项目：

Tomcat部署项目：

​ 将项目放置到webapps目录下，即部署完成

一般JavaWeb项目会被打包成war包，然后将war包放到webapps目录下，Tomcat会自动压缩war文件

3、IDEA中创建Maven Web项目：

Web项目结构：

Maven Web项目结构：开发中的项目 部署的JavaWeb项目结构：开发完成，可以部署的项目

与JavaMaven相比多了一个与main同级的webapp目录 其中还有Java中的字节码文件和jar包依赖

编译后的Java字节码文件和resources的资源文件，放到WEB-INF下的classes目录下

使用骨架的方式：

​ 骨架：项目模板

1、选择web项目骨架，创建项目

2、删除pom.xml中多余的坐标

3、补齐缺失的目录结构

​ main目录下的Java和resources目录，对应测试目录看自己需要

不使用骨架的方式：

此方式中pom文件更好处理

1、选择web项目骨架，创建项目

​ 其实就是创建一个Java的maven项目，然后修改打包方式，在补齐文件

2、pom.xml中添加打包方式为war

<packaging>war</packaging>

3、补齐缺失的目录结构：webapp

补齐webapp内容：

注意添加的路径如果不符合，就手动修改一下

4、IDEA中使用Tomcat：

集成本地 Tomcat，将本地Tomcat 集成到Idea中，然后进行项目部署即可

这个图片多了，可以自行网上搜索：IEDA集成本地Tomcat

使用Tomcat-Tomcat Maven 插件

注意：当前插件只支持到Tomcat7

1、pom.xml 添加Tomcat插件

<build>
	<plugins>
        <!-- Tomcat插件 -->
    	<plugin>
        	<groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
        </plugin>
    </plugins>
</build>

2、使用Maven Helper插件快速启动项目，选中项目，右键--> Run Maven --> tomcat7:run

参考XML

<!--  通过Alt + Insert来插入的模板  -->
    <build>
        <plugins>
 
            <!--    tomcat 插件    -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <!-- 访问端口号 -->
                    <port>80</port>
                    <!-- 项目访问路径 -->
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
 
    </build>
Servlet

Servlet 是Java提供的一门动态Web资源开发技术

Servlet是JavaEE规范之一，其实就是一个接口，将来我们需要定义Servlet类实现Servlet接口，并由web服务器运行Servlet

快速入门

1、创建web项目，导入Service依赖坐标

<dependency>
	<groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <!-- 依赖范围：编译，测试有效，运行无效（Tomcat自带，运行环境不用打入war包这样不会冲突） -->
    <scope>provided</scope>
</dependency>

2、创建：定义一个类，实现Servlet接口，并重写接口中的所有方法，并在service方法中输入一句话

public class ServletDemo1 implements Servlet{
    public void service(){}
}

3、配置：在类上使用@WebServlet注解，配置该Servlet的访问路径

@WebServlet("demo1")
public class ServletDemo1 implements Servlet{
    ....
}

4、访问：启动Tomcat，浏览器输入URL访问该Servlet

http://localhost:8080/web-demo/demo1

参考代码：

<packaging>war</packaging>
 
<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <java.version>11</java.version>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
 
    <dependencies>
        <!-- 导入servlet依赖坐标，类比JDBC -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <!-- 设置依赖的范围 -->
            <scope>provided</scope>
        </dependency>
    </dependencies>
 
    <build>
        <plugins>
            <!-- tomcat 插件 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
            </plugin>
        </plugins>
    </build>
package com.itheima.web;
 
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import java.io.IOException;
 
//创建一个类实现Servlet接口
 
@WebServlet("/demo1")
public class ServletDemo1 implements Servlet {
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("servlet hello world");
    }
 
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
 
    }
 
    @Override
    public ServletConfig getServletConfig() {
        return null;
    }
 
    @Override
    public String getServletInfo() {
        return null;
    }
 
    @Override
    public void destroy() {
 
    }
}

Servlet执行流程

http://localhost:8080	找到Web服务器
web-demo				找到项目
demo1					Servlet访问路径

当浏览器访问到了Servlet，Tomcat会自动创建一个对象并调用service()方法

1、Servlet对象有谁创建？Servlet方法由谁调用？

​ Servlet对象由web服务器创建，Servlet方法由web服务器调用

2、服务器怎么知道Servlet中一定有service方法？

​ 因为自定义的Servlet，必须实现Servlet接口并复写其方法，而Servlet接口中有service方法

​

Servlet生命周期

对象的生命周期指一个对象从被创建到被销毁的整个过程

Servlet运行在Servlet容器（web服务器）中，其生命周期由容器来管理，分为4个阶段：

​ 1、加载和实例化：默认情况下，当servlet第一次被访问时，由容器创建Servlet对象

@WebServlet(urlPatterns = "/demo", loadOnStartup = 1)
 
//负整数：第一次被访问时创建Servlet对象
//0或正整数：服务器启动时创建Servlet对象，数字越小优先级越高

​ 2、初始化：在Servlet实例化之后，容器将调用Servlet的init()方法初始化这个对象，完成一些如加载配置文件、创建连接等初始化的工作。该方法只调用一次

​ 3、请求处理：每次请求Servlet时，Servlet容器都会调用Servlet的service()方法对请求进行处理。

​ 4、服务终止：当需要释放内存或者容器关闭时，容器就会调用Servlet实例的destroy()方法完成资源的释放。在destroy()方法调用之后，容器会释放这个Servlet实例，该实例随后会被Java的垃圾收集器所回收

//通过刷新浏览器，查看控制台
init...
servlet hello world
servlet hello world
servlet hello world
servlet hello world

在左下角的控制台中输入mvn tomcat7:run可以手动开启tomcat7

在使用ctrl + c可以正常关闭服务器，从而看到destroy()方法的调用

package com.itheima.web;
 
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import java.io.IOException;
 
//创建一个类实现Servlet接口
 
//发现修改后，重启服务器就会自动初始化
@WebServlet(urlPatterns="/demo2", loadOnStartup=1)
public class ServletDemo2 implements Servlet {
 
    /**
     * 初始化方法
     * 1、调用时机：默认情况下，Servlet被第一次访问时，调用
     *      loadOnStartup:
     * 2、调用次数：1次
     * @param servletConfig
     * @throws ServletException
     */
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("init...");
    }
 
    //方法中的两个参数是：请求数据 和 响应数据
 
    /**
     * 提供服务
     * 1、调用时机：每一次Servlet被访问时，调用
     * 2、调用次数：多次
     * @param servletRequest
     * @param servletResponse
     * @throws ServletException
     * @throws IOException
     */
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("servlet hello world");
    }
 
    /**
     * 销毁方法
     * 1、调用时机：内存释放或者服务器关闭的时候，Servlet对象会被销毁，调用
     * 2、调用次数：1次
     * 点击IDEA左下角：Terminal
     * ctrl + c 正常关闭服务器
     */
    @Override
    public void destroy() {
        System.out.println("destroy...");
    }
 
    @Override
    public ServletConfig getServletConfig() {
        return null;
    }
 
    @Override
    public String getServletInfo() {
        return null;
    }
 
}

Servlet方法介绍

初始化方法，在Servlet被创建时执行，只执行一次

void init(ServletConfig config)

提供服务方法，每次Servlet被访问，都会调用该方法

void service(ServletRequest req, ServletResponse res)

销毁方法，当servlet被销毁时，调用该方法。在内存释放或者服务器关闭时销毁Servlet

void destroy()

获取ServletConfig对象

ServletConfig getServletConfig()

获取Servlet信息

String getServletInfo()

Servlet体系结构

Servlet Servlet体系根结构

​ |

GenericServlet Servlet抽象实现类

​ |

HttpServlet 对HTTP协议封装的Servlet实现类（简化了Servlet中只有一个处理方法时，根据HTTP请求方式不同时的 分情况编写代码）

我们将来开发B/S架构的Web项目，都是针对HTTP协议，所以我们定义Servlet，会继承HttpServlet

注意：

​ 使用自定义类继承HttpServlet时候，通过html文件测试表单提交时，路径不符时刷新网页，通过网页的开发者工具查看heml代码是否和IDEA上的一致

参考代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="/web-demo/demo4" method="post">
        <input name="username"><input type="submit">
    </form>
</body>
</html>
package com.itheima.web;
 
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("/demo4")
public class ServletDemo4 extends HttpServlet {
 
    //通过URL访问Servlet时会调用
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       System.out.println("get...");
    }
 
    //通过URL访问对应的html文件（from标签的属性action对应为Sevlet访问路径），提交表单时会调用方法
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("post...");
    }
}

1、HttpServlet中为什么要根据请求方式的不同，调用不同方法？

​ get和post的请求方式，需要不同的逻辑处理，其中还有另外五个doXxx方法目前不涉及

报错信息：
Could not start Tomcat

解决：
检查你新建的servlet类的访问路径有没有写好，还有是否存在重复路径的情况。

自己写一个继承Servlet接口的简化类

package com.itheima.web;
 
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
 
//自己写一个简化的Servlet类
public class MyHttpServlet implements Servlet {
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
 
    }
 
    @Override
    public ServletConfig getServletConfig() {
        return null;
    }
 
    @Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        //根据请求方式的不同，进行分别的处理
 
        HttpServletRequest request = (HttpServletRequest) req;
 
        //1、获取请求方式
        String method = request.getMethod();
 
        //2、判断方式
        if("GET".equals(method)){
            //写GET方式的处理逻辑
            doGet(req, res);
        }else if("POST".equals(method)){
            //写POST方式的处理逻辑
            doPost(req, res);
        }
    }
 
    protected void doPost(ServletRequest req, ServletResponse res) {
    }
 
    //protected 子类可见
    protected void doGet(ServletRequest req, ServletResponse res) {
 
    }
 
    @Override
    public String getServletInfo() {
        return null;
    }
 
    @Override
    public void destroy() {
 
    }
}

2、如何调用？

​ 获得请求方式，进行相应的判断

Servlet urlPattern配置

Servlet想要被访问，必须配置其访问路径（urlPattern）

​ 1、一个Servlet，可以配置多个urlPattern

​ @WebServlet(urlPattern={"/demo1", "/demo2"})

package com.itheima.web;
 
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;
 
/*
    ​1、一个Servlet，可以配置多个urlPattern
 */
@WebServlet(urlPatterns = {"/demo7", "/demo8"})
public class ServletDemo7 extends HttpServlet {
 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("demo7 get...");
    }
 
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
    }
}

​ 2、urlPattern配置规则

​ 注意：当多个匹配条件都符合时，更精确的优先（即范围越小）

​ 精准匹配（一致性）

​ 配置路径：@WebServlet("/user/select")

​ 访问路径：localhost:8080/web-demo/user/select

​ 目录匹配（/*意味着后一个路径不限制）

​ 配置路径：@WebServlet("/user/*")

​ 访问路径：localhost:8080/web-demo/user/aaa 或者 localhost:8080/web-demo/user/bbb

​ 扩展名匹配

​ 配置路径：@WebServlet("*.do")

​ 访问路径：localhost:8080/web-demo/user/aaa.do 或者 localhost:8080/web-demo/user/ddd.do

​ 任意匹配

​ 配置路径：@WebServlet("/") 或者 @WebServlet("/*")

​ 访问路径：localhost:8080/web-demo/user/hehe 或者 localhost:8080/web-demo/user/hehe

/ 和 /* 区别：

​ 当我们的项目中的Servlet配置了”/“，会覆盖掉tomcat中的DefaultServlet，当其他的url-pattern都匹配不上时都会走这个Servlet

​ 当我们的项目中配置了”/*“，意味着匹配任意访问路径

​ 所以：/*的优先级大于/，只有都不匹配才会去使用默认的Servlet

/ 和 /* 会覆盖默认的Servlet，所以尽量不要配置，此处说的是网页无法从web服务器中访问

优先级排序：精确路径 > 目录路径 > 扩展名路径 > /* > /

XML的方式来编写Servlet

Servlet从3.0版本后开始支持使用注解配置，3.0版本前只支持XML配置文件的配置方式

步骤：

​ 1、编写Servlet类

​ 2、在web.xml中配置该Servlet

<!--
        Servlet 全类名
    -->
 
    <servlet>
        <servlet-name>demo13</servlet-name>
        <servlet-class>com.itheima.web.ServletDemo13</servlet-class>
    </servlet>
    <!--
       Servlet 访问路径
   -->
    <servlet-mapping>
        <servlet-name>demo13</servlet-name>
        <url-pattern>/demo13</url-pattern>
    </servlet-mapping><servlet>
	<servlet-name>demo5</servlet-name>
    <servlet-class>com.itheima.web.servlet.ServletDemo5</servlet-class>
</servlet>
<servlet-mapping>
	<servelt-name>demo5</servelt-name>
    <url-pattern>/demo5</url-pattern>
</servlet-mapping>

本文作者：如此而已~~~

本文链接：https://www.cnblogs.com/fragmentary/p/17070083.html

版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   如此而已~~~  阅读(24)  评论(0)  编辑  收藏  举报
历史上的今天：
2022-01-28 C语言的用户自定义函数
    //雪花飘落效果
    点击右上角即可分享
    微信分享提示
    AI IDE Trae
    评论
    收藏
    关注
    推荐
    深色
    回顶
    收起
    ✽
    ✽