web服务器通常只能处理静态的资源(html , css ， js ……) , 为了解决动态的处理数据，就需要对 web服务器的功能进行扩展，servlet 就是用于处理
动态数据的组件规范。
组件：符合一个规范，完成部分功能的软件模块。比如java中的servlet , jsp都属于组件。这些软
件模块需要放在容器中运行。比如tomcat就属于容器。
因此。 servlet ,jsp 都需要放在tomcat容器中去允许。
容器：符合一定规范，能够运行组件的一种软件。比如： tomcat , jetty , JBoss…..
Servlet规范：使用servlet 的时候，自定义类继承 HttpServlet , 重新service方法，那么就符合
Servlet规范。

Servlet的开发步骤

新建的工程是一个
java web
项目（
maven
中的
web app
）

Servlet
类
，基础
HttpServlet

重写 service方法
service(HttpServletRequest request , HttpServletResponse response)
request : 请求
response : 响应

java web
工程中的
web.xml
文件

web.xml文件名字不能修改。（tomcat容器找web.xml文件）
将java类和浏览器访问的地址做一个映射(mapping)
浏览器没办法直接访问java类中的方法，所以需要对java类映射为一个浏览器能够访问的url
地址。

打包
(idea
帮助完成
)

把web项目运行需要的文件按指定的文件结构保存

部署
(
在
idea
中可以完成
)

把打包好的web程序放到tomcat的过程，就称为部署。

启动容器

容器启动之后，就可以通过浏览器，访问这个java web 项目了。

servlet & servlet的配置

servlet

public class BMIServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req,
HttpServletResponse resp) throws
ServletException, IOException {
// 1. 设置编码
resp.setContentType("text/html;charset=utf-8");
req.setCharacterEncoding("utf-8");
// 2. 获取参数: -- url：
// http://localhost:8080/bmi?tz=60&sg=1.7
// ? key=value & key1+value1 , &用于分隔参数
String tz = req.getParameter("tz");
String sg = req.getParameter("sg");
// 3. 处理数据
double tz1 = Double.valueOf(tz);
double sg1 = Double.valueOf(sg);
double bmi = tz1 / (sg1 * sg1);
// 4. 响应结果
PrintWriter writer = resp.getWriter();
String str = "";
if(bmi < 18){
str = "太瘦了";
}else if(bmi < 24){
str="标准身材";
}else if(bmi < 28){
str="超重了";
}else {
str="肥胖状态。";
}
writer.println("你的bmi是：" + bmi + "\n");
writer.println("<b style='color:red'>"+str+"</b>");
}
}

web.xml中对servlet配置

<servlet>
<servlet-name>bmi</servlet-name>
<servlet-class>action.BMIServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>bmi</servlet-name>
<url-pattern>/bmi</url-pattern>
</servlet-mapping

html界面

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<!-- 绝对路径 ：/开始的路径都是绝对路径。在这个绝对路径之前，只拼接：
http://localhost:8080/绝对路径
<form action="/bmi" method="get"> --- http://localhost:8080/bmi （错误路径）
相对路径： 不是/开始的路径，都是相对路径。 根据当前路径， 拼接你的相对路径。
<form action="bmi" method="get"> -- 当前路径：
http://localhost:8080/web01/bmi.html
-- 拼接路径：
http://localhost:8080/web01/bmi
-->
<form action="bmi" method="get">
<label>请输入体重:</label>
<input type="text" name="tz">
<br>
<label>请输入身高：</label>
<input type="text" name="sg">
<br>
<input type="submit" value="计算bmi">
</form>
</body>
</html>

访问方式：

先访问
html
页面，输入数据：

http://localhost:8080/web01/bmi.html

然后通过表单提交访问：
http://localhost:8080/web01/bmi?tz=60&sg=1.7

接收前端提交的数据

request.getParameter(key) ，获取请求参数。
getParameter(key) 的返回值是String ，使用的时候，需要注意数据类型的转换问题。
如果前端没有传入某个参数，使用getParameter(key) ，那么返回值是null.

响应结果

通过response对象的 getWriter()方法，得到输出流
通过输出流，输出字符串内容，作为响应结果
设置响应结果的类型和字符编码方式：
response.setContentType(“text/html;charset=utf-8”);

1. text/html ,
这个是浏览器能解析的
html
格式

2. application/json,
这个是浏览器能解析的
json
格式
(
后面会使用
)

3.
如果格式写错，浏览器不能解析，就会提示你下载。

比如
test/html
，就是浏览器不认识的格式，就会提示下载这个响应结果。

http协议 & servlet 的运行

http协议

1.
通信方式

建立连接
发送请求（请求数据包）
发送响应（响应数据包）
断开连接

2.
数据包格式

请求数据包
响应数据包

3.
请求方式

get

请求参数在url地址后显示
数据量比较小
不安全
不支持文件上传
get请求： ① 浏览器地址栏直接访问， ② form的method设置为get , ③ 超链接，④ 异步请求的时候，设置为get.

post

数据放在消息体中的
数据量大
相对安全
支持文件上传
post请求： ① form的method设置为post , ② 异步请求的时候，设置为post

put

servlet的地址的设置

java

// 介绍 servlet的路径配置
public class UrlPatternServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// 1. 设置编码
resp.setContentType("text/html;charset=utf-8");
req.setCharacterEncoding("utf-8");
// 2. 获取请求参数
// 3. 获取请求的url地址
// -- ContextPath : 应用程序的访问路径(Application Context) .
String contextPath = req.getContextPath();
// -- ServletPath : 访问servlet的 路径 （配置的servlet的url）
String servletPath = req.getServletPath();
System.out.println("contextPath:" + contextPath);
System.out.println("servletPath:" + servletPath);
if(servletPath.equals("/add.do")){
System.out.println("增加的业务功能");
}else if(servletPath.equals("/update.do")){
System.out.println("修改的业务功能");
}else if(servletPath.equals("/delete.do")){
System.out.println("删除的业务功能");
}else if(servletPath.equals("/list.do")){
System.out.println("查询的业务");
}else{
System.out.println("请求地址错误。不支持这个操作");
}
// 4. 数据处理
// 5. 响应结果
PrintWriter writer = resp.getWriter();
writer.println("你的访问路径：" + servletPath);
writer.println("\n 当前被访问的类：UrlPatternServlet");
}
}

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<servlet>
<servlet-name>urlp</servlet-name>
<servlet-class>action.UrlPatternServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>urlp</servlet-name>
<!--
测试地址是否符合要求 ， 静态资源是否被拦截。
*** 当浏览器发送请求的时候， tomcat 通过web.xml文件， 优先 访问servlet ，
找到servlet类，就访问其service方法。
如果没有servlet ,就 找静态资源， 如果找不到静态资源， 就响应404 .
*** tomcat ，优先精确匹配 ， 如果没有精确的地址，就模糊匹配 ， 没有模糊匹配，
就找静态资源， 都没有，最后404.
*** web.xml中配置servlet的url地址的时候， 尽量避免特殊后缀名： 比如 .jsp ,
.html , .js ,.css
① / , 模糊匹配 ， 除了jsp之外，其他都会被servlet匹配到。 ： <urlpattern>/</url-pattern>
② /* , 模糊匹配， 所有地址都会被匹配到。 ： <url-pattern>/*</urlpattern>
③ *.xx , 模糊匹配，以某个固定后缀名结尾的地址 ， 按后缀名进行匹配。 <urlpattern>*.do</url-pattern>
④ /xx , 精确地址, <url-pattern>/mm</url-pattern> 说明访问地址，固定
为/mm.
⑤ /xx.yy , 精确地址, <url-pattern>/mm.do</url-pattern> ,访问地址固定
为： /mm.do
⑥ xx ， 错误 。 java.lang.IllegalArgumentException: servlet映射中的
<url pattern>[mm]无效
⑦ /*.xx ,错误 java.lang.IllegalArgumentException: servlet映射中的<url
pattern>[/*.xx]无效
⑧ xx.yy ,错误 ， java.lang.IllegalArgumentException: servlet映射中的
<url pattern>[aa.do]无效
-->
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>

servlet的生命周期

servlet类的各种方法

public class LifeServlet extends HttpServlet {
public LifeServlet(){
System.out.println("构造函数被执行........");
}
@Override
public void init() throws ServletException {
System.out.println("初始化方法init ......");
}
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
System.out.println("业务方法service....... ");
}
@Override
public void destroy() {
System.out.println("销毁方法destroy ......");
}
}

容器启动的时候，或者第一次访问
servlet
的时候，会执行
init
方法，一个生命周期之内只执行一

次。

servlet
被访问的时候，反复执行
service(doXX)
方法。

容器结束运行的时候，执行
destroy
方法，一个生命周期之内只执行一次。

servlet的参数

servlet级别的参数

@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
System.out.println("业务方法service....... ");
// --从web.xml中，找到servlet的配置中的参数， 根据参数的名字，获取参数的值。
System.out.println(this.getInitParameter("user"));
System.out.println(this.getInitParameter("pwd"));
}

<servlet>
<servlet-name>life</servlet-name>
<servlet-class>action.LifeServlet</servlet-class>
<!-- 初始化参数的配置： 在servlet标签内部配置的初始化参数，只能在当前servlet中使用--
>
<init-param>
<param-name>user</param-name>
<param-value>alice</param-value>
</init-param>
<init-param>
<param-name>pwd</param-name>
<param-value>123456</param-value>
</init-param>
<!-- tomcat容器启动的时候，就初始化servlet ，调用init方法。
数据值越小， 这里优先级越高。
.-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>life</servlet-name>
<url-pattern>/life.do</url-pattern>
</servlet-mapping>

context级别的参数

<!-- 全局参数（context）： 当前项目中的servlet都可以使用这个数据。-->
<context-param>
<param-name>count</param-name>
<param-value>1000</param-value>
</context-param>

@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// -- 从web.xml中， 找到context-param中配置的参数 ，从servletContext中获取
ServletContext servletContext = this.getServletContext();
String count = servletContext.getInitParameter("count");
System.out.println("count:" + count);
}

jsp的使用

jsp
是
sun
公司制定的一种用于服务器端的动态页面的技术规范，也是一种组件，依赖于容器
(tomcat)
进
行运行。

jsp
不需要再
web.xml
中进行配置，直接通过它的路径和文件名进行访问。

jsp
是一种运行在服务器端的页面，它里面可以包含
html ,
嵌入一些
java
代码，通过在
tomcat
容器中经
过解析，输出为
html
页面。

servlet : 数据的处理和数据的展示(拼html标签)
servlet + jsp : servlet做数据处理， jsp做数据的展示。
servlet做数据展示的时候，不方便（编写代码的时候，维护代码的时候）
jsp : 让数据的处理和数据的展示进行分离(解耦)

jsp页面怎么写java相关的内容

<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.3</version>
<scope>provided</scope>
</dependency>

jsp
页面写
java
代码

<%
// java 代码
String str = "hello jsp!";
%>

jsp
页面输出要显示内容

<%=str%>
out.print(str);

<%
// java 代码
String str = "hello jsp!";
%>
<p style="color: red;">
<%-- 这个是输出变量。--%>
<%=str%>
</p>
<p style="color: green">
<%
str = "hello my jsp!";
// out 是jsp 页面上提供的 输出内容的对象。 out是jsp的内置对象， 可以直接
使用。
out.print(str);
%>
</p>

jsp
页面导入
java
类

jsp
页面上，使用
java
类的时候，都需要先导入，然后再使用。

<%@ page import=”java.util.Date” %>

<%@ page import="java.util.Date" %>
<%@ page import="java.text.SimpleDateFormat" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>导包的练习</title>
</head>
<body>
<%
// 获取当前的系统时间， 以 yyyy-MM-dd HH:mm:ss的方式显示
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateStr = sdf.format(date);
%>
<h3>当前时间：<%= dateStr %></h3>
</body>
</html>

jsp
的运行

jsp
的本质就是
servlet

第一次访问一个jsp页面的时候，会将jsp页面，转换为一个servlet类。
html ， js , css 这种内容就直接使用输出语句拼接。
其他和java相关的内容，就按java的语法规则转换

转发和重定向

代码

if(servletPath.equals("/delete.do")){
String bookId = req.getParameter("bookId");
if(bookId == null){
req.setAttribute("msg" , "只能根据id删除数据。");
RequestDispatcher rd =
req.getRequestDispatcher("./book/info.jsp");
rd.forward(req ,resp);
}else{
Boolean aBoolean = service.deleteOne(Integer.valueOf(bookId));
if(aBoolean == false){
req.setAttribute("msg" , "删除失败");
RequestDispatcher rd =
req.getRequestDispatcher("./book/info.jsp");
rd.forward(req ,resp);
}else{ // 删除成功，重定向到list.do (重定向是第二个请求)
resp.sendRedirect("list.do"); // sendRedirect -- 重定向
}
}
}

一个请求完成部分功能，希望剩下的功能由另一个请求完成，这种时候使用转发
.

一般使用servlet完成数据处理，转发数据到jsp页面，实现数据的展示。
转发可以通过request对象，把数据转发给另一个请求
转发的本质是一个请求，因为request对象不变（可以共享request中的数据）。
转发之后，浏览器地址栏显示的是第一个请求的地址。

重定向

某个请求完成之后，希望浏览器自动发起另一个请求，则使用重定向。

使用重定向的时候，浏览器消息头中收到一个302状态码和url地址。浏览器根据这个状态码和 url地址，自动发起请求。
重定向是完全不同的两个请求，是两个request对象，两个请求的数据无法共享。
浏览器地址栏显示的是第二个请求的地址。

路径的写法

资源文件的路径(.js , .css , 图片…..) , 表单提交的路径，超链接，重定向的路径，建议使用绝对路径。
转发的路径，建议使用相对路径。
servlet的绝对路径：/application context/servlet path .

jsp、html的绝对路径： / application context /文件的路径（webapp目录中文件的路径）
各种资源文件，jsp , html 等保存的目录必须是webapp目录。

绝对路径的代码：

/路径， 表示绝对路径。
/web04/add.do --- 绝对路径， 属于硬编码。不方便维护。
String appContext = request.getContextPath();// 获取到application
context 的路径。
appContext + /add.do --- 绝对路径。 维护更方便。

相对路径的代码：

../ 表示推出当前目录，到上层目录，然后拼接路径。
./ 表示当前目录，直接拼接路径。 可以省略./

增加一个cookie

// cookie : 服务器中可以设置cookie数据， 保存在浏览器中。
public class AddCookieServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
// 保存一个count=100在cookie中。
Cookie cookie = new Cookie("count" , 100+""); // 创建了cookie对象
cookie.setMaxAge(180); // 单位是秒， 设置cookie的有效期， 过了有效期，cookie就
不能使用了。
resp.addCookie(cookie); // 把cookie添加到浏览器中。
Cookie cookie1 = new Cookie("ip" , "localhost"); // 有一个默认的有效期。
resp.addCookie(cookie1);
resp.getWriter().println("count：" + cookie.getValue() + ",ip:" +
cookie1.getName());
}
}

获取cookie,修改cookie

// cookie: 每次访问服务器的时候，请求中，会把跟这个服务器域名相关的cookie数据，发送
// 到服务器端， 服务器端就可以获取到这些cookie数据。
public class GetCookieServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
Cookie[] cookies = req.getCookies();
if(cookies != null){
for(Cookie c : cookies){
//c.getName() : cookie的key
// c.getValue() : cookie的value
System.out.println(c.getName() + ":" + c.getValue());
// 修改cookie的数据，重新保存在浏览器中
if(c.getName().equals("count")){
c.setValue(Integer.valueOf(c.getValue()) + 1 + "");
resp.addCookie(c); // 修改了浏览器中的cookie
}
}
resp.getWriter().println("有"+cookies.length+"个cookie");
}else{
resp.getWriter().println("没有cookie");
}
}
}

状态管理

状态
(
数据
)
管理
(
数据存储
)
：浏览器和服务器的多次交互作为一个整体，这个过程中有一些需要使用的
数据，这些数据
(
状态
)
需要保存起来，用于表示某种状态。

客户端状态管理：cookie技术，把数据保存在浏览器中，就是客户端的状态管理。
服务器端状态管理： session技术，把数据保存在服务器的session对象中，就是服务器端的状态管理。

服务器端创建cookie对象，再添加到浏览器中。
```
Cookie c = new Cookie(key ,value);
response.addCookie(c)
```

浏览器保存响应结果中邀请你需要add的cookie对象，每个cookie和自己的请求的域名一致。
浏览器每次给服务器发请求的时候，会将请求对应的域名中保存的cookie数据，一起发送到服务器。
服务器通过request获取cookie对象的数据，根据cookie的name，找到value值，进行使用value

setMaxAge(正数) : 有效期就是当前时间 + 正数的秒数。
setMaxAge(0) ：立即失效，表示cookie过期了。

没有调用setMaxAge 或者 setMaxAge(负数) ：表示会话期间有效。浏览器关闭，cookie失效了。默认设置。
会话期间：浏览器第一次访问某个服务器，到浏览器关闭的期间，称为一个会话。

子路径下可以找到父路径中的
cookie

cookie.setPath(url) -- 创建好cookie对象之后，可以修改cookie的路径，然后再添加到浏览器中。
比如： http://localhost:8080/web04/xx/yy/aa.do - 这个路径中添加了一个cookie(count
,"100")
http://localhost:8080/web04/xx/bb.do - 这个访问不了count.

用户可以删除cookie
用户可以禁止使用cookie
存储小于4k的内容
cookie的个数不能超过300个
只能存储字符串
cookie不安全

session的使用

状态管理

cookie: 客户端状态管理技术
session: 服务器端状态管理技术

session
对象的获取

sesssion对象的获取，和请求中从浏览器中传输到服务器的cookie（JSESSIONID）有关系。
根据JSESSIONID 这个cookie，去查找当前请求对应的session对象。

// 根据sessionId 获取session对象，如果没有获取到，就创建一个session.
HttpSession session = request.getSession()
// true: 同 request.getSession() 一样，就是找不到就给创建一个。
// false : 找不到session对象，就返回null.
HttpSession session = request.getSession(boolean)

session
中保存数据

session.setAttribute(String , Object) -- key，value

session
中获取数据

Object obj = session.getAttribute(String) -- 根据key找到value

session
中删除数据

session.removeAttribute(String) -- 根据key ，删除数据

session
会话超时

可以设置
session
的有效期

session.setMaxInactiveInterval(秒)

如果没有设置有效期，默认的有效期是
30
分钟，如果会话结束了，
session
一般就无效了。

设置
session
无效

一般系统又一个退出功能，可以清空
session
中保存的数据，使用
session
的
invalidate
方法，

设置
session
为无效

session.invalidate();

Filter的使用

sun
公司提供的一种特殊的组件规范，主要用于拦截容器的调用过程。

规范：实现Filter接口（实现doFilter方法）
特殊：过滤器不能单独使用，需要和servlet进行配合使用
组件：实现软件的某个模块功能，需要在容器中运行。
容器：一个特殊的软件，可以运行组件
支持多个Filter , 以在web.xml中的配置的顺序进行过滤。

案例

统计
web
程序总共被访问了多少次！

Filter:
过滤器统计次数

filter
的类

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class TotalFilter implements Filter {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse
servletResponse, FilterChain filterChain) throws IOException, ServletException {
// 类型转换
HttpServletRequest request = (HttpServletRequest)servletRequest;
HttpServletResponse response = (HttpServletResponse) servletResponse;
// servletContext: 容器运行程序期间都有效，可以共享数据。
// 容器停止运行，servletContext就无效了。
ServletContext servletContext = request.getServletContext();
// 数据处理
Object total = servletContext.getAttribute("total");
if(total != null){
servletContext.setAttribute("total" , (Integer)total + 1);
System.out.println("当前系统一共被访问了：" + ((Integer)total + 1) +
"次");
}else{
servletContext.setAttribute("total" , 1);
System.out.println("当前系统一共被访问了：" + 1 + "次");
}
// 找下一个Filter
filterChain.doFilter(request , response);
}
}

filter
的配置

<filter>
<filter-name>total</filter-name>
<filter-class>filter.TotalFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>total</filter-name>
<!-- 模糊匹配： /*匹配任意路径(包含servlet，jsp)，所以就能直接统计访问次数
了。-->
<url-pattern>/*</url-pattern>
</filter-mapping>

Filter的生命周期

实例化（调用构造函数） — 1次
初始化（调用init函数） — 1次
就绪(调用doFilter函数) — 任意次
销毁（调用destroy函数）— 1次

ServletContext的使用

应用程序执行期间都是同一个
ServletContext
对象，可以在所有请求中，获取到该对象，操作该对象中
的数据。

// servletContext: 容器运行程序期间都有效，可以共享数据。
// 容器停止运行，servletContext就无效了。
ServletContext servletContext = request.getServletContext();
// 获取数据
Object total = servletContext.getAttribute("total");
// 设置数据
servletContext.setAttribute("total" , 1)

servlet
中数据可以存储的区域：

servlet的service方法中的变量
request对象：可以通过转发的方式，把数据转发到其他的请求中
session对象：可以让一个用户在会话期间，直接使用session中的数据。
servletContext对象：可以让所有请求在容器运行期间，直接使用servletContext中的数据。

jsp的内置对象

EL表达式

expression language: el
表达式

el
表达式
,
主要用于替换掉
<%=xx %>
输出语句

在jsp页面中，可以直接通过el表达式，获取到存储在pageContext, request, session , application中的数据。

语法规则

${对象} [<%=xx %>]
${对象.属性名} [<%=xx.getXXX() %>]
对象符合java bean的规范（描述类的属性私有化，提供公开的get/set方法。比如属性名叫abc , 对应的方法叫getAbc / setAbc）
${对象.属性名} ,这里的本质是调用属性名对应的get方法。

el
表达式的查找数据方式

从pageContext, request, session , application等对象中，查找需要输出的对象
pageContext, request, session , application如果出现了同名的key , 那么查找按小范围优选的原则查找
可以通过pageScope， requestScope , sessionScope, applicationScope 指定查找范围。

el
表达式可以做运算

条件运算：结果是boolean
数学运算: 运算结果
逻辑运算：结果是boolean
empty运算：结果是boolean

el
表达式的输出结果

如果没有这个key ，输出是空字符串
如果有这个key，但是key对应的value值是null , 输出的是空字符串
其他情况，输出的是key对应的value值。

el
表达式使用
cookie

${cookie.cookieName.value}
<h3>
根据cookie的名字找value
</h3>
<h3>jsessionid: ${cookie.JSESSIONID.value}</h3>

el
表达式绝对路径的写法

${pageContext.request.contextPath}
替换掉： <%=request.getContextPath()%>

jstl: jsp的标签库

jstl
标签，用于替换掉
jsp
页面上的
<% java
代码
%>

jsp
页面上，如果有太多的
java
代码，对于
jsp
页面的修改，维护，前端人员都不友好。

jstl
使用

导入
jstl
的
jar
包

<!-- https://mvnrepository.com/artifact/javax.servlet.jsp.jstl/jstl -->
<dependency>
<groupId>javax.servlet.jsp.jstl</groupId>
<artifactId>jstl-api</artifactId>
<version>1.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/taglibs/standard -->
<dependency>
<groupId>taglibs</groupId>
<artifactId>standard</artifactId>
<version>1.1.2</version>
</dependency>

在
jsp
页面上，使用
taglib
指令，把想用的标签，导入到
jsp
页面上，让
jsp
支持标签的使用

taglib ： jsp的导入标签库的指令
prefix : 前缀，给标签添加上前缀之后，可以和其他的重名标签进行区分。
uri: 标签的访问地址

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

常用的标签

c:if — if
c:choose …. if…else
c:forEach …. 循环

jsp的include指令

head.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<h3 style="color: green">xx , 下午好， 欢迎使用本系统！</h3>

其他
jsp

<%@ include file="head.jsp"%>

HTTP协议

超文本传输协议（Hyper Text Transfer Protocol，HTTP）是一个简单的请求-响应协议，它通常运行在TCP之上。它指定了客户端可能发送给服务器什么样的消息以及得到什么样的响应。请求和响应消息的头以ASCII形式给出；而 [9] 消息内容则具有一个类似MIME的格式。这个简单模型是早期Web成功的有功之臣，因为它使开发和部署非常地直截了当。

华清远见-重庆中心-Java web段技术总结/知识点梳理

Servlet 介绍

Servlet的开发步骤

servlet & servlet的配置

http协议 & servlet 的运行

http协议

servlet的地址的设置

servlet的生命周期

servlet的参数

servlet级别的参数

context级别的参数

jsp的使用

jsp页面怎么写java相关的内容

转发和重定向

增加一个cookie

获取cookie,修改cookie

状态管理

session的使用

Filter的使用

案例

Filter的生命周期

ServletContext的使用

jsp的内置对象

EL表达式

jstl: jsp的标签库

jsp的include指令

HTTP协议

状态消息

相关推荐

十月红莲的最新文章

随机推荐

回顶部

Servlet 介绍

Servlet的开发步骤

servlet & servlet的配置

http协议 & servlet 的运行

http协议

servlet的地址的设置

servlet的生命周期

servlet的参数

servlet级别的参数

context级别的参数

jsp的使用

jsp页面怎么写java相关的内容

转发和重定向

cookie使用

增加一个cookie

获取cookie,修改cookie

状态管理

cookie的使用过程

cookie的有效期

cookie的路径问题

cookie的特点

session的使用

Filter的使用

案例

Filter的生命周期

ServletContext的使用

jsp的内置对象

EL表达式

jstl: jsp的标签库

jsp的include指令

HTTP协议

状态消息

相关推荐

十月红莲 的最新文章

随机推荐

回顶部

十月红莲的最新文章