过滤器（Filter）和监听器（listener）

最新推荐文章于 2022-11-07 11:27:52 发布
最新推荐文章于 2022-11-07 11:27:52 发布
阅读量1.7k 收藏 11
点赞数 2
分类专栏： 框架相关 文章标签： filter
转载地址：[http://blog.csdn.net/qq1131410679/article/details/75151080]

一、过滤器

Filter（过滤器）并不是一个标准的Servlet ，它不能处理用户请求，也不能对客户端生成响应。通过Filter技术，开发人员可以实现用户在访问某个目标资源之前，对访问的请求和响应进行拦截，从而实现一些特殊的功能。例如实现URL级别的权限访问控制、过滤敏感词汇、压缩响应信息等一些高级功能。
这里写图片描述
过滤器在执行过程中任何时候都可以打断，只要不执chain.doFilter()方法就不会再执行后面的过滤器和请求的内容。因此，要特别注意过滤链的执行顺序问题。假如在逻辑出现两次doFilter会导致有些页面会执行两次。
这里写图片描述


（一）Filter开发步骤

1、编写java类实现Filter接口，并重写其方法

例如：字符编码的 Filter 

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;
/**
 * Description:
 * 设置编码格式的filter
 * @author lee
 */
public class ContentType implements Filter{
    private String charset;
    private boolean enabled;

    @Override
    public void destroy() {}

    /**
     * Description：
     * 设置编码格式
     */
    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
            throws IOException, ServletException {
        //设置编码格式
        if(enabled && charset!=null)
            resp.setCharacterEncoding(charset);

        //执行doFilter方法，放行,进入目标资源或下一个过滤器
        chain.doFilter(req, resp);
    }
    @Override
    public void init(FilterConfig config) throws ServletException {
        charset = config.getInitParameter("charset");
        enabled = "ture".equals(config.getInitParameter("enabled"));
    }
}

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42


2、在 web.xml 文件中使用和元素对过滤器进行注册，并指定拦截资源。
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
            xmlns="http://xmlns.jcp.org/xml/ns/javaee" 
            xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" 
            id="WebApp_ID" 
            version="3.1">
  <display-name>web</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>
    <!-- 监听器名称 -->
    <filter-name>charset</filter-name>
    <!-- 监听器的class全称，包名+类名 -->
    <filter-class>filter.ContentType</filter-class>
    <!-- 初始化参数 -->
    <init-param>
        <param-name>charset</param-name>
        <param-value>utf-8</param-value>
    </init-param>
    <init-param>
        <param-name>enabled</param-name>
        <param-value>true</param-value>
    </init-param>
  </filter>

  <filter-mapping>
    <filter-name>charset</filter-name>
    <!-- 
    设置 filter 所拦截的请求路径(过滤器关联的URL样式)
    值要与浏览器输入的地址相匹配，通过url-pattern查找指定的资源
    写法：
    1.完全匹配  要求以/开始，名称与url一致.
    2.使用通配符 *
    1.目录匹配   以/开始,以*结束.
    2.扩展名匹配 不能以/开始，以*.xxx对束
    （目录匹配和扩展名匹配不能同时使用，例如 /*.jsp） 
    -->
    <!-- /*意味着拦截所有资源 -->
    <url-pattern>/*</url-pattern>

    <!-- 根据servlet的内部名称拦截，拦截名内部名称为Servlet的servlet -->
    <servlet-name>Servlet</servlet-name>

    <!-- 
    指定过滤器所拦截的资源被 Servlet 容器调用的方式。用户可以设置多个<dispatcher> 子元素用来指定 Filter 对资源的多种调用方式进行拦截。
    REQUEST：当用户直接访问页面时，Web容器将会调用过滤器。如果目标资源是通过RequestDispatcher的include()或forward()方法访问时，那么该过滤器就不会被调用。
    INCLUDE：如果目标资源是通过RequestDispatcher的include()方法访问时，那么该过滤器将被调用。除此之外，该过滤器不会被调用。
    FORWARD：如果目标资源是通过RequestDispatcher的forward()方法访问时，那么该过滤器将被调用，除此之外，该过滤器不会被调用。
    ERROR：如果目标资源是通过声明式异常处理机制调用时，那么该过滤器将被调用。除此之外，过滤器不会被调用 
    -->
    <dispatcher>REQUEST</dispatcher>
  </filter-mapping>

</web-app>
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63

Filter链
多个Filter的访问先后顺序由 配置在前面的Filter 执行要早于配置在后面的Filter决定 。
（关于在<url-pattern> 元素中，的匹配方式可以参考另外一篇博客Servlet编程基础 中的映射路径）

这里也可以通过注解在注册过滤器，例如

@WebFilter(filterName="过滤器名称",urlPattern="需要进行过滤的url")
   
   
  • 1

   
   

    
    
   
   

   
   
  • 1



（二）Filter的生命周期

过滤器是服务器启动的时候创建和初始化，当有请求访问时就会调用过滤器的doFilter方法，当关闭服务器的时候就会调用destroy方法销毁过滤器。

public void init(FilterConfig filterConfig) throws ServletException;
//1、Filter的创建和销毁由WEB服务器负责。web应用程序启动时创建Filter 的实例对象，并调用其init方法，读取web.xml配置，完成对象的初始化功能。

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException;
//2、当客户请求访问与过滤器关联的URL的时候，将先执行doFilter方法。

public void destroy();//销毁
//3、Filter对象创建后会驻留在内存，当web应用移除或服务器停止时才销毁。

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9



（三）FilterConfig对象

在web.xml配置文件可以为filter配置一些初始化参数，当web容器实例化Filter对象，调用其init方法时，会把封装了filter初始化参数的filterConfig对象传递进来。因此开发人员在编写filter时，通过filterConfig对象的方法，初始化参数。
例如在web.xml文件中，配置filter初始化参数：

<!-- 部分代码 -->
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
            xmlns="http://xmlns.jcp.org/xml/ns/javaee" 
            xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" 
            id="WebApp_ID" 
            version="3.1">
  <display-name>web</display-name>

  <filter>
    <filter-name>charset</filter-name>
    <filter-class>filter.ContentType</filter-class>
    <!-- 初始化参数 -->
    <init-param>
        <param-name>name1</param-name>
        <param-value>value1</param-value>
    </init-param>
  </filter>

  <filter-mapping>
    <filter-name>charset</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
</web-app>
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

然后，我们就可以在filter中使用FilterConfig获取这些初始化参数：

//部分代码

public class ContentType implements Filter{
    FilterConfig config;
    @Override
    public void destroy() {
        config=null;}

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
            throws IOException, ServletException {
        //获取初始化参数
        Enumeration e = config.getInitParameterNames();
        while(e.hasMoreElement){
            paramName = e.nextElement();
            paramValue = e.getInitParameter(paramName);
        }
    }
    @Override
    public void init(FilterConfig config) throws ServletException {
        this.config = config;}
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22



（四）过滤器案例

1、执行公用业务代码
2、无效数据过滤（引入ckeditor客户端组件）
3、登陆权限的判断
这里写链接内容





二、监听器

监听器就是一个实现特定接口的普通Java程序，这个程序专门用于监听另一个java对象的方法调用或属性改变，当被监听对象触发某些事件后，监听器某个方法将立即被执行。
在Servlet规范中定义了多种类型的监听器，它们用于监听的事件源分别为 ServletContext, HttpSession 和 ServletRequest 这三个域对象。
监听器划分为三种类型：

  • 监听三个域对象创建和销毁的事件监听器
  • 监听域对象中属性的增加和删除的事件监听器
  • 监听绑定到 HttpSession 域中的某个对象的状态的事件监听器。

这里写图片描述


（一）监听器的分类

1、监听对象创建/销毁的监听器接口
Interface ServletRequestListener
//用于监听ServletRequest对象的创建和销毁。
//主要方法有：
void    requestDestroyed(ServletRequestEvent sre)
void    requestInitialized(ServletRequestEvent sre)

Interface HttpSessionListener
//用于监听HttpSession对象的创建和销毁
//主要方法有：
void    sessionCreated(HttpSessionEvent se)
void    sessionDestroyed(HttpSessionEvent se)

//用于监听 ServletContext 对象的创建和销毁事件。
//主要方法有：
void    contextDestroyed(ServletContextEvent sce)
void    contextInitialized(ServletContextEvent sce)

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17


2、监听对象属性的变化

Servlet规范定义了监听 ServletContext, HttpSession, HttpServletRequest 这三个对象中的属性变更信息事件的监听器。这三个接口中都定义了三个方法来处理被监听对象中的属性的增加，删除和替换的事件，同一个事件在这三个接口中对应的方法名称完全相同，只是接受的参数类型不同。 

Interface ServletRequestAttributeListener
//主要方法有：
void    attributeAdded(ServletRequestAttributeEvent srae)
void    attributeRemoved(ServletRequestAttributeEvent srae)
void    attributeReplaced(ServletRequestAttributeEvent srae)

Interface HttpSessionAttributeListener
//主要方法有：
void    attributeAdded(HttpSessionBindingEvent event)
void    attributeRemoved(HttpSessionBindingEvent event)
void    attributeReplaced(HttpSessionBindingEvent event)

Interface ServletContextAttributeListener
//主要方法有：
void    attributeAdded(ServletContextAttributeEvent event)
void    attributeRemoved(ServletContextAttributeEvent event)
void    attributeReplaced(ServletContextAttributeEvent event) 

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18


3、监听绑定到 HttpSession 域中的某个对象的变化

Servlet 规范中定义了两个特殊的监听器接口来帮助 JavaBean 对象了解自己在 Session 域中的这些状态，实现这两个接口的类不需要 web.xml 文件中进行注册。

保存在 Session 域中的可以有多种状态：
1、绑定到 Session 域中；从 Session 域中解除绑定；
2、随 Session 对象持久化到一个存储设备中(钝化)；随 Session 对象从一个存储设备中恢复（活化） 
Interface HttpSessionBindingListene
//监听对象绑定/解绑到session上的事件，即是将对象保存到session当中就会调用该对象实现该监听器类方法
Interface HttpSessionActivationListener
//实现了该接口的 JavaBean 对象可以感知自己被活化和钝化的事件

   
   
  • 1
  • 2
  • 3
  • 4
  • 5

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5

这里写图片描述



（二）监听器的的实现步骤

1、实现相应监听器的类
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
/**
 * Description:
 * @author lee
 */
public class SessionListener implements HttpSessionListener{

    /**
     * Description:
     */
    @Override
    public void sessionCreated(HttpSessionEvent event) {
    }

    /**
     * Description:
     */
    @Override
    public void sessionDestroyed(HttpSessionEvent event) {
    }
}

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24


2、web.xml文件中配置监听器

开发人员只需在web.xml文件中使用标签配置好监听器，web容器就会自动把监听器注册到事件源中。一个 web.xml 文件中可以配置多个事件监听器，web 服务器按照它们在 web.xml 文件中的注册顺序来加载和注册这些 Serlvet 事件监听器。（这里不包括不用注册的两个监听器。）

<!-- web.xml文件部分 -->
<listener>
    <!-- 这里就是把listener包下的Listener类注册成为监听器 -->
    <lisntener-class>listener.Listener</listener-class>
</listener>
   
   
  • 1
  • 2
  • 3
  • 4
  • 5

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5

在Servlet3.0下，也可以通过注解@WebListener就可以实现监听器的注册，不需要在web.xml中进行配置。



（三）监听器案例

1、统计在线人数





三、过滤器和监听器的实例

（一）实例描述

一个网页，存储有员工信息。可以进行管理员的登陆，管理员可以浏览、修改员工信息。管理员可以看得到其他管理员的是否在线。实现步骤：

1、建立数据库

管理员：编号、名称、密码
员工：编号、名称

2、编写实体类

用于封装管理员和员工的信息
Admin.java、Employee.java

3、数据访问层

实现对数据的处理
IAdminDao.java 接口、IEmployeeDao.java 接口、AdminDao.java、EmployeeDao.java

4、数据库连接

实现连接数据库，获取数据。
JdbcUtils

5、Servlet

LoginServlet.java 登陆处理
IndexServlet.java 首页列表查询Servlet
LogoutServlet.java 退出处理

6、Jsp页面

Login.jsp
登陆成功, 提交到登陆Servlet处理其业务，跳转到员工列表
登陆失败，跳转到登陆！
List.jsp 退出功能，跳转到登陆页面

7、过滤器

只有登陆后，才可以访问员工列表。如果没有登陆，直接访问首页列表，要跳转到登陆!
LoginFilter.java 登陆验证过滤器
ContentType.java 编码过滤

8、监听器

监听servletContext对象的创建，储存在线管理员。登陆功能：用户登陆时候，把数据保存到servletContext中。退出功能；监听session销毁，把当前登陆用户从onlineuserlist移除！
ContextListener.java 监听整个的项目的启动，启动时就创建在线管理员列表。
SessionListener.java 监听管理员的登陆


描述图：
这里写图片描述

程序结构图：
这里写图片描述
这里写图片描述

注：这里使用了MySQL数据库，引用C3P0连接池、dbutil、jstl标签，以上这些都需要导入jar包。这里在这个网站中找到对应的jar包



（二）数据库设计

1、管理员数据库
这里写图片描述
2、员工数据库
这里写图片描述


（三）实体类

1、封装管理员信息的实体类

package entity;

/**
 * Description:
 * 一个用来封装管理员信息的实体类
 * 
 * @author lee
 * */
public class Admin {
    private int id;
    private String adName;
    private String password;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }

    public String getAdName() {
        return adName;
    }
    public void setAdName(String adName) {
        this.adName = adName;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }

}

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

2、封装员工信息的实体类

package entity;

/**
 * Description：
 * 封装则员工信息的实体类
 * 
 * @author lee
 *
 */
public class Employee {
    private int id;
    private String empName;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getEmpName() {
        return empName;
    }
    public void setEmpName(String empName) {
        this.empName = empName;
    }


}

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28



（四）数据库连接

package utils;

import javax.sql.DataSource;

import org.apache.commons.dbutils.QueryRunner;
import org.junit.Test;

import com.mchange.v2.c3p0.ComboPooledDataSource;
/**
 * Description:
 * 这里使用C3P0的JDBC连接池，来实现数据源和JNDI（标准的Java命名系统接口）绑定
 * 实现连接数据库，获取数据。
 * 
 * @author lee
 */
public class JdbcUtils {

    /**
     * C3P0连接池的核心工具类
     */
    private static DataSource dataSource;
    //静态初始化连接池
    //C3P0连接池会自动加载src目录下的c3p0-config.xml配置文件，来连接mysql数据库
    static{
        dataSource = new ComboPooledDataSource();
    }

    /**
     * Description:
     * 初始化DbUtils核心工具类对象，并返回
     * 
     * @return 返回DbUtils核心工具类对象
     */
    @Test 
    public static QueryRunner getQueryRunner(){
        //返回创建的QueryRuuner对象，并传入连接池对象
        return new QueryRunner(dataSource);
    }

}

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

c3p0-config.xml配置文件的编写

<c3p0-config>
  <default-config>
    <!-- mysql数据库的url地址 -->
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/data</property>
    <!-- mysql数据库的驱动 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <!-- 数据库的用户名称 -->
    <property name="user">root</property>
    <!-- 数据库的用户的密码 -->
    <property name="password">123456</property>
    <!-- 连接池保持的最小连接数 -->
    <property name="initialPoolSize">3</property>
    <!-- 链接池保持的最大连接数 -->
    <property name="maxPoolSize">6</property>
    <!-- 最大空闲时间,600秒内未使用则连接被丢弃。若为0则永不丢弃。默认为0  -->
    <property name="maxIdleTime">600</property>
  </default-config>
</c3p0-config>

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19



（五）数据访问层

1、管理员数据访问层接口

package dao;
import entity.Admin;
/*
 * Description:
 * 管理员数据访问层接口
 * 
 * @author lee
 */
public interface IAdminDao {
    /**
     * Description:
     * 根据管理员名称来获取管理员信息
     * 
     * @param adName 管理员的名称
     * @return 返回封装着管理员信息的Admin类
     */
    Admin findByName(String adName);
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

2、员工数据访问层的接口

package dao;
import java.util.List;
import entity.Employee;

/*
 * Description:
 * 员工数据访问层的接口
 * 
 * @author lee
 */
public interface IEmployeeDao {
    /**
     * Description:
     * 返回一个包含所有着员工信息集合
     * 
     * @return 返回一个包含所有着员工信息集合
     */
    List<Employee> findAll();
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

3、管理员数据访问层接口的实现类

package dao.impl;

import java.sql.SQLException;

import org.apache.commons.dbutils.handlers.BeanHandler;

import dao.IAdminDao;
import entity.Admin;
import utils.JdbcUtils;

/**
 * Description:
 * 管理员数据访问层接口的实现类
 * 
 * @author lee
 *
 */
public class AdminDao implements IAdminDao{

    /**
     * Description:
     * 调用JdbcUtils的方法执行sql的查询语句，根据指定的管理员名称来获取管理员信息。
     * 如果找不到对应名称的管理员，则返回null
     * 
     * public T BeanHandler.handle(ResultSet rs) throws SQLException
     * An initialized JavaBean or null if there were no rows in the ResultSet
     * 
     * @param adName 管理员的名称
     * @return 返回封装着管理员信息的Admin类
     */
    @Override
    public Admin findByName(String adName) {
        //sql查询语句
        String sql = "select * from admin where adName=?";

        try {
            //执行sql查询语句，使用dbUtil工具类，
            //将查询语句返回的数据表（ResultSet）第一行的封装成一个JavaBean（即是封装管理员信息实体类Admin）
            //that converts the first ResultSet row into a JavaBean. 
            return JdbcUtils.getQueryRunner()
                    .query(sql,new BeanHandler<Admin>(Admin.class),adName);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static void main(String[] args){
        Admin admin = new AdminDao().findByName("lee");
        if(admin!=null)
            System.out.println(admin.getAdName()+","+admin.getPassword());

    }
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

4、员工数据访问层接口的实现类

package dao.impl;

import java.sql.SQLException;
import java.util.List;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import dao.IEmployeeDao;
import entity.Employee;
import utils.JdbcUtils;

/**
 * Description:
 * 员工数据访问层接口的实现类
 * 
 * @author lee
 *
 */
public class EmployeeDao implements IEmployeeDao{

    /**
     * Description:
     * 同过调用JdbcUtils的方法执行sql查询语句，来获取所有员工的数据。
     * 
     * @return List<Employee>一个包含所有员工信息的集合，假如没有则返回null
     */
    @Override
    public List<Employee> findAll() {
        //sql查询语句
        String sql = "select * from employee";
        try {
            //执行sql查询语句，使用dbUtil工具类，
            //将查询语句返回的数据库结果集的数据表（ResultSet）封装成一个JavaBean的集合
            //that converts the first ResultSet 
            return JdbcUtils.getQueryRunner()
                    .query(sql,new BeanListHandler<Employee>(Employee.class));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41



（六）Servlet

1、LoginServlet.java 登陆处理 

package servlet;

import java.io.IOException;
import java.util.Iterator;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;


import dao.impl.AdminDao;
import entity.Admin;

/**
 * Description:
 * 管理员的登陆验证
 * 
 * @author lee
 */
@WebServlet("/LoginServlet")
public class LoginServlet extends HttpServlet {
    /**
     * Description：
     * 转发的uri
     * 
     */
    String uri;

    /**
     * Description:
     * 管理员的登陆验证。从表单中获取管理员的名称和密码，并与数据库中的管理员信息相比较。
     * 如果名称和密码相匹配，则登陆成功，转发到员工列表页面。
     * 否则转发进入登陆页面。
     * 
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        //获取表单的提交的管理员名称和密码
        String userName = request.getParameter("userName");
        String password = request.getParameter("password");

        //从数据库中差查找指定的名称的管理员的信息，由Admin封装着
        Admin admin = new AdminDao().findByName(userName);

        //当密码相匹配，则转发员工列表页面，否则转发进入登陆页面
        if(admin!=null&&password.equals(admin.getPassword())){
            //获取session
            HttpSession session = request.getSession();
            //设置session的最大保留时间
            session.setMaxInactiveInterval(60);

            //假如session没有管理员的信息，则将该管理员的信息保存在session域当中
            if(session.getAttribute("admin")==null){
                //将封装管理员信息的admin保存在session域中
                session.setAttribute("admin", admin);

                //获取在线管理员列表
                @SuppressWarnings("unchecked")
                List<Admin> admins = (List<Admin>)request.getServletContext().getAttribute("admins");
                if(admins!=null){
                    //将管理员信息添加到在线管理员列表
                    admins.add(admin);
                }
            }

            uri = "/IndexServlet";
        }else{
            uri = "login.jsp";
        }

        //转发页面
        request.getRequestDispatcher(uri).forward(request,response);
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83

2、IndexServlet.java 首页列表查询Servlet 

package servlet;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import dao.impl.EmployeeDao;
import entity.Admin;
import entity.Employee;

/**
 * Description:
 * 获取所有员工信息
 * 
 * @author lee
 */
@WebServlet("/IndexServlet")
public class IndexServlet extends HttpServlet {
    /**
     * Description：
     * 转发的uri
     * 
     */
    String uri;

    /**
     * Description:
     * 获取所有员工信息，并将其保存在session域中
     * 
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取所有装载员工信息实体的集合
        List<Employee> list = new EmployeeDao().findAll();

        //假如能获取所有员工信息则将其保存在session域，否则转发进入错误页面
        if(list!=null){
            HttpSession session = request.getSession(false);
            session.setAttribute("list",list);

            uri="list.jsp";
        }else{
            uri="error.jsp";
        }

//      @SuppressWarnings("unchecked")
//      List<Admin> admins = (List<Admin>)request.getServletContext().getAttribute("admins");
//      if(admins!=null){
//          Iterator<Admin> i = admins.iterator();
//          while(i.hasNext()){
//              Admin admin = (Admin)i.next();
//              System.out.println(admin.getAdName());
//          }
//      }else{
//          System.out.println("该在线列表不存在");
//      }


        //转发
        request.getRequestDispatcher(uri).forward(request,response);
    }
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74

3、LogoutServlet.java 退出处理 

package servlet;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
 * Description:
 * 销毁管理员的session
 * 
 * Servlet implementation class LogoutServlet
 */
@WebServlet("/LogoutServlet")
public class LogoutServlet extends HttpServlet {

    /**
     * Description:
     * 当管理员点击退出时，销毁管理员的session
     * 
     * Invalidates this session then unbinds any objects bound to it.
     * 
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取session，销毁session
        HttpSession session = request.getSession();
        if(session!=null){
            session.invalidate();
        }

        //重定向到登陆页面
        response.sendRedirect("login.jsp");
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43



（八）Jsp页面

1、Login.jsp 

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!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=ISO-8859-1">
<title>登录页面</title>
</head>
<body>

    <!-- 将表单提交到LoginServle处理 -->
    <form align="center" style="position:relative;top:100px" 
                    name="form" 
                    action="${pageContext.request.contextPath}/LoginServlet" 
                    method="post">

        <h2 style="margin:25px">欢迎登陆</h2>
        <!-- 假如session有保存管理员的信息，则名称和密码的值为管理员对应的名称和密码  -->
        用户名：<input type="text" name="userName" value="${admin.adName}"><br>
        密码：&nbsp;&nbsp;&nbsp;&nbsp;<input type="password" name="password"  value="${admin.password}"><br>
        <input align= "center" type="submit" name="登陆">
    </form>
</body>
</html>
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

2、List.jsp 

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!-- 导入Admin实体类 -->
<%@ page language="java" import="entity.Admin" %>
<!-- 导入jstl核心标签 -->
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<!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=ISO-8859-1">
<title>员工列表</title>
</head>
<body>
    <h3 align="center">欢迎管理员${admin.adName}登陆!</h3><br><br>

    <!-- 循环员工列表 -->
    <h3 align="center">员工列表</h3>
    <table align="center" border="1">
            <tr>
                <td>员工编号</td>
                <td>员工名称</td>
            </tr>
        <c:forEach items="${list}" var="var">
            <tr>
                <td>${var.id}</td>
                <td>${var.empName}</td>
            </tr>
        </c:forEach>
    </table>

    <br><br>
    <c:if test="${not empty admins}">
        <p align="right" style="position:relative;right:10px;font-size:20px">
            当前在线管理员：<br>
            <c:forEach items="${admins}" var="var">
                ${var.adName}&nbsp;&nbsp;
            </c:forEach>
        </p>
    </c:if>
    <div align="right" style="position:relative;right:30px;font-size:20px"><a href="${pageContext.request.contextPath }/LogoutServlet" >退出</a></div>
</body>
</html>
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43



（九）过滤器

1、ContentType.java 编码过滤 

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;


/**
 * Description:
 * 设置编码格式
 * 
 * @author lee
 */
public class ContentType implements Filter{
    FilterConfig config;
    @Override
    public void destroy() {
        config=null;

    }

    /**
     * Description：
     * 设置编码格式
     * 
     */
    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
            throws IOException, ServletException {
        //设置编码格式
        resp.setContentType("text/html;charset=utf-8");
        chain.doFilter(req, resp);
    }

    @Override
    public void init(FilterConfig config) throws ServletException {
        this.config = config;
    }

}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

2、LoginFilter.java 登陆验证过滤器 

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;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
 * Description:
 * 拦截没有登陆的管理员进入查看员工列表页面
 * 
 * @author lee
 */
public class LoginFilter implements Filter {
    FilterConfig  config;

    @Override
    public void destroy() { 
        config = null;
    }

    /*
     * Description:
     * 当用户直接访问员工列表页面时，需要通过session保存的信息来判断是否已经登陆，
     * 假如已经登陆后，则直接进入员工列表，假如没有登陆则转入登陆页面
     * 
     * (non-Javadoc)
     * @see javax.servlet.Filter#doFilter(javax.servlet.ServletRequest, javax.servlet.ServletResponse, javax.servlet.FilterChain)
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest res = (HttpServletRequest)request;
        HttpServletResponse resp = (HttpServletResponse)response;

        //获取请求的uri
        String uri = res.getRequestURI();

        //请求直接访问员工列表页面时
        if("/web/list.jsp".equals(uri)
                ||"/web/IndexServlet".equals(uri)){
            //获取session
            HttpSession session = res.getSession(false);

            //判断session是否保存有登陆信息，已经登陆（即是session保存有其管理员的信息）
            //则可以直接访问员工列表
            //否则，则重定向登陆页面
            if(session!=null
                    &&session.getAttribute("admin")!=null)
                chain.doFilter(res, resp);
            else
                resp.sendRedirect("login.jsp");
        }else{
            //访问其他页面，则直接通过
            chain.doFilter(res, resp);
        }

    }

    @Override
    public void init(FilterConfig config) throws ServletException {
        this.config = config;
    }

}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72



（十）监听器

1、ContextListener

package listener;

import java.util.ArrayList;
import java.util.List;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import entity.Admin;

/**
 * Decsription:
 * 监听整个当前项目，维护一个当前用户登陆列表。
 * 
 * @author lee
 *
 */
public class ContextListener implements ServletContextListener{

    public static List<Admin> admins = new ArrayList<Admin>();


    /**
     * Decsription:
     * 当真个项目销毁是，销毁该用户登陆列表
     * 
     */
    @Override
    public void contextDestroyed(ServletContextEvent event) {
        Object admins = event.getServletContext().getAttribute("admins");
        if(admins!=null)
            event.getServletContext().removeAttribute("admins");

    }

    /**
     * Description:
     * 当整个项目被创建时，初试化一个当前用户登陆列表
     * 
     */
    @Override
    public void contextInitialized(ServletContextEvent event) {
        System.out.println("初始化在线用户列表..");
        event.getServletContext().setAttribute("admins",admins);
    }

}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

2、SessionListener.java

package listener;

import java.util.List;

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

import entity.Admin;

/**
 * Description:
 * 记录session保存的用户
 * 
 * @author lee
 *
 */
public class SessionListener implements HttpSessionListener{

    /**
     * Description:
     * 当记录用户的session别创建时，则将其保存在在线用户列表
     */
    @Override
    public void sessionCreated(HttpSessionEvent event) {
//      HttpSession session = event.getSession();
//      System.out.println("初始化session");
//      @SuppressWarnings("unchecked")
//      List<Admin> admins = (List<Admin>) session.getServletContext().getAttribute("admins");
//      if(admins!=null){
//          Admin admin  = (Admin)session.getAttribute("admin");
//          if(admin!=null){
//              System.out.println(admin.getAdName());
//              admins.add(admin);
//          }
//      }
    }

    /**
     * Description:
     * 当记录用户的session被销毁是，则将其从在线用户列表中移除
     * 
     */
    @Override
    public void sessionDestroyed(HttpSessionEvent event) {
        //获取session
        HttpSession session = event.getSession();

        //获取在线用户列表
        @SuppressWarnings("unchecked")
        List<Admin> admins = (List<Admin>) event.getSession().getServletContext().getAttribute("admins");
        if(admins!=null){
            //获取session的用户信息
            Admin admin  = (Admin)session.getAttribute("admin");
            //将用户从在线列表中移除
            admins.remove(admin);
        }

    }


}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62



（十一）web.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
            xmlns="http://xmlns.jcp.org/xml/ns/javaee" 
            xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" 
            id="WebApp_ID" 
            version="3.1">
  <display-name>web</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>
  <servlet>
    <servlet-name>loginServlet</servlet-name>
    <servlet-class>servlet.LoginServlet</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>loginServlet</servlet-name>
    <url-pattern>/login</url-pattern>
  </servlet-mapping>

  <filter>
    <filter-name>charset</filter-name>
    <filter-class>filter.ContentType</filter-class>
  </filter>
  <filter>
    <filter-name>loginFilter</filter-name>
    <filter-class>filter.LoginFilter</filter-class>

  </filter>

  <filter-mapping>
    <filter-name>charset</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <filter-mapping>
    <filter-name>loginFilter</filter-name>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
  </filter-mapping>

  <listener>
    <listener-class>listener.ContextListener</listener-class>
  </listener>
  <listener>
    <listener-class>listener.SessionListener</listener-class>
  </listener>

  <error-page>
    <error-code>404</error-code>
    <location>/notFound.jsp</location>
  </error-page>
  <error-page>
    <error-code>500</error-code>
    <location>/error.jsp</location>
  </error-page>
</web-app>
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61



（十二）效果

这里写图片描述
这里写图片描述

路灯下的女孩
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
过滤器（Filter）和监听器（Listener）
我是沈君哦！
07-16 3594
一、过滤器Filter（过滤器）并不是一个标准的Servlet ，它不能处理用户请求，也不能对客户端生成响应。通过Filter技术，开发人员可以实现用户在访问某个目标资源之前，对访问的请求和响应进行拦截，从而实现一些特殊的功能。例如实现URL级别的权限访问控制、过滤敏感词汇、压缩响应信息等一些高级功能。 过滤器在执行过程中任何时候都可以打断，只要不执chain.doFilter()方法就不会再
Javaweb基础-servlet应用3
weixin_46899412的博客
02-12 899
ServletContext对象，Filter过滤器
过滤器和监听器
lmdbhf的博客
11-07 304
当客户端向服务器端发送一个请求时，如果有对应的过滤器进行拦截，过滤器可以改变请求的内容、或者重新设置请求协议的相关信息等，然后再将请求发送给服务器端的Servlet进行处理。Servlet规范中定义的一种特殊类，用于监听ServletContext，HttpSession和ServletRequest等域对象的创建与销毁事件，用于监听域对象的属性发生增、删、改的事件，可以在事件发生前，发生后做一些必要的处理。3、放行指定操作:不需要登录即可执行的操作(例如:登录操作、注册操作等)2.重写接口中的方法。
过滤器&监听器
weixin_54877075的博客
03-22 301
1.过滤器（Filter） 过滤器（拦截器）是拦截请求（Request）的对象，可动态地拦截请求和响应，以变换或使用包含在请求或响应中的信息；一个过滤器可以过滤N个请求 作用： 在客户端的请求访问后端资源之前，拦截这些请求 在服务器的响应发送回客户端之前，处理这些响应 1.1：Servlet 过滤器方法 过滤器实现了 javax.servlet.Filter 接口，javax.servlet.Filter 接口定义了三个方法： 序号 方法 & 描述 1 pub.
使用java过滤器（filter）进行登陆验证
爱学习的大雄的博客
12-13 1638
因为需要使用request方法中的getRequestURI()获取资源请求路径，Filter里的request是ServletRequest类型的而getRequsetURI()方法是HttpServletRequest类型的。所以首先需要强制转换。之后，就判断一下是否初始化页面时可以放行，如果未登录用户要访问登陆后才能查看的信息，就跳转到登陆页面，提示用户先登陆，最后再判断是否登录即可。登录了就放行，登录不成功跳转登录页面 import javax.servlet.*; import javax.ser
过滤器Filter和监听器Listener
最新发布
03-06
过滤器Filter和监听器Listener
过滤器filter和监听器listener的应用总结
07-26
在Java Web开发中，过滤器...在阅读《过滤器filter和监听器listener的应用总结》这篇博客后，相信你对这两个概念会有更深入的认识。在实际工作中，根据具体需求灵活运用它们，可以大大提升应用的健壮性和用户体验。
Filter过滤器和Listener监听器详解
01-21
Filter过滤器和Listener监听器详解 Filter过滤器 Filter的简介 对资源的访问进行过滤，相当于小区的保安，进去要检查，出去还要检查。 Filter的使用 编写一个类，继承并实现javax.servlet.Filter。 package ...
第7章 过滤器Filter和监听器Listener.ppt
09-12
Java Web基础与实例教程的PPT，自己制作的PPT，将近400页，免费分享，童鞋们努力学习吧。
关于监听器Listener和过滤器的小demo
12-08
在这个"关于监听器Listener和过滤器的小demo"中，作者可能创建了一个简单的Web应用程序，用以演示如何使用监听器监听应用程序的事件，以及如何使用过滤器处理请求和响应。文件`day10.html`和`day10.md`可能是记录了...
杂记（一）：Listener、Filter和工具
11-22
杂记（一）：Listener、Filter和工具 杂记（一）：Listener、Filter和工具
Java SpringBoot实现的过滤器（和拦截器）控制登录页面跳转
04-13
该压缩包实现了利用过滤器或者拦截器对登录信息进行验证跳转登陆页的功能，利用的是SpringBoot和thymeleaf,使用前请先看使用说明
过滤器和监听器的使用与区别
01-03
xml文件及文档讲解过滤器与监听器的配置，实际应用等，以及二者的区别和使用时应该注意的地方
java 监听器 分类_java过滤器和监听器详解 分类： 学习专区
weixin_26969967的博客
02-16 217
过滤器1、Filter工作原理(执行流程)当客户端发出Web资源的请求时，Web服务器根据应用程序配置文件设置的过滤规则进行检查，若客户请求满足过滤规则，则对客户请求／响应进行拦截，对请求头和请求数据进行检查或改动，并依次通过过滤器链，最后把请求／响应交给请求的Web资源处理。请求信息在过滤器链中可以被修改，也可以根据条件让请求不发往资源处理器，并直接向客户机发回一个响应。当资源处理器完成了对资源...
Filter(过滤器)、Listener(监听器)
weixin_40161708的博客
03-09 490
一: 过滤器: 可以把”不和谐”的东西给过滤掉 01.过滤器概述 生活中的过滤器:带有过滤功能的净水器,滤纸,香烟的过滤嘴,测试,丈母娘. 程序中的过滤器:在JAVA中最小的程序单元是类,程序中的过滤器就是一个特殊的类 Servelt/Filter是Web的一个组件. Web中过滤器的作用(简单理解为:过滤器处在客户端和服务端资源之间):......
学习笔记——Filter和Listener详解
qq_52538587的博客
01-07 370
过滤器和监听器
肥桃的Java学习记录24：监听器
Archimontao的博客
10-23 188
监听器(Listener) 1.什么是监听器 监听器就是监听某个域对象的的状态变化的组件 监听器的相关概念： 事件源：被监听的对象(三个域对象request、session、servletContext) 监听器：监听事件源对象事件源对象的状态的变化都会触发监听器 注册监听器：将监听器与事件源进行绑定 响应行为：监听器监听到事件源的状态变化时所涉及的功能代码（程序员编写代码） 2.监听器分类 第一维度按照被监听的对象划分：ServletRequest域、HttpSession域、Servl
过滤器、监听器、拦截器的区别
LuckyBrown的博客
07-14 9561
过滤器 Servlet中的过滤器Filter是实现了javax.servlet.Filter接口的服务器端程序，主要的用途是过滤字符编码、做一些业务逻辑判断等。其工作原理是，只要你在web.xml文件配置好要拦截的客户端请求，它都会帮你拦截到请求，此时你就可以对请求或响应(Request、Response)统一设置编码，简化操作；同时还可以进行逻辑判断，如用户是否已经登录、有没有权限访问
过滤器、监听器
yuer629
05-28 1813
一、过滤器(Filter)1.概述过滤器是JavaWeb三大组件之一，它与Servlet很相似！不过servlet是用来处理请求，而过滤器是用来过滤请求的。拥有对目标资源的请求和响应进行截取的功能。2.实现方式其实过滤器与Servlet很相似，具体如下: 1.实现Filter接口，重新里面抽象方法2.配置web.xml配置文件步骤一:创建类，实现Filter接口，重新里面的三个方法 public ...
WEB技术深度解析：过滤器与监听器的运用
在Web开发中，过滤器（Filter）和监听器（Listener）是两种重要的Servlet扩展技术，它们能增强应用程序的功能和控制力。过滤器主要用于对HTTP请求和响应进行处理，而监听器则用于监听和响应Web应用程序中的特定事件...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值