前言：写这篇博客目的也是为了自己复习，本博客是在学习学校课程所做的笔记,供本人复习之用。
JavaWebjava 8 、Tomcat 7.0.61、mysql 5.7.62
资源都在这，链接：https://pan.baidu.com/s/1qHhAaBRNajj6ujlwdFjAdA?pwd=1234
提取码：1234
JavaWeb是通过Java语言编写可以通过浏览器访问的程序的总称，叫JavaWeb。JavaWeb是基于请求和响应来开发的。
常用的web服务器
安装
找到你需要的tomcat版本对应的zip压缩文件，解压到需要安装的目录即可。
tomcat你可以去官网（https://apache.org/）下载，我网盘也有，链接：https://pan.baidu.com/s/1qHhAaBRNajj6ujlwdFjAdA?pwd=1234
提取码：1234
注意：下载的压缩包不要解压在有中文或者空格的文件夹下
目录介绍
bin: 存放tomcat服务器的可执行程序
conf: 配置文件
lib: tomcat服务器的运行jar包
logs: tomcat运行时输出的日志文件
temp: tomcat运行时产生的临时数据
webapps: 专门存放web程序的，里面5个文件夹，这五个是不能动别人的，随便哪一个删掉这个服务器就运行不了了。专门用于部署web工程的。
work: 工作目录，它会把我们一些需要翻译的代码编译成源文件，也就是tomcat把jsp转换为class文件的工作目录，当浏览器访问某个jsp页面时，tomcat会在work目录里把这个jsp页面转换成.java文件，比如将index.jsp转换为index_jsp.java文件，而后编译为index_jsp.class文件，最后tomcat容器通过ClassLoader类把这个index_jsp.class类装载入内存，进行响应客户端的工作。
启动服务器
找到这个bin目录里面，有个startup.bat文件，双击一下就可以启动了
在浏览器输入http://localhost:8080/ 或者http://127.0.0.1:8080/ 进行测试，localhost和127.0.0.1都是代表本机，能看到这个东西证明服务器安装成功了。
还可以通过dos命令去启动
catalina run
记住一点：这个服务器启动了是不能关的，关掉叫访问不了了。
启动失败的情况，启动了startup.bat出现的黑色窗口直接闪一下就退出了，是因为没有配置好环境变量。
1）JAVA_HOME
jdk真实的安装路径C:Program FilesJavajdk1.8.0_40
2）Path 新建
%JAVA_HOME%bin
这样再重启一下就可以了。
修改默认端口
记事本打开目录apache-tomcat-7.0.61conf 目录下的server.xml文件，往下找
Connector 连接
port 端口 8080
connectionTimeout 连接超时 20000–>20秒
redirectPort 重定向端口 8443
我就改成8081端口，改完之后保存
重新启动一下，在浏览器输入http://127.0.0.1:8081/
我们随便新建一个html文件部署到tomcat上进行访问，把文件放到apache-tomcat-7.0.61webapps下，我新建一个文件夹叫day01
更多时候我们不是把代码写好然后复制进去，应该是用Idea把代码写好，然后把项目部署到服务器里面，所以我们要用Idea去整合我们的服务器。
配置
File->Settings->Bulid,Execution,Deployment->Application Servers->点±>Tomcat Server
Apply ( 应用 )->OK
Application Server只有前面配置了，它才会自动帮你填。
点next，取个名叫myJavaWeb_day01，Finish
我们打开web文件夹看看，index.jsp就是我们web工程的首页，web.xml文件就是web工程的主配置文件
src：存放我们的源码的地方
web：是专门存放我们资源文件 ，里面有个目录叫WEB-INF，是一个受保护的目录，我们不能直接去访问它，在WEB-INF里面有一个web.xml是我们web工程的主配置文件，它主要可以在这个web.xml文件里面来配置web工程的一些组件，比如说我们的Servlet、jsp都需要到这里面来进行配置。我们还可以在WEB-INF下新建一个目录lib，用来放第三方jar包。
druid-1.0.9.jar:数据库连接池
mysql-connector-java-5.1.37-bin.jar:连接MySQL数据库驱动包
我们来测试一下包导入进来没有，新建文件srccomqibutestTestDb类（测试类）
package com.qibu.test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class TestDb {
public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection cn =DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/数据库名?characterEncoding=utf-8","账号","密码");
System.out.println(cn);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
连接成功，包已经导入进来了。
我们在web文件夹下有一个index.jsp，可以先理解成html
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
$Title$
这是myweb----index.jsp
$END$
现在我们要把项目部署到tomcat中
1）
HTTP port访问的端口，我的是8081，这些都是默认的，我们一般动的是Deployment，点击一下，可以看到之前已经帮我们全部添加好了，点击+号，这个意思是找到需要部署的web工程，把它添加到tomcat中去进行管理。
这些其实都已经帮我生成好了，我们什么都不用动。点击OK，运行就行了，默认访问我的首页。
到这就部署成功了。
每次写完代码都要重新运行才能看到效果，这时候我们可以设置热部署。
Servlet程序一定要有jsp-api.jar包，没有的可以到我的网盘里找。
servlet是javaWeb三大组件之一，分别是servlet、filter过滤器、listener监听器。
servlet是运行在服务器上的一个小程序，它可以接受请求，处理响应。
实现servlet程序方式一写一个类去实现Servlet接口。
实现它的所有的抽象方法，service()方法，接受请求处理响应。
到web.xml中配置servlet程序的访问地址。
srccomqibuservlet目录下创建一个MyServlet类
package com.qibu.servlet;
import javax.servlet.*;
import java.io.IOException;
public class MyServlet implements Servlet {
public MyServlet(){
System.out.println("MyServlet的构造函数");
}
//初始化
@Override
public void init(ServletConfig servletConfig) throws ServletException {
System.out.println("init");
}
//获得Servlet的配置
@Override
public ServletConfig getServletConfig() {
System.out.println("getServletConfig");
return null;
}
//专门用来处理请求和响应的方法
@Override
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
System.out.println("service");
}
//销毁
@Override
public void destroy() {
System.out.println("destroy");
}
@Override
public String getServletInfo() {
System.out.println("getServletInfo");
return null;
}
}
web.xml，我们要通过标签的方式去配置
MyServlet com.qibu.servlet.MyServlet MyServlet /myServlet
浏览器输入http://127.0.0.1:8081/myJavaWeb_day01_war_exploded/myServlet打开，我们去看idea控制台
再浏览器访问http://127.0.0.1:8081/myJavaWeb_day01_war_exploded/myServlet，我们发现每访问一次，service方法就会执行一次。
执行servlet的构造函数
执行init()初始化
1和2的访问只是在第一次访问servlet程序的时候会调用创建servlet。
执行service()方法。每次被访问都会被调用。
执行destroy销毁方法，当web工程停止的时候被调用。
1.url-pattern中配置的路径没有以斜杠打头。
InvalidmyServlet in servlet mapping
2.servlet-name配置的值不存在。
Servlet mapping specifies an unknown servlet name MyServle
3.servlet-class标签配置的全类名错误。
java.lang.ClassNotFoundException: com.qingruan.servlt.MyServlet实现servlet程序方式二
继承父类HttpServlet，它并没有要求我实现任何方法，但是取而代之有一个doGet方法（GET请求）、doPost方法（POST请求）等等
srccomqibuservlet目录下新建一个MyServlet1类
package com.qibu.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 MyServlet1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("get");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("post");
}
}
web.xml
MyServlet1 com.qibu.servlet.MyServlet1 MyServlet1 /myServlet1
Postman用GET和POST分别访问http://localhost:8081/myJavaWeb_day01_war_exploded/myServlet1，控制台打印get和post。
如果我们将来要保证不管是GET还是POST都执行同一段代码，我们可以要么在GET里面调用POST，要么POST调用GET。
修改doGet方法
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
Postman用GET和POST分别访问http://localhost:8081/myJavaWeb_day01_war_exploded/myServlet1，控制台打印两次post。
HttpServlet 继承的是 GenericServlet
实现servlet程序方式三继承父类GenericServlet ，GenericServlet 实现了 Servlet接口，并且将Servlet所有的方法都做了清空实现，也就是说它不需要你去实现了，你只需要继承GenericServlet ，实现service方法就可以了。
srccomqibuservlet目录下新建一个MyServlet2类
package com.qibu.servlet;
import javax.servlet.GenericServlet;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.IOException;
public class MyServlet2 extends GenericServlet {
@Override
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
System.out.println("MyServlet2..GenericServlet");
}
}
web.xml，我们要配置
MyServlet2 com.qibu.servlet.MyServlet2 MyServlet2 /myServlet2
浏览器访问http://localhost:8081/myJavaWeb_day01_war_exploded/myServlet2，控制台打印MyServlet2…GenericServlet。
Http协议实际上用 方式二 和 方式三 多
Http协议：客户端与服务器之间通信，发送的数据，需要遵守的规则。叫HTTP协议。协议中发送的数据又叫做报文。
get请求：
post请求：
200 表示请求成功
302 暂时性重定向,可以理解为该资源原本确实存在,但已经被临时改变了位置,就是地址A跳转到地址B啦
404 表示你要访问的数据不存在(请求地址错误)
500 表示服务器内部错误(代码错误)
HttpServletRequest类当请求进入tomcat服务器，tomcat服务器会把Http协议信息解析封装成reuqest对象。然后传递到doGet() / doPost()方法中给我们使用，我们可以通过HttpServletRequest对象，获取请求中信息。
System.out.println("获得请求方式==>"+req.getMethod());
System.out.println("获得请求绝对路径==>"+req.getRequestURL());
System.out.println("获得请求资源路径==>"+req.getRequestURI());
获取请求的参数
get和post都可用，注：不适用contentType为multipart/form-data
req.getParameter() 根据参数名称获取参数值
req.getParameterValues()将前端name属性相同的数据以阵列的方式取回
修改MyServlet1
package com.qibu.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 MyServlet1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("utf-8");
System.out.println("获得请求方式==>" + req.getMethod());
String username = req.getParameter("username");//req.getParameter() get和post都可用，注：不适用contentType为multipart/form-data
String password = req.getParameter("password");
//获得请求中同名的参数
String[] hobbys = req.getParameterValues("hobby");//将前端name属性相同的数据以阵列的方式取回
if (req.getMethod().equals("GET")) {
//获得请求中的参数
username = new String(username.getBytes("ISO-8859-1"), "utf-8");
for (int i = 0; i < hobbys.length; i++) {
hobbys[i] = new String(hobbys[i].getBytes("ISO-8859-1"), "utf-8");
}
} else {//POST
}
System.out.println("用户名:" + username + ",密码:" + password + ",爱好:" + Arrays.toString(hobbys));
}
}
//先以ISO-8859-1进行编码
String username = request.getParameter("username");
//再以UTF-8进行解码
username=new String(username.getBytes("ISO-8859-1"), "utf-8");
post请求中文乱码解决:
//设置请求的字符集为UTF-8，只能是Post请求
request.setCharacterEncoding("utf-8");
ServletConfig类
从字面上的意思可以理解是servlet的配置信息类。
作用：
1.可以获取servlet程序的class-name的值
2.可以获取初始化参数
3.获取servletContext对象
//初始化
@Override
public void init(ServletConfig config) throws ServletException {
System.out.println("init");
System.out.println("获得servlet的名字==>"+config.getServletName());
System.out.println("获得配置的初始化参数username==>"+config.getInitParameter("username"));
System.out.println("获得配置的初始化参数password==>"+config.getInitParameter("password"));
System.out.println("获得servletContext==>"+config.getServletContext());
}
ServletContext类
ServletContext是一个接口，它表示servlet上下文对象。
一个web工程，只有一个ServletContext对象。
ServletContext还是一个域对象。
ServletContext是在web工程部署启动的时候创建，web工程停止的时候消亡。
直观的感受就是用注解来代替xml。
@WebSerlvet注解常用属性：
| 属性名 | 类型 | 描述 |
|---|---|---|
| name | String | 指定Servlet 的name属性，等价于 |
| value | String[] | 该属性等价于urlPatterns属性。两个属性不能同时使用 |
| urlPatterns | String[] | 指定一组Servlet的URL匹配模式。等价于 |
| loadOnStartup | int | 指定Servlet的加载顺序，等价于 |
| initParams | WeblnitParam[] | 指定一组Servlet初始化参数，等价于 |
| asyncSupported | boolean | 声明Servlet是否支持异步操作模式，等价于标签 |
| description | String | 该Servlet的描述信息，等价于 |
| displayName | String | 该Servlet 的显示名，通常配合工具使用，等价于 |
@WebServlet(value = "/myServlet1",name = "MyServlet1")
public class MyServlet1 extends HttpServlet {
等价于
@WebServlet(value = "/myServlet1")
等价于
@WebServlet(urlPatterns = "/myServlet1")
更简便的方式是什么都不写
@WebServlet("/myServlet1")
等价于在web.xml中去配置servlet标签
请求转发请求转发是指，服务器收到请求后，从一次资源到另一个资源的操作叫做请求转发。
req.setAttribute(String key,Object value); 携带材料
Object value = req.getAttribute(“key”); 获取请求的参数(材料)
req.getRequestDispatcher(“/myServlet2”).forward(req,resp);请求转发
把前面写的代码删干净，创建MyServlet1和MyServlet2类
MyServlet1 类
@WebServlet("/myServlet1")
public class MyServlet1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("utf-8");
String username = req.getParameter("username");
//请求转发
req.setAttribute("key",username);//携带材料
//走到servlet2 /myServlet2路径 需要传递请求和响应对象
req.getRequestDispatcher("/myServlet2").forward(req,resp);
}
}
MyServlet2 类
@WebServlet("/myServlet2")
public class MyServlet2 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("myServlet2----doPost");
//获取请求的参数(材料)
Object value = req.getAttribute("key");
System.out.println("MyServlet2获得的材料:" + value);
}
}
测试：
当请求进入tomcat服务器，tomcat服务器都会去创建一个HttpServletResponse对象传递给servlet使用。HttpServletResponse表示是响应对象。
通过响应对象设置返回给客户端的信息设置响应中文乱码问题往客户端回传数据
resp.getWriter()返回的是io.PrintWriter是个流对象，其实本质上我们请求和响应就是我们的流传递（io流）
设置响应中文乱码问题 该方法一定要在获取流对象之前调用才有效
resp.setContentType(“text/html;charset=utf-8”);
注意不要跟前面设置请求中文乱码搞混了
修改MyServlet2 类
@WebServlet("/myServlet2")
public class MyServlet2 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//设置响应中文乱码问题 该方法一定要在获取流对象之前调用才有效
resp.setContentType("text/html;charset=utf-8");
System.out.println("myServlet2----doPost");
//获取请求的参数(材料)
Object value = req.getAttribute("key");
// 通过响应对象设置返回给客户端的信息
resp.getWriter().write("");
resp.getWriter().write("MyServlet2获得的材料:" + value);
resp.getWriter().write("");
}
}
请求重定向
请求重定向，客户端向服务器发送请求，然后服务器接收到客户端的请求，告诉客户端我给你一个新地址，你去新地址访问，叫请求重定向。
resp.sendRedirect(“myServlet4”);
com.qibu.servlet 新建一个MyServlet3类
package com.qibu.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("/myServlet3")
public class MyServlet3 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("utf-8");
String username = req.getParameter("username");
req.setAttribute("key",username);//携带材料
//请求重定向
resp.sendRedirect("myServlet4");//注意不要加/ ,如果要/打头要 "/工程名/"
}
}
新建一个MyServlet4类
package com.qibu.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("/myServlet4")
public class MyServlet4 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//获取请求的参数(材料)
Object value = req.getAttribute("key");
resp.getWriter().write("MyServlet4 ==>"+value);
}
}
浏览器输入http://localhost:8081/myJavaWeb_day01_war_exploded/myServlet3
不可以共享request域中数据，所以key数据拿不到，为null
重定向和请求转发的区别：
jsp全称Java Service pages。java服务器页面。
作用：代表servlet程序回传html页面的数据。
Jsp是对Servlet的一种高级封装，间接的继承了Servlet类，jsp页面本质上就是一个servlet程序。
当我们第一次访问jsp页面，tomcat服务器会将页面进行翻译成为.java文件，对它进行翻译为.class类文件程序。
Jsp的语法 1.jsp头部的page指令<%@ page contentType="text/html;charset=UTF-8" language="java" import="java.util.*,java.io.*" %>
2.jsp脚本<%@ 我们把它叫做指令，jsp指令，jsp头部的page指令
page 指令可以修改jsp页面一些属性。
language：表示jsp页面翻译后是什么语言文件。
import：用于导包，导类。
pageEncoding：当前jsp页面字符集编码格式，例如：“UTF-8”。
contentType: 表示当前的jsp返回的数据类型是什么。
isELIgnored:表示当前的这个页面是不是支持我们的EL表达式 ，默认false。
1)声明脚本
<%! //声明属性 方法
private int age;
private String sex;
public void say(){
System.out.print("123123");
}
%>
2)表达式脚本
作用：在jsp页面上输出数据，输出一个值的。
注意：<%= 后面不能写分号; %>
<%="hello jsp" %>
<%=123 %>
<%=request.getParameter("username") %>
request.getParameter(“username”)获取请求当中的参数，jsp页面本质上就是一个servlet程序，request对象是jsp九大内置对象之一，不需要我们去创建可以直接使用。
3)代码脚本
作用：可以在jsp页面中，书写自己的功能代码。
一个jsp页面中有多个java代码脚本，执行顺序是从往下执行。
<% %>
<%!..%> //声明时要加" ! "，属于类成员，最先加载，可写于任何位置；不加 ! 则是脚本的局部变量，必须调用前写。
新建success.jsp文件
<%@ page pageEncoding="UTF-8" language="java" %>
<%! //声明属性 方法
private int age;
private String sex;
public void say() {
System.out.print("123123");
}
%>
Title
<%="hello jsp" %>
<%=123 %>
<%= request.getParameter("username") %>
<%
int sex;//1男 2女
%>
<%
sex = 1;
if (sex == 1) {
%>
男
<% } else {%>
女
<% } %>
<%
age=18;
System.out.println(this.sex);
say();
%>
年龄：<%= age %>
浏览器访问http://localhost:8081/myJavaWeb_day01_war_exploded/success.jsp?username=tom
写个循环试试，success.jsp
<%@ page pageEncoding="UTF-8" language="java" %>
Title
<% for (int i = 1; i < 7; i++) { %>
<%= i %>
<% } %>
浏览器访问http://localhost:8081/myJavaWeb_day01_war_exploded/success.jsp
<% //声明属性 方法 %> <%-- jsp可以注释页面所有的代码，并且不会在浏览器看到注释 --%>Jsp九个内置对象
| 对象 | 描述 |
|---|---|
| request | 请求对象 |
| response | 响应对象 |
| application | jsp上下文对象(servletContext对象，所说的范围是我们整个web工程) |
| config | servletConfig对象 |
| exception | 异常对象 |
| out | jsp输出流对象 [ 就是我们前面使用的 resp.getWriter()返回的io.PrintWriter流对象] |
| session | 会话对象(一般用来保存登录用户信息) |
| page | 代表当前jsp的对象 |
| pageContext | jsp的上下文对象（范围是整个jsp页面） |
Jsp四大域对象几乎跟我们的Servlet是一样的
域对象就是可以像Map一样存取数据的对象，四个域对象功能一样，不同的是他们对数据的存取范围。
pageContext ----> request —> session —> application 从小到大的作用域顺序，优先顺序。
如果出现四个key相同，按照四个域从小到大的顺序去查找，pageContext—>request—>session—>application
pageContext:当前jsp页面范围有效
request:一次请求内有效
session:一次会话内有效(打开浏览器，直到没有关闭浏览器都有效)
application:整个web工程范围内都有效(只要web工程不停止，数据一直都在)
success.jsp
<%@ page pageEncoding="UTF-8" language="java" %>
Title
<%
//往四个域对象存放数据
pageContext.setAttribute("page","pageValue");
request.setAttribute("req","reqValue");
session.setAttribute("ses","sessValue");
application.setAttribute("app","appValue");
%>
pageContext: <%=pageContext.getAttribute("page") %>
request: <%=request.getAttribute("req") %>
session: <%=session.getAttribute("ses") %>
application: <%=application.getAttribute("app") %>
可以看到，在当前页面，我们分别往四个域对象中绑定了数据，可以看到在当前jsp页面四个域对象当中的数据都可以获得到。
在success.jsp加一行代码，请求转发到index1.jsp页面
<%@ page pageEncoding="UTF-8" language="java" %>
Title
<%
//往四个域对象存放数据
pageContext.setAttribute("page","pageValue");
request.setAttribute("req","reqValue");
session.setAttribute("ses","sessValue");
application.setAttribute("app","appValue");
%>
pageContext: <%=pageContext.getAttribute("page") %>
request: <%=request.getAttribute("req") %>
session: <%=session.getAttribute("ses") %>
application: <%=application.getAttribute("app") %>
<%
request.getRequestDispatcher("index1.jsp").forward(request,response); //请求转发到index1.jsp
%>
新建一个index1.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
index1页面
index1页面
pageContext: <%=pageContext.getAttribute("page") %>
request: <%=request.getAttribute("req") %>
session: <%=session.getAttribute("ses") %>
application: <%=application.getAttribute("app") %>
我们先在success.jsp分别往四个域对象中绑定了数据，然后请求转发到index1.jsp页面，我们发现pageContext这个数据拿不到了，因为pageContext只能在当前的jsp页面获取到数据，在另外一个jsp页面就拿不到了。
两个请求在index1.jsp添加一个链接，链接到https://blog.csdn.net/weixin_59633478/article/details/index2.jsp页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
index1页面
index1页面
pageContext: <%=pageContext.getAttribute("page") %>
request: <%=request.getAttribute("req") %>
session: <%=session.getAttribute("ses") %>
application: <%=application.getAttribute("app") %>
https://blog.csdn.net/weixin_59633478/article/details/index2.jsp
新建一个https://blog.csdn.net/weixin_59633478/article/details/index2.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
index2页面
index2页面
pageContext: <%=pageContext.getAttribute("page") %>
request: <%=request.getAttribute("req") %>
session: <%=session.getAttribute("ses") %>
application: <%=application.getAttribute("app") %>
浏览器输入http://localhost:8081/myJavaWeb_day01_war_exploded/success.jsp，点击超链接到https://blog.csdn.net/weixin_59633478/article/details/index2.jsp。发现request数据拿不到了，因为我们是第二次请求了，所以request数据拿不到了，
我们关闭浏览器，就是一次会话结束了，我们重新打开浏览器访问http://localhost:8081/myJavaWeb_day01_war_exploded/https://blog.csdn.net/weixin_59633478/article/details/index2.jsp
可以看到session数据没了，还发现application一直都有。
先浏览器访问http://localhost:8081/myJavaWeb_day01_war_exploded/success.jsp，关闭web工程，再启动工程，浏览器访问http://localhost:8081/myJavaWeb_day01_war_exploded/https://blog.csdn.net/weixin_59633478/article/details/index2.jsp
结果发现全都没了。
<%@ include file=“页面路径”%> 静态包含
特点：静态包含其实会把需要包含的jsp页面的代码直接复制到包含的位置,相当于直接把代码复制过来。
新建一个header.jsp
header
修改index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" import="java.util.*,java.io.*" %>
index
<%@ include file="header.jsp"%>
这是index.jsp
由于静态包含是直接把代码复制过来，那么就会有这么个问题，我的java代码是一起运行的。
index.jsp,假如我定义变量s
<%@ page contentType="text/html;charset=UTF-8" language="java" import="java.util.*,java.io.*" %>
index
<%@ include file="header.jsp"%>
<%
String s="index";
%>
这是index.jsp
header.jsp
<% String s="header"; %>header
报错了
