• AJAX和JSON

    1、AJAX：

            AJAX（Asynchronous JavaScript and XML）是一种用于创建交互式、动态网页的技术。它允许网页在不重新加载整个页面的情况下与服务器进行异步通信，从而改善用户体验。以下是关于AJAX的一些重要信息：

    1. 异步通信：AJAX 的核心特性是异步通信，意味着在向服务器发送请求时，页面无需等待服务器的响应。这允许页面继续执行其他操作，同时等待响应。一旦响应可用，就会触发回调函数来处理数据。

    2. JavaScript：AJAX 主要使用JavaScript来实现。通过JavaScript，可以创建HTTP请求（通常是GET或POST请求），并在后台发送这些请求。然后，JavaScript可以解析从服务器返回的响应数据，并将其插入到网页中，实现动态更新。

    3. XML或JSON：虽然最初的名字中包含XML（eXtensible Markup Language），但实际上，现在更常见的是使用JSON（JavaScript Object Notation）作为数据的传输格式。JSON更轻量，易于处理，并且与JavaScript天然兼容。当然，仍然可以使用XML。

    4. 无需页面刷新：AJAX的一个重要优势是它可以在不刷新整个网页的情况下更新部分页面内容。这可以提高用户体验，因为页面可以动态地加载新数据，而不需要重新加载整个页面。

    5. 用途：AJAX广泛用于各种Web应用程序，包括在线邮件客户端、社交媒体网站、购物车更新、实时通讯等。任何需要实时或部分页面更新的情况都可以受益于AJAX技术。

    6. 浏览器支持：AJAX已经成为现代Web开发的标准之一，并且得到了主流浏览器的广泛支持。开发人员可以使用原生JavaScript或AJAX库（如jQuery、Axios等）来简化AJAX请求的编写和处理。

            总之，AJAX是一种强大的技术，使Web应用程序更加动态和交互，提高了用户体验，并为开发人员提供了更多的灵活性和控制权，使他们能够实现各种复杂的Web功能。

            同步的话：比如你和对象打电话，永远是一个人在讲 一个人在听，不可能同时讲话也不可能同时倾听是吧，一个在说话，另一个什么都干只是在那倾听。

             客户端必须等待服务器端的响应。在等待的期间客户端不能做其他操作。

            异步的话：就是比如你和对象打电话，你对象在讲话，你在打游戏，你没有停下来听，忙着你自己的事情，等她讲完然后去回应她

            客户端不需要等待服务器端的响应。在服务器处理请求的过程中，客户端可以进行其他的操作。

    2、AJAX的实现方式

            1、基于原生的方式：

    客户端：

    1. html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>基于jstitle>
    6. head>
    7. <script>
    8.     function fun() {
    9.         //法送异步请求
    10.  
    11.         //1.创建核心对象
    12.         // 创建 XMLHttpRequest 对象
    13.         const xhttp = new XMLHttpRequest();
    14.  
    15.         // 定义回调函数
    16.         xhttp.onload = function () {
    17.             // 您可以在这里使用数据
    18.         }
    19.  
    20.         // 建立连接
    21.         /*
    22.         * 参数:
    23.         *       第一个: 请求方式
    24.         *       如果是get方式,请求参数那在URL后面拼接,如果是post请求,请求参数在sent(String)
    25.         *       第二个: 请求的url
    26.         *       第三个: 同步(ture)或者异步(false)请求
    27.         * */
    28.         xhttp.open("GET", "/web_tomcat/AjaxServletDemo1?username=张三", true);
    29.  
    30.         //xhttp.open("GET", "/web_tomcat/AjaxServletDemo1?username=张三",false);
    31.         //发送请求
    32.         xhttp.send();//psot的话xhttp.send(String) String是请求的参数
    33.  
    34.  
    35.         //接收并且处理来自服务器的响应结果
    36.         /*
    37.         * 获取方式 xhttp.responseText  但是要在服务器相应以后才能或者,不然获取不到数据*/
    38.  
    39.         //当xhttp对象的就绪状态发生改变的时候会触发事件onreadystatechange 然后执行函数
    40.         xhttp.onreadystatechange = function () {
    41.             //判断readyState是不是4  0: 请求未初始化
    42.  
    43.             /*1: 服务器连接已建立
    44.             2: 请求已接收
    45.             3: 正在处理请求
    46.             4: 请求已完成且响应已就绪*/
    47.  
    48.             //判断status响应状态是不是200
    49.  
    50.             /*200: "OK"
    51.             403: "Forbidden"
    52.             404: "Page not found"*/
    53.  
    54.             if (this.readyState == 4 && this.status == 200) {
    55.                 //都满足,获取结果
    56.                 let responseText = this.responseText;
    57.                 alert(responseText)
    58.             }
    59.         };
    60.  
    61.  
    62.     }
    63.  
    64. script>
    65. <body>
    66.  
    67.  
    68. <input type="button" value="发送异步请求" onclick="fun()">
    69. <input type="text">
    70. body>
    71. html>

    服务器端：

    1. package com.songzhishu.web.servlet;
    2.  
    3. import javax.servlet.ServletException;
    4. import javax.servlet.annotation.WebServlet;
    5. import javax.servlet.http.HttpServlet;
    6. import javax.servlet.http.HttpServletRequest;
    7. import javax.servlet.http.HttpServletResponse;
    8. import java.io.IOException;
    9.  
    10. /**
    11.  * @BelongsProject: web_tomcat
    12.  * @BelongsPackage: com.songzhishu.web.servlet
    13.  * @Author: 斗痘侠
    14.  * @CreateTime: 2023-09-29  10:06
    15.  * @Description: 异步请求
    16.  * @Version: 1.0
    17.  */
    18. @WebServlet("/AjaxServletDemo1")
    19. public class AjaxServletDemo1 extends HttpServlet {
    20.     @Override
    21.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    22.         this.doPost(req, resp);
    23.     }
    24.  
    25.     @Override
    26.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    27.         req.setCharacterEncoding("utf-8");
    28.         resp.setContentType("text/html;charset=utf-8");
    29.         //获取请求参数
    30.         String username = req.getParameter("username");
    31.  
    32.  
    33.         //业务处理
    34.         /*
    35.         * 如果是同步的话,那么这个个时候服务器在正在进行业务处理,那么客户端只能得等待,不能做其他的操作,但是如果是异步请求的话,此时客户端可以
    36.         * 进行其他的操作*/
    37.         //让当前线程睡6秒
    38.         try {
    39.             Thread.sleep(6000);
    40.         } catch (InterruptedException e) {
    41.             e.printStackTrace();
    42.         }
    43.         //打印
    44.         System.out.println(username);
    45.  
    46.         //响硬
    47.         resp.getWriter().write("你好"+username);
    48.     }
    49. }
    50.

            这这种方式比骄傲繁琐，细节参考w3school 在线教程

    2、基于jQuery的方式；

            

    1. html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>基于jstitle>
    6. head>
    7. <script src="../js/jquery-3.3.1.min.js">script>
    8. <script>
    9.     function fun() {
    10.         //使用$.ajax的方式发送异步请求
    11.         /*$.ajax({
    12.             /!*
    13.             * url  请求的url
    14.             * type 请求的方式
    15.             * data 携带的参数
    16.             *      "username=张三&age=23"  ----方式一
    17.             *      {
    18.             *       "username":"zhngsan",
    19.             *       "age":23
    20.             *       };                    ----方式二  以json的方式发送请求数据
    21.             * success   回调函数  响应成功后会执行这个这个函数
    22.             * error     回调函数  响应错误会执行这个函数
    23.             *
    24.             * datatype   响应数据的格式  Xml html txt Josn
    25.             * *!/
    26.             url:"/web_tomcat/AjaxServletDemo1",
    27.             type:"POST",
    28.             data:{
    29.                       "username":"张三",
    30.                       "age":23
    31.                 },
    32.             success:function (data) {
    33.                 alert(data)
    34.             },
    35.             error:function () {
    36.               alert("出错啦")
    37.             }
    38.         });*/
    39.  
    40.         //使用$.get() 发送请求
    41.         /*
    42.         * $.get(URL,callback);
    43.         *
    44.         * */
    45.         /*$.get("/web_tomcat/AjaxServletDemo1", {
    46.                 "username": "张三",
    47.                 "age": 23
    48.             }, function (data) {
    49.                 alert(data);
    50.             },"text"
    51.         );*/
    52.  
    53.         //使用$.psot()
    54.         $.post("/web_tomcat/AjaxServletDemo1", {
    55.                 "username": "张三",
    56.                 "age": 23
    57.             }, function (data) {
    58.                 alert(data);
    59.             },"text"
    60.         );
    61.  
    62.     }
    63.  
    64. script>
    65. <body>
    66.  
    67.  
    68. <input type="button" value="发送异步请求" onclick="fun()">
    69. <input type="text">
    70. body>
    71. html>

    3、JSON：

            JSON 是一种轻量级的数据交换格式，通常用于在不同应用程序之间传输数据。以下是关于 JSON 的重要信息：

    1. 数据格式：JSON 是一种文本格式，它使用易于理解的键值对（key-value pairs）来表示数据。每个键（key）都是一个字符串，每个值（value）可以是字符串、数字、布尔值、数组、对象、null等数据类型。

    2. 易于阅读和编写：JSON 的语法非常简单和直观，使人们可以轻松地阅读和编写。这也有助于人们快速理解数据结构。

    3. 数据结构：JSON 支持复杂的数据结构，包括嵌套对象和数组。这使得它非常适合表示各种类型的数据，从简单的配置文件到复杂的数据集。

    4. 跨平台和语言：JSON 不限于特定的编程语言或平台，几乎所有现代编程语言都有 JSON 的解析和生成库。这意味着可以在不同的应用程序之间轻松交换数据，而无需考虑它们使用的编程语言。

    5. 示例：以下是一个 JSON 示例，表示一个简单的人员信息：

      1. {
      2.   "name": "John Doe",
      3.   "age": 30,
      4.   "isStudent": false,
      5.   "hobbies": ["reading", "swimming"],
      6.   "address": {
      7.     "street": "123 Main St",
      8.     "city": "Anytown"
      9.   }
      10. }

    6. 用途：JSON 在Web开发中广泛应用，特别是在Web API中用于数据传输。它还用于配置文件、日志文件、NoSQL数据库等各种情况。

    7. 与XML的比较：JSON与XML是两种常见的数据交换格式。与XML相比，JSON更轻量、更易于处理，并且更适合在JavaScript中使用，因为它直接映射到JavaScript对象。

            总之，JSON是一种通用的数据格式，它在现代应用程序中起着重要作用，简化了数据交换和处理的过程。它的简洁性和易读性使其成为许多应用程序和Web服务的首选数据表示方式。

            1、基本规则：

          （1）  数据在名称/值对中：json数据是由键值对构成的
          （2） 键用引号(单双都行)引起来，也可以不使用引号
          （3）  值得取值类型：
                    1. 数字                           （整数或浮点数）
                    2. 字符串                       （在双引号中）
                    3. 逻辑值                       （true 或 false）
                    4. 数组（在方括号中）     {"persons":[{},{}]}
                    5. 对象（在花括号中）     {"address":{"province"："陕西"....}}
                    6. null
          （4） 数据由逗号分隔：     多个键值对由逗号分隔
          （5）花括号保存对象：      使用{}定义json 格式
          （6）方括号保存数组：      []

    1. html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>JSONtitle>
    6. head>
    7. <script>
    8.     //定义基本格式
    9.     var person = {
    10.         "name": "张三", age: 23, 'gender': true
    11.     }
    12.     //alert(person);
    13.  
    14.     //获取值
    15.     //alert(person.name);
    16.     //alert(person["age"]);
    17.  
    18.  
    19.     //嵌套方式  []---->{}
    20.     var persons = [{"name": "张三", "age": 23, "gender": true},
    21.         {"name": "李四", "age": 24, "gender": true},
    22.         {"name": "王五", "age": 25, "gender": false}];
    23.     //alert(persons);
    24.     //alert(persons[1].name)
    25.  
    26.     //嵌套方式  {}---->[]
    27.     var personss = {
    28.         "person": [
    29.             {"name": "张三", "age": 23, "gender": true},
    30.             {"name": "李四", "age": 24, "gender": true},
    31.             {"name": "王五", "age": 25, "gender": false}
    32.         ]
    33.     }
    34.     //alert(personss)
    35.  
    36.     //获取值
    37.     //alert(personss.person[2].name)
    38.  
    39.  
    40.     //因为定义的方式不同所以获取值的方式也不太一样
    41.  
    42.  
    43.     //遍历
    44.  
    45.     //获取person对象的所有的数据
    46.     for (let personKey in person) {
    47.         alert(personKey + "=" + person[personKey])//键值
    48.     }
    49.     alert("结束")
    50.  
    51.     //获取persons的所有值
    52.     for (let i = 0; i < persons.length; i++) {
    53.         let person = persons[i];
    54.         for (let personKey in person) {
    55.             alert(personKey + "*" +person[personKey]);
    56.         }
    57.     }
    58.  
    59.     //获取personss的所有值
    60.     let personk = personss.person;  //数组
    61.     for (let i = 0; i < personk.length; i++){
    62.         let personkElement = personk[i];
    63.         for (let personkElementKey in personkElement) {
    64.             alert(personkElementKey +"-"+personkElement[personkElementKey])
    65.  
    66.         }
    67.     }
    68.  
    69.  
    70. script>
    71. <body>
    72.  
    73. body>
    74. html>

    2、JSON和Java对象的相互转换：

            

    1、JSON解析器：        

            JSON解析器是一种程序或库，用于将JSON（JavaScript Object Notation）格式的数据解析为程序可以使用的数据结构。这个过程通常涉及将JSON文本转换为相应的数据对象，以便在程序中进行操作、处理和使用。在许多编程语言中，都有内置的JSON解析器或者第三方库，使得开发人员能够轻松地将JSON数据转换为其所在语言支持的数据类型

            java中常见的解析器有Jsonlib，Gson，fastjson，jackson，其中Jackson是一个流行的JSON处理库，它提供了高性能的JSON解析和生成功能。它支持JSON与Java对象之间的双向映射。也是spring boot 框架的内置解析器。
        2. Java对象转换JSON
            1. 使用步骤：
                1. 导入jackson的相关jar包
                2. 创建Jackson核心对象 ObjectMapper
                3. 调用ObjectMapper的相关方法进行转换
           

    1. package com.songzhishu.web.test;
    2.  
    3. import com.fasterxml.jackson.databind.ObjectMapper;
    4. import com.songzhishu.web.domain.Person;
    5. import org.junit.Test;
    6.  
    7. import java.io.FileWriter;
    8. import java.io.IOException;
    9.  
    10. /**
    11.  * @BelongsProject: web_tomcat
    12.  * @BelongsPackage: com.songzhishu.web.test
    13.  * @Author: 斗痘侠
    14.  * @CreateTime: 2023-09-29  14:53
    15.  * @Description: 测试转换
    16.  * @Version: 1.0
    17.  */
    18. public class JacksonTest1 {
    19.     //java对象转换成Json
    20.     @Test
    21.     public void test1() throws IOException {
    22.         //创建对象
    23.         Person person = new Person("张三",23,"女");
    24.  
    25.         //创建Jsackson的核心对象 objectMapper
    26.         ObjectMapper mapper = new ObjectMapper();
    27.  
    28.         //转换
    29.         /*      转换的方法:
    30.         *               writerValue(参数1,obj)
    31.         *                   这个方法有很多的重载的方式 通过传递不同的参数
    32.         *                   file  将obj对象转换成为Json字符串并且将Json字符串数据填充到字符流的文件中
    33.         *                   writer 将obj对象转换成为Json字符串并且将Json字符串数据填充到字符输出流中
    34.         *                   outputstream 将obj对象转换成Json字符串,并且将Json数据填充到字节输出流中
    35.         *               writerValueString(obj) 将对象转换成Json字符串
    36.         * */
    37.         String s = mapper.writeValueAsString(person);
    38.         //System.out.println(s);
    39.  
    40.         //将数据写入到d盘
    41.         //mapper.writeValue(new File("d://a.txt"),person);
    42.         
    43.         //将数据关联到writer中
    44.         mapper.writeValue(new FileWriter("d://b.txt"),person);
    45.  
    46.     }
    47. }
    48.
    2. 注解：

                        1. @JsonIgnore：排除属性。
                        2. @JsonFormat：属性值得格式化
                            * @JsonFormat(pattern = "yyyy-MM-dd")

                    3. 复杂java对象转换
                        1. List：数组
                        2. Map：对象格式一致

    1. package com.songzhishu.web.test;
    2.  
    3. import com.fasterxml.jackson.core.JsonProcessingException;
    4. import com.fasterxml.jackson.databind.ObjectMapper;
    5. import com.songzhishu.web.domain.Person;
    6. import org.junit.Test;
    7.  
    8. import java.io.FileWriter;
    9. import java.io.IOException;
    10. import java.util.ArrayList;
    11. import java.util.Collections;
    12. import java.util.Date;
    13. import java.util.HashMap;
    14.  
    15. /**
    16.  * @BelongsProject: web_tomcat
    17.  * @BelongsPackage: com.songzhishu.web.test
    18.  * @Author: 斗痘侠
    19.  * @CreateTime: 2023-09-29  14:53
    20.  * @Description: 测试转换
    21.  * @Version: 1.0
    22.  */
    23. public class JacksonTest1 {
    24.     //java对象转换成Json
    25.     @Test
    26.     public void test1() throws IOException {
    27.         //创建对象
    28.         Person person = new Person("张三", 23, "女", new Date());
    29.  
    30.         //创建Jsackson的核心对象 objectMapper
    31.         ObjectMapper mapper = new ObjectMapper();
    32.  
    33.         //转换
    34.         /*      转换的方法:
    35.          *               writerValue(参数1,obj)
    36.          *                   这个方法有很多的重载的方式 通过传递不同的参数
    37.          *                   file  将obj对象转换成为Json字符串并且将Json字符串数据填充到字符流的文件中
    38.          *                   writer 将obj对象转换成为Json字符串并且将Json字符串数据填充到字符输出流中
    39.          *                   outputstream 将obj对象转换成Json字符串,并且将Json数据填充到字节输出流中
    40.          *               writerValueString(obj) 将对象转换成Json字符串
    41.          * */
    42.         String s = mapper.writeValueAsString(person);
    43.         //System.out.println(s);
    44.  
    45.         //将数据写入到d盘
    46.         //mapper.writeValue(new File("d://a.txt"),person);
    47.  
    48.         //将数据关联到writer中
    49.         mapper.writeValue(new FileWriter("d://b.txt"), person);
    50.  
    51.     }
    52.  
    53.  
    54.     @Test
    55.     public void test2() throws JsonProcessingException {
    56.         Person person = new Person("张三", 23, "女", new Date());
    57.  
    58.         //转换
    59.         ObjectMapper mapper = new ObjectMapper();
    60.         String s = mapper.writeValueAsString(person);
    61.         System.out.println(s);
    62.  
    63.         /*
    64.         直接输出的样式{"name":"张三","age":23,"gender":"女","brithday":1695973073829} 日期有点太难看了 咋办
    66.         要么我就不转换日期  要么我改变输出的格式
    68.         第一种在生日的属性上 加上一个注解     @JsonIgnore  //忽略该字端
    69.         输出 {"name":"张三","age":23,"gender":"女"}
    71.         但是这种注解的方式不太友好，就是不能因为不好看就不要这数据吧
    73.         第二种 格式转换  @JsonFormat(pattern = "yyyy-MM-dd")
    74.         {"name":"张三","age":23,"gender":"女","brithday":"2023-09-29"}
    76.         */
    77.     }
    78.  
    79.  
    80.     //复杂格式的转换
    81.     @Test
    82.     public void test3() throws JsonProcessingException {
    83.         Person person1 = new Person("张三", 23, "女", new Date());
    84.         Person person2 = new Person("李四", 24, "男", new Date());
    85.         Person person3 = new Person("王五", 25, "男", new Date());
    86.  
    87.         //集合
    88.         ArrayList list = new ArrayList<>();
    89.         Collections.addAll(list,person1,person2,person3);
    90.  
    91.         //创建对象
    92.         ObjectMapper mapper = new ObjectMapper();
    93.         String s = mapper.writeValueAsString(list);
    94.         System.out.println(s);
    95.  
    96.  
    97.     }
    98.  
    99.     //map集合
    100.     @Test
    101.     public void test4() throws JsonProcessingException {
    102.         //创建map
    103.         HashMap hashMap = new HashMap<>();
    104.         hashMap.put("name","李四");
    105.         hashMap.put("age",24);
    106.         hashMap.put("gender","女");
    107.  
    108.         //创建对象
    109.         ObjectMapper mapper = new ObjectMapper();
    110.         String s = mapper.writeValueAsString(hashMap);
    111.         System.out.println(s);
    112.  
    113.     }
    114.  
    115. }
    116.
    3、 JSON转为Java对象


            1. 导入jackson的相关jar包
            2. 创建Jackson核心对象 ObjectMapper
            3. 调用ObjectMapper的相关方法进行转换
                1. readValue(json字符串数据,Class)

    1.  
    2.     //json字符串转换成java对象
    3.     @Test
    4.     public  void  test5() throws IOException {
    5.         //初始化json字符串
    6.  
    7.         String Json="{\"gender\":\"女\",\"name\":\"李四\",\"age\":24}";
    8.  
    9.         //创建对象
    10.         ObjectMapper mapper = new ObjectMapper();
    11.         Person person = mapper.readValue(Json, Person.class);
    12.         System.out.println(person);
    13.     }
    14. }

  • 相关阅读:
    【毕业设计】机器视觉火车票识别系统 - python 深度学习
    网络安全等级保护2.0详解
    ali内核服务器搭建Linux版本的小皮面板(微调)
    QT专栏2 -Qt for Android
    ninja编译方法介绍
    CISSP考试背点记录
    zookeeper + kafka集群搭建详解
    postgresSql-基础入门(待续...)
    网络之物理层
    咖啡技术培训：6款创意咖啡拿铁教程
  • 原文地址：https://blog.csdn.net/keleID/article/details/133394497