第三十一：JavaWeb

“真正的危险不是计算机开始像人一样思考，而是人开始像计算机一样思考。”

【狂神说Java】JavaWeb入门到实战_哔哩哔哩_bilibili

基本概念

• web开发

  • web，网页的意思
  • 静态web
    • html，css
    • 提供给所有人看的数据，始终不会发生变化
  • 动态web
    • 会发生变化。每个人在不同时间，不同地点 看到的信息各不相同
    • 常用的技术栈，servlet/JSP，ASP，PHP

在Java中，动态资源开发的技术统称为JavaWeb

web应用程序

可以提供浏览器访问的程序

• a.html , b.html…多个web资源，这些web资源可以被外界访问，对外界提供服务

• 能访问到任何一个页面或者资源，都存在于这个世界一台计算机上

• URL

• 这个统一的web资源会被放在同一个文件夹下，web应用程序–>Tomcat服务器

• 一个web应用由多个部分组成（静态web，动态web）

  • html,css,js
  • jsp,servlet
  • Java程序
  • jar包
  • 配置文件(properties)

web应用程序编写完毕后，若想提供给外界访问，需要一个服务器来统一管理

静态web

• *.html，*.htm是网页后缀

  

• 静态 web 存在的缺点

  • Web 页面无法动态更新 ， 所有用户看到都是同一个页面
  • 轮播图 ， 点击特效 ： 伪动态
  • JavaScript [ 实际开发中 ， 它用的最多 ]
  • VBScript
  • 无法和数据库交互（数据无法

动态web

页面会动态展示，web页面展示的效果因人而异

• 加入服务器的动态 web 资源出现了错误 ， 我们需要重新编写我们的后台程序，重新发布

  • 停机维护

• Web 页面可以动态更新 ， 所有用户看到不是同一个页面

• 它可以和数据库交互

Web服务器

常见的Web服务器

ASP

• 微软：国内最早流行的是ASP

• 在HTML中嵌入了VB的脚本，ASP+COM

• 在ASP开发中，基本一个页面都有几千行代码，很混乱

• C#

• IIS

php

• 开发速度快，功能强大，跨平台，代码简单

• 无法承载大访问量

JSP/Servlet

• B/S：浏览器和服务器

• C/S：客户端和服务端

• Sun公司主推的B/S架构

• 基于Java语言的（所有的大公司，或者一些开源的组件，都是用的Java写的）

• 可以承载三高问题（三高：高并发，高可用，高性能）

服务器是一种被动的 操作，用来处理用户的一些请求和给用户一些响应信息

IIS

• 微软的，跑ASP，windows自带的

Tomcat

• Tomcat是由Apache软件基金会属下Jakarta项目开发的Servlet容器，按照Sun Microsystems提供的技术规范，实现了对Servlet和JavaServer Page（JSP）的支持，并提供了作为Web服务器的一些特有功能，如Tomcat管理和控制平台、安全局管理和Tomcat阀等。由于Tomcat本身也内含了HTTP服务器，因此也可以视作单独的Web服务器。但是，不能将Tomcat和Apache HTTP服务器混淆，Apache HTTP服务器是用C语言实现的HTTPWeb服务器；这两个HTTP web server不是捆绑在一起的。Apache Tomcat包含了配置管理工具，也可以通过编辑XML格式的配置文件来进行配置。

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

1. 输入一个域名 ； 回车

2. 检直本机的 C:\Window s\System32\drivers\etc\hosts 配置文件下有没有这个域名映射

   1. 有 ： 直接返回对应的 ip 地址， 这个地址中 ， 有我们需要访问的 web 程序 ， 可以直接访问

      1	127.0.0.1 www.baidu.com

   2. 没有：去 DNS 服务器找， 找到的话就返回 ， 找不到就返回找不到

      

   3. 配置环境变量

HTTP协议

概念：

• 超文本传输协议（英语：HyperText Transfer Protocol，缩写：HTTP）是一种用于分布式、协作式和超媒体信息系统的应用层协议。HTTP是万维网的数据通信的基础。

• 设计HTTP最初的目的是为了提供一种发布和接收HTML页面的方法。通过HTTP或者HTTPS协议请求的资源由统一资源标识符（Uniform Resource Identifiers，URI）来标识。

• HTTP的发展是由蒂姆·伯纳斯-李于1989年在欧洲核子研究组织（CERN）所发起。HTTP的标准制定由万维网协会（World Wide Web Consortium，W3C）和互联网工程任务组（Internet Engineering Task Force，IETF）进行协调，最终发布了一系列的RFC，其中最著名的是1999年6月公布的 RFC 2616，定义了HTTP协议中现今广泛使用的一个版本——HTTP 1.1。

• 2014年12月，互联网工程任务组（IETF）的Hypertext Transfer Protocol Bis（httpbis）工作小组将HTTP/2标准提议递交至IESG进行讨论[2]，于2015年2月17日被批准。[3] HTTP/2标准于2015年5月以RFC 7540正式发表，取代HTTP 1.1成为HTTP的实现标准。

相关：

• HTTP （ 超文本传输协议 ） 是一个简单的请求 · 响应协议 ， 它通常运行在 TCP 之上

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

• HTTPS：安全的

  • 443端口

两个时代：

• HTTP1.0

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

• HTTP2.0

  • HTTP/1.1：客户端可以与 web 服务器连接后 ， 可以获得多个 web 资源

请求和相应：

• 请求：客户端-发请求-服务器

  1 2 3 4

  请求 URL（Rquest URL）:https://www.baidu.com/ 请求方法（Request Method）:GET 状态代码（Status Code）:200 OK 远程地址（Remote Address）:127.0.0.1:7879

  • 请求行

    • 请求行中的请求方式：GET
    • 请求方式 Get,Post,HEAD,DELETE,PUT,TRACT…
      • get: 请求能够携带的参数较少，大小有限制，会在浏览器的URL地址中显示，不安全但是高效
      • post: 请求能够携带的参数较多，大小没有限制，不会在浏览器的URL地址中显示，安全但是不高效

  • 消息头

    1 2 3 4 5 6

    Accept 告诉浏览器它所支持的数据类型 Accept-Encoding 编码格式 Accept-Language 告诉浏览器语言环境 Connection 告诉浏览器，请求完成还是保持连接 Cache-Control 缓存控制 HOST 主机

• 响应：服务器-响应-客户端

  1 2 3 4

  Cache-Control max-age=0 缓存控制 Connection keep-alive 连接 Content-Encoding gzip 编码类型 Content-Type text/html; charset=utf-8

  • 响应体

    1 2 3 4 5 6 7 8

    Accept 告诉浏览器它所支持的数据类型 Accept-Encoding 编码格式 Accept-Language 告诉浏览器语言环境 Connection 告诉浏览器，请求完成还是保持连接 Cache-Control 缓存控制 HOST 主机 Reflush 告诉客户端多久刷新一次 Location 让网页重新定位

  • 响应状态码

    • 200：请求响应成功

    • 3xx：重定向

    • 404：找不到资源‘

    • 5xx：服务器代码错误

      502：网关错误

• request和response的作用执行流程

  • Web服务器收到客户端的http请求，会针对每一次请求，分别创建一个用于代表请求的request对象、和代表响应的response对象。

  • 当需要获取客户机提交过来的数据时，找request对象就行了。

    当需要向客户机输出数据，找response对象。

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

Maven

为什么要学习Maven？

1. 在Javaweb开发过程中，通常需要使用大量jar包，为了避免手动导入

2. 如何能够让一个东西能够自动帮我导入需要的jar包

3. Maven只是一个工具，不能说是一个jar包

Maven项目架构管理工具及其一些配置

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

• 有约束，不要去违反

Maven会规定好如何去编写Java代码，

配置：

1
2
3
4
5
6

<mirror>
    <id>nexus-aliyun</id>
    <mirrorOf>*</mirrorOf>
    <name>Nexus aliyun</name>
    <url>https://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>

本地仓库：

1

<localRepository>D:\Maven\repository</localRepository>

在IDEA中使用maven

1. 启动IDEA

2. 创建一个Maven项目

   

3. Maven设置

   

   自动导入源码

   

   项目设置

   

   添加Tomcat服务器

   

   为什么会出现这个警告？

   我们访问一个网站，需要指定一个文件夹的名字

   

   修改默认应用程序上下文，如果设置为/MavenLearn_war，那么访问时将为localhost:8080/MavenLearn_war

   

   运行结果：

   

   这里可以查看Maven命令

pom文件

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

<!--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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
<!--  这里是配置的GAV  -->
    <groupId>com.joker_yue</groupId>
    <artifactId>MavenLearn</artifactId>
    <version>1.0-SNAPSHOT</version>

<!--  packaging 项目的打包方式
      jar:java项目
      war:javaweb项目
  -->
    <packaging>war</packaging>
<!-- 名称   -->
    <name>MavenLearn Maven Webapp</name>
    <url>http://maven.apache.org</url>

<!--  依赖  -->
    <dependencies>
<!--    具体依赖的jar包    -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
<!--  项目构建用的东西  -->
    <build>
        <finalName>MavenLearn</finalName>
    </build>
</project>

Maven由于约定大于配置，之后可能会遇到我们写的配置文件无法导出或生效的问题，解决方案：在build中配置resources，防止资源导出失败

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

<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>

可以通过右键来显示图

遇到的坑

1. pom无法同步

   3.6.2maven有此问题,降低版本

2. JDK兼容

   使用JDK18

3. 无法部署war

   重新检查运行配置

4. 我的配置:

   Tomact:9.0.40

   Maven:3.5.3

   JDK:

5. 将IDEA中web.xml的版本设置为与Tomcat的推荐版本一致

   可以看到推荐版本为4.0

   

   1 2 3 4 5 6 7 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" metadata-complete="true"> </web-app>

6. 目录结构

   

Tomcat示例文件

可以通过这里查看示例代码

可以通过这里导入依赖 ，也可以通过Maven仓库导入

Servlet

什么是Servlet

• 是Sun公司用于开发动态网站的一门技术

• Sun公司在这些API中提供了一个接口叫做Sevlet。如果你想开发一个Servlet，只需要完成两个步骤：

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

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

HelloServlet

1. 创建一个普通的Maven项目，删掉里面的src目录

   空的工程叫做主文件

2. 关于Maven父子关系的理解

   父项目中会多一个module

   

   1 2 3 4

   <!--父模块中会有以下信息--> <modules> <module>Servlet-01</module> </modules>

   1 2 3 4 5 6

   <!--子模块中会有以下信息--> <parent> <groupId>com.joker_yue</groupId> <artifactId>MavenLearn</artifactId> <version>1.0-SNAPSHOT</version> </parent>

   子项目可以直接使用父项目中的Java

   1	son extend father

3. Maven环境优化

   1. 修改web.xml为最新的
   2. 将Maven的结构搭建完整

4. 编写一个Servlet程序

   1. 编写一个普通类

   2. 实现Servlet接口，直接继承HttpServlet

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

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

5. 编写Servlet的映射

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

   1 2 3 4 5 6 7 8 9 10

   <!--注册Servlet--> <servlet> <servlet-name>helloServlet</servlet-name> <servlet-class>com.joker_yue.servlet.HelloServlet</servlet-class> </servlet> <!--配置servlet请求路径--> <servlet-mapping> <servlet-name>helloServlet</servlet-name> <url-pattern>/joker_yue</url-pattern> </servlet-mapping>

6. 配置Tomcat

   注意：配置项目发布的路径就可以了

7. 启动测试

Sevlet原理

servlet就是一个接口，定义了java类被浏览器访问到（被Tomcat识别）的规则，主要负责接收浏览器的请求，tomcat服务器调用servlet方法。步骤：创建 一个JavaEE项目，定义一个类实现servlet接口，重写方法，在web.xml中配置servlet。

servlet执行原理：当服务器接收到浏览器客户的请求之后，会解析请求的URL路径，获取访问的servlet的资源路径，找到项目，查找web.xml文件，是否有对应的标签体内容，如果有，则找到对应的标签内的全类名，tomcat会将字节码文件加载进内存，并且创建其对象，调用其方法。

Servlet生命周期

Mapping问题

1. 一个Servlet可以指定一个映射路径

2. 一个Servlet可以指定多个映射路径

   1 2 3 4 5 6 7 8 9 10 11 12

   <!--配置servlet请求路径--> <servlet-mapping> <servlet-name>helloServlet</servlet-name> <url-pattern>/joker_yue</url-pattern> </servlet-mapping> <servlet-mapping> <servlet-name>helloServlet</servlet-name> <url-pattern>/joker_yue1</url-pattern> </servlet-mapping><servlet-mapping> <servlet-name>helloServlet</servlet-name> <url-pattern>/joker_yue2</url-pattern> </servlet-mapping>

3. 一个Servlet可以指定通用映射路径

   1 2 3 4

   <servlet-mapping> <servlet-name>helloServlet</servlet-name> <url-pattern>/joker_yue/*</url-pattern> </servlet-mapping>

   注意不要把通配的时候不要包含根目录

4. 指定一些后缀或者前缀

   1 2 3 4

   <servlet-mapping> <servlet-name>helloServlet</servlet-name> <url-pattern>*.do</url-pattern> </servlet-mapping>

   注意，*前面不可加任何路径

5. 优先级问题

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

   1 2 3 4 5 6 7 8 9 10

   <!-- 404--> <servlet> <servlet-name>errorServlet</servlet-name> <servlet-class>com.joker_yue.servlet.ErrorServlet</servlet-class> </servlet> <!--配置servlet请求路径--> <servlet-mapping> <servlet-name>errorServlet</servlet-name> <url-pattern>/*</url-pattern> </servlet-mapping>

ServletContext

web容器在启动的时候，他会为每个web程序都创建一个对应的ServiceContext对象，它代表了当前的web应用

• 共享数据

  我在这个Servlet中保存的数据，可以在另一个Servlet拿到

  1 2 3 4 5 6 7 8 9

  public class HelloServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { ServletContext servletContext = this.getServletContext(); String username = "Joker_Yue"; servletContext .setAttribute("username", username);//将一个数据保存在ServletContext中，名字为username。值,username } }

  1 2 3 4 5 6 7 8 9 10 11 12

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

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

  <servlet> <servlet-name>HelloServlet</servlet-name> <servlet-class>com.joker_yue.servlet.HelloServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>HelloServlet</servlet-name> <url-pattern>/hello</url-pattern> </servlet-mapping> <servlet> <servlet-name>getc</servlet-name> <servlet-class>com.joker_yue.servlet.GetServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>getc</servlet-name> <url-pattern>/getc</url-pattern> </servlet-mapping>

获取初始化参数

1
2
3
4
5

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

1
2
3
4
5
6

@Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       ServletContext servletContext = this.getServletContext();
       String url = servletContext.getInitParameter("url");
       resp.getWriter().print(url);
   }

请求转发和重定向

这是请求转发：

这是重定向：

实现请求转发

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

package com.joker_yue.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 ServletTest04 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 进入了ServletTest04
        System.out.println("进入ServletTest04了");
        ServletContext servletContext = this.getServletContext();
        // RequestDispatcher requestDispatcher = servletContext.getRequestDispatcher("/gp");//转发的请求路径
        // requestDispatcher.forward(req, resp);   //调用Servlet实现请求转发
        //  当然也可以连写成下面这一句
        servletContext.getRequestDispatcher("/gp").forward(req, resp);
    }

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

• 面试题：重定向和转发的区别

  • 相同：页面都会跳转

    • 不同：

      • 请求转发的时候，页面的URL不会发生变化：307

      • 重定向的时候，url地址栏会发生变化：302

      • 在Servlet中，请求转发只能定位到项目内文件，而重定向可以定位到项目之外的。

        所以请求转发不需要写绝对路径，而重定向需要

  • 比喻：

    重定向：这事儿啊，你呀，问村长去

    转发：这事我去给你问问村长，问到了告诉你哈

读取资源文件

Properties

• 在Java目录下新建properties

• 在resource目录下新建properties

发现：都被打包到了同一路径下：class，我们俗称为类路径

思路：需要一个文件流

1
2
3
4

username=root
password=12345

#classpath:类路径

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

package com.joker_yue.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.io.InputStream;
import java.util.Properties;

public class ServletTest05 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);
        resp.getWriter().print("密码:"+password);

    }

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

HttpServletResponse

响应：用于客户端向浏览器传递信息

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

• 如果我们要获取客户端请求过来的参数，找HttpServletRequest

• 如果要给客户端响应一些参数，找HttpServletResponse

简单分类

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

1
2
3

public ServletOutputStream getOutputStream() throws IOException;
    
public PrintWriter getWriter() throws UnsupportedEncodingException ;

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

1
2
3
4
5
6
7
8
9
10

public void setCharacterEncoding(String charset);
public void setContentLength(int len);
public void setContentLengthLong(long len);
public void setContentType(String type);
public void setDateHeader(String name, long date);
public void addDateHeader(String name, long date);
public void setHeader(String name, String value);   
public void addHeader(String name, String value);
public void setIntHeader(String name, int value);
public void addIntHeader(String name, int value);

一些常量，响应的状态码

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270

/*
 * Server status codes; see RFC 2068.
 */

/**
 * Status code (100) indicating the client can continue.
 */
public static final int SC_CONTINUE = 100;

/**
 * Status code (101) indicating the server is switching protocols
 * according to Upgrade header.
 */
public static final int SC_SWITCHING_PROTOCOLS = 101;

/**
 * Status code (200) indicating the request succeeded normally.
 */
public static final int SC_OK = 200;

/**
 * Status code (201) indicating the request succeeded and created
 * a new resource on the server.
 */
public static final int SC_CREATED = 201;

/**
 * Status code (202) indicating that a request was accepted for
 * processing, but was not completed.
 */
public static final int SC_ACCEPTED = 202;

/**
 * Status code (203) indicating that the meta information presented
 * by the client did not originate from the server.
 */
public static final int SC_NON_AUTHORITATIVE_INFORMATION = 203;

/**
 * Status code (204) indicating that the request succeeded but that
 * there was no new information to return.
 */
public static final int SC_NO_CONTENT = 204;

/**
 * Status code (205) indicating that the agent <em>SHOULD</em> reset
 * the document view which caused the request to be sent.
 */
public static final int SC_RESET_CONTENT = 205;

/**
 * Status code (206) indicating that the server has fulfilled
 * the partial GET request for the resource.
 */
public static final int SC_PARTIAL_CONTENT = 206;

/**
 * Status code (300) indicating that the requested resource
 * corresponds to any one of a set of representations, each with
 * its own specific location.
 */
public static final int SC_MULTIPLE_CHOICES = 300;

/**
 * Status code (301) indicating that the resource has permanently
 * moved to a new location, and that future references should use a
 * new URI with their requests.
 */
public static final int SC_MOVED_PERMANENTLY = 301;

/**
 * Status code (302) indicating that the resource has temporarily
 * moved to another location, but that future references should
 * still use the original URI to access the resource.
 *
 * This definition is being retained for backwards compatibility.
 * SC_FOUND is now the preferred definition.
 */
public static final int SC_MOVED_TEMPORARILY = 302;

/**
* Status code (302) indicating that the resource reside
* temporarily under a different URI. Since the redirection might
* be altered on occasion, the client should continue to use the
* Request-URI for future requests.(HTTP/1.1) To represent the
* status code (302), it is recommended to use this variable.
*/
public static final int SC_FOUND = 302;

/**
 * Status code (303) indicating that the response to the request
 * can be found under a different URI.
 */
public static final int SC_SEE_OTHER = 303;

/**
 * Status code (304) indicating that a conditional GET operation
 * found that the resource was available and not modified.
 */
public static final int SC_NOT_MODIFIED = 304;

/**
 * Status code (305) indicating that the requested resource
 * <em>MUST</em> be accessed through the proxy given by the
 * <code><em>Location</em></code> field.
 */
public static final int SC_USE_PROXY = 305;

 /**
 * Status code (307) indicating that the requested resource 
 * resides temporarily under a different URI. The temporary URI
 * <em>SHOULD</em> be given by the <code><em>Location</em></code> 
 * field in the response.
 */
public static final int SC_TEMPORARY_REDIRECT = 307;

/**
 * Status code (400) indicating the request sent by the client was
 * syntactically incorrect.
 */
public static final int SC_BAD_REQUEST = 400;

/**
 * Status code (401) indicating that the request requires HTTP
 * authentication.
 */
public static final int SC_UNAUTHORIZED = 401;

/**
 * Status code (402) reserved for future use.
 */
public static final int SC_PAYMENT_REQUIRED = 402;

/**
 * Status code (403) indicating the server understood the request
 * but refused to fulfill it.
 */
public static final int SC_FORBIDDEN = 403;

/**
 * Status code (404) indicating that the requested resource is not
 * available.
 */
public static final int SC_NOT_FOUND = 404;

/**
 * Status code (405) indicating that the method specified in the
 * <code><em>Request-Line</em></code> is not allowed for the resource
 * identified by the <code><em>Request-URI</em></code>.
 */
public static final int SC_METHOD_NOT_ALLOWED = 405;

/**
 * Status code (406) indicating that the resource identified by the
 * request is only capable of generating response entities which have
 * content characteristics not acceptable according to the accept
 * headers sent in the request.
 */
public static final int SC_NOT_ACCEPTABLE = 406;

/**
 * Status code (407) indicating that the client <em>MUST</em> first
 * authenticate itself with the proxy.
 */
public static final int SC_PROXY_AUTHENTICATION_REQUIRED = 407;

/**
 * Status code (408) indicating that the client did not produce a
 * request within the time that the server was prepared to wait.
 */
public static final int SC_REQUEST_TIMEOUT = 408;

/**
 * Status code (409) indicating that the request could not be
 * completed due to a conflict with the current state of the
 * resource.
 */
public static final int SC_CONFLICT = 409;

/**
 * Status code (410) indicating that the resource is no longer
 * available at the server and no forwarding address is known.
 * This condition <em>SHOULD</em> be considered permanent.
 */
public static final int SC_GONE = 410;

/**
 * Status code (411) indicating that the request cannot be handled
 * without a defined <code><em>Content-Length</em></code>.
 */
public static final int SC_LENGTH_REQUIRED = 411;

/**
 * Status code (412) indicating that the precondition given in one
 * or more of the request-header fields evaluated to false when it
 * was tested on the server.
 */
public static final int SC_PRECONDITION_FAILED = 412;

/**
 * Status code (413) indicating that the server is refusing to process
 * the request because the request entity is larger than the server is
 * willing or able to process.
 */
public static final int SC_REQUEST_ENTITY_TOO_LARGE = 413;

/**
 * Status code (414) indicating that the server is refusing to service
 * the request because the <code><em>Request-URI</em></code> is longer
 * than the server is willing to interpret.
 */
public static final int SC_REQUEST_URI_TOO_LONG = 414;

/**
 * Status code (415) indicating that the server is refusing to service
 * the request because the entity of the request is in a format not
 * supported by the requested resource for the requested method.
 */
public static final int SC_UNSUPPORTED_MEDIA_TYPE = 415;

/**
 * Status code (416) indicating that the server cannot serve the
 * requested byte range.
 */
public static final int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;

/**
 * Status code (417) indicating that the server could not meet the
 * expectation given in the Expect request header.
 */
public static final int SC_EXPECTATION_FAILED = 417;

/**
 * Status code (500) indicating an error inside the HTTP server
 * which prevented it from fulfilling the request.
 */
public static final int SC_INTERNAL_SERVER_ERROR = 500;

/**
 * Status code (501) indicating the HTTP server does not support
 * the functionality needed to fulfill the request.
 */
public static final int SC_NOT_IMPLEMENTED = 501;

/**
 * Status code (502) indicating that the HTTP server received an
 * invalid response from a server it consulted when acting as a
 * proxy or gateway.
 */
public static final int SC_BAD_GATEWAY = 502;

/**
 * Status code (503) indicating that the HTTP server is
 * temporarily overloaded, and unable to handle the request.
 */
public static final int SC_SERVICE_UNAVAILABLE = 503;

/**
 * Status code (504) indicating that the server did not receive
 * a timely response from the upstream server while acting as
 * a gateway or proxy.
 */
public static final int SC_GATEWAY_TIMEOUT = 504;

/**
 * Status code (505) indicating that the server does not support
 * or refuses to support the HTTP protocol version that was used
 * in the request message.
 */
public static final int SC_HTTP_VERSION_NOT_SUPPORTED = 505;

常见应用

1. 向浏览器输出消息

2. 下载文件

   1. 要获取下载的文件路径
   2. 下载的文件名
   3. 想办法让浏览器支持下载我们需要的东西
   4. 获取下载文件的输入流
   5. 创建缓冲区
   6. 获取OutputStream
   7. 将FileOutputStream流写入到buffer缓冲区
   8. 使用OutputStream将缓冲区中的数据输出到客户端

   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

   package com.joker_yue.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; import java.net.URLEncoder; public class FileServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 1. 要获取下载的文件路径 String realPath = "E:\\Program\\Idea\\JavaLearning\\src\\MavenLearn\\Servlet-Response\\src\\main\\resources\\下载.png"; System.out.println("下载的文件的路径：" + realPath); // 2. 下载的文件名 String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1); // 3. 想办法让浏览器支持(Content-Disposition)下载我们需要的东西。使用URLEncoder转换编码 resp.setHeader("Content-Disposition", "attachment;fileName=" + URLEncoder.encode(fileName, "UTF-8")); // 4. 获取下载文件的输入流 FileInputStream in = new FileInputStream(realPath); // 5. 创建缓冲区 int len = 0; byte[] buffer = new byte[1024]; // 6. 获取OutputStream ServletOutputStream out = resp.getOutputStream(); // 7. 将FileOutputStream流写入到buffer缓冲区 while(in.read(buffer) != -1){ out.write(buffer, 0, len); } in.close(); out.close(); } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { super.doPost(req, resp); } }

验证码功能

验证怎么来的

• 前端实现

• 后端实现

  • 需要用到Java的图片类，生成一个图片

    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 56 57 58 59 60 61 62

    package com.joker_yue.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, 80, BufferedImage.TYPE_INT_RGB); //得到图片 Graphics2D graphics =(Graphics2D) image.getGraphics();//笔 //设置图片的背景颜色 graphics.setColor(Color.white); graphics.fillRect(0, 0, 80, 20); //给图片写数据 graphics.setColor(Color.BLUE); graphics.setFont(new Font("宋体", Font.BOLD, 20)); graphics.drawString(makeNumber(),0,20); //告诉浏览器这个请求用图片的方式打开 resp.setContentType("image/png"); //网站存在缓存，不让浏览器缓存 resp.setDateHeader("Expires",-1); resp.setHeader("Cache-Control","no-cache"); resp.setHeader("Pragma","no-cache"); //把图片写给浏览器 ImageIO.write(image,"png",resp.getOutputStream()); } //生成随机数 private String makeNumber(){ Random random = new Random(); String num = String.valueOf(random.nextInt(9999999)); // StringBuffer：拼接字符串 StringBuffer sb = new StringBuffer(); for (int i = 0; i < 7 - num.length(); i++) { sb.append("0"); } num= sb.toString() + num; return num; } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { super.doPost(req, resp); } }

实现重定向

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

常见场景：

• 用户登录成功跳转到另一个界面

  1	public void sendRedirect(String location) throws IOException;

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

  package com.joker_yue.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.sendRedirect("/down/img");//要加项目路径'/down' } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { super.doPost(req, resp); } }

• 分析：

  虽然只需一句就可以实现重定向

  1	resp.sendRedirect("/down/img");//要加项目路径'/down'

  但是它其实做了这些：

  1 2 3 4

  //设置了要跳转的地址 resp.setHeader("Location", "/down/img");//要加项目路径'/down' //设置了状态码302 resp.setStatus(HttpServletResponse.SC_FOUND);

• 用户登录

  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

  package com.joker_yue.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 doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { } @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 = " + username); System.out.println("password = " + password); // 重定向一定要注意路径问题，否则容易404 resp.sendRedirect("/down/success.jsp"); } }

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

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

HttpServletRequest

请求：要想接收浏览器发送过来的参数,通过request就可以了

HttpServletRequest代表客户端的请求，用户通过Http协议访问服务器，HTTP请求中的所有信息将会被封装到HttpServletRequest

获取前端传递的参数

获取前端传递的参数，请求转发

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

package com.joker_yue.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.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("hobby");
        System.out.println("=========================");
        System.out.println("username = " + username);
        System.out.println("password = " + password);
        System.out.println(Arrays.toString(hobbies));
        System.out.println("=========================");

        // 通过sendRedirect()方法重定向
        // resp.sendRedirect("/success.jsp");

        // 请求转发，转到success.jsp
        /* 说明：这里的/ 代表当前的web应用
         * 也就是这里的 /success.jsp 其实是 http://localhost:8080/request/success.jsp
         * success前面的/ 代替了很长一串目录
         * */
        // 因为转发是服务器内部的，不需要写绝对路径 （/是绝对路径）
        // 而重定向可以定位到项目之外，所以要写
        req.getRequestDispatcher("/success.jsp").forward(req, resp);

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(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

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录</title>
</head>
<body>
<h1>登录</h1>
<div style="text-align: center">
    <%--    这里表单表达的意思：以get方式提交表单，提交到login请求    --%>
    <form action="${pageContext.request.contextPath}/login" method="get">
        用户名:<input type="text" name="username"><br/>
        密码:<input type="password" name="password"><br/>
        爱好:
        <input type="checkbox" name="hobby" value="唱歌">唱歌
        <input type="checkbox" name="hobby" value="女孩">女孩
        <input type="checkbox" name="hobby" value="代码">代码
        <input type="checkbox" name="hobby" value="游戏">游戏
        
        <br/>
        <input type="submit" >
    </form>
</div>
</body>
</html>

Session、Cookie

cookie是监视器，session是会话

会话

会话：用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器。这整个过程，可以看作一个会话

有状态会话：你能如何证明你是中国人。出生证：中国给你的；居住证：中国你来过

​ 一个网站怎么证明你来过： 服务端给客户端一个信件，客户端下次访问服务端带上信件就可以了。这个信件就是cookie。服务器登记客户端信息，下次来的时候匹配一下。这个信息就是session。

保存会话的两种技术

cookie

• 客户端技术（响应，请求）

session

• 服务器技术，利用这个技术，可以保存用户的会话信息。我们可以把信息或者数据放在session中

常见场景

• 网站登录之后，你下次就不用再登录了，第二次访问直接就上去了

Cookie

1. 从请求中拿到Cookie

2. 服务器响应给客户端Cookie

   1 2 3 4 5 6

   Cookie[] cookies = req.getCookies(); // 获得cookie cookie.getName(); // 获得cookie中的key cookie.getValue(); // 获得cookie中的值 Cookie cookie = new Cookie("lastVisit", System.currentTimeMillis() + ""); //新建一个cookie cookie.setMaxAge(24*60*60); // 设置Cookie有效期 resp.addCookie(cookie); //响应给客户端一个Cookie

一个网站cookie是否存在上限？

• 一个cookie 只能保存一个信息

• 一个web站点可以给浏览器发送多个cookie。最多存放20个cookie

• cookie大小有限制，4kB

• 浏览器上限300个Cookie

删除Cookie：

• 不设置有效期，关闭浏览器，自动失效

• 设置有效期0

转码解码：

1

Cookie cookie = new Cookie("username", URLEncoder.encode("九歌", "UTF-8"));

1

out.write(URLDecoder.decode(cookie.getValue(), "UTF-8"));

Session

什么是session

• 服务器会给每一个用户（浏览器）创建Session（会话）

• 一个Session独占一个浏览器，只要浏览器没关，这个Session就存在

• 用户登录之后，整个网站它都可以访问 -->保存用户的信息

cookie和session的区别

• cookie是把用户的数据写给用户的浏览器，浏览器保存（可以保存多个）

• session是把用户的数据写到独占的Session对象中，服务器端保存（保存重要信息，避免资源浪费）

• session对象由服务器创建

HttpSession类

Session在创建的时候做了什么

1
2

Cookie jsessionid = new Cookie("JSESSIONID", sessionId);
resp.addCookie(jsessionid);

使用Session

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

package com.joker_yue.servlet;

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

// 创建Session
public class SessionTest01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 解决乱码
        req.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=UTF-8");

        //得到Session
        HttpSession session = req.getSession();

        //给Session存东西
        session.setAttribute("username", new Person("Joker",19));

        //获取session的ID
        String sessionId = session.getId();

        //判断session是不是新创建的
        if (session.isNew()) {
            resp.getWriter().write("创建Session成功"+sessionId);
        }else {
            resp.getWriter().write("Session已经存在"+sessionId);
        }

        // Session在创建的时候做了什么事情
        Cookie jsessionid = new Cookie("JSESSIONID", sessionId);
        resp.addCookie(jsessionid);


    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doGet(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

package com.joker_yue.servlet;

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

// 得到Session
public class SessionTest02 extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doGet(req, resp);
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 解决乱码
        req.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=UTF-8");

        //得到Session
        HttpSession session = req.getSession();

        Person person = (Person) session.getAttribute("username");
        System.out.println(person.toString());
    }
}

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

package com.joker_yue.servlet;

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

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

package com.joker_yue.servlet;

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

// 注销Session
public class SessionTest03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 解决乱码
        req.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=UTF-8");

        // 得到Session
        HttpSession session = req.getSession();
        Person person = (Person) session.getAttribute("username");

        // 手动注销Session
        session.invalidate();
    }

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

设置Session超时

• 在web.xml中：

  1 2 3 4 5

  <!-- 设置Session的超时时间 --> <session-config> <!-- 超时时间：15分钟 --> <session-timeout>15</session-timeout> </session-config>

使用场景

• 保存一个登录用户的信息

• 购物车信息

• 在整个网站中，经常会使用的数据，我们将他保存在session中

注意：

• Session在浏览器打开会话的一瞬间就创建了

  

JSP

什么是JSP

Java Server Page：Java服务器端页面，也和Servlet一样，用于动态web技术

最大特点：

• 写jsp就像是写HTML

• 区别：

  • HTML只给用户提供静态数据
  • jsp页面中可以嵌入java代码，为用户提供动态数据

JSP原理

思路：jsp到底怎么执行的

• 代码层面没有任何问题

• 服务器内部工作

  tomcat中有一个work目录

  IDEA中使用Tomcat的会在IDEA中生成一个work目录

• jsp最终会被转成Java程序

• 浏览器向服务器发送请求，不管访问什么资源，其实都是在访问servlet

• jsp本质上就是一个Servlet

  1	public abstract class HttpJspBase extends HttpServlet implements HttpJspPage

  1 2 3 4 5 6 7 8 9

  //初始化 public void _jspInit() { } //销毁 protected void _jspDestroy() { } //JSPService public void _jspService(HttpServletRequest var1, HttpServletResponse var2)

1. 执行请求

2. 内置了一些对象

   1 2 3 4 5 6 7

   final javax.servlet.jsp.PageContext pageContext; //页面上下文 final javax.servlet.ServletContext application; //applicationContext final javax.servlet.ServletConfig config; //config javax.servlet.jsp.JspWriter out = null; //out final java.lang.Object page = this; //page：当前 HttpServletRequest var1 //请求 HttpServletResponse var2 //响应

3. 输出页面前增加的代码

   1 2 3 4 5 6 7

   response.setContentType("text/html; charset=UTF-8"); //设置响应的页面类型 pageContext = _jspxFactory.getPageContext(this, request, response,null, false, 8192, true); _jspx_page_context = pageContext; application = pageContext.getServletContext(); config = pageContext.getServletConfig(); out = pageContext.getOut(); _jspx_out = out;

4. 以上的这些对象我们可以直接在jsp页面中直接使用

5. 我们可以直接在<% %>中使用java代码

6. 

JSP基础语法

表达式

1
2
3
4
5

<%--JSP表达式
作用：用来将程序的输出，输出到客户端
<% 变量或者表达式 %>
--%>
<%= new java.util.Date()%>

脚本片段

1
2
3
4
5
6
7
8

<%--  jsp脚本片段  --%>
    <%
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        out.println("<h1>Sum=" + sum + "</h1>");
    %>

JSP脚本的再实现

1
2
3
4
5
6
7
8
9
10
11

 <%--脚本片段的再实现--%>
    <%
        int x = 10;
        out.println(x);
    %>
<p>这是一个JSP文档</p>
    <%
        //int x = 10;
        //你将无法再此处再定义x，因为上面已经定义
        out.println(x);
    %>

在代码中嵌入HTML

1
2
3
4
5
6
7
8

<%--在代码中嵌入HJTML--%>
    <%
        for (int i = 0; i < 5; i++) {
    %>   
	<h1>Hello,World <%=i%></h1>
    <%
        }
    %>

JSP声明：会被编译到JSP生成的Java的类中，其他的会被生成到_jspService方法中

1
2
3
4
5
6
7
8
9
10

<%--全局代码块--%>
    <%!
        static {
            System.out.println("Loading Servlet");
        }
        private int globalVar = 0;
        public void joker(){
            System.out.println("进入了方法Joker");
        }
    %>

也可以使用EL表达式（ExpressLanguage）

JSP的注释不会在客户端被查看到

自定义错误页面：在页面出错的时候将会自动定位到新页面

1
2
3
4
5

<%--定制错误页面
    此段代码写在jsp中
    如果此jsp出现错误，将会自动定位到下述页面
    --%>
<%@ page errorPage="500.jsp" %>

1
2
3
4
5
6
7
8

<!-- 定制错误页面
此段代码写在wen.xml中
如果访问的页面出现错误，将会自动根据错误类型重定向
-->
<error-page>
    <error-code>404</error-code>
    <location>/404.jsp</location>
</error-page>

网页拼接

@include会将两个页面合二为一

jsp:include本质还是三个页面

JSP九大内置对象

1
2
3
4
5
6
7
8
9

request内置对象
response内置对象
page内置对象
session内置对象
application内置对象
out内置对象
exception内置对象
config内置对象
pageContext内置对象

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

<%--内置对象--%>
<%
    pageContext.setAttribute("name1", "Joker1");    //保存的数据只在一个页面中有效
    request.setAttribute("name2", "Joker2");        //保存的数据只在一次请求中有效，请求转发会携带这个数据，没有转发将会消失
    session.setAttribute("name3", "Joker3");        //保存的数据只在一次会话中有效，从打开浏览器到关闭浏览器
    application.setAttribute("name4", "Joker4");    //保存的数据只在服务器中有效，从打开服务器到关闭服务器
%>

<%
    //从pageContext中获取
    //作用域从底层到高层
    String name1 = (String) pageContext.getAttribute("name1");
    String name2 = (String) pageContext.getAttribute("name2");
    String name3 = (String) pageContext.getAttribute("name3");
    String name4 = (String) pageContext.getAttribute("name4");
    String name5 = (String) pageContext.getAttribute("name5");//不存在
%>

<%--使用EL表达式输出--%>
    <h1>取出的值:</h1>
    <h3>${name1}</h3>
    <h3>${name2}</h3>
    <h3>${name3}</h3>
    <h3>${name4}</h3>
    <h3>${name5}</h3>
<%--如果使用普通方法取出name5，会输出NULL--%>
    <h3><%=name5%></h3>

双亲委派机制：这层没找到就向上一层找，直到找到最顶层，没找到就会NULL

JSP标签，JSTL标签，EL表达式

EL表达式：${}

• 获取数据

• 执行运算

• 获取web开发的常用对象

• 调用Java方法

JSP标签

1
2
3
4
5
6
7
8
9
10

<h1>Page1</h1>
<%--
http://localhost:8080/jspTag.jsp?name=Joker&age=19
--%>
<%--页面跳转--%>
<%-- 转发的时候可以写东西的  --%>
<jsp:forward page="/jspTag2.jsp">
    <jsp:param name="name" value="Joker"/>
    <jsp:param name="age" value="19"/>
</jsp:forward>

1
2
3
4
5

<h1>Page2</h1>
<%--取出参数--%>
名字：<%=request.getParameter("name")%>
年龄:<%=request.getParameter("age")%>
</body>

JSTL表达式

JSTL标签库的使用就是为了弥补HTML标签的不足，它自定义了许多标签，可供我们使用，标签的功能和Java代码一样

核心标签是最常用的 JSTL标签。引用核心标签库的语法如下：

1

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

JSTL使用步骤：

1. 导入对应的taglib

2. 使用其中的方法

   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

   <%@ page contentType="text/html;charset=UTF-8" language="java" %> <%--引入JSTL--%> <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> <html> <head> <title>Title</title> </head> <body> <h4>if测试</h4> <hr> <form action="coreIf.jsp" method="get"> <input type="text" name="name" value="${param.name}"> <%-- EL表达式获取表单中的数据 ${param.参数名} --%> <input type="submit" value="提交"> </form> <%--判断如果提交的是管理员则登录成功,否则登录失败--%> <%--<%--%> <%-- if (request.getParameter("name").equals("admin")) {--%> <%-- out.println("登录成功");--%> <%-- }--%> <%--%>--%> <c:if test="${param.name == 'admin'}" var="isAdmin"> <c:out value="管理员登录成功"/> </c:if> <%--自闭合标签--%> <c:out value="${isAdmin}"/> </body> </html>

   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

   <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> <%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>Title</title> </head> <body> <%--定义一个变量--%> <c:set var="score" value="85"/> <c:choose> <c:when test="${score>=90}"> <c:out value="优秀"/> </c:when> <c:when test="${score>=80}"> <c:out value="良好"/> </c:when> <c:when test="${score>=70}"> <c:out value="中等"/> </c:when> <c:when test="${score>=60}"> <c:out value="及格"/> </c:when> <c:otherwise> <c:out value="不及格"/> </c:otherwise> </c:choose> </body> </html>

   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

   <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> <%@ page import="java.util.ArrayList" %> <%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>Title</title> </head> <body> <% ArrayList<String> people = new ArrayList<>(); people.add(0,"Jack"); people.add(1,"Tom"); people.add(2,"Jerry"); people.add(3,"Sam"); people.add(4,"Lily"); people.add(5,"Bob"); request.setAttribute("list",people); %> <%-- var:每次遍历出来的对象 items：要遍历的对象 --%> <c:forEach var="p" items="${list}" > <c:out value="${p}"/> <br> </c:forEach> <hr> <%-- 参数解释： var:每次遍历出来的对象 items：要遍历的对象 step：步长 begin：起始值 end：结束值 --%> <c:forEach begin="1" end="5" step="2" var="i" items="${list}"> <c:out value="${i}"/> </c:forEach> </body> </html>

JavaBean

实体类

JavaBean由特定的写法：

• 必须要有一个无参构造

• 属性必须私有化

• 必须要有对应的get/set

一般用来和数据库的字段做映射 ORM

ORM：对象关系映射

• 表–>类

• 字段–>属性

• 行记录–>对象

people表：

1
2
3
4
5
6
7
8
9
10

class People{
    private int id;
    private String name;
    private int age;
    private String address;
}

class A{
    new People(1,"Joker1",18,"湖南");
}

MVC三层架构

什么是MVC：Model模型，View视图，Controller控制器

以往的开发逻辑：

• 用户直接访问控制层，控制层就可以直接操作数据库

  1 2 3 4 5 6

  servlet--CRUD-->数据库 弊端：程序十分臃肿，不利于维护 servlet的代码中：处理请求、响应、视图跳转、处理JDBC、处理业务代码、逻辑代码 架构：没有什么是加一层解决不了的 数据库有很多：Mysql、Oracle、SqlServer...我们只需要实现JDBC，就可以直接操作数据库

•