JSP

杂记

---

setContextType

Page指令

language 属性：声明使用的脚本语言
extends 属性：表明JSP编译成Servlet的时候继承的类。默认值：HttpJspBase
session 属性：表明JSP中是否可以直接使用session对象。默认值：true
buffer 属性：表明JSP对用户输出缓冲区大小。默认值：8kb
autoFlush属性：如果缓冲区大小溢出，是否自动刷出。默认：true
import属性：用于引入java包或者类
contentType属性：标明JSP被浏览器解析和打开的时候采用的默认字符集
pageEncoding属性：JSP文件及JSP翻译后的Servlet保存到硬盘上采用字符集
isErrorPage属性：处理JSP页面异常
errorPage属性：处理JSP页面异常
isElIgnored属性：通知JSP是否忽略EL语句

---

Include 指令属性

file属性：指示JSP页面包含页面路径

taglib 指令

taglib 指令用来声明JSP使用了定义的标签，同时引用标签库
语法格式如下：
<%@ taglib uri=”” prefix=”tagprefix”%>

内置对象

request对象的常用方法：

Object getAttribute(String name) 用来返回指定的属性值，该属性不存在时返回null
String getCharacterEncoding() 返回请求中的字符编码方法，可以在response对象中设置
String getContentType() 返回在response中定义的内容类型
String getContentPath() 返回请求的路径
Enumeration getHeaderNames() 返回所有HTTP头的名称集合
String getHeader(String name) 返回指定名称的HTTP头的信息
String getLocalName() 获取响应请求的服务器端主机名
String getLocalAddr() 获取响应请求的服务器端地址
String getLocalPort() 获取响应请求的服务器端口
String getMethod() 获取客户端向服务器端发送请求的方法（GET、POST）
String getParameter(String name) 获取客户端发送给服务器的参数值
Enumeration getParameterNames() 返回请求中所有参数的集合
String[] getParameterValues(String name) 获取请求中指定参数的所有值
String getQueryString() 返回GET方法传递的参数字符串，该方法不分解出单独的参数
String getRemoteAddr() 获取发出请求的客户端的IP地址
String getRemoteHost() 获取发出请求的客户端主机名
String getRealPath(String path) 返回给定虚拟路径的物理路径
String getRequestURI() 返回发出请求的服务器端地址，但是不包括请求的参数字符串
String getServletPath() 获取客户端所请求的脚本文件的文件路径
String getServerName() 返回响应请求的服务器名称或IP地址
String getServerPort() 返回响应请求的服务器端主机端口号
void setCharacterEncoding(String name) 设置请求的字符串编码格式

response对象的常用方法：

void addCookie(Cookie cookie) 创建一个Cookie对象并保存到客户端浏览器
void addHeader(String name,String value) 创建一个HTTP头，覆盖同名的旧HTTP头
String encodeRedirectURL(String url) 对sendRedirect()方法使用的URL进行编码
String encodeURL(String url) 对URL进行编码，回传包含sessionID的URL
void flushBuffer() 强制把当前缓冲区域的内容发送到客户端
String getCharacterEncoding() 获取响应的字符编码格式
void setCharacterEncoding(String charset) 设置响应使用的字符编码格式
void setContentLength(int length) 设置响应的BODY长度
void setContentType(String type) 设置响应类型
void sendRedirect(String url) 用于将对客户端的响应重定向到指定的URL上，这里可以使用相对URL
void setBufferSize(int size) 设置以KB为单位的缓冲区大小

out对象的常用方法：

void print(object obj) 将指定类型的数据输出到http流，不换行
void println(object obj) —换行
void clear() 清除缓冲区的数据，不把数据写到客户端
void clearBuffer() 清除缓冲区的当前内容，不把数据写到客户端
void flush() 输出缓冲区的数据
int getBufferSize() 返回缓冲区字节数的大小，如不设置缓冲区则为0
boolean isAutoFlush() 返回缓冲区满时，是自动清空还是抛出异常
close() 关闭输出流，从而可以强制终止当前界面的剩余部分向浏览器输出

session对象的常用方法：

void setAttribute(String name,Object obj) 将obj对象以name名称储存到会话中
Object getAttribute(String name) 获取指定名称相关联的session属性值
Enumeration getAttributeNames() 取得session对象所有的属性的集合，返回一个枚举类型数据
long getCreationTime() 获取session对象的创造时间，单位为毫秒
String getId() 获取sessionId的值
long getLastAccessedTime() 返回与当前session相关的客户端最后一次访问时间，由1970年1月1日算起，单位为毫秒
int getMaxInactiveInterval(int interval) 返回会话总时间，以秒为单位，即session对象的有效时间，当超过这个有效时间，此session被清除
void setMaxInactiveInterval(int interval) 设置session对象的有效时间
ServletContext getServeletContext() 返回一个该JSP页面对应的ServletContext对象实例
boolean isNew() 判断是否由服务器产生一个新的session对象
void invalidate() 销毁session对象

application对象的常用方法：

application对象实现了用户数据的共享

void setAttribute(String name,Object obj) 将obj对象以name名称储存到application对象中
Object getAttribute(String name) 获取指定名称相关联的application属性值
Enumeration getAttribute() 返回所有的application属性

JDBC常用API

Connection接口：表示与特定数据库之间的连接

Statement接口：用于执行SQL语句并返回它所生成结果的对象

PreparedStatement：Statement的子接口，用于执行预编译的SQL语句，当多次执行这条SQL语句时，可以调用预编译好的SQL语句，大大节省了时间

CallableStatement接口：是PreparedStatement接口的子接口，用于执行SQL存储过程

ResultSet接口：表示执行select语句所得到的结果集

ResultSetMetaData类：用来获取数据库表的结构，包括数据库的字段名称、类型、数目等所必须具备的信息

JDBC的连接

public static Connection getConnection() {
		Connection conn = null;
		
//		改变数据库连接变量conn的值
//		1.加载驱动类
		try {
			Class.forName("com.mysql.cj.jdbc.Driver");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
//		2.sql数据库的连接地址及用户名和密码
		String url = "jdbc:mysql://localhost:3306/onlinedb";
		String name = "root";
		String pwd = "zt20020806";
		
//		获取数据库连接
		try {
			conn = DriverManager.getConnection(url,name,pwd);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return conn;
	}



## 

XML

概念：Extensible Markup Language 可扩展标记语言

可扩展：标签可自定义

功能

存储数据

1.配置文件

2.在网络中传输

XML和 html的区别

1.xml标签都是自定义的，html标签是预定义

2.xml的语法严格，html语法松散

3.xml存储数据，html展示数据

语法

基本语法：

1.xml文档的后缀名 .xml

2.xml第一行必须定义为文档声明（第一行是空格也不行）

3.xml文档中有且仅有一个根标签

4.属性值必须用单引号或双引号包起来

5.标签必须正确关闭（双标签）

6.xml标签名称区分大小写

快速入门：

<?xml version='1.0' ?>
<users>
	<user id='1'>
		<name>张三</name>
		<age>23</age>
		<gender>男</gender>
	</user>

	<user id='2'>
		<name>李四</name>
		<age>24</age>
		<gender>男</gender>
	</user>
</users>

组成部分：

1.文档声明

1.格式

2.属性列表：

version：版本号，必须的属性

encoding：编码方式，告知解析引擎当前文档使用的字符集，默认值：ISO-8859-1

standalone：是否独立

​ 取值：

​ yes：不依赖其他文件

​ no：依赖其他文件

2.指令（了解）：结合css

<?xml version='1.0' ?>
<?xml-stylesheet type="text/css" href="index.css" ?>
<users>
	<user id='1'>
		<name>张三</name>
		<age>23</age>
		<gender>男</gender>
	</user>

	<user id='2'>
		<name>李四</name>
		<age>24</age>
		<gender>男</gender>
	</user>
</users>

3.标签：标签名称自定义的

规则：名称可以含字母、数字以及其他的字符

​ 名称不能以数字或者标点符号开始

​ 名称不能以字符 “xml”（或者 XML、Xml）开始

​ 名称不能包含空格

​ 可使用任何名称，没有保留的字词。

4.属性：

id属性值唯一

5.文本

1.CDATA区：在该区域中的数据会被原样进行展示

格式：

<![CDATA[
	if(a < b && a > c) {}
]]>

约束

谁编写xml？–用户，软件使用者

谁解析xml？–软件

• 约束：规定xml文档的书写规则

• 分类：

1.DTD：一种简单的约束技术

2.Schema：一种复杂的约束技术

• DTD：

  引入dtd文档到xml文档中

  • 内部dtd：将约束规则定义在xml文档中

  • 外部dtd：将约束的规则定义在外部的dtd文档中

  • • 本地：

    • 网络：

    • 直接写入

    • ```xml

      <!ELEMENT student (name,age,sex)><!--  student标签内的书写顺序 -->
      <!ELEMENT name (#PCDATA)><!--  字符串 -->
      <!ELEMENT age (#PCDATA)><!--  字符串 -->
      <!ELEMENT sex (#PCDATA)><!--  字符串 -->
      <!ATTLIST student number ID #REQUIRED><!--  不可重复 -->
      

      ]>

          * 
      
      * Schema:
      
        * 引入：
      
          * 1.填写xml文档的根元素
      
          * 2.引入xsi前缀，xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      
          * 3.引入xsd文件命名空间，xsi:schemaLocation="http://www.itcast.cn/xml student.xsd"
      
          * 4.为每一个xsd约束声明一个前缀，作为标识 xmlns="http://www.itcast.cn/xml"
      
          * ```xml
            <students xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                      xmlns:"http://www.itcast.cn/xml"
                      xsi:schemaLocation="http://www.itcast.cn/xml student.xsd">

3.解析：操作xml文档，将文档中的数据读取到内存中

• 操作xml文档

  • 1.解析（读取）：将文档中的数据读取到内存中
  • 2.写入：将内存中的数据保存到xml文档中。持久化的存储

• 解析xml的方式

  • DOM：将标记语言文档一次性加载进内存，在内存中形成一颗dom树

    • 优点：操作方便，可以对文档进行CRUD的所有操作
    • 缺点：占内存

  • SAX：逐行读取，基于事件驱动

    • 优点：不占内存
    • 缺点：只能读取，不能增删改

• xml常见的解析器

  • 1.JAXP：sun公司提供的解析器，支持dom和sax两种思想
  • 2.DOM4J：一款非常优秀的解析器
  • 3.Jsoup：是一款Java的HTML解析器，可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，可通过DOM，CSS以及类似于jQuery的操作方法来取出和操作数据
  • 4.PULL：Android操作系统内置的解析器，sax方式的

• Jsoup

  • 快速入门：

    • 步骤：

      • 1.导入jar包

      • 2.获取Document对象

      • 3.获取对应的标签Element对象

      • 4.获取数据

  • ```java
    // 获取Document对象，根据xml文档获取
    // 获取student.xml的path
    // .class获取字节码

        String path = JsoupDemo1.class.getClassLoader().getResource("student.xml").getPath();
    

    // 解析xml文档，加载文档进内存，获取dom树–>Document

        Document document = Jsoup.parse(new File(path),"utf-8");
    

    // 获取元素对象,Element

        Elements elements = document.getElementsByTag("name");
        System.out.println(elements.size());
    

    // 获取第一个name的Element对象

        Element element = elements.get(0);
    

    // 获取数据

        String name = element.text();
        System.out.println(name)
    

      
      * 
    
    * 对象的使用
      * Jsoup：工具类，可以解析html或xml文档，返回Document对象
        * parse：解析html或xml文档，返回Document
          * parse(File in,String charsetName)：解析xml或html文件的
          * parse(String html)：解析html或xml字符串
          * parse(URL url,int timeoutMillis)：通过网络路径获取指定的html或xml文档对象
        
      * Document：文档对象，代表内存中的dom树
      
        * 元素ELement对象的集合
      
          * getElementById(String id)：根据id属性值获取唯一的element对象
      
          * getElementsByTag(String tagName)：根据标签名获取元素对象集合
      
          * getElementsByAttribute(String key)：根据属性名称获取元素对象集合
          * getElementsByAttributeValue(String key, String value)：根据对应的属性名和属性值获取元素对象集合
      
      * Elements：元素ELement对象的集合，可以当作ArrayList<ELement>来使用
      
      * ELement：元素对象
      
        * 1.获取子元素对象 
      
          * getElementById(String id)：根据id属性值获取唯一的element对象
      
          * getElementsByTag(String tagName)：根据标签名获取元素对象集合
      
          * getElementsByAttribute(String key)：根据属性名称获取元素对象集合
          * getElementsByAttributeValue(String key, String value)：根据对应的属性名和属性值获取元素对象集合
      
        * 2.获取属性值
      
          * attr(String key)：根据属性名称获取属性值
      
        * 3.获取文本内容
      
          * String text()：获取文本内容
          * String html()：获取标签体的所有内容（包括子标签的字符串内容）
      
      * Node：节点对象
      
        * 是Document和Element的父类
      
          
    
    * 快捷查询方式：
      * 1.selector：选择器
        * 使用的方法：Elements selector(String cssQuery)
          * 语法：参考Selector类中定义的语法
      * 2.XPath：XPath即为XML路径语言，它是一种用来确定XML（标准通用标记语言的子集）文档中某部分位置的语言
        * 使用Jsoup的XPath需要额外导入jar包
        * 查询w3cschool参考手册，用XPath的语法完成查询
    
    ## Servlet
    
    ### web相关概念
    
    * 1.软件架构
      * C/S：客户端/服务器端
      * B/S：浏览器/服务器端
    
    * 2.资源分类
      * 1.静态资源：所有用户访问后，得到的结果是一样的，称为静态资源，静态资源可以直接被浏览器解析
        * 如：html,cssjavascript
      * 2.动态资源：每个用户访问相同资源后，得到的结果可能不一样。称为动态资源，动态资源被访问后，需要先转化为静态资源，再返回给浏览器
        * 如：servlet/jsp,php,asp.......
    
    * 3.网络通信三要素
    
      * 1.IP：电子设备在网络中的唯一标识
    
      * 2.端口：应用程序在计算机中的唯一标识。0~65536
    
      * 3.传输协议：规定了数据传输的规则
    
        * 1.基础协议：
    
          * 1.tcp：安全协议，三次握手。速度稍慢
          * 2.udp：不安全协议。速度快
    
          
    
    ### web服务器软件
    
    * 服务器：安装了服务器软件的计算机
    * 服务器软件：接收用户的请求，处理请求，做出响应
    * web服务器软件：接收用户的请求，处理请求，做出响应
      * 在web服务器软件中，可以部署web项目，让用户通过浏览器来访问这些项目
      * web容器
    
    * 常见的java相关的web服务器软件：
      * webLogic：oracle公司，大型的JavaEE服务器，支持所有的JavaEE规范，收费的。
      * webSphere：IBM公司，大型的JavaEE服务器，支持所有的JavaEE规范，收费的。
      * JBOSS：JBOSS公司的，大型的JavaEE服务器，支持所有的JavaEE规范，收费的。
      * Tomcat：Apache基金组织，中小型的JavaEE服务器，仅仅支持少量的JavaEE规范servlet/jsp。开源的，免费的。
    
    * JavaEE：Java语言在企业级开发中使用的技术规范的总和，一共规定了13项大的规范
    
    * Tomcat：web服务器软件
    
      * 1.下载：见官网
    
      * 2.安装：解压压缩包即可
    
        * 注意：安装目录建议不要有中文和空格
    
      * 3.卸载：删除目录即可
    
      * 4.启动：
    
        * bin/startup.bat,双击运行该文件即可
    
        * 访问：浏览器输入：http://localhost:8080（http://ip:8080可以做到访问他们）
    
        * 可能遇到的问题：
    
          * 1.黑窗口一闪而过
    
            * 原因：没有正确配置JAVA_HOME环境变量
    
          * 2.启动报错
    
            * 1.找到占用的端口号，并且找到对应的进程，杀死该进程
    
              * netstat -ano，找到占用的PID结束进程
    
            * 2.修改自身的端口号
    
              * conf/server.xml下修改
    
                ```xml
                <Connector port="8080" protocol="HTTP:/1.1" connectionTimeout="20000" redirectPort="8445" />

      * 一般会将tomcat的端口号改为80，80端口号是http协议的默认端口号。
        * 好处：在访问时不用输入端口号
    

  • 5.关闭：

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

  • 6.文件信息：

    • bin：可执行文件
    • conf：配置文件
    • lib：依赖jar包
    • logs：日志文件
    • temp：临时文件
    • webapps：存放web项目
    • work：存放运行时的数据

  • 7.配置：

    • 部署项目的方式：

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

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

      • 2.配置conf/server.xml文件

        • 在标签体中配置
        • docBase：项目存放的路径
        • path：虚拟目录

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

        • * 虚拟目录：xml文件的名称

    • 静态项目和动态项目：

      • 目录结构

        • java动态项目的目录结构

          – 项目的根目录

          ​ – WEB-INF目录：

          ​ – web.xml：web项目的核心配置文件

          ​ – classes目录：放置字节码文件的目录

          ​ – lib目录：放置依赖的jar包

    • 将Tomcat集成到IEDA中，并且创建JavaEE的项目，部署项目

Servlet：server applet

• 概念：运行在服务器的小程序

  • Servlet就是一个接口，定义了Java类被浏览器访问到（tomcat）的规则
  • 将来需要自定义一个类，实现Servlet接口，复写方法

• 快速入门：

  • 1.创建JavaEE项目

  • 2.定义一个类，实现Servlet接口

    • ```java
      public class ServletDemo1 implements Servlet

        * 
      
      * 3.实现接口中的抽象方法
      
      * 4.配置Servlet
      
        * 在web.xml中配置
      
        * ```jsp
          
          <!--    配置Servlet-->
              <servlet>
                  <servlet-name>demo1</servlet-name>
                  <servlet-class>com.example.tomcat_demo.ServletDemo1</servlet-class>
              </servlet>
          <!--    映射-->
              <servlet-mapping>
                  <servlet-name>demo1</servlet-name>
                  <url-pattern>/demo1</url-pattern>
              </servlet-mapping>

• 执行原理：

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

• Servlet中的生命周期：

  • 1.被创建：执行init方法，只执行一次
    • Servlet什么时候被创建？
      • 默认情况下，第一次被访问时，Servlet被创建
      • 可以配置执行Servlet的创建时机
        • 在标签下配置
          • 1.第一次被访问时，创建
            • 的值为负数
          • 2.在服务器启动时，创建
            • 的值为0或正整数
    • Servlet的init方法，只执行一次，说明一个Servlet在内存中只存在一个对象，Servlet是单例的
      • 多个用户同时访问时，可能存在线程安全问题
      • 解决：尽量不要在Servlet中定义成员变量，即使定义了成员变量，也不要修改值
  • 2.提供服务：执行service方法，执行多次
    • 每次访问Servlet时，Service方法都会被调用一次
  • 3.被销毁：执行destroy方法，只执行一次
    • Servlet被销毁时执行，服务器关闭时，Servlet被销毁
    • 只有服务器正常关闭时，才会执行destroy方法
    • destroy方法在Servlet被销毁之前执行，一一般用于释放资源

• Servlet3.0:

  • 好处：
    • 支持注解配置，可以不需要web.xml了
  • 步骤：
    • 1.创建JavaEE项目，选择Servlet的版本要3.0以上，可以不创建web.xml
    • 2.定义一个类，实现Servlet接口
    • 3.复写方法
    • 4.在类上使用@webServlet注解，进行配置
      • @WebServlet(“资源路径”)

IDEA与tomcat的相关配置

1.IDEA会为每一个tomcat部署的项目单独建立一份配置文件

• 查看控制台的log：Using CATALINA_BASE: “C:\Users\用户名\AppData\Local\JetBrains\IntelliJIdea2021.2\tomcat\dfb8989f-c5a5-440a-90fa-0a8f89abf92c”

2.工作空间项目和tomcat部署的web项目

• tomcat真正访问的是“tomcat部署的web项目”，“tomcat部署的web项目”对应着“工作空间项目”的目录下的所有资源
• WEB-INF目录下的资源不能直接被浏览器访问

3.断点调试，使用debug调试

Servlet的体系结构

Servlet –接口
|
GenericServlet –抽象类
|
HttpServlet

• GenericServlet：将Servlet接口中其他的方法做了默认空实现，只将service()方法作为抽象
  • 将来定义Servlet类时，可以继承GenericServlet，实现service()方法即可
• HttpServlet：对http协议的一种封装，简化操作
  • 1.定义类继承HttpServlet
  • 2.复写doGet/doPost方法

Servlet相关配置

1.urlparttern：Servlet访问路径

• 1.一个Servlet可以定义多个访问路径：@WebServlet({“/d4”,”/dd4”,”/ddd4”})
• 2.路径定义规则：
  • 1./xxx
  • 2./xxx/xxx：多层路径，目录结构
  • 3.*.do

Http:

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

  • 传输协议：定义了客户端和服务端通信时，发送数据的格式
  • 特点：
    • 1.基于TCP/IP的高级协议
    • 2.默认端口号：80
    • 3.基于请求/响应模型的：一次请求对应一次响应
    • 4.无状态的：每次请求之间相互独立
  • 历史版本：
    • 1.0：每次请求响应都会建立新的连接
    • 1.1：服用连接

• 请求消息数据格式

  • 1.请求行
    • 请求方式 请求url 请求协议/版本
    • GET/login.html HTTP/1.1
      • 请求方式：
        • HTTP协议有7种请求方式，常用的有2种
          • GET：
            • 1.请求参数在请求行中，在url后
            • 2.请求的url长度有限制
            • 3.不安全
          • POST：
            • 1.请求参数在请求体中
            • 2.请求的url长度没有限制
            • 3.相对安全
  • 2.请求头
    • 请求头名称：请求头值
      • 常见的请求头：
        • 1.User-Agent：浏览器告诉服务器，我访问你使用的浏览器版本信息
          • 可以在服务器端获取该头的信息，解决浏览器的兼容性问题
        • 2.Referer：http://localhost/login.html
          • 告诉服务器，我（当前请求）从哪里来？
            • 作用：
              • 1.防盗链
              • 2.统计工作
  • 3.请求空行
    • 空行，就是用于分割POST请求的请求头和请求体的。
  • 4.请求体（正文）
    • 封装POST请求消息的请求参数的

  字符串格式：

  ​ GET/login.html HTTP/1.1

  ​ Host:localhost

  1. Accept:

     text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,/;q=0.8,application/signed-exchange;v=b3;q=0.9

  2. Accept-Encoding:

     gzip, deflate, br

  3. Accept-Language:

     zh-CN,zh;q=0.9

  4. Connection:

     keep-alive

  5. Cookie:

     Idea-d37dec6f=fa9f839c-7baa-460a-a6b8-5c760add1c6e; JSESSIONID=68854B7F13843557287B8C28F2E756E4

  6. Host:

     localhost:8080

  7. Referer:

     http://localhost:8080/login.html

  8. sec-ch-ua:

     “ Not A;Brand”;v=”99”, “Chromium”;v=”96”, “Google Chrome”;v=”96”

  9. sec-ch-ua-mobile:

     ?0

  10. sec-ch-ua-platform:

      “Windows”

  11. Sec-Fetch-Dest:

      document

  12. Sec-Fetch-Mode:

      navigate

  13. Sec-Fetch-Site:

      same-origin

  14. Sec-Fetch-User:

      ?1

  15. Upgrade-Insecure-Requests:

      1

  16. User-Agent:

      Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36

  ​

• 响应消息数据格式

Request:

• tomcat服务器会根据请求url中的资源路径，创建对应的ServletDemo1的对象。
• tomcat服务器，会创建request和response对象，request对象中封装请求消息数据
• tomcat将request和response两个对象传递给service方法，并且调用service方法
• 程序员可以通过request对象获取请求消息数据，通过request对象获取请求消息数据，可以通过response对象设置响应消息数据
• 服务器在给浏览器做出响应之前，会从response对象中拿程序员设置的响应消息数据

1.request对象和response对象的原理

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

2.request对象继承体系结构：

• ServletRequest –接口
• 继承 |
• HttpServletRequest –接口
• 实现 |
• org.apache.catalina.connector.RequestFacade 类（tomcat）

3.request功能：

• 1.获取请求消息数据

  • 1.获取请求行数据

    • GET /day14/demo1?name=zhangsan HTTP/1.1

    • 方法：

      • 1.获取请求方式：GET

        • String getMethod()

        2.(*)获取虚拟目录：/day14

        • String getContextPath()

        3.获取Servlet路径：/demo1

        • String getServletPath()

        4.获取get方式请求参数：name=zhangsan

        • String getQueryString()

        5.(*)获取请求URI：/day14/demo1

        • String getRequetURI()：/day14/demo1
        • StringBuffer getRequestURL() ：http:/localhost/day14/demo1
        • URL：统一资源定位符：http:/localhost/day14/demo1 橘子味汽水
        • URI：统一资源标识符：/day14/demo1 汽水

        6.获取协议及版本：HTTP/1.1

        • String getProtocol()

        7.获取客户机的ip地址：

        • String getRemoteAddr()

  • 2.获取请求头数据

    • 方法：
      • (*)String getHeader(String name)：通过请求头的名称获取请求头的值
      • Enumeration getHeaderNames()：获取所有的请求头名称

  • 3.获取请求体数据

    • 请求体：只有POST请求方式，才有请求体，在请求体中封装了POST请求的请求参数
    • 步骤：
      • 1.获取流对象
        • BufferedReader getReader()：获取字符输入流，只能操作字符数据
        • ServletInputStream getInputStream()：获取字节输入流，可以操作所有类型数据
      • 2.再从流对象中拿数据

• 2.其他功能：

  • 1.获取请求参数通用方式：不论是get还是post请求方式都可以使用下列方式来获取请求

    • 1.getParameter(String name)：根据参数名称获取参数 username=zhangsan&password=123
    • 2.String[] getParameterValues(String name)：根据参数名称获取参数值的数组 hobby=xx&hobby=game
    • 3.Enumeration getParameterNames()：获取所有请求的参数名称
    • 4.Map<String,String[]> getParameterMap()：获取所有参数的map集合
    • 中文乱码问题：
      • get方式：tomcat8已经将get方式乱码问题解决了
      • post方式：会乱码
        • 解决：在获取参数前，设置request的编码request.setCharacterEncoding(“utf-8”);

  • 2.请求转发：一种在服务器内部的资源跳转方式

    • 1.步骤
      • 1.通过request对象获取转发器对象：RequestDispatcher getRequestDispacther(String path)
      • 2.使用RequestDispatcher对象进行转发：forward(ServletRequest request, ServletResponse response)
      2.特点：
      • 1.浏览器地址栏路径不发生变化
      • 2.只能转发到当前服务器内部中
      • 3.转发是一次请求

  • 3.共享数据：

    • 域对象：一个有作用范围的对象，可以在范围内共享数据
    • request域：代表一次请求的范围，一般用于请求转发的多个资源中共享数据
    • 方法：
      • 1.setAttribute(String name,Object obj)：存储数据
      • 2.Object getAttribute(String name)：通过键获取值
      • 3.void removeAttribute(String name)：通过键移除键值对

  • 4.获取ServletContext：

    • ServletContext getServletContext()

案例：用户登录

• 用户登录案例需求：

  • 1.编写login.html登录页面
    • username & password 两个输入框
  • 2.使用Druid数据库连接池技术，操作mysql，day14数据库中user表
  • 3.使用JdbcTemplate技术封装JDBC
  • 4.登录成功跳转到SuccessServlet展示：登录成功！用户名，欢迎您
  • 5.登录失败跳转到FailServlet展示：登录失败，用户名或密码错误

• 分析：

• 开发步骤：

  • 1.创建项目，导入html页面，配置文件，jar包

  • 2.创建数据库环境

    • ```mysq
      create database day14;
      use day14;
      create table user(

      id int primary key auto_increment,
      username varchar(32) unique not null,
      password varchar(32) not null
      

      );
      insert into user(username,password) values(‘superbaby’,’123’);

      * 3.创建包cn.itcast.domain，创建user类
      
        * ```java
          package com.cn.itcast.domian;
          
          //用户实体类
          public class User {
               private int id;
               private String username;
               private String password;
          
              public User() {
              }
          
              public User(int id, String username, String password) {
                  this.id = id;
                  this.username = username;
                  this.password = password;
              }
          
              public int getId() {
                  return id;
              }
          
              public void setId(int 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;
              }
          
              @Override
              public String toString() {
                  return "User{" +
                          "id=" + id +
                          ", username='" + username + '\'' +
                          ", password='" + password + '\'' +
                          '}';
              }
          }
          

  • 4.创建包cn.itcast.util,创建类JDBCUtils类提供getConnection方法

  • 5.创建包cn.itcast.dao，创建类UserDao，提供login方法

    • ```java
      package com.cn.itcast.dao;

      import com.cn.itcast.domian.User;
      import com.cn.itcast.util.JDBCUtils;

      import java.sql.Connection;
      import java.sql.PreparedStatement;
      import java.sql.ResultSet;
      import java.sql.SQLException;

      //操作数据库中User表的类
      public class UserDao {

      // 登录方法，loginUser只有用户名和密码 return user包含用户全部数据

      public User login(User loginUser) {
          //        1.编写sql
          String sql = "select * from user where username = ? and password = ?";
          JDBCUtils jdbcUtils = new JDBCUtils();
          User user = null;
          try {
              Connection connection = jdbcUtils.getConnection();
              PreparedStatement ps = connection.prepareStatement(sql);
              ResultSet resultSet = ps.executeQuery();
              ps.setString(1,loginUser.getUsername());
              ps.setString(2,loginUser.getPassword());
              user = new User();
              while (resultSet.next()) {
                  user.setId(resultSet.getInt(1));
                  user.setUsername(resultSet.getString(2));
                  user.setPassword(resultSet.getString(3));
      
              }
      
          } catch (SQLException e) {
              e.printStackTrace();
          }
          return user;
      
      }
      

      }

      * 6.编写cn.itcast.web.servlet.LoginServlet类
      
      * 7.login.html中form表单的action路径的写法
      
        * 虚拟目录+Servlet资源路径
        
      * 8.BeanUtils工具类，简化数据封装
      
        * 获取所有请求参数：
      
          ```java
          Map<String, String[]> map = req.getParameterMap();
          //创建User对象
          User loginUser = new User();
          //使用BeanUtils封装
          try {
              BeanUtils.populate(loginUser,map)l
          } catch(IllegalAccessException e) {
              e.printStackTrace();
          } catch(InvocationTargetException e) {
              e.printStackTrace();
          }
          

    • 用于封装JavaBean的

      • 1.JavaBean：标准的Java类

        • 1.要求：
          • 1.类必须被public修饰
          • 2.必须提供空参的构造器
          • 3.成员变量必须使用private修饰
          • 4.提供公共setter和getter方法
        • 2.功能：封装数据

      • 2.概念：

        • 成员变量：
        • 属性：setter和getter方法截取后的产物
          • 例如getUsername() –> Username –>username

      • 3.方法：

        • 1.setProperty(Object bean,String name,Object value)

        • 2.getProperty()

        • 3.populate(Object obj,Map map)：将map集合的键值对信息，封装到对应的JavaBean对象中

        • ```java
          //代码演示
          public class BeanUtilsTest {

          @Test
          public void test() {
              User user = new User();//User需自定义
              try {
                  BeanUtils.setProperty(user,"username","张三");
                  String gender = BeanUtils.getProperty(user,"gender");
                  System.out.println(gender);
              } catch (IllegalAccessException e) {
                  e.printStackTrace();
              } catch (InvocationTargetException e) {
                  e.printStackTrace();
              } catch (NoSuchMethodException e) {
                  e.printStackTrace();
              }
              System.out.println(user)
          }
          

          }

          ## HTTP协议：
          
          1.请求消息：客户端发送给服务器端的数据
          
          * 数据格式：
            * 1.请求行
            * 2.请求头
            * 3.请求空行
            * 4.请求体
          
          2.响应消息：服务器端发送给客户端的数据
          
          * 数据格式：
          
            * 1.响应行
              * 1.组成：协议/版本 响应状态码 状态码描述
              * 2.响应状态码：服务器告诉客户端浏览器本次请求和响应的一个状态
                * 1.状态码都是3位数字
                * 2.分类：
                  * 1.1xx：服务器接受客户端信息，但没有接受完成，等待一段时间后，发送1xx状态码
                  * 2.2xx：成功。代表：200
                  * 3.3xx：重定向。代表：302（重定向），304（访问缓存）
                  * 4.4xx：客户端错误。
                    * 代表：
                      * 404（请求路径没有对应的资源）
                      * 405（请求方式没有对应的doXX方法）
                  * 5.5xx：服务端错误 。代表：500（服务器内部出现异常）
            * 2.响应头：
              * 1.格式：头名称：值
              * 2.常见的响应头：
                * 1.Content-Type：服务器告诉客户端本次响应体数据格式以及编码格式
                * 2.Content-disposition：服务器告诉客户端以什么格式打开响应体数据
                  * 值：
                    * in-line：默认值，在当前页面内打开
                    * attachment;filename=xxx：以附件形式打开响应体。文件下载
            * 3.响应空行
            * 4.响应体：传输的数据
          
          * 响应字符串格式
          
            * HTTP/2.0 200 OK
          
            * Content-Type：text/html;charset=UTF-8
          
            * Content-Length：101
          
            * Date：Web,06 Jun 2021 12:00:00 GMT
          
              ```html
              <html>
                  <head>
                      <title>$Title$</title>
                  </head>
                  <body>
                      hello,response
                  </body>
              </html>

Response对象

• 功能：设置响应消息

  • 1.设置响应行
    • 1.格式：HTTP/1.1 200 ok
    • 2.设置状态码：setStatus(int sc)
  • 2.设置响应头：setHeader(String name,String value)
  • 3.设置响应体:
    • 使用步骤：
      • 1.获取输出流
        • 字符输出流：PrintWriter getWriter()
        • 字节输出流：ServletOutputStream getOutputStream()
      • 2.使用输出流，将数据输出到客户端浏览器

• 案例：

  • 1.完成重定向

    • 重定向：资源跳转的方式

    • 代码实现：

      • ```java
        //1.设置状态码为302

            response.setStatus(302);
        

        // 2.设置响应头location
        // response.setHeader(“location”,”ResponseDemo2”);// 简单的重定向方法

            response.sendRedirect("ResponseDemo2");
        

          * 重定向的特点
        
            * 1.地址栏发生变化
            * 2.重定向可以访问其他站点（服务器）的资源
            * 3.重定向是两次请求。不能使用request来共享数据
        
          * 转发的特点：
        
            * 1.转发地址路径不变
            * 2.转发只能访问当前服务器下的资源
            * 3.转发是一次请求，可以使用request来共享数据
        
          * forward 和 redirect区别
        
          * 路径写法：
        
            * 1.路径分类：
              * 1.相对路径：通过相对路径不可以确定唯一资源
                * 如：./index.html
                * 不以/开头，以.开头路径
                * 规则：找到当前资源和目标资源之间的相对位置关系
                  * ./：当前目录
                  * ../：后退一级目录
              * 2.绝对路径：通过绝对路径可以确定唯一资源
                * 如：[localhost:8080/day15_response_war_exploded/ResponseDemo2](http://localhost:8080/day15_response_war_exploded/ResponseDemo2)   /day15_response_war_exploded/ResponseDemo2
                * 以/开头的路径
                * 规则：判断定义的路径是给谁用的？判断请求将来从哪儿发出
                  * 给客户端浏览器使用：需要加虚拟目录（项目的访问路径）
                    * 动态获取虚拟目录：request.getContextPath() 
                    * <a>,<form>重定向
                  * 给服务器使用：不需要加虚拟目录
                    * 转发路径
        
        * 2.服务器输出字符数据到浏览器
        
          * 步骤：
        
            * 1.获取字符输出流
            * 2.输出数据
        
          * 注意：
        
            * 乱码问题：
        
              * 1.PrintWriter pw = response.getWriter();获取的流的默认编码是ISO-8859-1
        
              * 2.设置该流的默认编码
        
              * 3.告诉浏览器响应体使用的编码
        
              * ```java
                //简单形式，设置编码，在获取流之前设置
                response.setContentType("text/html;charset=utf-8")

  • 3.服务器输出字节数据到浏览器

    • 步骤：
      • 1.获取字节输出流
      • 2.输出数据

  • 4.验证码

    • 1.本质：图片
    • 2.目的：防止恶意表单注册

ServletContext对象

1.概念：代表整个web应用，可以和程序的容器来通信

2.获取：

• 1.通过request对象获取

  • request.getServletContext();

• 2.通过HttpServlet获取

  • this.getServletContext();

• ```java
  // 获取ServletContext对象

  // 1.通过request对象获取

      ServletContext context1 = request.getServletContext();
  

  // 2.通过HttpServlet获取

      ServletContext context2 = this.getServletContext();
  
      System.out.println(context1);
      System.out.println(context2);
  
      System.out.println(context1 == context2);//true
  

  3.功能：
  
  * 1.获取MIME类型：
    * MIME类型：在互联网通信过程中定义的一种文件数据类型
      * 格式：大类型/小类型	text/html	image/jpeg
    * 获取：String getMimeType(String file)
  * 2.域对象：共享数据
    * 1.setAttribute(String name,Object value)
    * 2.getAttribute(String name)
    * 3.removeAttribute(String name)
    * ServletContext对象范围：所有用户所有请求的数据
  * 3.获取文件的真实（服务器）路径
    * 1.方法：String getRealPath(String path)
  
  ## 会话技术
  
  1.会话：一次会话中包含多次请求和响应
  
  * 一次会话：浏览器第一次给服务器资源发送请求，会话建立，直到有一方断开为止
  
  2.功能：在一次会话的范围内多次请求间，共享数据
  
  3.方式：
  
  * 1.客户端会话技术：Cookie
  * 2.服务器端会话技术：Session
  
  ## Cookie
  
  1.概念：客户端会话技术，将数据保存到客户端
  
  2.快速入门：
  
  * 使用步骤：
    * 1.创建Cookie对象，绑定数据
      * new Cookie(String name,String value)
    * 2.发送Cookie对象
      * response.addCookie(Cookie cookie)
    * 3.获取Cookie，拿到数据
      * Cookie[] request.getCookie()
  
  3.实现原理
  
  * 基于响应头set-cookie和请求头cookie实现
  
  4.Cookie的细节
  
  * 1.一次可不可以发送多个cookie？
    * 可以
  * 2.cookie在浏览器中保存多长时间？
    * 1.默认情况下，当浏览器关闭后，Cookie数据被销毁
    * 2.持久化的存储：
      * setMaxAge(int seconds)
        * 1.正数：将Cookie数据写到硬盘的文件中，持久化存储。cookie存活时间
        * 2.负数：默认值
        * 3.零：删除Cookie信息
  * 3.cookie能不能存中文？
    * 在tomcat 8 之前 cookie中不能直接存储中文数据
      * 需要将中文数据转码---一般采用URL编码（%E3）
    * 在tomcat 8 之后， cookie支持中文数据.不支持特殊字符，建议使用URL编码存储，URL解码
  * 4.cookie获取范围多大？
    * 1.假设在一个tomcat 服务器中，部署了多个web项目，那么在这些web项目中cookie能不能共享？
      * 默认情况下cookie不能共享
      * setPath(String path)：设置cookie的获取范围。默认情况下会设置当前的虚拟目录
      * 如果要共享，则可以将path设置为"/"
    * 2.不同的tomcat服务器间cookie共享问题？
      * setDomain(String path)：如果设置一级域名相同，那么多个服务器之间cookie可以共享
        * setDomain(".baidu.com")，那么tieba.baidu.com 和 news.baidu.com 中cookie可以共享
  * 5.Cookie的特点和作用
    * 1.cookie存储数据在客户端浏览器
    * 2.浏览器对于单个cookie的大小有限制（4kb）以及对同一个域名下的总cookie数也有限制（20个）
    * 作用：
      * 1.cookie一般用来存储少量的不太敏感的数据
      * 2.在不登陆的情况下，完成服务器对客户端的身份识别
  
  * 6.案例：记住上一次访问时间
    * 1.需求：
      * 1.访问一个Servlet，如果是第一次访问，则提示：您好，欢迎您首次访问
      * 2.如果不是第一次访问，则提示：欢迎回来，您上次访问的时间为：显示时间字符串
    * 2.分析：
      * 1.可以采用Cookie来完成
      * 2.在服务器中的Servlet判断是否有一个名为lastTime的cookie
        * 1.有：不是第一次访问
          * 1.响应数据：欢迎回来，您上次访问的时间为：显示时间字符串
        * 2.没有：是第一次访问
          * 1.响应数据：您好，欢迎您首次访问
          * 2.写Cookie：lastTime = 2021年12月16日11:50:01
  
  ## JSP：入门学习
  
  1.概念：
  
  * Java Server Pages：java服务器端页面
    * 可以理解为：一个特殊的页面，其中既可以指定定义html标签，又可以定义java代码
    * 用于简化书写
  
  2.原理
  
  * JSP本质上就是一个Servlet
  
  3.JSP的脚本
  
  * 1.<% 代码 %>：定义的java代码，在service方法中。service方法可以定义什么，该脚本就可以定义什么
  * 2.<%! 代码 %>：定义的java代码，在jsp转换后的java类的成员位置
  * 3.<%= 代码 %>：定义的java代码，会输出到页面上。输出语句可以定义什么，该脚本就可以定义什么
  
  4.JSP的内置对象
  
  * 在jsp页面中不需要获取和创建，可以直接使用的对象
  * jsp一共有九个内置对象
  * 介绍3个：
    * request：
    * response：
    * out：可以将数据输出到页面上。和response.getWriter()类似
    * out.write()和response.getWriter()的区别
      * 在tomcat服务器真正给客户端做出响应之前，会先找response缓冲区数据，再找out缓冲区数据
      * response.getWriter()数据输出永远在out.write()之前
      * 尽量使用out
  
  ## Session：主菜
  
  1.概念：服务器端会话技术，在一次会话的多次请求间共享数据，将数据保存在服务器端的对象中。HttpSession
  
  2.快速入门：
  
  * 1.获取HttpSession对象：
    * HttpSession session = request.getSession();
  * 2.使用HttpSession对象：
    * HttpSession对象：
      * Object getAttribute(String name)
      * void setAttribute(String name,Object value)
      * void removeAttribute(String name)
  
  3.原理
  
  * Session的实现是依赖于Cookie的
  
  4.细节：
  
  * 1.当客户端关闭后，服务器不关闭，两次获取的session是否为同一个
  
    * 默认情况下，不是
  
    * 如果需要相同，则可以创建Cookie，键为JSESSIONID，设置最大存活时间，让cookie持久化保存
  
    * ```java
      //1.获取session
      HttpSession session = request.getSession();
      
      //期望客户端关闭后，session也能相同
      Cookie c = new Cookie("JSESSIONID",session.getId());
      c.setMaxAge(60*60);
      response.addCookie(c);

• 2.客户端不关闭，服务器关闭后，两次获取的session是同一个吗？

  • 不是同一个，但要确保数据不丢失
    • session的钝化：
      • 在服务器正常关闭之前，将session对象系列化到硬盘上
    • session的活化：
      • 在服务器启动后，将session文件转化为内存中的session对象即可

• 3.session什么时候被销毁？

  • 1.服务器关闭

  • 2.session对象调用invalidate()

  • 3.session默认的失效时间 30 分钟

    • 可以选择性的修改配置

    • ```xml

      30

      5.session的特点
      
      * 1.session用于存储一次会话的多次请求的数据，存在服务器端
      * 2.session可以存储任意类型，任意大小的数据
      * 3.session与Cookie的区别：
        * 1.session存储数据在服务器端，Cookie在客户端
        * 2.session没有数据大小限制，Cookie有
        * 3.session数据安全，Cookie相对不安全
      
      ## JSP：
      
      ### 1.指令
      
      * 作用：用于配置JSP页面，导入资源文件
      
      * 格式：
      
        * ```jsp
          <%@ 指令名称 属性名1=属性值1 属性名2=属性值2 ... %>

  • 分类：

    • 1.page：配置JSP页面的

      • contentType：等同于response.setContentType()
        • 1.设置响应体的mime类型及字符集
        • 2.设置当前JSP页面的编码（只能是高级的IDE工具才能生效，如果使用低级工具，则需要设置pageEncoding属性设置当前页面的字符集）
      • import：用来导包
      • errorPage：当前页面发生异常后，会自动跳转到指定的错误页面
      • isErrorPage：标识当前页面是否是错误页面
        • true：是，可以使用内置对象exception
        • false：否，默认值，不可以使用内置对象exception

    • 2.include：页面包含的，导入页面资源文件

      • ```jsp
        <%@include file=”top.jsp” %>

        * 3.taglib：导入资源
        
          * ```jsp
            <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

      • prefix：前缀，

2.注释

• 1.html注释：
• 2.jsp注释：推荐使用
  • <%– –%>

3.内置对象

• 在jsp页面中不需要创建，直接使用的对象
• 一共有9个：
  • 变量名 真实类型
  • pageContext PageContext（当前页面共享数据）
  • request HttpServletRequest（一次请求访问的多个资源（转发））
  • session HttpSession（一次会话的多个请求间）
  • application ServletContext（所有用户间共享数据）
  • response HttpServletResponse（响应对象）
  • page Object（当前页面（Servlet）的对象 this）
  • out JspWriter（输出对象，输出数据到页面上）
  • config ServletConfig（Servlet的配置对象）
  • exception Throwable（异常对象）

MVC开发模式

1.JSP发展历史

• 1.早期只有Servlet，只能使用response输出标签数据，非常麻烦
• 2.后来有jsp，简化了Servlet开发，如果过度使用jsp，在jsp中写大量的java代码，又写html标签，造成难以维护难以分工的结局
• 3.在后来，java的web开发，借鉴mvc开发模式，使得程序的设计更加合理

2.MVC

• 1.M：Model，模型，JavaBean
  • 完成具体的业务操作，如：查询数据库，封装对象
• 2.V：View，视图，JSP
  • 展示数据
• 3.C：Controller，控制器，Servlet
  • 获取用户的输入
  • 调用模型
  • 将数据交给视图进行展示
• 优缺点
  • 1.优点：
    • 1.耦合性低，方便维护，可以利于分工协作
    • 2.重用性高
  • 2.缺点
    • 1.使得项目架构变得复杂，对开发人员要求高

EL表达式

• 1.概念：Expression Language 表达式语言

• 2.作用：替换和简化jsp页面中java代码的缩写

• 3.语法：${表达式}

• 4.注意：

  • jsp默认支持el表达式，如果要忽略el表达式
    • 1.设置jsp中page指令中：isELIgnored=”true” 忽略当前jsp页面中所有的el表达式
    • 2.\${表达式}：忽略当前这个el表达式

• 5.使用：

  • 1.运算：

    • 运算符：
      • 1.算数运算符：+ - * /(div) %(mod)
      • 2.比较运算符：> < >= <= == !=
      • 3.逻辑运算符：&& (and)||(or) !(not)
      • 4.空运算符：empty
        • 功能：用于判断字符、集数组对象是否为null并且长度是否为0
        • ${empty list}：判断字符串、集合、数组对象是否为null 或者 长度为0
        • ${not empty str}：表示判断字符串、集合、数组对象是否不为null 并且 长度>0

  • 2.获取值

    • 1.el表达式只能从域对象中获取值
    • 2.语法：
      • 1.${域名称.键值}：从指定域中获取指定键的值
        • 域名称：
          • 1.pageScope –>pageContext
          • 2.requestScope –>request
          • 3.sessionScope –>session
          • 4.applicationScope –>application(ServletContext)
        • 举例：在request域中存储了name=张三
        • 获取：{requestScope.name}
      • 2.${键名}：表示依次从最小的域中查找是否有该键对应的值，直到找到位置
      • 3.获取对象、List集合、Map集合的值
        • 1.对象：${域名称.键名.属性名}
          • 本质上会去调用对象的getter方法
        • 2.List集合：${域名称.键名[索引]}
        • 3.Map集合：${域名称.键名}
          • ${域名称.键名.key名称}
          • ${域名称.键名[“key名称”]}

  • 3.隐式对象：

    • el表达式中有11个隐式对象

    • pageContext：

      • 1.获取jsp其他八个对象

      • ```jsp

        pageContext.request.contextPath

        ## JSTL
        
        * 1.概念：JavaServer Pages Tag Library
        
          * 是由Apache组织提供的开源的免费的jsp标签
        
        * 2.作用：用于简化和替换jsp页面上的java代码
        
        * 3.使用步骤：
        
          * 1.导入jstl相关jar包
          * 2.引入标签库：taglib指令：<%@ taglib %>
          * 3.使用标签
        
        * 4.常用的JSTL标签
        
          * 1.if（相当于java代码的if语句）
        
            * 1.属性：
              * test必须属性，接受boolean表达式
                *  如果表达式为true，则显示if标签内容，如果为false则不显示
                *  一般情况下，test属性会结合el表达式一起使用
            * 2.注意：c:if标签没有else情况，想要else情况，则可以再定义一个c:if标签
        
          * 2.choose（相当于java代码的switch语句）
        
            * 1.使用choose标签声明（相当于switch声明）
        
            * 2.使用when标签做判断（相当于case）
        
            * 3.使用otherwise标签做其他情况的声明（相当于default）
        
            * ```jsp
              <%@ page contentType="text/html;charset=UTF-8" language="java" %>
              <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
              <html>
              <head>
                  <title>Title</title>
              </head>
              <body>
              <%--    完成数字编号对应星期几案例
                          1.域中存储一数字
                          2.使用choose标签取出数字（相当于switch声明）
                          3.使用when标签做数字判断（相当于case）
                          4.otherwise标签做其他情况的声明（相当于default）
              --%>
              <%
                  request.setAttribute("number",3);
              %>
              <c:choose>
                  <c:when test="${number == 1}">星期一</c:when>
                  <c:when test="${number == 2}">星期二</c:when>
                  <c:when test="${number == 3}">星期三</c:when>
                  <c:when test="${number == 4}">星期四</c:when>
                  <c:when test="${number == 5}">星期五</c:when>
                  <c:when test="${number == 6}">星期六</c:when>
                  <c:when test="${number == 7}">星期天</c:when>
                  <c:otherwise>数字输入有误</c:otherwise>
              </c:choose>
              </body>
              </html>

  • 3.foreach（相当于java代码的for语句）

    • 1.完成重复的操作

      • 属性：
        • begin：开始值
        • end：结束值
        • var：临时变量
        • step：步长
        • varStatus：循环状态对象
          • index：容器中元素的索引，从0开始
          • count：循环次数，从1开始

    • 2.遍历容器

      • 属性：

        • items：容器对象
        • var：容器中元素的临时变量
        • varStatus：容器中元素的索引，从0开始
          • index：容器中元素的索引，从0开始
          • count：循环次数，从1开始

      • <%@ page import="java.util.ArrayList" %>
        <%@ page import="java.util.List" %>
        <%@ page contentType="text/html;charset=UTF-8" language="java" %>
        <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
        <html>
        <head>
            <title>Title</title>
        </head>
        <body>
          <c:forEach begin="1" end="10" var="i" step="2" varStatus="s">
              ${i} ${s.index} ${s.count}<br>
          </c:forEach>
        
          <hr>
        <%
            List list = new ArrayList<>();
            list.add("aaa");
            list.add("bbb");
            list.add("ccc");
            request.setAttribute("list",list);
        %>
        <c:forEach items="${list}" var="str" varStatus="s">
             ${s.index}${s.count}${str}<br>
        </c:forEach>
        </body>
        </html>
        

三层架构：软件设计架构

• 1.界面层（表示层/web层）：用户看得到的界面，用户可以通过界面上的组件和服务器进行交互（接受用户参数，封装数据，调用业务逻辑层完成处理，转发jsp页面完成显示）
• 2.业务逻辑层（service）：处理业务逻辑的（组合DAO层中的简单方法，形成复杂的功能（业务逻辑操作））
• 3.数据访问层（dao层）：操作数据存储文件（定义了对于数据库最基本的CRUD操作）