防火墙 - Firewalld

firewalld 服务命令

1
2
3
4
5
6
7

systemctl enable firewalld.service  # 开启服务（开机自动启动服务）
systemctl disable firewalld.service # 关闭服务（开机不会自动启动服务）
systemctl start firewalld.service   # 启动服务
systemctl stop firewalld.service    # 停止服务
systemctl restart firewalld.service # 重启服务
systemctl reload firewalld.service  # 重新载入配置
systemctl status firewalld.service  # 查看服务状态

firewall-cmd 命令

firewall-cmd 命令用于配置防火墙。

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

firewall-cmd --version                    # 查看版本
firewall-cmd --help                       # 查看帮助
firewall-cmd --state                      # 显示状态
firewall-cmd --reload                     # 更新防火墙规则
firewall-cmd --get-active-zones           # 查看区域信息
firewall-cmd --get-zone-of-interface=eth0 # 查看指定接口所属区域
firewall-cmd --panic-on                   # 拒绝所有包
firewall-cmd --panic-off                  # 取消拒绝状态
firewall-cmd --query-panic                # 查看是否拒绝

firewall-cmd --zone=public --list-ports   # 查看所有打开的端口
firewall-cmd --zone=public --query-port=80/tcp # 查看是否有开放的 80 TCP 端口
firewall-cmd --zone=public --add-port=8080/tcp --permanent # 添加开放端口（--permanent永久生效，没有此参数重启后失效）
firewall-cmd --zone=public --remove-port=80/tcp --permanent # 永久删除开放的 80 TCP 端口

参考资料

• CentOS7 使用 firewalld 打开关闭防火墙与端口

定时任务 - crontab

环境：CentOS

通过 crontab 命令，我们可以在固定的间隔时间执行指定的系统指令或 shell script 脚本。时间间隔的单位可以是分钟、小时、日、月、周及以上的任意组合。这个命令非常适合周期性的日志分析或数据备份等工作。

crond 服务

Linux 通过 crond 服务来支持 crontab。

检查 crond 服务

使用 systemctl list-unit-files 命令确认 crond 服务是否已安装。

1
2

$ systemctl list-unit-files | grep crond
crond.service                               enabled

如果为 enabled，表示服务正运行。

crond 服务命令

开机自动启动 crond 服务：chkconfig crond on

或者，按以下命令手动启动：

1
2
3
4
5
6
7

systemctl enable crond.service  # 开启服务（开机自动启动服务）
systemctl disable crond.service # 关闭服务（开机不会自动启动服务）
systemctl start crond.service   # 启动服务
systemctl stop crond.service    # 停止服务
systemctl restart crond.service # 重启服务
systemctl reload crond.service  # 重新载入配置
systemctl status crond.service  # 查看服务状态

crontab

crontab 命令

crontab 命令格式如下：

1

crontab [-u user] file crontab [-u user] [ -e | -l | -r ]

说明：

• -u user：用来设定某个用户的 crontab 服务；
• file：file 是命令文件的名字，表示将 file 做为 crontab 的任务列表文件并载入 crontab。如果在命令行中没有指定这个文件，crontab 命令将接受标准输入（键盘）上键入的命令，并将它们载入 crontab。
• -e：编辑某个用户的 crontab 文件内容。如果不指定用户，则表示编辑当前用户的 crontab 文件。
• -l：显示某个用户的 crontab 文件内容，如果不指定用户，则表示显示当前用户的 crontab 文件内容。
• -r：从/var/spool/cron 目录中删除某个用户的 crontab 文件，如果不指定用户，则默认删除当前用户的 crontab 文件。
• -i：在删除用户的 crontab 文件时给确认提示。

有两种方法写入定时任务：

• 在命令行输入：crontab -e 然后添加相应的任务，存盘退出。
• 直接编辑 /etc/crontab 文件，即 vi /etc/crontab，添加相应的任务。

crontab 文件

crontab 要执行的定时任务都被保存在 /etc/crontab 文件中。

crontab 的文件格式如下：

标准字段

逗号用于分隔列表。例如，在第 5 个字段(星期几)中使用 MON,WED,FRI 表示周一、周三和周五。

连字符定义范围。例如，2000-2010 表示 2000 年至 2010 年期间的每年，包括 2000 年和 2010 年。

除非用反斜杠()转义，否则命令中的**百分号(%)**会被替换成换行符，第一个百分号后面的所有数据都会作为标准输入发送给命令。

/etc/crontab 文件示例：

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

SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root

# For details see man 4 crontabs

# Example of job definition:
# .---------------- minute (0 - 59)
# |  .------------- hour (0 - 23)
# |  |  .---------- day of month (1 - 31)
# |  |  |  .------- month (1 - 12) OR jan,feb,mar,apr ...
# |  |  |  |  .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat
# |  |  |  |  |
# *  *  *  *  * user-name  command to be executed

# 每两个小时以root身份执行 /home/hello.sh 脚本
0 */2 * * * root /home/hello.sh

crontab 实例

实例 1：每 1 分钟执行一次 myCommand

1

* * * * * myCommand

实例 2：每小时的第 3 和第 15 分钟执行

1

3,15 * * * * myCommand

实例 3：在上午 8 点到 11 点的第 3 和第 15 分钟执行

1

3,15 8-11 * * * myCommand

实例 4：每隔两天的上午 8 点到 11 点的第 3 和第 15 分钟执行

1

3,15 8-11 */2  *  * myCommand

实例 5：每周一上午 8 点到 11 点的第 3 和第 15 分钟执行

1

3,15 8-11 * * 1 myCommand

实例 6：每晚的 21:30 重启 smb

1

30 21 * * * /etc/init.d/smb restart

实例 7：每月 1、10、22 日的 4 : 45 重启 smb

1

45 4 1,10,22 * * /etc/init.d/smb restart

实例 8：每周六、周日的 1 : 10 重启 smb

1

10 1 * * 6,0 /etc/init.d/smb restart

实例 9：每天 18 : 00 至 23 : 00 之间每隔 30 分钟重启 smb

1

0,30 18-23 * * * /etc/init.d/smb restart

实例 10：每星期六的晚上 11 : 00 pm 重启 smb

1

0 23 * * 6 /etc/init.d/smb restart

实例 11：每一小时重启 smb

1

0 * * * * /etc/init.d/smb restart

实例 12：晚上 11 点到早上 7 点之间，每隔一小时重启 smb

1

0 23-7 * * * /etc/init.d/smb restart

参考资料

• 文章
  • crontab 定时任务
  • linux 定时执行脚本
• 在线工具
  • https://tool.lu/crontab/
  • https://cron.qqe2.com/

效率提升方法论

在智力水平相当的前提下，常常会发现：有些人做事，事倍功半；有些人做事，事半功倍。

做任何事，如果有了清晰的思路，正确的指导方针，肯定是比毫无头绪要高效很多。所以，现实中，常常会看到这样一种现象，优秀的人，往往全面优秀，干什么都出彩；而平庸的人，做什么都出不了成绩。

大多数人不是天才，想要变得优秀，唯一的途径就是：按照正确的习惯（方式方法），坚持不懈的努力进步（自律）。

我们日复一日做的事情，决定了我们是怎样的人。因此所谓卓越，并非指行为，而是习惯。

We are what we repeatedly do. Excellence, then, is not an act, but a habit.

——莎士比亚

做计划常用方法

名称	图示	方式	优点	缺点
时间法		时间顺序	清晰明确 操作性强	时间分配不合理或 突出情况容易打乱计划
清单法		重要程度	要事优先 事无遗漏	未完成容易形成压力； 容易造成形式主义，为打卡而完成
三段法		完成状态	态度明了 有条不紊	灵活性差，只能电子版或软件实现编辑， 纸质版事项会重复
OKR 法		目标分解	目标导向 高效成事	适合复杂事情或大项目的分解执行跟进
分类法		八个方面	事事周全 面面俱到	越是想顾周全，越难周全， 面面俱到，也会事事难完成
四象限法		轻重缓急	要事优先 忽略次要	被要事牵着走，忽略了 人生应该适度娱乐的重要性
甘特图法		日期进度	进度直观 易于理解	进度条只能反映时间进度， 无法反映事项具体完成情况的进度
PDCA 法		流程顺序	流程推进 循环解决	流程化容易形成思维惯性， 并且缺乏压力难以形成创造性

W2H

5W2H 分析法是一种思考问题的启发式思维方式。5W2H 分析法用五个以 W 开头的英语单词和两个以 H 开头的英语单词进行设问，得到关键性问题的答案，最后总结归纳出问题的目标、解决思路、处理方法等，这就叫做 5W2H 法。

5W2H 分析法又叫七问分析法，是二战中美国陆军兵器修理部首创。这种分析法广泛用于企业管理和技术活动，对于决策和执行性的活动措施也非常有帮助，也有助于弥补考虑问题的疏漏。

5W2H 分析法的意义在于：避免遇到一个问题后，不知从何入手。通过设问方式，由点成线，由线成面，把问题的关键点串联起来，整理出问题的解决思路。

• why - 为什么？为什么要这么做？理由何在？原因是什么？
• what - 是什么？目的是什么？作什么工作？
• where - 何处？在哪里做？从哪里入手？
• when - 何时？什么时间完成？什么时机最适宜？
• who - 谁？有谁来承担？谁来完成？谁负责？
• how - 怎么做？如何提高效率？如何实施？方法怎么样？
• how much - 多少？做到什么程度？数量如何？质量水平如何？费用产出如何？

四象限原则

四象限原则是一种时间管理方式。

有首歌唱出了大多数职场人的心声：时间都去哪儿了？

事情、任务太多，时间太少，分身乏术。

时间管理四象限法则是美国的管理学家科维提出的一个时间管理的理论，按处理顺序划分为：紧急又重要、重要不紧急、紧急不重要、不紧急不重要。

• 第一象限（重要而紧急）

  • 案例：应付难缠的客户、准时完成工作、住院开刀等等。
  • 这是考验我们的经验、判断力的时刻，也是可以用心耕耘的园地。如果荒废了，我们很会可能变成行尸走肉。但我们也不能忘记，很多重要的事都是因为一拖再拖或事前准备不足，而变成迫在眉睫。
  • 该象限的本质是缺乏有效的工作计划导致本处于“重要但不紧急”第二象限的事情转变过来的，这也是传统思维状态下的管理者的通常状况，就是“忙”。

• 第二象限（重要但不紧急）

  • 案例：学习新技能、建立人际关系、保持身体健康、长期的规划、问题的发掘与预防、参加培训、向上级提出问题处理的建议等等事项。
  • 荒废这个领域将使第一象限日益扩大，使我们陷入更大的压力，在危机中疲于应付。反之，多投入一些时间在这个领域有利于提高实践能力，缩小第一象限的范围。做好事先的规划、准备与预防措施，很多急事将无从产生。这个领域的事情不会对我们造成催促力量，所以必须主动去做，这是发挥个人领导力的领域。
  • 这更是传统低效管理者与高效卓越管理者的重要区别标志，建议管理者要把 80%的精力投入到该象限的工作，以使第一象限的“急”事无限变少，不再瞎“忙”。

• 第三象限（紧急但不重要）

  • 案例：电话、会议、突发的访客都属于这一类。
  • 表面看似第一象限，因为迫切的呼声会让我们产生“这件事很重要”的错觉——实际上就算重要也是对别人而言。我们花很多时间在这个里面打转，自以为是在第一象限，其实不过是在满足别人的期望与标准。

• 第四象限（不紧急也不重要）

  • 案例：阅读无聊小说、看毫无内容的电视节目、办公室聊天、刷微博、刷朋友圈等。
  • 简而言之就是浪费生命，所以根本不值得花半点时间在这个象限。但我们往往在一、三象限来回奔走，忙得焦头烂额，不得不到第四象限去疗养一番再出发。这部分范围倒不见得都是休闲活动，因为真正有创造意义的休闲活动是很有价值的。然而像阅读令人上瘾的无聊小说、毫无内容的电视节目、办公室聊天等。这样的休息不但不是为了走更长的路，反而是对身心的毁损，刚开始时也许有滋有味，到后来你就会发现其实是很空虚的。

HBase 快速入门

HBase 简介

为什么需要 HBase

在介绍 HBase 之前，我们不妨先了解一下为什么需要 HBase，或者说 HBase 是为了达到什么目的而产生。

在 HBase 诞生之前，Hadoop 可以通过 HDFS 来存储结构化、半结构甚至非结构化的数据，它是传统数据库的补充，是海量数据存储的最佳方法，它针对大文件的存储，批量访问和流式访问都做了优化，同时也通过多副本解决了容灾问题。

Hadoop 的缺陷在于：它只能执行批处理，并且只能以顺序方式访问数据。这意味着即使是最简单的工作，也必须搜索整个数据集，即：Hadoop 无法实现对数据的随机访问。实现数据的随机访问是传统的关系型数据库所擅长的，但它们却不能用于海量数据的存储。在这种情况下，必须有一种新的方案来同时解决海量数据存储和随机访问的问题，HBase 就是其中之一 (HBase，Cassandra，CouchDB，Dynamo 和 MongoDB 都能存储海量数据并支持随机访问)。

注：数据结构分类：

• 结构化数据：即以关系型数据库表形式管理的数据；
• 半结构化数据：非关系模型的，有基本固定结构模式的数据，例如日志文件、XML 文档、JSON 文档、Email 等；
• 非结构化数据：没有固定模式的数据，如 WORD、PDF、PPT、EXL，各种格式的图片、视频等。

什么是 HBase

HBase 是一个构建在 HDFS（Hadoop 文件系统）之上的列式数据库。

HBase 是一种类似于 Google’s Big Table 的数据模型，它是 Hadoop 生态系统的一部分，它将数据存储在 HDFS 上，客户端可以通过 HBase 实现对 HDFS 上数据的随机访问。

HBase 的核心特性如下：

• 分布式
  • 伸缩性：支持通过增减机器进行水平扩展，以提升整体容量和性能
  • 高可用：支持 RegionServers 之间的自动故障转移
  • 自动分区：Region 分散在集群中，当行数增长的时候，Region 也会自动的分区再均衡
• 超大数据集：HBase 被设计用来读写超大规模的数据集（数十亿行至数百亿行的表）
• 支持结构化、半结构化和非结构化的数据：由于 HBase 基于 HDFS 构建，所以和 HDFS 一样，支持结构化、半结构化和非结构化的数据
• 非关系型数据库
  • 不支持标准 SQL 语法
  • 没有真正的索引
  • 不支持复杂的事务：只支持行级事务，即单行数据的读写都是原子性的

HBase 的其他特性

• 读写操作遵循强一致性
• 过滤器支持谓词下推
• 易于使用的 Java 客户端 API
• 它支持线性和模块化可扩展性。
• HBase 表支持 Hadoop MapReduce 作业的便捷基类
• 很容易使用 Java API 进行客户端访问
• 为实时查询提供块缓存 BlockCache 和布隆过滤器
• 它通过服务器端过滤器提供查询谓词下推

什么时候使用 HBase

根据上一节对于 HBase 特性的介绍，我们可以梳理出 HBase 适用、不适用的场景：

HBase 不适用场景：

• 需要索引
• 需要复杂的事务
• 数据量较小（比如：数据量不足几百万行）

HBase 适用场景：

• 能存储海量数据并支持随机访问（比如：数据量级达到十亿级至百亿级）
• 存储结构化、半结构化数据
• 硬件资源充足

一言以蔽之——HBase 适用的场景是：实时地随机访问超大数据集。

HBase 的典型应用场景

• 存储监控数据
• 存储用户/车辆 GPS 信息
• 存储用户行为数据
• 存储各种日志数据，如：访问日志、操作日志、推送日志等。
• 存储短信、邮件等消息类数据
• 存储网页数据

HBase 数据模型简介

前面已经提及，HBase 是一个列式数据库，其数据模型和关系型数据库有所不同。其数据模型的关键术语如下：

• Table - HBase 表由多行组成。
• Row - HBase 中的一行由一个行键和一个或多个列以及与之关联的值组成。 行在存储时按行键的字母顺序排序。 为此，行键的设计非常重要。 目标是以相关行彼此靠近的方式存储数据。 常见的行键模式是网站域。 如果您的行键是域，您应该将它们反向存储（org.apache.www、org.apache.mail、org.apache.jira）。 这样，所有 Apache 域在表中彼此靠近，而不是根据子域的第一个字母展开。
• Column - HBase 中的列由列族和列限定符组成，它们由 :（冒号）字符分隔。
• Column Family - 通常出于性能原因，列族在物理上将一组列及其值放在一起。 每个列族都有一组存储属性，例如它的值是否应该缓存在内存中，它的数据是如何压缩的，它的行键是如何编码的，等等。 表中的每一行都有相同的列族，尽管给定的行可能不在给定的列族中存储任何内容。
• 列限定符 - 将列限定符添加到列族以提供给定数据片段的索引。 给定列族内容，列限定符可能是 content:html，另一个可能是 content:pdf。 尽管列族在表创建时是固定的，但列限定符是可变的，并且行之间可能有很大差异。
• Cell - 单元格是行、列族和列限定符的组合，包含一个值和一个时间戳，代表值的版本。
• Timestamp - 时间戳写在每个值旁边，是给定版本值的标识符。 默认情况下，时间戳表示写入数据时 RegionServer 上的时间，但您可以在将数据放入单元格时指定不同的时间戳值。

特性比较

HBase vs. RDBMS

HBase vs. HDFS

行式数据库 vs. 列式数据库

列式数据库的优点：

• 支持数据压缩
• 支持快速数据检索
• 简化了管理和配置
• 有利于聚合查询（例如 COUNT、SUM、AVG、MIN 和 MAX）的高性能
• 分区效率很高，因为它提供了自动分片机制的功能，可以将较大的区域分配给较小的区域

列式数据库的缺点：

• JOIN 查询和来自多个表的数据未优化
• 必须为频繁的删除和更新创建拆分，因此降低了存储效率
• 由于非关系数据库的特性，分区和索引的设计非常困难

HBase 安装

HBase 安装可以参考以下文档：

• 独立模式
• 伪分布式模式
• 全分布式模式
• Docker 部署

HBase Hello World 示例

（1）连接 HBase

在 HBase 安装目录的 /bin 目录下执行 hbase shell 命令进入 HBase 控制台。

1
2

$ ./bin/hbase shell
hbase(main):001:0>

（2）输入 help 可以查看 HBase Shell 命令。

（3）创建表

可以使用 create 命令创建一张新表。必须要指定表名和 Column Family。

1
2
3
4

hbase(main):001:0> create 'test', 'cf'
0 row(s) in 0.4170 seconds

=> Hbase::Table - test

（4）列出表信息

使用 list 命令来确认新建的表已存在。

1
2
3
4
5
6

hbase(main):002:0> list 'test'
TABLE
test
1 row(s) in 0.0180 seconds

=> ["test"]

可以使用 describe 命令可以查看表的细节信息，包括配置信息

1
2
3
4
5
6
7
8
9
10

hbase(main):003:0> describe 'test'
Table test is ENABLED
test
COLUMN FAMILIES DESCRIPTION
{NAME => 'cf', VERSIONS => '1', EVICT_BLOCKS_ON_CLOSE => 'false', NEW_VERSION_BEHAVIOR => 'false', KEEP_DELETED_CELLS => 'FALSE', CACHE_DATA_ON_WRITE =>
'false', DATA_BLOCK_ENCODING => 'NONE', TTL => 'FOREVER', MIN_VERSIONS => '0', REPLICATION_SCOPE => '0', BLOOMFILTER => 'ROW', CACHE_INDEX_ON_WRITE => 'f
alse', IN_MEMORY => 'false', CACHE_BLOOMS_ON_WRITE => 'false', PREFETCH_BLOCKS_ON_OPEN => 'false', COMPRESSION => 'NONE', BLOCKCACHE => 'true', BLOCKSIZE
 => '65536'}
1 row(s)
Took 0.9998 seconds

（5）向表中写数据

可以使用 put 命令向 HBase 表中写数据。

1
2
3
4
5
6
7
8

hbase(main):003:0> put 'test', 'row1', 'cf:a', 'value1'
0 row(s) in 0.0850 seconds

hbase(main):004:0> put 'test', 'row2', 'cf:b', 'value2'
0 row(s) in 0.0110 seconds

hbase(main):005:0> put 'test', 'row3', 'cf:c', 'value3'
0 row(s) in 0.0100 seconds

（6）一次性扫描表的所有数据

使用 scan 命令来扫描表数据。

1
2
3
4
5
6

hbase(main):006:0> scan 'test'
ROW                                      COLUMN+CELL
 row1                                    column=cf:a, timestamp=1421762485768, value=value1
 row2                                    column=cf:b, timestamp=1421762491785, value=value2
 row3                                    column=cf:c, timestamp=1421762496210, value=value3
3 row(s) in 0.0230 seconds

（7）查看一行数据

使用 get 命令可以查看一行表数据。

1
2
3
4

hbase(main):007:0> get 'test', 'row1'
COLUMN                                   CELL
 cf:a                                    timestamp=1421762485768, value=value1
1 row(s) in 0.0350 seconds

（8）禁用表

如果想要删除表或修改表设置，必须先使用 disable 命令禁用表。如果想再次启用表，可以使用 enable 命令。

1
2
3
4
5

hbase(main):008:0> disable 'test'
0 row(s) in 1.1820 seconds

hbase(main):009:0> enable 'test'
0 row(s) in 0.1770 seconds

（9）删除表

使用 drop 命令可以删除表。

1
2

hbase(main):011:0> drop 'test'
0 row(s) in 0.1370 seconds

（10）退出 HBase Shell

使用 quit 命令，就能退出 HBase Shell 控制台。

参考资料

• 官方
  • HBase 官网
  • HBase 官方文档
  • HBase 官方文档中文版
• 书籍
  • Hadoop 权威指南
• 文章
  • Bigtable: A Distributed Storage System for Structured Data
  • An In-Depth Look at the HBase Architecture
• 教程
  • https://github.com/heibaiying/BigData-Notes
  • https://www.cloudduggu.com/hbase/introduction/

Nosql 技术选型

一、Nosql 简介

传统的关系型数据库存在以下缺点：

• 大数据场景下 I/O 较高 - 因为数据是按行存储，即使只针对其中某一列进行运算，关系型数据库也会将整行数据从存储设备中读入内存，导致 I/O 较高。
• 存储的是行记录，无法存储数据结构。
• 表结构 schema 扩展不方便 - 如要需要修改表结构，需要执行执行 DDL(data definition language)，语句修改，修改期间会导致锁表，部分服务不可用。
• 全文搜索功能较弱 - 关系型数据库下只能够进行子字符串的匹配查询，当表的数据逐渐变大的时候，LIKE 查询的匹配会非常慢，即使在有索引的情况下。况且关系型数据库也不应该对文本字段进行索引。
• 存储和处理复杂关系型数据功能较弱 - 许多应用程序需要了解和导航高度连接数据之间的关系，才能启用社交应用程序、推荐引擎、欺诈检测、知识图谱、生命科学和 IT/网络等用例。然而传统的关系数据库并不善于处理数据点之间的关系。它们的表格数据模型和严格的模式使它们很难添加新的或不同种类的关联信息。

随着大数据时代的到来，越来越多的网站、应用系统需要支撑海量数据存储，高并发请求、高可用、高可扩展性等特性要求。传统的关系型数据库在应付这些调整已经显得力不从心，暴露了许多能以克服的问题。由此，各种各样的 NoSQL（Not Only SQL）数据库作为传统关系型数据的一个有力补充得到迅猛发展。

NoSQL，泛指非关系型的数据库，可以理解为 SQL 的一个有力补充。

在 NoSQL 许多方面性能大大优于非关系型数据库的同时，往往也伴随一些特性的缺失，比较常见的，是事务库事务功能的缺失。 数据库事务正确执行的四个基本要素：ACID 如下：

下面介绍 5 大类 NoSQL 数据针对传统关系型数据库的缺点提供的解决方案：

二、列式数据库

列式数据库是以列相关存储架构进行数据存储的数据库，主要适合于批量数据处理和即时查询。

相对应的是行式数据库，数据以行相关的存储体系架构进行空间分配，主要适合于小批量的数据处理，常用于联机事务型数据处理。

基于列式数据库的列列存储特性，可以解决某些特定场景下关系型数据库 I/O 较高的问题。

列式数据库原理

传统关系型数据库是按照行来存储数据库，称为“行式数据库”，而列式数据库是按照列来存储数据。

将表放入存储系统中有两种方法，而我们绝大部分是采用行存储的。 行存储法是将各行放入连续的物理位置，这很像传统的记录和文件系统。 列存储法是将数据按照列存储到数据库中，与行存储类似，下图是两种存储方法的图形化解释：

列式数据库产品

• HBase

  

  HBase 是一个开源的非关系型分布式数据库（NoSQL），它参考了谷歌的 BigTable 建模，实现的编程语言为 Java。它是 Apache 软件基金会的 Hadoop 项目的一部分，运行于 HDFS 文件系统之上，为 Hadoop 提供类似于 BigTable 规模的服务。因此，它可以容错地存储海量稀疏的数据。

• BigTable

  

  BigTable 是一种压缩的、高性能的、高可扩展性的，基于 Google 文件系统（Google File System，GFS）的数据存储系统，用于存储大规模结构化数据，适用于云端计算。

列式数据库特性

优点如下：

• 高效的储存空间利用率

列式数据库由于其针对不同列的数据特征而发明的不同算法，使其往往有比行式数据库高的多的压缩率，普通的行式数据库一般压缩率在 3：1 到 5：1 左右，而列式数据库的压缩率一般在 8：1 到 30：1 左右。 比较常见的，通过字典表压缩数据： 下面中才是那张表本来的样子。经过字典表进行数据压缩后，表中的字符串才都变成数字了。正因为每个字符串在字典表里只出现一次了，所以达到了压缩的目的（有点像规范化和非规范化 Normalize 和 Denomalize)

• 查询效率高

读取多条数据的同一列效率高，因为这些列都是存储在一起的，一次磁盘操作可以数据的指定列全部读取到内存中。 下图通过一条查询的执行过程说明列式存储（以及数据压缩）的优点

1
2
3
4
5
6

执行步骤如下：
i. 去字典表里找到字符串对应数字（只进行一次字符串比较）。
ii. 用数字去列表里匹配，匹配上的位置设为 1。
iii. 把不同列的匹配结果进行位运算得到符合所有条件的记录下标。
iv. 使用这个下标组装出最终的结果集。
复制代码

• 适合做聚合操作
• 适合大量的数据而不是小数据

缺点如下：

• 不适合扫描小量数据
• 不适合随机的更新
• 不适合做含有删除和更新的实时操作
• 单行的数据是 ACID 的，多行的事务时，不支持事务的正常回滚，支持 I(Isolation) 隔离性（事务串行提交），D(Durability) 持久性，不能保证 A(Atomicity) 原子性， C(Consistency) 一致性

列式数据库使用场景

以 HBase 为例说明：

• 大数据量 （100s TB 级数据） 且有快速随机访问的需求。增长量无法预估的应用，需要进行优雅的数据扩展的 HBase 支持在线扩展，即使在一段时间内数据量呈井喷式增长，也可以通过 HBase 横向扩展来满足功能。
• 写密集型应用，每天写入量巨大，而相对读数量较小的应用 比如 IM 的历史消息，游戏的日志等等
• 不需要复杂查询条件来查询数据的应用 HBase 只支持基于 rowkey 的查询，对于 HBase 来说，单条记录或者小范围的查询是可以接受的，大范围的查询由于分布式的原因，可能在性能上有点影响，HBase 不适用于有 join，多级索引，表关系复杂的数据模型。
• 对性能和可靠性要求非常高的应用，由于 HBase 本身没有单点故障，可用性非常高。
• 存储结构化和半结构化的数据。

三、K-V 数据库

K-V 数据库指的是使用键值 (key-value) 存储的数据库，其数据按照键值对的形式进行组织、索引和存储。

KV 存储非常适合存储不涉及过多数据关系业务关系的数据，同时能有效减少读写磁盘的次数，比 SQL 数据库存储拥有更好的读写性能，能够解决关系型数据库无法存储数据结构的问题。

K-V 数据库产品

• Redis

  

  Redis 是一个使用 ANSI C 编写的开源、支持网络、基于内存、可选持久性的键值对存储数据库。从 2015 年 6 月开始，Redis 的开发由 Redis Labs 赞助，而 2013 年 5 月至 2015 年 6 月期间，其开发由 Pivotal 赞助。在 2013 年 5 月之前，其开发由 VMware 赞助。根据月度排行网站 DB-Engines.com 的数据显示，Redis 是最流行的键值对存储数据库。

• Cassandra

  

  Apache Cassandra（社区内一般简称为 C*）是一套开源分布式 NoSQL 数据库系统。它最初由 Facebook 开发，用于储存收件箱等简单格式数据，集 Google BigTable 的数据模型与 Amazon Dynamo 的完全分布式架构于一身。Facebook 于 2008 将 Cassandra 开源，此后，由于 Cassandra 良好的可扩展性和性能，被 Apple, Comcast,Instagram, Spotify, eBay, Rackspace, Netflix 等知名网站所采用，成为了一种流行的分布式结构化数据存储方案。

• LevelDB

  

  LevelDB 是一个由 Google 公司所研发的键／值对（Key/Value Pair）嵌入式数据库管理系统编程库， 以开源的 BSD 许可证发布。

K-V 数据库特性

以 Redis 为例：

优点如下：

• 性能极高 - Redis 能支持超过 10W 的 TPS。
• 丰富的数据类型 - Redis 支持包括 String，Hash，List，Set，Sorted Set，Bitmap 和 hyperloglog。
• 丰富的特性 - Redis 还支持 publish/subscribe、通知、key 过期等等特性。

缺点如下： 针对 ACID，Redis 事务不能支持原子性和持久性 (A 和 D)，只支持隔离性和一致性 (I 和 C) 特别说明一下，这里所说的无法保证原子性，是针对 Redis 的事务操作，因为事务是不支持回滚（roll back），而因为 Redis 的单线程模型，Redis 的普通操作是原子性的。

大部分业务不需要严格遵循 ACID 原则，例如游戏实时排行榜，粉丝关注等场景，即使部分数据持久化失败，其实业务影响也非常小。因此在设计方案时，需要根据业务特征和要求来做选择

K-V 数据库使用场景

• 适用场景 - 储存用户信息（比如会话）、配置文件、参数、购物车等等。这些信息一般都和 ID（键）挂钩。

• 不适用场景

  • 需要通过值来查询，而不是键来查询。Key-Value 数据库中根本没有通过值查询的途径。
  • 需要储存数据之间的关系。在 Key-Value 数据库中不能通过两个或以上的键来关联数据
  • 需要事务的支持。在 Key-Value 数据库中故障产生时不可以进行回滚。

四、文档数据库

文档数据库（也称为文档型数据库）是旨在将半结构化数据存储为文档的一种数据库，它可以解决关系型数据库表结构 schema 扩展不方便的问题。文档数据库通常以 JSON 或 XML 格式存储数据。

由于文档数据库的 no-schema 特性，可以存储和读取任意数据。由于使用的数据格式是 JSON 或者 XML，无需在使用前定义字段，读取一个 JSON 中不存在的字段也不会导致 SQL 那样的语法错误。

文档数据库产品

• MongoDB

  

  **MongoDB **是一种面向文档的数据库管理系统，由 C++ 撰写而成，以此来解决应用程序开发社区中的大量现实问题。2007 年 10 月，MongoDB 由 10gen 团队所发展。2009 年 2 月首度推出。

• CouchDB

  

  Apache CouchDB 是一个开源数据库，专注于易用性和成为”完全拥抱 web 的数据库“。它是一个使用 JSON 作为存储格式，JavaScript 作为查询语言，MapReduce 和 HTTP 作为 API 的 NoSQL 数据库。其中一个显著的功能就是多主复制。CouchDB 的第一个版本发布在 2005 年，在 2008 年成为了 Apache 的项目。

文档数据库特性

以 MongoDB 为例进行说明

优点如下：

• 容易存储复杂数据结构 - JSON 是一种强大的描述语言，能够描述复杂的数据结构。
• 容易变更数据结构 - 无需像关系型数据库一样先执行 DDL 语句修改表结构，程序代码直接读写即可。
• 容易兼容历史数据 - 对于历史数据，即使没有新增的字段，也不会导致错误，只会返回空值，此时代码兼容处理即可。

缺点如下：

• 部分支持事务
  • Atomicity（原子性） 仅支持单行/文档级原子性，不支持多行、多文档、多语句原子性。
  • Isolation（隔离性） 隔离级别仅支持已提交读（Read committed）级别，可能导致不可重复读，幻读的问题。
• 不支持复杂查询 - 例如 join 查询，如果需要 join 查询，需要多次操作数据库。

MongonDB 还是支持多文档事务的 Consistency（一致性）和 Durability（持久性）

虽然官方宣布 MongoDB 将在 4.0 版本中正式推出多文档 ACID 事务支持，最后落地情况还有待见证。

文档数据库使用场景

适用场景：

• 大数据量，且未来数据增长很快
• 表结构不明确，且字段在不断增加，例如内容管理系统，信息管理系统

不适用场景：

• 支持事务 - 在不同的文档上需要添加事务。Document-Oriented 数据库并不支持文档间的事务
• 支持复杂查询 - 多个文档直接需要复杂查询，例如 join

五、全文搜索引擎

传统关系型数据库主要通过索引来达到快速查询的目的，在全文搜索的业务下，索引也无能为力，主要体现在：

• 全文搜索的条件可以随意排列组合，如果通过索引来满足，则索引的数量非常多
• 全文搜索的模糊匹配方式，索引无法满足，只能用 LIKE 查询，而 LIKE 查询是整表扫描，效率非常低

而全文搜索引擎的出现，正是解决关系型数据库全文搜索功能较弱的问题。

搜索引擎原理

全文搜索引擎的技术原理称为 **倒排索引（inverted index）**，是一种索引方法，其基本原理是建立单词到文档的索引。与之相对是，是“正排索引”，其基本原理是建立文档到单词的索引。

现在有如下文档集合：

正排索引得到索引如下：

可见，正排索引适用于根据文档名称查询文档内容

简单的倒排索引如下：

带有单词频率信息的倒排索引如下：

可见，倒排索引适用于根据关键词来查询文档内容

搜索引擎产品

• Elasticsearch

  

  Elasticsearch 是一个基于 Lucene 的搜索引擎。它提供了一个分布式，多租户 -能够全文搜索与发动机 HTTP Web 界面和无架构 JSON 文件。Elasticsearch 是用 Java 开发的，并根据 Apache License 的条款作为开源发布。根据 DB-Engines 排名，Elasticsearch 是最受欢迎的企业搜索引擎，后面是基于 Lucene 的 Apache Solr。

• Solr

  

  Solr 是 Apache Lucene 项目的开源企业搜索平台。其主要功能包括全文检索、命中标示、分面搜索、动态聚类、数据库集成，以及富文本（如 Word、PDF）的处理。Solr 是高度可扩展的，并提供了分布式搜索和索引复制

搜索引擎特性

以 Elasticsearch 为例： 优点如下：

• 查询效率高 - 对海量数据进行近实时的处理
• 可扩展性 - 基于集群环境可以方便横向扩展，可以承载 PB 级数据
• 高可用 - Elasticsearch 集群弹性-他们将发现新的或失败的节点，重组和重新平衡数据，确保数据是安全的和可访问的

缺点如下：

• 部分支持事务 - 单一文档的数据是 ACID 的，包含多个文档的事务时不支持事务的正常回滚，支持 I(Isolation) 隔离性（基于乐观锁机制的），D(Durability) 持久性，不支持 A(Atomicity) 原子性，C(Consistency) 一致性
• 对类似数据库中通过外键的复杂的多表关联操作支持较弱。
• 读写有一定延时，写入的数据，最快 1s 中能被检索到
• 更新性能较低，底层实现是先删数据，再插入新数据
• 内存占用大，因为 Lucene 将索引部分加载到内存中

搜索引擎场景

适用场景如下：

• 搜索引擎和数据分析引擎 - 全文检索，结构化检索，数据分析
• 对海量数据进行近实时的处理 - 可以将海量数据分散到多台服务器上去存储和检索

不适用场景如下：

• 数据需要频繁更新
• 需要复杂关联查询

六、图数据库

图形数据库应用图论存储实体之间的关系信息。最常见例子就是社会网络中人与人之间的关系。关系型数据库用于存储“关系型”数据的效果并不好，其查询复杂、缓慢、超出预期，而图形数据库的独特设计恰恰弥补了这个缺陷，解决关系型数据库存储和处理复杂关系型数据功能较弱的问题。

图数据库产品

• Neo4j

  

  Neo4j 是由 Neo4j，Inc。开发的图形数据库管理系统。由其开发人员描述为具有原生图存储和处理的符合 ACID 的事务数据库，根据 DB-Engines 排名， Neo4j 是最流行的图形数据库。

• ArangoDB

  

  ArangoDB 是由 triAGENS GmbH 开发的原生多模型数据库系统。数据库系统支持三个重要的数据模型（键/值，文档，图形），其中包含一个数据库核心和统一查询语言 AQL（ArangoDB 查询语言）。查询语言是声明性的，允许在单个查询中组合不同的数据访问模式。ArangoDB 是一个 NoSQL 数据库系统，但 AQL 在很多方面与 SQL 类似。

• Titan

  

  Titan 是一个可扩展的图形数据库，针对存储和查询包含分布在多机群集中的数百亿个顶点和边缘的图形进行了优化。Titan 是一个事务性数据库，可以支持数千个并发用户实时执行复杂的图形遍历。

图数据库特性

以 Neo4j 为例：

Neo4j 使用数据结构中图（graph）的概念来进行建模。 Neo4j 中两个最基本的概念是节点和边。节点表示实体，边则表示实体之间的关系。节点和边都可以有自己的属性。不同实体通过各种不同的关系关联起来，形成复杂的对象图。

针对关系数据，2 种 2 数据库的存储结构不同：

Neo4j 中，存储节点时使用了”index-free adjacency”，即每个节点都有指向其邻居节点的指针，可以让我们在 O(1) 的时间内找到邻居节点。另外，按照官方的说法，在 Neo4j 中边是最重要的，是”first-class entities”，所以单独存储，这有利于在图遍历的时候提高速度，也可以很方便地以任何方向进行遍历

如下优点：

• 高性能 - 图的遍历是图数据结构所具有的独特算法，即从一个节点开始，根据其连接的关系，可以快速和方便地找出它的邻近节点。这种查找数据的方法并不受数据量的大小所影响，因为邻近查询始终查找的是有限的局部数据，不会对整个数据库进行搜索
• 设计的灵活性 - 数据结构的自然伸展特性及其非结构化的数据格式，让图数据库设计可以具有很大的伸缩性和灵活性。因为随着需求的变化而增加的节点、关系及其属性并不会影响到原来数据的正常使用
• 开发的敏捷性 - 直观明了的数据模型，从需求的讨论开始，到程序开发和实现，以及最终保存在数据库中的样子，它的模样似乎没有什么变化，甚至可以说本来就是一模一样的
• 完全支持 ACID - 不像别的 NoSQL 数据库 Neo4j 还具有完全事务管理特性，完全支持 ACID 事务管理

缺点如下：

• 存在支持节点，关系和属性的数量的限制。
• 不支持拆分。

图数据库场景

适用场景如下：

• 关系性强的数据中，如社交网络
• 推荐引擎。如果我们将数据以图的形式表现，那么将会非常有益于推荐的制定

不适用场景如下：

• 记录大量基于事件的数据（例如日志条目或传感器数据）
• 对大规模分布式数据进行处理
• 保存在关系型数据库中的结构化数据
• 二进制数据存储

七、总结

关系型数据库和 NoSQL 数据库的选型，往往需要考虑几个指标：

• 数据量
• 并发量
• 实时性
• 一致性要求
• 读写分布和类型
• 安全性
• 运维成本

常见软件系统数据库选型参考如下：

• 中后台管理型系统 - 如运营系统，数据量少，并发量小，首选关系型数据库。
• 大流量系统 - 如电商单品页，后台考虑选关系型数据库，前台考虑选内存型数据库。
• 日志型系统 - 原始数据考虑选列式数据库，日志搜索考虑选搜索引擎。
• 搜索型系统 - 例如站内搜索，非通用搜索，如商品搜索，后台考虑选关系型数据库，前台考虑选搜索引擎。
• 事务型系统 - 如库存，交易，记账，考虑选关系型数据库+K-V 数据库（作为缓存）+分布式事务。
• 离线计算 - 如大量数据分析，考虑选列式数据库或关系型数据。
• 实时计算 - 如实时监控，可以考虑选内存型数据库或者列式数据库。

设计实践中，要基于需求、业务驱动架构，无论选用 RDB/NoSQL/DRDB, 一定是以需求为导向，最终数据存储方案必然是各种权衡的综合性设计

参考资料

• NoSQL 还是 SQL ？这一篇讲清楚

JavaWeb 之 Jsp 指南

简介

什么是 Java Server Pages

JSP全称Java Server Pages，是一种动态网页开发技术。

它使用 JSP 标签在 HTML 网页中插入 Java 代码。标签通常以 <% 开头以 %> 结束。

JSP 是一种 Java servlet，主要用于实现 Java web 应用程序的用户界面部分。网页开发者们通过结合 HTML 代码、XHTML 代码、XML 元素以及嵌入 JSP 操作和命令来编写 JSP。

JSP 通过网页表单获取用户输入数据、访问数据库及其他数据源，然后动态地创建网页。

JSP 标签有多种功能，比如访问数据库、记录用户选择信息、访问 JavaBeans 组件等，还可以在不同的网页中传递控制信息和共享信息。

为什么使用 JSP

JSP 也是一种 Servlet，因此 JSP 能够完成 Servlet 能完成的任何工作。

JSP 程序与 CGI 程序有着相似的功能，但和 CGI 程序相比，JSP 程序有如下优势：

• 性能更加优越，因为 JSP 可以直接在 HTML 网页中动态嵌入元素而不需要单独引用 CGI 文件。
• 服务器调用的是已经编译好的 JSP 文件，而不像 CGI/Perl 那样必须先载入解释器和目标脚本。
• JSP 基于 Java Servlets API，因此，JSP 拥有各种强大的企业级 Java API，包括 JDBC，JNDI，EJB，JAXP 等等。
• JSP 页面可以与处理业务逻辑的 servlets 一起使用，这种模式被 Java servlet 模板引擎所支持。

最后，JSP 是 Java EE 不可或缺的一部分，是一个完整的企业级应用平台。这意味着 JSP 可以用最简单的方式来实现最复杂的应用。

JSP 的优势

以下列出了使用 JSP 带来的其他好处：

• 与 ASP 相比：JSP 有两大优势。首先，动态部分用 Java 编写，而不是 VB 或其他 MS 专用语言，所以更加强大与易用。第二点就是 JSP 易于移植到非 MS 平台上。
• 与纯 Servlets 相比：JSP 可以很方便的编写或者修改 HTML 网页而不用去面对大量的 println 语句。
• 与 SSI 相比：SSI 无法使用表单数据、无法进行数据库链接。
• 与 JavaScript 相比：虽然 JavaScript 可以在客户端动态生成 HTML，但是很难与服务器交互，因此不能提供复杂的服务，比如访问数据库和图像处理等等。
• 与静态 HTML 相比：静态 HTML 不包含动态信息。

JSP 工作原理

JSP 是一种 Servlet，但工作方式和 Servlet 有所差别。

Servlet 是先将源代码编译为 class 文件后部署到服务器下的，先编译后部署。

Jsp 是先将源代码部署到服务器再编译，先部署后编译。

Jsp 会在客户端第一次请求 Jsp 文件时被编译为 HttpJspPage 类（Servlet 的一个子类）。该类会被服务器临时存放在服务器工作目录里。所以，第一次请求 Jsp 后，访问速度会变快就是这个道理。

JSP 工作流程

网络服务器需要一个 JSP 引擎，也就是一个容器来处理 JSP 页面。容器负责截获对 JSP 页面的请求。本教程使用内嵌 JSP 容器的 Apache 来支持 JSP 开发。

JSP 容器与 Web 服务器协同合作，为 JSP 的正常运行提供必要的运行环境和其他服务，并且能够正确识别专属于 JSP 网页的特殊元素。

下图显示了 JSP 容器和 JSP 文件在 Web 应用中所处的位置。

工作步骤

以下步骤表明了 Web 服务器是如何使用 JSP 来创建网页的：

• 就像其他普通的网页一样，您的浏览器发送一个 HTTP 请求给服务器。
• Web 服务器识别出这是一个对 JSP 网页的请求，并且将该请求传递给 JSP 引擎。通过使用 URL 或者.jsp 文件来完成。
• JSP 引擎从磁盘中载入 JSP 文件，然后将它们转化为 servlet。这种转化只是简单地将所有模板文本改用 println()语句，并且将所有的 JSP 元素转化成 Java 代码。
• JSP 引擎将 servlet 编译成可执行类，并且将原始请求传递给 servlet 引擎。
• Web 服务器的某组件将会调用 servlet 引擎，然后载入并执行 servlet 类。在执行过程中，servlet 产生 HTML 格式的输出并将其内嵌于 HTTP response 中上交给 Web 服务器。
• Web 服务器以静态 HTML 网页的形式将 HTTP response 返回到您的浏览器中。
• 最终，Web 浏览器处理 HTTP response 中动态产生的 HTML 网页，就好像在处理静态网页一样。

以上提及到的步骤可以用下图来表示：

一般情况下，JSP 引擎会检查 JSP 文件对应的 servlet 是否已经存在，并且检查 JSP 文件的修改日期是否早于 servlet。如果 JSP 文件的修改日期早于对应的 servlet，那么容器就可以确定 JSP 文件没有被修改过并且 servlet 有效。这使得整个流程与其他脚本语言（比如 PHP）相比要高效快捷一些。

JSP 生命周期

理解 JSP 底层功能的关键就是去理解它们所遵守的生命周期。

JSP 生命周期就是从创建到销毁的整个过程，类似于 servlet 生命周期，区别在于 JSP 生命周期还包括将 JSP 文件编译成 servlet。

以下是 JSP 生命周期中所走过的几个阶段：

• 编译阶段：servlet 容器编译 servlet 源文件，生成 servlet 类
• 初始化阶段：加载与 JSP 对应的 servlet 类，创建其实例，并调用它的初始化方法
• 执行阶段：调用与 JSP 对应的 servlet 实例的服务方法
• 销毁阶段：调用与 JSP 对应的 servlet 实例的销毁方法，然后销毁 servlet 实例

很明显，JSP 生命周期的四个主要阶段和 servlet 生命周期非常相似，下面给出图示：

JSP 编译

当浏览器请求 JSP 页面时，JSP 引擎会首先去检查是否需要编译这个文件。如果这个文件没有被编译过，或者在上次编译后被更改过，则编译这个 JSP 文件。

编译的过程包括三个步骤：

• 解析 JSP 文件。
• 将 JSP 文件转为 servlet。
• 编译 servlet。

JSP 初始化

容器载入 JSP 文件后，它会在为请求提供任何服务前调用 jspInit()方法。如果您需要执行自定义的 JSP 初始化任务，复写 jspInit()方法就行了，就像下面这样：

1
2
3

public void jspInit(){
  // 初始化代码
}

一般来讲程序只初始化一次，servlet 也是如此。通常情况下您可以在 jspInit()方法中初始化数据库连接、打开文件和创建查询表。

JSP 执行

这一阶段描述了 JSP 生命周期中一切与请求相关的交互行为，直到被销毁。

当 JSP 网页完成初始化后，JSP 引擎将会调用 _jspService() 方法。

_jspService() 方法需要一个 HttpServletRequest 对象和一个 HttpServletResponse 对象作为它的参数，就像下面这样：

1
2
3
4

void _jspService(HttpServletRequest request,
                 HttpServletResponse response) {
   // 服务端处理代码
}

_jspService() 方法在每个 request 中被调用一次并且负责产生与之相对应的 response，并且它还负责产生所有 7 个 HTTP 方法的回应，比如 GET、POST、DELETE 等等。

JSP 清理

JSP 生命周期的销毁阶段描述了当一个 JSP 网页从容器中被移除时所发生的一切。

jspDestroy()方法在 JSP 中等价于 servlet 中的销毁方法。当您需要执行任何清理工作时复写 jspDestroy()方法，比如释放数据库连接或者关闭文件夹等等。

jspDestroy()方法的格式如下：

1
2
3

public void jspDestroy() {
   // 清理代码
}

语法

脚本

脚本程序可以包含任意量的 Java 语句、变量、方法或表达式，只要它们在脚本语言中是有效的。

脚本程序的语法格式：

1

<% 代码片段 %>

或者，您也可以编写与其等价的 XML 语句，就像下面这样：

1
2
3

<jsp:scriptlet>
  代码片段
</jsp:scriptlet>

任何文本、HTML 标签、JSP 元素必须写在脚本程序的外面。

下面给出一个示例，同时也是本教程的第一个 JSP 示例：

1
2
3
4
5
6
7
8
9

<html>
  <head>
    <title>Hello World</title>
  </head>
  <body>
    Hello World!<br />
    <% out.println("Your IP address is " + request.getRemoteAddr()); %>
  </body>
</html>

注意：请确保 Apache Tomcat 已经安装在 C:\apache-tomcat-7.0.2 目录下并且运行环境已经正确设置。

将以上代码保存在 hello.jsp 中，然后将它放置在 C:\apache-tomcat-7.0.2\webapps\ROOT 目录下，打开浏览器并在地址栏中输入 http://localhost:8080/hello.jsp 。运行后得到以下结果：

中文编码问题

如果我们要在页面正常显示中文，我们需要在 JSP 文件头部添加以下代码：<>

1
2

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>

接下来我们将以上程序修改为：

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

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>菜鸟教程(runoob.com)</title>
  </head>
  <body>
    Hello World!<br />
    <% out.println("你的 IP 地址 " + request.getRemoteAddr()); %>
  </body>
</html>

这样中文就可以正常显示了。

JSP 声明

一个声明语句可以声明一个或多个变量、方法，供后面的 Java 代码使用。在 JSP 文件中，您必须先声明这些变量和方法然后才能使用它们。

JSP 声明的语法格式：

1

<%! declaration; [ declaration; ]+ ... %>

或者，您也可以编写与其等价的 XML 语句，就像下面这样：

1
2
3

<jsp:declaration>
  代码片段
</jsp:declaration>

程序示例：

1

<%! int i = 0; %> <%! int a, b, c; %> <%! Circle a = new Circle(2.0); %>

JSP 表达式

一个 JSP 表达式中包含的脚本语言表达式，先被转化成 String，然后插入到表达式出现的地方。

由于表达式的值会被转化成 String，所以您可以在一个文本行中使用表达式而不用去管它是否是 HTML 标签。

表达式元素中可以包含任何符合 Java 语言规范的表达式，但是不能使用分号来结束表达式。

JSP 表达式的语法格式：

1

<%= 表达式 %>

同样，您也可以编写与之等价的 XML 语句：

1
2
3

<jsp:expression>
  表达式
</jsp:expression>

程序示例：

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

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>菜鸟教程(runoob.com)</title>
  </head>
  <body>
    <p>
      今天的日期是: <%= (new java.util.Date()).toLocaleString()%>
    </p>
  </body>
</html>

运行后得到以下结果：

1

今天的日期是: 2016-6-25 13:40:07

JSP 注释

JSP 注释主要有两个作用：为代码作注释以及将某段代码注释掉。

JSP 注释的语法格式：

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

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>JSP注释示例</title>
  </head>
  <body>
    <%-- 该部分注释在网页中不会被显示--%>
    <p>
      今天的日期是: <%= (new java.util.Date()).toLocaleString()%>
    </p>
  </body>
</html>

运行后得到以下结果：

1

今天的日期是: 2016-6-25 13:41:26

不同情况下使用注释的语法规则：

控制语句

JSP 提供对 Java 语言的全面支持。您可以在 JSP 程序中使用 Java API 甚至建立 Java 代码块，包括判断语句和循环语句等等。

if…else 语句

If…else块，请看下面这个例子：

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

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%> <%! int day = 1; %>
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>02.JSP语法 - if...else示例</title>
  </head>
  <body>
    <h3>IF...ELSE 实例</h3>
    <% if (day == 1 | day == 7) { %>
    <p>今天是周末</p>
    <% } else { %>
    <p>今天不是周末</p>
    <% } %>
  </body>
</html>

运行后得到以下结果：

1
2

IF...ELSE 实例
今天不是周末

switch…case 语句

现在来看看 switch…case 块，与 if…else 块有很大的不同，它使用 out.println()，并且整个都装在脚本程序的标签中，就像下面这样：

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

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%> <%! int day = 3; %>
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>02.JSP语法 - switch...case示例</title>
  </head>
  <body>
    <h3>Sswitch...case示例</h3>
    <% switch(day) { case 0: out.println("星期天"); break; case 1:
    out.println("星期一"); break; case 2: out.println("星期二"); break; case 3:
    out.println("星期三"); break; case 4: out.println("星期四"); break; case 5:
    out.println("星期五"); break; default: out.println("星期六"); } %>
  </body>
</html>

浏览器访问，运行后得出以下结果：

1
2
3

SWITCH...CASE 实例

星期三

循环语句

在 JSP 程序中可以使用 Java 的三个基本循环类型：for，while，和 do…while。

让我们来看看 for 循环的例子，以下输出的不同字体大小的”菜鸟教程”：

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

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%> <%! int fontSize; %>
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>菜鸟教程(runoob.com)</title>
  </head>
  <body>
    <h3>For 循环实例</h3>
    <%for ( fontSize = 1; fontSize <= 3; fontSize++){ %>
    <font color="green" size="<%= fontSize %>">
      菜鸟教程 </font
    ><br />
    <%}%>
  </body>
</html>

运行后得到以下结果：

将上例改用 while 循环来写：

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

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%> <%! int fontSize; %>
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>菜鸟教程(runoob.com)</title>
  </head>
  <body>
    <h3>While 循环实例</h3>
    <%while ( fontSize <= 3){ %>
    <font color="green" size="<%= fontSize %>">
      菜鸟教程 </font
    ><br />
    <%fontSize++;%> <%}%>
  </body>
</html>

浏览器访问，输出结果为（fontSize 初始化为 0，所以多输出了一行）：

JSP 运算符

JSP 支持所有 Java 逻辑和算术运算符。

下表罗列出了 JSP 常见运算符，优先级从高到底：

JSP 字面量

JSP 语言定义了以下几个字面量：

• 布尔值(boolean)：true 和 false;
• 整型(int)：与 Java 中的一样;
• 浮点型(float)：与 Java 中的一样;
• 字符串(string)：以单引号或双引号开始和结束;
• Null：null。

指令

JSP 指令用来设置整个 JSP 页面相关的属性，如网页的编码方式和脚本语言。

JSP 指令以开<%@开始，以%>结束。

JSP 指令语法格式如下：

1

<%@ directive attribute="value" %>

指令可以有很多个属性，它们以键值对的形式存在，并用逗号隔开。

JSP 中的三种指令标签：

Page 指令

Page 指令为容器提供当前页面的使用说明。一个 JSP 页面可以包含多个page指令。

Page 指令的语法格式：

1

<%@ page attribute="value" %>

等价的 XML 格式：

1

<jsp:directive.page attribute="value" />

例：

1
2

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" %>

属性

下表列出与 Page 指令相关的属性：

Include 指令

JSP 可以通过include指令来包含其他文件。

被包含的文件可以是 JSP 文件、HTML 文件或文本文件。包含的文件就好像是该 JSP 文件的一部分，会被同时编译执行。

Include 指令的语法格式如下：

1

<%@ include file="文件相对 url 地址" %>

include 指令中的文件名实际上是一个相对的 URL 地址。

如果您没有给文件关联一个路径，JSP 编译器默认在当前路径下寻找。

等价的 XML 语法：

1

<jsp:directive.include file="文件相对 url 地址" />

Taglib 指令

JSP 允许用户自定义标签，一个自定义标签库就是自定义标签的集合。

taglib指令引入一个自定义标签集合的定义，包括库路径、自定义标签。

taglib指令的语法：

1

<%@ taglib uri="uri" prefix="prefixOfTag" %>

uri 属性确定标签库的位置，prefix 属性指定标签库的前缀。

等价的 XML 语法：

1

<jsp:directive.taglib uri="uri" prefix="prefixOfTag" />

JSP 动作元素

JSP 动作元素是一组 JSP 内置的标签，只需要书写很少的标记代码就能使用 JSP 提供的丰富功能。JSP 动作元素是对常用的 JSP 功能的抽象与封装，包括两种，自定义 JSP 动作元素与标准 JSP 动作元素。

与 JSP 指令元素不同的是，JSP 动作元素在请求处理阶段起作用。JSP 动作元素是用 XML 语法写成的。

利用 JSP 动作可以动态地插入文件、重用 JavaBean 组件、把用户重定向到另外的页面、为 Java 插件生成 HTML 代码。

动作元素只有一种语法，它符合 XML 标准：

1

<jsp:action_name attribute="value" />

动作元素基本上都是预定义的函数，JSP 规范定义了一系列的标准动作，它用 JSP 作为前缀，可用的标准动作元素如下：

常见的属性

所有的动作要素都有两个属性：id 属性和 scope 属性。

• id 属性：id 属性是动作元素的唯一标识，可以在 JSP 页面中引用。动作元素创建的 id 值可以通过 PageContext 来调用。
• scope 属性：该属性用于识别动作元素的生命周期。 id 属性和 scope 属性有直接关系，scope 属性定义了相关联 id 对象的寿命。 scope 属性有四个可能的值： (a) page, (b)request, (c)session, 和 (d) application。

<jsp:include>

<jsp:include> 用来包含静态和动态的文件。该动作把指定文件插入正在生成的页面。

如果被包含的文件为 JSP 程序，则会先执行 JSP 程序，再将执行结果包含进来。

语法格式如下：

1

<jsp:include page="相对 URL 地址" flush="true" />

前面已经介绍过 include 指令，它是在 JSP 文件被转换成 Servlet 的时候引入文件，而这里的 jsp:include 动作不同，插入文件的时间是在页面被请求的时候。

以下是 include 动作相关的属性列表。

示例：

以下我们定义了两个文件 date.jsp 和 main.jsp，代码如下所示：

date.jsp 文件代码：

1
2
3
4
5

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<p>
  今天的日期是: <%= (new java.util.Date())%>
</p>

main.jsp 文件代码：

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

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>菜鸟教程(runoob.com)</title>
  </head>
  <body>
    <h2>include 动作实例</h2>
    <jsp:include page="date.jsp" flush="true" />
  </body>
</html>

现在将以上两个文件放在服务器的根目录下，访问 main.jsp 文件。显示结果如下：

1
2
3

include 动作实例

今天的日期是: 2016-6-25 14:08:17

<jsp:useBean>

jsp:useBean 动作用来加载一个将在 JSP 页面中使用的 JavaBean。

这个功能非常有用，因为它使得我们可以发挥 Java 组件复用的优势。

jsp:useBean 动作最简单的语法为：

1

<jsp:useBean id="name" class="package.class" />

在类载入后，我们既可以通过 jsp:setProperty 和 jsp:getProperty 动作来修改和检索 bean 的属性。

以下是 useBean 动作相关的属性列表。

在给出具体实例前，让我们先来看下 jsp:setProperty 和 jsp:getProperty 动作元素：

<jsp:setProperty>

jsp:setProperty 用来设置已经实例化的 Bean 对象的属性，有两种用法。首先，你可以在 jsp:useBean 元素的外面（后面）使用 jsp:setProperty，如下所示：

1
2
3

<jsp:useBean id="myName" ... />
...
<jsp:setProperty name="myName" property="someProperty" .../>

此时，不管 jsp:useBean 是找到了一个现有的 Bean，还是新创建了一个 Bean 实例，jsp:setProperty 都会执行。第二种用法是把 jsp:setProperty 放入 jsp:useBean 元素的内部，如下所示：

1
2
3
4

<jsp:useBean id="myName" ... >
...
   <jsp:setProperty name="myName" property="someProperty" .../>
</jsp:useBean>

此时，jsp:setProperty 只有在新建 Bean 实例时才会执行，如果是使用现有实例则不执行 jsp:setProperty。

jsp:setProperty 动作有下面四个属性,如下表：

<jsp:getProperty>

jsp:getProperty 动作提取指定 Bean 属性的值，转换成字符串，然后输出。语法格式如下：

1
2
3

<jsp:useBean id="myName" ... />
...
<jsp:getProperty name="myName" property="someProperty" .../>

下表是与 getProperty 相关联的属性：

实例

以下实例我们使用了 Bean:

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

package com.runoob.main;

public class TestBean {
   private String message = "菜鸟教程";

   public String getMessage() {
      return(message);
   }
   public void setMessage(String message) {
      this.message = message;
   }
}

编译以上实例文件 TestBean.java ：

1

$ javac TestBean.java

编译完成后会在当前目录下生成一个 TestBean.class 文件， 将该文件拷贝至当前 JSP 项目的 WebContent/WEB-INF/classes/com/runoob/main 下( com/runoob/main 包路径，没有需要手动创建)。

下面是一个 Eclipse 中目录结构图：

下面是一个很简单的例子，它的功能是装载一个 Bean，然后设置/读取它的 message 属性。

现在让我们在 main.jsp 文件中调用该 Bean:

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

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>菜鸟教程(runoob.com)</title>
  </head>
  <body>
    <h2>Jsp 使用 JavaBean 实例</h2>
    <jsp:useBean id="test" class="com.runoob.main.TestBean" />

    <jsp:setProperty name="test" property="message" value="菜鸟教程..." />

    <p>输出信息....</p>

    <jsp:getProperty name="test" property="message" />
  </body>
</html>

浏览器访问，执行以上文件，输出如下所示：

<jsp:forward>

jsp:forward 动作把请求转到另外的页面。jsp:forward 标记只有一个属性 page。语法格式如下所示：

1

<jsp:forward page="相对 URL 地址" />

以下是 forward 相关联的属性：

实例

以下实例我们使用了两个文件，分别是： date.jsp 和 main.jsp。

date.jsp 文件代码如下：

1
2
3
4
5

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<p>
  今天的日期是: <%= (new java.util.Date()).toLocaleString()%>
</p>

main.jsp 文件代码：

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

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>菜鸟教程(runoob.com)</title>
  </head>
  <body>
    <h2>forward 动作实例</h2>
    <jsp:forward page="date.jsp" />
  </body>
</html>

现在将以上两个文件放在服务器的根目录下，访问 main.jsp 文件。显示结果如下：

1

今天的日期是: 2016-6-25 14:37:25

<jsp:plugin>

jsp:plugin 动作用来根据浏览器的类型，插入通过 Java 插件 运行 Java Applet 所必需的 OBJECT 或 EMBED 元素。

如果需要的插件不存在，它会下载插件，然后执行 Java 组件。 Java 组件可以是一个 applet 或一个 JavaBean。

plugin 动作有多个对应 HTML 元素的属性用于格式化 Java 组件。param 元素可用于向 Applet 或 Bean 传递参数。

以下是使用 plugin 动作元素的典型实例:

1
2
3
4
5
6
7
8
9
10

<jsp:plugin type="applet" codebase="dirname" code="MyApplet.class"
                           width="60" height="80">
   <jsp:param name="fontcolor" value="red" />
   <jsp:param name="background" value="black" />

   <jsp:fallback>
      Unable to initialize Java Plugin
   </jsp:fallback>

</jsp:plugin>

如果你有兴趣可以尝试使用 applet 来测试 jsp:plugin 动作元素，<fallback> 元素是一个新元素，在组件出现故障的错误是发送给用户错误信息。

<jsp:element> 、 <jsp:attribute>、<jsp:body>

<jsp:element> 、 <jsp:attribute>、<jsp:body> 动作元素动态定义 XML 元素。动态是非常重要的，这就意味着 XML 元素在编译时是动态生成的而非静态。

以下实例动态定义了 XML 元素：

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

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>菜鸟教程(runoob.com)</title>
  </head>
  <body>
    <jsp:element name="xmlElement">
      <jsp:attribute name="xmlElementAttr">
        属性值
      </jsp:attribute>
      <jsp:body>
        XML 元素的主体
      </jsp:body>
    </jsp:element>
  </body>
</html>

浏览器访问以下页面，输出结果如下所示：

<jsp:text>

jsp:text动作元素允许在 JSP 页面和文档中使用写入文本的模板，语法格式如下：

1

<jsp:text>模板数据</jsp:text>

以上文本模板不能包含其他元素，只能只能包含文本和 EL 表达式（注：EL 表达式将在后续章节中介绍）。请注意，在 XML 文件中，您不能使用表达式如 ${whatever > 0}，因为>符号是非法的。 你可以使用 ${whatever gt 0}表达式或者嵌入在一个 CDATA 部分的值。

1

<jsp:text><![CDATA[<br>]]></jsp:text>

如果你需要在 XHTML 中声明 DOCTYPE,必须使用到 <jsp:text> 动作元素，实例如下：

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

<jsp:text><![CDATA[<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"DTD/xhtml1-strict.dtd">]]>
</jsp:text>
<head><title>jsp:text action</title></head>
<body>

<books><book><jsp:text>
    Welcome to JSP Programming
</jsp:text></book></books>

</body>
</html>

你可以对以上实例尝试使用jsp:text及不使用该动作元素执行结果的区别。

JSP 隐式对象

JSP 隐式对象是 JSP 容器为每个页面提供的 Java 对象，开发者可以直接使用它们而不用显式声明。JSP 隐式对象也被称为预定义变量。

JSP 所支持的九大隐式对象：

request 对象

request对象是javax.servlet.http.HttpServletRequest 类的实例。

每当客户端请求一个 JSP 页面时，JSP 引擎就会制造一个新的request对象来代表这个请求。

request对象提供了一系列方法来获取 HTTP 头信息，cookies，HTTP 方法等等。

response 对象

response对象是javax.servlet.http.HttpServletResponse类的实例。

当服务器创建request对象时会同时创建用于响应这个客户端的response对象。

response对象也定义了处理 HTTP 头模块的接口。通过这个对象，开发者们可以添加新的 cookies，时间戳，HTTP 状态码等等。

out 对象

out对象是javax.servlet.jsp.JspWriter类的实例，用来在response对象中写入内容。

最初的JspWriter类对象根据页面是否有缓存来进行不同的实例化操作。可以在page指令中使用buffered='false'属性来轻松关闭缓存。

JspWriter类包含了大部分java.io.PrintWriter类中的方法。不过，JspWriter新增了一些专为处理缓存而设计的方法。还有就是，JspWriter类会抛出IOExceptions异常，而PrintWriter不会。

下表列出了我们将会用来输出boolean，char，int，double，String，object等类型数据的重要方法：

session 对象

session对象是javax.servlet.http.HttpSession类的实例。和 Java Servlets 中的session对象有一样的行为。

session对象用来跟踪在各个客户端请求间的会话。

application 对象

application对象直接包装了 servlet 的ServletContext类的对象，是javax.servlet.ServletContext类的实例。

这个对象在 JSP 页面的整个生命周期中都代表着这个 JSP 页面。这个对象在 JSP 页面初始化时被创建，随着jspDestroy()方法的调用而被移除。

通过向application中添加属性，则所有组成您 web 应用的 JSP 文件都能访问到这些属性。

config 对象

config对象是javax.servlet.ServletConfig类的实例，直接包装了 servlet 的ServletConfig类的对象。

这个对象允许开发者访问 Servlet 或者 JSP 引擎的初始化参数，比如文件路径等。

以下是 config 对象的使用方法，不是很重要，所以不常用：

1

config.getServletName();

它返回包含在<servlet-name>元素中的 servlet 名字，注意，<servlet-name>元素在WEB-INF\web.xml文件中定义。

pageContext 对象

pageContext对象是javax.servlet.jsp.PageContext类的实例，用来代表整个 JSP 页面。

这个对象主要用来访问页面信息，同时过滤掉大部分实现细节。

这个对象存储了request对象和response对象的引用。application对象，config对象，session对象，out对象可以通过访问这个对象的属性来导出。

pageContext对象也包含了传给 JSP 页面的指令信息，包括缓存信息，ErrorPage URL,页面 scope 等。

PageContext类定义了一些字段，包括 PAGE_SCOPE，REQUEST_SCOPE，SESSION_SCOPE， APPLICATION_SCOPE。它也提供了 40 余种方法，有一半继承自javax.servlet.jsp.JspContext 类。

其中一个重要的方法就是removeArribute()，它可接受一个或两个参数。比如，pageContext.removeArribute(“attrName”)移除四个 scope 中相关属性，但是下面这种方法只移除特定 scope 中的相关属性：

1

pageContext.removeAttribute("attrName", PAGE_SCOPE);

page 对象

这个对象就是页面实例的引用。它可以被看做是整个 JSP 页面的代表。

page对象就是this对象的同义词。

exception 对象

exception对象包装了从先前页面中抛出的异常信息。它通常被用来产生对出错条件的适当响应。

EL 表达式

EL 表达式是用${}括起来的脚本，用来更方便地读取对象。EL 表达式写在 JSP 的 HTML 代码中，而不能写在<%与%>引起的 JSP 脚本中。

JSP 表达式语言（EL）使得访问存储在 JavaBean 中的数据变得非常简单。JSP EL 既可以用来创建算术表达式也可以用来创建逻辑表达式。在 JSP EL 表达式内可以使用整型数，浮点数，字符串，常量 true、false，还有 null。

一个简单的语法

典型的，当您需要在 JSP 标签中指定一个属性值时，只需要简单地使用字符串即可：

1

<jsp:setProperty name="box" property="perimeter" value="100" />

JSP EL 允许您指定一个表达式来表示属性值。一个简单的表达式语法如下：

1

${expr}

其中，expr 指的是表达式。在 JSP EL 中通用的操作符是”.”和”[]”。这两个操作符允许您通过内嵌的 JSP 对象访问各种各样的 JavaBean 属性。

举例来说，上面的 <jsp:setProperty> 标签可以使用表达式语言改写成如下形式：

1
2
3
4
5

<jsp:setProperty
  name="box"
  property="perimeter"
  value="${2*box.width+2*box.height}"
/>

当 JSP 编译器在属性中见到”${}”格式后，它会产生代码来计算这个表达式，并且产生一个替代品来代替表达式的值。

您也可以在标签的模板文本中使用表达式语言。比如 <jsp:text> 标签简单地将其主体中的文本插入到 JSP 输出中：

1
2
3

<jsp:text>
  <h1>Hello JSP!</h1>
</jsp:text>

现在，在jsp:text标签主体中使用表达式，就像这样：

1
2
3

<jsp:text>
  Box Perimeter is: ${2*box.width + 2*box.height}
</jsp:text>

在 EL 表达式中可以使用圆括号来组织子表达式。比如 ${(1 + 2) _ 3} 等于 9，但是 ${1 + (2 _ 3)} 等于 7。

想要停用对 EL 表达式的评估的话，需要使用 page 指令将 isELIgnored 属性值设为 true：

1

<%@ page isELIgnored ="true|false" %>

这样，EL 表达式就会被忽略。若设为 false，则容器将会计算 EL 表达式。

EL 中的基础操作符

EL 表达式支持大部分 Java 所提供的算术和逻辑操作符：

JSP EL 中的函数

JSP EL 允许您在表达式中使用函数。这些函数必须被定义在自定义标签库中。函数的使用语法如下：

1

${ns:func(param1, param2, ...)}

ns 指的是命名空间（namespace），func 指的是函数的名称，param1 指的是第一个参数，param2 指的是第二个参数，以此类推。比如，有函数 fn:length，在 JSTL 库中定义，可以像下面这样来获取一个字符串的长度：

1

${fn:length("Get my length")}

要使用任何标签库中的函数，您需要将这些库安装在服务器中，然后使用 <taglib> 标签在 JSP 文件中包含这些库。

JSP EL 隐含对象

JSP EL 支持下表列出的隐含对象：

您可以在表达式中使用这些对象，就像使用变量一样。接下来会给出几个例子来更好的理解这个概念。

pageContext 对象

pageContext 对象是 JSP 中 pageContext 对象的引用。通过 pageContext 对象，您可以访问 request 对象。比如，访问 request 对象传入的查询字符串，就像这样：

1

${pageContext.request.queryString}

Scope 对象

pageScope，requestScope，sessionScope，applicationScope 变量用来访问存储在各个作用域层次的变量。

举例来说，如果您需要显式访问在 applicationScope 层的 box 变量，可以这样来访问：applicationScope.box。

param 和 paramValues 对象

param 和 paramValues 对象用来访问参数值，通过使用 request.getParameter 方法和 request.getParameterValues 方法。

举例来说，访问一个名为 order 的参数，可以这样使用表达式：${param.order}，或者${param["order"]}。

接下来的例子表明了如何访问 request 中的 username 参数：

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

<%@ page import="java.io.*,java.util.*" %> <% String title = "Accessing Request
Param"; %>
<html>
  <head>
    <title><% out.print(title); %></title>
  </head>
  <body>
    <center>
      <h1><% out.print(title); %></h1>
    </center>
    <div align="center">
      <p>${param["username"]}</p>
    </div>
  </body>
</html>

param 对象返回单一的字符串，而 paramValues 对象则返回一个字符串数组。

header 和 headerValues 对象

header 和 headerValues 对象用来访问信息头，通过使用 request.getHeader 方法和 request.getHeaders 方法。

举例来说，要访问一个名为 user-agent 的信息头，可以这样使用表达式：${header.user-agent}，或者 ${header["user-agent"]}。

接下来的例子表明了如何访问 user-agent 信息头：

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

<%@ page import="java.io.*,java.util.*" %> <% String title = "User Agent
Example"; %>
<html>
  <head>
    <title><% out.print(title); %></title>
  </head>
  <body>
    <center>
      <h1><% out.print(title); %></h1>
    </center>
    <div align="center">
      <p>${header["user-agent"]}</p>
    </div>
  </body>
</html>

运行结果如下：

header 对象返回单一值，而 headerValues 则返回一个字符串数组。

JSTL

JSP 标准标签库（JSTL）是一个 JSP 标签集合，它封装了 JSP 应用的通用核心功能。

JSTL 支持通用的、结构化的任务，比如迭代，条件判断，XML 文档操作，国际化标签，SQL 标签。 除了这些，它还提供了一个框架来使用集成 JSTL 的自定义标签。

根据 JSTL 标签所提供的功能，可以将其分为 5 个类别。

• 核心标签
• 格式化标签
• SQL 标签
• XML 标签
• JSTL 函数

JSTL 库安装

Apache Tomcat 安装 JSTL 库步骤如下：

从 Apache 的标准标签库中下载的二进包(jakarta-taglibs-standard-current.zip)。

• 官方下载地址：http://archive.apache.org/dist/jakarta/taglibs/standard/binaries/
• 本站下载地址：jakarta-taglibs-standard-1.1.2.zip

下载 jakarta-taglibs-standard-1.1.2.zip 包并解压，将 jakarta-taglibs-standard-1.1.2/lib/ 下的两个 jar 文件：standard.jar 和 jstl.jar 文件拷贝到 /WEB-INF/lib/ 下。

将 tld 下的需要引入的 tld 文件复制到 WEB-INF 目录下。

接下来我们在 web.xml 文件中添加以下配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

<?xml version="1.0" encoding="UTF-8"?>
<web-app
  version="2.4"
  xmlns="http://java.sun.com/xml/ns/j2ee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
        http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
>
  <jsp-config>
    <taglib>
      <taglib-uri>http://java.sun.com/jsp/jstl/fmt</taglib-uri>
      <taglib-location>/WEB-INF/fmt.tld</taglib-location>
    </taglib>
    <taglib>
      <taglib-uri>http://java.sun.com/jsp/jstl/fmt-rt</taglib-uri>
      <taglib-location>/WEB-INF/fmt-rt.tld</taglib-location>
    </taglib>
    <taglib>
      <taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>
      <taglib-location>/WEB-INF/c.tld</taglib-location>
    </taglib>
    <taglib>
      <taglib-uri>http://java.sun.com/jsp/jstl/core-rt</taglib-uri>
      <taglib-location>/WEB-INF/c-rt.tld</taglib-location>
    </taglib>
    <taglib>
      <taglib-uri>http://java.sun.com/jsp/jstl/sql</taglib-uri>
      <taglib-location>/WEB-INF/sql.tld</taglib-location>
    </taglib>
    <taglib>
      <taglib-uri>http://java.sun.com/jsp/jstl/sql-rt</taglib-uri>
      <taglib-location>/WEB-INF/sql-rt.tld</taglib-location>
    </taglib>
    <taglib>
      <taglib-uri>http://java.sun.com/jsp/jstl/x</taglib-uri>
      <taglib-location>/WEB-INF/x.tld</taglib-location>
    </taglib>
    <taglib>
      <taglib-uri>http://java.sun.com/jsp/jstl/x-rt</taglib-uri>
      <taglib-location>/WEB-INF/x-rt.tld</taglib-location>
    </taglib>
  </jsp-config>
</web-app>

使用任何库，你必须在每个 JSP 文件中的头部包含 <taglib> 标签。

核心标签

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

1

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

格式化标签

JSTL 格式化标签用来格式化并输出文本、日期、时间、数字。引用格式化标签库的语法如下：

1

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

SQL 标签

JSTL SQL 标签库提供了与关系型数据库（Oracle，MySQL，SQL Server 等等）进行交互的标签。引用 SQL 标签库的语法如下：

1

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

XML 标签

JSTL XML 标签库提供了创建和操作 XML 文档的标签。引用 XML 标签库的语法如下：

1

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

在使用 xml 标签前，你必须将 XML 和 XPath 的相关包拷贝至你的 <Tomcat 安装目录>\lib 下:

• XercesImpl.jar

  下载地址： http://www.apache.org/dist/xerces/j/

• xalan.jar

  下载地址： http://xml.apache.org/xalan-j/index.html

JSTL 函数

JSTL 包含一系列标准函数，大部分是通用的字符串处理函数。引用 JSTL 函数库的语法如下：

1

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

Taglib

JSP 自定义标签

自定义标签是用户定义的 JSP 语言元素。当 JSP 页面包含一个自定义标签时将被转化为 servlet，标签转化为对被 称为 tag handler 的对象的操作，即当 servlet 执行时 Web container 调用那些操作。

JSP 标签扩展可以让你创建新的标签并且可以直接插入到一个 JSP 页面。 JSP 2.0 规范中引入 Simple Tag Handlers 来编写这些自定义标记。

你可以继承 SimpleTagSupport 类并重写的 doTag()方法来开发一个最简单的自定义标签。

创建”Hello”标签

接下来，我们想创建一个自定义标签叫作ex:Hello，标签格式为：

1

<ex:Hello />

要创建自定义的 JSP 标签，你首先必须创建处理标签的 Java 类。所以，让我们创建一个 HelloTag 类，如下所示：

1
2
3
4

package com.runoob; import javax.servlet.jsp.tagext.*; import
javax.servlet.jsp.*; import java.io.*; public class HelloTag extends
SimpleTagSupport { public void doTag() throws JspException, IOException {
JspWriter out = getJspContext().getOut(); out.println("Hello Custom Tag!"); } }

以下代码重写了 doTag()方法，方法中使用了 getJspContext()方法来获取当前的 JspContext 对象，并将”Hello Custom Tag!”传递给 JspWriter 对象。

编译以上类，并将其复制到环境变量 CLASSPATH 目录中。最后创建如下标签库：<Tomcat安装目录>webapps\ROOT\WEB-INF\custom.tld。

1
2
3
4
5
6
7
8
9
10

<taglib>
  <tlib-version>1.0</tlib-version>
  <jsp-version>2.0</jsp-version>
  <short-name>Example TLD</short-name>
  <tag>
    <name>Hello</name>
    <tag-class>com.runoob.HelloTag</tag-class>
    <body-content>empty</body-content>
  </tag>
</taglib>

接下来，我们就可以在 JSP 文件中使用 Hello 标签：

1
2
3
4
5
6
7
8
9

<%@ taglib prefix="ex" uri="WEB-INF/custom.tld"%>
<html>
  <head>
    <title>A sample custom tag</title>
  </head>
  <body>
    <ex:Hello />
  </body>
</html>

以上程序输出结果为：

1

Hello Custom Tag!

访问标签体

你可以像标准标签库一样在标签中包含消息内容。如我们要在我们自定义的 Hello 中包含内容，格式如下：

1
2
3

<ex:Hello>
  This is message body
</ex:Hello>

我们可以修改标签处理类文件，代码如下：

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

package com.runoob;

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;

public class HelloTag extends SimpleTagSupport {

   StringWriter sw = new StringWriter();
   public void doTag()
      throws JspException, IOException
    {
       getJspBody().invoke(sw);
       getJspContext().getOut().println(sw.toString());
    }

}

接下来我们需要修改 TLD 文件，如下所示：

1
2
3
4
5
6
7
8
9
10

<taglib>
  <tlib-version>1.0</tlib-version>
  <jsp-version>2.0</jsp-version>
  <short-name>Example TLD with Body</short-name>
  <tag>
    <name>Hello</name>
    <tag-class>com.runoob.HelloTag</tag-class>
    <body-content>scriptless</body-content>
  </tag>
</taglib>

现在我们可以在 JSP 使用修改后的标签，如下所示:

1
2
3
4
5
6
7
8
9
10
11

<%@ taglib prefix="ex" uri="WEB-INF/custom.tld"%>
<html>
  <head>
    <title>A sample custom tag</title>
  </head>
  <body>
    <ex:Hello>
      This is message body
    </ex:Hello>
  </body>
</html>

以上程序输出结果如下所示：

1

This is message body

自定义标签属性

你可以在自定义标准中设置各种属性，要接收属性，值自定义标签类必须实现 setter 方法， JavaBean 中的 setter 方法如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package com.runoob;

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;

public class HelloTag extends SimpleTagSupport {

   private String message;

   public void setMessage(String msg) {
      this.message = msg;
   }

   StringWriter sw = new StringWriter();

   public void doTag()
      throws JspException, IOException
    {
       if (message != null) {
          /* 从属性中使用消息 */
          JspWriter out = getJspContext().getOut();
          out.println( message );
       }
       else {
          /* 从内容体中使用消息 */
          getJspBody().invoke(sw);
          getJspContext().getOut().println(sw.toString());
       }
   }

}

属性的名称是”message”，所以 setter 方法是的 setMessage()。现在让我们在 TLD 文件中使用的 <attribute> 元素添加此属性：

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

<taglib>
  <tlib-version>1.0</tlib-version>
  <jsp-version>2.0</jsp-version>
  <short-name>Example TLD with Body</short-name>
  <tag>
    <name>Hello</name>
    <tag-class>com.runoob.HelloTag</tag-class>
    <body-content>scriptless</body-content>
    <attribute>
      <name>message</name>
    </attribute>
  </tag>
</taglib>

现在我们就可以在 JSP 文件中使用 message 属性了，如下所示：

1
2
3
4
5
6
7
8
9

<%@ taglib prefix="ex" uri="WEB-INF/custom.tld"%>
<html>
  <head>
    <title>A sample custom tag</title>
  </head>
  <body>
    <ex:Hello message="This is custom tag" />
  </body>
</html>

以上实例数据输出结果为：

1

This is custom tag

你还可以包含以下属性：

以下是指定相关的属性实例：

1
2
3
4
5
6
7
8

.....
<attribute>
  <name>attribute_name</name>
  <required>false</required>
  <type>java.util.Date</type>
  <fragment>false</fragment>
</attribute>
.....

如果你使用了两个属性，修改 TLD 文件，如下所示：

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

.....
<attribute>
  <name>attribute_name1</name>
  <required>false</required>
  <type>java.util.Boolean</type>
  <fragment>false</fragment>
</attribute>
<attribute>
  <name>attribute_name2</name>
  <required>true</required>
  <type>java.util.Date</type>
</attribute>
.....

JavaWeb 面经

Servlet

什么是 Servlet

Servlet（Server Applet），即小服务程序或服务连接器。Servlet 是 Java 编写的服务器端程序，具有独立于平台和协议的特性，主要功能在于交互式地浏览和生成数据，生成动态 Web 内容。

• 狭义的 Servlet 是指 Java 实现的一个接口。
• 广义的 Servlet 是指任何实现了这个 Servlet 接口的类。

Servlet 运行于支持 Java 的应用服务器中。从原理上讲，Servlet 可以响应任何类型的请求，但绝大多数情况下 Servlet 只用来扩展基于 HTTP 协议的 Web 服务器。

Servlet 和 CGI 的区别

Servlet 技术出现之前，Web 主要使用 CGI 技术。它们的区别如下：

• Servlet 是基于 Java 编写的，处于服务器进程中，他能够通过多线程方式运行 service() 方法，一个实例可以服务于多个请求，而且一般不会销毁；
• CGI(Common Gateway Interface)，即通用网关接口。它会为每个请求产生新的进程，服务完成后销毁，所以效率上低于 Servlet。

Servlet 版本以及主要特性

Servlet 和 JSP 的区别

1. Servlet 是一个运行在服务器上的 Java 类,依靠服务器支持向浏览器传输数据。
2. JSP 本质上就是 Servlet，每次运行的时候 JSP 都会被编译成 .java 文件，然后再被编译成 .class 文件。
3. 有了 JSP，Servlet 不再负责动态生成页面，转而去负责控制程序逻辑的作用，控制 JSP 与 JavaBean 之间的流转。
4. JSP 侧重于视图,而 Servlet 侧重于控制逻辑,在 MVC 架构模式中,JSP 适合充当视图 View,Servlet 适合充当控制器 Controller。

简述 Servlet 生命周期

Servlet 生命周期如下：

1. 加载 - 第一个到达服务器的 HTTP 请求被委派到 Servlet 容器。容器通过类加载器使用 Servlet 类对应的文件加载 servlet；
2. 初始化 - Servlet 通过调用 init () 方法进行初始化。
3. 服务 - Servlet 调用 service() 方法来处理客户端的请求。
4. 销毁 - Servlet 通过调用 destroy() 方法终止（结束）。
5. 卸载 - Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。

如何现实 servlet 的单线程模式

1

<%@ page isThreadSafe="false" %>

Servlet 中如何获取用户提交的查询参数或者表单数据

• HttpServletRequest 的 getParameter() 方法。
• HttpServletRequest 的 getParameterValues() 方法。
• HttpServletRequest 的 getParameterMap() 方法。

request 的主要方法

• setAttribute(String name,Object)：设置名字为 name 的 request 的参数值
• getAttribute(String name)：返回由 name 指定的属性值
• getAttributeNames()：返回 request 对象所有属性的名字集合，结果是一个枚举的实例
• getCookies()：返回客户端的所有 Cookie 对象，结果是一个 Cookie 数组
• getCharacterEncoding()：返回请求中的字符编码方式
• getContentLength()：返回请求的 Body 的长度
• getHeader(String name)：获得 HTTP 协议定义的文件头信息
• getHeaders(String name)：返回指定名字的 request Header 的所有值，结果是一个枚举的实例
• getHeaderNames()：返回所以 request Header 的名字，结果是一个枚举的实例
• getInputStream()：返回请求的输入流，用于获得请求中的数据 getMethod()：获得客户端向服务器端传送数据的方法
• getParameter(String name)：获得客户端传送给服务器端的有 name 指定的参数值
• getParameterNames()：获得客户端传送给服务器端的所有参数的名字，结果是一个枚举的实例
• getParameterValues(String name)：获得有 name 指定的参数的所有值
• getProtocol()：获取客户端向服务器端传送数据所依据的协议名称
• getQueryString()：获得查询字符串
• getRequestURI()：获取发出请求字符串的客户端地址
• getRemoteAddr()：获取客户端的 IP 地址
• getRemoteHost()：获取客户端的名字
• getSession([Boolean create])：返回和请求相关
• Session getServerName()：获取服务器的名字
• getServletPath()：获取客户端所请求的脚本文件的路径
• getServerPort()：获取服务器的端口号
• removeAttribute(String name)：删除请求中的一个属性

JSP

JSP 的内置对象

1. request：包含客户端请求的信息；
2. response：包含服务器传回客户端的响应信息；
3. session：主要用来区分每个用户信息和会话状态；
4. pageContext：管理页面属性；
5. application：服务器启动时创建，服务器关闭时停止，保存所有应用系统中的共有数据，一个共享的内置对象（即一个容器中的多个用户共享一个 application 对象）；
6. out：向客户端输出数据；
7. config：代码片段配置对象，用于初始化 Servlet 的配置参数；
8. page：指网页本身；
9. exception：处理 JSP 文件执行时发生的错误和异常，只要在错误页面里才能使用。

JSP 的作用域

1. page：一个页面；
2. request：一次请求；
3. session：一次会话；
4. application：服务器从启动到停止。

JSP 中 7 个动作指令和作用

1. jsp:forward - 执行页面转向，把请求转发到下一个页面；
2. jsp:param - 用于传递参数，必须与其他支持参数的标签一起使用；
3. jsp:include - 用于动态引入一个 JSP 页面；
4. jsp:plugin - 用于下载 JavaBean 或 Applet 到客户端执行；
5. jsp:useBean - 寻求或者实例化一个 JavaBean；
6. jsp:setProperty - 设置 JavaBean 的属性值；
7. jsp:getProperty - 获取 JavaBean 的属性值。

JSP 中动态 INCLUDE 和静态 INCLUDE 有什么区别

• 静态 INCLUDE：用 include 伪码实现，不会检查所含文件的变化，适用于包含静态页面<%@ include file=”页面名称.html” %>。先合并再编译。
• 动态 INCLUDE：用 jsp:include 动作实现 <jsp:include page=”页面名称 .jsp” flush=”true”> 它总是会检查文件中的变化，适用于包含动态页面，并且可以带参数。先编译再合并。