JavaWeb基础入门_javaweb localhost 500

一、Web相关概念

1.1、软件架构：

• C/S：Client / Server 客户端/服务器

  • 在用户本地有一个客户端程序，在远端有一个服务器端程序
    • 如：QQ、迅雷…
  • 特点：
    • 充分发挥客户端PC的处理能力，很多数据可以通过客户端的处理后再发给服务器，降低了服务器的负荷，提高了速度。但维护和升级比较复杂，维护和升级是针对成千上万的客户机的。
    • 必须安装专用的客户端软件。客户端是成千上万的，要安装专用软件，是多么大的工作量，如果一台客户机出现了问题，如：感染病毒、计算机故障等等原因，都需要进行安装或维护。系统软件需要升级的时候，每一台客户机都需要重新安装系统软件，维护和升级成本相当的高。
    • 对客户机的操作系统有限制，对一些操作系统和新开发的操作系统不兼容。目前产品更新换代十分的快，要针对不同的操作系统系统版本开发不同的客户机软件，对成本而言是相当大

• B/S: Browser/Server 浏览器/服务器端

  • 只需要一个浏览器，用户通过不同的网址 ( URL ) ，客户访问不同的服务端程序
    • 如：淘宝、京东…
  • 特点：
    • 维护和升级简单，我们只要对服务器端进行维护和升级即可，不需要对成千上万的客服端进行维护和升级，减少了人力资源成本。
    • 随时随地都可以访问，只要有一台连接互联网和安装了浏览器的计算机就可以访问。
    • 减轻了客户端电脑载荷，客户端电脑只要运行少部分程序就能实现。因此对客服端电脑要求不高，对服务器端负荷较重，由于主要的功能都集中到了服务器端，因此对服务器要求高，但总体而言，还是大大降低了成本。

• 总结：B/S对C/S而言，B/S具有的优势。

  • 分布性：可以随时随地进行查询和浏览等业务；
  • 功能业务扩展比较方便：增加服务器的功能，就能增加浏览器端的功能；
  • 维护简单方便：改变服务器端数据即可以实现所有用户同步更新；
  • 开发简单，共享性强，成本低，数据可以持久存储在服务器端而不必担心数据的丢失

---

1.2 Web资源分类：

• 静态资源：

  • 使用静态网页开发技术发布的资源
  • 特点：
    • 所有用户访问，得到的结果是一样的。如：文本、图片、音频、视频、HTML、CSS、JavaScript
    • 如果用户请求的是静态资源，那么服务器会直接将静态资源发送给浏览器。浏览器中内置了静态资源的解析引擎，可以展示静态资源。

• 动态资源：

  • 使用动态网页技术发布的资源
  • 特点：
    • 所有用户访问，得到的结果可能不一样。如：jsp / servlet、php、asp…
    • 如果用户请求的是动态资源，那么服务器会执行动态资源，转换为静态资源，再发送给浏览器

---

1.3、Web资源请求：

---

二、Web服务器软件

2.1 Web服务器软件概念：

服务器：安装了服务器软件的计算机。

服务器软件：接收用户的请求，处理请求，做出响应。

web服务器软件：接收用户的请求，处理请求，做出响应。

在web服务器软件中，可以部署web项目，让用户通过浏览器来访问这些项目。

---

2.2 常见的Web服务器软件

• webLogic：oracle公司，大型的JavaEE服务器，支持所有的JavaEE规范，收费的。
• webSphere：IBM公司， 大型的JavaEE服务器，支持所有的JavaEE规范，收费的。
• JBOSS：JBOSS公司的，大型的JavaEE服务器，支持所有的JavaEE规范，收费的。
• Tomcat：Apache基金组织，中小型的JavaEE服务器，仅仅支持少量的JavaEE规范servlet/jsp。开源的，免费的

---

2.3 Tomcat：Web服务器软件

Tomcat免费的Web服务器，该服务器支持全部JSP以及Servlet规范，也是我们学习javaweb所使用的服务器，所以我们有必要深入了解;

2.3.1 下载：

可以直接在官网下载：http://tomcat.apache.org/

2.3.2 安装：

解压压缩包即可。

注意：安装目录建议不要有中文和空格,解压的目录结构如下图

2.3.3 卸载：

删除目录即可

2.3.4 启动：

bin/startup.bat ,双击运行该文件即可

访问：浏览器输入：http://localhost:8080 回车访问自己

​ http://别人的ip:8080 访问别人

显示如下界面表示成功

启动时可能遇到的问题：

1. 黑窗口一闪而过：

   1. 原因： 没有正确配置JAVA_HOME环境变量
   2. 解决方案：正确配置JAVA_HOME环境变量

2. 端口号被占用：
   
   暴力解决：找到占用的端口号，并且找到对应的进程，杀死该进程

   1. 使用命令netstat –ano|findstr [指定端口号]找到占用端口的进程
   2. 打开任务管理器->查看->选择列->然后勾选PID选项，回到任务管理器上可以查看到对应的pid，然后结束进程

3. 温柔解决：修改自身的端口号

在conf/server.xml 配置文件中修改

<Connector port="8888" protocol="HTTP/1.1"
  	    connectionTimeout="20000"
     	    redirectPort="8445" />
1
2
3

2.3.5 关闭：

• 正常关闭：
  • bin/shutdown.bat
  • ctrl+c
• 强制关闭：
  • 点击启动窗口的 ×

2.3.6 Tomcat项目部署（虚拟路径映射）：

Web应用开发好后，若想供外界访问，需要把web应用所在目录交给web服务器管理，这个过程称之为项目部署（虚拟目录的映射）。

• 配置conf/server.xml文件, 在<Host>标签体中加入子标签配置

   <!--<Context  path="虚拟路径"   docBase ="物理路径" />-->
   <Context docBase="D:\hello" path="/xixi" /> 
  1
  2

  • docBase:项目存放的路径

  • path：虚拟目录

• 直接将项目放到webapps目录下即可

  • /hello：项目的访问路径–>虚拟目录
  • 简化部署：将项目打成一个war包，再将war包放置到webapps目录下。 war包会自动解压缩。

• 在conf\Catalina\localhost创建任意名称的xml文件。在文件中编写

  <!--<Context docBase="虚拟路径"/> -->
  <Context docBase="D:\hello" />
  1
  2

---

三、利用开发工具开发Web应用程序

3.1、Idea开发Web应用程序

3.1.1 Idea配置Tomcat：

run -->Edit Configurations

±->Tomcat Server–>Local


Configure…,选取Tomcat文件路径，apply

3.1.2 Idea创建Web项目：

---

四、Servlet

4.1 什么是Servlet？

Servlet是一门用于开发动态web资源的技术，它是运行在服务器端的小程序。

Servlet就是一个接口，定义了Java类被浏览器访问到(tomcat识别)的规则(抽象方法）。

作用：Servlet主要用于处理客户端传来的 HTTP请求，并返回一个响应，它能够处理的请求有 doGet() 和 doPost() 等方法。

用户若想用发一个动态web资源(即开发一个Java程序向浏览器输出数据)，需要完成以下2个步骤：

1. 编写一个Java类，实现Servlet接口。
2. 把开发好的Java类部署到web服务器中。

---

4.2 Servlet快速入门：

快速入门，用Servlet向浏览器输出“hello servlet”

1、创建Java web项目

2、定义一个类DemoSevlet，实现Servlet接口

public class DemoServlet implements Servlet
1

3、实现接口中的抽象方法

package com.blb.servlet

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class ServletDemo01 implements Servlet {
	
	@Override
	// destory : 销毁
	public void destory() {
		
	}

	@Override
	// ServletConfig : 配置信息
	public ServletConfig getServletconfig() {
		return null;
	}

	@Override
	// getServletInfo : 获取Servlet的信息
	public String getServletInfo() {
		return null;
	}

	@Override
	// Init : 初始化方法
	public void Init(ServletConfig servletConfig) throws ServletException {
		System.out.println("初始化");
	}

	@Override
	// Service : 处理请求的业务逻辑方法
	public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
		// 向控制台输出一句话
		System.out.println("Hello Servlet");
		// 得到输出对象
		PrintWriter out = res.getwriter();
		// 向浏览器输出信息
		out.write("Hello Servlet");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

4、在web.xml中配置Servlet

• tomcat将全类名对应的字节码文件加载进内存。Class.forName()
• 创建对象 cls.newInstance();
• 调用方法 ----service();

<!--配置Servlet -->
<?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_4_0.xsd"
         version="4.0">
    <servlet>
        <!--给当前需要配置的servlet取名字-->
        <servlet-name>Demo01</servlet-name>
        <servlet-class>com.blb.servlet.ServletDemo01</servlet-class>
    </servlet>
    <servlet-mapping>
        <!--写全类名-->
        <servlet-name>Demo01</servlet-name>
        <url-pattern>/Demo</url-pattern>
    </servlet-mapping>
    
</web-app>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5、运行效果

分析 http://localhost:8080/javaweb_01/demo01

localhost：主机号；8080：端口号；javaweb_01：项目名称（在配置的时候可以选择不用）；demo01：资源路径

执行原理：

• 当服务器接受到客户端浏览器的请求后，会解析请求URL路径，获取访问的Servlet的资源路径
• 查找web.xml文件，是否有对应的<url-pattern>标签体内容
• 如果有，则在找到对应的<servlet-class>全类名
• tomcat会将字节码文件加载进内存，并且创建其对象
• 调用其方法

---

4.3 Servlet的生命周期：

4.3.1 Servlet生命周期方法详解：

1、Servlet被创建时：执行init方法，只执行一次

Servlet什么时候被创建？

• 默认情况下，第一次被访问时，Servlet被创建
• 可以配置执行Servlet的创建时机
  • 在<servlet>标签下配置
    • ①、第一次被访问时，创建：
      • <load-on-startup>的值为负数
    • ②、在服务器启动时，创建：
      • <load-on-startup>的值为0或正整数

Servlet的init方法，只执行一次，说明一个Servlet在内存中只存在一个对象，Servlet是单例的

• 多个用户同时访问时，可能存在线程安全问题
• 解决：尽量不要在Servlet中定义成员变量。即使定义了成员变量，也不要对修改值

2、提供服务：执行service方法，执行多次

• 每次访问Servlet时，service方法都会被调用一次。

3、被销毁：执行destroy方法，只执行一次

• Servlet被销毁时执行。服务器关闭时，Servlet被销毁
  • 只有服务器正常关闭时，才会执行destroy方法。
  • destroy方法在Servlet被销毁之前执行，一般用于释放资源

创建一个Servlet，理解Servlet的生命周期。

package com.blb.servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class ServletDemo01 implements Servlet {
	
	@Override
	public void destroy() {
		System.out.println("我被销毁了！！");
	}

	@Override
	public ServletConfig getServletConfig() {
		return null;
	}
	
	@Override
	public String getServletInfo() {
		return null;
	}

	@Override
	public void init(ServletConfig config) throws ServletException {
		System.out.println("我出生了....");
	}
	
	@Override
	public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
		// 向控制台输出一句话
		System.out.println("Hello Servlet");
		// 得到输出对象
		PrintWriter out = res.getWriter();
		// 向浏览器输出信息
		out.write("Hello Servlet");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

4.4 Servlet3.0 注解配置：

Servlet3.0开始支持注解配置，通过WebServlet注解来实现映射，web.xml不再是必需的组件。

步骤：

1. 创建JavaEE项目，选择Servlet的版本3.0以上，可以不创建web.xml
2. 定义一个类，实现Servlet接口
3. 复写方法
4. 在类上使用@WebServlet注解，进行配置：@WebServlet("资源路径")

下面是@WebServlet的源码实现

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface WebServlet {
    
	String name() default "";//相当于<Servlet-name>
			
	String[] value() default {};//代表urlPatterns()属性配置
			
	String[] urlPatterns() default {};//相当于<url-pattern>
			
	int loadOnStartup() default -1;//相当于<load-on-startup>
			
	 WebInitParam[] initParams() default {};
			
	 boolean asyncSupported() default false;
			
	 String smallIcon() default "";
			
	 String largeIcon() default "";
			
	 String description() default "";
			
	 String displayName() default "";
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

4.5 Servlet体系结构：

Servlet– 接口 :抽象方法：必须要被实现类重写
|

GenericServlet – 抽象类 ：必须重写Servlet里面的抽象方法
|

HttpServlet – 抽象类 doget dopost

• GenericServlet：将Servlet接口中其他的方法做了默认空实现，只将service()方法作为抽象

  • 定义Servlet类时，可以继承GenericServlet，实现service()方法即可

package com.blb.servlet;

import java.io.IOException;

import javax.servlet.GenericServlet;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;
/**
 * Servlet第二种创建方式，
 * 继承 GenericServlet 方式 创建Servlet
 *
 */
@WebServlet("/demo02")
public class ServletDemo02 extends GenericServlet{

	@Override
	public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
		
		System.out.println("继承 GenericServlet 方式 创建Servlet");
		
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

HttpServlet：对http协议的一种封装，简化操作 （我们一般使用这个）

1. 定义类继承HttpServlet
2. 复写doGet/doPost方法

package com.blb.servlet;

import java.io.IOException;

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

/**
 * 继承HttpServlet，创建Servlet
 *
 */
@WebServlet("/demo03")
public class ServletDemo03 extends HttpServlet{

	/**
	 * 重写doGet方法，如果请求是get方式，执行该方法
	 */
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		System.out.println("接收到get请求......");
	}
	/**
	 * 重写doPost方法，如果请求是post方式，执行该方法
	 */
	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		
		System.out.println("接收到post请求......");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

4.6 Servlet相关配置：

urlpartten：servlet访问路径

• 一个servlet可以定义多个路径：@WebServlet({“资源路径1”,“资源路径2”,“资源路径3”})
• 目录结构：/资源路径1/资源路径2

---

五、Http协议：

5.1 Http协议概念：

• 什么是协议：

  • 生活中的协议：双方进行交流的一个标准和约束
  • 协议：协议的甲乙双方，就是客户端（浏览器）和服务器 理解成双方通信的格式

• HTTP概念：- Hyper Text Transfer Protocol 超文本传输协议

  • 传输协议：定义了，客户端和服务器端通信时，发送数据的格式

  • HTTP协议特点：

    1. 基于TCP/IP的高级协议
    2. 默认端口号:80
    3. 基于请求/响应模型的:一次请求对应一次响应,http请求必会有对应的一次响应
    4. 无状态的：每次请求之间相互独立，不能交互数据

  • 历史版本：
    * 1.0：每一次请求响应都会建立新的连接
    * 1.1：复用连接

http协议是一个重要的协议，他是贯穿整合B/S架构的核心协议。因此学习http协议的时候一定要从请求和响应两个角度思考。

注意方向性（ 请求：浏览器 -> 服务器；响应：服务器 -> 浏览器 ）

5.2 Http 请求：

客户端连上服务器后，向服务器请求某个web资源，称之为客户端向服务器发送一个 HTTP 请求

一个完整的HTTP请求包括如下内容：

1. 请求行：

   请求方式 请求url 请求协议/版本

2. 请求头：客户端浏览器告诉服务器一些信息

   请求头名称: 请求头值

3. 请求空行：

   空行，就是用于分割POST请求的请求头，和请求体的。

4. 请求体(正文)：

   封装POST请求消息的请求参数的

请求字符串格式

POST /servlet_demo/demo2 HTTP/1.1  请求行
Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:78.0) Gecko/20100101 Firefox/78.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 16
Origin: http://localhost:8080
Connection: keep-alive
Referer: http://localhost:8080/servlet_demo/demo2.html //防盗链
Upgrade-Insecure-Requests: 1
		
username=wangcai
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5.3 Get请求

• 通过浏览器地址栏访问的方式
• 使用超链接方式
• 使用js中的location.href 方式
• 表单的方式设置method=“get”

特点：

• 数据直接跟在URL地址后面明文显示的格式 ?key1=value1&key2=value2…//请求参数
• 请求的url长度有限制的
• 安全性较低，数据可以直接在地址栏看到

5.4 Post请求

• 将表单的提交方式设为method=“post”

特点：

• 数据是隐藏在请求体里面的不是明文的也是key/value的形式
• 数据大小没有限制
• 安全性高

下面的表格比较了两种 HTTP 方法：GET 和 POST。

5.5 Http响应

一个HTTP响应代表服务器向客户端回送的数据，它包括：

1. 响应行：

   组成：协议/版本、响应状态码、状态码描述

   响应状态码：服务器告诉客户端浏览器本次请求和响应的一个状态

   • 状态码都是3位数字

   • 分类：

     • 1xx：服务器就收客户端消息，但没有接受完成，等待一段时间后，发送1xx多状态码
     • 2xx：成功。代表：200
     • 3xx：重定向。代表：302(重定向)，304(访问缓存)
     • 4xx：客户端错误。代表：404（请求路径没有对应的资源） ，405：请求方式没有对应的doXxx方法
     • 5xx：服务器端错误。代表：500(服务器内部出现异常)

2. 响应头：

   • 格式：头名称： 值

   • 常见的响应头：

     • Content-Type：服务器告诉客户端本次响应体数据格式以及编码格式
     • Content-disposition：服务器告诉客户端以什么格式打开响应体数据
       • in-line:默认值,在当前页面内打开
       • attachment;filename=xxx：以附件形式打开响应体。文件下载

3. 响应空行

4. 响应体:传输的数据

响应字符串格式

HTTP/1.1 200 
Accept-Ranges: bytes
ETag: W/"309-1594050856290"
Last-Modified: Mon, 06 Jul 2020 15:54:16 GMT
Content-Type: text/html
Content-Length: 309
Date: Mon, 06 Jul 2020 16:02:39 GMT

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>demo2</title>
</head>
<body>
  <form action="/servlet_demo/demo2" method="post">
          用户名: <input type="text"  name = "username"  /><br/>
          <input type="submit" value="提交" />

    </form>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

---

六、Request对象：

6.1 Request概述

request对象和response对象的原理

• request和response对象是由服务器创建的。我们来使用它们
• request对象是来获取请求消息，response对象是来设置响应消息

request对象继承体系结构

ServletRequest–接口
| 继承
HttpServletRequest–接口
| 实现
org.apache.catalina.connector.RequestFacade 类(tomcat)

6.2 Request功能

6.2.1 获取请求消息数据

获取请求行数据

POST /servlet_demo/demo2 HTTP/1.1

方法：

  	1. 获取请求方式 ： `String getMethod()`  
 	2. 获取虚拟目录：`/servlet_demo`
     * `String getContextPath()`
 	3. 获取Servlet路径:`/demo2`
     * `String getServletPath()`
 	4. 获取get方式请求参数：`name=zhangsan`
     * `String getQueryString()`
 	5. 获取请求URI：
     * `String getRequestURI()`：`/servlet_demo/demo2`
     * `StringBuffer getRequestURL()`  :  `http://localhost/servlet_demo/demo2`
    6. 获取访问的客户端IP地址：
     * String getRemoteAddr()
    7.获取协议及版本
     * String getProtocol()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

获取请求头数据：

• 方法：
  • 通过请求头的名称获取请求头的值：String getHeader(String name)
  • 获取所有的请求头名称：Enumeration<String> getHeaderNames()
• 获取请求体数据：
  • 请求体：只有POST请求方式，才有请求体，在请求体中封装了POST请求的请求参数
  • BufferedReader getReader()：获取字符输入流，只能操作字符数据

创建Servlet分别调用方法获取请求行、请求头、请求体数据

获取请求行数据：

package com.blb.servlet;

import java.io.IOException;

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

/**
 * request获取请求行数据
 *
 */
@WebServlet("/demo01")
public class ServletDemo01 extends HttpServlet{

	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		//获取请求方式
		String method = req.getMethod();
		System.out.println(method);
		
		//获取虚拟目录
		String path = req.getContextPath();
		System.out.println(path);
		
		//获取Servlet的路径
		String servletPath = req.getServletPath();
		System.out.println(servletPath);
		
		//获取get方法请求参数
		String parameter = req.getQueryString();
		System.out.println(parameter);
		
		//返回资源的路径(项目名加虚拟路径)
		String uri = req.getRequestURI();
		System.out.println(uri);
				
		//返回的是资源路径（但是是全路径，带有地址以及端口号）
		StringBuffer urlBuffer = req.getRequestURL();
		System.out.println(urlBuffer);
		
		//获取访问的客户端IP地址
		String ipPath = req.getRemoteAddr();
		System.out.println(ipPath);
		
		
	}

	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

获取请求头数据：

package com.blb.servlet;

import java.io.IOException;
import java.util.Enumeration;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
 * request获取请求头数据
 *
 */
@WebServlet("/demo02")
public class ServletDemo02 extends HttpServlet{

	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		
		//通过请求头的名称获取请求头的值
		String value = req.getHeader("Cookie");
		System.out.println(value);
		
		//获取所有请求头的名称
		Enumeration<String> headerNames =  req.getHeaderNames();
		while (headerNames.hasMoreElements()) {
			String string = (String) headerNames.nextElement();
			System.out.println(string);
		}
	}

	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

---

一个小样例：

盗版网站的视频链接全部都是由正版授权网站的资源。盗版网站这样不仅分了流量和钱。所以可以设计一个小型拦截器。

HTTP Referer是header的一部分，当浏览器向web服务器发送请求的时候，一般会带上Referer，告诉服务器该网页是从哪个页面链接过来的，服务器因此可以获得一些信息用于处理。

“正版” 检测判断：

package com.blb.servlet;

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(name = "demo03",urlPatterns = "/demo03")
//@WebServlet("/demo03")
public class ServletDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        String head = req.getHeader("referer");
        System.out.println(head);
        if (head!=null){
            if (head.contains("day05")){
                System.out.println("播放电影");
            }else{
                System.out.println("盗版可耻");
            }
        }
    }

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

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

正版网页页面：

<%--
  Created by IntelliJ IDEA.
  User: 86182
  Date: 2021/11/10
  Time: 14:04
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
    <form>
<%--      <input type="submit">--%>
<%--      <input name="username">--%>
      <a href="http://localhost:8080/day05/demo03">看电影</a>
    </form>
  </body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

如果在正版页面点击播放链接，则

盗版的页面：

<%--
  Created by IntelliJ IDEA.
  User: 86182
  Date: 2021/11/1
  Time: 14:05
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
    <a href="http://localhost:8080/day05/demo03">点击播放电影</a>
  </body>
</html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

如果通过盗版页面点击链接，则

如果是在网址上通过直接输入对应链接网址，则会返回空

那么它的判断方式就是：通过识别跳转到链接的前一个网址的url是什么，它的网址url有没有和我规定的页面网址有相同的地方。

---

6.2.2 获取请求参数通用方式

• String getParameter(String name):根据参数名称获取参数值 username=zs&password=123
• String[] getParameterValues(String name):根据参数名称获取参数值的数组 hobby=xx&hobby=game
• Enumeration getParameterNames():获取所有请求的参数名称

中文乱码问题：

• get方式：tomcat 8 已经将get方式乱码问题解决了
• post方式：会乱码

解决：在获取参数前，设置request的编码request.setCharacterEncoding(“utf-8”);

获取请求体数据：

package com.blb.servlet;

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.BufferedReader;
import java.io.IOException;

@WebServlet("/demo05")

public class ServletDemo05 extends HttpServlet {
    // 只能用POST请求
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// 读取字符流
		BufferedReader reader = req.getReader();
		// 读取数据
		String line = null;
		while((line=reader.readLine())!=null){
			System.out.println(line);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

index.jsp

<form action="demo05" method="post">
  	<input type="text" name="username" />
 	<input type="submit" />
</form>
1
2
3
4

---

下面的GET请求和POST请求基本上都一样，在Tomcat8之后，GET请求不需要自行设置编码格式，而POST请求需要加上

req.setCharacterEncoding("utf-8");
1

req.getParameter("") 根据参数名获取参数值

String username = req.getParameter("username");
1

package com.blb.servlet;

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("/demo06")

public class ServletDemo06 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 设置编码格式
        req.setCharacterEncoding("utf-8");
        // req.getParameter("") 根据参数名获取参数值
        String username = req.getParameter("username");
        System.out.println("这是GET请求");
        System.out.println(username);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 设置编码格式
        req.setCharacterEncoding("utf-8");
        // String getParameter(String name):根据参数名称获取参数值
        String username = req.getParameter("username");
        System.out.println("这是POST请求");
        System.out.println(username);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

index.jsp

<form action="demo06" method="get">
    <input type="text" name="username" />
    <input type="submit" />
</form>
1
2
3
4

---

像日常生活中网页的多项选项（checkbox），我们可以通过 getParameterValues 创建一个字符串数组得到我们选择的值

String[] getParameterValues(String name):根据参数名称获取参数值的数组 hobby=xx&hobby=game

package com.blb.servlet;

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("/demo07")

public class ServletDemo07 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 设置编码格式
        req.setCharacterEncoding("utf-8");
        // String[] getParameterValues(String name):根据参数名称获取参数值的数组
        String[] hobbies = req.getParameterValues("hobby");

        for (String hobby:hobbies) {
            System.out.println(hobby);
        }
    }

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

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

index.jsp

<form action="demo07" method="get">
    <input type="text" name="username" />
    <input type="checkbox" name="hobby" value="game" />游戏
    <input type="checkbox" name="hobby" value="music" />音乐
    <input type="checkbox" name="hobby" value="football" />足球
    <input type="submit" />
</form>
1
2
3
4
5
6
7

---

Enumeration getParameterNames():获取所有请求的参数名称

package com.blb.servlet;

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.util.Enumeration;

@WebServlet("/demo08")

public class ServletDemo08 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // Enumeration<String> getParameterNames():获取所有请求的参数名称
        Enumeration<String> names =  req.getParameterNames();
        while(names.hasMoreElements()){
            String name = names.nextElement();
            System.out.println(name);
        }
    }

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

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

index.jsp

<form action="demo08" method="get">
   <input type="text" name="username" />
   <input type="checkbox" name="hobby" value="game" />游戏
   <input type="checkbox" name="hobby" value="music" />音乐
   <input type="checkbox" name="hobby" value="football" />足球
   <input type="submit" />
</form>
1
2
3
4
5
6
7

---

6.2.3 请求转发forward

一种在服务器内部的资源跳转方式

请求转发和重定向的区别主要在于路径上的变化（后面细讲！）

• 步骤

  • 通过request对象获取请求转发器对象：RequestDispatcher getRequestDispatcher(String path)
  • 使用RequestDispatcher对象来进行转发：forward(ServletRequest request, ServletResponse response)

• 特点：

  • 浏览器地址栏路径不发生变化
  • 只能转发到当前服务器内部资源中。
  • 转发是一次请求

请求转发的应用场景：MVC设计模式

早期开发，前后端不分离

jsp 不是html 一点都不一样， jsp (视图层的servlet) --> servlet(控制层) MVC设计模式 Model（实体类 dao） View（html） Controller（servlet

package com.blb.servlet;

import javax.servlet.RequestDispatcher;
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("/servlet01")

public class DemoServlet01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        System.out.println("servlet01");
        // 前一部分是获取转发对象，以及转发地址
        RequestDispatcher requ = req.getRequestDispatcher("/index.jsp");
        // 第二部分
        requ.forward(req, resp);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

通过请求转发来实现登录页面的切换：

package com.blb.servlet;

import javax.servlet.RequestDispatcher;
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("/servlet01")

public class DemoServlet01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        String username = req.getParameter("username");
        String password = req.getParameter("password");

        if (username.equals("admin") && password.equals("123456")){
            // 请求转发
            RequestDispatcher requ1 = req.getRequestDispatcher("/login.jsp");
            requ1.forward(req,resp);
            
            //或者 req.getRequestDispatcher("/login.jsp").forward(req, resp);
        }else {
            RequestDispatcher requ1 = req.getRequestDispatcher("/fail.jsp");
            requ1.forward(req,resp);

			//或者 req.getRequestDispatcher("/fail.jsp").forward(req, resp);
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

首页 index.jsp

<%--
  Created by IntelliJ IDEA.
  User: 86182
  Date: 2021/11/17
  Time: 14:13
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
    <form action="servlet01">
      账号: <input type="text" name="username"><br>
      密码: <input type="password" name="password">
      <input type="submit">
    </form>
  </body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

登陆成功页面 login.jsp

<%--
  Created by IntelliJ IDEA.
  User: 86182
  Date: 2021/11/17
  Time: 14:27
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>login</title>
</head>
<body>
    登录成功
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

登陆失败页面 fail.jsp

<%--
  Created by IntelliJ IDEA.
  User: 86182
  Date: 2021/11/17
  Time: 14:27
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>failed</title>
</head>
<body>
    登陆失败
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

---

6.2.4 共享数据

域对象：一个有作用范围的对象，可以在范围内共享数据

request域：代表一次请求的范围，一般用于请求转发的多个资源中共享数据

方法：

• void setAttribute(String name,Object obj):存储数据
• Object getAttitude(String name):通过键获取值
• void removeAttribute(String name):通过键移除键值对

实例：第一个class存储数据，第二个class取数据并删除数据，第三个class再取数据

DemoServlet01：

package com.blb.servlet;

import javax.servlet.RequestDispatcher;
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("/servlet01")

public class DemoServlet01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
        req.setAttribute("a", "zya");
        System.out.println(req.getAttribute("a"));

        req.getRequestDispatcher("/servlet02").forward(req, resp);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

DemoServlet02：

package com.blb.servlet;

import com.sun.org.apache.xpath.internal.objects.XObject;

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("/servlet02")

public class DemoServlet02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Object b = req.getAttribute("a");

        System.out.println(b);

        req.removeAttribute("a");

        req.getRequestDispatcher("/servlet03").forward(req, resp);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

DemoServlet03：

package com.blb.servlet;

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("/servlet03")

public class DemoServlet03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    	// 获取存储的数据（通过键值对的方式）
        System.out.println(req.getAttribute("a"));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

打印的结果为

---

七、Response对象

7.1 Response功能

7.1.1 设置响应消息

设置响应行

HTTP/1.1 200

设置状态码：setStatus(int sc)

设置响应头

• 方法：setHeader(String name, String value)

7.1.2 将数据输出到客户端浏览器(重点)

• 步骤：

  1. 获取字符输出流：PrintWriter out= response.getWriter();
  2. 输出数据：out.write(数据);

• 乱码问题：

  PrintWriter out= response.getWriter();获取的流的默认编码是ISO-8859-1

  告诉浏览器响应体使用的编码和响应的数据类型：response.setContentType("text/html;charset=utf-8");

package com.blb.servlet;

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.io.PrintWriter;

@WebServlet("/ResponseDemo")

public class ResponseDemo extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 设置状态码(302代表重定向)
        resp.setStatus(302);

        // setHeader(String name, String value)
        // 设置编码格式
        resp.setHeader("Content-Type", "text/html;charset=utf-8");
        // resp.setCharacterEncoding("gbk");

        // response浏览器输出
        // 获取IO流
        PrintWriter pw = resp.getWriter();
        pw.write("hello world世界");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

7.1.3 重定向 redirect (重点)

资源跳转的方式

• 代码实现
  • response.sendRedirect(跳转地址);
  • resp.setStatus(302) 和 resp.setHeader("location", "跳转地址")（这种方法用的少）
• 特点：
  • 地址栏发生变化
  • 重定向可以访问其他站点(服务器)的资源
  • 重定向是两次请求。不能使用request对象来共享数据

package com.blb.servlet;

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("/Response01")

public class ResponseDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setStatus(302);

//        resp.setHeader("location", "https://www.baidu.com");
        resp.sendRedirect("https://www.baidu.com");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

7.1.4 forward和redirect区别

• 重定向是两次请求,转发是一次请求。
• 重定向浏览器地址栏发生变化，转发浏览器地址栏路径不发生变化
• 重定向可以访问其他服务器的资源 ，转发只能转发到当前服务器内部资源中