idea 快捷键
ctrl + alt + b implementation(查找谁继承或者是实现了本类)查找实现类
ctrl + H Hierarchy 查找继承
ctrl + i 实现接口
ctrl + b 查找在哪里申明 == ctrl + 左键
ctrl + alt + shift + u 关系树
ctrl + o 重写超类中的方法
ctrl + shift + U 大小写转换
ctrl + d 将当前行复制到下一行
ctrl + y 删除当前行

1.抽象类和接口的区别：

    1.抽象类是用来捕捉子类的通用特性，而接口则是抽象方法的集合；
    2.抽象类不能被实例化，只能被用作子类的超类，是被用来创建继承层级的模板，而接口只是一种形式，接口自身不能做任何事情。
    3.抽象类可以有默认的方法实现，子类使用extends关键字来继承抽象类，如果子类不是抽象类，他需要提供抽象类中所有声明方法的实现。而接口完全是抽象的，不存在方法的实现，子类使用关键字implements来实现接口，它需要提供接口所有的声明方法的实现。
    4.抽象类可以有构造器，除了不能实现抽象类外，与一般java类无区别，抽象方法可以用public,protect,default这些修饰符。而接口不能有构造器，是完全不同的类型，接口方法默认的修饰符是public，不能使用其他修饰符。

2.Set和List的区别

    1.Set接口实例存储是无序的，不重复的数据。List接口实例存储的有序的，可以重复的元素。
    2.Set检索效率低下，删除和插入效率高，插入删除不会引起元素位置的改变<实现类有HashSet, TreeSet>.
    3.List和数组类似，可以动态增长，根据实际存储的数据长度自动增长List的长度。查找效率高，插入效率低。因为会引起其他位置的改变<实现类有ArrayList,LinkList,Vector>.

3.HashMap

    1.HashMap是一个散列表，存储内容是键值对
    2.HashMap实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null,不支持同步。
    3.HashMap是无序的，即不会记录插入的顺序。
    4.HashMap继承于AbstructMap,实现了Map,Cloneable,java.io.Serializable接口。

4.权限数据库设计

抽象类
    抽象类里边可以有抽象方法和实现方法
    如果抽象类继承了一个接口，可以选择实现或者继续抽象接口中的方法,但不是必须的，如果没写，但孙子类必须实现
    一个普通类继承抽象类，抽象类实现接口：
        (1)抽象类 重写并继续抽象接口中某方法，则普通子类必须重写并实现该抽象方法
        (2)抽象类 重写并实现接口中某方法，则普通子类：
            分支(1)普通子类可以不重写该抽象方法，此时接口引用普通子类的实例并执行该接        口方法时，调用抽象类的方法实现
            分支(2)普通子类可以选择重写父抽象类的方法，此时接口引用普通子类的实例，并执行该接口方法时，调用普通子类的方法实现

集合

Map

    1.通常遍历map需要使用map实例，entrySet()方法，得到Map.Entry<String,Object>
    2.执行map实例.keySet方法可以得到map里key的集合是一个Set<K>,所以map的key符合Set的特性，比如唯一
    3.执行map实例.keyValues()方法可以得到map里key的集合是一个Collection<Object>,所以map的Values符合List的特性，比如可重复

    Set遍历无序且唯一
    new LinkedHashMap<>();可使之有序

接口

implements表示实现接口，其继承关系，相当于继承，例如：类A implements 接口B,那么类A是B的子类

Jsp

#### get和post
Get url中会显示参数，传输是明文，不安全
    由于所有的信息都在url中，可能导致url过长，造成服务器错误，不能传较大的数据
    书写简单，使用方便，可以在url中通过？参数的方式直接传值
Post url中不显示参数，安全
     由于数据并不在url中，可以传输较大的数据
     使用相对复杂，无法在url中直接传值
一、静态网页知识回顾
1HTML标签
2CSS样式
3Java Script 或Jquery
二、JSP基础知识回顾
2.1  JSP运行过程



2.2  JSP元素组成
JSP文件由6类基本元素组成：
JSP指令
JSP声明
JSP表达式
JSP脚本
JSP动作
JSP注释

2.2.1  JSP指令（背过）
JSP指令的语法格式如下：
<%@ 指令名 属性="值" 属性="值"%>
常用的三种指令为：
page指令
include指令
taglib指令
2.2.1.1  page指令
page指令用于设置页面的各种属性，如导入包、指明输出内容类型、控制Session等。page指令一般位于JSP页面的开头部分，一个JSP页面可包含多条page指令。
例如：
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
2.2.1.2  include指令
include指令用于在当前JSP中包含其他文件。被包含的文件可以是JSP、HTML或文本文件。包含的过程发生在将JSP翻译成Servlet时，当前JSP和被包含的JSP会融合到一起，形成一个Servlet，然后进行编译并运行。
例如：
<%@ include file="./top.jsp" %>
2.2.1.3  taglib指令
taglib指令用于指定JSP页面所使用的标签库，通过该指令可以在JSP页面中使用标签库中的标签。
例如：
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

2.2.2  JSP声明
JSP声明用于在JSP页面中定义变量和方法。JSP声明通过“<%! %>”定义。一个JSP页面可以有多个声明，并且每个声明中可以同时定义多个变量或方法，其中，每个JSP声明只在当前JSP页面中有效。
JSP声明的语法格式如下：
<%! 声明的内容 %>
例如：
<%! 
        long  countNum = 0;
        //人数自增长方法
        public synchronized void addNumber(){
            countNum ++;
        }
    %>
2.2.3  JSP表达式（了解）
JSP表达式用于将Java表达式的运行结果输出在页面中。JSP表达式通过“<%= %>”定义。在JSP表达式中可以包含任何一个有效的Java表达式。当请求JSP页面时，表达式会被运行并将结果转化成字符串插入到该表达式所在的位置上。
JSP表达式的语法格式如下：
<%=表达式%>
例如：
    <p>您是第 <font color="red"> <b><%= countNum %></b></font> 个访问本页面的用户</p>
2.2.4  JSP脚本（了解）
JSP脚本用于在JSP页面中插入Java代码，JSP脚本通过“<%”和“%>”定义，其中可以包含任何符合Java语法的代码。JSP脚本在服务器端执行，当JSP页面被请求时，页面上的JSP脚本会从上到下依次执行。
JSP脚本的语法格式如下：
<% Java代码 %>
例如：
<%
        addNumber();
    %>
2.2.5  JSP动作标签（有印象）
    Jsp中有6个动作标签：include、forward、useBean、getProperty、setProperty、plugin。
2.2.5.1  include标签
<jsp:include>标签表示包含一个静态的HTML或者动态的JSP文件。
语法：
<jsp:include page="path" flush="true" />
或
<jsp:include page="path" flush="true">
<jsp:param name="paramName" value="paramValue" />
</jsp:include>
注意：
1、page="path" 为相对路径，或其表达式。
2、flush="true" 必须设置flush为true，因为它默认值是false。
3、<jsp:param>子句能传递一个或多个参数给动态文件，也可在一个页面中使用多个<jsp:param>来传递多个参数给动态文件。
例如：
<jsp:include page="../top.jsp"></jsp:include>

<jsp:include/>与 <%@ include/%> 之间的区别：
1、<%@ include/%> 将引用文件a.jsp的内容加入到b.jsp中一起进行编译，然后运行显示；<jsp:include /> 是将引用文件a.jsp的内容和b.jsp的内容各自独立编译，在运行的时候再将a.jsp加入到b.jsp内容当中进行显示，并可以传递参数。
2、<%@ include/%> 是静态引用，不会实时检查引用文件内容变化，适用于引用静态页面；<jsp:include/>是动态引用，会实时检查引用文件内容变化，适用于引用动态页面，并且可以带参数。



2.2.5.2  forward标签
<jsp:forward>标签表示重定向一个静态html/jsp的文件，或者是一个程序段。
语法：
<jsp:forward page="path"} />
或
<jsp:forward page="path"} >
<jsp:param name="paramName" value="paramValue" />
</jsp:forward>
注意：
1、page="path" 为一表达式，或一个字符串。
2、<jsp:param> name 指定参数名，value指定参数值。参数被发送到一个动态文件，参数可以是一个或多个值，而这个文件却必须是动态文件。
要传递多个参数，则可在一个JSP文件中使用多个<jsp:param>将多个参数发送到一个动态文件中。
例如：
<jsp:forward page="../top.jsp"></jsp:forward>
2.2.5.3  useBean标签
<jsp:useBean>标签表示用来在JSP页面中创建一个BEAN实例并指定它的名字以及作用范围。
语法：
<jsp:useBean id="name" scope="page | request | session | application"  typeSpec />
其中typeSpec有以下几种可能的情况：
class="className" | type="typeName" 
| class="className" type="typeName" 
| beanName="beanName" type="typeName" 
注：
必须使用class或type，但不能同时使用class和beanName。beanName表示Bean的名字。

例如：
<jsp:useBean id="user" scope="page" class="com.hyg.pojo.User"></jsp:useBean>

2.2.5.4  setProperty标签
<jsp:setProperty>标签表示用来设置Bean中的属性值。
语法：
<jsp:setProperty name="beanName" prop_expr />
其中prop_expr有以下几种可能：
property="*" | property="propertyName" | property="propertyName" param="parameterName" | property="propertyName" value="propertyValue"
注意：
使用 jsp:setProperty 来为一个Bean的属性赋值；可以使用两种方式来实现。
1、在jsp:useBean后使用jsp:setProperty：
<jsp:useBean id="user" … />
…
<jsp:setProperty name="user" property="userNo" … />
在这种方式中，jsp:setProperty将被执行。
2、jsp:setProperty出现在jsp:useBean标签内：
<jsp:useBean id="user" … >
…
<jsp:setProperty name="user" property="userNo" … />
</jsp:useBean>
在这种方式中，jsp:setProperty只会在新的对象被实例化时才将被执行。

2.2.5.5  getProperty标签
<jsp:getProperty>标签表示获取Bean属性的值并将之转化为一个字符串，然后将其插入到输出的页面中。
语法：
<jsp:getProperty name="name" property="propertyName" />
注意：
1、在使用<jsp:getProperty>之前，必须用<jsp:useBean>来创建它。
2、不能使用<jsp:getProperty>来检索一个已经被索引了的属性。
3、能够和JavaBeans组件一起使用<jsp:getProperty>，但不能与Enterprise Java Bean一起使用。
例如：
    用户名：<jsp:getProperty property="userNo" name="user"/><br/>

2.2.5.6  plugin标签
<jsp:plugin>元素用于在浏览器中播放或显示一个对象（典型的就是applet和Bean),而这种显示需要在浏览器的java插件，因此有可能的话还要下载一个java插件用于执行它。
2.3  Jsp内置对象（背过+精通）
JSP内置对象是指由JSP容器加载的，不用声明就可以直接在JSP页面中使用的对象。JSP中有9个内置对象，下表所示。
JSP内置对象
属性名 说明  作用域
request 客户端的请求，包含所有从浏览器发往服务器的请求信息   request
response    返回客户端的响应    page
session 会话对象，表示用户的会话状态  session
application 应用上下文对象，作用于整个应用程序   application
out 输出流，向客户端输出数据    page
pageContext 用于存储当前JSP页面的相关信息    page
config  JSP页面的配置信息对象    page
page    表示JSP页面的当前实例    page
exception   异常对象，用于处理JSP页面中的错误  page
2.3.1  request对象（精通）
request 对象是 javax.servlet.httpServletRequest类型的对象。 该对象代表了客户端的请求信息，主要用于接受通过HTTP协议传送到服务器的数据。（包括头信息、系统信息、请求方式以及请求参数等）。request对 象的作用域为一次请求。
2.3.2  response对象（精通）
response 代表的是对客户端的响应，主要是将JSP容器处理过的对象传回到客户端。response对象也具有作用域，它只在JSP页面内有效。
2.3.3  session对象（精通）
session 对象是由服务器自动创建的与用户请求相关的对象。服务器为每个用户都生成一个session对象，用于保存该用户的信息，跟踪用户的操作状态。 session对象内部使用Map类来保存数据，因此保存数据的格式为 “Key/value”。 session对象的value可以使复杂的对象类型，而不仅仅局限于字符串类型。
2.3.4  application对象（掌握）
 application 对象可将信息保存在服务器中，直到服务器关闭，否则application对象中保存的信息会在整个应用中都有效。与session对象相比，application对象生命周期更长，类似于系统的“全局变量”。
2.3.5  out 对象
out 对象用于在Web浏览器内输出信息，并且管理应用服务器上的输出缓冲区。在使用 out 对象输出数据时，可以对数据缓冲区进行操作，及时清除缓冲区中的残余数据，为其他的输出让出缓冲空间。待数据输出完毕后，要及时关闭输出流。
2.3.6  pageContext 对象(掌握)
pageContext 对象的作用是取得任何范围的参数，通过它可以获取 JSP页面的out、request、reponse、session、application 等对象。pageContext对象的创建和初始化都是由容器来完成的，在JSP页面中可以直接使用 pageContext对象。
2.3.7  config 对象
config 对象的主要作用是取得服务器的配置信息。通过 pageConext对象的 getServletConfig() 方法可以获取一个config对象。当一个Servlet 初始化时，容器把某些信息通过 config对象传递给这个 Servlet。 开发者可以在web.xml 文件中为应用程序环境中的Servlet程序和JSP页面提供初始化参数。
2.3.8  page 对象（掌握）
page 对象代表JSP本身，只有在JSP页面内才是合法的。 page隐含对象本质上包含当前 Servlet接口引用的变量，类似于Java编程中的 this 指针。
2.3.9  exception 对象
exception 对象的作用是显示异常信息，只有在包含 isErrorPage="true" 的页面中才可以被使用，在一般的JSP页面中使用该对象将无法编译JSP文件。excepation对象和Java的所有对象一样，都具有系统提供的继承 结构。exception 对象几乎定义了所有异常情况。在Java程序中，可以使用try/catch关键字来处理异常情况； 如果在JSP页面中出现没有捕获到的异常，就会生成 exception 对象，并把 exception 对象传送到在page指令中设定的错误页面中，然后在错误页面中处理相应的 exception 对象。
例如：
在jsp4.jsp页面，添加<%@ page errorPage="error.jsp" %> 指定错误处理页面，并在当前页面发生一个异常信息。在error.jsp页面添加<%@ page isErrorPage="true" %> 指定当前页面是错误处理页面，将错误信息显示出来。

三、Servlet 知识点回顾（精通）
3.1  Servlet使用配置
   创建Servlet需要首先需要创建一个Servlet类，并且这个类需要继承HttpServlet，然后重写doGet()/doPost()方法实现业务逻辑流程。TestServlet.java代码如下：

public class TestServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    public void init(ServletConfig config) throws ServletException {
        // TODO Auto-generated method stub
        System.out.println("进入TestServlet。。。。。。。。。。。。。。。");
    }
    public void destroy() {
        // TODO Auto-generated method stub
        System.out.println("销毁TestServlet。。。。。。。。。。。。。。。");
    }

    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        System.out.println("调用service()方法。。。。。。");

        response.setContentType("text/html");
        response.setCharacterEncoding("UTF-8");
        PrintWriter out = response.getWriter();
        out.append("welcome to  英谷教育");
        out.flush();
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("调用doGet()方法。。。。。。。。。。。。");
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("调用doPost()方法.................");
    }

}
其次需要配置Web.xml文件，在该文件中指定自定义的Servlet的信息即可。Web.xml中Servlet的配置信息如下：
  <servlet>
    <servlet-name>TestServlet</servlet-name>
    <servlet-class>com.hyg.servlet.TestServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>TestServlet</servlet-name>
    <url-pattern>/TestServlet</url-pattern>
  </servlet-mapping>

注意：
<servlet-name/>是自定义的servlet名称（唯一）；<servlet-class> 用于指定当前servlet所在的类路径 ；<url-pattern> 用于指定进入当前servelt时访问的url地址。
3.2  Servlet声明周期 精通  
Servlet生命周期概括为以下几个阶段：
1)装载Servlet：这项操作一般是动态执行的，有些服务器提供了相应的管理功能，可以在启动的时候就装载Servlet；
2)创建一个Servlet实例：容器创建Servlet的一个实例对象；
3)初始化：容器调用init()方法对Servlet实例进行初始化；
4)服务：当容器接收到对此Servlet的请求时，将调用service()方法响应客户的请求；
5)销毁：容器调用destroy()方法销毁Servlet实例。
3.3  重定向和请求转发 （精通）
3.3.1  重定向（精通）
重定向是指页面重新定位到某个新地址，之前的Request失效，进入一个新的Request，且跳转后浏览器地址栏内容将变为新的指定地址。重定向是通过HttpServletResponse对象的sendRedirect()来实现，该方法用于生成302响应码和Location响应头，从而通知客户端去重新访问Location响应头中指定的URL，其语法格式如下：
pubilc void sendRedirect(java.lang.String location)throws java.io.IOException
其中：
location参数指定了重定向的URL，它可以是相对路径也可是绝对路径。
sendRedirect()不仅可以重定向到当前应用程序中的其他资源，还可以重定向到其他应用程序中的资源，例如：
    response.sendRedirect("http://www.baidu.com"); 
3.3.2  请求转发（精通）
请求转发是指将请求再转发到另一页面，此过程依然在Request范围内，转发后浏览器地址栏内容不变。请求转发使用RequestDispatcher接口中的forward()方法来实现，该方法可以把请求转发到另外一个资源，并让该资源对浏览器的请求进行响应。
RequestDispatcher接口有两个方法：
forward()方法：请求转发，可以从当前Servlet跳转到其它Servlet；
include()方法：引入其他Servlet的内容。
RequestDispatcher是一个接口，通过使用HttpRequest对象的getRequestDispalcher()方法可以获得该接口的实例对象，例如：
RequestDispatcher rd = request.getRequestDispatcher(path);
rd.forward(request,response);
3.3.3 重定向和请求转发的区别
1、请求转发只能将请求转发给同一个Web应用中的组件，而重定向不仅可以重定向到当前应用程序中的其他资源，还可以重定向到其他站点的资源。
2、重定向的访问过程结束后，浏览器地址栏中显示的URL会发生改变，由初始的URL地址变成重定向的目标URL；而请求转发访问过程结束后，浏览器地址栏保持初始的URL地址不变。
3、请求转发的调用者与被调用者之间共享相同的request对象和response对象；而重定向的调用者和被调用者使用各自的request对象和response对象，它们属于两个独立的请求和响应过程。
3.4   Session（精通）和内置对象的session不同
3.4.1  session生命周期
Session生命周期经过以下几个过程：
1)客户端向服务器第一次发送请求的时候，request中并无SessionID。
2)此时服务器会创建一个Session对象，并分配一个SessionID。Serssion对象保存在服务器端，此时为新建状态，调用session.isNew()返回true。
3)当服务器端处理完毕后，会将SessionID通过response对象传回到客户端，浏览器负责保存到当前进程中。
4)当客户端再次发送请求时，会同时将SessionID发送给服务器。
5)服务器根据传递过来的SessionID将这次请求（request）与保存在服务器端的Session对象联系起来。此时Session已不处于新建状态，调用session.isNew()返回false。
6)循环执行过程3-5，直到Session超时或销毁。
3.4.2  Session的常用方法
3.4.2.1 获取session
HttpSession session=request.getSession();//获取当前Session
3.4.2.2 在session中存取数据
用于存取数据的方法有：
setAttribute()：用于在Session对象中保存数据，数据以Key/Value映射形式存放。
getAttribute()：从Session中提取指定Key对应的Value值。
向Session对象中保存数据的示例代码如下：
//将username保存到Session中，并指定其引用名称为uName
session.setAttribute("uName", username);
从Session中提取存放的信息，则代码如下：
//取出数据，注意：因该方法的返回数据类型为Object，所以需要转换数据类型。
String username = (String)session.getAttribute("uName");
3.4.2.3  销毁session
用于销毁Session的方法是：
invalidate()：调用此方法可以同时删除HttpSession对象和数据。
使用invalidate()销毁Session的示例代码如下：
//销毁Session（常用于用户注销）
session.invalidate();
3.5  ServletContext接口（掌握）
Servlet上下文是运行Servlet的逻辑容器。同一个上下文中的所有Servlet共享存于其中的信息和属性。在Servlet API中定义了一个ServletContext接口，用于存取Servlet运行的环境或者上下文信息。ServletContext对象可以通过使用ServletConfig对象的getServletContext()方法获得，在Servlet中提供了getServletContext()方法也可以直接获得ServletContext对象。
ServletContext ctx = this.getServletContext();
ServletContext接口中定义了许多有用的方法，其中getAttribute()、setAttribute()、removeAttribute()和getInitParameter()是在Web开发中比较常用的方法。
Integer counter = (Integer) ctx.getAttribute("UserNumber");
tx.setAttribute("UserNumber", counter);
3.5.1  ServletContext的生命周期
ServletContext的生命周期过程如下：
1）新Servlet容器启动的时候，服务器端会创建一个ServletContext对象；
2）在容器运行期间ServletContext对象一直存在；
3）当容器停止时，ServletContext的生命周期结束。
3.5.2  ServletContext的配置和使用
Web.xml的配置信息如下：
  <!-- servletContext初始化配置 -->
    <context-param>   
        <param-name>url</param-name>   
        <param-value>jdbc:mysql://localhost:3306/servlet</param-value>   
    </context-param>
    <context-param>   
        <param-name>driver</param-name>   
        <param-value>com.mysql.jdbc.Driver</param-value>   
    </context-param>
    <context-param>   
          <param-name>user</param-name>   
          <param-value>yjx</param-value>   
    </context-param>      
    <context-param>   
         <param-name>password</param-name>   
         <param-value>yjx123</param-value>   
     </context-param>   

TestServletContextServlet.java中的代码如下：
// 获得ServletContext对象
ServletContext ctx = this.getServletContext();
// 获得web.xml中设置的初始化参数   连接数据库的基本信息
String url = ctx.getInitParameter("url");
url = url + "?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull";
String driver = ctx.getInitParameter("driver");
String user = ctx.getInitParameter("user");
String password = ctx.getInitParameter("password");
3.6  监听器（熟悉）
Servlet监听器的作用是监听Servlet应用中的事件，并根据需求作出适当的响应。
Listener接口和Event类
监听对象    Listener    Event
监听Servlet上下文    ServletContextListener  ServletContextEvent
    ServletContextAttributeListener ServletContextAttributeEvent
监听Session   HttpSessionListener HttpSessionEvent
    HttpSessionActivationListerner  
    HttpSessionAttributeListener    HttpSessionBindingEvent
    HttpSessionBindingListener  
监听Request   ServletRequestListener  ServletRequestEvent
    ServletRequestAttributeListener ServletRequestAttributeEvent
3.6.1  监听器配置
在web.xml中配置监听器的格式如下：
<listener>
    <listener-class>监听类</listener-class>
</listener>
例如：
<!-- 监听器配置 -->
 <listener>
    <listener-class>
com.hyg.listener.OnlineSessionListener
</listener-class>
</listener>
3.6.2  监听器的使用
以监听session为例，统计当前在线人数，创建一个监听器，实现HttpSessionListener接口，并重写接口方法，具体代码如下所示:
public class OnlineSessionListener implements HttpSessionListener {
    private static long  onlineNumber = 0;//在线人数
    @Override
    public void sessionCreated(HttpSessionEvent se) {
        // TODO Auto-generated method stub
        System.out.println("在线人数监听启动....");
        onlineNumber++;
        //设置当前session最大生效时间
        //se.getSession().setMaxInactiveInterval(5);
    }
    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        // TODO Auto-generated method stub
        System.out.println("在线人数监听销毁....");
        onlineNumber--;
    }
    public static long getOnlineNumber() {
        return onlineNumber;
    }
}
当在服务器启动的时候就会触发监听器，此时会调用sessionCreate()方法，当用户关闭浏览器并且session有效时间过期的时候，才会触发 sessionDestroye()方法。
3.7  过滤器（精通）
过滤器（Filter）技术是Servlet 2.3规范新增加的功能，作用是用于过滤、拦截请求或响应信息，可以在Servlet或JSP页面运行之前和之后被自动调用，从而增强了Java Web应用程序的灵活性。
3.7.1  过滤器的过滤过程



当用户发送请求后，运行的步骤如下：
1)浏览器根据用户的请求生成HTTP请求消息，并将其发送给Web容器。
2)Web容器创建针对该次访问的请求对象（request）和响应对象（response）。请求对象中包含了HTTP的请求信息，响应对象用于封装将要发送的HTTP响应信息，此时的响应对象中的内容为空。
3)Web容器在调用Web组件之前（Servlet、JSP或HTML）把request对象和response对象传递给过滤器。
4)过滤器对request对象进行处理（如获取请求的URL等），一般不对response对象进行处理。
5)过滤器把处理后的request对象和可能没有处理的response对象传递给Web组件。
6)Web组件调用完毕后，再次经过该过滤器，此时过滤器可能对response对象进行特殊处理（如设置响应报头或内容压缩等操作）。
7)过滤器把response对象传递给Web容器。
8)Web容器把响应的结果传递给浏览器，并由浏览器显示响应结果。
在实际的应用中，可以使用过滤器来完成以下任务：
访问特定资源（HTML、JSP页、Servlet）时的身份认证，禁止用户非法访问；
应用程序级资源的访问审核和记录；
应用程序范围内对资源的加密访问，它建立在定制的加密方案基础上；
对被访问资源的及时转换，包括从Servlet和JSP的动态输出等。
3.7.2  过滤器配置
在Web.xml中添加如下配置信息：
  <!-- 过滤器配置 -->
  <filter>
    <display-name>LoginFilter</display-name>
    <filter-name>LoginFilter</filter-name>
    <filter-class>com.hyg.filter.LoginFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>LoginFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

注意: <url-pattern>/*</url-pattern> 表示拦截所有url路径。
3.7.2   过滤器的使用
要创建一个过滤器，必需要实现Filter接口，并实现接口中的方法。以URL地址过滤为例，其实现代码如下：

@Override
    public void doFilter(ServletRequest request, ServletResponse response,  FilterChain chain) throws IOException, ServletException {
        // TODO Auto-generated method stub
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse resp = (HttpServletResponse) response;
        //剔除不需要过滤的页面
        String path = req.getRequestURI();
        req.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");
        if (path.endsWith("login.jsp") || path.endsWith("login.action") || path.endsWith("register.jsp") || path.endsWith("register.action")) {
            chain.doFilter(req, resp);
            return;
        }
        //校验是否登录用户
        HttpSession session = req.getSession();
        String userName = (String)session.getAttribute("userName");
        if(StringUtils.isEmpty(userName)){
            resp.sendRedirect("login.jsp");
            return;
        }
        chain.doFilter(req, resp);
    }