Java
- 第四阶段 模块一 JavaWeb核心（上）
-
- 第一章 Servlet核心技术（上）
- 第二章 Servlet核心技术（下）
- 第三章 JSP核心技术
- 第四阶段模块一作业
- 第四阶段 模块二 JavaWeb核心（下）
第四阶段 模块一 JavaWeb核心（上）
第一章 Servlet核心技术（上）
1.1 基本概念（常识）
1.1.1 C/S架构的概念
- C/S架构（Client/Server，客户端/服务器模式），是一种比较早的软件体系结构，也是生活中很常见的结构。这种结构将需要处理的业务合理地分配到客户端和服务器端，客户端通常负责完成与用户的交互任务，服务器通常负责数据的管理。
- C/S架构的主要优点如下：
○ 客户端的界面和功能可以很丰富。
○ 应用服务器的负荷较轻。
○ 响应速度较快。(只有一层客户端和服务端) - C/S架构的主要缺点如下：
○ 适用面窄，用户群固定。
○ 维护和升级的成本高，所有的客户端都需要更新版本。
1.1.2 B/S架构的概念
- B/S架构（Browser/Server，浏览器/服务器模式），是互联网兴起后的软件体系结构，该结构将系统功能实现的主要业务逻辑集中到服务器端，极少数业务逻辑在浏览器实现，浏览器通常负责完成与用户的交互任务，服务器通常负责数据的管理。
- B/S架构的主要优点如下：
○ 无需安装客户端，只要有浏览器即可。
○ 适用面广，用户群不固定。
○ 通过权限控制实现多客户访问的目的，交互性较强。
○ 维护和升级的成本低，无需更新所有客户端版本。 - B/S架构的主要缺点如下：
○ 应用服务器的负荷较重。
○ 浏览器的界面和功能想要达到客户端的丰富程度需要花费大量的成本。
○ 在跨浏览器上不尽如人意，适配比较麻烦。
1.1.3 JavaWeb的概念
- Web本意为网页的含义，这里表示互联网上供外界访问的资源。
- 互联网上供外界访问的资源主要分为以下两种：
○ 静态资源：主要指Web页面中供人们浏览的数据始终是不变。
○ 动态资源：主要指Web页面中供人们浏览的数据由程序产生，不同时间点访问页面看到的内容各不相同。 - JavaWeb主要指使用Java语言进行动态Web资源开发技术的统称，是解决相关Web互联网领域的技术总和。
- 早期的B/S架构
- 后来的B/S架构
1.2 HTTP协议（熟悉）
1.2.1 HTTP协议的概念
- HTTP协议（HyperText Transfer Protocol，超文本传输协议）是由W3C（万维网联盟）组织制定的一种应用层协议，是用来规范浏览器与Web服务器之间如何通讯的数据格式，主要涉及浏览器的发请求格式和服务器的响应格式。
- HTTP协议通常承载于TCP协议之上，而承载于TLS或SSL协议层之上的协议就是常说的HTTPS协议。
- HTTP默认的端口号为80，HTTPS默认的端口号为443。
1.2.2 HTTP请求格式
- 客户端发送一个HTTP请求到服务器的请求消息主要包括：请求行、请求头、空白行和请求体。
请求行用来说明请求类型和要访问的资源以及所使用的HTTP版本，格式如下：
请求类型 请求的路径 协议的版本(1.1)
请求头是紧接着请求行（即第一行）之后的部分，用来说明服务器要使用的附加信息，格式（key:value）如下：
主机 请求长度 请求的浏览器相关信息
空白行就是请求头部的空行，即使后面的请求数据为空则必须有空行。
请求体也叫请求数据，可以添加任意的其他数据。
- 举例如下：
POST /task01_demo01/demo1.html HTTP/1.1
Host: localhost:8088
Content-Length: 21
Cache-Control: max-age=0
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64)
name=scott&pwd=123456
1.2.3 HTTP响应格式
- 通常情况下服务器接收并处理客户端发过来的请求后会返回一个HTTP的响应消息，主要包括：响应行、响应头、空白行和响应体。
响应行用来说明HTTP协议版本号和状态码以及状态消息，格式如下：
协议的版本(1.0 1.1) 状态码 (200 成功 404 路径错误 500 服务错误) 状态信息
响应头用来说明客户端要使用的一些附加信息，格式（key:value）。
空白行就是响应头部的空行，即使后面的请求数据为空则必须有空行。
响应体用来服务器返回给客户端的文本信息。
- 举例如下：
HTTP/1.1 200 OK
Content-Type: text/html
Content-Length: 588
Date: Thu, 08 Sep 2021 12:59:54 GMT
<html><head><title>示例1</title></head>
<body><h1>这是一个HTML页面</h1></body>
</html>
1.3 Tomcat服务器（重点）
1.3.1 基本概念
- Tomcat本意为公猫的含义，最初是由Sun公司的软件架构师詹姆斯·邓肯·戴维森开发的，后来他帮助将其变为开源项目并由Sun公司贡献给Apache软件基金会。
- Tomcat 服务器是一个开源的轻量级Web应用服务器，在中小型系统和并发量小的场合下被普遍使用，是开发和调试Servlet、JSP 程序的首选。
1.3.2 安装方式
- 下载地址：http://tomcat.apache.org/
1.3.3 目录结构
- bin 主要存放二进制可执行文件和脚本。
- conf 主要存放各种配置文件。
- lib 主要用来存放Tomcat运行需要加载的jar包。
- logs 主要存放Tomcat在运行过程中产生的日志文件。
- temp 主要存放Tomcat在运行过程中产生的临时文件。
- webapps 主要存放应用程序，当Tomcat启动时会去加载该目录下的应用程序。
- work 主要存放tomcat在运行时的编译后文件，例如JSP编译后的文件。
1.3.4 启动和关闭
- 启动方式
1.使用bin目录下的批处理文件startup.bat来启动Tomcat服务器，若出现一个毫秒数说明启动成功。
2.浏览器上 http://localhost:8080
3.http协议的默认端口80，可省略不写，像百度
4.http://localhost:8080 提示输入用户名和密码，原因是tomcat的端口号和其他软件占用了，该一下端口号就可以 server.xml 文件中该端口号 192.168.175.180:8081 - 关闭方式
1.使用bin目录下的批处理文件shutdown.bat来关闭Tomcat服务器。
2.直接关掉启动的startup.bat - 注意事项
启动之前首先安装JDK并配置环境变量JAVA_HOME，若希望Tomcat服务器可以在任意路径启动，则需要配置环境变量CATALINA_HOME。
启动信息乱码的处理方式：logging.properties文件修改为java.util.logging.ConsoleHandler.encoding = GBK
1.3.5 配置文件
- server.xml文件是服务器的主配置文件，可以设置端口号、设置域名或IP、默认加载的项目、请求编码等。
<Connector port="8888" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />
- tomcat-users.xml文件用来配置管理Tomcat服务器的用户与权限 。
<role rolename="manager-gui"/>
<user username="stone" password="stone" roles="manager-gui"/>
- http://localhost:8081 访问到webapps，后面没跟项目名默认访问ROOT，项目名后面没跟页面则默认访问index.html（没有index.html则默认访问index.jsp）
1.3.6
- New Project > Empty Project > Project Name: javaweb > finish
- File > New > Module > Java > Module Name: task01_demo01 > finish
- 项目界面,右键项目名称
> add framwork support
> 选中Web Application
>默认勾选创建web.xml - Run
> Edit Configuration
> Templates > Tomcat Server > Local
> Application Server: C:\apache-tomcat-8.5.55
> Deployment
> +
> Artifact… 目标项目
> ok - Run
> Edit Configuration
> +
> Name: task01_demo01
> Application Server: C:\apache-tomcat-8.5.55
> On ‘Update’ action: update classes and resources
> On frame deactivation: do nothing
> Deployment > Application context: /task01_demo01
> ok - Shift + F10 (Run task01_demo01)
1.4 Servlet的概念和使用（重点）
1.4.1 基本概念
- Servlet（Server Applet）是Java Servlet的简称，称为小服务程序或服务连接器，是Java语言编写的服务器端程序，换句话说，Servlet就是运行在服务器上的Java类。
- Servlet用来完成B/S架构下客户端请求的响应处理，也就是交互式地浏览和生成数据，生成动态Web内容。
1.4.2 Servlet的编程步骤
- 建立一个Java Web Application项目并配置Tomcat服务器。(创建模块)
- 自定义类实现Servlet接口或继承 HttpServlet类（推荐） 并重写service方法。
- 将自定义类的信息配置到 web.xml文件并启动项目，配置方式如下：
<!-- 配置Servlet -->
<servlet>
<!-- HelloServlet是Servlet类的别名 -->
<servlet-name> HelloServlet </servlet-name>
<!-- com.lagou.task01.HelloServlet是包含路径的真实的Servlet类名 -->
<servlet-class> com.lagou.task01.HelloServlet </servlet-class>
</servlet>
<!-- 映射Servlet -->
<servlet-mapping>
<!-- HelloServlet是Servlet类的别名，与上述名称必须相同 -->
<servlet-name> HelloServlet </servlet-name>
<!-- /hello是供浏览器使用的地址 -->
<url-pattern> /hello </url-pattern>
</servlet-mapping>
- 在浏览器上访问的方式为：
http://localhost:8080/工程路径/url-pattern的内容
1.4.3 Servlet接口
（1）基本概念
- javax.servlet.Servlet接口用于定义所有servlet必须实现的方法。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| void init(ServletConfig config) | 由servlet容器调用，以向servlet指示servlet正在被放入服务中 |
| void service(ServletRequest req, ServletResponse res) | 由servlet容器调用，以允许servlet响应请求 |
| ServletConfig getServletConfig() | 返回ServletConfig对象，该对象包含此servlet的初始化和启动参数 |
| String getServletInfo() | 返回有关servlet的信息，如作者、版本和版权 |
| void destroy() | 由servlet容器调用，以向servlet指示该servlet正在退出服务 |
1.4.5 GenericServlet类
（1）基本概念
-
javax.servlet.GenericServlet类主要用于定义一个通用的、与协议无关的servlet，该类实现了 Servlet接口。
-
若编写通用servlet，只需重写service抽象方法即可。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| abstract void service(ServletRequest req, ServletResponse res) | 由servlet容器调用允许servlet响应请求 |
1.4.6 HttpServlet类
（1）基本概念
-
javax.servlet.http.HttpServlet类是个抽象类并继承了GenericServlet类。
-
用于创建适用于网站的HTTP Servlet，该类的子类必须至少重写一个方法。
-
以后开发中推荐使用此方法创建Servlet
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| void doGet(HttpServletRequest req, HttpServletResponse resp) | 处理客户端的GET请求 |
| void doPost(HttpServletRequest req, HttpServletResponse resp) | 处理客户端的POST请求 |
| void init() | 进行初始化操作 |
| void service(HttpServletRequest req, HttpServletResponse resp) | 根据请求决定调用doGet还是doPost方法 |
| void destroy() | 删除实例时释放资源 |
1.4.7 Servlet 的生命周期
- 构造方法只被调用一次，当第一次请求Servlet时调用构造方法来创建Servlet的实例。
- init方法只被调用一次，当创建好Servlet实例后立即调用该方法实现Servlet的初始化。
- service方法被多次调用，每当有请求时都会调用service方法来用于请求的响应。
- destroy方法只被调用一次，当该Servlet实例所在的Web应用被卸载前调用该方法来释放当前占用的资源。
1.5 POST和GET请求（重点）
1.5.1 GET请求
发出GET请求的主要方式：
（1）在浏览器输入URL按回车
（2）点击<a>超链接
（3）点击submit按钮，提交 <form method=“get”>表单
GET请求特点：
会将请求数据添加到请求URL地址的后面，只能提交少量的数据、不安全
1.5.2 POST请求
发出POST请求的方法如下：
点击submit按钮，提交 <form method=“post”>表单
POST请求的特点：
请求数据添加到HTTP协议体中，可提交大量数据、安全性好
1.5.3 ServletRequest接口
（1）基本概念
- javax.servlet.ServletRequest接口主要用于向servlet提供客户端请求信息，可以从中获取到任何请求信息。
- Servlet容器创建一个ServletRequest对象，并将其作为参数传递给Servlet的service方法。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| String getParameter(String name) | 以字符串形式返回请求参数的值，如果该参数不存在，则返回空值 |
| String[] getParameterValues( String name) | 返回一个字符串对象数组，其中包含给定请求参数所具有的所有值，如果该参数不存在，则返回空值 |
| Enumeration getParameterNames() | 返回包含此请求中包含的参数名称的字符串对象的枚举。如果请求没有参数，则方法返回空枚举 |
| Map<String, String[]> getParameterMap() | 返回请求参数的键值对，一个键可以对应多个值 |
| String getRemoteAddr() | 返回发送请求的客户端或最后一个代理的IP地址 |
| int getRemotePort() | 返回发送请求的客户端或最后一个代理的端口号 |
1.5.4 HttpServletRequest接口
（1）基本概念
- javax.servlet.http.HttpServletRequest接口是ServletRequest接口的子接口，主要用于提供HTTP请求信息的功能。
- 不同于表单数据，在发送HTTP请求时，HTTP请求头直接由浏览器设置。
- 可直接通过HttpServletRequest对象提供的一系列get方法获取请求头数据。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| String getRequestURI() | 返回此请求的资源路径信息 |
| StringBuffer getRequestURL() | 返回此请求的完整路径信息 |
| String getMethod() | 返回发出此请求的HTTP方法的名称，例如GET、POST |
| String getQueryString() | 返回路径后面请求中附带的参数 |
| String getServletPath() | 返回此请求中调用servlet的路径部分 |
1.5.5 ServletResponse接口
（1）基本概念
- javax.servlet.ServletResponse接口用于定义一个对象来帮助Servlet向客户端发送响应。
- Servlet容器创建ServletResponse对象，并将其作为参数传递给servlet的service方法。
（2）常用方法
| 方法声明 | 功能介绍 |
|---|---|
| PrintWriter getWriter() | 返回可向客户端发送字符文本的PrintWriter对象 |
| String getCharacterEncoding() | 获取响应内容的编码方式void |
| setContentType(String type) | 如果尚未提交响应，则设置发送到客户端响应的内容类型。内容类型可以包括字符编码规范，例如text/html;charset=UTF-8 |
1.5.6 HttpServletResponse接口
（1）基本概念
- javax.servlet.http.HttpServletResponse接口继承ServletResponse接口，以便在发送响应时提供特定于HTTP的功能。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| void sendRedirect(String location) | 使用指定的重定向位置URL向客户端发送临时重定向响应 |
1.5.7 使用示例
// 继承HttpServlet
public class HelloWorld extends HttpServlet {
// 重写HttpServlet中的doGet方法
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
// 设置响应输出编码，避免中文乱码
response.setContentType(“text/html;charset=utf-8”);
// 获取响应输出流
PrintWriter out= response.getWriter();
// 利用输出流输出信息
out.println(“<html><body> Hello world！</body></html>”);
//关闭流
out.close();
}
}
- 案例题目
使用Servlet获取在服务器获取一个1~100之间的随机数并发送给客户端进行显示。
1.6 Servlet接收中文乱码（重点）
1.6.1 接收乱码原因
- 浏览器在提交表单时，会对中文参数值进行自动编码。当Tomcat服务器接收到浏览器请求后自动解码，当编码与解码方式不一致时,就会导致乱码。
1.6.2 解决POST接收乱码
接收之前设置编码方式：
request.setCharacterEncoding(“utf-8”)
提示：
必须在调用request.getParameter(“name”)之前设置
1.6.3 解决GET接收乱码
将接收到的中文乱码重新编码:
// 接收到get请求的中文字符串
String name = request.getParameter("name");
// 将中文字符重新编码，默认编码为ISO-8859-1
String userName = new String(name.getBytes(“ISO-8859-1”),“utf-8");
1.7 ServletConfig接口（熟悉）
（1）基本概念
- javax.servlet.ServletConfig接口用于描述Servlet本身的相关配置信息，在初始化期间用于将信息传递给Servlet配置对象。
（2）配置方式
<!-- 在web.xml中配置ServletConfig初始化参数 -->
<servlet>
<servlet-name>actionservlet</servlet-name>
<servlet-class>com.lagou.demo01.ActionServlet</servlet-class>
<!-- 配置 Serlvet 的初始化参数 -->
<init-param>
<!-- 参数名 -->
<param-name>config</param-name>
<!-- 参数值 -->
<param-value>struts.xml</param-value>
</init-param>
</servlet>
（3）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| String getServletName() | 返回Servlet的别名 |
| String getInitParameter(String name) | 返回包含初始化参数值的字符串，如果该参数不存在，则返回null |
| Enumeration getInitParameterNames() | 将servlet的初始化参数的名称作为字符串对象的枚举返回，如果servlet没有初始化参数，则返回空枚举 |
| ServletContext getServletContext() | 返回对调用方正在其中执行的ServletContext的引用 |
1.8 ServletContext接口（熟悉）
（1）基本概念
- javax.servlet.ServletContext接口主要用于定义一组方法，Servlet使用这些方法与它的Servlet容器通信。
- 服务器容器在启动时会为每个项目创建唯一的一个ServletContext对象，用于实现多个Servlet之间的信息共享和通信。
- 在Servlet中通过this.getServletContext()方法可以获得ServletContext对象。
（2）配置方式
<!--在web.xml中配置ServletContext初始化参数 -->
<context-param>
<param-name>username</param-name>
<param-value>scott</param-value>
<context-param>
<context-param>
<param-name>password</param-name>
<param-value>tiger</param-value>
<context-param>
（3）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| String getInitParameter(String name) | 返回包含初始化参数值的字符串，如果该参数不存在，则返回null |
| Enumeration getInitParameterNames() | 将servlet的初始化参数的名称作为字符串对象的枚举返回，如果servlet没有初始化参数，则返回空枚举 |
| String getRealPath(String path) | 返回包含给定虚拟路径的实际路径的字符串 |
| String getContextPath() | 返回与此上下文关联的主路径 |
| InputStream getResourceAsStream(String path) | 将位于指定路径的资源作为InputStream对象返回 |
| void setAttribute(String name, Object object) | 将指定的属性名和属性值绑定到当前对象 |
| Object getAttribute(String name) | 根据执行的属性名获取属性值 |
| void removeAttribute(String name) | 删除指定的属性名信息 |
1.9 总结
- Servlet核心技术（上）
基本概念，Http协议，
Tomcat服务器，Servlet的概念和使用，Post请求和Get请求，Servlet解决中文乱码，
ServletConfig接口，ServletContext接口等
第二章 Servlet核心技术（下）
2.1 Servlet+JDBC应用（重点）
- 在Servlet中可以使用JDBC技术访问数据库，常见功能如下：
○ 查询DB数据，然后生成显示页面，例如：列表显示功能。
○ 接收请求参数，然后对DB操作，例如：注册、登录、修改密码等功能。 - 为了方便重用和便于维护等目的，经常会采用DAO（Data Access Object）模式对数据库操作进行独立封装。
1.register.html
2.com.lagou.demo01.servlet.RegisterServlet
3.com.lagou.demo01.model.User
4.create database db_web; create table t_user(…);
5.com.lagou.demo01.utils.DBUtils
6.导入jar包：web.WEB-INF.lib.mysql-connector-java-5.1.37-bin.jar
7.task02_demo01(模块)右键 > Open Module Settings > Libraries > + > java > C:\Users\kimyu\IdeaProjects\javaweb\task02_demo01\web\WEB-INF\lib (找到lib) > apply > Modules > Dependencies >确认有lib > ok
8.com.lagou.demo01.test.DBUtilTest
9.com.lagou.demo01.dao.UserDao
10.com.lagou.demo01.RegisterServlet
(java_web > task02_demo01)
- DAO工厂(工厂模式)
工厂类：封装了对象的创建细节，为调用者提供符合要求的对象。
2.2 重定向和转发（重点）
2.2.1 重定向的概述
（1）重定向的概念
- 首先客户浏览器发送http请求，当web服务器接受后发送302状态码响应及对应新的location给客户浏览器，客户浏览器发现是302响应，则自动再发送一个新的http请求，请求url是新的location地址，服务器根据此请求寻找资源并发送给客户。
（2）重定向的实现
- 实现重定向需要借助javax.servlet.http.HttpServletResponse接口中的以下方法：
| 方法声明 | 功能介绍 |
|---|---|
| void sendRedirect(String location) | 使用指定的重定向位置URL向客户端发送临时重定向响应 |
（3）重定向的原理
（4）重定向的特点
- 重定向之后，浏览器地址栏的URL会发生改变。
- 重定向过程中会将前面Request对象销毁，然后创建一个新的Request对象。
- 重定向的URL可以是其它项目工程。
2.2.2 转发的概述
（1）转发的概念
- 一个Web组件（Servlet/JSP）将未完成的处理通过容器转交给另外一个Web组件继续处理，转发的各个组件会共享Request和Response对象。
（2）转发的实现
- 绑定数据到Request对象
| 方法声明 | 功能介绍 |
|---|---|
| Object getAttribute(String name) | 将指定属性值作为对象返回，若给定名称属性不存在，则返回空值 |
| void setAttribute(String name,Object o) | 在此请求中存储属性值 |
- 获取转发器对象
| 方法声明 | 功能介绍 |
|---|---|
| RequestDispatcher getRequestDispatcher(String path) | 返回一个RequestDispatcher对象，该对象充当位于给定路径上的资源的包装器 |
- 转发操作
| 方法声明 | 功能介绍 |
|---|---|
| void forward(ServletRequest request, ServletResponse response) | 将请求从一个servlet转发到服务器上的另一个资源（Servlet、JSP文件或HTML文件） |
（3）转发的特点
- 转发之后浏览器地址栏的URL不会发生改变。
- 转发过程中共享Request对象。
- 转发的URL不可以是其它项目工程。
（4） 重定向和转发的比较
2.3 Servlet线程安全（重点）
- 服务器在收到请求之后，会启动一个线程来进行相应的请求处理。
- 默认情况下，服务器为每个Servlet只创建一个对象实例。当多个请求访问同一个Servlet时，会有多个线程访问同一个Servlet对象，此时就可能发生线程安全问题。
- 多线程并发逻辑，需要使用synchronized对代码加锁处理，但尽量避免使用。
2.4 状态管理（重点）
- Web程序基于HTTP协议通信，而HTTP协议是”无状态”的协议，一旦服务器响应完客户的请求之后，就断开连接，而同一个客户的下一次请求又会重新建立网络连接。
- 服务器程序有时是需要判断是否为同一个客户发出的请求，比如客户的多次选购商品。因此，有必要跟踪同一个客户发出的一系列请求。
- 把浏览器与服务器之间多次交互作为一个整体，将多次交互所涉及的数据保存下来，即状态管理。
- 多次交互的数据状态可以在客户端保存，也可以在服务器端保存。状态管理主要分为以下两类：
○ 客户端管理：将状态保存在客户端。基于Cookie技术实现。
○ 服务器管理：将状态保存在服务器端。基于Session技术实现。
2.5 Cookie技术（重点）
2.5.1 基本概念
- Cookie本意为”饼干“的含义，在这里表示客户端以“名-值”形式进行保存的一种技术。
- 浏览器向服务器发送请求时，服务器将数据以Set-Cookie消息头的方式响应给浏览器，然后浏览器会将这些数据以文本文件的方式保存起来。
- 当浏览器再次访问服务器时，会将这些数据以Cookie消息头的方式发送给服务器。
2.5.2 相关的方法
- 使用javax.servlet.http.Cookie类的构造方法实现Cookie的创建。
| 方法声明 | 功能介绍 |
|---|---|
| Cookie(String name, String value) | 根据参数指定数值构造对象 |
- 使用javax.servlet.http.HttpServletResponse接口的成员方法实现Cookie的添加。
| 方法声明 | 功能介绍 |
|---|---|
| void addCookie(Cookie cookie) | 添加参数指定的对象到响应 |
- 使用javax.servlet.http.HttpServletRequest接口的成员方法实现Cookie对象的获取。
| 方法声明 | 功能介绍 |
|---|---|
| Cookie[] getCookies() | 返回此请求中包含的所有Cookie对象 |
- 使用javax.servlet.http.Cookie类的构造方法实现Cookie对象中属性的获取和修改。
| 方法声明 | 功能介绍 |
|---|---|
| String getName() | 返回此Cookie对象中的名字 |
| String getValue() | 返回此Cookie对象的数值 |
| void setValue(String newValue) | 设置Cookie的数值 |
2.5.3 Cookie的生命周期
- 默认情况下，浏览器会将Cookie信息保存在内存中，只要浏览器关闭，Cookie信息就会消失。
- 如果希望关闭浏览器后Cookie信息仍有效，可以通过Cookie类的成员方法实现。
| 方法声明 | 功能介绍 |
|---|---|
| int getMaxAge() | 返回cookie的最长使用期限（以秒为单位） |
| void setMaxAge(int expiry) | 设置cookie的最长保留时间（秒） 正数表示指定的描述后失效 数表示浏览器关闭后失效 0表示马上失效 |
2.5.4 Cookie的路径问题
- 浏览器在访问服务器时，会比较Cookie的路径与请求路径是否匹配，只有匹配的Cookie才会发送给服务器。
- Cookie的默认路径等于添加这个Cookie信息时的组件路径，例如：/项目名/目录/add.do请求添加了一个Cookie信息，则该Cookie的路径是 /项目名/目录。
- 访问的请求地址必须符合Cookie的路径或者其子路径时，浏览器才会发送Cookie信息。
| 方法声明 | 功能介绍 |
|---|---|
| void setPath(String uri) | 设置cookie的路径信息 |
2.5.5 Cookie的特点
- Cookie技术不适合存储所有数据，程序员只用于存储少量、非敏感信息，原因如下：
○ 将状态数据保存在浏览器端，不安全。
○ 保存数据量有限制，大约4KB左右。
○ 只能保存字符串信息。
○ 可以通过浏览器设置为禁止使用。
2.6 Session技术（重点）
2.6.1 基本概念
- Session本意为"会话"的含义，是用来维护一个客户端和服务器关联的一种技术。
- 浏览器访问服务器时，服务器会为每一个浏览器都在服务器端的内存中分配一个空间，用于创建一个Session对象，该对象有一个id属性且该值唯一，我们称为SessionId，并且服务器会将这个SessionId以Cookie方式发送给浏览器存储。
- 浏览器再次访问服务器时会将SessionId发送给服务器，服务器可以依据SessionId查找相对应的Session对象
2.6.2 相关的方法
- 使用javax.servlet.http.HttpServletRequest接口的成员方法实现Session的获取。
| 方法声明 | 功能介绍 |
|---|---|
| HttpSession getSession() | 返回此请求关联的当前Session，若此请求没有则创建一个 |
- 使用javax.servlet.http.HttpSession接口的成员方法实现判断和获取。
| 方法声明 | 功能介绍 |
|---|---|
| boolean isNew() | 判断是否为新创建的Session |
| String getId() | 获取Session的编号 |
- 使用javax.servlet.http.HttpSession接口的成员方法实现属性的管理。
| 方法声明 | 功能介绍 |
|---|---|
| Object getAttribute(String name) | 返回在此会话中用指定名称绑定的对象，如果没有对象在该名称下绑定，则返回空值 |
| void setAttribute(String name, Object value) | 使用指定的名称将对象绑定到此会话 |
| void removeAttribute(String name) | 从此会话中删除与指定名称绑定的对象 |
2.6.3 Session的生命周期
- 为了节省服务器内存空间资源，服务器会将空闲时间过长的Session对象自动清除掉，服务器默认的超时限制一般是30分钟。
- 使用javax.servlet.http.HttpSession接口的成员方法实现失效实现的获取和设置。
| 方法声明 | 功能介绍 |
|---|---|
| int getMaxInactiveInterval() | 获取失效时间 |
| void setMaxInactiveInterval(int interval) | 设置失效时间 |
- 可以配置web.xml文件修改失效时间。
<session-config>
<session-timeout>30</session-timeout>
</session-config>
2.6.4 Session的特点
- 数据比较安全。
- 能够保存的数据类型丰富，而Cookie只能保存字符串。
- 能够保存更多的数据，而Cookie大约保存4KB。
- 数据保存在服务器端会占用服务器的内存空间，如果存储信息过多、用户量过大，会严重影响服务器的性能。
2.7 总结
- Servlet核心技术（下）
Servlet和JDBC用用，重定向和转发，Servlet线程安全，状态管理，
Cookie技术，Session技术
第三章 JSP核心技术
3.1 JSP的概述（熟悉）
3.1.1 JSP的概念
- JSP是Java Server Pages的简称，跟Servlet一样可以动态生成HTML响应， JSP文件命名为xxx.jsp。
- 与Servlet不同，JSP文件以HTML标记为主，然后内嵌Java代码段，用于处理动态内容。
3.1.2 JSP的示例
<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Hello Time</title>
</head>
<body>
现在的时间是：<%= new Date()%>
</body>
</html>
3.1.3 JSP与Servlet的关系
3.2 JSP的语法（熟悉）
3.2.1 JSP语法结构
- 声明区
- 程序代码区
- 表达式
- 注释
- 指令和动作
- 内置对象
3.2.2 声明区
- 基本语法：
<%! %> - 说明：可以定义全局变量、方法、类。
<%!
int i;
public void setName(){
… …}
%>
3.2.3 程序代码区
- 基本语法：
<%程序代码区%> - 说明：可以定义局部变量以及放入任何的Java程序代码。
<%
int j;
for (int k=0; k<10; k++) {
… …
}
%>
3.2.4 表达式
- 基本语法：
<%=… …%> - 说明：可以输出一个变量或一个具体内容，但=后面必须是字符串变量或者可以被转换成字符串的表达式。
- 注意：不需要以;结束，只有一行
<%=“hello world”%>
<%=i+1%>
- 案例题目
使用for循环输出一个html语言的表格，具体表头如下：
id name age salary
1 1 1 1
2 2 2 2
...
5 5 5 5
3.2.5 注释
格式：
<!--… …--> HTML文件的注释，浏览器可以查看到
<%--… …--%> JSP文件的注释，浏览器看不到
<%//… …%> Java语言中的单行注释，浏览器看不到
<%/*… …*/%> Java语言中的多行注释，浏览器看不到
注释的内容不会被执行
3.2.6 指令和动作
- 指令格式：
<%@指令 属性=“属性值”%> - 指令的属性可以设定多个。
- JSP常用指令有：page、taglib、include。
（1）page指令
- page指令用于导包和设置一些页面属性，常用属性如下：
import 导入相应的包，惟一允许在同一文档中多次出现的属性
contentType 设置Content-Type响应报头，标明即将发送到浏览器的文档类型
pageEncoding 设置页面的编码
language 指定页面使用的语言
session 控制页面是否参与HTTP会话
errorPage 处理当前页面中抛出但未被捕获的任何异常
isErrorPage 当前页是否可以作为其他页面的错误处理页面
（2）taglib指令
- taglib指令用来扩展JSP程序的标签元素，引入其他功能的标签库文件。
<!-- prefix属性用于指定库前缀 -->
<!-- uri属性用于指定库的标识 -->
<%@taglib uri=“tagLibary” prefix=“prefix”%>
（3）include指令
- include指令用于引入另一个JSP程序或HTML文件等，格式如下：
<%@include file=“被包含的文件地址%>
- JSP引擎会在JSP文件的转换时期先把file属性设定的文件包含进来，然后开始执行转换及编译的工作。
（4）jsp:include/jsp:param
- jsp:include动作用于引入另一个JSP程序或HTML文件等。
- 执行到include时，被include的文件才会被编译。
- 如果include的是jsp文件，那它不会被转换成Servlet文件。
<jsp:include page=“URLSpec” flush=“true”/>
<jsp:include page=“URLSpec” flush=“true”>
<jsp:param name=“key” value=“value”/>
</jsp:include>
（5）include指令和include动作的区别
- include指令是在JSP程序的转换时期就将file属性所指定的程序内容嵌入再编译执行（静态包含）。
- include动作在转换时期是不会被编译的，只有在客户端请求时期被执行到才会被动态的编译载入（动态包含，推荐）。
（6）jsp:forward/jsp:param
- forward动作用于在JSP中实现转发，将请求转发到另一个指定的JSP程序或者Servlet中处理。
<jsp:forward page=“urlSpec” flush=“true”/>
<jsp:forward page=“urlSpec”>
<!-- 用于指定参数和其对应的值 -->
<jsp:param name=“key” value=“value”/>
</jsp:forward>
3.3 JSP内置对象（重点）
3.3.1 基本概念
- 内置对象：内部已经制定好的对象，即已有的对象
- 在JSP程序中有9个内置对象由容器为用户进行实例化，程序员可以不用定义就直接使用这些变量。
- 在JSP转换成Servlet后，会自动追加这些变量的定义，使用内置对象可以简化JSP的开发。
3.3.2 对象名称
| 对象变量 | 对象类型 | 作用 |
|---|---|---|
| out | JSPWriter | 输出流 |
| request | HttpServletRequest | 请求信息 |
| response | HttpServletResponse | 响应信息 |
| session | HttpSession | 会话 |
| application | ServletContext | 全局的上下文对象 |
| pageContext | PageContext | JSP页面上下文 |
| page | Object | JSP页面本身 |
| config | ServletConfig | Servlet配置对象 |
| exception | Throwable | 捕获网页异常 |
3.3.3 out内置对象
- out内置对象是一个缓冲的输出流，用来给客户端输出信息。
- 常用方法如下：
| 方法声明 | 功能介绍 |
|---|---|
| void println(String x) | 向客户端输出各种类型数据 |
| void newLine() | 输出一个换行符 |
| void close() | 关闭输出流 |
| int getBufferSize() | 返回缓冲区的大小 |
| int getRemaining() | 返回缓冲区中未使用的字节数 |
| void flush() | 输出缓冲区里的数据 |
| void clearBuffer() | 清除缓冲区里的数据，同时把数据输出到客户端 |
| void clear() | 清除缓冲区里的数据，但不把数据输出到客户端 |
3.3.4 request内置对象
- request对象封装的是调用JSP页面的请求信息，它是HttpServletRequest接口的一个实例。
- 该对象的属性值只在一个请求中保存。
- 常用方法如下：
| 方法声明 | 功能介绍 |
|---|---|
| String getMethod() | 返回客户端向服务器端传送数据的方式 |
| String getParameter(String name) | 返回客户端向服务器端传送的参数值 |
| String[] getParameterValues( Strin name) | 获得指定参数的所有值 |
| String getRequestURI() | 获得请求地址 |
| String getRemoteAddr() | 返回发送请求的客户端或最后一个代理的IP地址 |
| int getRemotePort() | 返回发送请求的客户端或最后一个代理的端口号 |
| String getServerName() | 获取服务器的名字 |
| int getServerPort() | 获取服务器端的端口 |
| void setAttribute(String name,Object o) | 在此请求中存储属性。属性在请求之间重置 |
| Object getAttribute(String name) | 将指定属性的值作为对象返回，若不存在则返回空值 |
3.3.5 response内置对象
- response对象用于给客户端相应输出处理结果，它是HttpServletResponse接口的一个实例。
- 经常用于设置HTTP标题，添加cookie、设置响应内容的类型和状态、发送HTTP重定向和编码URL。
- 常用方法如下：
| 方法声明 | 功能介绍 |
|---|---|
| void addCookie(Cookie cookie) | 添加一个Cookie对象，用于在客户端保存特定的信息 |
| void addHeader(String name, String value) | 添加HTTP头信息，该Header信息将发送到客户端 |
| boolean containsHeader(String name) | 判断指定名字的HTTP文件头是否存在 |
| void sendRedirect(String location) | 重定向JSP文件 |
| void setContentType(String type) | 设置类型与编码方式 |
3.3.6 session内置对象
- session对象表示浏览器和服务器之间的一次会话，一次会话可以包含多次请求，在多次请求之间可以借助session对象存储信息，它是HttpSession类型的一个实例。
- 该对象的属性值在一次会话范围中保存，保存在服务器端，只要不关闭浏览器，默认半个小时内都可以访问。
- 常用方法如下：
| 方法声明 | 功能介绍 |
|---|---|
| void setAttribute(String name, Object value) | 使用指定的名称将对象绑定到此会话 |
| Object getAttribute(String name) | 返回在此会话中用指定名称绑定的对象，如果没有对象在该名称下绑定则返回空值 |
3.3.7 application内置对象
- application对象是一个web程序的全局变量，它是ServletContext类型的一个实例。
- 在整个服务器上保存数据，所有用户共享。
- 常用方法如下：
| 方法声明 | 功能介绍 |
|---|---|
| void setAttribute(String name, Object object) | 将对象绑定到此servlet上下文中的给定属性名 |
| Object getAttribute(String name) | 返回给定名称的servlet容器属性，若没有该名称的属性返回null |
3.3.8 pageContext内置对象
- pageContext对象是PageContext类型的对象，可以使用这个对象来管理其他的隐含对象。
(servlet 上下文) - 只在一个页面中保存数据。
(范围比session还大)
| 方法声明 | 功能介绍 |
|---|---|
| void setAttribute(String name, Object value, int scope) | 使用适当的作用域设置指定的名称和值 |
| Object getAttribute(String name, int scope) | 返回指定作用域中名称关联的对象，若找不到则返回null |
| ServletRequest getRequest() | 获取请求对象 |
| ServletResponse getResponse() | 获取响应对象 |
| HttpSession getSession() | 获取会话对象 |
| ServletConfig getServletConfig() | 获取配置对象 |
| JspWriter getOut() | 获取输出对象 |
| Object getPage() | 获取页面对象 |
| Exception getException() | 获取异常对象 |
3.3.9 exception内置对象
- exception 对象是Throwable的实例，表示的是JSP的异常信息。
- 如果要使用它，必须将对应页面page指令的isErrorPage属性设置成true。
- 单个页面的处理方式
<%@page errorPage="error.jsp" %>
- 在web.xml中配置统一的异常处理页面。
<error-page>
<exception-type>java.lang.Throwable</exception-type>
<location>/error.jsp</location>
</error-page>
3.4 JavaBean组件（熟悉）
（1）基本概念
- JavaBean 是使用 Java 语言开发的一个可重用的组件，在 JSP 开发中可以使用 JavaBean 减少重复代码，使整个 JSP 代码的开发更加简洁。
- JavaBean本质上就是Java类，通常要求如下：
○ 属性：全部私有化，通过get和set方法进行访问。
○ 方法：必须是public关键字修饰。
○ 构造器 ：必须有无参构造方法。
（2）使用方式
- 使用jsp:useBean的方式创建javaBean实例
<jsp:useBean id=“对象名” scope=“保存范围 class=“包名.类名” />
保存范围有：page|request|sessin|application，默认为page范围。
- 使用jsp:setProperty的方式设置javaBean的属性值
<jsp:setProperty name="对象名" property="属性名" value="属性值" param="参数名"/>
- 使用jsp:getProperty的方式获取javaBean的属性值
<jsp:getProperty name="对象名" property="属性名"/>
（3）保存范围
- JavaBean的保存范围有page、request、session以及application，默认是page范围。
（4）删除方式
<%
内置对象.removeAttribute(“JavaBean的名字”);
%>
3.5 MVC设计模式（重点）
3.5.1 基本概念
- MVC是模型(Model)和视图(View)以及控制器(Controller)的简写，是一种将数据、界面显示和业务逻辑进行分离的组织方式，这样在改进界面及用户交互时，不需要重新编写业务逻辑，从而提高了代码的可维护性。
- M：主要用于封装业务数据的JavaBean(Bean) 和 业务逻辑的JavaBean(Service)及访问数据库的DAO对象。
- V：主要负责数据收集 和 数据展现，通常由JSP文件完成。
- C：主要负责流程控制 和 页面跳转，通常由Servlet完成。
3.5.2 基本模型
(javaweb.task03_demo03)
3.6 总结
- JSP核心技术
JSP的概念，JSP和Servlet的区别，JSP的语法，JSP的九大内置对象，JavaBean的使用，MVC设计模式
第四阶段模块一作业
编程题
使用前端、数据库、JavaWeb 等技术并采用 MVC 设计模式实现学生信息管理系统，要求使用管理员账号密码登录后进行学员信息增加、学员信息修改、学员信息删除、学员信息查找、学员信息显示功能。
其中学生信息有：学号、姓名、性别、出生日期、邮箱、备注
要求：
- 前端页面、数据库表、后台业务等自行设计和实现，根据功能点和后期维护及可扩展程度给分。
- 尽可能使用已学过的流行技术，如：数据库连接池、分页显示等。
第四阶段 模块二 JavaWeb核心（下）
第四章 EL和JSTL核心技术
4.1 EL表达式（熟悉）
4.1.1 基本概念
- EL（Expression Language）表达式提供了在JSP中简化表达式的方法，可以方便地访问各种数据并输出。
4.1.2 主要功能
- 依次访问pageContext、request、session和application作用域对象存储的数据。
pageContext:当前页面中有效
request:当前请求中有效
session:当前会话中有效
aplication:当前服务器中有效 - 获取请求参数值。
- 访问Bean对象的属性。
- 访问集合中的数据。
- 输出简单的运算结果。
4.1.3 访问内置对象的数据
（1）访问方式
- <%=request.getAttribute(“ varName”)%>
- 用EL实现: ${ varName }
（2）执行流程
4.1.4 访问请求参数的数据
- 在EL之前使用下列方式访问请求参数的数据
request.getParameter(name);
request.getParameterValues(name); - 在EL中使用下列方式访问请求参数的数据
param：接收的参数只有一个值。
paramValues：接受的参数有多个值。
<!-- 获取指定参数的数值 -->
${param.name}
<!-- 获取指定参数中指定下标的数值 -->
${paramValues.hobby[0]}
4.1.5 访问Bean对象的属性
（1）访问方式
- 方式一： $ { 对象名 . 属性名 }，例如：${user.name}
- 方式二： $ { 对象名 [“属性名”] }，例如：${user[“name”]} （推荐）
（2）主要区别
- 当要存取的属性名中包含一些特殊字符，如： . 或 ,等并非字母或数字的符号，就一定要使用 [ ]而不是.的方式
- 使用[]的方式可以动态取值，具体方式如下：
<%
request.setAttribute(“prop”,“age”);
%>
<!-- 相当于表达式中写一个变量 -->
${ user[prop] }
4.1.6 访问集合中的数据
<!-- student为ArrayList类型的对象 -->
${student[0].name}
4.1.7 常用的内置对象
- EL表达式中常用的内置对象
| 类别 | 标识符 | 描述 |
|---|---|---|
| JSP | pageContext | PageContext 处理当前页面 |
| 作用域 | pageScope | 同页面作用域属性名称和值有关的Map类 |
| requestScope | 同请求作用域属性的名称和值有关的Map类 | |
| sessionScope | 同会话作用域属性的名称和值有关的Map类 | |
| applicationScope | 同应用程序作用域属性的名称和值有关的Map类 | |
| 请求参数 | param | 根据名称存储请求参数的值的Map类 |
| paramValues | 把请求参数的所有值作为一个String数组来存储的Map类 | |
| 请求头 | header | 根据名称存储请求头主要值的Map类 |
| headerValues | 把请求头的所有值作为一个String数组来存储的Map类 | |
| Cookie | cookie | 根据名称存储请求附带的cookie的Map类 |
| 初始化参数 | initParam | 根据名称存储Web应用程序上下文初始化参数的Map类 |
4.1.8 常用的运算符
（1）常用的算术运算符
| 算术运算符 | 说 明 | 范 例 | 运算结果 |
|---|---|---|---|
| + | 加 | ${1+2} | 3 |
| － | 减 | ${2-1} | 1 |
| * | 乘 | ${2*3} | 6 |
| / 或 div | 除 | ${16/5}或${16div5} | 3.2 |
| % 或 mod | 取余 | ${16%5}或${16mod5} | 1 |
（2）常用的关系运算符
| 关系运算符 | 说 明 | 范 例 | 运算结果 |
|---|---|---|---|
| ==或 eq | 等于 | ${1==2}或${1 eq 2} | false |
| != 或 ne | 不等于 | ${2!=1}或${1 ne 2} | true |
| < 或 lt | 小于 | ${2<3}或${2 lt 3 } | true |
| > 或 gt | 大于 | ${16>5}或${16 gt 5} | true |
| <= 或 le | 小于等于 | ${16<=5}或${16 le 5} | false |
| >= 或 ge | 大于等于 | ${16>=5}或${16 ge 5} | true |
（3）常用的逻辑运算符
| 逻辑运算符 | 说 明 | 范 例 | 运算结果 |
|---|---|---|---|
| && 或 and | 与运算 | ${true&&true}或${true and true} | true |
| || 或or | 或运算 | ${true||false}或${true or false} | true |
| ! 或not | 非运算 | ${!true}或${not true } | false |
（4）条件运算符
${条件表达式? 语句1 : 语句2}
（5）验证运算符
${empty 表达式}
返回布尔值判断表达式是否为"空"值，null值、无元素的集合或数组、长度为零的String被认为是空值。
4.2 JSTL标签（熟悉）
4.2.1 基本概念
- JSTL( JSP Standard Tag Library ) 被称为JSP标准标签库。
- 开发人员可以利用这些标签取代JSP页面上的Java代码，从而提高程序的可读性，降低程序的维护难度。
4.2.2 使用方式
- 下载JSTL的jar包并添加到项目中，下载地址为：https://tomcat.apache.org/download-taglibs.cgi
- 在JSP页面中使用taglib指定引入jstl标签库，方式为：
<!-- prefix属性用于指定库前缀 -->
<!-- uri属性用于指定库的标识 -->
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
4.2.3 常用核心标签
（1）输出标签
<c:out></c:out> 用来将指定内容输出的标签
（2）设置标签
<c:set></c:set> 用来设置属性范围值的标签
（3）删除标签
<c:remove></c:remove> 用来删除指定数据的标签
（4）单条件判断标签
<c:if test =“EL条件表达式”>
满足条件执行
</c:if >
（5）多条件判断标签
<c:choose >
<c:when test =“EL表达式”>
满足条件执行
</c:when>
…
<c:otherwise>
不满足上述when条件时执行
</c:otherwise>
</c:choose >
（6）循环标签
<c:forEach var=“循环变量” items=“集合”>
…
</c:forEach>
<%
// 准备一个数组并初始化
String[] sArr = {"11","22","33","44","55"};
pageContext.setAttribute("sArr",sArr);
%>
<%-- 使用循环标签遍历数组中的所有元素--%>
<c:forEach items="${sArr}" var="ts" >
<c:out value="${ts}"></c:out>
</c:forEach>
<hr>
<%-- 跳跃性遍历 间隔为2 也就是 跳过一个遍历一个 --%>
<c:forEach items="${sArr}" var="ts" step="2">
<c:out value="${ts}"></c:out>
</c:forEach>
<hr>
<%--11 33 55--%>
<%-- 指定起始和结尾位置 从下标1开始到3结束 --%>
<c:forEach items="${sArr}" var="ts" begin="1" end="3" >
<c:out value="${ts}"></c:out>
</c:forEach>
<%--22 33 44--%>
4.2.4 常用函数标签
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
<%
pageContext.setAttribute("var","Hello World!");
%>
原始字符串为：${var}<br> <%--Hello World!--%>
判断该字符串是否包含指定字符串的结果为：${fn:contains(var,"Hello")}<br> <%--true--%>
将字符串中所有字符转换为大写的结果为：${fn:toUpperCase(var)}<br> <%--HELLO WORLD!--%>
将字符串中所有字符转换为小写的结果为：${fn:toLowerCase(var)}<br> <%--hello world!--%>
4.2.5 常用格式化标签
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%
// 获取当前系统时间
Date date = new Date();
pageContext.setAttribute("date",date);
%>
当前系统时间为：${date}<br>
<hr>
<fmt:formatDate value="${date}" pattern="yyyy-MM-dd HH:mm:ss"></fmt:formatDate>
4.2.6 自定义标签
- 如果上面几个标签不能满足需求，程序员也可以自定义标签，步骤如下：
- 编写标签类继承SimpleTagSupport类或TagSupport类并重写doTag方法或doStartTag方法。
public class HelloTag extends SimpleTagSupport {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public void doTag() throws JspException, IOException {
JspWriter out = this.getJspContext().getOut();
out.println("自定义标签的参数为：" + name);
}
}
- 定义标签库文件（tld标签库文件）并配置标签说明文件到到WEB-INF下：
<tag>
<name>helloTag</name>
<tag-class>com.lagou.demo02.HelloTag</tag-class>
<body-content>empty</body-content>
<attribute>
<name>name</name>
<required>true</required>
</attribute>
</tag>
- 在JSP中添加taglib指令引入标签库使用：
<%@ taglib prefix="hello" uri="http://lagou.com" %>
4.3 总结
- EL和JSTL核心技术
EL表达式的概念，主要功能，床用的内置对象，常用的运算符，
JSTL基本概念，使用方式，常用的核心标签，函数标签，格式化标签，自定义标签
第五章 Filter+Listener核心技术
5.1 Filter过滤器（重点）
5.1.1 基本概念
- Filter本意为”过滤“的含义，是JavaWeb的三大组件之一，三大组件为：Servlet、Filter、Listener。
- 过滤器是向 Web 应用程序的请求和响应处理添加功能的 Web 服务组件。
- 过滤器相当于浏览器与Web资源之间的一道过滤网，在访问资源之前通过一系列的过滤器对请求进行修改、判断以及拦截等，也可以对响应进行修改、判断以及拦截等。（数据的过滤）
5.1.2 工作方式
- 身份认证：是否已经登录（会员，VIP，VVIP等权限）
- 资源审核：当前登录的用户是否有权限访问web资源，有些资源只允许VVIP的访问
- 资源加密访问：对数据进行加密，防止第三方的窃取
5.1.3 使用方式
- 假设：login.jsp登陆成功后重定向到main.jsp。有人直接将main.jsp页面地址复制，不通过login直接访问main.jsp。这不符合实际世界（相当于淘宝中不登录就购买产品），如果为登陆我们需要对main.jsp进行拦截即过滤Filter
- 自定义类实现Filter接口并重写doFilter方法。
javax.servlet.Filter
import javax.servlet.Filter;
public class LoginFilter implements Filter {
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,ServletException {
//TODO 处理逻辑，必须调用下面的方法
//相当于放行，到web服务器
chain.doFilter(request,response);
}
}
- 在web.xml文件中配置过滤器。
<filter>
<filter-name>LoginFilter</filter-name>
<filter-class>com.lagou.LoginFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>LoginFilter</filter-name>
<url-pattern>/*</url-pattern>
<!--
<url-pattern>/main.jsp</url-pattern>
只要用这种方式去请求的话就去找别名LoginFilter，
找到之后去找这个类，找到类后执行重写的doFilter方法
-->
</filter-mapping>
5.1.4 Filter接口
（1）基本概念
- javax.servlet.Filter接口主要用于描述过滤器对象，可以对资源的请求和资源的响应操作进行筛选操作。
（2）常用的方法
- init() 初始化题词，重新部署时（Redeploy）
- destroy() 销毁一次，重新部署时（Redeploy）
- doFilter() 过滤很多次，访问配置文件中设置的路径（<url-pattern>）
| 方法声明 | 功能介绍 |
|---|---|
| void init(FilterConfig filterConfig) | 实现过滤器的初始化操作 |
| void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) | 执行过滤操作的功能 |
| void destroy() | 实现过滤器的销毁操作 |
5.1.5 FilterConfig接口
（1）基本概念
- javax.servlet.FilterConfig接口主要用于描述过滤器的配置信息。
Filte接口的 init(FilterConfig filterConfig) 方法中有FilterConfig
（2）常用方法
| 方法声明 | 功能介绍 |
|---|---|
| String getFilterName() | 获取过滤器的名字 |
| String getInitParameter(String name) | 获取指定的初始化参数信息 |
| Enumeration getInitParameterNames() | 获取所有的初始化操作名称 |
| ServletContext getServletContext() | 获取ServletContext对象 |
5.1.6 多个过滤器的使用
- 第一个过滤器过滤大石头剩下的给第二个过滤器，过滤小石头剩下的交给第三个过滤器，在过滤零碎的漏网之鱼最后把沙子留下较为web服务器
- 请求和相应都过多个过滤器
- 如果有多个过滤器都满足过滤的条件，则容器依据映射的先后顺序来调用各个过滤器。
- 先后顺序由配置文件中设置filter-mapping的顺序决定，（即配置文件中映射的先后顺序有关）
5.1.7 过滤器优点
- 实现代码的“可插拔性”，即增加或减少某个功能模块，不会影响程序的正常执行。
- 可以将多个相同处理逻辑的模块集中写在过滤器里面，可实现重复利用、也方便代码的维护。
5.2 Listener监听器（重点）
5.2.1 基本概念
- Servlet规范中定义的一种特殊的组件，用来监听Servlet容器产生的事件并进行相应的处理。
- 容器产生的事件分类如下：
○ 生命周期相关的事件。（这个对象创建了，销毁了之类）
○ 属性状态相关的事件。（setAttribute，getAttribute，removeAttribute）
○ 存值状态相关的事件。（绑定Person类到Session中，解除Person类从Session中） - 底层原理是采用接口回调的方式实现。(该方法不用我们调用会自动动用，我们只要从写方法，写入配置文件就好)
5.2.2 基本分类
| 监听器类型 | 功能介绍 |
|---|---|
| javax.servlet.ServletRequestListener | 监听request作用域的创建和销毁 |
| javax.servlet.ServletRequestAttributeListener | 监听request作用域的属性状态变化 |
| javax.servlet.http.HttpSessionListener | 监听session作用域的创建和销毁 |
| javax.servlet.http.HttpSessionAttributeListener | 监听session作用域的属性状态变化 |
| javax.servlet.ServletContextListener | 监听application作用域的创建和销毁 |
| javax.servlet.ServletContextAttributeListener | 监听application作用域的属性状态变化 |
| javax.servlet.http.HttpSessionBindingListener | 监听对象与session的绑定和解除 |
| javax.servlet.http.HttpSessionActivationListener | 监听session数值的钝化和活化 |
- 钝化：序列化，即从内存写入到硬盘
- 活化：反序列化，即从硬盘到内存
5.2.3 监听器详解
（1）ServletRequestListener监听器
- 在ServletRequest创建和关闭时都会通知ServletRequestListener监听器。
- 常用方法如下：
| 方法声明 | 功能介绍 |
|---|---|
| void requestInitialized(ServletRequestEvent sre) | 实现ServletRequest对象的初始化 |
| void requestDestroyed(ServletRequestEvent sre) | 实现ServletRequest对象的销毁 |
- 配置文件
<listener>
<listener-class>com.lagou.demo03.MyRequestListener</listener-class>
</listener>
- 自动发出请求：执行两次初始化和销毁
- 手动发出请求：执行一次初始化和销毁
（2）ServletRequestAttributeListener监听器
- 向ServletRequest添加、删除或者替换一个属性的时候，将会通知
ServletRequestAttributeListener监听器。 - 常用方法如下：
| 方法声明 | 功能介绍 |
|---|---|
| void attributeAdded(ServletRequestAttributeEvent srae) | 增加属性时触发 |
| void attributeReplaced(ServletRequestAttributeEvent srae) | 修改属性时触发 |
| void attributeRemoved(ServletRequestAttributeEvent srae) | 删除属性时触发 |
- 配置文件
<listener>
<listener-class>com.lagou.demo03.MyRequestAttributeListener</listener-class>
</listener>
（3）HttpSessionListener监听器
- 当一个HttpSession刚被创建或者失效（invalidate）的时候，将会通知HttpSessionListener监听器。
- 常用方法如下：
| 方法声明 | 功能介绍 |
|---|---|
| void sessionCreated(HttpSessionEvent se) | 当一个HttpSession对象被创建时会调用这个方法 |
| void sessionDestroyed(HttpSessionEvent se) | 当一个HttpSession超时或者调用HttpSession的invalidate()方法让它销毁时，将会调用这个方法 |
- 配置文件
<listener>
<listener-class>com.lagou.demo03.MySessionListener</listener-class>
</listener>
<session-config>
<session-timeout>1</session-timeout> //session有效时间设置为1分钟
</session-config>
（4）HttpSessionAttributeListener监听器
- HttpSession中添加、删除或者替换一个属性的时候，将会通知HttpSessionAttributeListener监听器。
- 常用方法如下：
| 方法声明 | 功能介绍 |
|---|---|
| void attributeAdded(HttpSessionBindingEvent se) | 当往会话中加入一个属性的时候会调用这个方法 |
| void attributeRemoved(HttpSessionBindingEvent se) | 当从会话中删除一个属性的时候会调用这个方法 |
| void attributeReplaced(HttpSessionBindingEvent se) | 当改变会话中的属性的时候会调用这个方法 |
- 配置文件
<listener>
<listener-class>com.lagou.demo03.MySessionAttributeListener</listener-class>
</listener>
（5）ServletContextListener监听器
- 在ServletContext创建和关闭时都会通知ServletContextListener监听器。
- 随着服务器的创建而创建，随着服务器的关闭而关闭
- 常用方法如下：
| 方法声明 | 功能介绍 |
|---|---|
| void contextInitialized(ServletContextEvent sce) | 当ServletContext创建的时候，将会调用这个方法 |
| void contextDestroyed(ServletContextEvent sce) | 当ServletContext销毁的时候（例如关闭应用服务器或者重新加载应用），将会调用这个方法 |
- 配置文件
<listener>
<listener-class>com.lagou.demo03.MyContextListener</listener-class>
</listener>
（6）ServletContextAttributeListener监听器
- 向ServletContext添加、删除或者替换一个属性的时候，将会通知ServletContextAttributesListener监听器
- 常用方法如下：
| 方法声明 | 功能介绍 |
|---|---|
| void attributeAdded(ServletContextAttributeEvent scae) | 往ServletContext中加入一个属性的时候触发 |
| void attributeRemoved(ServletContextAttributeEvent scae) | 从ServletContext中删除一个属性的时候触发 |
| void attributeReplaced(ServletContextAttributeEvent scae) | 改变ServletContext中属性的时候触发 |
- 配置文件
<listener>
<listener-class>com.lagou.demo03.MyContextAttributeListener</listener-class>
</listener>
（7）HttpSessionBindingListener监听器
- HttpSession中绑定和解除绑定时，将会通知HttpSessionListener监听器。
- Person类和Session产生关联时，触发HttpSessionBindingListener监听器，也就是Person类要和HttpSessionBindingListener监听器有关联，即Person类实现HttpSessionBindingListener接口
- 常用方法如下：
| 方法声明 | 功能介绍 |
|---|---|
| void valueBound(HttpSessionBindingEvent event) | 有对象绑定时调用该方法 |
| void valueUnbound(HttpSessionBindingEvent event) | 有对象解除绑定时调用该方法 |
- 这个监听器不需要配置
因为：当Person类的对象与Session建立关系时触发Person类中实现的接口，去调用实现的接口中的方法，就不需要单独配置了
（8）HttpSessionActivationListener监听器
- 当有session数值的钝化和活化操作时，将会通知HttpSessionActivationListener监听器。
- Student类实现该接口，并且Session中存在Student对象，这是Student对象还在内存中，服务器停止时，会执行钝化操作，Student从内存导入硬盘了，在哪儿呢？Tomcat的临时路径 > Using CATALINA_BASE: “C:\Users\kimyu\AppData\Local\JetBrains\IntelliJIdea2020.2\tomcat\Tomcat_8_5_55_javaweb_12” > work > Catalina > localhost > task05_demo03 > SESSIONS.ser (SESSIONS.ser 在这个里面) 。这仅仅是钝化操作，启动服务器，看不到活化，看看SESSIONS.ser 还在不在，没有了，重新启动服务器时IDEA做了一件事，将work目录里的内容删掉重新生成。我们需要将存储SESSIONS.ser的目录改一下，通过配置文件改，下面有。
- 测试时不要设置自动访问
- 常用方法如下：
| 方法声明 | 功能介绍 |
|---|---|
| void sessionWillPassivate(HttpSessionEvent se) | 有钝化操作时调用该方法 |
| void sessionDidActivate(HttpSessionEvent se) | 有活化操作时调用该方法 |
- 配置context.xml文件的方式如下：
context.xml位置：C:\apache-tomcat-8.5.55\conf > context.xml
若无C:\session文件手动创建
<Manager className="org.apache.catalina.session.PersistentManager" saveOnRestart="true">
<!-- 配置文件存放的路径信息，可以自由指定 -->
<Store className="org.apache.catalina.session.FileStore" directory="C:\session"/>
</Manager>
5.2.4 实战案例
-
自定义类实现监听器接口并重写相关的方法。
-
实现HttpSessionListener，HttpSessionListener接口的目的
实现监听会话的创建和销毁
实现监听ServletContext的创建和销毁
由于浏览器向服务器发出一个请求之后服务器就会创建一个Session对象，本质上在内存中申请一块空间，把Session信息已cookie的方式发给浏览器，即只要有一个浏览器访问我们的服务器的时候就会创建一个Session，有多少个浏览器访问服务器就会有多少个Session，一个浏览器代表一个用户，那么多少个Session就代表多少个用户。监听session的创建和销毁，即在线用户的增加和减少。但无论增加或减少都要保存到ServletContext里，因为一个web项目对应唯一的一个对象，用它记录在线用户因为项目是唯一的记录出来的值也是唯一的
public class OnlineUser implements HttpSessionListener,ServletContextListener {
ServletContext ctx = null;
// 初始化ServletContext
public void contextInitialized(ServletContextEvent e) {
ctx = e.getServletContext();
}
// 销毁ServletContext
public void contextDestroyed(ServletContextEvent e) {
//将ServletContext设置成null;
}
// 当新创建一个HttpSession对象时
public void sessionCreated(HttpSessionEvent e) {
//将当前的在线人数加上1，并且保存到ServletContext(application)中
}
// 当一个HttpSession被销毁时（过期或者调用了invalidate()方法）
public void sessionDestroyed(HttpSessionEvent e) {
//将当前人数减去1，并且保存到ServletContext(application)中
}
}
- 在web.xml中配置监听器
<listener>
<listener-class> com.lagou.listener.OnlineUser </listener-class>
</listener>
5.3 总结
-
Filter过滤器
基本概念，工作方式，使用方式，Filter接口，FilterConfig接口，多个过滤器的使用，优点 -
Listener监听器
基本概念，基本分类，实战案例
第六章 Linux系统概述和编程基础
6.1 Linux系统概述（常识）
6.1.1 计算机的体系结构
- 计算机由计算机硬件和计算机软件两个部分组成，其中计算机软件(Computer Software)可分为系统软件和应用软件，系统软件就是操作系统，是其他软件的基础。
- 目前主流的操作系统有：Windows系列、Unix系列、Linux系列、Android系列、IOS系列、…
6.1.2 Linux系统的概述
- Linux系统诞生于1991年，在林纳斯·托瓦兹（Linus Torvalds）上大学期间因不满意教学中使用的MINIX操作系统并出于个人爱好设计和研发的。
- Linux系统是一套免费、自由、开发源代码的类Unix操作系统，是一个基于Posix(Portable Operating System Interface)标准和多用户、多任务、支持多线程的操作系统。
- Linux能运行主要的Unix工具软件、应用程序和网络协议，支持32位和64位硬件。
6.1.3 主要发行版本
- Redhat：目前最大的Linux发行商，功能全面并且稳定，于2018年10月被IBM以340亿美元的价格收购。
- Ubuntu：目前最好的Linux桌面版，拥有很人性化的亮丽的交互界面，强大的软件源支持。
- CentOS：是RHEL的克隆版本，可以认为是免费版本的Redhat系统。
6.2 CentOS系统安装（掌握）
6.2.1 Vmware的下载和安装
- CentOS的虚拟机
- 下载地址：https://www.vmware.com/cn.html
- 按照安装教程一步步操作即可。
6.2.2 CentOS系统的下载和安装
- 下载地址：https://www.centos.org/
- 按照安装教程通过Vmware软件进行CentOS系统的安装。。
- C:\Download\CentOS-7-x86_64-DVD-1503-01.iso
- linux：lagou
- 用户名：stone
- 密码：stone
- 安装位置：C:\Users\kimyu\Documents\Virtual Machines\CentOS 7 64 位
6.3 目录结构（熟悉）
6.3.1 框架结构
6.3.2 目录详解
| 目录名称 | 功能介绍 |
|---|---|
| / | 跟目录 |
| ~ | 主目录 (当前用户所在的主目录，即/home)(因为Linux支持多用户的，可以开很多用户，防止这些用户之前起冲突，给每个用户分配了主目录/home，即分配了一个地盘，可以在自己的地盘上胡作非为，敌人的地盘就不能踩过去没有权限，防止了互相影响你把我的文件删了我把你的文件删了) |
| /bin | binarie:存放二进制可执行文件 (例如tomcat的bin目录) |
| /sbin | super binaries:存放二进制文件,只有root用户才能访问 |
| /boot | 系统启动核心目录,存放系统启动程序文件，例:查看启动文件的大小 |
| /dev | devices:用于存放硬件设备文件 |
| /etc | etcetera:存放系统配置文件(字体文件等) |
| /home | 家目录,每一个用户都有一个”家”，用户的起始目录,创建用户跟随创建相应的家目录 |
| /lib | library:系统资源文件类库 |
| /proc | 内存映射目录,可以查看系统相关硬件的信息 |
| /var | variable:可变的,变量. 部署项目用的 |
| /tmp | temporary:用来存放临时文件 |
| /root | 超级用户root的家目录 |
| /usr | unix shared resouce: 存放unix共享系统资源，类似于” C:/ Program Files”,用于安装各种软件 |
6.4 常用命令（重点）
6.4.1 Shell的概念
- Shell俗称外壳，是提供用户使用界面的一种软件，叫做命令解释器。
（Terminal） - 主要负责接受用户输入的命令，然后调用相应的应用程序，最后向用户输出程序运行的结果。
（我们输入命令，shell传递到计算机内核，内核通过硬件，通过操作系统之类的实现我们想要的功能，在通过Terminal窗口显示出来）
6.4.2 命令的格式
- 命令 [-选项] [参数]
- 命令区分大小写，其中选项和参数是可选的，中间采用空格隔开。
6.4.3 常用命令的详解
（1）查看目录下文件/目录
| 命令 | 功能描述 |
|---|---|
| ls | list显示文件 |
| ls -l 或 ll | list -list显示详细信息 |
| ls -a | list -all显示全部(包含隐藏文件)文件 |
| ls -al | list -all list 上两个合体 |
| ls 目录名 | 查看目录下有什么东西 |
. : 当前目录
… : 上一级目录
（2）目录切换
| 命令 | 功能描述 |
|---|---|
| cd … | 上一级目录 |
| cd dirname | 进入目录 |
| cd 或 cd ~ | 直接回到用户的家目录 |
| cd / | 回到系统根目录 |
- 相对路径和绝对路径的概念。
（3）查看完整路径
| 命令 | 功能描述 |
|---|---|
| pwd | 查看当前目录所在的位置 print work directory |
（4）查看当前用户
| 命令 | 功能描述 |
|---|---|
| whoami | 查看当前用户的名称 |
- 除了我至少还有一个root用户超级用户
- root用户的密码默认和创建次虚拟机的用户的密码一致stone
（5）用户切换
| 命令 | 功能描述 |
|---|---|
| su | 普通用户切换到root用户 switch user |
| su root | 切换到root用户 |
| su 用户名 | 切换到普通用户 |
| exit | 退回到原来用户 |
- root@localhost stone]# 表示从stone用户切换到root用户
- 最好使用su和exit搭配使用，否则多次使用su指令会导致用户的”叠加”。
（6）管理用户
| 命令 | 功能描述 |
|---|---|
| useradd xxx | 创建用户 |
| passwd xxx | 为创建的用户设置密码 |
| userdel xxx | 删除用户，userdel -r xxx 主目录也一起删掉 |
- root用户下执行（超级管理官创建用户，不能让一个用户创建新用户）
（7）查看命令的所在目录
| 命令 | 功能描述 |
|---|---|
| which 命令 | 查看指定命令所在的路径信息 |
（8）文件操作
| 命令 | 功能描述 |
|---|---|
| touch fileName | 创建名字为fileName的文件 |
| touch dir/fileName | 在dir目录下创建名字为fileName的文件 |
| echo 内容 > fileName | 把内容覆盖写到文件中，若文件不存在则创建 |
| echo 内容 >> fileName | 把内容追加到文件中 |
| cat fileName | 打印文件内容到终端 |
| more fileName | 分屏查看文件各行内容，不支持回看， enter一行一行，spacebar一页一页，q退出 |
| less fileName | 查看文件各部分内容，支持回看 使用上下左右键查看，q退出 |
| head -n fileName | 查看文件的前n行内容 |
| tail -n fileName | 查看文件末尾n行内容 |
| wc fileName | 查看文件的行数 |
- echo：回显
echo hello 就会显示 hello - >：重定向
echo hello > a.txt 表示hello这个字符串重定向到a.txt文件中，即写入（覆盖的形式） - >>：追加
echo hello > a.txt 表示在后面写入，即追加 - more：分屏幕查看
- less：分段查看，分各个部分查看
（9）目录操作
| 命令 | 功能描述 |
|---|---|
| mkdir 目录名 | 创建普通文件夹 |
| mkdir -p 目录/目录/目录 | 递归方式创建多级父子文件夹 |
| mv dir1 dir2 | 将dir1移动到dir2中 |
| mv dir1/dir2 ./ | 将dir1中dir2移动到当前目录下 |
| mv dir1 name | 将dir1改名为name |
| cp dir1 name | 将dir1拷贝为name（拷贝文件） |
| cp -r dir1 dir2 | 需要设置参数 -r (recursive递归) 无视目录层次（拷贝目录） |
| rm 文件 | 删除文件 |
| rm -r 目录 | 递归删除目录(无视目录层次) |
| rm -rf 文件/目录 | -r force(强制) 删除文件/目录 |
（10）查找操作
| 命令 | 功能描述 |
|---|---|
| find / -name passwd[完整名称] | 查找passwd文件 |
| find ./ -name “p*” | 查找带”p”的文件 |
| find ./ -type f | 查找所有文件 |
| grep 内容 fileName | 从指定文件中查找指定的内容 |
- 文件：file f
- 目录：directory d
- grep：正则表达式
（11）权限管理
| 命令 | 功能描述 |
|---|---|
| chmod 权限 文件/目录名 | 管理指定文件的权限信息，r读:4 w写:2 x执行:1 |
chmod u+x b.txt
chmod g+x b.txt
chmod o+wx b.txt
chmod o-wx b.txt
chmod 664 b.txt
chmod 777 b.txt
- 4+2=6 4+2+1=7
（12）进程管理
| 命令 | 功能描述 |
|---|---|
| ps | 查看当前终端窗口里的进程 |
| ps -aux | 查看系统中的所有进程 |
| ps -ef | 查看进程列表 |
| kill 进程号 | 杀死指定的进程 |
| kill -9 进程号 | 强制杀死指定的进程 |
- PID：进程编号
- TTY：终端
- TIME：时间
- CMD：命令
- |：想象成管道，前后命令接起来 ps -aux | more
- USER：所属用户
- COMMAND：具体的命令和名字是什么
- PPID：parent process id 父进程编号
（13）其它命令
| 命令 | 功能描述 |
|---|---|
| ifconfig | 查看当前系统的IP地址等信息 |
| tar -zcvf 压缩文件名.tar.gz 路径1 路径2 … | 实现一组文件或文件夹的打包 |
| tar -zxvf 压缩文件名.tar.gz | 实现解压缩解包 |
| man [章节号] 命令/函数名 | 查询指定的命令或函数 |
- ipconfig：window
6.5 vi工具的使用（重点）
6.5.1 基本概念
- vi和vim是Linux系统命令行下的文本编辑器，通常格式为：vi 文件名 或 vim 文件名。
6.5.2 三种模式
6.5.3 使用方式
（1）命令模式的编辑命令
i：在当前位置之前插入 （光标位置不变）
a：在当前位置之后插入 （光标往后移一个）
o：在当前行下插入 （跑到下一行）
（2）命令行模式的删除命令
x 删除一个字符
dw 删除当前词
3dw 删除三个词
dd 删除当前行
5dd 删除五行
（3）命令行模式的修改命令
r 替换一个字符
cw 替换一个单词
cc 替换一行
C 替换从光标至行尾
（4）命令行模式的拷贝命令
yw 拷贝词
yy 拷贝行(或Y)
dd 剪切行
p 当前行下粘贴
u 撤销
ctrl+r 取消撤销
（5）底行模式的命令
:w 存盘
:w newfile 存成新文件
:wq 存盘退出Vi(或ZZ，或:x)
:q! 强行退出不存盘
:1,2co3 拷贝行1，行2在行3之后
:4,5mo6 移动行4，行5在行6之后
:%s /源字符串/目标字符串
:%s /源字符串/目标字符串/g 替换每一行中的所有
（6）注意使用
- 使用vimtutor 命令用来练习vi命令。
- 用户主目录下.vimrc文件可以实现vi的简单设置。
6.6 总结
- Linux系统概述和编程基础
计算机的体系结构，Linux系统的由来，虚拟机软件和系统的安装，目录结构，常用的命令，vi工具的使用
第七章 开发环境搭建和Shell编程
7.1 开发环境搭建（掌握）
7.1.1 Xshell和Xftp工具
- Xshell ：远程访问服务器
- Xftp ：文件传输协议 当前本机和服务器之间的文件传输
（1）下载和安装方式
- 下载地址：https://www.netsarang.com/zh/
- 安装方式：直接一路点击下一步即可，安装过程选择免费版。
（2）使用方式
- 主机：要远程访问的主机IP地址（虚拟机的IP地址）
需要给虚拟机配置IP地址下面有
确定后弹出SSH用户名：请输入登陆的用户名：stone
稍等一会会弹出输入密码的框，输入密码
Connecting to 192.168.8.128:22…
Connection established.
ls以下试试，可以看到和虚拟机上ls一样
（3）网络模式设置
- 设置网络连接模式为NAT模式，如下图：
VMare > 虚拟机 > 设置 > 网络适配器：NAT
（4）修改配置文件
- 使用root用户打开/etc/sysconfig/network-scripts/ifcfg-eno16777736文件，添加内容如下：（虚拟机配置IP地址）
BOOTPROTO=static
ONBOOT=yes
IPADDR=192.168.8.128 //IP地址
GATEWAY=192.168.8.2 //网关
NETMASK=255.255.255.0 //子网掩码
DNS1=114.114.114.114
- VMare > 编辑 > 虚拟网络编辑器 > 选择NAT模式 > 选项为默认情况下点击NAT设置 > 获取以下信息
子网掩码：255.255.255.0
网关IP(G)：192.168.8.2 - VMare > 编辑 > 虚拟网络编辑器 > 选择NAT模式 > 选项为默认情况下点击DHCP设置 > 获取以下信息
起始IP地址(S)：192.168.2.128
结束IP地址(E)：192.168.2.254
（5）配置文件生效
使用命令使得配置文件生效：service network restart
7.1.2 JDK的下载和安装
（1）下载和安装方式
- 下载地址：https://www.oracle.com/java/technologies/javase-downloads.html
- jdk安装包名：jdk-11.0.7_linux-x64_bin.tar.gz
- 安装方式：将下载好的jdk安装包通过Xftp工具传输到CentOS系统中，使用tar命令解压即可。
- 通过Xftp工具传输到CentOS系统中
Xshell > icon中的New File Transfer(即启动Xftp) > 先安装Xftp > 左边我们的系统，右边远程访问的虚拟机系统 > 左边找到jdk安装包 双击就传过去了 - tar -zxvf 压缩文件名.tar.gz
- 移动 解压获得目录（解压获得目录就是JDK）到 /user
需要管理员权限 root
mv jdk-11.0.7 /usr/
cd /usr/
mv jdk-11.0.7/ javajdk 改名字
（2）配置环境变量
- 获取JDK路径
cd /usr/javajdk - 使用root用户打开配置文件/etc/profile，向文件末尾追加内容如下：
vi /etc/profile
到文件的最下面，输入o，进入编辑模式，写入下面两行代码
- export：导入
- JAVA_HOME：变量
- $JAVA_HOME：把JAVA_HOME的值拿出来
- ：：路径分隔符
export JAVA_HOME=/usr/javajdk
export PATH=$JAVA_HOME/bin:$PATH
- 保存退出后让文件生效并验证是否配置成功
:wq
source /etc/profile 表示让这个配置文件立即生效
javac 测试是否成功，打出一堆东西表示成功
javac -version javac 版本
7.1.3 Tomcat的下载和安装
（1）下载和安装方式
- 下载地址：https://tomcat.apache.org/download-80.cgi
- 安装方式：将下载好的Tomcat安装包通过Xftp工具传输到CentOS系统中，使用tar命令解压即可。
（2）启动和关闭方式
cd /usr/tomcat/bin
./startup.sh 回车运行 打印一句话Tomcat started.
./shutdown.sh 回车关闭
- 浏览器 http://192.168.8.128:8080/ 测试Tomcat启动。
打不通是因为防火墙
（3）开放防火墙端口
/sbin/iptables -I INPUT -p tcp --dport 8080 -j ACCEPT 开启8080端口（暂时开通，重启系统就没了）
（4）配置环境变量 不作
- Linux系统下一律不作Tomcat的环境变量的配置，以后搭建集群时如果配置了环境变量我们任意目录下都用同一个Tomcat，集群就不好搭建了
- 使用root用户打开配置文件/etc/profile，向文件末尾追加内容。
export CATALINA_HOME=/usr/tomcat
export PATH=$CATALINA_HOME/bin:$PATH
- 保存退出后让文件生效并验证是否配置成功
source /etc/profile
startup.sh
（5）发布Web项目
- 将Web项目打成war包，通过Xftp工具将war包放在tomcat/webapp目录并启动
7.1.4 Mysql的下载和安装
- 在线安装
（1）下载Mysql的repo源
wget：下载
repo源：安装Mysql步骤的快照
wget http://dev.mysql.com/get/mysql57-community-release-el7-8.noarch.rpm
（2）安装rpm包
解析快照文件 （community：免费版）
rpm -ivh mysql57-community-release-el7-8.noarch.rpm
集成在快照里面
（3）安装Mysql
yum：智能安装（安装包的管理器工具）
yum install mysql-server
y
y
y
rpm：类似手机上的应用商店，软件包的管理工具，通过他可以实现软件的自动安装
下面代码表示通过rpm查看里面的软件管理工具所安装的所有的软件信息或者包信息，grep(查找) mysql
rpm -qa | grept mysql
（4）启动服务
service mysqld start
显示一下信息，启动成功
Redirecting to /bin/systemctl start mysqld.service
（5）查看服务状态
自动安装时，配置了一个随机的密码，查找密码
grep password /var/log/mysqld.log
systemctl status mysqld
（6）使用root用户登录
mysql -u root
（7）修改临时密码
alter user 'root'@'localhost' identified by 'StOne@222';
7.1.5 图形化界面访问数据库
（1）使用SQLyog工具
- 启动图形化界面工具SQLyog连接虚拟机中Mysql数据库，如下图：
（2）解决方案
- 使用root权限登录数据库后选择mysql库
mysql -u root -p
use mysql;
- 查看mysql库中的user表的host值后修改为通配符%
select user,host from user;
select host from user where user='root';
update user set host='%' where user='root';
flush privileges;
- 查看修改结果并重新测试
select user,host from user;
- 失败 2003错误
放开3306端口，在根目录下
/sbin/iptables -I INPUT -p tcp --dport 3306 -j ACCEPT
重启生效
service iptables restart
7.2 Shell编程（熟悉）
7.2.1 基本概念
- Shell是一个命令行解释器，可以接收应用程序或用户命令，然后访问操作系统内核。
- Shell是一个功能相当强大的编程语言，易编写、易调试、灵活性强；
7.2.2 编写第一个程序
- 使用vi工具创建xxx.sh的文件。
- 以#!/bin/bash开头并编写代码后保存。
#!/bin/bash 固定搭配，在shell程序中表示一会儿使用/根目录下的bin目录下有个bash的工具来解释执行这个脚本
7.2.3 执行Shell程序的方式
- 方式一：./文件名，此方式需要执行权限。
ll 查看hello.sh 文件 -rw-rw-r–. 没有权限 - 方式二：
/bin/bash 文件名，此方式不需要执行权限。
bash 文件名，省略了/bin路径信息 环境变量的配置
sh 文件名，sh就是bash的简写
7.2.4 变量的定义
（1）语法格式
- 定义变量：变量=值
- 撤销变量：unset 变量
- 获取变量值：$变量名
（2）定义规则
- 变量名称可以由字母、数字和下划线组成，但是不能以数字开头，环境变量名建议大写。
- 不能使用bash里的关键字。
- 中间不能有空格，可以有下划线。
- 在bash中，变量默认类型都是字符串类型，无法直接进行数值运算。
- 变量的值如果有空格，需要使用双引号或单引号括起来。
双引号另外一个功能：“abc$变量名” 可以获取变量值
7.2.5 常用运算符
（1）算术运算符
| 运算符 | 说明 | 举例 |
|---|---|---|
| + | 加法 | `expr $a + $b` 结果为 30。 |
| - | 减法 | `expr $a - $b` 结果为 -10。 |
| * | 乘法 | `expr $a * $b` 结果为 200。 |
| / | 除法 | `expr $b / $a` 结果为 2。 |
| % | 取余 | `expr $b % $a` 结果为 0。 |
| = | 赋值 | `a=$b` 将把变量b的值赋给a。 |
| == | 相等。用于比较两个数字，相同则返回true。 | `[ $a == $b ]` 返回 false。 |
| != | 不相等。用于比较两个数字，不相同则返回true。 | `[ $a != $b ]` 返回 true |
#!/bin/bash
#定义两个变量
ia=5
ib=2
#打印两个变量的数值
echo "ia=$ia"
echo "ib=$ib"
#实现加法运算，要求+两边必须有空格
echo `expr $ia + $ib`
#使用其他方法实现加法运算
ic=$[$ia+$ib]
echo $ic
id=$(($ia+$ib))
echo $id
-----------------------------sh arithmetic.sh
ia=5
ib=2
7
7
7
（2）关系运算符
| 运算符 | 说明 | 英文 | 举例 |
|---|---|---|---|
| -eq | 检测两个数是否相等，相等返回 true。 | equal | `$a -eq $b` 返回false |
| -ne | 检测两个数是否不相等，不相等返回 true。 | not equal | `$a -ne $b` 返回true |
| -gt | 检测左边的数是否大于右边的，如果是，则返回 true。 | greater than | `$a -gt $b` 返回false |
| -lt | 检测左边的数是否小于右边的，如果是，则返回 true。 | less than | `$a -lt $b` 返回true |
| -ge | 检测左边的数是否大于等于右边的，如果是，则返回true。 | greater than or equal to | `$a -ge $b` 返回fasle |
| -le | 检测左边的数是否小于等于右边的，如果是，则返回 true。 | less than or equal to | `$a -le $b` 返回 true |
7.2.6 流程控制语句
（1）if判断
if [ 条件判断式 ]
then
程序
fi
#!/bin/bash
#定义一个变量用于描述考试成绩
score=60
echo $score
#使用if判断给出及格或者不及格的提示信息
if [ $score -gt 60 ]
then
echo "恭喜考试通过了！"
elif [ $score -eq 60 ]
then
echo "60分万岁，对一份浪费！"
else
echo "下学期再来吧！"
fi
（2）case语句
case $变量名 in
"值1"）
如果变量的值等于值1，则执行程序1
;;
"值2"）
如果变量的值等于值2，则执行程序2
;;
…省略其他分支…
*）
如果变量的值都不是以上的值，则执行此程序
;;
esac
#!/bin/bash
#提示用户输入1~4之间的整数并记录到变量中
echo "请输入0~4之间的整数："
read num #表示读取一个整数放到变量num中
#使用case语句进行批评和打印
case $num in
1) echo "你选择了1号业务！"
;;
2) echo "你选择了2号业务！"
;;
3) echo "你选择了3号业务！"
;;
4) echo "你选择了4号业务！"
;;
*) echo "你没有选择1~4号之间的业务，你想干啥？"
;;
esac
（3）for循环
for (( 初始值;循环控制条件;变量变化 ))
do
程序
done
#!/bin/bash
#定义一个变量负责记录累加和
sum=0
#使用for循环计算1~100之间的累加并记录到上述变量中
for(( i=1;i<=100;i++ ))
do
sum=$[$sum+$i]
done
#答应变量的数值
echo $sum
（4）while循环
- 在控制台结束死循环 ctrl+c
while [ 条件判断式 ]
do
程序
done
#!/bin/bash
#使用while循环实现1~100之间的累加和
#定义两个变量分别记录累加和与初始值
sum=0
i=1
#使用while循环
while [ $i -le 100 ]
do
sum=$[$sum+1]
i=$[$i+1]
done
#打印结果
echo $sum
7.2.7 函数
- 这里的 [ ] 里的可以省略
[ function ] funname[()]
{
Action;
[return int;]
}
funname
#!/bin/bash
#定义一个函数负责计算两个输入数据的和并答应
function sum()
{
s=$[$1+$2]
echo $s
}
#提示用户从键盘输入两个数据
read -p "input num1:" num1
read -p "input num2:" num2
#调用函数
sum $num1 $num2
7.3 总结
- 开发环境的搭建和Shell编程
Xshell和Xftp工具的下载和安装，配置网络换将，JDK的下载和安装和配置环境变量，Tomcat的下载和安装，MySQL数据库的在线下载和安装，Shell编程的概念，变量的定义，运算符，流程控制语句，函数
第四阶段模块二作业
编程题
-
使用 EL+JSTL 表达式、过滤器和监听器对第四阶段模块一的作业进行技术升级，
-
使用 Cookie 实现一周内免登录，
-
再增加班级管理功能：创建班级、修改班级信息、删除班级（前提：保证班级内没有关联学生）、查询班级， 此时需要为学生表增加字段：所属班级编号。
-
其中班级信息有：班级名称、年级、班主任名称、班级口号 、班级人数
-
要求： a.将项目部署到 Linux 系统中并通过本地浏览器能正常访问。
作业说明：
1、提供可运行的编程代码和sql脚本，代码记得要加注释，方便导师能通过浏览代码明白你的程序执行流程；
2、提供程序运行和讲解的视频（程序运行包含：按照作业要求体现程序执行结果；讲解内容包含：题目分析、实现思路、代码讲解。）
3、当前模块学习过程中的笔记，可以以文档、照片、思维导图的形式提供；
4、本次作业的内容，分三个文件夹，code（每个题单独一个文件夹）、运行视频、学习笔记；
list为原先的总集合，newlist为获取特定区域后集合，pageindex表示选择的特定页码数据，每页十条
if(pageIndex*10>list.size()){newlist=list.subList((pageIndex-1)*10, list.size());
}else{
newlist=list.subList((pageIndex-1)*10, pageIndex*10);
}
注意newList虽然为新的集合但是修改newList中的数据，list中的数据同样改变
String module = (String) getServletConfig().getServletContext().getAttribute("module");