servlet

1: servlet生命周期

 　　　　　　　　 实例化servlet(第一次调用该servlet时)
            init初始化
            服务(多次)
            销毁(tomcat关闭时执行)

　　　　创建一个servlet， 配置web.xml ， 测试  尝试一下

public class HelloServlet extends HttpServlet {

    public HelloServlet() {
        super();
        System.out.println("实例化 servlet");
    }

    @Override
    public void init() throws ServletException {
        super.init();
        System.out.println("init 初始化");
    }

    @Override
    public void destroy() {
        super.destroy();
        System.out.println("HelloServlet 初始化");
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

 　　 System.out.println("HelloServlet 服务");
    }

}

　　web.xml 配置

  <!--servlet实例，每一个servlet都需要配置class与映射-->
    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.draymond.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

　　get请求调用，看打印信息

2：cookie session

    /**
     * 添加cookie与session
     *
     * @param req
     * @param resp
     */
    private void setCookieAndSession(HttpServletRequest req, HttpServletResponse resp) {
        String userName = req.getParameter("userName");
        String password = req.getParameter("password");

        Cookie cookie = new Cookie(userName, password);
        cookie.setMaxAge(60 * 60 * 24); //cookie有效期 单位：秒
        resp.addCookie(cookie);

        HttpSession session = req.getSession();
        session.setAttribute(userName, password);
        session.setMaxInactiveInterval(60);  //session有效期
    }

 /**
     * cookie测试
     *
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Cookie[] cookies = req.getCookies();
        PrintWriter writer = resp.getWriter();
        for (Cookie cookie : cookies) {
            writer.println("name:" + cookie.getName() + "  value:" + cookie.getValue());
        }
        writer.flush();
        writer.close(); // 客户端输出 name:ddd  value:ddd
    }

   /**
     * 获取session
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        HttpSession session = req.getSession();
        String ddd = (String) session.getAttribute("ddd");
        System.out.println(ddd);

    }

  cookie和session 是与浏览器一一对应的(想一想为了安全，也不会随意的可以跨浏览器自动使用)

3：servlet共享变量

        http协议发生一次请求，相应结束，请求也就结束了。。所以需要共享变量
        　　servletContext 范围最大，应用程序级别，整个web程序中都能使用
        　　HttpSession    次之，会话级别，在当前浏览器中都能访问
        　　HttpServletRequest  范围最小，请求级别，请求结束，连梁的作用域也会结束(servlet中的 doGet(HttpServletRequest req, HttpServletResponse resp))

        com.draymond.servlet.ShareOfGetServlet
        com.draymond.servlet.ShareOfSetServlet

  

    /**
     * 存放 共享变量
     *
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 1 ServletContext
        ServletContext context = this.getServletContext();
        context.setAttribute("zsc", "zsc123456");
        context.setAttribute("draymond", "draymond123456");
        // 2 HttpSession
        HttpSession session = req.getSession();
        session.setAttribute("session", "session123");
    }

    /**
     * 获取 共享变量
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        String zsc = (String) servletContext.getAttribute("zsc");
        String draymond = (String) servletContext.getAttribute("draymond");

        HttpSession session = req.getSession();
        String sessionValue = (String) session.getAttribute("session");
        PrintWriter writer = resp.getWriter();
        writer.println("zsc::" + zsc);
        writer.println("draymond::" + draymond);
        writer.println("sessionValue::" + sessionValue);
        writer.flush();
        writer.close(); // 浏览器输出 zsc::zsc123456  draymond::draymond123456    sessionValue::session123
        // 换另外一个浏览器   zsc::zsc123456 draymond::draymond123456 sessionValue::null   (session123获取不到:HttpSession的作用域为当前浏览器)

    }

4：请求转发 与重定向

 /**
     * 重定向（doGet方法中再调用该方法）
     *
     * @param req
     * @param resp
     */
    private void redirect(HttpServletRequest req, HttpServletResponse resp) {
        try {
            resp.sendRedirect("html.html");        // 重定向到本地的 html.html 页面
            // resp.sendRedirect("/outHtml");        // 重定向到本地的 outHtml接口
            // resp.sendRedirect("http://www.baidu.com");             // 跳转到项目之外的地址，则要带上http，不然，重定向的路径会在前面加上项目地址
            // resp.sendRedirect("www.baidu.com");                    // 重定向地址：http://localhost:90/www.baidu.com  造成404

        } catch (IOException e) {
        }
    }

/**
     * forward转发
     * 转发到请求    /outHtml接口
     *
     * @param req
     * @param resp
     */
    private void forwardtDispatcher(HttpServletRequest req, HttpServletResponse resp) {
        try {
            //  req.getRequestDispatcher("outHtml").forward(req, resp);                   // 转发请求本项目的 /outHtml接口(outHml接口做什么不管转发之前的事)
            req.getRequestDispatcher("http://www.baidu.com").forward(req, resp);    //转发到百度
        } catch (Exception e) {
        }
    }

 /**
     * include  包含形式转发
     * 两个输出的内容合到一块输出
     *
     * @param req
     * @param resp
     */
    private void includeDispatcher(HttpServletRequest req, HttpServletResponse resp) {
        try {
            // 请求包含(此处的writer1也会显示的页面上)
            PrintWriter writer = resp.getWriter();
            writer.print("<h1> login servlet </h1>");

            req.getRequestDispatcher("/outHtml").include(req, resp);
            writer.close();
        } catch (Exception e) {
        }
    }

5：filter过滤器

　　5.1 自定义过滤器

　　

/**
     * 登录拦截
     *
     * @param req
     * @param resp
     * @param chain
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
        System.out.println("进入 LoginFilter 拦截器");
        String token = req.getParameter("token");
        if (null == token || "".equals(token)) {
            PrintWriter writer = resp.getWriter();
            writer.println("login error ,no token");
            writer.flush();
            writer.close();
            //     return;   暂时注释不然其他的方法测试不了
        }
        try {
            chain.doFilter(req, resp);
        } catch (Exception e) {
        }
    }

　　5.2 web.xml配置

 <!--过滤器-->
    <filter>
        <filter-name>LoginFilter</filter-name>
        <filter-class>com.draymond.filter.LoginFilter</filter-class>
    </filter>

6: listen 监听器

    用来监听整个web工程状态改变的实现机制
    1： ServletContextListen ServletContextAttributeListen
    2： ServletContextListener ServletContextAttributeListener
    3： ServletRequestListener ServletRequestAttributeListener
        监听对应：三个不同的共享作用域：Context session request (参照 10 servlet共享变量)
    左边的监听：容器的创建一销毁
    右边的监听：容器中元素的变化(带Attribute就明白式检测共享区域里面的元素的)

　　  以Context为例

　　　　6.1 自定义监听，实现接口

public class ContextListen implements ServletContextListener {
    
    /**
     * context 初始化
     *
     * @param sce
     */
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("------------contextInitialized---------");
        // web工程初始化的时候可以做一些其他的事情：再手动初始化自定义的一些东西(线程池，MQ等)
    }

    /**
     * context 销毁
     *
     * @param sce
     */
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println(" -----contextDestroyed-------");
        // web工程关闭的时候，另外再关闭一些东西
    }

/**
 * 监听Context里面的变量改变
 */
public class ContextAttributeListen implements ServletContextAttributeListener {
    /**
     * 监听ServletContext中添加变量
     *
     * @param event
     */
    @Override
    public void attributeAdded(ServletContextAttributeEvent event) {
        System.out.println("attributeAdded：：：name:" + event.getName() + "  value:" + event.getValue());
    }

    /**
     * 监听ServletContext中删除变量
     *
     * @param event
     */
    @Override
    public void attributeRemoved(ServletContextAttributeEvent event) {
        System.out.println("attributeRemoved：：：name:" + event.getName() + "  value:" + event.getValue());

    }

    /**
     * 监听ServletContext中修改变量
     *
     * @param event
     */
    @Override
    public void attributeReplaced(ServletContextAttributeEvent event) {
        System.out.println("attributeReplaced：：：name:" + event.getName() + "  value:" + event.getValue());

    }
}

　　6.2 web.xml配置监听

<!--监听器-->
    <listener>
        <listener-class>com.draymond.listen.ContextListen</listener-class>
    </listener>
    <listener>
        <listener-class>com.draymond.listen.ContextAttributeListen</listener-class>
    </listener>

项目地址： https://gitee.com/draymond728/springwork.git