Tomcat,Servlet,Jsp（Filter,Listener）

基于之前的Servlet和Jsp的升级版，默认配置环境

新建项目，项目名：Servlet

记录jar包下载地址servlet-api-2.5.jar，这个包在服务器里已经有了，只是随便写一下

http://maven.aliyun.com/nexus/service/local/repositories/hongkong-nexus/content/javax/servlet/servlet-api/2.5/servlet-api-2.5.jar

1，Filter(配置完成后会从首先访问)

1.0，创建类和配置web.xml

package Filter;

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

/**
 * 实现了Filter的接口，分别需要实现方法:
 * 1，构造方法：
 * 2，init方法：实例生成时调用该方法
 * 3，destroy方法：在该实例销毁时调用该方法
 * 4，doFilter方法：过滤器拦截的请求都要实现的方法
 * 
 */
public class TestFilter implements Filter {

    /**
     * Default constructor. 
     */
    public TestFilter() {
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see Filter#destroy()
	 */
	public void destroy() {
		// TODO Auto-generated method stub
	}

	/**
	 * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
	 */
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
		// TODO Auto-generated method stub
		// place your code here
		System.out.println("doFilter");
		//在完成过滤器的所有操作之后调用这个方法会继续访问或者拒绝访问地方反对法
		chain.doFilter(request, response);
	}

	/**
	 * @see Filter#init(FilterConfig)
	 */
	public void init(FilterConfig fConfig) throws ServletException {
		// TODO Auto-generated method stub
		System.out.println(fConfig.getInitParameter("param"));//利用FilterConfig可以读取配置的初始化参数
		/*就像在org.apache.catalina.filters.SetCharacterEncodingFilter中可以设置字符集的编码，参数名encoding，参数UTF-8*/
	}

}

<?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_2_5.xsd"
	version="2.5">
	<display-name>Servlet</display-name>
	<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>
	<filter>
		<display-name>TestFilter</display-name>
		<filter-name>TestFilter</filter-name>
		<filter-class>Filter.TestFilter</filter-class>
		<init-param>
			<description></description>
			<param-name>param</param-name>
			<param-value>CK</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>TestFilter</filter-name>
		<url-pattern>/</url-pattern>
	</filter-mapping>
	<!-- 可以设置多个过滤器，但是过滤器的调用顺序是根据先后顺序来定的 -->
</web-app>

比较常用的过滤器，web.xml中的配置省略

1.1，SetCharacterEncodingFilter，jar包中过滤器，直接新建Filter，选择use existing Filter class找到他，可以自动得到它在web.xml中的配置代码

1.2，禁止浏览器缓存所有动态页面，缓存有利有弊，有时会阻碍数据更新

public class NoCacheFilter implements Filter {
 
 
  public void doFilter(ServletRequest req, ServletResponse resp,
      FilterChain chain) throws IOException, ServletException {
    //把ServletRequest强转成HttpServletRequest
    HttpServletRequest request = (HttpServletRequest) req;
    //把ServletResponse强转成HttpServletResponse
    HttpServletResponse response = (HttpServletResponse) resp;
    //禁止浏览器缓存所有动态页面
    response.setDateHeader("Expires", -1);
    response.setHeader("Cache-Control", "no-cache");
    response.setHeader("Pragma", "no-cache");
     
    chain.doFilter(request, response);
  }
 
  public void init(FilterConfig filterConfig) throws ServletException {
 
  }
   
  public void destroy() {
     
  }
}

1.3，控制浏览器缓存页面中的静态页面

public class CacheFilter implements Filter {
 
  private FilterConfig filterConfig;
 
  public void doFilter(ServletRequest req, ServletResponse resp,
      FilterChain chain) throws IOException, ServletException {
   
    HttpServletRequest request = (HttpServletRequest) req;
    HttpServletResponse response = (HttpServletResponse) resp;
     
    //1.获取用户想访问的资源
    String uri = request.getRequestURI(); 
     
    //2.得到用户想访问的资源的后缀名
    String ext = uri.substring(uri.lastIndexOf(".")+1);
     
    //得到资源需要缓存的时间
    String time = filterConfig.getInitParameter(ext);
    if(time!=null){
      long t = Long.parseLong(time)*3600*1000;
      //设置缓存
      response.setDateHeader("expires", System.currentTimeMillis() + t);
    }
     
    chain.doFilter(request, response);
 
  }
 
  public void init(FilterConfig filterConfig) throws ServletException {
    this.filterConfig = filterConfig;
  }
   
  public void destroy() {
     
  }
}

<!-- 配置缓存过滤器 -->
  <filter>
   <filter-name>CacheFilter</filter-name>
   <filter-class>me.gacl.web.filter.CacheFilter</filter-class>
    <!-- 配置要缓存的web资源以及缓存时间，以小时为单位 -->
   <init-param>
     <param-name>css</param-name>
     <param-value>4</param-value>
   </init-param>
   <init-param>
     <param-name>jpg</param-name>
     <param-value>1</param-value>
   </init-param>
   <init-param>
     <param-name>js</param-name>
     <param-value>4</param-value>
   </init-param>
   <init-param>
     <param-name>png</param-name>
     <param-value>4</param-value>
   </init-param>
 </filter>
 <!-- 配置要缓存的web资源的后缀-->
 <filter-mapping>
   <filter-name>CacheFilter</filter-name>
   <url-pattern>*.jpg</url-pattern>
 </filter-mapping>
  
 <filter-mapping>
   <filter-name>CacheFilter</filter-name>
   <url-pattern>*.css</url-pattern>
 </filter-mapping>
  
 <filter-mapping>
   <filter-name>CacheFilter</filter-name>
   <url-pattern>*.js</url-pattern>
 </filter-mapping>
  <filter-mapping>
   <filter-name>CacheFilter</filter-name>
   <url-pattern>*.png</url-pattern>
 </filter-mapping>

1.4，登陆过滤

这个之后再和拦截器一起讨论,

2，Servlet

package servlet;

import java.io.IOException;
import java.net.URLEncoder;
import java.util.Enumeration;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
 * 继承自HttpServlet init和destroy同Filter
 * 重写doGet，doPost，service方法，首先调用service方法，然后根据请求类型调用doGet或者doPost，这里讲方法合并直接在doGet中编码
 */
public class TestServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;

	ServletContext sc;

	/**
	 * @see HttpServlet#HttpServlet()
	 */
	public TestServlet() {
		super();
		// TODO Auto-generated constructor stub
	}

	@Override
	public void destroy() {
		// TODO Auto-generated method stub
		super.destroy();
	}

	@Override
	public void init(ServletConfig config) throws ServletException {
		// TODO Auto-generated method stub
		sc = config.getServletContext();
		super.init(config);
	}

	@Override
	protected void service(HttpServletRequest arg0, HttpServletResponse arg1) throws ServletException, IOException {
		// TODO Auto-generated method stub
		super.service(arg0, arg1);
	}

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse
	 *      response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		// TODO Auto-generated method stub
		// 1,ServletContext目前的版本无法用request获得ServletContext
		sc.setAttribute("C", "???");
		sc.getAttribute("C");
		sc.removeAttribute("C");
		sc.getContextPath();
		sc.getRealPath("/WEB-INF");
		// 2,HttpSession
		HttpSession session = request.getSession();
		session.getId();// 对于每个用户访问都会有一个不同的SESSIONID来区分
		session.setMaxInactiveInterval(60 * 60 * 24);// 设置session的保存时间，本来可以保存20分钟
		session.setAttribute("test", "???");
		session.getAttribute("test");
		session.removeAttribute("test");
		session.invalidate();// 删除
		// 3,Cookie
		Cookie cookie = new Cookie("username", URLEncoder.encode("孙悟空", "UTF8"));// 新建一个Cookie，当然也可以在前端页面新建Cookie
		cookie.setPath("/");// 可以设置cookie的作用范围
		cookie.setMaxAge(60);// 最大60s后消失
		cookie.getValue();
		request.getCookies();// 获取的到的Cookie数组
		if (cookie.getName().equals("B")) {
			cookie.setMaxAge(0);// 即刻关闭
		}
		response.addCookie(cookie);// 这个时候cookie就已经追备好发送给浏览器了，当再次访问客户端的时候发送给浏览器
		// 4,request的常用方法
		// Get QueryLine
		String queryLine = request.getQueryString();
		System.out.println("queryLine:" + queryLine);
		// Get Url
		StringBuffer url = request.getRequestURL();// WOW!StringBuffer
		String uri = request.getRequestURI();
		System.out.println("url:" + url + "////" + "uri:" + uri);
		// Get Method
		String method = request.getMethod();
		System.out.println("method:" + method);
		// Get Parameter
		String name = request.getParameter("name");
		System.out.println("parameter-name:" + name);
		// String[] sex=request.getParameterValues("sex");
		// for(String s:sex) {
		// System.out.println(s);
		// }
		// Get Headers
		Enumeration<String> headerNames = request.getHeaderNames();
		while (headerNames.hasMoreElements()) {
			String headerName = headerNames.nextElement();
			System.out.println(headerName + ":" + request.getHeader(headerName));
		}
		// request/response
		request.setAttribute("A", "???");
		request.getAttribute("A");
		request.removeAttribute("A");
		//5,response的常用设置
		//
		response.setCharacterEncoding("UTF-8");
		response.setContentType("text/html;charset=UTF-8");
		//......
		//转发
		/*String contextUrl=request.getContextPath();//在此之下加上web地址就可以让浏览器访问
		//
		RequestDispatcher rd=request.getRequestDispatcher("/hello./jsp");
		rd.forward(request, response);*/
		//重定向
		//response.sendRedirect(contextUrl+"/hello.html");
		//直接向客户端输出内容
		response.getWriter().append("Served at: ").append(request.getContextPath());
		//ServletContext读取全局的配置参数
		//sc.getInitParameter("encoding");
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse
	 *      response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

	<servlet>
		<description></description>
		<display-name>TestServlet</display-name>
		<servlet-name>TestServlet</servlet-name>
		<servlet-class>servlet.TestServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>TestServlet</servlet-name>
		<url-pattern>/TestServlet</url-pattern>
	</servlet-mapping>
	<context-param>
		<param-name>encoding</param-name>
		<param-value>UTF-8</param-value>
	</context-param>

常用的Servlet有很多，例如struts1中的ActionServlet，Spring中的DispatcherServlet等等，在tomcat服务器上所有的访问符合web.xml中配置路径的都是经过Filter或者Servlet的，这也他们能成为控制中心的原因，废话

3，Listener

三种常用监听器以及其方法

web.xml声明

<listener>
    <listener-class>com.itheima.listener.FirstListener</listener-class>
</listener>

创建类，session创建及标识有用户访问

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

/**
 * Application Lifecycle Listener implementation class FirstListener
 *
 */
public class FirstListener implements HttpSessionListener {

    /**
     * Default constructor. 
     */
    public FirstListener() {
        // TODO Auto-generated constructor stub
    }

	/**
     * @see HttpSessionListener#sessionCreated(HttpSessionEvent)
     */
    public void sessionCreated(HttpSessionEvent se)  { 
         // TODO Auto-generated method stub
    	//创建session时启用
    }

	/**
     * @see HttpSessionListener#sessionDestroyed(HttpSessionEvent)
     */
    public void sessionDestroyed(HttpSessionEvent se)  { 
         // TODO Auto-generated method stub
    	//session销毁时销毁
    	
    }
	
}

具体的案例以后更新

4，Jsp

Jsp简单的来说就是一个类似于前端HTML页面的Servlet，也就是在初始化服务器时访问到JSP会自动生成Servlet类来调用，而不是直接返回的JSP页面

4.1，指令

taglib，page，include等

page用来设置类型参数和引用import一些类

<%@ page import="java.lang.Math,java.lang.String" language="java" contentType="text/html; charset=utf8" pageEncoding="utf8"%>

include可以用来引入其他的页面

<%@include file="/WEB-INF/in.jsp"%>

taglib可以声明存在的标签，例如常用的jstl标签c和fmt，这个在下面的jstl标签中应用

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

4.2，代码

<%-- --%>注释；<%! %>声明；<% %>代码块；<%= %>表达式输出；

<%=Math.random()%>//可以直接在页面显示表达式的结果
<%!int a = 0;%>//可以用来声明一个在整个jsp中都可以用的变量
<%
    request.setAttribute("test", "a");//java代码可以在这个标签中写
%>

4.3，标签

jstl标签，导入包：

<dependency>
	<groupId>jstl</groupId>
	<artifactId>jstl</artifactId>
	<version>1.2</version>
</dependency>

jstl标签是从外部导入的可以用来直接实现某种功能的标签，它的定义原理可以查看另一篇

常用的方法：开头引入

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

：页面应用

<c:out value="直接显示" />
<fmt:formatNumber value="100000000" pattern="RMB###,###.00"></fmt:formatNumber>//数字格式

4.4，隐含对象

4.4.1，九大内置对象

输入输出：request，response，out，

作用域：session，pageContext，application

servlet：page，config

异常：exception

request 请求对象　类型 javax.servlet.ServletRequest 作用域 Request

response 响应对象类型 javax.servlet.SrvletResponse 作用域 Page

pageContext 页面上下文对象类型 javax.servlet.jsp.PageContext 句柄，获取对象，作用域 Page

session 会话对象类型 javax.servlet.http.HttpSession 作用域 Session

application 应用程序对象类型 javax.servlet.ServletContext 作用域 Application

out 输出对象类型 javax.servlet.jsp.JspWriter 作用域 Page

config 配置对象类型 javax.servlet.ServletConfig 作用域 Page

page 页面对象类型 javax.lang.Object 作用域 Page

exception 例外对象类型 javax.lang.Throwable 作用域 page

4.4.2，EL表达式

EL表达式是jsp中为了方便取值而设定的，会从Page、Request、Session、Application中依次查找对象，取出最先找到的对象，你也可以设定对象的作用域来指定它属于哪个

表达形式如下（假如request.setAttribute("student",student)）

<c:out value="${student.age}" />
<c:out value="${request.student.phonenumber}" />
<c:out value="${student.name}" />

完整页面

<%@ page import="java.lang.Math,java.lang.String" language="java"
  contentType="text/html; charset=utf8" pageEncoding="utf8"%>
<%-- 注释 --%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>
<c:set var="base" value="${pageContext.request.contextPath}" />
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf8">
<title>Insert title here</title>
</head>
<body>
  <%@include file="/WEB-INF/in.jsp"%>
  <c:import url="/WEB-INF/in.jsp" />//页面拼接
  <%=Math.random()%>
  <%!int a = 0;%>
  <%
  	request.setAttribute("test", "a");
  %>
  <p>${test}+${requestScope.test}+${sessionScope.test}+${pageScpoe.test}+
    ${applicationScope[test]}</p>
  <p>
    <c:out value="${tag}" />
  </p>
  <h2>if流程控制</h2>
  <p>处理满足条件的输出</p>
  <c:set var="name" value="熊大" />
  <c:if test="${name=='熊大'}">光头强别跑</c:if>
  <h2>choose多路分支</h2>
  <c:choose>                                    
    <c:when test="${name=='熊大'}">haha</c:when>
    <c:when test="${name eq '熊大'}">heihei</c:when>
    <c:otherwise>aaaah</c:otherwise>
  </c:choose>
  <h2>循环控制</h2>
  <p>for循环，可以实现两种功能：计算次数循环，遍历循环</p>
  <c:forEach var="i" begin="1" end="5" step="1">${i}</c:forEach>
  <%
  	request.setAttribute("names", new String[] { "Tom", "Andy", "Jerry" });
  %>
  <p>varStatus定义循环状态变量</p>
  <c:forEach var="n" items="${names}" varStatus="stat">
    <p>第${stat.index}${n}</p>
  </c:forEach>
  <fmt:formatNumber value="${price}" pattern="RMB###,###.00"></fmt:formatNumber>
  <fmt:formatDate value="${d}" pattern="yyyy-MM-dd HH-mm-ss" />
</body>
</html>

Tomcat,Servlet,Jsp（Filter,Listener）

猜你喜欢