servlet,Filter,责任的设计模式，静态代理

servlet

servlet是前端和数据库交互的一个桥梁

静态网页资源的技术：
  在前端整个运行的过程中 我们的网页代码不发生改变的这种情况就称为静态的网页资源技术

动态网页资源的技术：
  在前端运行的过程中 我们的前端页面代码会发生改变的这种情况就称为 动态的网页资源技术

servlet的生命周期

生命周期 就是这个Servlet从创建到销毁的整个过程 

问题来了：Servlet什么时候创建呢?

默认情况下 程序启动是不会 创建Servlet对象的

程序在第一次启动的时候 创建对象 执行init方法

那么有没有方法在程序启动的时候 就让Tomcat将这个对象创建好呢?

@WebServlet(urlPatterns = "/ticket/sell",loadOnStartup = 1)

  <servlet>
        <!--    这个名字逻辑上可以随便写  但是一般见名之意 写这个类的类名-->
        <servlet-name>UserServlet</servlet-name>
        <!--    这个配置的是Servlet的全路径-->
        <servlet-class>com.qfedu.edu.servlet.UserServlet</servlet-class>

        <!--
           <load-on-startup>1</load-on-startup> 是一个在web.xml文件中常见的参数配置。它用于指定在应用程序启动时，是否要立即加载某个Servlet或其他组件。当设置为1时，表示在应用程序启动时立即加载；当设置为0时，表示不立即加载，而是在第一次请求时才加载。
        -->
        <load-on-startup>1</load-on-startup>
    </servlet>

程序的销毁是在 Tomcat关闭的时候 这个Servlet才会被销毁

全局参数

所谓的这个全局的参数指的是在任何一个Servlet中都能取到这个参数那么这个参数就是全局参数

在web.xml中申明全局参数

<!--    申明全局参数-->
    <context-param>
        <param-name>filename</param-name>
        <param-value>test.txt</param-value>
    </context-param>

    <context-param>
        <param-name>键</param-name>
        <param-value>值</param-value>
    </context-param>

局部参数

Request对象

tomcat将请求封装成了一个对象，这个对象就是Request

Request相关方法

//req中参数的含义
//http://localhost:8080/users?username=admin&password=123456&%E8%AF%B7%E6%B1%82=%E6%8F%90%E4%BA%A4
//  /users
String requestURI = req.getRequestURI();//端口之后，问号之前的数据
String method = req.getMethod(); //获取请求的方法
//String parameter = req.getParameter();通过名字请求参数
req.getContextPath();//获取上下文信息
req.getCookies(); //cookies信息获取
req.getHeaderNames();//获取HTTP协议中所有的key
req.getRequestURL();//获取请求地址

Request获取请求数据

GET

String queryString = req.getQueryString();
System.out.println("获取到的数据是："+queryString);
//获取到的数据是：username=%E5%BC%A0%E4%B8%89&password=123456&%E8%AF%B7%E6%B1%82=%E6%8F%90%E4%BA%A4
//获取到的数据是加密的，使用的是URLEncode编码
//要使用URLDecode解码
String decode = URLDecoder.decode(queryString,"UTF-8");
System.out.println(decode);
//================================
//如果是tomcat8以前的版本会出现乱码问题
//因为tomcat在处理数据的时候将这些数据进行了ISO-8859-1的编码
//这个ISO-8859-1是欧洲人的编码
//解决办法是先采用ISO-8859-1解码后，再采用汉字编码重新编码，再解码就可以了
String username = req.getParameter("username");
String password = req.getParameter("password");


//解码
//        byte[] bytes = username.getBytes("ISO-8859-1");
//        username=new String(bytes,"UTF-8");

System.out.println(username+"="+password);

URL和URI的区别

URI：统一资源标记符

不光可以标记本地资源，还可以标记网络资源

URL：统一资源定位符

只能定位网络资源

从范围上看，URL的范围小于URI

POST

public class RequestParameterServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //第一种方式getParameter
        //设置编码格式
//        req.setCharacterEncoding("UTF-8");
//        String username = req.getParameter("username");
//        String password = req.getParameter("password");
//        System.out.println("username:"+username+"-----password:"+password);
        //第二种方式：流 post方式都可以使用流来获取
        ServletInputStream in = req.getInputStream();
        //将输入流放到缓冲区
        byte[] buf = new byte[8192];
        int readLength = in.read(buf);
        String val = new String(buf, 0, readLength);
        String values = URLDecoder.decode(val,"UTF-8");
        System.out.println("取出的数据是："+values);
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //get第第一种方式
        String queryString = req.getQueryString();
        System.out.println(queryString);//URLEncode编码
        String values = URLDecoder.decode(queryString, "UTF-8");
        System.out.println("获取到的数据时："+values);
        //username=%E5%BC%A0%E4%B8%89&password=123456
        //第二种方式
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        //????是ISO-8859-1编码，需要解码
        byte[] bytes = username.getBytes("ISO-8859-1");
        username = new String(bytes, "UTF-8");
        byte[] bytepwd = password.getBytes("ISO-8859-1");
        password = new String(bytepwd, "UTF-8");
        System.out.println("username:"+username+"-----password:"+password);
    }
}

Response对象的使用

http响应码

对于HTTP协议的这样一个请求 的响应码很重要  

200：表示的是请求成功

302：重定向错误(多次重定向)

400：服务器接受到数据了 但是无法处理参数  简单的说就是参数不匹配

401：未认证

403：没权限访问

404：路径没对

500：服务器报错

页面转发

转发的特点是啥?
转发的时候请求地址不变转发只能转发到服务器的内部不能抓没法到第三方的服务器上转发是一次性的请求 req 统一的一个
转发如何实现

req.getRequestDispatcher("/teudan.html").forward(req,resp);

页面重定向

重定向的特点
地址会发生改变
重定向是可以定位到任意的服务器的
重定向的请求和原始的请求不是一个

resp.sendRedirect("http://www.baidu.com");

响应数据的编写

//响应数据给客户端
//你就告诉他编码是啥
resp.setContentType("text/html;charset=utf-8");
PrintWriter writer = resp.getWriter();
writer.write("小波波最帅");
writer.flush();
writer.close();

json格式

Filter

什么是过滤器呢?

所谓的过滤器你可以认为这个请求和响应都要经过他、经过他的时候他就可以干预你

这个Filter就是横跨在我们的前端请求和 Servlet之间的一个桥梁

这个Filter可以单独的对我们的请求和响应进行干预(改变他|拦截他)

这个Filter的出现就是为了规避Java中的一个职责 (单一职责)----->实际上是一个责任链的设计模式

单一职责：自己的事情自己干

浏览器上发送的请求默认都是 get请求

Filter的使用

filter的编写

public class AuthticationFilter implements Filter {
    /**
     * 请求和响应都会经过这个方法
     *
     * @param servletRequest
     * @param servletResponse
     * @param filterChain
     * @throws IOException
     * @throws ServletException
     */
    public void doFilter(ServletRequest servletRequest,
                         ServletResponse servletResponse,
                         FilterChain filterChain) throws IOException, ServletException {

        System.out.println("过滤器执行了....之前");
        //这句话的意思就是放行...
        //filterChain.doFilter(servletRequest,servletResponse);

        System.out.println("过滤器执行了....之后");
    }
}

编写声明

<!--   配置   -->

<filter>
    <filter-name>AuthticationFilter</filter-name>
    <filter-class>com.qfedu.edu.filter.AuthticationFilter</filter-class>
</filter>

<filter-mapping>
    <filter-name>AuthticationFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

第二种使用方式

@WebFilter(urlPatterns = "/*")
public class BlackFilter implements Filter {
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
System.out.println("黑名单的Filter----之前");
filterChain.doFilter(servletRequest, servletResponse);
System.out.println("黑名单的Filter----之后");
}
}

Filter的生命周期

在程序启动的时候创建Filter对象
对象创建完成，调用init方法进行对资源的初始化操作
当Tomcat关闭的时候，这个Filter的destroy执行

参数的初始化

package com.wz.practice.servlet.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;
import java.io.IOException;

@WebFilter(urlPatterns = "/*",initParams = {
    @WebInitParam(name="key1",value = "val1")
})
public class AuthenticationFilter implements Filter {
    public AuthenticationFilter() {
        System.out.println("AuthenticationFilter创建对象");
    }

    /**
     * 资源初始化
     *
     * @param filterConfig 这个参数拿到你设计的全局变量或局部变量
     * @throws ServletException
     */

    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("AuthenticationFilter--init执行的地方");
        String test = filterConfig.getServletContext().getInitParameter("test");
        System.out.println("拿到的(全局)参数值是"+test);
        //下面这个方法只能拿到自己的参数
        String key1 = filterConfig.getInitParameter("key1");
        System.out.println("拿到的局部参数是"+key1);

    }

    /**
     * 拦截请求
     *
     * @param servletRequest
     * @param servletResponse
     * @param filterChain
     * @throws IOException
     * @throws ServletException
     */
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("请求之前的拦截");
        filterChain.doFilter(servletRequest, servletResponse);
        System.out.println("请求之后的拦截");
    }

    public void destroy() {
        System.out.println("destory执行的地方");
    }
}

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <context-param>
    <param-name>test</param-name>
    <param-value>123</param-value>
  </context-param>

</web-app>

Filter的运行原理

配置模式下这个运行顺序的问题

<!--申明Filter-->
<filter>
    <filter-name>AuthFilter</filter-name>
    <filter-class>com.wz.practice.filter.AuthFilter</filter-class>
</filter>
<filter>
    <filter-name>BlackFilter</filter-name>
    <filter-class>com.wz.practice.filter.BlackFilter</filter-class>
</filter>
<filter>
    <filter-name>LimitFilter</filter-name>
    <filter-class>com.wz.practice.filter.LimitFilter</filter-class>
</filter>


<!--谁先申明，谁先执行-->
<filter-mapping>
    <filter-name>LimitFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
    <filter-name>AuthFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
    <filter-name>BlackFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

注解方式的顺序

注解方式的时候跟这个Filter名字字母的先后顺序有关系排在前面的先执行排在后面的后执行

混合方式的顺序

先配置在按照注解的Filter的手写字母排序

配置注解排序

责任链的设计模式

需求：
  通过一个全局的过滤器  执行到自定义的这个链条中来   这个自定义的链条就可以实现 限流 降级 认证 鉴权 黑名单校验 敏感词校验 .....
  责任链的设计模式主要实现的功能就是 过滤器  或者拦截器

给所有的链编写一个父接口(BaseSlot)

package com.wz.practice.slot.base;

import javax.servlet.http.HttpServletRequest;

/**
* 我们这里的目的是为了实现仿写
* 给这个过滤器整了个爹  这个接口类似于我们的 Filter接口
*/
public interface BaseSlot {

   /**
    * 这个就要要处理的方法
    * 这个方法类似于我们的 doFilter方法
    * @param req
    */
   void dealReq(HttpServletRequest req);
}

给这个BaseSlot的执行编写一个父接口最终需要一个类去调用这个BaseSlot的所有孩子 SlotChain

package com.wz.practice.slot.base;

import javax.servlet.http.HttpServletRequest;

/**
* 这个接口的抽象是为了调用BaseSlot的实现类的
*/
public interface SlotChain {

   /**
    * 这个就要要处理的方法
    * 这个方法类似于我们的 doFilter方法
    *
    * @param req
    */
   void dealReq(HttpServletRequest req);
}

编写链条 --------- 给这个BaseSlot编写实现类

package com.wz.practice.slot.impl;

import com.wz.practice.slot.base.BaseSlot;

import javax.servlet.http.HttpServletRequest;

public class AuthSlot implements BaseSlot {

   public void dealReq(HttpServletRequest req) {
       System.out.println("----AuthSlot-----------");
   }
}


package com.wz.practice.slot.impl;

import com.wz.practice.slot.base.BaseSlot;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

public class BlackSlot implements BaseSlot {

   public void dealReq(HttpServletRequest req) {
       System.out.println("-------BlackSlot--------");
   }
}


package com.wz.practice.slot.impl;

import com.wz.practice.slot.base.BaseSlot;

import javax.servlet.http.HttpServletRequest;

public class LimitSlot implements BaseSlot {
   public void dealReq(HttpServletRequest req) {
       System.out.println("-------LimitSlot--------");
   }
}

编写链条的调用者 -------- SlotChain的实现类

在SlotChainImpl中去申明我们的BaseSlot的容器

package com.wz.practice.slot.impl;

import com.wz.practice.slot.base.BaseSlot;
import com.wz.practice.slot.base.SlotChain;

import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.io.InputStream;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;

public class SlotChainImpl implements SlotChain {
   private static Map<String, BaseSlot> maps = new ConcurrentHashMap<String,BaseSlot>();
   private static String slotOrder;
   static {
       maps.put("authSlot",new AuthSlot());
       maps.put("blackSlot",new BlackSlot());
       maps.put("limitSlot",new LimitSlot());
       //资源加载
       InputStream in = SlotChainImpl.class.getClassLoader().getResourceAsStream("slot.properties");
       Properties properties = new Properties();
       try {
           properties.load(in);
           slotOrder = (String) properties.get("slotOrder");
       } catch (IOException e) {
           e.printStackTrace();
       }

   }
   public void dealReq(HttpServletRequest req) {
       if(maps.size()==0){
           throw new RuntimeException("slot数据为空无法启动链条");
       }
       if("".equals(slotOrder)||null==slotOrder){
           throw new RuntimeException("slot执行顺序未定义....");
       }
       //执行到这里两边都有值
       if(!slotOrder.contains(",")){
           //说明只有一个值
           BaseSlot baseSlot = maps.get(slotOrder);
           handlerSimpleSlot(req, baseSlot);
           return ;
       }
       //程序如果是执行到这里 说明有多个名字
       String[] split = slotOrder.split(",");
       for (int i = 0; i <split.length ; i++) {
           //取出这个名字
           String slotName = split[i];
           //说明只有一个值
           BaseSlot baseSlot = maps.get(slotName);
           //接下来从maps中取出数据
           handlerSimpleSlot(req, baseSlot);
       }
   }

   /**
    * 处理单个Slot
    * @param req
    * @param baseSlot
    */
   private static void handlerSimpleSlot(HttpServletRequest req, BaseSlot baseSlot) {
       if(null== baseSlot){
           throw new RuntimeException("slot执行顺序的名字不对");
       }
       //执行到这里说明名字是对的
       baseSlot.dealReq(req);
   }
}

给这个BaseSlot编写调用顺序----slot.properties

slotOrder = limitSlot,authSlot,blackSlot

在SlotChainImpl中去进行BaseSlot链条的调用

package com.wz.practice.filter;

import com.wz.practice.slot.base.SlotChain;
import com.wz.practice.slot.impl.SlotChainImpl;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
* 全局过滤器
*/
@WebFilter(urlPatterns = "/*")
public class GlobleFilter implements Filter {
   private SlotChain slotChain = new SlotChainImpl();
   public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
       try {
           slotChain.dealReq((HttpServletRequest) servletRequest);
       } catch (Exception e) {
           System.out.println("执行到了异常！");
       }
   }
}

代理的设计模式

代理模式的主要实现功能是什么？

对方法进行监听，在执行方法是动态的植入我们的代码

静态代理

静态代理和动态代理，被代理的类必须实现接口

静态代理的步骤：
	1、编写一个代理类和被代理类，实现相同的接口
	2、在这个代理类维护被代理类的类对象
	3、在下面的方法中，调用被代理类中相同名字的方法，就能完成代理

静态代理的步骤：

编写接口

package com.wz.practice.proxy.static1;

public interface IUserService {
   void add();
   void update();
}

编写被代理类

package com.wz.practice.proxy.static1;

public class UserService implements IUserService{
   public void add() {
       System.out.println("-------add执行------");
   }

   public void update() {
       System.out.println("--------update执行-----");
   }
}

编写代理类

package com.wz.practice.proxy.static1;

public class UserServiceProxy implements IUserService{
   //在这个类中维护被代理的对象
   private IUserService userService;
   public UserServiceProxy(IUserService userService){
       this.userService=userService;
   }

   //在下面的方法中调用 被代理类中相同名字的方法 就可以完成监控了
   public void add() {
       System.out.println("打开事务");
       userService.add();
       System.out.println("提交事务");
   }

   public void update() {
       System.out.println("打开事务");
       userService.update();
       System.out.println("提交事务");
   }
}

测试

package com.wz.practice.proxy.static1;

public class test {
   public static void main(String[] args) {
       UserServiceProxy userServiceProxy = new UserServiceProxy(new UserService());
       userServiceProxy.update();
       userServiceProxy.add();
   }
}

结果：

servlet,Filter,责任的设计模式，静态代理_动态代理

动态代理(JDK代理)

静态代理和动态代理，被代理的类必须实现接口

整个代理的过程被JDK实现了

Proxy.newProxyInstance

动态代理的步骤：

编写接口

package com.wz.practice.proxy.dynamic;

public interface IUserService {
    void add();
    void update();
}

编写被代理的类

package com.wz.practice.proxy.dynamic;

public class UserService implements IUserService{
    public void add() {
        System.out.println("-------add执行-------");
    }

    public void update() {
        System.out.println("---------update执行-----");
    }
}

测试

package com.wz.practice.proxy.dynamic;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Test {
    public static void main(String[] args) {
        /**
         * 第一个参数类加载器 这个是有固定的写法
         *    被代理的类.class.getClassLoader
         *  第二个参数：就是我们被代理的类实现的接口
         *    如果被代理的是类：被代理的类.class.getInterfaces();
         *    如果被代理的是接口：new Class[]{被代理的接口.class}
         *  第三个参数：就是对这个代理的类或者接口中方法执行的监听
         *    new InvocationHandler(){}
         */
        IUserService userServiceProxy = (IUserService) Proxy.newProxyInstance(UserService.class.getClassLoader(), UserService.class.getInterfaces(), new InvocationHandler() {
            /**
             * 这个方法就是对你当前执行方法的监听
             * proxy：代理类对象
             * method：当前执行的方法
             * args：执行方法需要的参数
             * @return
             * @throws Throwable
             */
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("打开事务");
                String name = method.getName();
                System.out.println("当前执行的方法是："+name);

                //可以去执行这个方法
                //这里的第一个参数：被代理类的对象
                Object invoke = method.invoke(new UserService(), args);
                System.out.println("提交事务.....");
                return invoke;
            }
        });
        userServiceProxy.add();
        userServiceProxy.update();
    }
}