一、知识点1：动态网页的执行原理

容器初始化Servlet实例，根据请求方法，调用相应的doXXX方法，并初始化请求和响应对象，作为doXXX方法的参数使用；
执行doXXX方法后，将响应对象中的数据流写到客户端；
客户端浏览器将收到的数据进行解析，显示给用户；

二、知识点2： JSP的功能与特性

（一）什么是jsp

JSP（Java Server Pages）java服务器端页面,是JavaEE规范中的Web组件，用来编写动态页面.

（二）jsp的特点

JSP运行在服务器端，本质是Servlet
JSP文件以.jsp为后缀，在工程目录中存在webapp目录下
JSP文件可以直接在浏览器中访问
JSP文件中的内容就是 HTML+Java代码，静态部分使用HTML和文本即可，动态部分使用Java代码

（三）课堂练习

1．目标

创建jsp

2．步骤

（1）webapp下新建JSP

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    1.jsp
</body>
</html>

（2）测试

三、知识点3： JSP的执行流程解析

（一）翻译

Web服务器找到a.jsp，对其进行翻译，生成a_jsp.java文件,就是Servlet；查看路径：

C:\Users\Administrator\AppData\Local\JetBrains\IntelliJIdea2020.1\tomcat\Unnamed_20210606_2\work\Catalina\localhost\20210606\org\apache\jsp

翻译的命名方式:

单词.jsp->单词_jsp.java

数字.jsp->_数字_jsp.java

public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)

throws java.io.IOException, javax.servlet.ServletException {

if (!javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {

final java.lang.String _jspx_method = request.getMethod();

if (“OPTIONS”.equals(_jspx_method)) {

response.setHeader(“Allow”,”GET, HEAD, POST, OPTIONS”);

return;

}

if (!”GET”.equals(_jspx_method) && !”POST”.equals(_jspx_method) && !”HEAD”.equals(_jspx_method)) {

response.setHeader(“Allow”,”GET, HEAD, POST, OPTIONS”);

response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, “JSP 只允许 GET、POST 或 HEAD。Jasper 还允许 OPTIONS”);

return;

}

final javax.servlet.jsp.PageContext pageContext;

javax.servlet.http.HttpSession session = null;

final javax.servlet.ServletContext application;

final javax.servlet.ServletConfig config;

javax.servlet.jsp.JspWriter out = null;

final java.lang.Object page = this;

javax.servlet.jsp.JspWriter _jspx_out = null;

javax.servlet.jsp.PageContext _jspx_page_context = null;

try {

response.setContentType(“text/html; charset=UTF-8”);

pageContext = _jspxFactory.getPageContext(this, request, response,

null, true, 8192, true);

_jspx_page_context = pageContext;

application = pageContext.getServletContext();

config = pageContext.getServletConfig();

session = pageContext.getSession();

out = pageContext.getOut();

_jspx_out = out;

out.write(“\r\n”);

out.write(“<!DOCTYPE html PUBLIC \”-//W3C//DTD HTML 4.01 Transitional//EN\” \”http://www.w3.org/TR/html4/loose.dtd\”>\r\n”);

out.write(“<html>\r\n”);

out.write(“<head>\r\n”);

out.write(“<meta http-equiv=\”Content-Type\” content=\”text/html; charset=UTF-8\”>\r\n”);

out.write(“<title>Insert title here</title>\r\n”);

out.write(“</head>\r\n”);

out.write(“<body>\r\n”);

out.write(“blank.jsp\r\n”);

out.write(“</body>\r\n”);

out.write(“</html>”);

} catch (java.lang.Throwable t) {

if (!(t instanceof javax.servlet.jsp.SkipPageException)){

out = _jspx_out;

if (out != null && out.getBufferSize() != 0)

try {

if (response.isCommitted()) {

out.flush();

} else {

out.clearBuffer();

}

} catch (java.io.IOException e) {}

if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);

else throw new ServletException(t);

}

} finally {

_jspxFactory.releasePageContext(_jspx_page_context);

}

（二）编译

服务器将a_jsp.java编译成类文件a_jsp.class，翻译和编译的过程遵守Servlet规范，因此说JSP的本质也是Servlet；

（三）实例化

服务器实例化类a_jsp.class

（四）提供服务：

调用类中的_jspService方法提供服务

（五）总结

1．为什么要使用JSP组件？

Servlet生成动态页面比较繁琐，使用JSP生成动态页面比较便捷，因为其中的静态内容可以使用HTML生成

2．JSP执行的流程是什么？

JSP的执行过程是：翻译-编译-实例化-提供服务

3．JSP的本质

JSP的本质就是Servlet，不过是服务器将JSP进行了翻译和编译；可以说，JSP也是一个Java类；

四、知识点1：脚本元素

（一）什么是脚本元素

脚本元素可以用来包含任意Java代码

（二）语法格式

<%Java代码%>

（三）特点

服务器翻译脚本元素时，将把其中Java代码直接翻译到_jspService方法中，如果语法错误，将在浏览器中提示错误

<body>

blank.jsp<br/>

System.out.println(“Hello Jsp!”);

</body>

out.write(“blank.jsp<br/>\r\n”);

System.out.println(“Hello Jsp!”);

out.write(“\r\n”);

（四）课堂练习(5分钟)

1．目标

在jsp写脚本元素

2．步骤

在jsp写java脚本

<%@ page language=“java” contentType=“text/html; charset=UTF-8”

pageEncoding=“UTF-8”%>

<!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN” “http://www.w3.org/TR/html4/loose.dtd”>

<html>

<head>

<title>Insert title here</title>

</head>

<body>

blank.jsp<br/>

System.out.println(“Hello Jsp!”);

</body>

</html>

Hello Jsp!

五、知识点2：表达式元素

（一）什么是表达式元素

表达式元素用来向页面输出动态内容

（二）语法格式

<%=Java代码%>

（三）特点

服务器翻译表达式元素时，将把其中Java代码部分的返回值使用out.print语句输出

<body>

<%=request.getRemoteAddr()%>

</body>

out.write(“<body>\r\n”);

out.print(request.getRemoteAddr());

out.write(“\r\n”);

out.write(“</body>\r\n”);

（四）课堂练习(5分钟)

1．目标

在jsp写脚本表达式

2．步骤

在jsp写java脚本表达式

<%@ page language=“java” contentType=“text/html; charset=UTF-8”

pageEncoding=“UTF-8”%>

<!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN” “http://www.w3.org/TR/html4/loose.dtd”>

<html>

<head>

<title>Insert title here</title>

</head>

<body>

<%=request.getRemoteAddr()%>

</body>

</html>

六、知识点3：模版元素

（一）什么是模板元素

模板元素指JSP中静态HTML或者XML内容

（二）模板元素

<!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN” “http://www.w3.org/TR/html4/loose.dtd”>

<html>

<head>

<title>Insert title here</title>

</head>

<body>

七、注释元素

在JSP中可以使用注释元素，有三种情况

（一）JSP注释

1．语法

格式为<%–JSP注释–%>；

2．特点

JSP的注释只有在源代码中可见，翻译时已经忽略；

<body>

<%–JSP注释 –%>

<%=request.getRemoteAddr()%>

</body>

out.write(“</head>\r\n”);

out.write(“<body>\r\n”);

out.print(request.getRemoteAddr());

out.write(“\r\n”);

out.write(“</body>\r\n”);

out.write(“</html>”);

（二）HTML注释

1．语法

<!–HTML注释–>

2．特点

在JSP中，除了使用JSP注释外，还可以使用HTML注释，<!–HTML注释–>，

HTML注释翻译时会被翻译成write(“<!– HTML注释 –>\r\n”),
会被返回到客户端，
在网页源代码能看见
但是不显示到页面中；

<body>

<!– HTML注释 –>

<%=request.getRemoteAddr()%>

</body>

out.write(“</head>\r\n”);

out.write(“<body>\r\n”);

out.write(“<!– HTML注释 –>\r\n”);

out.print(request.getRemoteAddr());

out.write(“\r\n”);

out.write(“</body>\r\n”);

查看网页源代码:

3．Java注释

（1）语法

单行://

多行:/**/

doc:/** */

（2）特点

JSP中的Java代码部分，可以使用Java注释；Java注释会翻译到.java文件中，但是编译时忽略；

<body>

//java注释

int i=0;

</body>

Java注释会翻译到.java文件中:

out.write(“<body>\r\n”);

//java注释

int i=0;

out.write(“\r\n”);

out.write(“</body>\r\n”);

八、知识点4：声明元素

（一）什么是声明元素

在JSP文件中定义类的成员变量或方法的元素叫做声明元素

（二）语法

<%!声明语句%>

（三）特点

声明元素被翻译到Java类中，而不是_jspService方法中；

实际中使用不多；

<body>

<%!

private String path=”WEB-INF”;

public String sayHello(String name){

return “Hello “+name;

}

</body>

public final class _05_002ddeclare_jsp extends org.apache.jasper.runtime.HttpJspBase

implements org.apache.jasper.runtime.JspSourceDependent,

org.apache.jasper.runtime.JspSourceImports {

private String path=”WEB-INF”;

public String sayHello(String name){

return “Hello “+name;

}

（四）课堂练习(5分钟)

1．目标

使用脚本表达式调用声明方法的返回值显示在页面上

2．步骤

（1）在jsp写声明方法有返回值

（2）在jsp使用脚本表达式调用方法传递参数

<%@ page language=“java” contentType=“text/html; charset=UTF-8”

pageEncoding=“UTF-8”%>

<!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN” “http://www.w3.org/TR/html4/loose.dtd”>

<html>

<head>

<title>Insert title here</title>

</head>

<body>

<%!

private String path=”WEB-INF”;

public String sayHello(String name){

return “Hello “+name;

}

<%=sayHello(“张三”) %>

</body>

</html>

public final class _05_002ddeclare_jsp extends org.apache.jasper.runtime.HttpJspBase

implements org.apache.jasper.runtime.JspSourceDependent,

org.apache.jasper.runtime.JspSourceImports {

private String path=”WEB-INF”;

public String sayHello(String name){

return “Hello “+name;

}

_jspService()方法:

out.print(sayHello(“张三”) );

九、知识点5：内置对象概念

（一）什么是内置对象

内置对象指的是在JSP中可以直接使用的对象，不需要声明，直接使用固定的名字使用即可；例如<%=request.getRemoteAddr()%>中的request就是内置对象；

（二）JSP的9大内置对象

1．分类

与输入/输出有关的对象： request、response、out
与属性作用域有关的对象：session、application、pageContext
与Servlet 相关对象：page、config
与错误处理有关的：exception

2．4大作用域

作用域范围从小到大顺序

page—->request—->session—->application

page 当前页面有效(页面跳转后无效）

request 同一次请求有效（请求转发后有效，重定向后无效）

session 同一次对话有效（同一个浏览器在退出关闭之前都有效）

application 全局有效（整个项目）

十、阶段总结

1.脚本元素、表达式元素的作用是什么？

脚本元素:<%任意的java代码%>

表达式元素:<%=java代码有返回值%> 向页面输出内容

2.有几种注释？

1.JSP注释 <%–JSP注释–%> 翻译忽略

2.HTML注释:<!–HTML注释–> 翻译有页面源代码有页面不显示

3.JAVA注释翻译有编译没有

// /**/ /***/

3.声明元素有什么不同？

java类成员变量或者成员方法不是在_jspService()方法中

<%!声明语句%>

4.内置对象是什么意思？如何使用？

直接使用的对象,不用声明就能使用,直接使用

5.JSP的9大内置对象

request

response

session

application

out

page

config

exception

pageContext

6.4个作用域范围

page

request

session

application

十一、Servlet与JSP的作用

（一）知识点1：Servlet与JSP的作用总结

1．JSP的作用

Servlet和JSP都可以生成动态页面；然而，显然JSP更适合生成动态页面，因为其中的静态部分可以直接使用HTML即可.

2．Servlet的作用

接收来自JSP的请求，
处理请求，
然后转到JSP页面把结果显示给客户端看

（二）知识点2：Servlet与JSP之间跳转的方式

有2种:

1．响应重定向

响应接口中提供了该方法

（1）使用方法

response.sendRedirect(request.getContextPath()+”/xxx”);

（2）特点

实际是两次HTTP请求，
服务器端在响应第一次请求的时候，让浏览器再向另外一个URL发出请求，从而达到转发的目的
浏览器地址栏发生变化,显示的是第二次请求的地址

2．请求转发

RequestDispatcher接口定义了请求转发的方法

要使用forward方法，需要先获得RequestDispatcher对象；请求接口中提供了获得该对象的方法：

（1）使用方法

request.getRequestDispatcher(url).forward(request,response);

（2）特点

客户端和浏览器只发出一次请求
请求转发是在服务器内部进行转发,
浏览器地址栏还是显示第一次请求的URL,没有发生变化

3．课堂练习(10分钟)

（1）目标

Servlet与JSP之间跳转的方式

（2）步骤

①创建登录的login.jsp,用户名和密码,提交按钮

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
    </head>
    <body>
        <form action="/login" method="post">
             用户名:<input type="text" name="username"/><br/>
             密码:<input type="password" name="password"/><br/>
            <input type="submit" name="提交">
        </form>
    </body>
</html>

②创建LoginServlet,处理登录的请求

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 LoginServlet 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 {
        /*返回请求参数的值作为 a String*/
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        if (username.equals("Tom") && password.equals("123")) {
            System.out.println("登陆成功");
            //请求转发可携带数据，刷新页面，会提交表单
            /*在此请求中存储一个属性。*/
            req.setAttribute("username", username);
            //重定向，不可携带数据，刷新不会再提交表单
            /*返回一个RequestDispatcher对象，该对象充当位于给定路径的资源的包装器。*/
            req.getRequestDispatcher(req.getContextPath() + "/login_success.jsp").forward(req, resp);
        } else {
            System.out.println("登陆失败");
            /*使用指定的重定向位置 URL 向客户端发送临时重定向响应。*/
            resp.sendRedirect(req.getContextPath() + "/login_fail.jsp");
            /*返回请求 URI 中指示请求上下文的部分。*/
        }
    }
}

配置web.xml

③创建login_success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
    </head>
    <body>
        <%--返回命名属性的值作为Object--%>
        <h1>欢迎<%=request.getAttribute("username")%> ，登陆成功</h1>
    </body>
</html>

④创建login_fail.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
    </head>
    <body>
        <h1>登陆失败</h1>
    </body>
</html>

⑤测试

（三）知识点3：请求属性的使用

如果需要在Servlet，JSP之间跳转时，同时把一些自定义的、或者通过数据库查询的、或者调用其他资源获得的数据传递到下一个资源时，就可以把这些数据设置为请求的属性即可。

请求属性可以是任意类型的对象，可以用setAttribute方法将对象作为属性存储到请求对象中

请求参数是用户提交请求时，自动封装到请求对象中的一些输入信息，都是String类型

1．课堂练习(10分钟)

（1）目标

向request作用域放值,使用请求转发后在jsp页面取值

（2）步骤

①Servlet调用request.setAttribute(name,value)向请求作用域里放值

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

//得到用户名

String username = request.getParameter(“username”);

//得到密码

String password = request.getParameter(“password”);

//判断用户名和密码是否正确

//正确

if (username.equals(“Tom”) && password.equals(“123”)) {

//向请求作用域放入数据,准备在页面接收并显示

request.setAttribute(“username”, username);

//请求转发到成功页面

request.getRequestDispatcher(“/success.jsp”).forward(request, response);

}else {//错误

//重定向到错误页面

response.sendRedirect(request.getContextPath()+”/error.jsp”);

}

②jsp使用request.getAttribute(name)取得值

<body>

success!!!

String username=(String)request.getAttribute(“username”);

<%=username%>

</body>

③测试

十二、阶段总结

（一）Servlet和JSP分别有什么作用？

1．JSP

动态页面

2．servlet

接收请求
处理请求
返回响应数据

（二）Servlet和JSP之间跳转有几种方式，有何区别？

1．响应重定向

发2次请求
服务器端在响应第一次请求的时候，让浏览器再向另外一个URL发出请求，从而达到转发的目的
地址栏发生变化

2．请求转发

1次请求
服务器内部转发
地址栏不发生变化

（三）什么是请求属性？和请求参数有啥区别？

请求属性可以是任意类型的对象，可以用setAttribute方法将对象作为属性存储到请求对象中

请求参数是用户提交请求时，自动封装到请求对象中的一些输入信息，都是String类型

十三、添加base标签

<base> 标签为页面上的所有链接规定默认地址或默认目标。

使用 <base> 标签，浏览器随后将不再使用当前文档的 URL，而使用指定的基本 URL 来解析所有的相对 URL。这其中包括 <a>、<img>、<link>、<form> 标签中的 URL。

（一）课堂案例

1．目标及步骤

创建User类:id username password
创建UserListServlet
用户服务该servlet时候:
- 构建list集合,向集合放入6条user对象的数据
- 将该list集合对象放入request作用域属性中
- 将请求转发到jsp
在jsp里写一个table表格,表格的列包括:序号用户名密码
- 先从request作用域里取出list集合对象
- 使用java脚本for循环list集合对象
- 取出每一个user对象
- 将user对象的各个属性显示在对应的列上

2．代码

package com.tjetc.domain;

public class User {
    private Integer id;
    private String username;
    private String password;
    public User(Integer id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }
    public User() {
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

package com.tjetc.servlet;
import com.tjetc.domain.User;
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.ArrayList;
import java.util.List;
public class UserListServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//        (1)构建list集合,向集合放入6条user对象的数据
        List<User> list=new ArrayList<>();
        list.add(new User(1,“zs1”,“123”));
        list.add(new User(2,“zs2”,“123”));
        list.add(new User(3,“zs3”,“123”));
        list.add(new User(4,“zs4”,“123”));
        list.add(new User(5,“zs5”,“123”));
        list.add(new User(6,“zs6”,“123”));
//                (2)将该list集合对象放入request作用域属性中
        request.setAttribute(“list”,list);
//                (3)将请求转发到list.jsp
        request.getRequestDispatcher(“/list.jsp”).forward(request,response);
}
}

<%@ page import=”java.util.List” %>
<%@ page import=”com.tjetc.domain.User” %>
<%@ page contentType=”text/html;charset=UTF-8” language=”java” %>
<html>
<head>
    <base href=“${pageContext.request.contextPath}/”/>
    <title>Title</title>
</head>
<body>
<table border=“1” cellspacing=“0”>
    <tr>
        <td>序号</td>
        <td>用户名</td>
        <td>密码</td>
    </tr>
    <%
//        (1)先从request作用域里取出list集合对象
        List<User> list= (List<User>) request.getAttribute(“list”);
//            (2)使用java脚本for循环list集合对象
        for (User user : list) {//(3)取出每一个user对象
     %>
    <tr>
        <%–(4)将user对象的各个属性显示在对应的列上–%>
        <td><%=user.getId()%></td>
        <td><%=user.getUsername()%></td>
        <td><%=user.getPassword()%></td>
    </tr>
    <%
        }
    %>
</table>
</body>
</html>

（二）课堂案例

1．思路及步骤

创建User类:id username password
创建Db类
- 声明静态成员变量list
- 在静态代码块中向list集合放入6条user对象数据
创建UserListServlet
- 当用户服务该servlet时候,就把list放入request作用域
- 将请求转发到jsp
在jsp里写一个table表格,表格的列包括:序号用户名密码
- 先从request作用域里取出list集合对象
- 使用java脚本for循环list集合对象
- 取出每一个user对象
- 将user对象的各个属性显示在对应的列上
jsp用户注册,form表单:id,username,password 提交按钮提交到UserAddServlet
在UserAddServlet
- 接收请求参数id,username,password,
- 创建user对象
- 向list添加新创建的user对象
- 重定向到/list

十四、总结

1.JSP的本质也是一个Java类，不过是服务器进行翻译编译；遵守Servlet规范，所以也可以说JSP的本质就是Servlet；

2.JSP的执行流程经过翻译-编译-实例化-提供服务几个步骤；

3.JSP文件包括HTML及Java代码，根据不同的需要，可以使用页面元素、表达式元素、注释元素、声明元素；

4.服务器总是把JSP文件按照一定的规范进行翻译，除了声明元素外，所有JSP中的内容都翻译到_jspService方法体中，该方法总是定义一系列的对象，称为内置对象，可以在编写JSP时直接使用，比如request/response/out等。

5.JSP主要用来生成动态页面，Servlet用来接收请求并处理请求，根据结果跳转到不同的JSP显示结果；

6.有两种跳转方法：响应重定向、请求转发；

7.请求属性可以用来在组件之间共享对象；

1.动态网页的执行原理

1.容器初始化Servlet实例，根据请求方法，调用相应的doXXX方法，并初始化请求和响应对象，作为doXXX方法的参数使用；

2.执行doXXX方法后，将响应对象中的数据流写到客户端；

3.客户端浏览器将收到的数据进行解析，显示给用户；

2.（一）什么是jsp

JSP（Java Server Pages）java服务器端页面,是JavaEE规范中的Web组件，用来编写动态页面.

（二）jsp的特点

1.JSP运行在服务器端，本质是Servlet

2.JSP文件以.jsp为后缀，在工程目录中存在WebContent目录下

3.JSP文件可以直接在浏览器中访问

4.JSP文件中的内容就是 HTML+Java代码，静态部分使用HTML和文本即可，动态部分使用Java代码

3.JSP的执行过程是：翻译-编译-实例化-提供服务

（一）什么是脚本元素

脚本元素可以用来包含任意Java代码

（二）语法格式

<%Java代码%>

（三）特点

服务器翻译脚本元素时，将把其中Java代码直接翻译到_jspService方法中，如果语法错误，将在浏览器中提示错误

5.（一）什么是表达式元素

表达式元素用来向页面输出动态内容

（二）语法格式

<%=Java代码%>

（三）特点

服务器翻译表达式元素时，将把其中Java代码部分的返回值使用out.print语句输出

6.（一）什么是模板元素

模板元素指JSP中静态HTML或者XML内容

7.七、注释元素

在JSP中可以使用注释元素，有三种情况

1.JSP <%–JSP注释–%> 源代码可见翻译忽略

2.HTML <!–HTML–> 源代码翻译网页源代码有页面不显示

3.java // /**/ /** */

8.八、声明元素

（一）什么是声明元素

在JSP文件中定义类的成员变量或方法的元素叫做声明元素

（二）语法

<%!声明语句%>

（三）特点

声明元素被翻译到Java类中，而不是_jspService方法中；

9.JSP的9大内置对象

request

response

session

application

out

page

config

exception

pageContext

4个作用域范围

page

request

session

application

1．分类

与输入/输出有关的对象： request、response、out
与属性作用域有关的对象：session、application、pageContext
与Servlet 相关对象：page、config
与错误处理有关的：exception

2．4大作用域

作用域范围从小到大顺序

page—->request—->session—->application

page 当前页面有效(页面跳转后无效）

request 同一次请求有效（请求转发后有效，重定向后无效）

session 同一次对话有效（同一个浏览器在退出关闭之前都有效）

application 全局有效（整个项目）

10.

1．JSP的作用

Servlet和JSP都可以生成动态页面；然而，显然JSP更适合生成动态页面，因为其中的静态部分可以直接使用HTML即可.

2．Servlet的作用

1.接收来自JSP的请求，

2.处理请求，

3.然后转到JSP页面把结果显示给客户端看

11.Servlet和JSP之间跳转有几种方式，有何区别？

1．响应重定向

1.发2次请求

2.服务器端在响应第一次请求的时候，让浏览器再向另外一个URL发出请求，从而达到转发的目的

3.地址栏发生变化

2．请求转发

1.1次请求

2.服务器内部转发

3.地址栏不发生变化

（三）什么是请求属性？和请求参数有啥区别？

请求属性可以是任意类型的对象，可以用setAttribute方法将对象作为属性存储到请求对象中

请求参数是用户提交请求时，自动封装到请求对象中的一些输入信息，都是String类型

本文链接：https://www.cnblogs.com/seventeen9588/p/16337727.html

Java-JSP

一、知识点1：动态网页的执行原理

二、知识点2： JSP的功能与特性

（一）什么是jsp

（二）jsp的特点

（三）课堂练习

1．目标

2．步骤

（1）webapp下新建JSP

（2）测试

三、知识点3： JSP的执行流程解析

（一）翻译

（二）编译

（三）实例化

（四）提供服务：

（五）总结

1．为什么要使用JSP组件？

2．JSP执行的流程是什么？

3．JSP的本质

四、知识点1：脚本元素

（一）什么是脚本元素

（二）语法格式

（三）特点

（四）课堂练习(5分钟)

1．目标

2．步骤

五、知识点2：表达式元素

（一）什么是表达式元素

（二）语法格式

（三）特点

（四）课堂练习(5分钟)

1．目标

2．步骤

六、知识点3：模版元素

（一）什么是模板元素

（二）模板元素

七、注释元素

（一）JSP注释

1．语法

2．特点

（二）HTML注释

1．语法

2．特点

3．Java注释

（1）语法

（2）特点

八、知识点4：声明元素

（一）什么是声明元素

（二）语法

（三）特点

（四）课堂练习(5分钟)

1．目标

2．步骤

（1）在jsp写声明方法有返回值

（2）在jsp使用脚本表达式调用方法传递参数

九、知识点5：内置对象概念

（一）什么是内置对象

（二）JSP的9大内置对象

1．分类

2．4大作用域

十、阶段总结

十一、Servlet与JSP的作用

（一）知识点1：Servlet与JSP的作用总结

1．JSP的作用

2．Servlet的作用

（二）知识点2：Servlet与JSP之间跳转的方式

1．响应重定向

（1）使用方法

（2）特点

2．请求转发

（1）使用方法

（2）特点

3．课堂练习(10分钟)

（1）目标

（2）步骤

①创建登录的login.jsp,用户名和密码,提交按钮

②创建LoginServlet,处理登录的请求

配置web.xml

③创建login_success.jsp

④创建login_fail.jsp