JavaWeb基础系列（十一）监听器

比眉伴天荒 2021-09-27 00:32 371阅读 0赞

# 一、监听器Listener #

## 1.1、什么是监听器 ##

监听器就是监听某个对象的的状态变化的组件。  
**监听器的相关概念：**  
事件源：被监听的对象 —– 三个域对象 request session servletContext  
监听器：监听事件源对象 事件源对象的状态的变化都会触发监听器 —- 6+2  
注册监听器：将监听器与事件源进行绑定  
响应行为：监听器监听到事件源的状态变化时 所涉及的功能代码 —- 程序员编写代码

## 1.2、监听器有哪些 ##

第一维度：按照被监听的对象划分：ServletRequest域、HttpSession域、ServletContext域  
第二维度：监听的内容分：监听域对象的创建与销毁的，监听域对象的属性变化的  
![这里写图片描述][70]

## 1.3、监听三大域对象的创建与销毁的监听器 ##

### （1）监听ServletContext域的创建与销毁的监听器ServletContextListener ###

（1）Servlet域的生命周期  
何时创建：服务器启动创建  
何时销毁：服务器关闭销毁  
（2）监听器的编写步骤（重点）：  
编写一个监听器类去实现监听器接口  
覆盖监听器的方法  
需要在web.xml中进行配置—注册

@WebListener()
    public class Listener implements ServletContextListener{ 
        //监听ServletContext对象的创建
        public void contextInitialized(ServletContextEvent sce) {
            //得到的就是被监听的对象--ServletContext
            ServletContext context = sce.getServletContext();
            //getSource就是被监听的对象，这是一个通用的方法
            Object source = (ServletContext)sce.getSource();
            System.out.println("context创建了");
        }
        //监听ServletContext对象的销毁
        public void contextDestroyed(ServletContextEvent sce) {
            System.out.println("context销毁了");
        }
    }

### （2）ServletContextListener监听器的主要作用 ###

a、初始化的工作：初始化对象，初始化数据 —- 加载数据库驱动连接池的初始化  
b、加载一些初始化的配置文件 — spring的配置文件  
c、任务调度—-定时器—-Timer/TimerTask

### （3）监听Httpsession域的创建与销毁的监听器HttpSessionListener ###

HttpSession对象的生命周期：  
何时创建：第一次调用request.getSession时创建  
何时销毁：服务器关闭销毁、session过期 、手动销毁

@WebListener()
    public class MyHttpSessionListener implements HttpSessionListener{ 
        @Override
        public void sessionCreated(HttpSessionEvent se) {
                System.out.println("session创建"+se.getSession().getId());
        }
        @Override
        public void sessionDestroyed(HttpSessionEvent se) {
                System.out.println("session销毁");
        }
    }

### （4）监听ServletRequest域创建与销毁的监听器ServletRequestListener ###

ServletRequest的生命周期：  
创建：每一次请求都会创建request  
销毁：请求结束  
ServletRequestListener的方法：  
![这里写图片描述][70 1]

## 1.4、监听三大域对象的属性变化的 ##

(1) 域对象的通用的方法：  
setAttribute(name,value)  
— 触发添加属性的监听器的方法  
attributeReplace(name）  
— 触发修改属性的监听器的方法  
getAttribute(name)  
removeAttribute(name)  
— 触发删除属性的监听器的方法  
(2) ServletContextAttibuteListener监听器

@WebListener()
    public class MyServletContextAttributeListener implements ServletContextAttributeListener{ 
        @Override
        public void attributeAdded(ServletContextAttributeEvent scab) {
            //放到域中的属性
            System.out.println(scab.getName());//放到域中的name
            System.out.println(scab.getValue());//放到域中的value
        }
        @Override
        public void attributeRemoved(ServletContextAttributeEvent scab) {
            System.out.println(scab.getName());//删除的域中的name
            System.out.println(scab.getValue());//删除的域中的value
        }
        @Override
        public void attributeReplaced(ServletContextAttributeEvent scab) {
            System.out.println(scab.getName());//获得修改前的name
            System.out.println(scab.getValue());//获得修改前的value
        }
    }

(3) HttpSessionAttributeListener监听器（同上）  
(4) ServletRequestAriibuteListenr监听器（同上）

# 二、对象感知监听器 #

(1) **即将要被绑定到session中的对象有几种状态**  
绑定状态：就一个对象被放到session域中  
解绑状态：就是这个对象从session域中移除了  
钝化状态：是将session内存中的对象持久化（序列化）到磁盘  
活化状态：就是将磁盘上的对象再次恢复到session内存中  
面试题：当用户很对时，怎样对服务器进行优化？  
定义一个Person对象：

public class Person implements HttpSessionBindingListener{ 
        private String id;
        private String name;
        public String getId() {
            return id;
        }
        public void setId(String id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Override
        //绑定的方法
        public void valueBound(HttpSessionBindingEvent event) {
            System.out.println("person被绑定了");
        }
        @Override
        //解绑方法
        public void valueUnbound(HttpSessionBindingEvent event) {
            System.out.println("person被解绑了");
        }
    }

创建一个Servlet：

@WebServlet(name = "TestPersonBindingServlet",
            urlPatterns = {
       "/TestPersonBindingServlet"})
    public class TestPersonBindingServlet extends HttpServlet { 
        protected void doGet(HttpServletRequest request, HttpServletResponse response)
                        throws ServletException, IOException {
            HttpSession session = request.getSession();
            //将person对象绑到session中
            Person p = new Person();
            p.setId("100");
            p.setName("zhangsanfeng");
            session.setAttribute("person", p);
            //将person对象从session中解绑
            session.removeAttribute("person");
        }
        protected void doPost(HttpServletRequest request, HttpServletResponse response)
                        throws ServletException, IOException {
            doGet(request, response);
        }
    }

**（2）钝化与活化的监听器HttpSessionActivationListener**  
定义一个Customer对象：

public class Customer implements HttpSessionActivationListener,Serializable{ 
        private String id;
        private String name;
    
        public String getId() {
                return id;
        }
        public void setId(String id) {
                this.id = id;
        }
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
        @Override
        //钝化
        public void sessionWillPassivate(HttpSessionEvent se) {
                System.out.println("customer被钝化了");
        }
        @Override
        //活化
        public void sessionDidActivate(HttpSessionEvent se) {
                System.out.println("customer被活化了");
        }
    }

创建一个Servlet：

public class TestCustomerActiveServlet extends HttpServlet { 
        protected void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            HttpSession session = request.getSession();
            //将customer放到session中
            Customer customer =new Customer();
            customer.setId("200");
            customer.setName("lucy");
            session.setAttribute("customer", customer);
            System.out.println("customer被放到session域中了");    
        }
        protected void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            doGet(request, response);
        }
    }

创建一个Servlet2：

public class TestCustomerActiveServlet2 extends HttpServlet { 
        protected void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            //从session域中获得customer
            HttpSession session = request.getSession();
            Customer customer = (Customer) session.getAttribute("customer");
            System.out.println(customer.getName());
        }
        protected void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            doGet(request, response);
        }
    }

可以通过配置文件 指定对象钝化时间 — 对象多长时间不用被钝化  
在META-INF下创建一个context.xml

# 三、邮箱的介绍与配置 #

邮件的客户端：可以只安装在电脑上的也可以是网页形式的  
邮件服务器：起到邮件的接受与推送的作用  
邮件发送的协议：  
协议：就是数据传输的约束  
接受邮件的协议：POP3 IMAP  
发送邮件的协议：SMTP

public class MailUtils {
        //email:邮件发给谁 subject:主题 emailMsg：邮件的内容
        public static void sendMail(String email, String subject, String emailMsg)
                        throws AddressException, MessagingException {
            // 1.创建一个程序与邮件服务器会话对象 Session
            Properties props = new Properties();
            props.setProperty("mail.transport.protocol", "SMTP");//发邮件的协议
            props.setProperty("mail.host", "localhost");//发送邮件的服务器地址
            props.setProperty("mail.smtp.auth", "true");// 指定验证为true
    
            // 创建验证器
            Authenticator auth = new Authenticator() {
                public PasswordAuthentication getPasswordAuthentication() {
                    return new PasswordAuthentication("tom", "12345");//发邮件的账号的验证
                }
            };
    
            Session session = Session.getInstance(props, auth);
    
            // 2.创建一个Message，它相当于是邮件内容
            Message message = new MimeMessage(session);
    
            message.setFrom(new InternetAddress("tom@163.com")); // 设置发送者
    
            message.setRecipient(Message.RecipientType.TO, new InternetAddress(email)); // 设置发送方式与接收者
    
            message.setSubject(subject);//邮件的主题
    
            message.setContent(emailMsg, "text/html;charset=utf-8");
    
            // 3.创建 Transport用于将邮件发送
            Transport.send(message);
        }
    }

测试：

public class SendMailTest {
        public static void main(String[] args) throws AddressException, MessagingException {
            MailUtils.sendMail("longjiahao666@163.com", "测试邮件","这是一封测试邮件");
        }
    }

> **转载请标明出处，原文地址：[https://blog.csdn.net/weixin\_41835916][https_blog.csdn.net_weixin_41835916] 如果觉得本文对您有帮助，请点击顶支持一下，您的支持是我写作最大的动力，谢谢。  
> ![这里写图片描述][70 2]**

[70]: /images/20210923/3d4362aa31c04730a306ad3720940b80.png
[70 1]: /images/20210923/c7f562e60e7a4c53aa5545325307bc9d.png
[https_blog.csdn.net_weixin_41835916]: https://blog.csdn.net/weixin_41835916
[70 2]: /images/20210923/bf028af66b2246ca8476c57ec024d9f0.png