本文通过两个实战实例详细讲述 JSP+jQuery 使用 Ajax 方式调用 JSON 的实现方法，从基础的参数传递与简单 JSON 返回，到基于实体类 + Servlet的复杂对象 / 集合 JSON 数据封装与页面渲染，覆盖前后端核心代码实现与关键配置，代码可直接复用，适合 Java Web 入门开发者参考，具体的实现步骤以及完整代码如下所示：

实例一：基础版 ——JSP 后端 + Ajax 简单参数交互与 JSON 返回

该实例实现前端通过 jQuery-Ajax 传递参数到 JSP 后端，后端处理后返回 JSON 格式的结果，前端解析 JSON 并做业务逻辑处理，是最基础的 JSP+Ajax+JSON 交互实现，适合简单的前后端参数传递场景。

一、前端页面代码（jQuery+Ajax 调用）

需先引入 jQuery 核心库，通过点击事件触发 Ajax 请求，传递参数并接收后端返回的 JSON 数据：

<script type="text/javascript" src="jquery-1.5.1.min.js"></script>

<script type="text/javascript">

 //test

 function test(uid)

 {

  if(confirm("确定该用户操作"+uid+"吗？"))

  {

  var date = new Date();

  var param = {uid:uid};

  jQuery.get("test.jsp?para=" + date, param,

    function(data){

     if(data != null)

     {

    var result = data.result;

    //alert("data==="+data);

    if(result == 1)

    {

    alert("操作失败");

    }

    if(result == 0)

    {

    alert("操作失败。");

    //document.location.href = document.location;

    //window.location.reload();

    }

     }

  });

  }

 }

</script>

<a href="javascript:void(0);" onclick="test(111111111111111111);">submit</a>

前端核心知识点

1. javascript:void(0);：用于取消 a 标签的默认跳转行为，仅触发 onclick 事件，是前端触发 JS 方法的常用写法；
2. 
   
3. 防缓存处理：拼接?para=" + date通过时间戳生成唯一参数，避免浏览器对 GET 请求的缓存，防止重复请求旧数据；
4. 
   
5. jQuery.get 语法：$.get(url, data, successCallback)，依次为请求地址、传递参数（对象 / 字符串）、成功回调函数，默认发起 GET 请求；
6. 
   
7. 自动解析 JSON：jQuery 会根据后端返回的Content-Type自动将 JSON 字符串解析为 JavaScript 对象，前端可直接通过data.字段名访问，无需手动调用JSON.parse()。

二、后端 JSP 代码（接收参数 + 返回 JSON）

后端 test.jsp 接收前端传递的参数，处理后手动拼接 JSON 格式字符串返回，需重点设置响应头指定返回数据类型为 JSON，确保前端正确解析：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%><%

response.setContentType("application/x-json;charset=UTF-8");

String uid=request.getParameter("uid");

int ret=0;

String result = "{\"result\":" + ret + "}";

out.print(result);

%>

后端核心注意事项

1. JSON 响应头设置：response.setContentType("application/x-json;charset=UTF-8")是核心配置，告知前端返回的是 JSON 格式数据，同时指定 UTF-8 编码避免中文乱码，也可使用标准的application/json;charset=UTF-8，两者均被 jQuery 识别；
2. 
   
3. JSON 字符串拼接规范：必须遵循 JSON 语法，键名用双引号（Java 中需转义为\"），值为数字时可直接拼接，值为字符串时需包裹双引号（如"{\"msg\":\"操作成功\",\"result\":0}"）；
4. 
   
5. 参数接收：通过request.getParameter("参数名")接收前端 GET 方式传递的参数，与普通 JSP 请求参数接收方式一致；
6. 
   
7. 输出方式：通过out.print(result)将 JSON 字符串输出，不可使用out.println()，避免多余的换行符破坏 JSON 格式。

三、基础实例关键总结

该实例的核心是前后端数据格式的统一，前端传递键值对参数，后端手动拼接 JSON 字符串返回，重点掌握响应头设置和JSON 语法规范，是 JSP+Ajax+JSON 交互的基础，适合简单的业务状态返回（如操作成功 / 失败、数量统计等）。  

实例二：实战版 ——JSP+Servlet + 实体类封装 JSON（集合 / 嵌套对象返回）

实际开发中，业务数据往往包含复杂对象、对象集合、嵌套对象（如个人信息包含地址信息），仅手动拼接 JSON 字符串效率低且易出错，该实例通过Person、Address 实体类描述数据，在 Servlet 中借助json-lib 工具包将实体类 / 集合自动转换为 JSON 格式，前端通过 jQuery 解析复杂 JSON 数据并渲染到页面，是 Java Web 开发中最常用的 JSON 交互方式。

一、项目依赖包（必备）

使用 json-lib 工具包实现 Java 对象与 JSON 的相互转换（序列化 / 反序列化），需引入以下 5 个依赖 jar 包，缺一不可，需将 jar 包放入项目

目录下：

• json-lib-2.1-jdk15.jar（核心包，实现对象转 JSON）
• commons-lang-2.1.jar（基础工具类依赖）
• commons-logging.jar（日志依赖）
• commons-collections-3.2.jar（集合处理依赖）
• commons-beanutils.jar（实体类属性操作依赖）

同时前端需引入两个核心 JS 文件：

• jquery.js（jQuery 核心库，实现 Ajax 请求）
• json.js（JSON 辅助解析库，兼容低版本浏览器）

二、实体类编写（Person+Address）

创建两个序列化实体类，Person 包含基础属性和嵌套的 Address 对象，描述业务数据结构，实现java.io.Serializable接口保证对象可序列化，符合 Java Web 开发规范：

Address 类（地址实体，嵌套在 Person 中） 

public class Address implements java.io.Serializable{   

    private String province;   

    private String city;   

    private String country;   

    public Address() {   

    }   

    public Address(String province, String city, String country){   

        this.province =province;   

        this.city = city;   

        this.country = country;   

    }   

    public String getProvince() {   

        return province;   

    }   

    public void setProvince(String province) {   

        this.province =province;   

    }   

    public String getCity() {   

        return city;   

    }   

    public void setCity(String city) {   

        this.city = city;   

    }   

    public String getCountry() {   

        return country;   

    }   

    public void setCountry(String country) {   

        this.country = country;   

    }   

} 

Person 类（人员实体，包含 Address 嵌套对象） 

public class Person implements java.io.Serializable{   

    private String name;   

    private String sex;   

    private Integer age;   

    private Address address;   

    public String getName() {   

        return name;   

    }   

    public void setName(String name) {   

        this.name = name;   

    }   

    public String getSex() {   

        return sex;   

    }   

    public void setSex(String sex) {   

        this.sex = sex;   

    }   

    public Integer getAge() {   

        return age;   

    }   

    public void setAge(Integer age) {   

        this.age = age;   

    }   

    public Address getAddress() {   

        return address;   

    }   

    public void setAddress(Address address) {   

        this.address = address;   

    }   

} 

实体类编写关键要求

1. 必须实现java.io.Serializable接口：避免对象序列化异常，符合 Java Web 中对象传输的规范；
2. 必须提供无参构造方法：json-lib 通过反射创建对象时，默认调用无参构造，缺少会抛出反射异常；
3. 必须为所有属性提供get/set 方法：json-lib 通过getXxx()方法获取实体类属性值，通过setXxx()设置值，缺少会导致 JSON 转换时丢失对应属性。

三、Servlet 后端代码（DemoServlet：组装数据 + 对象转 JSON）

创建 DemoServlet 作为后端接口，处理前端 Ajax 请求，组装 Person 对象集合，通过 json-lib 将集合对象和嵌套对象自动转换为 JSON 格式并返回，替代手动拼接 JSON 字符串，提升开发效率和代码可维护性：

import java.io.IOException;   

import java.util.ArrayList;   

import java.util.List;   

import javax.servlet.ServletException;   

import javax.servlet.http.HttpServlet;   

import javax.servlet.http.HttpServletRequest;   

import javax.servlet.http.HttpServletResponse;   

import net.sf.json.JSONArray;   

import net.sf.json.JSONObject;   

import org.wncnke.json.pojo.Address;   

import org.wncnke.json.pojo.Person;   

public class DemoServlet extends HttpServlet{   

    @Override 

    protected void doGet(HttpServletRequest request,HttpServletResponse response)   

            throwsServletException, IOException {   

        doPost(request, response);  

    }   

    @Override 

    protected void doPost(HttpServletRequest request,HttpServletResponse response)   

            throwsServletException, IOException {   

       response.setContentType("text/xml;charset=utf-8");   

        response.setHeader("Cache-Control","no-cache");   

        try{   

            Personperson1 = new Person();   

           person1.setName("小王");  

           person1.setSex("女");   

           person1.setAge(23);   

            person1.setAddress(newAddress("辽宁省","大连市","高新园区"));   

           List<Person> list = new ArrayList<Person>();   

           list.add(person1);   

            try{   

               //取集合   

               JSONArray jsonArray = JSONArray.fromObject(list);   

               JSONObject jsonObject = new JSONObject();   

               jsonObject.put("person", jsonArray);   

               response.getWriter().write(jsonObject.toString());    

            } catch(IOException e) {   

               e.printStackTrace();   

           }   

        }catch(Exception e){   

           e.printStackTrace();   

        }   

    }   

}

Servlet 核心知识点补充

1. GET/POST 请求统一处理：重写doGet方法并调用doPost，使 Servlet 同时支持 GET 和 POST 类型的 Ajax 请求，适配前端不同的请求方式；
2. 
   
3. json-lib 核心类： 
4.   JSONArray.fromObject(集合/数组)：将 Java 集合或数组转换为 JSON 数组格式； 
5. 
   
6.   JSONObject.fromObject(单个对象)：将 Java 单个实体对象转换为 JSON 对象格式；
7. 
   
8.   支持嵌套对象自动转换：无需手动处理 Person 中的 Address 对象，json-lib 会递归解析嵌套对象的 get 方法，生成嵌套 JSON；
9. 
   
10. 响应流输出：通过response.getWriter().write()输出 JSON 字符串，替代 JSP 的out.print()，是 Servlet 返回数据的标准方式；
11. 
    
12. 异常处理：通过 try-catch 捕获异常并打印堆栈，避免程序崩溃，实际开发中可添加自定义异常返回（如{"code":500,"msg":"服务器异常"}）。 

四、Web.xml 配置（Servlet 注册与映射）

Servlet 需在 web.xml 中进行注册和 URL 映射，才能被前端访问，这是 Java Web 中 Servlet 的核心配置，指定 Servlet 的访问路径：  

<?xml version="1.0"encoding="UTF-8"?> 

<web-app xmlns="http://caucho.com/ns/resin" xmlns:resin="http://caucho.com/ns/resin/core"> 

    <display-name>json</display-name> 

    <welcome-file-list> 

       <welcome-file>index.jsp</welcome-file>        

    </welcome-file-list> 

    <servlet> 

       <servlet-name>DemoServlet</servlet-name> 

       <servlet-class>org.wncnke.json.servlet.DemoServlet</servlet-class> 

    </servlet> 

    <servlet-mapping> 

       <servlet-name>DemoServlet</servlet-name> 

       <url-pattern>/demoServlet</url-pattern> 

    </servlet-mapping> 

</web-app>

Web.xml 配置关键说明

1. servlet-name：Servlet 的唯一标识，注册和映射中的名称必须完全一致；
2. servlet-class：Servlet 的全限定类名（包名 + 类名），必须准确，否则会抛出类找不到异常；
3. url-pattern：Servlet 的访问路径，前端 Ajax 的请求地址即为该路径（如demoServlet），可添加前缀（如/servlet/demoServlet），方便接口管理。

五、前端页面代码（index.jsp：Ajax 请求 + JSON 解析 + 页面渲染）

前端通过 jQuery 的$.getJSON发起 Ajax 请求，接收 Servlet 返回的复杂 JSON 数据（包含集合和嵌套对象），解析后通过 jQuery 动态渲染到表格中，实现数据的页面展示：

view plaincopy to clipboardprint?

<%@ page language="java" pageEncoding="utf-8"%> 

<%   

String path = request.getContextPath();   

String basePath =request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";  

%> 

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html> 

<head> 

<base href="<%=basePath%>"> 

<mce:script language="javascript" src="script/jquery.js"mce_src="script/jquery.js"></mce:script>     

<mce:script language="javascript" src="script/json.js"mce_src="script/json.js"></mce:script>    

<mce:script language="javascript"><!--   

function addPerson(){      

    $.getJSON("demoServlet",null,function call(data){   

        var list = data.person;   

        $.each(list, function(i, p){   

            var row =$("#tr").clone();   

           row.find("#name").text(p.name);   

           row.find("#age").text(p.age);   

           row.find("#sex").text(p.sex);   

           row.find("#address").text(p.address.province + p.address.city +p.address.country);   

           row.appendTo("#tbody");   

        });      

    });   

}      

// --></mce:script> 

</head> 

<body> 

<input type="button" value="JsonView"onClick="addPerson();">      

<div id="dateMessage">      

    <table id="planTable"border="1">      

        <tr> 

           <td>Name</td> 

           <td>Sex</td> 

           <td>Age</td> 

           <td>Address</td> 

       </tr>      

        <tbody id="tbody"> 

            <trid="tr"> 

               <td id="name"></td> 

               <td id="sex"></td> 

               <td id="age"></td> 

               <td id="address"></td> 

           </tr>      

        </tbody> 

    </table>      

</div> 

</body> 

</html>

前端核心知识点

1. $.getJSON方法：jQuery 专门为 JSON 请求封装的 GET 方法，语法$.getJSON(url, data, successCallback)，自动将后端返回的 JSON 字符串解析为 JavaScript 对象，比$.get更简洁，专为 JSON 交互设计；
2. 
   
3. basePath 根路径：通过 JSP 内置对象生成项目根路径，解决不同环境（如本地、服务器）的路径问题，确保 JS、CSS 等文件的正确引入；
4. 
   
5. jQuery 克隆与渲染：
6.     $("#tr").clone()：克隆表格行模板，避免手动拼接 HTML 字符串，提升代码可读性和可维护性；
7.     row.find("#name")：查找克隆节点中的子元素，通过text()方法赋值，是 jQuery 操作 DOM 的常用方式；
8.     row.appendTo("#tbody")：将克隆并赋值后的节点添加到 tbody 中，实现动态表格渲染；
9. 嵌套 JSON 解析：前端可直接通过p.address.province解析嵌套的地址属性，与 JavaScript 访问嵌套对象的方式完全一致，json-lib 保证了前后端数据结构的统一。