【JAVAEE基础学习（10）】--简述Filter-json-ajax篇

Filter过滤器：
一、基本知识
    1.概念：
        1、Filter过滤器它是JavaWeb的三大组件之一。三大组件分别是：Servlet程序、Listener监听器、Filter过滤器
        2、Filter过滤器它是JavaEE的规范。也就是接口
        3、Filter过滤器它的作用是：拦截请求，过滤响应。
            拦截请求常见的应用场景有：
                1、权限检查
                2、日记操作
                3、事务管理
                等等
    2.实现原理：
        在客户端和目标资源间存在一个Filter过滤器，这个过滤器的作用就是判断客户端的请求是否有权限，有权限则正常访问目标资源

    3.Filter过滤器的使用步骤：
        1、编写一个类去实现 Filter 接口
        2、实现过滤方法 doFilter()
        3、到 web.xml 中去配置 Filter 的拦截路径

    4.Filter的生命周期包含几个方法
        1、构造器方法
        2、init初始化方法
            第1，2步，在web工程启动的时候执行（Filter已经创建）
        3、doFilter过滤方法
            第3步，每次拦截到请求，就会执行
        4、destroy 销毁
            第4步，停止web工程的时候，就会执行（停止web工程，也会销毁Filter过滤器）

    5.Filter的FilterConfig类：
        1、概念：FilterConfig类是Filter过滤器的配置文件，tomcat每次创建Filter时会同时创建一个FilterConfig类，里面包含了Filter配置文件信息

        2、FilterConfig类的作用是获取filter过滤器的配置内容
            1、获取Filter的名称filter-name的内容
            2、获取在Filter中配置的init-param初始化参数
            3、获取ServletContext对象

        3.FilterChain 过滤器链
            FilterChain 就是过滤器链（多个过滤器如何一起工作）

            FilterChain.doFilter()方法的作用：
                1、执行下一个Filter过滤器（若有filter）
                2、执行目标资源（若无filter）

            多个filter过滤器执行顺序由其在web.xml中的顺序执行

            多个filter过滤器执行的特点：
                1、所有filter和目标资源默认都执行在同一个线程中
                2、多个filter共同执行的时候，它们都使用一个Request对象

二、实例：
    实例1

{
    public class adminFilter implements Filter {
        public adminFilter() {
            System.out.println("1.Filter构造器方法adminFilter()");
        }

        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
            System.out.println("2.filter的init(FilterConfig filterConfig)初始化");

    //        1、获取Filter的名称filter-name的内容
            System.out.println("filter-name的内容:"+filterConfig.getFilterName());
    //        2、获取在web.xml中配置的init-param初始化参数
            System.out.println("init-param初始化参数username:"+filterConfig.getInitParameter("username"));
            System.out.println("init-param初始化参数url:"+filterConfig.getInitParameter("url"));
    //        3、获取ServletContext对象
            System.out.println(filterConfig.getServletContext());


        }

        /**
         * doFilter方法，专门用于拦截请求，可以做权限检查
         * @param servletRequest
         * @param servletResponse
         * @param filterChain
         * @throws IOException
         * @throws ServletException
         */
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            System.out.println("3、filter的doFilter过滤方法");
            
            HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;

            HttpSession session = httpServletRequest.getSession();
            Object user = session.getAttribute("user");


            //如果等于null，说明还没有登录
            if (user==null){
                servletRequest.getRequestDispatcher("/login.jsp").forward(servletRequest,servletResponse);
                return;
            }else {
                //让程序继续往下访问用户的目标资源
                filterChain.doFilter(servletRequest,servletResponse);
            }
        }

        @Override
        public void destroy() {
            System.out.println("4、destroy()销毁方法");
        }
    }
}

    实例2

{
    public class Filter1 implements Filter {
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {

        }

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            System.out.println("filter1前置代码");
            System.out.println("filter1线程"+Thread.currentThread().getName());
            System.out.println("filter1"+ servletRequest.getParameter("username"));
            servletRequest.setAttribute("key1","value1");
            filterChain.doFilter(servletRequest,servletResponse);
            System.out.println("filter1线程"+Thread.currentThread().getName());
            System.out.println("filter1后置代码");
        }

        @Override
        public void destroy() {

        }
    }
}

    实例3

{
    public class Filter2 implements Filter {
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {

        }

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            System.out.println("filter2前置代码");
            System.out.println("filter222线程"+Thread.currentThread().getName());
            System.out.println("filter2222"+ servletRequest.getParameter("username"));
            System.out.println("filter2222取filter1中保存的数据是："+servletRequest.getAttribute("key1"));
            filterChain.doFilter(servletRequest,servletResponse);
            System.out.println("filter222线程"+Thread.currentThread().getName());
            System.out.println("filter2后置代码");
        }

        @Override
        public void destroy() {

        }
    }
}

    三个实例的web.xml配置

{
    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
             version="4.0">

    <!--    filter标签用于配置一个filter过滤器-->
        <filter>
    <!--        给filter起别名-->
            <filter-name>adminFilter</filter-name>
    <!--        配置filter的全类名-->
            <filter-class>com.lixxkv.filter.adminFilter</filter-class>

            <init-param>
                <param-name>username</param-name>
                <param-value>root</param-value>
            </init-param>

            <init-param>
                <param-name>url</param-name>
                <param-value>jdbc:mysql://localhost:19990/book?useSSL=false</param-value>
            </init-param>
        </filter>
    <!--    filter-mapping配置filter过滤器的拦截路径-->
        <filter-mapping>
    <!--        filter-name表示当前的拦截路径给那个filter使用-->
            <filter-name>adminFilter</filter-name>
    <!--
            url-pattern配置拦截路径
            / 表示请求地址为：http://ip:port/工程路径/目录/*;     映射到IDEA的web目录下
            这就是目录匹配
            /admin/* 表示请求地址为：http://ip:port/工程路径/admin/*
    -->
            <url-pattern>/admin/*</url-pattern>
        </filter-mapping>


        <filter>
            <filter-name>Filter1</filter-name>
            <filter-class>com.lixxkv.filter.Filter1</filter-class>
        </filter>
        <filter-mapping>
            <filter-name>Filter1</filter-name>
            <url-pattern>/target.jsp</url-pattern>
        </filter-mapping>

        <filter>
            <filter-name>Filter2</filter-name>
            <filter-class>com.lixxkv.filter.Filter2</filter-class>
        </filter>
        <filter-mapping>
    <!--
            精确匹配拦截方法
            其中请求地址必须为：http://ip:port/工程路径/target.jsp
    -->
            <filter-name>Filter2</filter-name>
            <url-pattern>/target.jsp</url-pattern>
        </filter-mapping>


        <servlet>
            <servlet-name>LoginServlet</servlet-name>
            <servlet-class>com.lixxkv.servlet.LoginServlet</servlet-class>
        </servlet>
        <servlet-mapping>
            <servlet-name>LoginServlet</servlet-name>
            <url-pattern>/LoginServlet</url-pattern>
        </servlet-mapping>

    <!--
        在filter的拦截路径匹配中还有后缀名匹配
        <url-pattern>*.后缀名</url-pattern>
        以上配置的路径，表示请求地址必须以.后缀名结尾，才会拦截到
        filter过滤器值只关心请求地址是否匹配，不关心请求的资源是否存在
    -->


    </web-app>
}

json
一、基本知识
    1、概念：
        JSON(JavaScript Object Notation)是一种轻量级(和xml相比较)的数据交换(客户端和服务器之间业务数据的传递格式)格式。易于人阅读和编写。同时也易于机器解析和生成。JSON采用完全独立于语言的文本格式，而且很多语言都提供了对json的支持（包括C,C++,C#,Java,JavaScript,Perl,Python等）。这样就使得JSON成为理想的数据交换格式。

二、在客户端使用json
    JSON在JavaScript中的使用。

    1、定义：json是由键值对组成，并且由花括号（大括号）包围。每个键由引号引起来，键和值之间使用冒号进行分隔，多组键值对之间进行逗号进行分隔。
    实例

{
    var jsonObj={
        "key":12,
        "key1":"abc",
        "key2":true,
        "key3":[11,"array",false],
        "key4":{
            "key4_1":441,
            "key4_2":"key4_2value"
        },
        "key5":[{
            "key5_1_1":5511,
            "key5_1_2":"key5-1-2-value"
        },{
            "key5_2_1":5521,
            "key5_2_2":"key5-2-2-value"
        }]
    }
}

    2、访问：json本身是一个对象。json中的key我们可以理解为是对象中的一个属性。json中的key访问就跟访问对象的属性一样：json对象.key
    实例

{
    alert(jsonObj.key);//12
    alert(jsonObj.key1);//abc
    alert(jsonObj.key2);//true
    alert(jsonObj.key3);//得到数组[11,"array",false]
    // json中数组值的遍历
    for (let i = 0; i < jsonObj.key3.length; i++) {
        alert(jsonObj.key3[i]);
    }
    alert(jsonObj.key4.key4_1);//441
    alert(jsonObj.key4.key4_2);//"key4_2value"
    alert(jsonObj.key5);//得到json数组
    var jsonItem=jsonObj.key5[0];
    alert(jsonItem.key5_1_1);//5511
    alert(jsonItem.key5_1_2);//"key5-1-2-value"
    var jsonItem00=jsonObj.key5[1];
    alert(jsonItem00.key5_2_1);
    alert(jsonItem00.key5_2_2);
}

    3、json两个常用方法：
        json的存在有两种形式。：
            1、对象的形式存在，被称为json对象。
        要操作json中的数据的时候，需要json对象的格式
            2、字符串的形式存在，被称为json字符串。
        要在客户端和服务器之间进行数据交换的时候，使用json字符串。

            JSON.stringify()：把json对象转换成为json字符串
            JSON.parse()：把json字符串转换成为json对象

        实例

{
    //json对象转字符串
    alert(jsonObj);
    //把json对象转换成json字符串
    var jsonObjString =JSON.stringify(jsonObj);//类似java中的toString
    // alert(jsonObjString);
    //json字符串转json对象
    var jsonObj2=JSON.parse(jsonObjString);
    alert(jsonObj2.key);
    alert(jsonObj2.key1);
}

三、在服务器端使用json
    在java中使用json，首先要导入json的jar包
    java端json使用实例

{
    public class jsonTest {
        //javaBean和json的转换
        @Test
        public void testOne(){
            Person person = new Person(1, "张三");
            //创建gson对象实列
            Gson gson = new Gson();
            //toJson()方法可以把javaBean转换成json字符串
            String personJsonString = gson.toJson(person);
            System.out.println(personJsonString);

            //fromJson把json字符串转换回java对象，第一个参数是json字符串，第二个参数是转换回去的javaBean类型
            Person personOne = gson.fromJson(personJsonString, Person.class);
            System.out.println(personOne);
        }
        //List和json的转换
        @Test
        public void testTwo(){
            ArrayList<Person> peopleList = new ArrayList<>();
            peopleList.add(new Person(1,"张三"));
            peopleList.add(new Person(2,"王五"));
            peopleList.add(new Person(3,"赵六"));

            Gson gson = new Gson();
            //把list集合转换为json字符串
            String personListJsonString = gson.toJson(peopleList);
            System.out.println(personListJsonString);

            List<Person> list = gson.fromJson(personListJsonString, new PersonListType().getType());
            System.out.println(list);
            Person person = list.get(0);
            System.out.println(person);

        }
        //map和json的转换
        @Test
        public void testThree(){
            Map<Integer, Person> personMap = new HashMap<>();
            personMap.put(1,new Person(1,"张三"));
            personMap.put(2,new Person(2,"王五"));
            personMap.put(3,new Person(3,"赵六"));

            Gson gson = new Gson();
            String personMapJsonString = gson.toJson(personMap);
            System.out.println(personMapJsonString);

    //        Map<Integer, Person> personMapOne  = gson.fromJson(personMapJsonString, new PersonMapType().getType());
            //使用匿名内部类的方式
            Map<Integer, Person> personMapOne  = gson.fromJson(personMapJsonString, new TypeToken<HashMap<Integer, Person>>(){}.getType());
            System.out.println(personMapOne);
            Person personOne = personMapOne.get(1);
            System.out.println(personOne);
        }
    }
}

ajax
一、基本知识：
    1.概念：
        AJAX即“Asynchronous Javascript And XML”（异步JavaScript和XML），是指一种创建交互式网页应用的网页开发技术。
        ajax是一种浏览器通过js异步发起请求，局部更新页面的技术。 Ajax请求的局部更新，浏览器地址栏不会发生变化 局部更新不会舍弃原来页面的内容
    2.同步与异步：
        同步：串行
        异步：并行
    
二、jQuery中的AJAX请求
     $.ajax方法
        url 表示请求的地址
        type 表示请求的类型 GET 或 POST 请求
        data 表示发送给服务器的数据
            格式有两种：
                一：name=value&name=value
                二：{key:value}
        success 请求成功，响应的回调函数
        dataType 响应的数据类型
            常用的数据类型有：
                text 表示纯文本
                xml 表示 xml 数据
                json 表示 json 对象

    $.get 方法和$.post 方法
        url 请求的 url 地址
        data 发送的数据
        callback 成功的回调函数
        type 返回的数据类型

    $.getJSON 方法
        url 请求的 url 地址
        data 发送给服务器的数据
        callback 成功的回调函数

    表单序列化 serialize()
        serialize()可以把表单中所有表单项的内容都获取到，并以 name=value&name=value 的形式进行拼接。