javaweb最原始代码,直接实现Servlet接口
public class HelloServlet implements Servlet{
// 5个方法
public void init(ServletConfig config) throws ServletException{
}
public void service(ServletRequest request,ServletResponse response)
throws ServletException , IOException{
// 向控制台打印输出
System.out.println("My First Servlet, Hello Servlet");
// 设置响应的内容类型是普通文本或html代码
// 需要在获取流对象之前设置,有效。
response.setContentType("text/html");
// 怎么将一个信息直接输出到浏览器上?
// 需要使用ServletResponse接口:response
// response表示响应:从服务器向浏览器发送数据叫做响应。
PrintWriter out = response.getWriter();
// 设置响应的内容类型时不要在获取流之后设置。
//response.setContentType("text/html");
out.print("Hello Servlet, You are my first servlet!");
// 浏览器是能够识别html代码的,那我们是不是应该输出一段HTML代码呢?
out.print("<h1>hello servlet,你好Servlet</h1>");
// 这是一个输出流,负责输出字符串到浏览器
// 这个输出流不需要我们刷新,也不需要我们关闭,这些都由Tomcat来维护。
/*
out.flush();
out.close();
*/
}
public void destroy(){
}
public String getServletInfo(){
return "";
}
public ServletConfig getServletConfig(){
return null;
}
}
GenericServlet
-
我们编写一个Servlet类直接实现Servlet接口有什么缺点?
- 我们只需要service方法,其他方法大部分情况下是不需要使用的。代码很丑陋。
-
适配器设计模式Adapter
- 手机直接插到220V的电压上,手机直接就报废了。怎么办?可以找一个充电器。这个充电器就是一个适配器。手机连接适配器。适配器连接220V的电压。这样问题就解决了。
-
编写一个GenericServlet类,这个类是一个抽象类,其中有一个抽象方法service。
-
GenericServlet实现Servlet接口。
-
GenericServlet是一个适配器。
-
以后编写的所有Servlet类继承GenericServlet,重写service方法即可。
-
思考:GenericServlet类是否需要改造一下?怎么改造?更利于子类程序的编写?
-
思考第一个问题:我提供了一个GenericServlet之后,init方法还会执行吗?
- 还会执行。会执行GenericServlet类中的init方法。
-
思考第二个问题:init方法是谁调用的?
- Tomcat服务器调用的。
-
思考第三个问题:init方法中的ServletConfig对象是谁创建的?是谁传过来的?
-
都是Tomcat干的。
-
Tomcat服务器先创建了ServletConfig对象,然后调用init方法,将ServletConfig对象传给了init方法。
-
-
-
GenericServlet源码
public abstract class GenericServlet implements Servlet, ServletConfig,
java.io.Serializable {
private static final long serialVersionUID = 1L;
private transient ServletConfig config;
/**
* Does nothing. All of the servlet initialization is done by one of the
* <code>init</code> methods.
*/
public GenericServlet() {
// NOOP
}
@Override
public void destroy() {
// NOOP by default
}
/**
* Returns a <code>String</code> containing the value of the named
* initialization parameter, or <code>null</code> if the parameter does not
* exist. See {@link ServletConfig#getInitParameter}.
* <p>
* This method is supplied for convenience. It gets the value of the named
* parameter from the servlet's <code>ServletConfig</code> object.
*
* @param name
* a <code>String</code> specifying the name of the
* initialization parameter
* @return String a <code>String</code> containing the value of the
* initialization parameter
*/
@Override
public String getInitParameter(String name) {
return getServletConfig().getInitParameter(name);
}
@Override
public Enumeration<String> getInitParameterNames() {
return getServletConfig().getInitParameterNames();
}
@Override
public ServletConfig getServletConfig() {
return config;
}
/**
* Returns a reference to the {@link ServletContext} in which this servlet
* is running. See {@link ServletConfig#getServletContext}.
* <p>
* This method is supplied for convenience. It gets the context from the
* servlet's <code>ServletConfig</code> object.
*
* @return ServletContext the <code>ServletContext</code> object passed to
* this servlet by the <code>init</code> method
*/
@Override
public ServletContext getServletContext() {
return getServletConfig().getServletContext();
}
/**
* Returns information about the servlet, such as author, version, and
* copyright. By default, this method returns an empty string. Override this
* method to have it return a meaningful value. See
* {@link Servlet#getServletInfo}.
*
* @return String information about this servlet, by default an empty string
*/
@Override
public String getServletInfo() {
return "";
}
@Override
public void init(ServletConfig config) throws ServletException {
this.config = config;
this.init();
}
public void init() throws ServletException {
// NOOP by default
}
@Override
public abstract void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException;
/**
* Returns the name of this servlet instance. See
* {@link ServletConfig#getServletName}.
*
* @return the name of this servlet instance
*/
@Override
public String getServletName() {
return config.getServletName();
}
}
继承GenericServlet类
/**
* ServletConfig对象中到底包装了什么信息呢?
* <servlet>
* <servlet-name>configTest</servlet-name>
* <servlet-class>com.bjpowernode.javaweb.servlet.ConfigTestServlet</servlet-class>
* </servlet>
* ServletConfig对象中包装的信息是:
* web.xml文件中<servlet></servlet>标签的配置信息。
*
* Tomcat小猫咪解析web.xml文件,将web.xml文件中<servlet></servlet>标签中的配置信息自动包装到ServletConfig对象中。
*
* 7. ServletConfig接口中有哪些方法?
* <servlet>
* <servlet-name>configTest</servlet-name>
* <servlet-class>com.bjpowernode.javaweb.servlet.ConfigTestServlet</servlet-class>
* <!--这里是可以配置一个Servlet对象的初始化信息的。-->
* <init-param>
* <param-name>driver</param-name>
* <param-value>com.mysql.cj.jdbc.Driver</param-value>
* </init-param>
* <init-param>
* <param-name>url</param-name>
* <param-value>jdbc:mysql://localhost:3306/bjpowernode</param-value>
* </init-param>
* <init-param>
* <param-name>user</param-name>
* <param-value>root</param-value>
* </init-param>
* <init-param>
* <param-name>password</param-name>
* <param-value>root1234</param-value>
* </init-param>
* </servlet>
* 以上<servlet></servlet>标签中的<init-param></init-param>是初始化参数。这个初始化参数信息会自动被小猫咪封装到ServletConfig对象当中。
* 8. ServletConfig接口中有4个方法:
* 第1个方法:
* public String getInitParameter(String name);
* 第2个方法:
* public Enumeration<String> getInitParameterNames();
* 第3个方法:
* public ServletContext getServletContext();
* 第4个方法:
* public String getServletName();
*
* 以上的4个方法,在自己编写的Servlet类当中也可以使用this去调用。(这个Servlet继承了GenericServlet)
*/
public class ConfigTestServlet extends GenericServlet {
@Override
public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
// 获取ServletConfig对象
ServletConfig config = this.getServletConfig();
// 输出该对象
// org.apache.catalina.core.StandardWrapperFacade@aea0d43
out.print("ServletConfig对象是:" + config.toString());
out.print("<br>");
// 获取<servlet-name></servlet-name>
String servletName = config.getServletName();
out.print("<servlet-name>"+servletName+"</servlet-name>");
out.print("<br>");
// 通过ServletConfig对象的两个方法,可以获取到web.xml文件中的初始化参数配置信息。
// java.util.Enumeration<java.lang.String> getInitParameterNames() 获取所有的初始化参数的name
Enumeration<String> initParameterNames = config.getInitParameterNames();
// 遍历集合
while(initParameterNames.hasMoreElements()) { // 是否有更多元素
String parameterName = initParameterNames.nextElement(); // 取元素
String parameterVal = config.getInitParameter(parameterName); // 通过name获取value
out.print(parameterName + "=" + parameterVal);
out.print("<br>");
}
// java.lang.String getInitParameter(java.lang.String name) 通过初始化参数的name获取value
/*String driver = config.getInitParameter("driver");
out.print(driver);*/
// 实际上获取一个Servlet对象的初始化参数,可以不用获取ServletConfig对象。直接通过this也可以。
Enumeration<String> names = this.getInitParameterNames();
while(names.hasMoreElements()){
String name = names.nextElement();
String value = this.getInitParameter(name);
// 打印到后台
System.out.println(name + "=" + value);
}
// 怎么获取ServletContext对象呢?
// 第一种方式:通过ServletConfig对象获取ServletContext对象。
ServletContext application = config.getServletContext();
// 输出
out.print("<br>" + application); //org.apache.catalina.core.ApplicationContextFacade@19187bbb
// 第二种方式:通过this也可以获取ServletContext对象。
ServletContext application2 = this.getServletContext();
out.print("<br>" + application2); //org.apache.catalina.core.ApplicationContextFacade@19187bbb
}
}
ServletConfig
-
什么是ServletConfig?
- Servlet对象的配置信息对象。
- ServletConfig对象中封装了标签中的配置信息。(web.xml文件中servlet的配置信息)
-
一个Servlet对应一个ServletConfig对象。
-
Servlet对象是Tomcat服务器创建,并且ServletConfig对象也是Tomcat服务器创建。并且默认情况下,他们都是在用户发送第一次请求的时候创建。
-
Tomcat服务器调用Servlet对象的init方法的时候需要传一个ServletConfig对象的参数给init方法。
-
ServletConfig接口的实现类是Tomcat服务器给实现的。(Tomcat服务器说的就是WEB服务器。)
-
ServletConfig接口有哪些常用的方法?
-
public String getInitParameter(String name); // 通过初始化参数的name获取value public Enumeration<String> getInitParameterNames(); // 获取所有的初始化参数的name public ServletContext getServletContext(); // 获取ServletContext对象 public String getServletName(); // 获取Servlet的name
-
以上方法在Servlet类当中,都可以使用this去调用。因为GenericServlet实现了ServletConfig接口。
-
ServletContext
-
一个Servlet对象对应一个ServletConfig。100个Servlet对象则对应100个ServletConfig对象。
-
只要在同一个webapp当中,只要在同一个应用当中,所有的Servlet对象都是共享同一个ServletContext对象的。
-
ServletContext对象在服务器启动阶段创建,在服务器关闭的时候销毁。这就是ServletContext对象的生命周期。ServletContext对象是应用级对象。
-
Tomcat服务器中有一个webapps,这个webapps下可以存放webapp,可以存放多个webapp,假设有100个webapp,那么就有100个ServletContext对象。但是,总之,一个应用,一个webapp肯定是只有一个ServletContext对象。
-
ServletContext被称为Servlet上下文对象。(Servlet对象的四周环境对象。)
-
一个ServletContext对象通常对应的是一个web.xml文件。
-
ServletContext对应显示生活中的什么例子呢?
- 一个教室里有多个学生,那么每一个学生就是一个Servlet,这些学生都在同一个教室当中,那么我们可以把这个教室叫做ServletContext对象。那么也就是说放在这个ServletContext对象(环境)当中的数据,在同一个教室当中,物品都是共享的。比如:教室中有一个空调,所有的学生都可以操作。可见,空调是共享的。因为空调放在教室当中。教室就是ServletContext对象。
-
ServletContext是一个接口,Tomcat服务器对ServletContext接口进行了实现。
- ServletContext对象的创建也是Tomcat服务器来完成的。启动webapp的时候创建的。
-
ServletContext接口中有哪些常用的方法?
-
public String getInitParameter(String name); // 通过初始化参数的name获取value public Enumeration<String> getInitParameterNames(); // 获取所有的初始化参数的name
-
<!--以上两个方法是ServletContext对象的方法,这个方法获取的是什么信息?是以下的配置信息--> <context-param> <param-name>pageSize</param-name> <param-value>10</param-value> </context-param> <context-param> <param-name>startIndex</param-name> <param-value>0</param-value> </context-param> <!--注意:以上的配置信息属于应用级的配置信息,一般一个项目中共享的配置信息会放到以上的标签当中。--> <!--如果你的配置信息只是想给某一个servlet作为参考,那么你配置到servlet标签当中即可,使用ServletConfig对象来获取。-->
-
// 获取应用的根路径(非常重要),因为在java源代码当中有一些地方可能会需要应用的根路径,这个方法可以动态获取应用的根路径 // 在java源码当中,不要将应用的根路径写死,因为你永远都不知道这个应用在最终部署的时候,起一个什么名字。 public String getContextPath(); //String contextPath = application.getContextPath();
-
// 获取文件的绝对路径(真实路径) public String getRealPath(String path);
-
// 通过ServletContext对象也是可以记录日志的 public void log(String message); public void log(String message, Throwable t); // 这些日志信息记录到哪里了? //使用idea会在这里 Using CATALINA_BASE: "C:\Users\86151\AppData\Local\JetBrains\IntelliJIdea2023.2\tomcat\79ec8f10-848d-46ff-95d7-7756bd66adfd" // localhost.2021-11-05.log // Tomcat服务器的logs目录下都有哪些日志文件? //catalina.2021-11-05.log 服务器端的java程序运行的控制台信息。 //localhost.2021-11-05.log ServletContext对象的log方法记录的日志信息存储到这个文件中。 //localhost_access_log.2021-11-05.txt 访问日志
-
// ServletContext对象还有另一个名字:应用域(后面还有其他域,例如:请求域、会话域) // 如果所有的用户共享一份数据,并且这个数据很少的被修改,并且这个数据量很少,可以将这些数据放到ServletContext这个应用域中 // 为什么是所有用户共享的数据? 不是共享的没有意义。因为ServletContext这个对象只有一个。只有共享的数据放进去才有意义。 // 为什么数据量要小? 因为数据量比较大的话,太占用堆内存,并且这个对象的生命周期比较长,服务器关闭的时候,这个对象才会被销毁。大数据量会影响服务器的性能。占用内存较小的数据量可以考虑放进去。 // 为什么这些共享数据很少的修改,或者说几乎不修改? // 所有用户共享的数据,如果涉及到修改操作,必然会存在线程并发所带来的安全问题。所以放在ServletContext对象中的数据一般都是只读的。 // 数据量小、所有用户共享、又不修改,这样的数据放到ServletContext这个应用域当中,会大大提升效率。因为应用域相当于一个缓存,放到缓存中的数据,下次在用的时候,不需要从数据库中再次获取,大大提升执行效率。 // 存(怎么向ServletContext应用域中存数据) public void setAttribute(String name, Object value); // map.put(k, v) // 取(怎么从ServletContext应用域中取数据) public Object getAttribute(String name); // Object v = map.get(k) // 删(怎么删除ServletContext应用域中的数据) public void removeAttribute(String name); // map.remove(k)
-
-
注意:以后我们编写Servlet类的时候,实际上是不会去直接继承GenericServlet类的,因为我们是B/S结构的系统,这种系统是基于HTTP超文本传输协议的,在Servlet规范当中,提供了一个类叫做HttpServlet,它是专门为HTTP协议准备的一个Servlet类。我们编写的Servlet类要继承HttpServlet。(HttpServlet是HTTP协议专用的。)使用HttpServlet处理HTTP协议更便捷。但是你需要知道它的继承结构:
jakarta.servlet.Servlet(接口)【爷爷】 jakarta.servlet.GenericServlet implements Servlet(抽象类)【儿子】 jakarta.servlet.http.HttpServlet extends GenericServlet(抽象类)【孙子】 我们以后编写的Servlet要继承HttpServlet类。
HTTP协议
-
什么是URI? 统一资源标识符。代表网络中某个资源的名字。但是通过URI是无法定位资源的。
-
什么是URL?统一资源定位符。代表网络中某个资源,同时,通过URL是可以定位到该资源的。
-
URI和URL什么关系,有什么区别?
- URL包括URI
- http://localhost:8080/servlet05/index.html 这是URL。
- /servlet05/index.html 这是URI。
-
200 表示请求响应成功,正常结束。
-
404表示访问的资源不存在,通常是因为要么是你路径写错了,要么是路径写对了,但是服务器中对应的资源并没有启动成功。总之404错误是前端错误。
-
405表示前端发送的请求方式与后端请求的处理方式不一致时发生:
- 比如:前端是POST请求,后端的处理方式按照get方式进行处理时,发生405
- 比如:前端是GET请求,后端的处理方式按照post方式进行处理时,发生405
-
500表示服务器端的程序出现了异常。一般会认为是服务器端的错误导致的。
-
以4开始的,一般是浏览器端的错误导致的。
-
以5开始的,一般是服务器端的错误导致的。
-
get请求是安全的。get请求是绝对安全的。为什么?因为get请求只是为了从服务器上获取数据。不会对服务器造成威胁。(get本身是安全的,你不要用错了。用错了之后又冤枉人家get不安全,你这样不好(太坏了),那是你自己的问题,不是get请求的问题。)
-
post请求是危险的。为什么?因为post请求是向服务器提交数据,如果这些数据通过后门的方式进入到服务器当中,服务器是很危险的。另外post是为了提交数据,所以一般情况下拦截请求的时候,大部分会选择拦截(监听)post请求。
get请求支持缓存。
- https://n.sinaimg.cn/finance/590/w240h350/20211101/b40c-b425eb67cabc342ff5b9dc018b4b00cc.jpg
- 任何一个get请求最终的“响应结果”都会被浏览器缓存起来。在浏览器缓存当中:
- 一个get请求的路径a 对应 一个资源。
- 一个get请求的路径b 对应 一个资源。
- 一个get请求的路径c 对应 一个资源。
- …
- 实际上,你只要发送get请求,浏览器做的第一件事都是先从本地浏览器缓存中找,找不到的时候才会去服务器上获取。这种缓存机制目的是为了提高用户的体验。
- 有没有这样一个需求:我们不希望get请求走缓存,怎么办?怎么避免走缓存?我希望每一次这个get请求都去服务器上找资源,我不想从本地浏览器的缓存中取。
- 只要每一次get请求的请求路径不同即可。
- https://n.sinaimg.cn/finance/590/w240h350/20211101/7cabc342ff5b9dc018b4b00cc.jpg?t=789789787897898
- https://n.sinaimg.cn/finance/590/w240h350/20211101/7cabc342ff5b9dc018b4b00cc.jpg?t=789789787897899
- https://n.sinaimg.cn/finance/590/w240h350/20211101/7cabc342ff5b9dc018b4b00cc.jpg?t=系统毫秒数
- 怎么解决?可以在路径的后面添加一个每时每刻都在变化的“时间戳”,这样,每一次的请求路径都不一样,浏览器就不走缓存了。
HttpServlet源码分析
HttpServlet使用了模板方法模式,service()方法定义了整个流程,其他doGet(),doPost()等方法留到子类去实现。
但是doGet(),doPost()等方法实现了异常判断
public class HelloServlet extends HttpServlet {
// 用户第一次请求,创建HelloServlet对象的时候,会执行这个无参数构造方法。
public HelloServlet() {
}
//override 重写 doGet方法
//override 重写 doPost方法
}
public abstract class GenericServlet implements Servlet, ServletConfig,
java.io.Serializable {
// 用户第一次请求的时候,HelloServlet对象第一次被创建之后,这个init方法会执行。
public void init(ServletConfig config) throws ServletException {
this.config = config;
this.init();
}
// 用户第一次请求的时候,带有参数的init(ServletConfig config)执行之后,会执行这个没有参数的init()
public void init() throws ServletException {
// NOOP by default
}
}
// HttpServlet模板类。
public abstract class HttpServlet extends GenericServlet {
// 用户发送第一次请求的时候这个service会执行
// 用户发送第N次请求的时候,这个service方法还是会执行。
// 用户只要发送一次请求,这个service方法就会执行一次。
@Override
public void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException {
HttpServletRequest request;
HttpServletResponse response;
try {
// 将ServletRequest和ServletResponse向下转型为带有Http的HttpServletRequest和HttpServletResponse
request = (HttpServletRequest) req;
response = (HttpServletResponse) res;
} catch (ClassCastException e) {
throw new ServletException(lStrings.getString("http.non_http"));
}
// 调用重载的service方法。
service(request, response);
}
// 这个service方法的两个参数都是带有Http的。
// 这个service是一个模板方法。
// 在该方法中定义核心算法骨架,具体的实现步骤延迟到子类中去完成。
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// 获取请求方式
// 这个请求方式最终可能是:""
// 注意:request.getMethod()方法获取的是请求方式,可能是七种之一:
// GET POST PUT DELETE HEAD OPTIONS TRACE
String method = req.getMethod();
// 如果请求方式是GET请求,则执行doGet方法。
if (method.equals(METHOD_GET)) {
long lastModified = getLastModified(req);
if (lastModified == -1) {
// servlet doesn't support if-modified-since, no reason
// to go through further expensive logic
doGet(req, resp);
} else {
long ifModifiedSince;
try {
ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
} catch (IllegalArgumentException iae) {
// Invalid date header - proceed as if none was set
ifModifiedSince = -1;
}
if (ifModifiedSince < (lastModified / 1000 * 1000)) {
// If the servlet mod time is later, call doGet()
// Round down to the nearest second for a proper compare
// A ifModifiedSince of -1 will always be less
maybeSetLastModified(resp, lastModified);
doGet(req, resp);
} else {
resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
}
}
} else if (method.equals(METHOD_HEAD)) {
long lastModified = getLastModified(req);
maybeSetLastModified(resp, lastModified);
doHead(req, resp);
} else if (method.equals(METHOD_POST)) {
// 如果请求方式是POST请求,则执行doPost方法。
doPost(req, resp);
} else if (method.equals(METHOD_PUT)) {
doPut(req, resp);
} else if (method.equals(METHOD_DELETE)) {
doDelete(req, resp);
} else if (method.equals(METHOD_OPTIONS)) {
doOptions(req,resp);
} else if (method.equals(METHOD_TRACE)) {
doTrace(req,resp);
} else {
//
// Note that this means NO servlet supports whatever
// method was requested, anywhere on this server.
//
String errMsg = lStrings.getString("http.method_not_implemented");
Object[] errArgs = new Object[1];
errArgs[0] = method;
errMsg = MessageFormat.format(errMsg, errArgs);
resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
}
}
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException{
// 报405错误
String msg = lStrings.getString("http.method_get_not_supported");
sendMethodNotAllowed(req, resp, msg);
}
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// 报405错误
String msg = lStrings.getString("http.method_post_not_supported");
sendMethodNotAllowed(req, resp, msg);
}
}
web站点欢迎界面设置
配置欢迎页面有两个地方可以配置:
-
一个是在webapp内部的web.xml文件中。(在这个地方配置的属于局部配置)
怎么设置欢迎页面呢?
-
第一步:我在IDEA工具的web目录下新建了一个文件login.html
-
第二步:在web.xml文件中进行了以下的配置
-
<welcome-file-list> <welcome-file>login.html</welcome-file> </welcome-file-list>
-
注意:设置欢迎页面的时候,这个路径不需要以“/”开始。并且这个路径默认是从webapp的根下开始查找。
-
-
第三步:启动服务器,浏览器地址栏输入地址
- http://localhost:8080/servlet07
-
一个webapp是可以设置多个欢迎页面的
<welcome-file-list>
<welcome-file>page1/page2/page.html</welcome-file>
<welcome-file>login.html</welcome-file>
</welcome-file-list>
注意:越靠上的优先级越高。找不到的继续向下找。
-
一个是在CATALINA_HOME/conf/web.xml文件中进行配置。(在这个地方配置的属于全局配置)
-
<welcome-file-list> <welcome-file>index.html</welcome-file> <welcome-file>index.htm</welcome-file> <welcome-file>index.jsp</welcome-file> </welcome-file-list>
-
Tomcat服务器的全局欢迎页面是:index.html index.htm index.jsp。如果你一个web站点没有设置局部的欢迎页面,Tomcat服务器就会以index.html index.htm index.jsp作为一个web站点的欢迎页面。
-
-
注意原则:局部优先原则。(就近原则)
关于WEB-INF目录
- 在WEB-INF目录下新建了一个文件:welcome.html
- 打开浏览器访问:http://localhost:8080/servlet07/WEB-INF/welcome.html 出现了404错误。
- 注意:放在WEB-INF目录下的资源是受保护的。在浏览器上不能够通过路径直接访问。所以像HTML、CSS、JS、image等静态资源一定要放到WEB-INF目录之外。
HttpServletRequest
-
跳转
-
转发(一次请求)
-
// 第一步:获取请求转发器对象,以斜杠开始不加项目名 RequestDispatcher dispatcher = request.getRequestDispatcher("/b"); // 第二步:调用转发器的forward方法完成跳转/转发 dispatcher.forward(request,response); // 第一步和第二步代码可以联合在一起。 request.getRequestDispatcher("/b").forward(request,response);
-
-
-
两个Servlet怎么共享数据?
- 将数据放到ServletContext应用域当中,当然是可以的,但是应用域范围太大,占用资源太多。不建议使用。
- 可以将数据放到request域当中,然后AServlet转发到BServlet,保证AServlet和BServlet在同一次请求当中,这样就可以做到两个Servlet,或者多个Servlet共享同一份数据。
-
转发的下一个资源必须是一个Servlet吗?
- 不一定,只要是Tomcat服务器当中的合法资源,都是可以转发的。例如:html…
- 注意:转发的时候,路径的写法要注意,转发的路径以“/”开始,不加项目名。
-
关于request对象中两个非常容易混淆的方法:
-
// uri?username=zhangsan&userpwd=123&sex=1 String username = request.getParameter("username"); // 之前一定是执行过:request.setAttribute("name", new Object()) Object obj = request.getAttribute("name"); // 以上两个方法的区别是什么? // 第一个方法:获取的是用户在浏览器上提交的数据。 // 第二个方法:获取的是请求域当中绑定的数据。
-
-
HttpServletRequest接口的其他常用方法:
// 获取客户端的IP地址 String remoteAddr = request.getRemoteAddr(); // get请求在请求行上提交数据。 // post请求在请求体中提交数据。 // 设置请求体的字符集。(显然这个方法是处理POST请求的乱码问题。这种方式并不能解决get请求的乱码问题。) // Tomcat10之后,request请求体当中的字符集默认就是UTF-8,不需要设置字符集,不会出现乱码问题。 // Tomcat9前(包括9在内),如果前端请求体提交的是中文,后端获取之后出现乱码,怎么解决这个乱码?执行以下代码。 request.setCharacterEncoding("UTF-8"); // 在Tomcat9之前(包括9),响应中文也是有乱码的,怎么解决这个响应的乱码? response.setContentType("text/html;charset=UTF-8"); // 在Tomcat10之后,包括10在内,响应中文的时候就不在出现乱码问题了。以上代码就不需要设置UTF-8了。 // 注意一个细节 // 在Tomcat10包括10在内之后的版本,中文将不再出现乱码。(这也体现了中文地位的提升。) // get请求乱码问题怎么解决? // get请求发送的时候,数据是在请求行上提交的,不是在请求体当中提交的。 // get请求乱码怎么解决 // 方案:修改CATALINA_HOME/conf/server.xml配置文件 <Connector URIEncoding="UTF-8" /> // 注意:从Tomcat8之后,URIEncoding的默认值就是UTF-8,所以GET请求也没有乱码问题了。 // 获取应用的根路径 /aaa /servlet08 String contextPath = request.getContextPath(); // 获取请求方式 GET POST String method = request.getMethod(); // 获取请求的URI String uri = request.getRequestURI(); // /aaa/testRequest // 获取servlet path String servletPath = request.getServletPath(); // /testRequest
在一个web应用中应该如何完成资源的跳转
-
在一个web应用中通过两种方式,可以完成资源的跳转:
- 第一种方式:转发
- 第二种方式:重定向
-
转发和重定向有什么区别?
-
代码上有什么区别?
-
转发
-
// 获取请求转发器对象 RequestDispatcher dispatcher = request.getRequestDispatcher("/dept/list"); // 调用请求转发器对象的forward方法完成转发 dispatcher.forward(request, response); // 合并一行代码 request.getRequestDispatcher("/dept/list").forward(request, response); // 转发的时候是一次请求,不管你转发了多少次。都是一次请求。 // AServlet转发到BServlet,再转发到CServlet,再转发到DServlet,不管转发了多少次,都在同一个request当中。 // 这是因为调用forward方法的时候,会将当前的request和response对象传递给下一个Servlet。
-
-
重定向
-
// 注意:路径上要加一个项目名。为什么? // 浏览器发送请求,请求路径上是需要添加项目名的。 // 以下这一行代码会将请求路径“/oa/dept/list”发送给浏览器 // 浏览器会自发的向服务器发送一次全新的请求:/oa/dept/list response.sendRedirect("/oa/dept/list");
-
-
-
形式上有什么区别?
- 转发(一次请求)
- 在浏览器地址栏上发送的请求是:http://localhost:8080/servlet10/a ,最终请求结束之后,浏览器地址栏上的地址还是这个。没变。
- 重定向(两次请求)
- 在浏览器地址栏上发送的请求是:http://localhost:8080/servlet10/a ,最终在浏览器地址栏上显示的地址是:http://localhost:8080/servlet10/b
- 转发(一次请求)
-
转发和重定向的本质区别?
- 转发:是由WEB服务器来控制的。A资源跳转到B资源,这个跳转动作是Tomcat服务器内部完成的。
- 重定向:是浏览器完成的。具体跳转到哪个资源,是浏览器说了算。
-
使用一个例子去描述这个转发和重定向
- 借钱(转发:发送了一次请求)
- 杜老师没钱了,找张三借钱,其实张三没有钱,但是张三够义气,张三自己找李四借了钱,然后张三把这个钱给了杜老师,杜老师不知道这个钱是李四的,杜老师只求了一个人。杜老师以为这个钱就是张三的。
- 借钱(重定向:发送了两次请求)
- 杜老师没钱了,找张三借钱,张三没有钱,张三有一个好哥们,叫李四,李四是个富二代,于是张三将李四的家庭住址告诉了杜老师,杜老师按照这个地址去找到李四,然后从李四那里借了钱。显然杜老师在这个过程中,求了两个人。并且杜老师知道最终这个钱是李四借给俺的。
- 借钱(转发:发送了一次请求)
-
-
转发和重定向应该如何选择?什么时候使用转发,什么时候使用重定向?
- 如果在上一个Servlet当中向request域当中绑定了数据,希望从下一个Servlet当中把request域里面的数据取出来,使用转发机制。
- 剩下所有的请求均使用重定向。(重定向使用较多。)
-
跳转的下一个资源有没有要求呢?必须是一个Servlet吗?
- 不一定,跳转的资源只要是服务器内部合法的资源即可。包括:Servlet、JSP、HTML…
-
转发会存在浏览器的刷新问题,(1)因为:(请求转发,不会改变浏览器中的地址,即使中间经过了很多其他资源路径,浏览器中仍会保持最初始的访问路径。)(2)所以:点击“请求转发表”的提交按钮后,浏览器地址栏发生最后一次改变,直到这次请求结束,浏览器地址栏也会保持这个初始地址不变。(3)但是一旦刷新浏览器,浏览器就会自动,将现在浏览器中的地址,再次发送给服务器(4)这个就跟点击表单的“提交按钮”,没有区别了。所以请求转发会导致,用户可能多次重复提交表单。
Servlet注解,简化配置
-
分析oa项目中的web.xml文件
- 现在只是一个单标的CRUD,没有复杂的业务逻辑,很简单的一丢丢功能。web.xml文件中就有如此多的配置信息。如果采用这种方式,对于一个大的项目来说,这样的话web.xml文件会非常庞大,有可能最终会达到几十兆。
- 在web.xml文件中进行servlet信息的配置,显然开发效率比较低,每一个都需要配置一下。
- 而且在web.xml文件中的配置是很少被修改的,所以这种配置信息能不能直接写到java类当中呢?可以的。
-
Servlet3.0版本之后,推出了各种Servlet基于注解式开发。优点是什么?
- 开发效率高,不需要编写大量的配置信息。直接在java类上使用注解进行标注。
- web.xml文件体积变小了。
-
并不是说注解有了之后,web.xml文件就不需要了:
- 有一些需要变化的信息,还是要配置到web.xml文件中。一般都是 注解+配置文件 的开发模式。
- 一些不会经常变化修改的配置建议使用注解。一些可能会被修改的建议写到配置文件中。
-
我们的第一个注解:
-
jakarta.servlet.annotation.WebServlet
-
在Servlet类上使用:@WebServlet,WebServlet注解中有哪些属性呢?
- name属性:用来指定Servlet的名字。等同于:
- urlPatterns属性:用来指定Servlet的映射路径。可以指定多个字符串。
- loadOnStartUp属性:用来指定在服务器启动阶段是否加载该Servlet。等同于:
- value属性:当注解的属性名是value的时候,使用注解的时候,value属性名是可以省略的。这个value属性和urlPatterns属性一致,都是用来指定Servlet的映射路径的。
- 注意:不是必须将所有属性都写上,只需要提供需要的。(需要什么用什么。)
- 注意:属性是一个数组,如果数组中只有一个元素,使用该注解的时候,属性值的大括号可以省略。
-
-
注解对象的使用格式:
- @注解名称(属性名=属性值, 属性名=属性值, 属性名=属性值…)
// 使用反射机制将类上面的注解进行解析。
// 获取类Class对象
Class<?> welcomeServletClass = Class.forName("com.bjpowernode.javaweb.servlet.WelcomeServlet");
// 获取这个类上面的注解对象
// 先判断这个类上面有没有这个注解对象,如果有这个注解对象,就获取该注解对象。
//boolean annotationPresent = welcomeServletClass.isAnnotationPresent(WebServlet.class);
//System.out.println(annotationPresent);
if (welcomeServletClass.isAnnotationPresent(WebServlet.class)) {
// 获取这个类上面的注解对象
WebServlet webServletAnnotation = welcomeServletClass.getAnnotation(WebServlet.class);
// 获取注解的value属性值。
String[] value = webServletAnnotation.value();
for (int i = 0; i < value.length; i++) {
System.out.println(value[i]);
}
}
@WebServlet(name = "hello",
urlPatterns = {"/hello1", "/hello2", "/hello3"},
//loadOnStartup = 1,
initParams = {
@WebInitParam(name="username", value="root"),
@WebInitParam(name="password", value="123")})
Session
-
什么是会话?
- 用户打开浏览器,进行一系列操作,然后最终将浏览器关闭,这个整个过程叫做:一次会话。会话在服务器端也有一个对应的java对象,这个java对象叫做:session。
- 什么是一次请求:用户在浏览器上点击了一下,然后到页面停下来,可以粗略认为是一次请求。请求对应的服务器端的java对象是:request。
- 一个会话当中包含多次请求。(一次会话对应N次请求。)
-
在java的servlet规范当中,session对应的类名:HttpSession(jarkata.servlet.http.HttpSession)
-
session对象最主要的作用是:保存会话状态。(用户登录成功了,这是一种登录成功的状态,你怎么把登录成功的状态一直保存下来呢?使用session对象可以保留会话状态。)
-
为什么需要session对象来保存会话状态呢?
- 因为HTTP协议是一种无状态协议。
- 什么是无状态:请求的时候,B和S是连接的,但是请求结束之后,连接就断了。为什么要这么做?HTTP协议为什么要设计成这样?因为这样的无状态协议,可以降低服务器的压力。请求的瞬间是连接的,请求结束之后,连接断开,这样服务器压力小。
- 只要B和S断开了,那么关闭浏览器这个动作,服务器知道吗?
- 不知道。服务器是不知道浏览器关闭的。
-
张三打开一个浏览器A,李四打开一个浏览器B,访问服务器之后,在服务器端会生成:
- 张三专属的session对象
- 李四专属的session对象
-
为什么不使用request对象保存会话状态?为什么不使用ServletContext对象保存会话状态?
- request.setAttribute()存,request.getAttribute()取,ServletContext也有这个方法。request是请求域。ServletContext是应用域。
- request是一次请求一个对象。
- ServletContext对象是服务器启动的时候创建,服务器关闭的时候销毁,这个ServletContext对象只有一个。
- ServletContext对象的域太大。
- request请求域(HttpServletRequest)、session会话域(HttpSession)、application域(ServletContext)
- request < session < application
-
session的实现原理:
- JSESSIONID=xxxxxx 这个是以Cookie的形式保存在浏览器的内存中的。浏览器只要关闭。这个cookie就没有了。
- session列表是一个Map,map的key是sessionid,map的value是session对象。
- 用户第一次请求,服务器生成session对象,同时生成id,将id发送给浏览器。
- 用户第二次请求,自动将浏览器内存中的id发送给服务器,服务器根据id查找session对象。
- 关闭浏览器,内存消失,cookie消失,sessionid消失,会话等同于结束。
-
Cookie禁用了,session还能找到吗?
- cookie禁用是什么意思?服务器正常发送cookie给浏览器,但是浏览器不要了。拒收了。并不是服务器不发了。
- 找不到了。每一次请求都会获取到新的session对象。
- cookie禁用了,session机制还能实现吗?
- 可以。需要使用URL重写机制。
- http://localhost:8080/servlet12/test/session;jsessionid=19D1C99560DCBF84839FA43D58F56E16
- URL重写机制会提高开发者的成本。开发人员在编写任何请求路径的时候,后面都要添加一个sessionid,给开发带来了很大的难度,很大的成本。所以大部分的网站都是这样设计的:你要是禁用cookie,你就别用了。
-
总结一下到目前位置我们所了解的域对象:
- request(对应的类名:HttpServletRequest)
- 请求域(请求级别的)
- session(对应的类名:HttpSession)
- 会话域(用户级别的)
- application(对应的类名:ServletContext)
- 应用域(项目级别的,所有用户共享的。)
- 这三个域对象的大小关系
- request < session < application
- 他们三个域对象都有以下三个公共的方法:
- setAttribute(向域当中绑定数据)
- getAttribute(从域当中获取数据)
- removeAttribute(删除域当中的数据)
- 使用原则:尽量使用小的域。
- request(对应的类名:HttpServletRequest)
-
session掌握之后,我们怎么解决oa项目中的登录问题,怎么能让登录起作用。
- 登录成功之后,可以将用户的登录信息存储到session当中。也就是说session中如果有用户的信息就代表用户登录成功了。session中没有用户信息,表示用户没有登录过。则跳转到登录页面。
-
销毁session对象:
-
session.invalidate();
-
// request和session都是服务器端的java对象。都在JVM当中。
// request对象代表了一次请求。(一次请求对应一个request对象。两次请求就会对应两个不同的request对象。)
// session对象代表了一次会话。(一次会话对应一个session对象。)
// 获取session对象
// 从WEB服务器当中获取session对象,如果session对象没有,则新建。
HttpSession session = request.getSession();
// 向会话域当中绑定数据。
// session.setAttribute();
// 从会话域当中取数据。
// Object obj = session.getAttribute()
// 将session对象响应到浏览器。
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
out.print("会话对象:" + session); // 想看看对象的内存地址。
Cookie
-
session的实现原理中,每一个session对象都会关联一个sessionid,例如:
- JSESSIONID=41C481F0224664BDB28E95081D23D5B8
- 以上的这个键值对数据其实就是cookie对象。
- 对于session关联的cookie来说,这个cookie是被保存在浏览器的“运行内存”当中。
- 只要浏览器不关闭,用户再次发送请求的时候,会自动将运行内存中的cookie发送给服务器。
- 例如,这个Cookie: JSESSIONID=41C481F0224664BDB28E95081D23D5B8就会再次发送给服务器。
- 服务器就是根据41C481F0224664BDB28E95081D23D5B8这个值来找到对应的session对象的。
-
cookie怎么生成?cookie保存在什么地方?cookie有啥用?浏览器什么时候会发送cookie,发送哪些cookie给服务器???????
-
cookie最终是保存在浏览器客户端上的。
- 可以保存在运行内存中。(浏览器只要关闭cookie就消失了。)
- 也可以保存在硬盘文件中。(永久保存。)
-
cookie有啥用呢?
- cookie和session机制其实都是为了保存会话的状态。
- cookie是将会话的状态保存在浏览器客户端上。(cookie数据存储在浏览器客户端上的。)
- session是将会话的状态保存在服务器端上。(session对象是存储在服务器上。)
- 为什么要有cookie和session机制呢?因为HTTP协议是无状态 无连接协议。
-
cookie的经典案例
- 京东商城,在未登录的情况下,向购物车中放几件商品。然后关闭商城,再次打开浏览器,访问京东商城的时候,购物车中的商品还在,这是怎么做的?我没有登录,为什么购物车中还有商品呢?
- 将购物车中的商品编号放到cookie当中,cookie保存在硬盘文件当中。这样即使关闭浏览器。硬盘上的cookie还在。下一次再打开京东商城的时候,查看购物车的时候,会自动读取本地硬盘中存储的cookie,拿到商品编号,动态展示购物车中的商品。
- 京东存储购物车中商品的cookie可能是这样的:productIds=xxxxx,yyyy,zzz,kkkk
- 注意:cookie如果清除掉,购物车中的商品就消失了。
- 将购物车中的商品编号放到cookie当中,cookie保存在硬盘文件当中。这样即使关闭浏览器。硬盘上的cookie还在。下一次再打开京东商城的时候,查看购物车的时候,会自动读取本地硬盘中存储的cookie,拿到商品编号,动态展示购物车中的商品。
- 126邮箱中有一个功能:十天内免登录
- 这个功能也是需要cookie来实现的。
- 怎么实现的呢?
- 用户输入正确的用户名和密码,并且同时选择十天内免登录。登录成功后。浏览器客户端会保存一个cookie,这个cookie中保存了用户名和密码等信息,这个cookie是保存在硬盘文件当中的,十天有效。在十天内用户再次访问126的时候,浏览器自动提交126的关联的cookie给服务器,服务器接收到cookie之后,获取用户名和密码,验证,通过之后,自动登录成功。
- 怎么让cookie失效?
- 十天过后自动失效。
- 或者改密码。
- 或者在客户端浏览器上清除cookie。
- 京东商城,在未登录的情况下,向购物车中放几件商品。然后关闭商城,再次打开浏览器,访问京东商城的时候,购物车中的商品还在,这是怎么做的?我没有登录,为什么购物车中还有商品呢?
-
cookie机制和session机制其实都不属于java中的机制,实际上cookie机制和session机制都是HTTP协议的一部分。php开发中也有cookie和session机制,只要是你是做web开发,不管是什么编程语言,cookie和session机制都是需要的。
-
HTTP协议中规定:任何一个cookie都是由name和value组成的。name和value都是字符串类型的。
-
在java的servlet中,对cookie提供了哪些支持呢?
- 提供了一个Cookie类来专门表示cookie数据。jakarta.servlet.http.Cookie;/javax.servlet.http.Cookie
- java程序怎么把cookie数据发送给浏览器呢?response.addCookie(cookie);
-
在HTTP协议中是这样规定的:当浏览器发送请求的时候,会自动携带该path下的cookie数据给服务器。(URL。)
-
关于cookie的有效时间
- 怎么用java设置cookie的有效时间
- cookie.setMaxAge(60 * 60); 设置cookie在一小时之后失效。以秒为单位
- 没有设置有效时间:默认保存在浏览器的运行内存中,浏览器关闭则cookie消失。
- 只要设置cookie的有效时间 > 0,这个cookie一定会存储到硬盘文件当中。
- 设置cookie的有效时间 = 0 呢?
- cookie被删除,同名cookie被删除。
- 设置cookie的有效时间 < 0 呢?
- 保存在运行内存中。和不设置一样。
- 怎么用java设置cookie的有效时间
-
关于cookie的path,cookie关联的路径:
默认为父路径
- 假设现在发送的请求路径是“http://localhost:8080/servlet13/cookie/generate”生成的cookie,如果cookie没有设置path,默认的path是什么?
- 默认的path是:http://localhost:8080/servlet13/cookie 以及它的子路径。
- 也就是说,以后只要浏览器的请求路径是http://localhost:8080/servlet13/cookie 这个路径以及这个路径下的子路径,cookie都会被发送到服务器。
- 手动设置cookie的path
- cookie.setPath(“/servlet13”); 表示只要是这个servlet13项目的请求路径,都会提交这个cookie给服务器。
- 假设现在发送的请求路径是“http://localhost:8080/servlet13/cookie/generate”生成的cookie,如果cookie没有设置path,默认的path是什么?
-
服务器生成cookie发送给浏览器
// 创建Cookie对象 Cookie cookie = new Cookie("productid", "12345645623145612"); Cookie cookie2 = new Cookie("username", "zhangsan"); // 设置cookie在一小时之后失效。(保存在硬盘文件当中) //cookie.setMaxAge(60 * 60); // 设置cookie的有效期为0,表示该cookie被删除。主要应用在:使用这种方式删除浏览器上的同名cookie。 //cookie.setMaxAge(0); // 设置cookie的有效期 < 0,表示该cookie不会被存储。(表示不会被存储到硬盘文件中。会放在浏览器运行内存当中。) cookie.setMaxAge(-1); // 和不调用sexMaxAge是同一个效果。 cookie2.setMaxAge(-1); // 默认情况下,没有设置path的时候,cookie关联的路径是什么? //cookie.setPath("/servlet13"); cookie.setPath(request.getContextPath()); cookie2.setPath(request.getContextPath()); // 将cookie响应到浏览器 response.addCookie(cookie); response.addCookie(cookie2);
-
浏览器发送cookie给服务器了,服务器中的java程序怎么接收?
-
Cookie[] cookies = request.getCookies(); // 这个方法可能返回null if(cookies != null){ for(Cookie cookie : cookies){ // 获取cookie的name String name = cookie.getName(); // 获取cookie的value String value = cookie.getValue(); } }
-
Filter过滤器
-
当前的OA项目存在什么缺陷?
- DeptServlet、EmpServlet、OrderServlet。每一个Servlet都是处理自己相关的业务。在这些Servlet执行之前都是需要判断用户是否登录了。如果用户登录了,可以继续操作,如果没有登录,需要用户登录。这段判断用户是否登录的代码是固定的,并且在每一个Servlet类当中都需要编写,显然代码没有得到重复利用。包括每一个Servlet都要解决中文乱码问题,也有公共的代码。这些代码目前都是重复编写,并没有达到复用。怎么解决这个问题?
- 可以使用Servlet规范中的Filter过滤器来解决这个问题。
- DeptServlet、EmpServlet、OrderServlet。每一个Servlet都是处理自己相关的业务。在这些Servlet执行之前都是需要判断用户是否登录了。如果用户登录了,可以继续操作,如果没有登录,需要用户登录。这段判断用户是否登录的代码是固定的,并且在每一个Servlet类当中都需要编写,显然代码没有得到重复利用。包括每一个Servlet都要解决中文乱码问题,也有公共的代码。这些代码目前都是重复编写,并没有达到复用。怎么解决这个问题?
-
Filter是什么,有什么用,执行原理是什么?
- Filter是过滤器。
- Filter可以在Servlet这个目标程序执行之前添加代码。也可以在目标Servlet执行之后添加代码。之前之后都可以添加过滤规则。
- 一般情况下,都是在过滤器当中编写公共代码。
-
一个过滤器怎么写呢?
-
第一步:编写一个Java类实现一个接口:jarkata.servlet.Filter。并且实现这个接口当中所有的方法。
- init方法:在Filter对象第一次被创建之后调用,并且只调用一次。
- doFilter方法:只要用户发送一次请求,则执行一次。发送N次请求,则执行N次。在这个方法中编写过滤规则。
- destroy方法:在Filter对象被释放/销毁之前调用,并且只调用一次。
-
第二步:在web.xml文件中对Filter进行配置。这个配置和Servlet很像。
-
<filter> <filter-name>filter2</filter-name> <filter-class>com.bjpowernode.javaweb.servlet.Filter2</filter-class> </filter> <filter-mapping> <filter-name>filter2</filter-name> <url-pattern>*.do</url-pattern> </filter-mapping>
-
或者使用注解:@WebFilter({“*.do”})
-
-
-
注意:
- Servlet对象默认情况下,在服务器启动的时候是不会新建对象的。
- Filter对象默认情况下,在服务器启动的时候会新建对象。
- Servlet是单例的。Filter也是单例的。(单实例。)
-
目标Servlet是否执行,取决于两个条件:
- 第一:在过滤器当中是否编写了:chain.doFilter(request, response); 代码。
- 第二:用户发送的请求路径是否和Servlet的请求路径一致。
-
chain.doFilter(request, response); 这行代码的作用:
- 执行下一个过滤器,如果下面没有过滤器了,执行最终的Servlet。
-
注意:Filter的优先级,天生的就比Servlet优先级高。
- /a.do 对应一个Filter,也对应一个Servlet。那么一定是先执行Filter,然后再执行Servlet。
-
关于Filter的配置路径:
- /a.do、/b.do、/dept/save。这些配置方式都是精确匹配。
- /* 匹配所有路径。
- *.do 后缀匹配。不要以 / 开始(这是扩展匹配)
- /dept/* 前缀匹配。
-
在web.xml文件中进行配置的时候,Filter的执行顺序是什么?
- 依靠filter-mapping标签的配置位置,越靠上优先级越高。
-
过滤器的调用顺序,遵循栈数据结构。
-
使用@WebFilter的时候,Filter的执行顺序是怎样的呢?
- 执行顺序是:比较Filter这个类名。
- 比如:FilterA和FilterB,则先执行FilterA。
- 比如:Filter1和Filter2,则先执行Filter1.
-
Filter的生命周期?
- 和Servlet对象生命周期一致。
- 唯一的区别:Filter默认情况下,在服务器启动阶段就实例化。Servlet不会。
-
Filter过滤器这里有一个设计模式:
- 责任链设计模式。
- 过滤器最大的优点:
- 在程序编译阶段不会确定调用顺序。因为Filter的调用顺序是配置到web.xml文件中的,只要修改web.xml配置文件中filter-mapping的顺序就可以调整Filter的执行顺序。显然Filter的执行顺序是在程序运行阶段动态组合的。那么这种设计模式被称为责任链设计模式。
- 责任链设计模式最大的核心思想:
- 在程序运行阶段,动态的组合程序的调用顺序。
-
使用过滤器改造OA项目。
public Filter1(){
System.out.println("无参数构造方法执行");
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("init方法执行。");
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
// 在请求的时候添加过滤规则。
System.out.println("Filter1 doFilter方法开始执行。");
// 执行下一个过滤器,如果下一个不是过滤器了,则执行目标程序Servlet。
// 向下走。没有它是不行滴。
chain.doFilter(request, response);
// 在响应的时候添加过滤规则。
System.out.println("Filter1 doFilter方法执行结束。");
}
@Override
public void destroy() {
System.out.println("destroy方法执行");
}
Listener监听器
-
什么是监听器?
- 监听器是Servlet规范中的一员。就像Filter一样。Filter也是Servlet规范中的一员。
- 在Servlet中,所有的监听器接口都是以“Listener”结尾。
-
监听器有什么用?
- 监听器实际上是Servlet规范留给我们javaweb程序员的特殊时机。
- 特殊的时刻如果想执行这段代码,你需要想到使用对应的监听器。
-
Servlet规范中提供了哪些监听器?
-
jakarta.servlet包下:
- ServletContextListener
- ServletContextAttributeListener
- ServletRequestListener
- ServletRequestAttributeListener
-
jakarta.servlet.http包下:
-
HttpSessionListener
-
HttpSessionAttributeListener
- 该监听器需要使用@WebListener注解进行标注。
- 该监听器监听的是什么?是session域中数据的变化。只要数据变化,则执行相应的方法。主要监测点在session域对象上。
-
HttpSessionBindingListener
- 该监听器不需要使用@WebListener进行标注。
- 假设User类实现了该监听器,那么User对象在被放入session的时候触发bind事件,User对象从session中删除的时候,触发unbind事件。
- 假设Customer类没有实现该监听器,那么Customer对象放入session或者从session删除的时候,不会触发bind和unbind事件。
-
HttpSessionIdListener
- session的id发生改变的时候,监听器中的唯一一个方法就会被调用。
-
HttpSessionActivationListener
-
监听session对象的钝化和活化的。
-
钝化:session对象从内存存储到硬盘文件。
-
活化:从硬盘文件把session恢复到内存。
-
-
@WebListener public class MyHttpSessionAttributeListener implements HttpSessionAttributeListener { // 向session域当中存储数据的时候,以下方法被WEB服务器调用。 @Override public void attributeAdded(HttpSessionBindingEvent se) { System.out.println("session data add"); } // 将session域当中存储的数据删除的时候,以下方法被WEB服务器调用。 @Override public void attributeRemoved(HttpSessionBindingEvent se) { System.out.println("session data remove"); } // session域当中的某个数据被替换的时候,以下方法被WEB服务器调用。 @Override public void attributeReplaced(HttpSessionBindingEvent se) { System.out.println("session data replace"); } } @WebListener public class MyHttpSessionListner implements HttpSessionListener { @Override public void sessionCreated(HttpSessionEvent se) { System.out.println("session被创建了"); } @Override public void sessionDestroyed(HttpSessionEvent se) { System.out.println("session被销毁了"); } } // ServletContextListener监听器主要监听的是:ServletContext对象的状态。 @WebListener public class MyServletContextListener implements ServletContextListener { /** * 监听器中的方法不需要程序员手动调用。是发生某个特殊事件之后被服务器调用。 * @param sce */ @Override public void contextInitialized(ServletContextEvent sce) { // 服务器启动时间点,想在这个时候执行一段代码,写就行了。 // 现在这个特殊的时刻写代码,你写就是了。它会被服务器自动调用。 // 这个方法是在ServletContext对象被创建的时候调用。 System.out.println("ServletContext对象创建了。"); } @Override public void contextDestroyed(ServletContextEvent sce) { // 服务器关闭时间点。 // 现在这个特殊的时刻写代码,你写就是了。它会被服务器自动调用。 // 这个方法是在ServletContext对象被销毁的时候调用。 System.out.println("ServletContext对象被销毁了。"); } } @WebListener public class MyServletRequestListener implements ServletRequestListener { // request对象销毁时间点 @Override public void requestDestroyed(ServletRequestEvent sre) { System.out.println("request对象销毁了"); } // request对象创建时间点 @Override public void requestInitialized(ServletRequestEvent sre) { System.out.println("request对象初始化了"); } }
-
-
实现一个监听器的步骤:以ServletContextListener为例。
-
第一步:编写一个类实现ServletContextListener接口。并且实现里面的方法。
-
void contextInitialized(ServletContextEvent event) void contextDestroyed(ServletContextEvent event)
-
-
第二步:在web.xml文件中对ServletContextListener进行配置,如下:
-
<listener> <listener-class>com.bjpowernode.javaweb.listener.MyServletContextListener</listener-class> </listener>
-
当然,第二步也可以不使用配置文件,也可以用注解,例如:@WebListener
-
-
-
注意:所有监听器中的方法都是不需要javaweb程序员调用的,由服务器来负责调用?什么时候被调用呢?
- 当某个特殊的事件发生(特殊的事件发生其实就是某个时机到了。)之后,被web服务器自动调用。
-
思考一个业务场景:
- 请编写一个功能,记录该网站实时的在线用户的个数。
- 我们可以通过服务器端有没有分配session对象,因为一个session代表了一个用户。有一个session就代表有一个用户。如果你采用这种逻辑去实现的话,session有多少个,在线用户就有多少个。这种方式的话:HttpSessionListener够用了。session对象只要新建,则count++,然后将count存储到ServletContext域当中,在页面展示在线人数即可。
- 业务发生改变了,只统计登录的用户的在线数量,这个该怎么办?
- session.setAttribute(“user”, userObj);
- 用户登录的标志是什么?session中曾经存储过User类型的对象。那么这个时候可以让User类型的对象实现HttpSessionBindingListener监听器,只要User类型对象存储到session域中,则count++,然后将count++存储到ServletContext对象中。页面展示在线人数即可。
-
实现oa项目中当前登录在线的人数。
- 什么代表着用户登录了?
- session.setAttribute(“user”, userObj); User类型的对象只要往session中存储过,表示有新用户登录。
- 什么代表着用户退出了?
- session.removeAttribute(“user”); User类型的对象从session域中移除了。
- 或者有可能是session销毁了。(session超时)
- 什么代表着用户登录了?
本文主要参考了动力结点杜聚宾老师的讲义