JavaWeb-完全自学指南

最新推荐文章于 2024-05-09 06:30:00 发布

风落_

最新推荐文章于 2024-05-09 06:30:00 发布

阅读量714

点赞数 5

分类专栏： Java基础文章标签：网络 java 开发语言 JavaWeb

本文链接：https://blog.csdn.net/qq_45523411/article/details/121397176

版权

Java基础专栏收录该内容

34 篇文章 3 订阅

订阅专栏

吹爆狂神老师的 B站课程，狂神哥的课程真的很小白友好了，相信只要学完之后做些项目巩固一下，定能大有裨益！

Java Web

Java Web 是成为一名合格的 Java工程师的一道坎，认真学完这部分可以轻松进入 Spring，加油！

紧急学习，从 Tomcat 开始，持续更新

1. Web基本概念

2. Web服务器

3. Tomcat

3.1 下载安装 tomcat

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

3.2 Tomcat启动和配置

文件夹作用：

启动 / 关闭 Tomcat

访问测试：http://localhost:8080/

可能遇到的问题：

Java 环境变量没有配置
闪退问题：配置兼容性
乱码设置：配置文件中设置

可以配置启动的端口号

tomcat：8080
mysql：3306
http：80
https：443

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

可以配置主机的名称

默认的主机名为：localhost (127.0.0.1)
默认网站应用存放的位置为：webapps

<Host name="www.fengluo.com"  appBase="webapps"
      unpackWARs="true" autoDeploy="true">

面试题：

请谈谈网站是如何进行访问的？

输入一个域名，回车
检查本机的 C:\Windows\System32\drivers\etc\hosts 配置文件下有没有这个域名的映射；
1. 有，直接返回对应的 ip 地址，这个地址中有我们需要访问的 web 程序，可以直接访问
```
127.0.0.1    www.fengluo.com
```
2. 没有，去 DNS 服务器查找，找不到的话就返回未找到 404；

3.3 发布一个 Web 网站

不会就先模仿

将自己写的网站，放到服务器（Tomcat）中指定的web应用文件夹下（webapps）下，就可以访问了

网站应该有的结构

-- webapps: tomcat 服务器的web目录
    -ROOT
    -fengluo: 网站的目录名
        -WEB-INF
          -classes: java程序
          -lib: web应用所依赖的 jar 包
          -web.xml: 网站配置文件
        -index.html 默认的首页
        -static
          -css
              -style.css
          -js
          -img
        -……

4. HTTP

4.1 什么是 HTTP

HTTP，即超文本传输协议（Hyper Text Transfer Protocol）是一个简单的请求-响应协议，通常运行在TCP之上。

文本：html，字符串，~
超文本：图片，音乐，视频，定位，地图，~
80 端口

HTTPS：安全的HTTP协议。

443 端口

4.2 两个时代

HTTP/1.0：客户端可以与web服务器连接后，只能获得一个web资源，断开连接。
HTTP/1.1：客户端可以与web服务器连接后，可以获得多个web资源。

4.3 HTTP请求

客户端 – 发请求（Request） – 服务器

百度：

Request URL: https://www.baidu.com/
Request Method: GET     // Get/Post方法
Status Code: 200 OK		// 状态码：200
Remote Address: 14.215.177.39:443	// 远程

Accept: text/html
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Cache-Control: max-age=0
Connection: keep-alive

请求行

请求行中的请求方式：GET
请求方式：Get，Post
- get：请求能够携带的参数比较少，大小有限制，会在浏览器的URL地址栏显示数据内容，不安全，但高效。
- post：请求能够携带的参数没有限制，大小没有限制，不会在浏览器的URL地址栏显示数据内容，安全，但不高效。

请求头

Accept				// 支持的数据类型
Accept-Encoding		// 编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language		// 语言环境
Cache-Control		// 缓存控制
Connection			// 请求完成时断开还是保持连接
Host				// 主机

4.4 HTTP响应

服务器 – 响应 – 客户端

百度：

Cache-Control: private	// 缓存控制
Connection: keep-alive  // 连接
Content-Encoding: gzip  // 编码

响应体

Accept				// 支持的数据类型
Accept-Encoding		// 编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language		// 语言环境
Cache-Control		// 缓存控制
Connection			// 请求完成时断开还是保持连接
Host				// 主机
Refresh				// 刷新周期
Location			// 让网页重新定位

响应状态码

200：请求响应成功

3xx：请求重定向

重定向：重新定位到新的位置

4xx：找不到资源 404

5xx：服务器代码错误 500、502（网关错误）

常见面试题

当你的浏览器中地址栏输入地址并回车的一瞬间到页面能够展示回来，经历了什么？

5. Maven

为什么要学习这个技术？

在 JavaWeb 开发中，需要使用大量的 jar 包，我们需要手动导入；
如何能够让一个东西自动帮我导入和配置 jar 包；

由此，Maven 诞生了！

5.1 Maven 项目架构管理工具

我们目前就是用来方便导入 jar 包的！

Maven 核心思想：约定大于配置。

有约束，不要违反。

Maven 会规定好如何去编写 Java 代码，必须要按照这个规范来。

5.2 下载安装 Maven

官网下载：https://dlcdn.apache.org/maven/maven-3/3.6.3/binaries/

下载后解压 bin 压缩包。

狂神建议：电脑上的所有环境放在一个文件夹下，方便管理。

5.3 配置环境变量

在我们的系统环境变量中

配置如下：

M2_HOME maven 目录下的 bin 目录
MAVEN_HOME maven 的目录
在 path 中配置 %MAVEN_HOME%\bin

测试 Maven 是否安装成功，保证必须配置完毕！

5.4 阿里云镜像

镜像：mirrors
- 作用：加快下载速度；
国内建议使用阿里云镜像。

<mirror>
	<id>nexus-aliyun</id>
	<mirrorOf>*,!jeecg,!jeecg-snapshots</mirrorOf>
	<name>Nexus aliyun</name>
	<url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>

5.5 本地仓库

在本地计算机的仓库，远程仓库；

建立一个本地仓库：localRepository

<localRepository>D:\Program Files\Java\apache-maven-3.8.2-bin\apache-maven-3.8.2\maven-repo</localRepository>

5.6 在 IDEA 中使用 Maven

启动 IDEA
新建 Maven Web 项目

等待项目初始化完毕

观察 maven 仓库文件夹
IDEA 中的 Maven 设置

到这里，Maven 在 IDEA 的配置和使用就 OK 了！

5.7 创建一个普通的 Maven 项目

纯净 Maven 初始目录

带有Webapp 模板的 Maven 初始目录

5.8 标记文件夹功能

通过右击文件夹

通过 Project Structure

5.9 在 IDEA 中配置 Tomcat（专业版IDEA，推荐大家使用专业版）

如果这里没有找到artifacts，我的解决办法是参照了这篇博客idea配置Tomcat时没有Artifacts选项_Czlcer的博客-CSDN博客

点击绿色小三角，如果浏览器显示 Hello World！代表第一步成功了，一起进军JavaWeb吧！

5.10 pom 文件

pom.xml 是 Maven 的核心配置文件

<?xml version="1.0" encoding="UTF-8"?>

<!--Maven版本和头文件-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <!--这里就是我们刚才配置的GAV-->
  <groupId>org.example</groupId>
  <artifactId>javaweb-01-maven</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!--
    package：项目的打包
    jar：java 应用
    web：javaweb 应用
  -->
  <packaging>war</packaging>

  <name>javaweb-01-maven Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <!--配置-->
  <properties>
    <!--项目的默认构建编码-->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!--编码版本-->
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <!--项目依赖-->
  <dependencies>
    <!--具体依赖的jar包配置文件-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <!--项目构建-->
  <!--在 build 中配置 resource 来防止我们的资源导出失败的问题-->
  <build>
    <finalName>javaweb-01-maven</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

Maven 由于它的约定大于配置，可能会遇到写的配置文件，无法被导出或者生效的问题，解决方案，直接百度就完事儿啦！

<!--在 build 中配置 resource 来防止我们的资源导出失败的问题-->
<build>        
    <resources>            
        <resource>               
            <directory>src/main/resources</directory>              
            <includes>                   
                <include>**/*.properties</include>                 
                <include>**/*.xml</include>              
            </includes>               
            <filtering>true</filtering>           
        </resource>        
        <resource>        
            <directory>src/main/java</directory>            
            <includes>            
                <include>**/*.properties</include>                
                <include>**/*.xml</include>                
            </includes>            
            <filtering>true</filtering>           
        </resource>
    </resources>
</build>

5.11 IDEA 操作

生成目录树，这里可能是因为版本问题？我用的是2021.2.3专业版，没有找到生成目录树的选项，先跳过了

5.12 Maven仓库的使用

官网：https://mvnrepository.com/

6. Servlet

6.1 Servlet简介

Servlet就是sun公司开发动态web的一门技术
sun公司在这些API中提供了一个接口：Servlet，如果你想开发一个Servlet程序，只需要完成两个小步骤：
- 编写一个类，实现Servlet接口
- 把开发好的Java类部署到web服务器中

把实现了Servlet接口的Java程序叫做，Servlet

6.2 HelloServlet

Servlet接口在Sun公司有两个默认的实现类：HttpServlet，GenericServlet

如果是tomcat10，需要更换依赖 jakarta

构建一个普通 Maven 项目，删除src目录，以后学习就在这个项目里面model；这个空的工程就是 Maven 主工程

关于 Maven 父子工程的理解：

父项目中会有

<modules>
    <module>servlet-02</module>
</modules>

子项目中会有

<!--父标签，自然是父项目的一些信息-->
<parent>
  <groupId>org.example</groupId>
  <!--注意：父项目的 artifactId-->
  <artifactId>javaweb-02-servlet</artifactId>
  <version>1.0-SNAPSHOT</version>
</parent>
<!--注意：这里是该子项目的artifactId-->
<artifactId>servlet-01</artifactId>
<packaging>war</packaging>

父项目中的java子项目可以直接使用：son extends father

Maven 环境优化
1. 修改 web.xml 为最新的
2. 将 maven 的结构搭建完整

编写一个 Servlet 程序

编写一个普通类

实现Servlet接口，这里我们直接继承HttpServlet

package com.fengluo;

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

public class HelloServlet extends HttpServlet {

    // 由于 get post 只是实现请求实现的不同方式，可以互相调用，业务逻辑都一样
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        PrintWriter writer = resp.getWriter();  // 响应流
        writer.print("Hello, Servlet");
    }

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

编写Servlet的映射

为什么需要映射：我们写的是Java程序，但是要通过浏览器访问，而浏览器需要连接Web服务器，所以我们需要在Web服务器中注册我们写的Servlet，还需要给它一个浏览器能够访问的路径

在web.xml中配置Servlet

<!--注册Servlet-->
<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.fengluo.HelloServlet</servlet-class>
</servlet>
<!--Servlet的请求路径-->
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

配置 Tomcat
1. 注意：配置项目的发布路径就可以了
启动测试，OK！

6.3 Servlet 原理

Servlet是由web服务器调用，web服务器在收到浏览器请求后

6.4 Mapping

一个Servlet请求可以指定一个映射路径

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

一个Servlet请求可以指定一个映射路径

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello2</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello3</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello4</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello5</url-pattern>
</servlet-mapping>

一个Servlet请求可以指定通用映射路径

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello/*</url-pattern>
</servlet-mapping>

默认请求路径

<!--默认请求路径-->
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

指定一些后缀或者前缀等等……

<!--可以自定义后缀实现请求映射，注意：'*'前面不能加'/'-->
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>*.fengluo</url-pattern>
</servlet-mapping>

优先级问题

指定了固有的映射路径优先级最高，如果找不到就会走默认的处理请求；

<!--404-->
<servlet>
    <servlet-name>error</servlet-name>
    <servlet-class>com.fengluo.ErrorServlet</servlet-class>
</servlet>
<!--Servlet的请求路径-->
<!--可以自定义后缀实现请求映射，注意：'*'前面不能加'/'-->
<servlet-mapping>
    <servlet-name>error</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

6.5 ServletContext

web容器在启动的时候，它会为每个web程序都创建一个对应的ServletContext对象，它代表了当前的web应用，ServletContext位于每个Servlet的顶层；

1. 共享数据

在这个Servlet中保存的数据，可以在另外一个Servlet中使用

package com.fengluo.servlet;

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

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //this.getInitParameter(); // 初始化参数
        //this.getServletConfig(); // Servlet配置
        //this.getServletContext(); // Servlet上下文
        ServletContext context = this.getServletContext();

        String username = "fengluo";
        context.setAttribute("username", username); // 将一个数据保存在 ServletContext 中，名字为：username, 值为：username
    }

}

package com.fengluo.servlet;

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

public class GetServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        String username = (String)context.getAttribute("username");

        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        resp.getWriter().print("名字" + username);
    }

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

    }
}

<!--注册 servlet-->
<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.fengluo.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

<servlet>
    <servlet-name>getc</servlet-name>
    <servlet-class>com.fengluo.servlet.GetServlet</servlet-class>
</servlet>
<servlet-mapping>

测试访问结果；

2. 获取初始化参数

<!--配置一些web应用初始化参数-->
    <context-param>
        <param-name>url</param-name>
        <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>
    </context-param>

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext context = this.getServletContext();

    String url = context.getInitParameter("url");
    resp.getWriter().print(url);
}

3. 请求转发

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext context = this.getServletContext();
    //RequestDispatcher requestDispatcher = context.getRequestDispatcher("/gp"); // 转发的请求路径
    //requestDispatcher.forward(req, resp); // 调用forward实现请求转发

    context.getRequestDispatcher("/gp").forward(req, resp);
    System.out.println("进入了ServletDemo04");
}

4. 读取资源文件

Properties类

在 java 目录下新建 properties
在 resource 目录下新建 properties

发现：都被打包到了同一个路径下 classes，俗称这个路径为 classpath

思路：需要一个文件流

username = fengluo
password = 123456

package com.fengluo.servlet;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class ServletDemo05 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");

        Properties prop = new Properties();
        prop.load(is);
        String username = prop.getProperty("username");
        String password = prop.getProperty("password");

        resp.getWriter().print(username + " " + password);
    }

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

测试访问结果接口

6.6 HttpServletResponse

web 服务器接收到客户端的 http 请求，针对这个请求，分别创建一个代表请求的 HttpServletRequest 对象，代表响应的一个 HttpServletResponse

如果要获取客户端请求过来的参数：找 HttpServletRequest
如果要给客户端响应一些信息：找 HttpServletResponse

1. 简单分类

负责向浏览器发送数据的方法

ServletOutputStream getOutputStream() throws IOException;

PrintWriter getWriter() throws IOException;

负责向浏览器发送响应头的方法

void setCharacterEncoding(String var1);

void setContentLength(int var1);

void setContentLengthLong(long var1);

void setContentType(String var1);

void setDateHeader(String var1, long var2);

void addDateHeader(String var1, long var2);

void setHeader(String var1, String var2);

void addHeader(String var1, String var2);

void setIntHeader(String var1, int var2);

void addIntHeader(String var1, int var2);

响应状态码

int SC_CONTINUE = 100;
int SC_SWITCHING_PROTOCOLS = 101;
int SC_OK = 200;
int SC_CREATED = 201;
int SC_ACCEPTED = 202;
int SC_NON_AUTHORITATIVE_INFORMATION = 203;
int SC_NO_CONTENT = 204;
int SC_RESET_CONTENT = 205;
int SC_PARTIAL_CONTENT = 206;
int SC_MULTIPLE_CHOICES = 300;
int SC_MOVED_PERMANENTLY = 301;
int SC_MOVED_TEMPORARILY = 302;
int SC_FOUND = 302;
int SC_SEE_OTHER = 303;
int SC_NOT_MODIFIED = 304;
int SC_USE_PROXY = 305;
int SC_TEMPORARY_REDIRECT = 307;
int SC_BAD_REQUEST = 400;
int SC_UNAUTHORIZED = 401;
int SC_PAYMENT_REQUIRED = 402;
int SC_FORBIDDEN = 403;
int SC_NOT_FOUND = 404;
int SC_METHOD_NOT_ALLOWED = 405;
int SC_NOT_ACCEPTABLE = 406;
int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
int SC_REQUEST_TIMEOUT = 408;
int SC_CONFLICT = 409;
int SC_GONE = 410;
int SC_LENGTH_REQUIRED = 411;
int SC_PRECONDITION_FAILED = 412;
int SC_REQUEST_ENTITY_TOO_LARGE = 413;
int SC_REQUEST_URI_TOO_LONG = 414;
int SC_UNSUPPORTED_MEDIA_TYPE = 415;
int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
int SC_EXPECTATION_FAILED = 417;
int SC_INTERNAL_SERVER_ERROR = 500;
int SC_NOT_IMPLEMENTED = 501;
int SC_BAD_GATEWAY = 502;
int SC_SERVICE_UNAVAILABLE = 503;
int SC_GATEWAY_TIMEOUT = 504;
int SC_HTTP_VERSION_NOT_SUPPORTED = 505;

2. 常见应用

向浏览器输出消息
下载文件
1. 获取下载文件的路径
2. 下载的文件的文件名
3. 设置让浏览器能够支持下载我们需要下载的文件
4. 获取下载文件的输入流
5. 创建缓冲区
6. 获取 OutputStream 对象
7. 将 FileOutputStream 流写入到 buffer 缓冲区
8. 使用 OutputStream 将缓冲区中的数据输出到客户端！

package com.fengluo.servlet;

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.FileInputStream;
import java.io.IOException;

public class FileServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 1. 获取下载文件的路径
        String realPath = "C:\\Users\\31678\\IdeaProjects\\javaweb-02-servlet\\response\\target\\classes\\1.jpg";
        System.out.println("获取到要下载的文件的路径：" + realPath);
        // 2. 下载的文件的文件名
        String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);
        // 3. 设置让浏览器能够支持下载我们需要下载的文件
        resp.setHeader("Content-Disposition","attachment;filename=" + fileName);
        // 4. 获取下载文件的输入流
        FileInputStream in = new FileInputStream(realPath);
        // 5. 创建缓冲区
        int len = 0;
        byte[] buffer = new byte[1024];
        // 6. 获取 OutputStream 对象
        ServletOutputStream out = resp.getOutputStream();
        // 7. 将 FileOutputStream 流写入到 buffer 缓冲区, 8. 使用 OutputStream 将缓冲区中的数据输出到客户端！
        while ((len = in.read(buffer)) != -1) {
            out.write(buffer, 0, len);
        }
        in.close();
        out.close();
    }

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

3. 验证码功能

验证怎么来的？

前端实现
后端实现，需要用到 java 图片类，生成一个图片

这里的代码太古老了感觉

package com.fengluo.servlet;

import javax.imageio.ImageIO;
import javax.servlet.ServletException;
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;

public class ImageServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 如何让浏览器 3s 自动刷新一次
        resp.setHeader("refresh", "3");

        // 在内存中创建一个图片
        BufferedImage image = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);
        // 得到图片
        Graphics2D g = (Graphics2D) image.getGraphics(); // 笔
        // 设置图片的背景颜色
        g.setColor(Color.WHITE);
        g.fillRect(0, 0, 80, 20);
        // 给图片写数据
        g.setColor(Color.BLUE);
        g.setFont(new Font(null, Font.BOLD, 20));
        g.drawString(makeNum(), 17, 20);

        // 告诉浏览器，这个请求用图片的方式打开
        resp.setContentType("image/jpg");
        // 取消浏览器的缓存策略
        resp.setDateHeader("expires", -1);
        resp.setHeader("Cache-Control", "no-cache");
        resp.setHeader("Pragma", "no-cache");

        // 把图片写给浏览器
        boolean write = ImageIO.write(image, "jpg", resp.getOutputStream());
    }

    // 生成随机数
    private String makeNum() {
        Random random =new Random();
        String num = random.nextInt(9999) + "";
        StringBuffer sb = new StringBuffer();
        // 补零
        for (int i = 0; i < 4 - num.length(); i++) {
            sb.append(random.nextInt(9));
        }
        num = sb.toString() + num;
        return num;
    }

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

4. 实现重定向

B 的一个 web 资源收到客户端A 的请求后，它会通知客户端A 去访问另外一个 web资源C，这个过程就叫做重定向

常见场景：

用户登录

void sendRedirect(String var1) throws IOException;

测试：

package com.fengluo.servlet;

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

public class RedirectServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        /*
            resp.setHeader("Location", "/r/img");
            resp.setStatus(302);
        */
        resp.sendRedirect("/response_war/image"); // 重定向
    }

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

面试题：请你聊聊重定向和转发的区别？

相同点：

页面都会实现跳转

不同点：

请求转发的时候，url 不会产生变化，307
重定向的时候，url 地址栏会发生变化，302

示例 - 简单模拟登录成功重定向

package com.fengluo.servlet;

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

public class RequestTest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 处理请求
        String username = req.getParameter("username");
        String password = req.getParameter("password");

        System.out.println(username + "：" + password);

        // 重定向的时候一定要注意，路径问题，否则就会 404
        resp.sendRedirect("/response_war/success.jsp");
    }

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

index.jsp

<html>
<body>
<h2>Hello World!</h2>

<%--这里提交的路径，需要寻找到项目的路径--%>
<%--${pageContext.request.ContextPath}代表当前项目--%>
<form action="${pageContext.request.contextPath}/login" method="get">
    用户名：<input type="text" name="username"> <br>
    密码：<input type="password" name="password"> <br>
    <input type="submit">
</form>

</body>
</html>

success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>恭喜，打开了 前后端的大门！</h1>
</body>
</html>

6.7 HttpServletRequest

HttpServletRequest 代表客户端的一个请求，用户通过 http 协议访问服务器，HTTP请求中的所有信息会被封装到 HttpServletRequest 中，通过这个 HttpServletRequest 方法，获得客户端的所有信息。

获取参数，请求转发

两个重要的方法

package com.fengluo.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.Array;
import java.util.Arrays;

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");

        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String[] hobbies = req.getParameterValues("hobbies");

        // 后台接收中文乱码问题
        System.out.println("=============================");
        System.out.println(username);
        System.out.println(password);
        System.out.println(Arrays.toString(hobbies));
        System.out.println("=============================");

        //resp.sendRedirect("/r/success.jsp");

        // 通过请求转发
        // 这里的 / 代表当前web路径
        req.getRequestDispatcher("/success.jsp").forward(req, resp);
    }

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

面试题：请你聊聊重定向和转发的区别？

相同点：

页面都会实现跳转

不同点：

请求转发的时候，url 不会产生变化，307
重定向的时候，url 地址栏会发生变化，302

风落_

关注

5
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
JavaWeb-完全自学指南

吹爆狂神老师的 B站课程，狂神哥的课程真的很小白友好了，相信只要学完之后做些项目巩固一下，定能大有裨益！Java WebJava Web 是成为一名合格的 Java工程师的一道坎，认真学完这部分可以轻松进入 Spring，加油！紧急学习，从 Tomcat 开始，持续更新1. Web基本概念2. Web服务器3. Tomcat3.1 下载安装 tomcat官网：https://tomcat.apache.org/3.2 Tomcat启动和配置文件夹作用：启动 / 关闭 Tomca
复制链接

扫一扫