import requests
import pymongo
from urllib.parse import urlencode
import json
 
# 设置MongoDB的连接
client = pymongo.MongoClient('mongodb://localhost:27017/')
db = client['jobbole']
 
# 设置ajax请求头信息
headers = {
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36',
    'X-Requested-With': 'XMLHttpRequest',
}
 
def get_ajax_data(url, params):
    # 发送ajax请求获取数据
    response = requests.get(url, headers=headers, params=params)
    return response.json()
 
def save_to_mongodb(data_list):
    # 将数据保存到MongoDB
    for data in data_list:
        title = data.get('title')
        job_id = data.get('jobid')
        salary = data.get('salary')
        city = data.get('cityname')
        experience = data.get('experience')
        education = data.get('education')
        company_name = data.get('companyname')
        db.jobs.update_one({'job_id': job_id}, {'$set': {
            'title': title,
            'salary': salary,
            'city': city,
            'experience': experience,
            'education': education,
            'company_name': company_name
        }}, upsert=True)
 
def main():
    # 设置ajax请求参数
    base_url = 'https://www.jobbole.com/zhaopin/p'
    page = 1
    fetch_num = 10
    query = {
        'city': '北京',
        'experience': '3-5年',
        'job_label': 'Python',
        'page': page,
        'kd': 'python'
    }
    query_str = urlencode(query)
    url = base_url + '?' + query_str
 
    # 获取ajax数据并保存到MongoDB
    data = get_ajax_data(url, query)
    total_page = data['totalPage']
    save_to_mongodb(data['data'])
 
    # 循环获取其他页面的数据
    for page in range(2, total_page+1):
        query['page'] = page
        query_str = urlencode(query)
        url = base_url + '?' + query_str
        data = get_ajax_data(url, query)
        save_to_mongodb(data['data'])
 
if __name__ == '__main__':
    main()

这段代码实现了与原代码相同的功能，但是修正了一些问题，并且使用了更现代的Python库和方法。代码首先设置了MongoDB的连接，然后定义了请求头和请求参数。get_ajax_data函数负责发起AJAX请求并获取JSON格式的响应数据。save_to_mongodb函数负责将获取到的数据保存到MongoDB中。最后，main函数组织了主要的逻辑流程，包括计算总页数、循环获取每一页的数据，并将其保存。

报错解释：

"Uncaught TypeError: Illegal invocation" 错误通常发生在使用 jQuery.ajax 方法时，尝试使用不符合预期的方式提交数据。这个错误表明调用 jQuery.ajax 时传递的数据对象格式不正确，或者可能是 contentType 的设置问题。

解决方法：

1. 确保传递给 data 选项的数据是一个字符串、一个数组或者一个对象。如果你正在传递一个 FormData 对象，确保没有设置 contentType 为 application/x-www-form-urlencoded 或 application/json，因为 FormData 对象已经定义了它自己的 Content-Type。
2. 如果你设置了 contentType 为 application/json，并且你尝试发送的数据不是一个字符串，那么你需要先将数据转换为 JSON 字符串。

示例代码：

$.ajax({
    url: 'your-endpoint',
    type: 'POST',
    data: yourData, // 确保这里的数据是有效的
    contentType: 'application/json', // 如果你需要发送 JSON 数据
    success: function(response) {
        // 处理响应
    },
    error: function(xhr, status, error) {
        // 处理错误
    }
});
 
// 如果你发送的是 JSON 数据
var yourData = { key: 'value' };
yourData = JSON.stringify(yourData); // 将对象转换为 JSON 字符串

确保 data 是有效的，如果 contentType 被设置为 application/json，那么 data 应该是一个 JSON 字符串。如果你正在使用 FormData 对象，则不需要设置 contentType 因为 FormData 自己处理了 Content-Type。

在前端开发中，AJAX技术被广泛使用以便于在不刷新页面的前提下与服务器进行数据交换。以下是几种使用AJAX的方法：

1. 原生JavaScript中的AJAX

var xhr = new XMLHttpRequest();
xhr.open("POST", "url", true);
xhr.setRequestHeader("Content-Type", "application/json");
xhr.onreadystatechange = function () {
  if (xhr.readyState === 4 && xhr.status === 200) {
    console.log(JSON.parse(xhr.responseText));
  }
};
xhr.send(JSON.stringify({ key: "value" }));

2. 使用jQuery中的$.ajax

$.ajax({
  url: "url",
  type: "POST",
  contentType: "application/json",
  data: JSON.stringify({ key: "value" }),
  dataType: "json",
  success: function (response) {
    console.log(response);
  },
});

3. 使用axios库发送AJAX请求

axios({
  method: 'post',
  url: 'url',
  data: {
    key: 'value'
  },
})
.then(function (response) {
  console.log(response);
});

以上代码展示了如何在前端使用AJAX技术与服务器进行数据交换。原生JavaScript和jQuery中的AJAX请求相对复杂，而axios则提供了一种更现代、更简洁的方式来发送HTTP请求。在实际开发中，可以根据项目需求和团队习惯选择合适的方法。

Ajax（Asynchronous JavaScript and XML）是一种创建交互式网页的技术，可以在不重新加载整个网页的情况下，与服务器交换数据。

基础介绍

Ajax 主要通过 JavaScript 的 XMLHttpRequest 对象实现。

使用Ajax

1. 创建 XMLHttpRequest 对象。
2. 配置请求（例如：HTTP方法，URL，是否异步）。
3. 设置请求状态变化的回调函数。
4. 发送请求。
5. 在回调函数中处理服务器响应。

示例代码

以下是一个使用Ajax的简单示例：

// 创建XMLHttpRequest对象
var xhr = new XMLHttpRequest();
 
// 配置请求
xhr.open('GET', 'your-api-endpoint', true);
 
// 设置回调函数
xhr.onreadystatechange = function() {
  // 请求完成并且响应状态为200
  if (xhr.readyState === 4 && xhr.status === 200) {
    // 处理服务器响应
    var response = JSON.parse(xhr.responseText);
    console.log(response);
  }
};
 
// 发送请求
xhr.send();

场景回放

假设你正在编写一个网页，用户可以输入他们的邮件地址来订阅新闻。你不希望页面重新加载，因此可以使用Ajax来异步发送用户的邮件地址到服务器。

// 获取输入元素
var emailInput = document.getElementById('email-input');
 
// 添加事件监听器
emailInput.addEventListener('blur', function() {
  var email = emailInput.value;
 
  // 创建XMLHttpRequest对象
  var xhr = new XMLHttpRequest();
 
  // 配置请求
  xhr.open('POST', '/subscribe', true);
  xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
 
  // 设置回调函数
  xhr.onreadystatechange = function() {
    if (xhr.readyState === 4 && xhr.status === 200) {
      console.log('Successfully subscribed!');
    } else {
      console.log('Subscription failed.');
    }
  };
 
  // 发送请求
  xhr.send('email=' + encodeURIComponent(email));
});

在这个例子中，当用户离开邮件输入字段时，会触发一个事件，然后使用Ajax异步发送邮件地址到服务器的 /subscribe 端点。服务器端需要相应地处理请求并完成订阅操作。

由于问题描述中提到的是一个完整的系统，我们无法提供一个完整的代码解决方案。但是，我可以提供一个简化的示例，展示如何使用Spring Boot创建一个简单的RESTful API，用于查询旅游景点。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class AttractionController {
 
    // 假设有一个简单的数据模型
    private static final Map<String, String> attractions = new HashMap<>();
 
    static {
        attractions.put("1", "大堡Temple of Artemis");
        attractions.put("2", "罗马Pantheon");
        attractions.put("3", "京都金阁寺Kyoto Tower");
    }
 
    // 一个简单的API端点，用于根据ID查询旅游景点
    @GetMapping("/attractions")
    public String getAttractionById(@RequestParam("id") String id) {
        return attractions.getOrDefault(id, "未找到旅游景点");
    }
}

这个简单的Spring Boot控制器定义了一个RESTful API，可以根据提供的ID查询一个静态数据库中的旅游景点。在实际系统中，你会需要一个数据库层和服务层来处理数据的持久化和复杂的业务逻辑。

请注意，这个代码示例没有详细的异常处理、安全性考虑（如认证和授权）、日志记录或其他生产级别的功能。它仅用于展示如何创建一个简单的RESTful API。

Ajax 的全称是 Asynchronous JavaScript and XML（异步的 JavaScript 和 XML），它是一种创建交互式网页的技术。Ajax 可以让你在不重新加载网页的情况下更新网页的部分内容。

在这个问题中，我们将使用 XMLHttpRequest 对象和 Promise 来创建一个简单的 Ajax 请求，并将其封装到一个 axios 插件库中。

1. 使用 XMLHttpRequest + Promise 创建一个简单的 Ajax 请求：

function ajax(url, method = 'GET', data = null) {
  const promise = new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();
    xhr.open(method, url);
    xhr.onload = () => {
      if (xhr.status === 200) {
        resolve(xhr.responseText);
      } else {
        reject(new Error(xhr.statusText));
      }
    };
    xhr.onerror = () => reject(new Error("Network Error"));
    if (method === 'POST') {
      xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
    }
    xhr.send(data);
  });
  return promise;
}
 
// 使用示例
ajax('https://api.example.com/data', 'GET').then(response => {
  console.log(response);
}).catch(error => {
  console.error(error);
});

2. 封装上述的 Ajax 请求到一个 axios 插件库中：

// 封装 axios 插件
const axios = {
  get: function(url) {
    return ajax(url, 'GET');
  },
  post: function(url, data) {
    return ajax(url, 'POST', data);
  }
};
 
// 使用示例
axios.get('https://api.example.com/data').then(response => {
  console.log(response);
}).catch(error => {
  console.error(error);
});
 
axios.post('https://api.example.com/data', 'key1=value1&key2=value2').then(response => {
  console.log(response);
}).catch(error => {
  console.error(error);
});

在这个示例中，我们创建了一个简单的 axios 对象，它有 get 和 post 方法用来发送 HTTP 请求。这个示例只是为了说明如何封装一个简单的 Ajax 请求库，实际的 axios 库要复杂得多。

由于您的问题涉及到一个完整的项目，我将提供一个简化的解决方案，包括Spring Boot项目的基本结构和配置，以及一个简单的MyBatis Mapper接口示例。

1. 创建Spring Boot项目：

// pom.xml 依赖
<dependencies>
    <!-- Spring Boot Web Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
 
    <!-- MyBatis Framework -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.3</version>
    </dependency>
 
    <!-- Database Driver -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.19</version>
    </dependency>
</dependencies>

2. 配置application.properties:

spring.datasource.url=jdbc:mysql://localhost:3306/hrm?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
 
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.yourpackage.model

3. 创建一个简单的MyBatis Mapper接口:

// UserMapper.java
package com.yourpackage.mapper;
 
import com.yourpackage.model.User;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;
 
@Repository
public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    User getUserById(int id);
}

4. 创建一个Service层来使用Mapper:

// UserService.java
package com.yourpackage.service;
 
import com.yourpackage.mapper.UserMapper;
import com.yourpackage.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
 
    public User getUserById(int id) {
        return userMapper.getUserById(id);
    }
}

5. 创建一个Con

// 创建XMLHttpRequest对象
var xhr = new XMLHttpRequest();
 
// 准备要发送的数据
var urlEncodedData = '';
var urlEncodedDataPairs = [];
var name = encodeURIComponent('Your Name');
var age = encodeURIComponent('100');
urlEncodedDataPairs.push('name=' + name);
urlEncodedDataPairs.push('age=' + age);
urlEncodedData = urlEncodedDataPairs.join('&').replace(/%20/g, '+');
 
// 配置请求
xhr.open('POST', 'https://example.com/api/data');
 
// 设置请求头
xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
 
// 监听请求状态变化
xhr.onload = function() {
    if (this.status == 200) {
        // 请求成功
        console.log(this.responseText);
    } else {
        // 请求失败
        console.error(this.statusText);
    }
};
 
// 发送请求
xhr.send(urlEncodedData);

这段代码演示了如何使用原生JavaScript创建一个AJAX POST请求，并发送URL编码后的数据到服务器。代码中包含了创建XMLHttpRequest对象、准备数据、设置请求、监听响应和发送请求的全过程。

在jQuery中，你可以使用$.each()函数来遍历对象或数组，并且可以在AJAX请求中使用它。以下是一个简单的例子，展示了如何在AJAX成功回调函数中使用$.each()来遍历返回的数据。

$.ajax({
    url: 'your-endpoint-url',
    type: 'GET',
    dataType: 'json',
    success: function(data) {
        // 使用$.each遍历返回的数据
        $.each(data, function(index, item) {
            console.log(index, item);
            // 在这里处理每个item
        });
    },
    error: function(xhr, status, error) {
        console.error("An error occurred: " + status + "\nError: " + error);
    }
});

在这个例子中，your-endpoint-url是你要请求的服务器端点，dataType: 'json'指定了预期的数据类型。在success回调函数中，data是从服务器接收到的数据，我们使用$.each来遍历这个数据。index是数组索引或对象的键，而item是当前遍历到的数据项。在循环体内，你可以根据需要处理每个项。如果是遍历对象属性，index将是属性名，item将是属性值。

在Spring MVC中，使用@RequestBody注解可以处理AJAX请求传递给后端的数据。AJAX请求可以发送多种数据格式，如application/json、application/x-www-form-urlencoded、multipart/form-data等。

1. application/json格式：

   发送JSON格式的数据时，通常需要将数据转换为JSON字符串，并设置请求头Content-Type为application/json。在Spring MVC中，可以直接使用@RequestBody注解将JSON字符串转换为Java对象。

2. application/x-www-form-urlencoded格式：

   这是标准的HTML表单数据格式，通常用于发送键值对数据。在Spring MVC中，可以直接使用@RequestParam注解获取这些参数。

3. multipart/form-data格式：

   这种格式常用于文件上传。Spring MVC提供了MultipartResolver接口来处理这种类型的数据。

以下是一个使用application/json格式发送AJAX请求的例子：

JavaScript (使用jQuery发送AJAX请求):

var data = {
    name: "John",
    age: 30
};
 
$.ajax({
    url: '/your-endpoint',
    type: 'POST',
    contentType: 'application/json',
    data: JSON.stringify(data),
    success: function(response) {
        // 处理响应
    }
});

Spring MVC Controller:

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.http.ResponseEntity;
 
@RestController
public class YourController {
 
    @PostMapping("/your-endpoint")
    public ResponseEntity<String> handleAjaxRequest(@RequestBody YourDataObject data) {
        // 处理接收到的数据
        return ResponseEntity.ok("Success");
    }
}
 
class YourDataObject {
    private String name;
    private int age;
 
    // 必要的getter和setter
}

在这个例子中，JavaScript 代码将数据转换为JSON字符串并发送到服务器。Spring MVC的Controller中的方法使用@RequestBody注解接收JSON数据，并将其自动转换成YourDataObject对象。