在JavaScript中，可以使用AJAX（Asynchronous JavaScript and XML）来发送请求到API并局部刷新页面内容。以下是一个简单的例子，展示了如何使用原生JavaScript发送GET请求到API，并更新页面上的一个元素内容。

HTML部分：

<div id="content">原始内容</div>
<button id="refreshButton">刷新内容</button>

JavaScript部分：

document.getElementById('refreshButton').addEventListener('click', function() {
  var xhr = new XMLHttpRequest();
  xhr.open('GET', 'https://api.example.com/data', true);
  xhr.onreadystatechange = function() {
    if (xhr.readyState == 4 && xhr.status == 200) {
      var response = JSON.parse(xhr.responseText);
      document.getElementById('content').innerHTML = response.data; // 假设返回的JSON中包含data字段
    }
  };
  xhr.send();
});

在这个例子中，当用户点击按钮时，会发送一个GET请求到指定的API地址。当请求完成并且响应状态为200（即请求成功）时，我们会解析返回的JSON数据，并将其中的data字段的内容设置到页面上ID为content的元素的innerHTML中，从而实现局部刷新。

由于篇幅限制，以下仅展示如何使用Servlet处理Ajax请求的核心函数。

@WebServlet("/shoppingCart")
public class ShoppingCartServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 获取请求参数
        String action = request.getParameter("action");
 
        // 根据不同的action执行不同的逻辑
        if ("addToCart".equals(action)) {
            addToCart(request, response);
        } else if ("removeFromCart".equals(action)) {
            removeFromCart(request, response);
        } else if ("updateCart".equals(action)) {
            updateCart(request, response);
        } else if ("getCart".equals(action)) {
            getCart(request, response);
        }
    }
 
    private void addToCart(HttpServletRequest request, HttpServletResponse response) throws IOException {
        // 添加商品到购物车的逻辑
    }
 
    private void removeFromCart(HttpServletRequest request, HttpServletResponse response) throws IOException {
        // 从购物车移除商品的逻辑
    }
 
    private void updateCart(HttpServletRequest request, HttpServletResponse response) throws IOException {
        // 更新购物车商品数量的逻辑
    }
 
    private void getCart(HttpServletRequest request, HttpServletResponse response) throws IOException {
        // 获取购物车商品列表的逻辑
    }
}

这个Servlet处理了四种不同的操作：添加商品到购物车、从购物车移除商品、更新购物车商品数量、获取购物车商品列表。每个操作都有其对应的处理函数，这些函数负责执行数据库操作、更新用户会话状态等。这个例子展示了如何使用Servlet作为Ajax请求的处理中心，并且如何根据请求参数执行不同的逻辑。

在JavaWeb中，可以使用Ajax、axios和JSON来进行异步请求处理。以下是使用这些技术的示例代码：

1. 使用Ajax发送异步请求：

前端JavaScript代码：

$.ajax({
    url: '/your-endpoint', // 服务器端点
    type: 'POST', // 请求类型，根据需要可以是 'GET' 或 'POST'
    contentType: 'application/json', // 发送信息至服务器时内容编码类型
    data: JSON.stringify({ key: 'value' }), // 将对象转换为JSON字符串
    dataType: 'json', // 预期服务器返回的数据类型
    success: function(response) {
        // 请求成功时的回调函数
        console.log(response);
    },
    error: function(xhr, status, error) {
        // 请求失败时的回调函数
        console.log(xhr.responseText);
    }
});

2. 使用axios发送异步请求：

前端JavaScript代码：

axios.post('/your-endpoint', { key: 'value' })
     .then(function (response) {
         // 请求成功时的回调函数
         console.log(response.data);
     })
     .catch(function (error) {
         // 请求失败时的回调函数
         console.log(error);
     });

3. 使用JSON处理数据：

前端JavaScript代码：

// 解析JSON字符串
var jsonString = '{"key": "value"}';
var jsonObj = JSON.parse(jsonString);
 
// 将JSON对象转换为字符串
var jsonObj = { key: 'value' };
var jsonString = JSON.stringify(jsonObj);

在实际应用中，你需要确保服务器端的端点（URL）是可访问的，并且服务器端的代码（如Java Servlet）已经配置好以接收和处理这些异步请求。

Ajax、axios 和 JSONP 都是常用的浏览器端技术，用于实现异步数据交换，但它们有不同的应用场景和实现方式。

1. Ajax (XMLHttpRequest)：Ajax 是一种浏览器技术，允许在不刷新页面的情况下更新网页的部分内容。使用原生的 XMLHttpRequest 对象进行跨域请求时，需要服务器支持 CORS (Cross-Origin Resource Sharing)。
2. axios：axios 是一个基于 Promise 的 HTTP 客户端，用于浏览器和 node.js 环境。它支持跨域请求，通过在请求头中设置跨域资源共享的相关字段，或者使用代理服务器来绕过同源策略。
3. JSONP：JSONP 主要用于解决跨域请求数据的问题。它通过动态创建 <script> 标签，并在其 src 属性中传递一个 callback 函数名来请求数据。服务器端需要支持这种请求方式。

以下是使用 axios 进行跨域请求的示例代码：

// 引入 axios
import axios from 'axios';
 
// 发送 GET 请求
axios.get('https://api.example.com/data', {
  params: {
    // 查询参数
  }
})
.then(response => {
  // 处理响应数据
  console.log(response.data);
})
.catch(error => {
  // 处理错误情况
  console.error(error);
});
 
// 发送 POST 请求
axios.post('https://api.example.com/data', {
  // 请求体数据
})
.then(response => {
  // 处理响应数据
  console.log(response.data);
})
.catch(error => {
  // 处理错误情况
  console.error(error);
});

服务器端也需要设置适当的 CORS 头部，例如 Access-Control-Allow-Origin，来允许跨域请求。

如果服务器不支持 CORS，可以考虑使用 JSONP，但请注意，axios 不原生支持 JSONP，可能需要第三方库或者自定义实现。

// 导入axios，这是一个基于promise的HTTP客户端，用于发送请求
import axios from 'axios';
 
// 轮询的配置对象
const pollConfig = {
  requests: [], // 请求数组，包含请求的url和方法
  interval: 5000, // 轮询间隔，单位毫秒
  stopCondition: () => false, // 停止轮询的条件，返回true时停止
};
 
// 轮询发送请求的函数
function pollRequests(config) {
  const { requests, interval, stopCondition } = config;
  let intervalId;
 
  // 执行请求并处理响应的函数
  function makeRequest(request) {
    axios(request).then(response => {
      console.log('请求成功:', response);
      // 根据响应处理逻辑
      // ...
 
      // 如果没有满足停止条件，继续轮询
      if (!stopCondition()) {
        intervalId = setTimeout(makeRequest, interval, request);
      } else {
        clearTimeout(intervalId);
        console.log('停止轮询');
      }
    }).catch(error => {
      console.error('请求失败:', error);
      // 错误处理逻辑
      // ...
 
      // 如果没有满足停止条件，继续轮询
      if (!stopCondition()) {
        intervalId = setTimeout(makeRequest, interval, request);
      } else {
        clearTimeout(intervalId);
        console.log('停止轮询');
      }
    });
  }
 
  // 开始轮询
  requests.forEach(request => {
    makeRequest(request);
  });
}
 
// 使用示例
pollRequests(pollConfig);

这段代码定义了一个名为pollRequests的函数，它接收一个配置对象作为参数，该对象包含轮询的请求数组、间隔时间以及停止轮询的条件。函数内部使用setTimeout进行轮询，并通过axios发送HTTP请求。如果响应成功，它会根据响应执行相关逻辑；如果发生错误，它会执行错误处理逻辑。如果满足停止轮询的条件，它会清除定时器并输出相应的日志信息。这个例子展示了如何使用JavaScript编写一个简单的轮询请求发送工具。

在JavaScript中，可以使用AbortController来取消一个fetch请求。以下是一个示例代码：

const controller = new AbortController();
const signal = controller.signal;
 
fetch('https://example.com/data', { signal })
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.log('Fetch error:', error));
 
// 在需要取消请求的时候
controller.abort();

在上面的代码中，我们首先创建了一个AbortController实例，然后通过调用其signal属性获得了一个AbortSignal对象，该对象可以传递给fetch请求。我们在fetch调用中使用了这个signal属性。

当我们希望取消请求时，我们调用controller.abort()方法，这将会触发一个"abort"事件在控制器的AbortSignal上，进而导致所有监听这个信号的Promise都会被拒绝，并且抛出一个DOMException异常，错误名为AbortError。

使用原生JavaScript实现Ajax的基本步骤如下：

1. 创建一个新的XMLHttpRequest对象。
2. 设置请求的方法（如GET或POST）和URL。
3. 绑定状态变化的事件监听器。
4. 发送请求。
5. 在事件监听器中处理服务器响应。

以下是一个简单的GET请求示例：

var xhr = new XMLHttpRequest();
xhr.open("GET", "your-api-endpoint", true);
 
xhr.onreadystatechange = function () {
  if (xhr.readyState === 4 && xhr.status === 200) {
    // 请求成功
    var response = xhr.responseText;
    // 处理response
    console.log(response);
  }
};
 
xhr.send();

对于POST请求，需要设置请求头以及发送数据：

var xhr = new XMLHttpRequest();
xhr.open("POST", "your-api-endpoint", true);
 
// 设置请求头
xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
 
xhr.onreadystatechange = function () {
  if (xhr.readyState === 4 && xhr.status === 200) {
    // 请求成功
    var response = xhr.responseText;
    // 处理response
    console.log(response);
  }
};
 
// 发送数据
xhr.send("key1=value1&key2=value2");

以上代码实现了基本的Ajax请求，可以根据实际需求进行调整。

以下是一个简化的Java后端API接口示例，用于处理Ajax请求并与Spring Boot框架整合：

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
 
@RestController
public class TicketController {
 
    // 假设这是一个获取票务信息的接口
    @GetMapping("/getTicketInfo")
    public Map<String, Object> getTicketInfo() {
        Map<String, Object> response = new HashMap<>();
        // 添加票务信息到response
        response.put("status", "success");
        response.put("data", "票务信息");
        return response;
    }
 
    // 假设这是一个用户购买票务的接口
    @GetMapping("/buyTicket")
    public Map<String, Object> buyTicket() {
        Map<String, Object> response = new HashMap<>();
        // 处理购票逻辑
        boolean isSuccess = true; // 假设这里是购票成功的逻辑
        response.put("status", isSuccess ? "success" : "fail");
        response.put("message", isSuccess ? "购票成功" : "购票失败");
        return response;
    }
}

这个示例展示了如何使用Spring Boot的@RestController注解来创建一个简单的API接口，并且使用@GetMapping注解来映射HTTP GET请求到特定的处理方法。在实际应用中，你可能需要处理POST请求以及与数据库的交互，以确保票务信息的正确性和安全性。

在原生JavaScript中，可以通过创建一个XMLHttpRequest对象来发送Ajax请求。以下是一个简单的Ajax请求函数的例子：

function makeAjaxRequest(method, url, data, callback) {
  var xhr = new XMLHttpRequest();
  xhr.open(method, url, true);
 
  if (method === 'POST') {
    xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
  }
 
  xhr.onreadystatechange = function () {
    if (xhr.readyState === 4 && xhr.status === 200) {
      callback(xhr.responseText);
    }
  };
 
  xhr.send(data);
}
 
// 使用方法:
makeAjaxRequest('GET', 'https://api.example.com/data', null, function(response) {
  console.log('Response:', response);
});
 
makeAjaxRequest('POST', 'https://api.example.com/data', 'key1=value1&key2=value2', function(response) {
  console.log('Response:', response);
});

这个函数makeAjaxRequest接受四个参数：HTTP请求方法（'GET'或'POST'），请求的URL，发送的数据（对于'GET'请求为null）和一个回调函数，该回调函数在请求成功完成时被调用，并接收响应文本作为参数。

在Express中，你可以使用req.accepts(type)方法来检查请求头的Accept字段是否接受特定类型。如果请求头中包含了可接受该类型的信息，该方法会返回该类型字符串，否则返回false。

以下是一个简单的Express服务器示例，演示如何使用req.accepts(type)方法：

const express = require('express');
const app = express();
const port = 3000;
 
app.get('/', (req, res) => {
  const acceptType = req.accepts('json');
  if (acceptType) {
    res.send({ message: `客户端接受${acceptType}类型。` });
  } else {
    res.status(406).send('客户端不接受提供的内容类型。');
  }
});
 
app.listen(port, () => {
  console.log(`服务器运行在 http://localhost:${port}`);
});

在这个例子中，当客户端请求根路径时，服务器会检查请求头中的Accept字段是否接受json类型。如果接受，则返回一个JSON响应；如果不接受，则返回406状态码。