Java Web开发技术

一、JSP：Java　Server　Page是一种运行在服务器端的Java页面

　1、使用能够JSP实现输出：

　　1-1：JSP对象输出显示

　　　out.prin();　向页面输出显示

　　　out.println();　向页面输出显示，在末尾加个空格

　　　★换行只能是<br/>

　　1-2：JSP注释

　　　HTML注释：<!--　HTML注释　-->，显示在源代码

　　　JSP注释：<%--　JSP注释　--%>，隐藏在源代码

　　　JSP脚本注释：<%　//JSP单行注释　%>、<%　/**JSP多行注释*/　%>，隐藏在源代码

　　1-3：转义字符

　　　\"　\"：引号引起来

　　1-4：JSP中声明和使用变量：<%String　变量名="内容";>

　　1-5：用变量实现页面输入：<%=变量名　%>

　　1-6：使用<%@page　%>导包

　　1-7：<%%>：局部变量

　　　　　<%!%>：全局变量

　　1-8：Web程序常见的错误

　　　1>404错误——找不到访问的页面或资源

　　　　A：运行时，URL输入有误

　　　　B：将页面放在WEB-INF下

　　　　C：外部启动Tomcat，未部署项目

　　　2>500错误——JSP页面代码有误

　　　3>页面无法显示：未启动Tomcat

　2、内置对象：JSP已经准备好的，可以直接使用的对象

　　2-1：请求对象：request（客户端发送请求）

　　2-2：输出对象：out

　　2-3：响应对象：response（服务器接受请求——200状态码）

　　2-4：应用程序对象：application

　　2-5：会话对象：session

　　2-6：页面上下文对象：pageContext

　　2-7：页面对象：page

　　2-8：配置对象：config

　　2-9：异常对象：exception

　3、request对象常用方法

　　3-1：String　getParameter(String　name)：根据表单组件名称获取提交数据

　　3-2：String[]　getParameterValues(String　name)：获取表单组件对应多个值时的请求数据

　　3-3：void　setCharacterEncoding(String　charset)：指定每个请求的编码

　　3-4：RequestDispatcher　getRequestDispatcher(String　path)：返回一个RequestDispatcher对象，该对象的forward()方法用于转发请求

　4、页面间的数据传递

　　4-1：使用属性存取数据

　　　1>setAttribute()：在请求中保存属性

　　　　public　void　setAttribute(String　name,Object　o);

　　　2>getAttribute()：在请求中获取属性

　　　　public　Object　getAttribute(String　name);

　　★在读取属性中保存的数据时，必须将数据转换成其最初的类型：String　mess=(String)request.getAttribute("mess");

　　　在使用属性值的时候要做非空判断，否则会出现空指针异常

　　4-2：转发与重定向

　　　1>转发：是服务器行为——RequestDispatcher对象、forward()方法（1个请求，返回200状态码，失败时返回页面）

　　　　语法：A：request.getRequestDispatcher("url").forward(request,response);

　　　　　　　B、<jsp:forward　page="url"　/>

　　　2>重定向：是客户端行为——将用户请求重新定位到一个新的URL（2个请求，第一个返回302状态码，第二个返回200状态码，成功时转到另一个页面）

　　　　语法：response.sendRedirect("url");

　5、Session会话对象：数据保存在服务器

　　5-1：Session保存和读取数据的方法

　　　使用Session保存数据：session.setAttribute(String　key,Object　value)

　　　从Session中读取数据：(Object)session.getAttribute(String　key);

　　5-2：Session对象常用方法（单用户）

　　　getId()：获取sessionId

　　　invalidate()：设置session对象失效

　　　setMaxInactiveInterval(int　interval（单位：秒）)：设置session的有效期

　　　removeAttribute(String　key)：移除session中的属性

　　5-3：Session的有效期

　　　在Tomcat服务器的web.xml文件中<web-app>和</web-app>之间添加：

　　　　　　<session-config><session-timeout>分钟</session-timeout></session-config>

　6、Cookie：以文件方法保存数据的，保存在客户端 

　　6-1：Cookie的应用（在JSP中使用Cookie）

　　　1>创建Cookie对象

　　　　Cookie　cookieName=new　Cookie(String　key,Object　value);

　　　2>写入Cookie

　　　　response.addCookie(cookieName);

　　　3>读取Cookie

　　　　Cookie[]　cookies=request.getCookies();

　　6-2：Cookie常用方法

　　　setValue(String　value)：创建Cookie后，为Cookie进行赋值

　　　getName()：获取Cookie的名称

　　　getValue()：获取Cookie的值

　　　getMaxAge()：获取Cookie的有效期，以秒为单位

　　　setMaxAge(int　expiry)：设置Cookie的有效期，以秒为单位

　6、application：实现统计页面的访问次数（多用户共享）

　　　setAttribute(String　key,Object　value)：以key-value的形式保存对象值

　　　getAttribute(String　key)：通过key获取对象值

　7、request、session、application三个对象对比

　　相同点：都可以存储属性

　　不同点：request中存储的数据仅在一个请求中可用

　　　　　　session中存储的数据在一个会话的有效期内可用

　　　　　　application中存储的数据在整个Web项目中可用

二、JDBC和JavaBean操作数据库

　1、JDBC是一中Java数据库连接技术，能实现Java程序对各种数据库的访问。

　2、JDBC访问数据库的五步骤：

　　2-1：加载驱动（找到jar包→com.msyql.jdbc→Drivere.class）

　　　　Class.forName("JDBC驱动类的名称");

　　　★mysql：com.mysql.jdbc.Driver

　　　　oracle：oracle.jdbc.driver.OracleDriver

　　2-2：使用DriverManager类获取数据库的连接

　　　　Connection　connection=DriverManager.getConnection(数据库URL，数据用户名，密码);

　　　★mysql 的URL：jdbc:mysql://localhost:3306/数据库名

　　　　oracle的URL：jdbc:oracle:thin@localhost:1521:数据库名

　　2-3：获取Statement对象，执行sql语句

　　　1>定义sql语句：String　sql = "select　*　from　表名";

　　　2>先创建Statement接口：Statement　st = connection.createStatement();

　　　3>获取结果对象：ResultSet　rs = st.executeQuery(sql);

　　2-4：处理结果

　　　while (rs.next()){　}

　　2-5：释放资源

　　　　rs.close();
　　　　st.close();
　　　　connection.close();

　3、设置配置文件

　　3-1：创建database.properties文件

　　3-2：构建数据库访问的工具类，来读取配置文件

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

//读取配置文件的工具类-单例模式
public class ConfigManager {
	// 读取配置properties.load(inputStream)
	private static ConfigManager configManager;
	private static Properties properties;

	// 在构造工具类时，进行配置文件的读取
	private ConfigManager() {
		String configFile = "database.properties";
		properties = new Properties();
		InputStream is = ConfigManager.class.getClassLoader()
				.getResourceAsStream(configFile);
		try {
			// 读取配置文件
			properties.load(is);
			is.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	// 通过单例模式设置实例化的个数
	public static ConfigManager getInstance() {
		if (configManager == null) {
			configManager = new ConfigManager();
		}
		return configManager;
	}

	// 通过key获取对应的value
	public String getString(String key) {
		return properties.getProperty(key);
	}
}

　4、Statement与PreparedStatement区别

　　4-1：Statement由方法createStatement()创建，该对象用于发送简单的sql语句

　　4-2：PreparedStatement由方法preparedStatement()创建，该对象用于发送带有一个或者多个输入参数的sql语句

　　　sql语句用“?”作为数据占位符、使用setXxx()方法设置数据

　5、连接池与数据源

　　5-1：连接池、连接、数据源的关系

　　　1>连接池：里面放着连接对象，并管理连接对象的（连接对象是保持与数据库连接的）

　　　2>数据源DataSource：用来获取连接对象，连接数据库（直接从数据源中获取连接）

　　　3>如何获取DataSource：由Tomcat容器创建，在程序里使用JNDI来获取

　　　4>通过数据源创建的连接对象被统一的放入到连接池中进行管理

　　5-2：在Toacat中配置数据源步骤：

　　　1>Tomcat中加入数据库驱动文件

　　　2>配置Tomcat的conf/context.xml

<span style="white-space:pre">	</span><Resource name="jdbc/news" 
              auth="Container"  type="javax.sql.DataSource"  maxActive="100" 
              maxIdle="30" maxWait="10000" username="root"  password="" 
              driverClassName="com.mysql.jdbc.Driver" 
              url="jdbc:mysql://localhost:3306/news"/>

　　　　★name：数据源名称，通常采取　jdbc/数据库名

　　　　　auth：连接池的归属权

　　　　　type：类型

　　　　　maxActive：并发连接的最大活动数。　0：无限制

　　　　　maxIdle：连接池中空闲的连接的个数

　　　　　maxWait：等待连接的最大连接的时间　-1：无限等待下去

　　　　　username、password：数据库用户名、密码

　　　　　driverClassName：驱动程序名称

　　　　　url：访问数据库路径

　　　3>使用JNDI获取连接对象

　　　　　A、 初始化上下文
　　　　　　Context　ctx = new　InitialContext();
　　　　　B、获取与逻辑名相关联的数据源对象
　　　　　　DataSource　ds = (DataSource) ctx.lookup("java:comp/env/数据源名称");
　　　　　　connection = ds.getConnection();

　　　4>调用数据源得到连接

　　　　　需要实例化获取数据源方法所在类，然后调用获取数据源的方法就可以得到一个Connection对象

　6、JavaBean：是一个java类。封装数据、业务逻辑

　　　DAO层：对数据进行增删改查操作，访问数据接口

　　　util层：读取配置文件的工具类

　　　entity/POJO层：实体类，JavaBean封装数据

　　　service层：业务层，负责业务逻辑，对dao的方法进行封装调用，主要负责和业务逻辑相关的操作

　7、JSP标签

　　7-1：JSP动作标签

　　　1><jsp:useBean>：在JSP中创建一个JavaBean的实例，并指定它的名称和作用范围，可发挥Java组件重用的优势

　　　　　语法：<jsp:useBean　id="name"　class="package.class"　scope="scope">

　　　　　　　id：JavaBean的引用名

　　　　　　　class：JavaBean类的完整限定名

　　　　　　　scope：JavaBean的作用范围，默认page

　　7-2：JSP页面包含：把指定文件插入正在生成的页面

　　　1>动态包含：先执行页面代码，再将页面包含，即将一个页面的运行结果包含到另一个页面上

　　　　　语法：<jsp:include　page="相对URL地址"　/>

　　　2>静态包含：先将页面包含，再执行页面代码，即将一个页面的代码复制到另一个页面上（适用于公共的CSS、JS代码）

　　　　　语法：<%@include　file="url"　%>

　　7-3：JSP页面跳转

　　　<jsp:forward　page="URL"　/>

三、第三方控件与分页查询

　1、第三方控件：commons-fileupload（Java的）

　　1-1：FileItem接口的常用方法

　　　1>getFieldName()：返回表单字段的name属性值

　　　2>isFormField()：判断FileItem封装的数据是属于普通表单还是文件表单　true：普通表单　false：文件表单

　　　3>getName()：返回上传文件字段中的文件名

　　　4>write(File　file)：将FileItem对象中的内容保存到指定文件中

　　　5>getString(String　encoding)：按照指定编码格式将内容转换成字符串返回

　　1-2：FileItemFactory接口与DiskFileItemFactory类

　　　1>FileItemFactory是一个接口，是用于构建FileItem实例的工厂

　　　2>DiskFileItemFactory类是FileItemFactory接口的实现类，在使用中，可以构造一个FileItemFactory接口类型的实例：

　　　　　　FileItemFactory　factory=new　DiskFileItemFactory();

　　1-3：ServleFileUpload类：用于处理文件上传的核心类，

　　　1>作用：以List形式返回每一个被封装成FileItem类型的表单元素集合

　　　2>构造语法：public　ServleFileUpload(FileItemFactory　fileitemfactory)

　　　3>常用方法

　　　　A、isMultpartContent(HttpServleRequest　request)：静态方法，用于判断请求数据中的内容是否是multipart/form-data类型

　　　　B、parseRequest(HttpServleRequest　request)：将请求数据中的每一个字段，单独封装成FileItem对象，并以集合方法返回

　2、使用commons-fileupload组件实现图片上传步骤

　　2-1：获取组件

　　　commons-fileupload-1.2.2.jar、commons-io-2.4.jar

　　2-2：修改页面

　　　1>修改表单：method="post"　enctype="multipart/form-data"

　　　2>设置上传文件的标签：<input type="file"　name="picPath"　value=""　/>

　　2-3：在JSP中实现文件上传

　　　1>判断表单提交内容形式

　　　　boolean　isMultiPart = ServletFileUpload.isMultipartContent(request);

　　　　if (isMultiPart){　处理文件上传}

　　　2>创建文件谁能够穿所有的API实例

　　　　A、创建FileItemFactory实例：FileItemFactory　factory = new　DiskFileItemFactory();

　　　　B、创建文件上传的核心类ServletFileUpload：ServletFileUpload　upload = new　ServletFileUpload(factory);

　　　3>解析request请求

　　　　List<FileItem>　items = upload.parseRequest(request);

　　　4>循环遍历集合中的数据

	//获取迭代器 
	Iterator<FileItem> iters = items.iterator();
	while (iters.hasNext()) {
		FileItem item = iters.next();
		//判断fileItem是文本域还是文件域
		if (item.isFormField()) {//若是普通的文本表单控件
			//获取文本域name的值
			String fieldName = item.getFieldName();
			if (fieldName.equals("categoryId")) {
				news.setCategoryId(Integer.parseInt(item.getString()));
			} else if (fieldName.equals("title")) {
				news.setTitle(item.getString("utf-8")); //获取文本域value的值
			}。。。。。。
		} else {//若是文件表单控件
			//上传文件名称（全路径）
			String fileName = item.getName();
			//userId+系统时间+随机数.doc
			if (fileName != null && !fileName.equals("")) {
				File fullFile = new File(fileName);
				//把文件上传到指定的目录下
				File saveFile = new File(uploadPath,fullFile.getName());
				//上传操作
				item.write(saveFile);
				news.setPicPath(fullFile.getName());
			}
		}	
	}

　3、CKEditor：网页中实现所见所得的编辑器（JS的）

　　3-1：使用步骤

　　　1>下载CKEditor

　　　2>解压到项目到WebRoot中

　　　3>在页面中加入CKEditor：<script　src="<%=request.getContextPath() %>/ckeditor/ckeditor.js" ></script>

　　　4>修改页面的<textarea>的属性：  添加"class=ckeditor"

　　　5>使用→提交

　4、分页查询

　　4-1：分页后台实现

　　　1>确定显示数据总数量：

　　　　　sql语句：select　count(*)　as　count　from　表名; 

　　　　　通过JDBC进行SQL语句执行：Object[]　params = {};

　　　　　　　　　　　　　　　　　　　ResultSet　rs = this.executeSQL(sql, params);

　　　　　获取总记录数：int　count = rs.getInt("count");

　　　2>计算显示页数

package com.util;

public class PageSupport {

	//总页数
	private int totalPageCount = 1;
	
	//总记录数
	private int totalCount = 0;
	
	//当前页面
	private int currentPageNo = 1;
	
	//页面容量（每页显示多少条）
	private int pageSize = 0 ;

	public int getTotalPageCount() {
		return totalPageCount;
	}

	public void setTotalPageCount(int totalPageCount) {
		this.totalPageCount = totalPageCount;
	}

	public int getTotalCount() {
		return totalCount;
	}

	public void setTotalCount(int totalCount) {
		if(totalCount > 0){
			this.totalCount = totalCount;
			//设置总页数
			this.setTotalPageCountByRs();
		}
	}

	public int getCurrentPageNo() {
		return currentPageNo;
	}

	public void setCurrentPageNo(int currentPageNo) {
		if(currentPageNo > 0){
			this.currentPageNo = currentPageNo;
		}
	}

	public int getPageSize() {
		return pageSize;
	}

	public void setPageSize(int pageSize) {
		if(pageSize > 0 ){
			this.pageSize = pageSize;
		}
	}

	//设置总页数
	public void setTotalPageCountByRs(){
		if(this.totalCount % this.pageSize == 0){
			this.totalPageCount = this.totalCount / this.pageSize;
		}else if(this.totalCount % this.pageSize > 0){
			this.totalPageCount = this.totalCount / this.pageSize + 1;
		}else{
			this.totalPageCount = 0;
		}
	}
}

　　　3>分页查询SQL语句　　　

　　　　　select　*　from　表名　order　by　createDate desc limit　起始位置，下标以0开始,页面容量;

　　　★总页数=总记录数　/　每页显示记录数

　　　　总页数=总记录数　/　每页显示记录数+1

　　　　起始记录数：（当前页码-1）×　每页显示的记录数+1;

　　　　结束记录数：当前页码　×　每页显示的记录数

　 　4-2：JSP中实现分页 

　　　1>确定当前页

	//页面容量
	int pageSize=2;
	
	//当前页面
	String pageIndex=request.getParameter("pageIndex");
	int currentPageNo = 1;;
	if(pageIndex == null){
		currentPageNo =1;
	}else{
		try{
			currentPageNo = Integer.parseInt(pageIndex);
		}catch(NumberFormatException e){
			response.sendRedirect("error.jsp");
		}
	}
	
	//总记录数
	int totalCount=newsService.getNewsCount();
	
	//总页数
	PageSupport pageSupport = new PageSupport();
	pageSupport.setPageSize(pageSize);
	pageSupport.setCurrentPageNo(currentPageNo);
	pageSupport.setTotalCount(totalCount);
	int totalPageCount =pageSupport.getTotalPageCount();

　　　

　　　2>页面分页设置

	<%-- 
	<%if(currentPageNo > 1){ %>
		<a href="newsDetailList.jsp?pageIndex=1">首页</a>
		<a href="newsDetailList.jsp?pageIndex=<%=currentPageNo-1%>">上一页</a>
	<%}if(currentPageNo < totalPageCount) {%>
		<a href="newsDetailList.jsp?pageIndex=<%=currentPageNo+1%>">下一页</a>
		<a href="newsDetailList.jsp?pageIndex=<%=totalPageCount %>">尾页</a>  
	<%} %>
	--%>
	<%if(currentPageNo > 1){ %>
		<a href="javaScript:page_nav(document.forms[0],1)">首页</a>
		<a href="javaScript:page_nav(document.forms[0],<%=currentPageNo-1%>)">上一页</a>
	<%}if(currentPageNo < totalPageCount) {%>
		<a href="javaScript:page_nav(document.forms[0],<%=currentPageNo+1%>)">下一页</a>
		<a href="javaScript:page_nav(document.forms[0],<%=totalPageCount %>)">尾页</a>  
	<%} %> 

　　　3>首页和尾页异常处理

	//首尾页的异常控制
	if(currentPageNo <1){
		currentPageNo = 1;
	}
	if(currentPageNo > totalPageCount){
		currentPageNo = totalPageCount;
	}

四、EL和JSTL

　1、EL语法

　　1-1：EL表达式：${EL表达式　}

　　1-2：EL操作符

　　　1>操作符“.”：获取对象的属性

　　　2>操作符“[]”：获取对象的属性、获取集合中的对象

　　★使用EL表达式之前，要先把变量放在作用域中

　　1-3：运算符（和java类似）

　　　empty：用于检测变量名是否为空，是否等于null

　　1-4：EL功能

　　　1>获取JavaBean对象的属性

　　　2>获取数组、List、Map类型对象的元素

　　　3>使用运算符进行数据处理

　　　4>屏蔽一些常见的异常

　　　5>自动实现类型转换

　　1-5：EL访问作用域

　　　1>pageScope：页面作用域→获取页面范围内的属性值

　　　2>requestScope：请求作用域→获取请求范围内的属性值

　　　3>sessionScope：会话作用域→获取会话范围内的属性值

　　　4>applicationScope：应用程序作用域→获取应用程序范围内的属性值

　2、JSTL：JSP标准标签库、实现JSP页面中的逻辑控制

　　2-1：JSTL使用步骤

　　　1>添加jar包（jstl.jar和standard.jar）

　　　2>在JSP页面添加指令：<%@ taglib　uri="http://java.sun.com/jsp/jstl/core"　prefix="c" %>

　　2-2：输出标签：用来显示数据

　　　1><c:out>

　　　　语法：<c:out　value="输出显示的表达式"　default="默认输出显示的值"　escapeXml="是否对输出的内容进行转义"　/>

　　　2><c:set>

　　　　设置变量的语法：<c:set　value="变量的值"　var="变量的名称"　scope="变量存在的作用范围">

　　　　设置对象属性的语法：<c:set　value="变量的值"　target="对象的名称"　property="对象的属性名称"　/>

　　　3><c:remove>

　　　　语法：<c:remove　var="变量的名称"　scope="变量存在的作用域范围"　/>

　　2-3：迭代标签<c:forEach>：可替换for循环语句

　　　语法：<c:foreach　var="集合中元素的名称"　items="集合对象"　varStatus="当前循环的状态信息">

　　2-3：条件标签<c:if/>：可替代if语句

　　　语法：<c:if　test="判断的条件"　var="判断的结果"　scope="判断结果存放的作用域">

　　2-4：超链接标签<c:url/>

　　　语法：<c:url　value="url">

　　2-5：超链接的参数标签<c:param>

　　　语法：<c:param　name="参数名称"　value="参数的值">

　　2-6：导入标签<c:import/>

　　　语法：<c:import　url="URL">

　　2-7：格式化日期标签<fmt:formatDate/>

　　　语法：<fmt:formatDate　value="时间对象"　pattern="显示格式"/>

五、Servlet、过滤器、监听器

　1、Servlet：接受请求，调用JavaBean去处理请求

　　1-1：Servlet　API：

　　　1>Servlet接口：Java　Servlet的基础接口，定义了Servlet必须实现的方法

　　　2>GenericServlet类：继承自Servlet接口，属于通用的，不依赖于协议的Servlet

　　　3>HttpServlet类：继承自GenericServlet类，是在其基础上扩展了HTTP协议的Servlet

　　　4>HttpServletRequest接口：继承自ServletRequest接口，用于获取请求数据的读取

　　　5>HttpServletResponse接口：继承自ServletResponse接口，用于返回响应数据

　　1-2：创建Servlet

　　　1>实现Servlet接口

　　　2>继承GenericServlet类

　　　3>继承HttpServlet类

　　1-3：Servlet中主要方法

　　　1>init()：Servlet的初始化方法，仅仅会执行一次

　　　2>service()：处理请求和生产响应

　　　3>destroy()：在服务器停止并且程序中的Servlet对象不再使用的时候调用，只执行一次

　　　4>ServletRequest：封装客户的请求信息，作用相当于JSP内置对象request

　　　5>ServletResponse：创建响应信息，将处理结果返回给客户端，作用相当于JSP内置对象response

　　　6>ServletConfig：包含了servlet的初始化参数信息

　　1-4：Servlet生命周期

　　　1>加载和实例化：创建Servlet的实例

　　　2>初始化：调用init()方法

　　　3>处理请求：调用servlet()方法

　　　4>销毁：调用destroy()方法

　　1-5：Servlet的部署：修改web.xml

  <servlet>
  	<servlet-name>servlet</servlet-name>　　类名
  	<servlet-class>cn.web.servlet.Servlet</servlet-class>　　包名+类名
  </servlet>
  
  <servlet-mapping>
  	<servlet-name>servlet</servlet-name>　　类名
  	<url-pattern>/servlet</url-pattern>　　<span style="font-family: Arial, Helvetica, sans-serif;">URL路径</span>
  </servlet-mapping>

　2、过滤器（Filter）：接口

　　2-1：过滤器的生命周期

　　　1>实例化

　　　2>初始化：调用init()方法

　　　3>执行过滤：调用doFilter()方法

　　　4>销毁：调用destory()方法

　　2-2：使用过滤器的步骤

　　　1>创建实现Filter接口的类

　　　2>在doFilter()中编写实现过滤的方法

　　　3>调用下一个过滤器或者web资源

　　　4>在web.xml文件中配置过滤器

  <filter>
  	<filter-name>过滤器名</filter-name>
  	<filter-class>过滤器的完全限定名</filter-class>
  </filter>
  <filter-mapping>
  	<filter-name>过滤器名</filter-name>
  	<url-pattern>过滤器映射的web资源</url-pattern>
  </filter-mapping>

　　2-3：应用场景

　　　1>对请求和响应进行统一处理

　　　2>对请求进行日志记录和审核

　　　3>对数据进行屏蔽和替换（上传代码时去掉空格，压缩代码）

　　　4>对数据进行加密和解密（认证）

六、监听器：web.xml配置（<listener><listener-class>监听器所属类的完全限定名</listener-class> </listener>）

　1、HttpSessionBindingListener监听（一对一）

　　1-1：创建用户类实现HttpSessionBindingListener接口

　　1-2：在valueBound()方法、valueUnbound()方法实现用户统计数量

　　1-3：在web.xml中进行监听配置　　　　

　2、HttpSessionListener监听（设置一次就可以监听所有的session）

　　方法：1>sessionCreated(HttpSessionEvent　event)

　　　　　2>sessionDestroyed(HttpSessionEvent　event)

　　　　　　　　执行session.invalidate()方法、session会话超时

　　在web.xml配置监听器

　3、ServletContextListener监听：启动服务时获取数据源（所有用户公用一个对象《application》）

　　contextInitialized、contextDestroyed

　★ServletContextListener：在Servlet上下文对象初始化或者销毁时得到通知

　　ServletContextAttributeListener：在Servlet上下文中的属性列表发生变化时得到通知

　　HttpSessionListener：在Session创建后或者失效前得到通知

　　HttpSessionActivationListener：实现该接口的对象，如果绑定到Session中，当Session被钝化或者激活时，Servlet容器将通知该对象

　　在web.xml配置监听器