Java第十二周心得体会

1.本周思维导图

点击查看详情

2.个人总结

会话技术

Cookie：数据存储到浏览器

• 获取Cookie

Cookie[] cookies = request.getCookies();
    Cookie cookie = null;
    for(Cookie sonCookie : cookies){
        if("msg".equals(sonCookie.getName())){
        cookie = sonCookie;
        }
    }
    if(null != cookie){
        System.out.println("name : "+msgCookie.getName() + " , value : "+             
        msgCookie.getValue());
}

• CookieUtils

public static Cookie getCookie(Cookie[] cookies ,String cookieName){
    if (null != cookies && 0 != cookies.length) {
        for (Cookie sonCookie : cookies) {
            if (cookieName.equals(sonCookie.getName())) {
                return sonCookie;
            }
        }
    }
    return null;
}

Session：数据存储到服务器

• 执行流程

第一次请求DemoServlet时，根据request.getSession方法， 新建一个session对象

当第一次响应时，会将该session对象的ID作为cookie头，响应给浏览器保存

第二次请求DemoServlet时，根据request.getSession方法，请求中会有cookie头

会根据该JSESSIONID去服务器中找有没有对应的session对象，如果有直接用，没有则新建

• 相关配置

Session 生命周期

默认有30分钟的存活时间，详情如下

 web.xml

  <session-config>
        <session-timeout>30</session-timeout>
  </session-config>

• 可通过session.invalidate方法，立即将对应的session对象销毁，后续则会新建session对象
• session两种销毁情况
  • 默认过了30分钟
  • 调用了invalidate方法

封装单条记录的结果集

• 自定义DbUtils：MyBeanHandler

public class MyBeanHandler<T> implements  MyResultSetHandler<T> {

    private Class<T> clazz;//User类Class对象，也可以是Student类Class对象

    public MyBeanHandler(Class<T> clazz) {
        this.clazz = clazz;
    }

    @Override
    public T handle(ResultSet resultSet) throws Exception {
        T t = clazz.newInstance();
        //处理结果集
        while (resultSet.next()){
            //id属性值,username属性值,password属性值
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                //字段名称
                String fieldName = field.getName();
                //字段值
                Object fieldValue = resultSet.getObject(fieldName);
                //将字段值设置Class对象对应的java实体对象
                //获取字段对应set方法
                String methodName = "set" + fieldName.substring(0,1).toUpperCase() + fieldName.substring(1);
                Method method = clazz.getMethod(methodName, field.getType());
                if (null != method) {
                    method.invoke(t,fieldValue);
                }
            }


        }
        return t;
    }
}

• 自定义DbUtils：MyBeanListHandler

public class MyBeanListHandler<T> implements MyResultSetHandler<List<T>> {

    private Class<? extends T> clazz;//集合中元素的Class对象

    public MyBeanListHandler(Class<? extends T> clazz) {
        this.clazz = clazz;
    }

    @Override
    public List<T> handle(ResultSet resultSet) throws Exception {
        List<T> list = new ArrayList<>();
        while (resultSet.next()) {
            //循环一次,就是一条记录,就是一个对象
            T t = clazz.newInstance();
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                String fieldName = field.getName();
                Object fieldValue = resultSet.getObject(fieldName);
                //获取set方法
                String methodName = "set"+fieldName.substring(0,1).toUpperCase()+fieldName.substring(1);
                Method method = clazz.getMethod(methodName, field.getType());
                if (null != method) {
                    method.invoke(t,fieldValue);
                }
            }
            list.add(t);
        }
        return list;
    }
}

过滤器

• 生命周期

随着服务器启动而初始化

随着请求的发出而过滤

随着服务器关闭而销毁

• 执行流程

浏览器发起请求

服务器会根据请求，创建request对象及response对象

过滤器会持有request对象及response对象

只有当过滤器放行之后，request对象及response对象才会传给Serlvet

•  根据配置顺序，遵从"先过滤，后放行"的原则
• 相关配置
  • Filter配置初始化参数

<filter>
        <filter-name>Demo03Filter</filter-name>
        <filter-class>com.qfedu.filter.DemoFilter</filter-class>
        <!--初始化参数-->
        <init-param>
            <param-name>username</param-name>
            <param-value>root</param-value>
        </init-param>
        <init-param>
            <param-name>password</param-name>
            <param-value>root123</param-value>
        </init-param>
</filter>

 

• Filter获取初始化参数

public class Demo03Filter implements Filter {

    public void init(FilterConfig config) throws ServletException {
        Enumeration<String> parameterNames = config.getInitParameterNames();
        while (parameterNames.hasMoreElements()) {
            //获取初始化参数名称
            String parameterName = parameterNames.nextElement();
            //获取初始化参数值
            String parameterValue = config.getInitParameter(parameterName);
            System.out.println("name : " + parameterName + " , value : " + parameterValue);
        }
    }   
}

过滤器注解开发

• @WebFilter注解

  • WebInitParam[] initParams() default {}；配置初始化参

  • String filterName() default ""；配置过滤器名称

  • String[] servletNames() default {}；配置过滤的Servlet

  • String[] urlPatterns() default {}；配置过滤路径

@WebFilter(filterName = "Demo04Filter" ,
        urlPatterns = "/demo01",
        servletNames = "Demo01Servlet" ,
        initParams = {
                @WebInitParam(name = "username",value = "root"),
                @WebInitParam(name = "password",value = "root123")
        })
public class Demo04Filter implements Filter {


    public void init(FilterConfig config) throws ServletException {
        Enumeration<String> parameterNames = config.getInitParameterNames();
        while (parameterNames.hasMoreElements()) {
            String parameterName = parameterNames.nextElement();
            String parameterValue = config.getInitParameter(parameterName);
            System.out.println(parameterName + " , " + parameterValue);
        }
    }
}

 

• 执行顺序
  • 按照过滤器的类名的字典顺序决定谁先过滤，谁先放行

过滤器解决中文乱码

public class EncodingFilter implements Filter {

    private String encoding = null;

    public void init(FilterConfig config) throws ServletException {
        encoding = config.getInitParameter("encoding");
    }

    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        //处理响应中文乱码
        resp.setContentType("text/html;charset="+encoding);
        //处理请求中文乱码
        req.setCharacterEncoding(encoding);
        chain.doFilter(req, resp);//放行
    }
}

<filter>
    <filter-name>EncodingFilter</filter-name>
    <filter-class>com.qfedu.filter.EncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>utf-8</param-value>
    </init-param>

</filter>

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

过滤器屏蔽敏感词

@WebFilter(
        filterName = "SensitiveWordsFilter" ,
        urlPatterns = "/*",
        initParams = {
                @WebInitParam(name = "word1", value = "山寨"),
                @WebInitParam(name = "word2", value = "水货"),
                @WebInitParam(name = "word3", value = "盗版"),
                @WebInitParam(name = "word4", value = "刻录")
        })
public class SensitiveWordsFilter implements Filter {

    //敏感词
    List<String> sensitiveWords = new ArrayList<>();

    public void init(FilterConfig config) throws ServletException {
        Enumeration<String> parameterNames = config.getInitParameterNames();
        while (parameterNames.hasMoreElements()) {
            String sensitiveWord = config.getInitParameter(parameterNames.nextElement());
            sensitiveWords.add(sensitiveWord);
        }
    }

    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        System.out.println("SensitiveWordsFilter doFilter");
        HttpServletRequest request = (HttpServletRequest) req;
        //增强request下的getParameter方法
        HttpServletRequest requestPrxoy = (HttpServletRequest) Proxy.newProxyInstance(
                request.getClass().getClassLoader(),
                request.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //增强getParameter方法
                        Object returnValue = null;
                        String methodName = method.getName();
                        if ("getParameter".equals(methodName)) {
                            //returnValue就是getParameter方法的返回值,可能会存在敏感词
                            String returnValue1 = (String)method.invoke(request, args);
                            //开始处理敏感词
                            for (String sensitiveWord : sensitiveWords) {
                                if (returnValue1.contains(sensitiveWord)) {
                                    //getParameter方法的返回值包含敏感词
                                    returnValue1 = returnValue1.replace(sensitiveWord,"***");
                                }
                            }
                            return returnValue1;
                        } else {
                            returnValue = method.invoke(request, args);
                        }
                        return returnValue;
                    }
                });
        chain.doFilter(requestPrxoy, resp);
    }
}

监听器

监听器分类

• 一类监听器
  • 监听域对象的创建、销毁
• 二类监听器
  • 监听域对象中的属性变更(属性设置、属性替换、属性移除)
• 三类监听器
  • 监听域对象的Java对象的绑定

一类监听器

• ServletRequestListener ： 监听ServletRequest域对象的创建、销毁
• HttpSessionListener ：监听HttpSession域对象的创建、销毁
• ServletContextListener ： 监听ServletContext域对象的创建、销毁

二类监听器

• ServletRequestAttributeListener ：监听ServletRequest域对象中属性变更
• HttpSessionAttributeListener ：监听HttpSession域对象中属性变更
• ServletContextAttributeListener ：监听ServletContext域对象中属性变更

三类监听器

• HttpSessionBindingListener
  • 监听session域中的java对象的状态(绑定和解绑)
  • HttpSessionBindingListener不需要配置 web.xml

监听器注解开发

• @WebListener 通等于配置web.xml绑定监听器

@WebListener
public class MyServletContextLIstener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("ServletContext创建");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("ServletContext销毁");
    }
}