jsp笔记

jsp笔记

tomcat

• bin:可执行文件（startup.bat shutdown.bat）
• conf:配置文件（server.xml）
• lib: tomcat 依赖的jar文件
• log:日志文件（记录出错信息）
• webapps:可执行的项目(开发的项目放入该目录)
• work：存放由jsp翻译的java，以及编辑成的class文件

常见状态码

• 200：一切正常
• 404：资源不存在
• 403：权限不足（如果访问a目录，但是a目录设置不可见）
• 301/301：页面重定向
• 500：服务器内部错误（代码有错）

其他编码：积累

jsp:在html中嵌套的java代码

在项目/WEB-INF/web.xml中设置 默认的初始页面

<welcome-file-list>
        <welcome-file>index2.jsp</welcome-file>
    </welcome-file-list>

虚拟路径

1. 将web项目配置到webapps以外的目录

   • conf/server.xml里面配置

   • docBase = “ ” 实际路径

   • path：虚拟路径（绝对路径 / 相对路径相对于webapps）

   • <Context docBase="D:\tool\JspProject" path="/JspProject" />//访问path的时候就相当于访问docBase;
     

   2.在conf\Catalina\localhost中新建 项目名.xml中新增一行

   <Context docBase="D:\tool\JspProject" path="/JspProject" />//访问path的时候就相当于访问docBase;
   

虚拟主机

通过 www.test.com 访问本机

1. conf/server.xml 在Host前加这个

<Host appBase="D:\tool\JspProject" name="www.test.com">
			<Contest docBase="D:\tool\JspProject" path="/"/>
</Host>

2.将本机的host文件进行修改 C:\Windows\System32\drivers\etc

增加

#   127.0.0.1       www.test.com

流程 www.test.com -> host找映射关系 -> server.xml 找Engine的defaultHost ->通过“/”映射到 “D:\tool\JspProject”；

JSP执行流程

第一次访问：jsp -> java -> class 第二次访问：直接访问class文件

D:\tool\apache-tomcat-8.0.33\work\Catalina\localhost\JspProject\org\apache\jsp

使用eclipse开发web项目（JSP）

• 在eclipse创建的web项目：

  • 浏览器可以直接访问WebContent中的文件，例如http://localhost:8888/MyJspProject1/index1.jsp

    但是WEB-INF中的文件 无法通过客户端（浏览器）直接访问，只能通过请求转发来访问

    注意：并不是 任何的内部跳转都能访问WEB-INF：原因是 跳转有两种方式：请求转发、重定向

• 统一字符集编码

  a.设置jsp文件的编码（jsp中的pageEncoding属性） ： jsp—>java

  b.设置浏览器读取jsp文件的编码（jsp文件中的content属性）

  一般需要将上述设置成一样的，推荐使用国际编码UTF-8

  c.文本编码：

  1. 将整个eclipse中的文件统一设置（推荐）
  2. 设置某一个项目设置统一编码
  3. 设置单独文件

  JSP的脚本页面元素:HTML java代码 指令 指令

  a.脚本Scriptlet

  1. <%
     	局部变量 Java语句
     	String name = "zhangsan";
     	out.print("hello..."+name);
     %>
     

  2. <%!
      	全局变量 
     %>
     

  3. <%=输出表达式%>
     

  一般而言修改web，xml，配置文件，java需要重启tomcat服务，但是如果修改Jsp、html、css、js不需要重启

  回车是

  <br/>
  

  b.指令

  ​ page指令<%@ …%>

  ​ language:jsp

  ​ import:

  ​ pageEncoding:jsp文件自身编码

  ​ contentType:浏览器解析jsp的编码

  c.注释

  ​ html注释： 可以被用户通过浏览器查看源码

  ​ java注释:// /…/

  ​ jsp注释<%-- --%>

  ​

JSP九大内置对象 （自带的，不需要new 也能使用的对象）

• out：向客户端输出内容

• pageContext：JSP页面容器

• request：请求对象；存储“客户端向服务端发送的请求信息” 常见方法

  1.  String  getParameter(Syring name):根据请求的字段名key，返回字段值value
  2.  String[] getParameterValues(String name) :兴趣爱好之类的，根据key，返回多个字段值value （checkbox）
  3.  void setCharacterEncoding("编码格式utf-8");设置请求编码 
  4.  getRequestDispatcher("b.jsp").forward(request,response);请求转发的方式跳转页面A->B
  5.  getServerContext();获取项目的ServletContext对象
  

  示例：注册 get提交方式 method=“get” 和地址栏 超链接 请求方式 默认都属于get提交方式

  get与post请求方式的区别:

  a.get方式 ：在地址栏显示 请求信息(但是地址栏容纳的信息有限4~5kb，如果存在大文件会出现报错) post不显示

  b.文件上传操作必须是post（推荐）

  统一请求的编码 request

  • get方式请求 如果出现乱码 解决：

    a.统一每一个变量的 编码

    b.修改server.xml,一次性的

    建议使用tomcat时，首先在server.xml中统一get方式的编码… URIEncoding=“UTF-8”

• response：响应对象

  提供的方法：

  void addCookie(Cookie cookie); //服务端向客服端增加cookie对象
  void sendRedirect(String location) throws IOException; //页面跳转的一种方式（重定向）
  注：页面跳转的两种方式：重定向，请求转发
  void sentContetType(String type)//设置服务端响应编码（设置服务端的content）
  
  

  示例：登录 login.jsp ->check.jsp->success.jsp

  结论：页面跳转：请求转发，可以获取到数据，并且地址栏没有改变（仍然保留转发时的页面）

  ​ 重定向会导致数据 的丢失

  请求转发和重定向的区别：

  区别	请求转发	重定向
  地址栏是否改变	不变	改变
  是否保留第一次请求的数据	保留	不保留(4种范围对象)
  请求的次数	1	2
  跳转发生的位置	服务端	客户端发出的第二次跳转

• session

  Cookie(客户端，不是内置对象，但服务端会自动new一个出来)：Cookie是由服务端产生，再发送给客户端保存。相当于缓存的作用 可以提高效率

  Cookie: key(name)  value
  
  javax.servlet.http.Cookie
  
  public Cookie(String key,String value)
  
  String getName()//获取name
  
  String getValue()//获取value
  
  void setMaxAge(int expiry);最大有效期（秒）
  

  服务端发送给客户端：

  a.服务端获取cookie：response对象 ； 客户端获取对象：resquest对象

  b.不能直接获取某一个单独对象，只能一次性的将全部cookie拿到

  c.建议Cookie中只保存英文和数字，否则需要进行编码处理

  d.客户端在第一次请求服务端时，如果服务端发现，此请求没有JSESSIONID,则会去创建一个name = JSESSIONID的cookie

  通过F12发现，除了自己的Cookie对象外，还有一个name为JESSIONNID的cookie

  准备cookie：
  response.addCookie()
  页面跳转（转发，重定向）
  客户端获取cookie：
  

request.getCookies();//只能获取全部的cookie

使用cookie实现 记住用户名 功能

**session**:会话

a.浏览网站：开始-关闭

b.购物：浏览、付款、退出

c.电子邮件：浏览、写、退出

sessionj机制：客户端第一次请求服务端时，服务端会产生一个session对象，（用于保存客户端信息），

并且每个session对象都会有一个唯一的sessionid（用于区分）；

服务端又会产生一个cookie，该cookie的name=JESSIONID,value = 服务端sessionid的值；

服务端会在响应客户端的同时，将cookie发送给客户端，至此客户端就有了一个cookie（JESSIONID）；

因此客户端的cookie就可以和服务端的sessionid一一对应（cookie保存在客户端，session保存在服务端二者一一对应）

**session总：**

a.session存储在服务端

b.在同一个客户请求时共享

c.session实现机制

**session方法**

1. String getID()//获取sessionid
2. boolean isNew//判断是否第一次访问
3. void invalidate()//使session失效
4. setAttribute();
5. getAttribute();
6. void setMaxInactiveInterval(秒)；//设置有效非活动时间
7. int getMaxInactiveInterval（）//获取时间

​		客户端第二次请求时：服务端会先根据客户端的cookie中的JESSIONID去匹配session中的sessionid，如果匹配成功，说明此用户不是第一次访问，不需要再登录了，直接登录。

​		**cookie和session的区别**

|            | session | cookie   |
| ---------- | ------- | -------- |
| 保存的位置 | 服务端  | 客户端   |
| 安全性     | 较安全  | 较不安全 |
| 保存的内容 | Object  | String   |



- **application**：全局对象

String getContextPath()//虚拟路径

String getRealPath（）//虚拟路径相对的绝对路径

- config

- page

- exception

### 四种范围对象（小->大）

| 四种范围对象             | 范围                                                         |
| ------------------------ | ------------------------------------------------------------ |
| pageContext//JSP页面容器 | 当前页面有效                                                 |
| session //会话对象       | 同一次会话有效(无论怎么跳转，都有效；关闭切换浏览器后无效；从登录->退出都有效) |
| request//请求对象        | 同一次请求有效, 其他请求无效，（请求转发后有效，重定向后无效 |
| application //全局对象   | 全局有效，整个项目运行期间都有效，切换浏览器仍然有效         |

以上4个对象公共的方法：

Object getAttribute(String name)//根据姓名，或者属性值

void setAttribute(String name,Object obj)// 设置属性值

​		setAtrribute("a","b)//如果a对象之前存在，将a的值改为b；如果a对象之前不存在那么创建a对象赋值为b；

void removeAtrribute(String name)//根据属性名 删除对象

1. 以上四个范围对象，通过setAtrribute()赋值，通过getAttribute（）取值；
2. 以上范围，尽量使用最小的的范围。因为对象的范围越大，造成的性能损耗越大

### JDBC

**JDBC API**  三件事

1. DriverManger//管理jdbc驱动

2. Connection//连接

 Connection产生操作数据库对象

 Connection产生Statement对象：createStatement()

 Connection产生PreparedStatement对象：prepareStatement()

 Connection产生CallableStatement对象：prepareCall()

3. Statement()  (PreparedStatement) //增删改查

 增删改：executeUpdate()

 查询:executeQuery()

 ctrl+shift+t    ctrl+o

 PrepareStatement与Statement在使用时的区别：

 1. Statement  executeUpdate（SQL)

 2. PreparedStatement ,将sql进行了预编译

    executeUpdate（）；

    setXxx()替换占位符

    注：一般用子类，子类比父类更加强大，推荐使用PrparedStatement:

    1. 编码更加简便
    2. 提高了性能，sql不需要循环100次，预编译只需执行一次
    3. 安全（可以有效防止sql注入）

4. CallableStatement//调用数据库中存储过程，存储函数

 connection.prepareCall(存储过程、存储函数)

 格式：

 存储过程{

 ​	call 存储过程名（参数列表）

 }

 存储函数：{（有返回值return）

 ？ = call 存储函数名（）

 }

5. Result //返回结果集

 next()//光标下移，判断是否有下一个数据

 previous（）//true/false

 getXxx（）//获得具体的字段值

 这些东西密切相关：1产生2，2产生3，3产生5

 **jdbc中除了Class.forName()抛出ClassNotFoundException，其余方法全部抛出SQLException**

 **在close前先排空**

**具体步骤**

1. 导入驱动，加载具体的驱动类
2. 与数据库建立连接
3. 发送sql，执行
4. 处理结果集（查询）



### JSP访问数据库

1. 导包：jar复制到WEB-INF/LIB里就可以了
2. 核心：就是将java中的JDBC代码复制到JSP中的<%..%>中

### JavaBean

我们将jsp中的登陆操作代码，转移到了LoginDao.java;其中LoginDao类就是javabean。

定义（就是一个Java类）：a.public 修饰的类 ，public无参构造  b.所有属性都是private，并且提供set/get（如果boolean 则 get可以替换成is）

**作用：**

1. 减轻了jsp的复杂度
2. 提高代码复用（以后任何地方的登录操作都可以调用javabean）

**使用层面，Java分为两大类**

a.封装业务逻辑的JavaBean，将jsp的JDBC代码，封装到Login.java类中 

用于操作 封装数据的Javabean

b.封装数据的javaBean，对应数据库的一张表

### MVC设计模式

M:Model模型：一个功能，用JavaBean实现

V:View视图：用于展示，以及与用户交互（html，js，css，jsp，jquery）

C:Control控制器：接受请求，请求跳转到模型处理；模型处理完毕后，再将处理的结果返回给请求处 可以用jsp，但是一般建议使用Servlet实现控制器（jsp->JAVA(Servlet)->JSP）

### **Servlet:**

Java类必须符合一定的规范：

1. 必须继承 javax.servlet.http.HttpServlet

2. 重写其中的doGet或doPost()方法

 1. doGet()：接受 并处理所有get提交方式的请求
 2. doPost()：接受 并处理所有post提交方式的请求

3. Servlet要想使用，必须配置

 Servlet2.5:web.xml

 Servlet3.0:@WebServlet

 项目的根目录：WebContent   src

 **Servlet2.5流程：**

 1、请求-><url-pattern>->根据<servlet-mapping>中的<serclet-name>去匹配<servlet>中的<servlet-name>,然后寻找<servlet-class>由该class执行。
 
 2、借助于eclipse快速生成Servlet：直接新建Servlet即可！（继承、重写、web.xml自动生成）
 
 **Servlet3.0与Servlet2.5的区别**
 
 3.0不需要再web.xml中配置，但需要在Servlet类定义之上注解@WebServlet("/WelcomeServlet2")
 
 **根目录寻找过程**
 
 如果：index.jsp中请求
 

…,则寻找范围，既会在src根目录寻找，也会在WebContent中寻找

如果是：请求<a href = "a/abc"></a> 寻找范围：现在src或webContent中找a目录，在a目录里找abc

web.xml中的”/“代表项目路径：http://localhost:8888/Servlet30Project/

JSP中的"/"代表服务器根路径：http://localhost:8888/

**Servlet生命周期**

加载

初始化：init(),该方法会在Servlet被加载实例化以后执行

服务：service（）->doGet()    doPost()

销毁:  destory(), Servlet被系统回收时

卸载

init():第一次访问Servlet会被执行，并且只执行一次

service()：调用几次执行几次

**Servlet API:**

由两个软件包组成：对应于HTTP协议的软件包，对应于除了HTTP协议以外的其他软件包

**Servlet 继承关系**

ServletConfig：接口

ServletContext  getServletContext():获取Servlet上下文对象，application

String getInitParameter(String name): 在当前Servlet 范围内，获取名为name的参数值（初始化参数）

1. ServletContext（）中常见的方法(application)

   1. getRealPath():绝对路径
   2. getContextPath()：相对路径
   3. setAttribute()   getAttribute()
   4. String getInitParameter(String name):在当前web容器范围内，获取名为name的参数值（初始化参数）

2. Servlet3.0方式,给当前Servlet设置初始值

   @WebServlet(.....,initParams = {@WebInitParam(name= "servletparaname30 , value = servletparavalue30")})

   此注解只隶属于某一个具体的Servlet，因此无法为整个web容器设置初始化参数（如果要通过3.0方式仍然要web.xml）

### 三层架构

1. 与MVC设计模式的目标一致，都是为了，提高代码复用

2. 三层组成

1. 表示层 ：视图层

   - 前台：对应于MVC中的View，用于和用户交互，界面的显示

   - 后台：用于MVC中的Controller，用于控制跳转、调用业务逻辑层(Servlet)

     位于xxx.servlet包

2. 业务逻辑层：Service

   - 组装数据访问层，逻辑性的操作（带逻辑的增删改查）

3. 数据访问层：Dao层

   - 直接访问数据库的操作，原子性的操作（增删改查）

   上层：将请求传给下层 ，下层处理后，返回给上层

   上层依赖于下层，依赖：代码的理解，就是持有成员变量 或者理解为：有A的前提必须有B（先有数据库才有Dao）

   **建议：一个Servlet对应一个功能**

3. 三层优化

1. **加入接口**

   - 建议面上接口开发：先接口-再实现类

   - service、dao加接口

   - 接口与实现类的命名规范

     接口：interface，IXxxService

     实现类：implement  	XxxServiceImpl

     以后使用接口/实现类推荐写法：

     接口x = new 实现类() IStudentDao studentDao = new StudentDaoImpl();

2. **DBUtil: 通用数据库帮助类**

   解决代码冗余问题，可以解决Dao层的开发

### 分页 

1.  **要实现分页必须知道 某一页的数据 从哪里开始 到哪里结束**

要知道第n页的数据

Mysql实现分页的sql 

limit 开始：多少条   ：mysql从0开始计数 Oracle 从1开始计数 

第0页：select * from student limit 0,10;

第1页：select * from student  limit 10,10;

第2页：select * from student limit 20,10;

第n页：selcet *from student limit 页数 * 页面大小，页面大小;

2.  **分页实现：**（五个变量）

 1. 数据总数    查数据库 select*
 
 2. 页面大小：每页显示的页面条数  //用户自定义
 
 3. 总页数//   程序自动计算
 
 4. 当前页（页码） /用户自定义
 
 5. 当前页的对象集合（实体类集合）：每页所显示所有数据（查数据库）通过sql语句
 
    list<Student> 

### JDIN：java 命名与目录接口

​	pageContext < request < session < application (一个项目有效)

​	如何实现多个项目有效：

- JNDI：将某一个配置文件，以配置文件(Tomcat/conf/context.xml)的形式写入 



### 上传

1. ​	apache: commons-fileupload组件  引入两个jar包

2. 代码：前台，后台

前台：上传照片：<input type="file" name="spicture"/><br>

​		表单提交方式必须位post，在表单中必须增加一个属性 entcype = "multipart/form-data"

## EL

### EL表达式语法

EL 提供“.”（点操作）和 [] 两种运算符来实现数据存取运算。

1. Expression Language ,可以代替JSP页面中的JAVA代码

2. servlet （增加数据）->jsp 显示数据  setAttribute()  request.send()  

3. 传统的 在JSP中用java代码显示数据的弊端；类型转换、需要处理、需要处理null

4. EL示例：

​	${resquestScope.student.address.schoolAddress}

​	${域对象.域对象中的属性.属性.属性.级联属性}

5. EL操作符：

​	点操作符 .      使用方便

​	中括号操作符： []  ---- 功能强大；

1.    可以包含特殊字符（. 、-）：例如：${requsetScope.my-name}与${resquestScope['my-name']}前者是输出不了的，后者可以输出

2. 还可以获取变量值：String name = "student"

    								${resquestScope[name]}

3. 可以访问数组元素

4. 获取map属性：${requetScope.map.cn}  

### EL关系运算、隐式对象

1. ​	关系运算符

| **EL关系运算符** | **说明** | **范例**                                              | **结果**        |
| ---------------- | -------- | ----------------------------------------------------- | --------------- |
| ==  或 eq        | 等于     | ${6==6} 或 ${6 eq 6} ${"A"="a"} 或 ${"A" eq "a"}      | true<br/>false  |
| != 或 ne         | 不等于   | ${6!=6} 或 ${6 ne 6}<br/>${“A"!=“a”} 或 ${“A” ne “a”} | false<br/>true  |
| < 或 lt          | 小于     | ${3<8} 或 ${3 lt 8} ${"A"<"a"} 或 ${"A" lt "a"}       | true<br/>true   |
| \> 或 gt         | 大于     | ${3>8} 或 ${3 gt 8}<br/>${"A">"a"} 或 ${"A" gt "a"}   | false<br/>false |
| <= 或 le         | 小于等于 | ${3<=8} 或 ${3 le 8} ${"A"<="a"} 或 ${"A" le "a"}     | true<br/>true   |
| \>= 或 ge        | 大于等于 | ${3>=8} 或 ${3 ge 8}<br/>${"A">="a"} 或 ${"A" ge "a"} | false<br/>false |

2. EL逻辑运算符



| **EL逻辑运算符** | **范例(A、B为逻辑型表达式）** | **结果**   |
| ---------------- | ----------------------------- | ---------- |
| && 或 and        | ${A && B} 或 ${A and B}       | true/false |
| \|\|或or         | ${A\|\|B}或${AorB}            | true/false |
| ! 或 not         | ${!A} 或 ${not A}             | true/false |

3. EL条件运算符

在 EL 表达式中，条件运算符的用法与 [Java](http://c.biancheng.net/java/) 语言的语法完全一致。格式如下：

```jsp
${条件表达式?表达式1:表达式2}

例如：${(68)?(99):(9!=9)} 结果为 ${(68)?(99):(9!=9)}

4. EL empty空运算符

   通过 empty 运算符，可以实现在 EL 表达式中判断对象是否为空。该运算符用于确定一个对象或者变量是否为 null 或空。若为空或者 null，返回空字符串、空数组，否则返回 false。

   例如，应用条件运算符来实现，当 cart 变量为空时，输出购物车为空，否则输出购物车的代码如下：

   ${empty cart?"购物车为空":cart}
   

5. EL中的常量

   1. Null 常量：Null 常量用于表示常量引用的对象为空，它只有一个 null 值。
   2. 整型常量：整型常量与 Java 中的十进制整型常量相似，它的取值范围与 Java 语言中 long 范围的整型常量相同，即在 -263~263-1 之间。
   3. 浮点数常量：浮点数常量用整数部分加小数部分来表示，也可以用指数的形式来表示。例如，1.3e4 和 1.3 都是合法的浮点数常量，它的取值范围是 Java 语言中定义的范围，即其绝对值介于 4.9E-324~1.8E-308 之间。
   4. 布尔常量：布尔常量用于区分一个事物的正反两方面，它的值只有两个，分别是 true 和 false。
   5. 字符串常量：字符串常量是使用单引号或者双引号括起来的一连串字符。如果字符串常量本身又含有单引号或双引号，则需要在前面加上“\”进行转义，即用“V”表示单引号，用表示双引号。如果字符本身包含“\”，则需要用“\”表示字面意义上的反斜杠。
   6. 符号常量：在 EL 表达式语言中，可以使用符号常量，它类似于 Java 中 final 说明的常量。使用符号常量的目的是为了减少代码的维护量。

   EL表达式的内置对象及其作用域

   1. EL 表达式的主要功能是进行内容显示。为了显示方便，在表达式语言中，提供了许多内置对象，通过不同的内置对象的设置，表达式语言可以输出不同的内容。

      内置对象	类型	说明
      pageContext	javax.servlet.ServletContext	表示 JSP 的 pageContext
      pageScope	java.util.Map	取得 page 范围的属性名称所对应的值
      sessionScope	java.util.Map	取得 session 范围的属性名称所对应的值
      requestScope	java.util.Map	取得 request 范围的属性名称所对应的值
      applicationScope	java.util.Map	取得 application 范围的属性名称所对应的值
      param	java.util.Map	如同 ServletRequest.getParameter(String name)，返回 Slring[] 类型的值
      param Values	java.util.Map	如同 ServletRequest.getParameter Values(String name)， 返回 string[] 类型的值
      header	java.util.Map	如同 ServletRequest.getHeader(String name)，返回 string[] 类型的值
      header Values	java.util.Map	如同 ServletRequest.getHeaders(String name)， 返回 string[] 类型的值
      cookie	java.util.Map	如同 HttpServletRequest.getCookies()
      initParam	java.util.Map	如同 ServletContext.getInitParameter(String name)，返回 string[] 类型的值

   2. 使用 EL 表达式语言可以输出4种属性范围的内容

属性范围	EL中的名称
page	pageScope
session	sessionScope
request	requestScope
application	applicationScope

下面通过例子来演示 EL 如何读取 4 种属性范围的内容。

<%@ page contentType="text/html"  pageEncoding="utf-8" %>
<html>
<head>
<title>EL 读取四种属性范围的内容 </title>
<body>
<%
pageContext.setAttribute("info","page属性范围");
request.setAttribute("info","request属性范围");
session.setAttribute("info","session属性范围");
application.setAttribute("info","application属性范围");
%>
<h1>四种属性范围</h1>
<hr/>
<h3>page 属性内容：${pageScope.info}</h3>
<h3>request 属性内容：${requestScope.info}</h3>
<h3>session 属性内容：${sessionScope.info}</h3>
<h3>application 属性内容：${applicationScope.info}</h3>
</body>
</html>

我们也可以通过表达式的 pageContext 内置对象获取 JSP 内置对象 request、session、application 的实例，可以通过 pageContext 内置对象调用 JSP 内置对象中提供的方法。

<%@ page contentType="text/html" pageEncoding="utf-8" %>
<html>
<head>
<title>调用 JSP 内置对象的方法 </title>
</head>
<body>
    <h1>EL 调用 JSP 内置对象的方法 </h1>
    <hr/>
    <h3>IP 地址：${pageContext.request.remoteAddr}</h3>
    <h3>SESSION ID：${pageContext.session.id}</h3>
    <h3>是否是新 session：${pageContext.session['new']}</h3>
</body>
</html>

使用EL表达式访问JavaBean

在实际开发过程中，Servlet 通常用于处理业务逻辑，由 Servlet 来实例化 JavaBean，最后在指定的 JSP 程序中显示 JavaBean 中的内容。使用 EL 表达式可以访问 JavaBean，基本语法格式如下：

${bean.property}

先定义 JavaBean，在 vo 包中定义 Person.java 类，程序代码如下：

package vo;
public class Person
{
    private String name;
    private String ID;
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name=name;
    }
    public String getID()
    {
        return ID;
    }
    public void setID(String id)
    {
        ID=id;
    }
}

在下面的程序中，创建了一个 Person 的实例 pi，接着对 pi 的属性设置值，然后将该对象放入 session 作用域中，最后取出 pi 对象，将其属性显示出来，代码如下：

<%@ page language="java" contentType="text/html;charset=utf-8" %>
<%@ page import="vo.Person" %>
<html>
<head>
<title>
    使用 EL 表达式访问 JavaBean
</title>
</head>
<body>
<h1>使用 EL 表达式访问 JavaBean </h1>
<hr>
<%
Person p1=new Person();
p1.setID("240225288303453578");
p1.setName("夜华");
session.setAttribute("p1",p1);
%>
<h3>学生学号是：${p1.ID}</h3>
<h3>学生姓名是：${p1.name}</h3>
</body>
</html>

使用EL表达式访问集合

在 EL 表达式中，同样可以获取集合的数据，这些集合可能是 Vector、List、Map、数组等。可以在 JSP 中获取这些对象，继而显示其中的内容，其语法格式如下：

${collection [序号]}

其中，collection 代表集合对象的名称。例如：

${books [0]}

上面表示的是一维集合，如数组、List 等，若操作的集合为二维集合，如 HashMap，其值是 key 和 value 值对的形式，则值 (value) 可以这样显示：

${collection.key}

表示显示名为 pi 的 HashMap 中的 key 为 ID 的元素的值。下面是通过 EL 表达式访问集合的一个案例。

<%@ page language="java"  contentType="text/html;charset=utf-8" %>
<%@ page import="java.util.*" %>
<html>
<head>
<title>使用 EL 访问集合</title>
</head>
<body>
<h1>使用 EL 访问集合</ h1>
<hr/>
<%
List books=new ArrayList();
books.add("Java语言程序设计");
books.add("高等数学");
session.setAttribute("books",books);
HashMap stu=new HashMap();
stu.put("stuno","00002");
stu.put("stuname","夜华");
session.setAttribute("stu",stu);
%>
<h3>books 中的内容是：${books[0]},${books[1]}</h3>
<h3>stu 中的内容是：${stu.stuno},${stu.stuname}</h3>
</body>
</html>

EL表达式内置对象cookie

EL 表达式的 cookie 内置对象可以获取 cookie 的值。使用方法如下：

${cookie.Cookie 名称.value}

【例1】获取 cookie 的值：

<%@page contentType="text/html;charset=utf-8" %>
<html>
<body>
<%
    response.addCookie(new Cookie("username","Make"));
%>
<a href="cookie-2.jsp"/>跳转cookie-2.jsp页面
</body>
</html>

<!--cookie-2.jsp-->
<%@ page contentType="text/html;charset=utf-8" %>
<html>
<body>
<h1>获得 cookie 对象</h1>
<hr>
<h3>${cookie.username.value}</h3>
</body>
</html>

Servlet

Servlet客户端转跳

Servlet 跳转有客户端跳转和服务器跳转两种。其中，客户端跳转运用 sendRedirect() 方法实现，服务器跳转运用 RequestDispatcher 接口实现，本文将介绍客户端跳转方法的实现以及使用。

在 Servlet 中要想进行客户端跳转，需要使用 HttpServletResponse 接口的 sendRedirect() 方法，但需要注意的是，这种跳转只能传递 session 和 application 范围的属性，无法传送 request 范围的属性。

例：使用客户端跳转：

首先创一个Servlet文件 ClientRedirect,代码如下：

package ch05;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class ClientRedirect extends HttpServlet
{
    /**
    *客户端跳转
    */
    public void goGet(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException
    {
        request.getSession().setAttribute("name","白辰");
        request.setAttribute("info","JavaServlet");
        response.sendRedirect("info.jsp");
    }
    public void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException
    {
        this.doGet(request,response);    //调用doGet的方法
    }
}

info.jsp 代码如下：

<%@ page contentType="text/html;charset=utf-8" pageEncoding="utf-8"%>
<html>
<head>
<title>
    Serlet客户端跳转
</title></head>
<body>
    <% request.setCharacterEncoding("utf-8");%>
    <h2>session 属性:<%=session.getAttribute("name")%></h2>
    <h2>request 属性:<%=request.getAttribute("info")%></h2>
</body>
</html>

Servlet生命周期

Servlet 程序是运行在服务端的 Java 程序，生命周期受 Web 容器的控制。Servlet 生命周期包括加载、初始化、服务、销毁、卸载 5 个部分，如图 所示。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TdLIXJ0Q-1610010212795)(C:\Users\小唐豆\Desktop\3-1Q12Q53ZY91.gif)]

JavaBean

什么是JavaBean

在实现功能时将 Java 代码嵌入网页中完成。这使得由 HTML 代码、JS 代码、CSS 代码、Java 代码等组成的程序代码看起来结构混乱，不利于程序员阅读调试。同时，界面设计和功能设计由同一人完成，也不利于开发人员进行开发，不能很好地发挥开发人员的长处。

JavaBean 正好解决了上述问题。简单地说，JavaBean 是一个可以重复使用的组件，通过编写一个组件来实现某种通用功能，“一次编写、任何地方执行、任何地方重用”，把复杂需求分析、分解成简单的功能模块。这种模块是相对独立的部分，可以重用，为程序员进行软件开发提供了一个极好的解决方案。

学习

JavaBean规范

1. 实现java.io.Serializable接口
2. 是一个公共类
   1. 类中必须存在一个无参数的构造函数。
   2. 提供对应的 setXxx() 和 getXxx() 方法来存取类中的属性。

JavaBean的Scope属性

​ 对于 JSP 程序而言，使用 JavaBean 组件不仅可以封装许多信息，而且还可以将一些数据处理的逻辑隐藏到 JavaBeah 的内部。除此之外，我们还可以设定 JavaBean 的 Scope 属性，使得 JavaBean 组件对于不同的任务具有不同的生命周期和不同的使用范围。

​ 在前面我们己经提到过 Scope 属性具有四个可能的值，分别是 application、session、request、page，分别代表 JavaBean 的四种不同的生命周期和四种不同的使用范围。bean 只有在它定义的范围里才能使用，在它的活动范围外将无法访问。

JSP指令

​ JSP 指令是为 JSP 引擎（比如 Tomcat）而设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理 JSP 页面中的其余部分。

JSP 引擎会根据 JSP 的指令信息来编译 JSP，生成 Java 文件。在生成的 Java 文件中，指令就不存在了。

一般都会把 JSP 指令放到 JSP 文件的最上方，但这不是必须的。

指令通常以<%@标记开始，以%>标记结束，它的具体语法如下：

<%@  指令名称  属性1="属性值1"  属性2="属性值2" ... 属性n="属性值n" %>

JSP 中三大指令，它们分别是 page、include 和 taglib，下表是对它们的简要说明。

指明	说明
page	page 指令用于定义 JSP 页面的各种属性。page 是最复杂的一个指令，它的属性很多，常用的属性有 import、language、pageEncoding 等。
include	静态包含指令，用于引入其它 JSP 文件。使用 include 指令引入的其它 JSP 文件，JSP 引擎将把这两个 JSP 文件翻译成一个 servlet，所以将 include 称为静态包含。
taglib	用于在 JSP 页面中导入标签库（JSP 标准标签库、第三方标签库、自定义标签库）。

JSP page指令

JSP page 指令是页面指令，可以定义在整个 JSP 页面范围有效的属性和相关的功能。利用 page 指令，可以指定脚本语言，导入需要的类，指明输出内容的类型，指定处理异常的错误页面，以及指定页面输出缓存的大小，还可以一次设置多个属性。

page 指令的属性如下：

<%@ page
[language="java"]
[contentType="mimeType[ ;charset=CHARSET ]"]
[import="{package.class|package.*},..."]
[info="text"]
[extends="package.class"]
[session="true|false"]
[errorPage="relativeURL"]
[isThreadSafe="true|false"]
[buffer="none|8kb|size kb"]
[autoFlush="true|false"]
[isThreadSafe="true|false"]
[isELIgnored="true|false"]
[page Encoding="CHARSET"]
%>

JSP文件上传

JSP 提供了上传和下载的功能，用户釆用此功能，可以轻松实现文件的传输。下面介绍文件上传与下载的操作。

用户通过一个 JSP 页面上传文件给服务器时，该 JSP 页面必须含有 File 类型的表单， 并且表单必须将 enctype 的属性值设置为 multipart/form-data。File 类型表单如下：

​

<form action="接受上传文件的页面" method="post" enctype="multipart/form-data">
<input type="File" name="picture">
</form>

JSP 引擎可以让内置对象 request 调用方法 getInputStream() 获得一个输入流，通过这输入流读入用户上传的全部信息，包括文件的内容以及表单域的信息。

JSTL

比EL更加强大需要引入两个jar包 ：jstl.jar standard.jar

引入taglib

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

核心标签库：

1. 通用标签库：

   <c:set>赋值
       在作用域中赋值（四个范围对象），给某个变量赋值，
        <c:set var="name" value="zhangsan" scope="request"/>
       在作用域中赋值（四个范围对象），给某个对象的属性赋值（此种写法，不指定scope属性）
       <c:set target="${requestScope.student}" property="sname"  value="zxs" />
   		${requestScope.student.sname } <br/>
       给map对象赋值
       ${requestScope.countries.cn }<br/>
   		<c:set target="${requestScope.countries}" property="cn"  value="中国" />
   			${requestScope.countries.cn }
       注：<c:set>可以给不存在的值赋值 但是不能给不存在的对象赋值
       
       
      <c:out>显示比el强大
          <c:out value="${requestScope.student }"   />
          c:out显示不存在的数据：<c:out value="${requestScope.stu }"   default="zs-23"  />
          
         删除属性
      <c:set  var="a" value="b" scope="request"/><br/>
   		显示：${a }
   		<c:remove var="a" scope="request"/>
   		删除后再显示：${a }
   
   

2. 条件标签库

3. 迭代标签库

过滤器

实现一个Filter接口 init(),distory() 原理执行时机同Servlet一样

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4OIfobiY-1610010212797)(C:\Users\小唐豆\AppData\Roaming\Typora\typora-user-images\image-20210106181430706.png)]

通过doFilter()处理拦截，并且通过chain.doFilter(request,response)；放行
   <url-pattern>/*<url-pattern> 拦截所有请求
   <url-pattern>MyServlet<url-pattern>只拦截MyServlet的请求
dispatcher请求方式：
  Request:拦截HTTP请求 get post
  Forward：只拦截通过请求转发方式的请求
  include：只拦截通过request.getResquestDispatcher("").include()
  error：只拦截<error-page>发出的请求

过滤器链

可以配置多个过滤器，过滤器的先后顺序是由的位置决定的

监听器

a.监听对象：request, session,application

request:ServletRequestListener

session:HttpSessionListener

application:ServletContextListener

上面三个接听对象的创建和销毁，每个监听器各自提供了两个方法：监听开始、监听结束的方法

ServletContext在servlet容器启动时，自动创建

b.监听对象属性的变更

request:ServletRequestAttributeListener

session:HttpSessionAttributeListener

application:ServletContextAttributeListener

public class Attribute implements 上面三个接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-imfTOA77-1610010212799)(C:\Users\小唐豆\AppData\Roaming\Typora\typora-user-images\image-20210106203315868.png)]

Ajax：

异步js+xml 异步刷新技术

如果网页某一个地方需要修改，异步刷新只刷新需要修改的地方。

实现

js：XMLHttpResquet对象

open(方法名（）,服务器地址,true)：与服务器建立连接
send()：   
		get: send(null)
		post:send(参数值)
setResquestHeader(header,value)
	get:不需要设计此方法
    post：需要设计此方法
    	如果请求元素中包含文件上传：    setResquestHeader("Conyent-Type","multipart/form-data")
		如果不包含文件上传：etResquestHeader("Conyent-Type","x-www-form-urlencoded")

XMLHttpResquet对象的属性：

readystate:请求状态 只有4是合适的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4ScmLEAr-1610010212802)(C:\Users\小唐豆\AppData\Roaming\Typora\typora-user-images\image-20210106211405675.png)]

status响应状态：只有200代表响应正常

onreadystatechange：回调函数

responseXML：响应格式为XML

注：客户端拿到电话号码，Ajax以post的方式请求服务端，服务端拿到数据对数据处理，通过流的方式返回给callback。

jquery：推荐

$.ajax({

​ url:服务器地址；

请求方式：get，post

data：请求数据

success:function(result,testStatus)

},

error:function(xhr,errorMessage,e)

);

get 方式
$.get(
服务器地址，
请求数据
function(result){

}，
预期返回值类型(String\)
);
post方式
$.get(
服务器地址，
请求数据
function(result){
		"xml"或"json"或"text"
}
);
$(jquery选择器).load(
	服务器地址，
请求数据
function(result){
		"xml"或"json"或"text"
}
);
$.getJSON(
	服务器地址,
	请求数据，
function(){

}
)

eListener

application:ServletContextAttributeListener

public class Attribute implements 上面三个接口

[外链图片转存中…(img-imfTOA77-1610010212799)]

Ajax：

异步js+xml 异步刷新技术

如果网页某一个地方需要修改，异步刷新只刷新需要修改的地方。

实现

js：XMLHttpResquet对象

open(方法名（）,服务器地址,true)：与服务器建立连接
send()：   
		get: send(null)
		post:send(参数值)
setResquestHeader(header,value)
	get:不需要设计此方法
    post：需要设计此方法
    	如果请求元素中包含文件上传：    setResquestHeader("Conyent-Type","multipart/form-data")
		如果不包含文件上传：etResquestHeader("Conyent-Type","x-www-form-urlencoded")

XMLHttpResquet对象的属性：

readystate:请求状态 只有4是合适的

[外链图片转存中…(img-4ScmLEAr-1610010212802)]

status响应状态：只有200代表响应正常

onreadystatechange：回调函数

responseXML：响应格式为XML

注：客户端拿到电话号码，Ajax以post的方式请求服务端，服务端拿到数据对数据处理，通过流的方式返回给callback。

jquery：推荐

$.ajax({

​ url:服务器地址；

请求方式：get，post

data：请求数据

success:function(result,testStatus)

},

error:function(xhr,errorMessage,e)

);

get 方式
$.get(
服务器地址，
请求数据
function(result){

}，
预期返回值类型(String\)
);
post方式
$.get(
服务器地址，
请求数据
function(result){
		"xml"或"json"或"text"
}
);
$(jquery选择器).load(
	服务器地址，
请求数据
function(result){
		"xml"或"json"或"text"
}
);
$.getJSON(
	服务器地址,
	请求数据，
function(){

}
)