JavaWeb与JSP详解

最新推荐文章于 2024-05-05 20:33:50 发布

夜林天

最新推荐文章于 2024-05-05 20:33:50 发布

阅读量1.3k

点赞数

分类专栏： java 文章标签： java web

本文链接：https://blog.csdn.net/weixin_43477950/article/details/110389520

版权

java 专栏收录该内容

25 篇文章 2 订阅

订阅专栏

Jsp九大内置对象

Request请求对象（重）

转译后对应HttpServletRequest/ServletRequest对象

1、客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应。它是HttpServletRequest类的实例。request对象具有请求域,即完成客户端的请求之前,该对象一直有效。常用方法如下:

常用方法	方法介绍
String getParameter(String name)	返回name指定参数的参数值
String[] getParameterValues(String name)	返回包含参数name的所有值的数组
void setAttribute(String,Object)	存储此请求中的属性
Object getAttribute(String name)	返回指定属性的属性值
String getContentType()	得到请求体的MIME类型
String getProtocol()	返回请求用的协议类型及版本号
String getServerName()	返回接受请求的服务器主机名
int getServerPort()	返回服务器接受此请求所用的端口号
String getCharacterEncoding()	返回字符编码方式
void setCharacterEncoding()	设置请求的字符编码方式
int getContentLength()	返回请求体的长度(以字节数)
String getRemoteAddr()	返回发送此请求的客户端IP地址
String getRealPath(String path)	返回一虚拟路径的真实路径
String request.getContextPath()	返回上下文路径

Response响应对象（重）

转译后对应HttpServletRespons/ServletResponse对象

1、对客户的请求做出动态的响应，向客户端发送数据。

void addCookie(Cookie cookie）// 给客户端添加一个Cookie对象，以保存客户端的信息
String encodeRedirectURL(String url)// 对使用的URL进行编译
String encodeURL(String url)// 封装URL并返回到客户端，实现URL重写
void flushBuffer() // 清空缓冲区
int getCharacterEncoding() // 取得字符编码类型
String getContentType() // 取得MIME类型
Locale getLocale()//  取得本地化信息
ServletOutputStream getOutputStream() // 返回一个二进制输出字节流
PrintWriter getWriter() // 返回一个输出字符流
void reset() // 重设response对象
void resetBuffer()// 重设缓冲区
void sendError(int sc)//  向客户端发送HTTP状态码的出错信息
void sendRedirect() // 重定向客户的请求到指定页面**
void setBufferSize(int size)//  设置缓冲区的大小为size
void setCharacterEncoding(String encoding)//  设置字符编码类型为encoding
void setContentLength(int length)// 设置响应数据的大小为size
void setContentType(String type) // 设置MIME类型
void setDateHeader(String s1,long l) // 设置日期类型的HTPP首部信息
void setLocale(Locale locale) // 设置本地化为locale
void setStatus(int status)  // 设置状态码为status

Session会话对象（重）

转译后对应HttpSession对象

1、从一个客户打开浏览器并连接到服务器开始，到客户关闭浏览器离开这个服务器结束，被称为一个会话。当一个客户访问一个服务器时，可能会在这个服务器的几个页面之间反复连接，反复刷新一个页面，服务器应当通过某种办法知道这是同一个客户，这就需要session对象。

2、session对象的ID：当一个客户首次访问服务器上的一个JSP页面时，JSP引擎产生一个session对象，同时分配一个String类型的ID号，JSP引擎同时将这个ID号发送到客户端，存放在Cookie中，这样session对象和客户之间就建立了一一对应的关系。当客户再访问连接该服务器的其他页面时，不再分配给客户新的session对象，直到客户关闭浏览器后，服务器端该客户的session对象才取消，并且和客户的会话对应关系消失。当客户重新打开浏览器再连接到该服务器时，服务器为该客户再创建一个新的session对象。

在jsp页面中可以直接使用session对象（jsp的内置对象），也可以通过**pageContext.getSession()或者request.getSession（）**获取session对象。

**session对象主要用于属性操作和会话管理，常用方法如下： **

public void setAttribute(String name,String value)
//1.    设定指定名字的属性的值，并将它添加到session会话范围内，如果这个属性是会话范围内存在，则更改该属性的值。  

public Object getAttribute(String name)
//2.     在会话范围内获取指定名字的属性的值，返回值类型为object，如果该属性不存在，则返回null。  

public void removeAttribute(String name)
//3.   删除指定名字的session属性，若该属性不存在，则出现异常。  

public void invalidate()
//4.   使session失效。可以立即使当前会话失效，原来会话中存储的所有对象都不能再被访问。  

public String getId()
//5.   获取当前的会话ID。每个会话在服务器端都存在一个唯一的标示sessionID，session对象发送到浏览器的唯一数据就是sessionID，它一般存储在cookie中。  

public void setMaxInactiveInterval(int interval) 
//6.   设置会话的最大持续时间，单位是秒，负数表明会话永不失效。  

public int getMaxInActiveInterval()
//7.   获取会话的最大持续时间。  

// 8、使用session对象的getCreationTime()和getLastAccessedTime()方法可以获取会话创建的时间和最后访问的时间，但其返回值是毫秒，一般需要使用下面的转换来获取具体日期和时间。  
     Date creationTime = new Date(session.getCreationTime())
     Date accessedTime = new Date(session.getLastAccessedTime())

session.isNew()  
//9、 是否是新的会话

session的工作原理：

客户首次访问服务器的一个页面时，服务器就会为该用户分配一个session对象，同时为这个session指定唯一的ID，并且将该ID发送到客户端并写入到cookie中，使得客户端与服务器的session建立一一对应的关系；
当客户端继续访问服务器端的其它资源时，服务器不再为该客户分配新的session对象，直到客户端浏览器关闭、超时或调用session的invalidate（）方法使其失效，客户端与服务器的会话结束。
当客户重新打开浏览器访问网站时，服务器会重新为客户分配一个session对象，并重新分配sessionID。

Application应用程序对象

转译后对应ServletContext对象

1、服务器启动后就产生了这个application对象，当客户在所访问的网站的各个页面之间浏览时，这个application对象都是同一个，直到服务器关闭。但是与session不同的是，所有客户的application对象都是同一个，即所有客户共享这个内置的application对象。

2、application对象常用方法:

public void **setAttribute**(String key,Object obj):
//   将参数Object指定的对象obj添加到application对象中，并为添加的对象指定一个索引关键字。

public Object **getAttribute**(String key):
//   获取application对象中含有关键字的对象。

Out输出对象

转译后对应JspWriter对象，其内部关联一个PringWriter对象

out 对象是一个输出流，用来向客户端输出数据。out对象用于各种数据的输出。

Page页面对象

转译后对应this

对应this关键字。JSP网页本身
page对象是当前页面转换后的Servlet类的实例。从转换后的Servlet类的代码中，可以看到这种关系：
Object page = this;
在JSP页面中，很少使用page对象。

Config配置对象

转译后对应ServletConfig对象

javax.servlet. ServletConfig 的实例，该实例代表该JSP 的配置信息。常用的方法有

getInitPararneter(String paramNarne) 及getInitPararneternarnes()
等方法。事实上， JSP
页面通常无须配置，也就不存在配置信息。因此，该对象更多地在Servlet 中有效。

Exception异常对象

转译后对应Throwable对象，代表由其他JSP页面抛出的异常对象，只会出现于JSP错误页面(isErrorPage设置为true的JSP页面)

该实例代表其他页面中的异常和错误。只有当页面是错误处理页面，即编译指令page
的isErrorPage 属性为true
时，该对象才可以使用。常用的方法有getMessageO和printStackTraceO等。

pageContext页面上下文对象

转译后对应PageContext对象，它提供了JSP页面资源的封装，并可设置页面范围属性

javax.servlet.jsp.PageContext
的实例，对象直译时可以称作“页面上下文”对象，代表的是当前页面运行的一些属性，通过此对象可以拿到其他8大对象，使用该对象可以访问页面中的共享数据。常用的方法有getServletContext（）和getServletConfig（）等。

方法	作用
forward(java.lang.String.relativeUtlpath)	把页面转发到另一个页面
getAttribute(String name)	获取参数值
getAttributeNames(int scope)	获取某范围的参数名称的集合，返回值为java.util.Enumeration对象
getException()	返回exception对象
getRequest()	返回request对象
getResponse()	返回response对象
getSession()	返回session对象
getOut()	返回out对象
getApplication()	返回application对象
setAttribute()	为指定范围内的属性设置属性值
removeAttribute()	删除指定范围内的指定属性

JSP四大属性范围

//使用pageContext 设置属性，该属性默认在page 范围内   
pageContext.setAttribute ("page" , "hello") ;   

//使用request 设置属性，该属性默认在request 范围内   
request. setAttribute ("request" , "hello");   

//使用pageContext将属性设置在request 范围中   
pageContext.setAttribute("request2" , "hello" , pageContext.REQUEST_SCOPE);   

// 使用session将属性设置在session 范围中   
session.setAttribute("session" , "hello");   

//使用pageContext将属性设置在session范围中   
pageContext.setAttribute("session2" , "hello" , pageContext.SESSION_SCOPE);   

//使用application将属性设置在application范围中   
application. setAttribute ("app" , "hello") ;   

//使用pageContext 将属性设置在application 范围中   
pageContext.setAttribute("app2" , "hello" , pageContext.APPL 工CATION_SCOPE) ;

四个作用域

四个作用域：request域 session域 application域 page域

application：
全局作用范围，整个应用程序共享，就是在部署文件中的同一个webApp共享，生命周期为：应用程序启动到停止。

session：
会话作用域，当用户首次访问服务器时，产生一个新的会话，以后服务器就可以记住这个会话状态。

生命周期：会话超时，或者服务器端强制使会话失效。

request：
请求作用域：就是客户端的一次请求，request里的变量可以跨越forward前后的两页。但是只要刷新页面，它们就重新计算了。

page：
作用域：一个JSP页面。

以上作用范围使越来越小， request和page的生命周期都是短暂的，他们之间的区别就是：一个request可以包含多个page页(include，forward以及filter)。

JSP三大指令

<%@开头的
jsp指令 page include taglib

page：指令作用：设置文件编码响应的编码编程的语言导入包
isELIgnored=“false” 是否支持el表达式
include：页面静态包含：
taglib：引入标签库

JSP页面跳转的六种方式

一,　　使用href超链接标记              (客户端跳转)
二,　　提交表单                        (客户端跳转)
　　　　<form name="form" method="post" action="page2.jsp">
           　　 <input type="submit" value="跳转1">
        </form>
    
三,　　Javascrip事件　　　　 　　(客户端跳转)
　　　　<input type="button" value="跳转2" οnclick="next()">
      　　<script type="text/javascript">
            　　function next(){
                　　window.location = "page2.jsp";
           　　 }
       　　</script>
             
四,　　使用response对象 　　　　(客户端跳转)(重定向)
　　　　<%  response.sendRedirect("page2.jsp"); %>　　　　　　　　　
		//sendRedirect()可以带参数传递,后面应该紧跟一句return
　　　　<%   response.setHeader("Refresh", "1;url=page2.jsp"); %>　　
		//1秒后,刷新,并跳到,page2.jsp页面
             
五,　　使用forward动作标记　　　(服务器端跳转)(转发)
　　　　jsp自带的forword标签来实现跳转　　　　<jsp:forward page="page2.jsp" />　
        
六,　　 使用RequestDispatcher类     (服务器端跳转)(转发)　
　　　　<% request.getRequestDispatcher("page2.jsp").forward(request, response);%>　　
        
    response重定向和forward跳转和RequestDispatcher的区别
        (1) response重定向
            执行完页面的所有代码，再跳转到目标页面。
            跳转到目标页面后，浏览器地址栏中的URL会改变。
            在浏览器端重定向，可以跳转到其它服务器上的页面，response.sendRedirect(“http://www.baidu.com”)
        (2) forward跳转
            forward动作标记之后的代码，不再执行，直接跳转到目标页面。
            跳转到目标页面后，浏览器地址栏中的URL不会改变。
            在服务器端重定向，无法跳转到其它服务器上的页面，指定目标页面时，既可以使用绝对路径，也可以使用相对路径。
        (3) RequestDispatcher跳转
            执行完所有代码，包括RequestDispatcher之后的所有代码，再跳转到目标页面。
            跳转到目标页面后，浏览器地址栏中的URL不会改变。
            在服务器端重定向，无法跳转到其它服务器上的页面，指定目标页面时，只能使用绝对路径。

JSTL表达式语言

导入依赖

Servlet

定义servlet，并重写doGet，doPost方法

public class HelloServlet extends HttpServlet {
 
	@Override
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		System.out.println("处理Get请求。。。。。");
		PrintWriter out = response.getWriter();
		out.println("Hello Servlet-Get");
	}
 
	@Override
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		System.out.println("处理Post请求。。。。。");
		PrintWriter out = response.getWriter();
		out.println("Hello Servlet-Post");
	}
}

在web.xml文件中注册servlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>20180510</display-name>
    
    <!-- welcome-file-list是一个配置在web.xml中的一个欢迎页，用于当用户在url中输入工程名称或者输入web容器url（如http://localhost:8080/）时直接跳转的页面.-->
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
    
   <!-- 注册创建的servlet -->
  <servlet>
  	<servlet-name>HelloServlet</servlet-name>
  	<servlet-class>servlet.HelloServlet</servlet-class>
  </servlet>
  <servlet-mapping>
  	<servlet-name>HelloServlet</servlet-name>
  	<url-pattern>/servlet/HelloServlet</url-pattern>
  </servlet-mapping>
</web-app>

使用servlet

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
	<h1>第一个Servlet小例子</h1>
	<hr>
	<a href="servlet/HelloServlet">Get方式请求HellowServlet</a>
	
	<form action="servlet/HelloServlet" method="post">
		<input type="submit" value="Post方式请求HelloServlet">
	</form>
</body>
</html>

servlet生命周期

在默认情况下Servlet实例是在第一个请求到来的时候创建，以后复用。如果有的Servlet需要复杂的操作需要载初始化时完成，比如打开文件、初始化网络连接等，可以通知服务器在启动的时候创建该Servlet的实例。具体配置如下：

<servlet>
    <servlet-name>TimeServlet</servlet-name>
    <servlet-class>com.allanlxf.servlet.basic.TimeServlet</servlet-class>
    <!-- 表示在tomcat容器启动时，servlet的启动循序，为第一个启动 -->
    <load-on-startup>1</load-on-startup>
</servlet>

1352204684_1548

过滤器

过滤器通过 Web 部署描述符（web.xml）中的 XML
标签来声明，然后映射到您的应用程序的部署描述符中的 Servlet 名称或 URL 模式。

当 Web 容器启动 Web
应用程序时，它会为您在部署描述符中声明的每一个过滤器创建一个实例。

Filter 的执行顺序与在 web.xml 配置文件中的配置顺序一致，一般把 Filter
配置在所有的 Servlet 之前。

Servlet 过滤器方法

过滤器是一个实现了 javax.servlet.Filter 接口的 Java 类。javax.servlet.Filter
接口定义了三个方法：

	过滤器方法
1	public void doFilter (ServletRequest, ServletResponse, FilterChain)
	该方法完成实际的过滤操作，当客户端的请求与过滤器设置的 URL 匹配时，Servlet 容器将先调用过滤器的 doFilter 方法。FilterChain 用于访问后续过滤器。
2	public void init(FilterConfig filterConfig)
	web 应用程序启动时，web 服务器将创建Filter 的实例对象，并调用其init方法，读取web.xml配置，完成对象的初始化功能，从而为后续的用户请求作好拦截的准备工作（filter对象只会创建一次，init方法也只会执行一次）。开发人员通过init方法的参数，可获得代表当前filter配置信息的FilterConfig对象。
3	public void destroy()
	Servlet容器在销毁过滤器实例前调用该方法，在该方法中释放Servlet过滤器占用的资源。

FilterConfig 使用

Filter 的 init 方法中提供了一个 FilterConfig 对象。

如 web.xml 文件配置如下：

<filter>
    <filter-name>LogFilter</filter-name>
    <filter-class>com.runoob.test.LogFilter</filter-class>
    <init-param>
        <param-name>Site</param-name>
        <param-value>菜鸟教程</param-value>
    </init-param>
</filter>

在 init 方法使用 FilterConfig 对象获取参数：

public void  init(FilterConfig config) throws ServletException {
    // 获取初始化参数
    String site = config.getInitParameter("Site"); 
    // 输出初始化参数
    System.out.println("网站名称: " + site); 
}

JSP 过滤器实例

以下是 Servlet 过滤器的实例，将输出网站名称和地址。本实例让您对 Servlet
过滤器有基本的了解，您可以使用相同的概念编写更复杂的过滤器应用程序：

//导入必需的 java 库
import javax.servlet.*;
import java.util.*;

//实现 Filter 类
public class LogFilter implements Filter  {
    public void  init(FilterConfig config) throws ServletException {
        // 获取初始化参数
        String site = config.getInitParameter("Site"); 

        // 输出初始化参数
        System.out.println("网站名称: " + site); 
    }
    public void  doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws java.io.IOException, ServletException {

        // 输出站点名称
        System.out.println("站点网址：http://www.runoob.com");

        // 把请求传回过滤链 
        chain.doFilter(request,response);
    }
    public void destroy( ){
        /* 在 Filter 实例被 Web 容器从服务移除之前调用 */
    }
}

监听器

监听器：简单理解就是监听观察某个事件的发生情况，当被监听的事件发生，事件发生者（事件源）
就会给注册该事件的监听者（监听器）发送消息，将某些信息传递给监听者，同时监听者也可以获得一份事件对象，根据这个对象可以获得相关属性和执行相关操作。

监听器模型涉及以下三个对象，模型图如下：

（1）事件：用户对组件的一个操作，或者说程序执行某个方法，称之为一个事件。

（2）事件源：发生事件的组件就是事件源，也就是被监听的对象。

（3）事件监听器（处理器）：监听并负责处理事件的方法。

监听对象	监听接口	监听事件
ServletRequest	ServletRequestListener	ServletRequestEvent
	ServletRequestAttributeListener	ServletRequestAttributeEvent
HttpSession	HttpSessionListener	HttpSessionEvent
	HttpSessionActivationListener
	HttpSessionAttributeListener	HttpSessionBindingEvent
	HttpSessionBindingListener
ServletContext	ServletContextListener	ServletContextEvent
	ServletContextAttributeListener	ServletContextAttributeEvent

创建监听器

package listener;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

//统计网站在线人数，就是统计session
public class OnlineCountListener implements HttpSessionListener {

    //创建session监听，一旦有session属性创建就会触发一次这个事件
    public void sessionCreated(HttpSessionEvent httpSessionEvent) {
        ServletContext context = httpSessionEvent.getSession().getServletContext();
        System.out.println(httpSessionEvent.getSession().getId());
        Integer OnlineCount = (Integer) context.getAttribute("OnlineCount");
        if (OnlineCount==null){
            OnlineCount = new Integer(1);
        }else {
            int count = OnlineCount.intValue();
            OnlineCount = new Integer(count+1);
        }
        context.setAttribute("OnlineCount",OnlineCount);
    }

    //销毁session监听
    public void sessionDestroyed(HttpSessionEvent httpSessionEvent) {
        ServletContext context = httpSessionEvent.getSession().getServletContext();
        Integer OnlineCount = (Integer) context.getAttribute("OnlineCount");
        if (OnlineCount==null){
            OnlineCount = new Integer(0);
        }else {
            int count = OnlineCount.intValue();
            OnlineCount = new Integer(count-1);
        }
        context.setAttribute("OnlineCount",OnlineCount);
    }
    /*
    * session的销毁：
    * 手动销毁：getSession().invalidate();
    * 自动销毁：设置过期*/
}

注册监听器

<!--注册监听器-->
<listener>
    <listener-class>listener.OnlineCountListener</listener-class>
</listener>

问题

1、<%@include file=”” @> 与 <jsp:include page=””/>的区别

<%@include file="" @>

静态包含，将包含的jsp页面代码复制到该页面的include指令位置，在执行时，只执行一个jsp页面，
特点：在源代码不变的情况下，包含的结果是一样的

<jsp:include page=""/>

动态包含：将包含的jsp运行，将运行后的结果返回给该页面的include标签位置，在执行时，执行了两个jsp页面，

}
context.setAttribute(“OnlineCount”,OnlineCount);
}
/*
* session的销毁：
* 手动销毁：getSession().invalidate();
* 自动销毁：设置过期*/
}


> 注册监听器

```xml
<!--注册监听器-->
<listener>
    <listener-class>listener.OnlineCountListener</listener-class>
</listener>

问题

1、<%@include file=”” @> 与 <jsp:include page=””/>的区别

<%@include file="" @>

静态包含，将包含的jsp页面代码复制到该页面的include指令位置，在执行时，只执行一个jsp页面，
特点：在源代码不变的情况下，包含的结果是一样的

<jsp:include page=""/>

动态包含：将包含的jsp运行，将运行后的结果返回给该页面的include标签位置，在执行时，执行了两个jsp页面，
特点：在动态包含jsp页面时，根据传入的参数不同，返回给页面的结果也会发生变化

夜林天

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
JavaWeb与JSP详解

Jsp九大内置对象Request请求对象（重）转译后对应HttpServletRequest/ServletRequest对象1、客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应。它是HttpServletRequest类的实例。request对象具有请求域,即完成客户端的请求之前,该对象一直有效。常用方法如下:常用方法方法介绍String getParameter(String name)返回name指定参数的参数值String
复制链接

扫一扫