下面我将为你提供几种主流的实现方式,从传统的 Servlet 到现代的 Spring Boot，并附上完整的代码示例。
（图片来源网络，侵删）
核心思路
无论使用哪种技术,返回 XML 响应的核心步骤都大同小异：
- 创建 XML 数据：将你的业务数据（如对象、列表）转换成 XML 格式的字符串或流。
- 设置 HTTP 响应头：告诉客户端（浏览器、其他程序）我返回的是 XML 数据，最关键的响应头是
Content-Type，其值应为application/xml或text/xml。 - 写入响应体：将生成的 XML 数据写入到 HTTP 响应的输出流中。
使用传统的 Java Servlet (最基础)
这是最原始的方式,能让你理解底层原理。
创建一个简单的 XML 工具类
为了方便,我们写一个工具类将 Java 对象转换为 XML，这里使用简单的字符串拼接，实际项目中推荐使用 JAXB (Java Architecture for XML Binding) 或其他 XML 库（如 Dom4j, XStream）。
// XmlUtils.java
public class XmlUtils {
/**
* 将一个简单的 User 对象转换为 XML 字符串
*/
public static String userToXml(User user) {
// 注意：实际开发中请务必使用 XML 库来防止注入和格式错误
// 这里仅为演示
return "<user>" +
"<id>" + user.getId() + "</id>" +
"<name>" + user.getName() + "</name>" +
"<email>" + user.getEmail() + "</email>" +
"</user>";
}
public static String usersToXml(List<User> users) {
StringBuilder sb = new StringBuilder();
sb.append("<users>");
for (User user : users) {
sb.append(userToXml(user));
}
sb.append("</users>");
return sb.toString();
}
}
// User.java (POJO)
public class User {
private int id;
private String name;
private String email;
// 构造方法、Getters 和 Setters
public User() {}
public User(int id, String name, String email) {
this.id = id;
this.name = name;
this.email = email;
}
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
}
创建 Servlet 并处理请求
// UserServlet.java
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
@WebServlet("/api/users") // 映射 URL
public class UserServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 1. 准备业务数据
List<User> users = Arrays.asList(
new User(1, "张三", "zhangsan@example.com"),
new User(2, "李四", "lisi@example.com")
);
// 2. 将数据转换为 XML
String xmlResponse = XmlUtils.usersToXml(users);
// 3. 设置响应头
resp.setContentType("application/xml"); // 告诉浏览器这是 XML
resp.setCharacterEncoding("UTF-8"); // 设置字符编码，防止中文乱码
resp.setStatus(HttpServletResponse.SC_OK); // 设置状态码为 200
// 4. 将 XML 写入响应输出流
resp.getWriter().write(xmlResponse);
}
}
部署和测试
将项目打包成 WAR 文件并部署到 Tomcat 等 Servlet 容器中，然后访问 http://localhost:8080/your-app-name/api/users，你将看到如下 XML 响应：
（图片来源网络，侵删）
<users> <user><id>1</id><name>张三</name><email>zhangsan@example.com</email></user> <user><id>2</id><name>李四</name><email>lisi@example.com</email></user> </users>
使用 Spring Boot (推荐，更现代、更简单)
Spring Boot 是目前 Java Web 开发的主流框架，它极大地简化了开发过程。
项目依赖
在你的 pom.xml 中添加 spring-boot-starter-web 依赖，它已经包含了所有你需要的东西。
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 如果需要更强大的 XML 支持，可以添加 Jackson 的 XML 模块 -->
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
</dependency>
</dependencies>
创建 Controller
Spring Boot 可以非常方便地返回 XML，最简单的方式是返回一个对象，然后通过消息转换器自动将其转换为 XML。
使用 Jackson XML 模块 (推荐)
（图片来源网络，侵删）
Spring Boot 默认使用 Jackson 处理 JSON，通过添加 jackson-dataformat-xml 依赖，Jackson 就可以处理 XML 了。
// User.java (POJO)
// 可以添加 Jackson 的注解来控制 XML 输出
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
@JacksonXmlRootElement(localName = "user") // 指定根元素标签名
public class User {
private int id;
private String name;
private String email;
// 构造方法、Getters 和 Setters...
// ... (与 Servlet 示例中的 User 类相同)
}
// UserController.java
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Arrays;
import java.util.List;
@RestController
@RequestMapping("/api/users")
public class UserController {
@GetMapping
public List<User> getAllUsers() {
// Spring Boot 会自动将 List<User> 序列化为 XML
// 并设置正确的 Content-Type 为 application/xml
return Arrays.asList(
new User(1, "张三", "zhangsan@example.com"),
new User(2, "李四", "lisi@example.com")
);
}
}
启动 Spring Boot 应用，访问 http://localhost:8080/api/users，你会得到格式化的 XML 响应：
<list>
<user>
<id>1</id>
<name>张三</name>
<email>zhangsan@example.com</email>
</user>
<user>
<id>2</id>
<name>李四</name>
<email>lisi@example.com</email>
</user>
</list>
手动构建并返回
如果你对 XML 格式有完全的控制权，也可以手动构建字符串。
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@RestController
@RequestMapping("/api/manual-xml")
public class ManualXmlController {
@GetMapping("/user")
public void getManualUser(HttpServletResponse response) throws IOException {
String xml = "<user><id>99</id><name>手动构建的XML</name></user>";
// 设置响应头
response.setContentType("application/xml");
response.setCharacterEncoding("UTF-8");
// 写入响应
response.getWriter().write(xml);
}
}
使用 JAX-RS (Java API for RESTful Web Services)
JAX-RS 是 Java EE 中定义的一套 RESTful 服务标准，Jersey 和 RESTEasy 是其流行的实现。
项目依赖 (以 Jersey 为例)
<dependencies>
<dependency>
<groupId>org.glassfish.jersey.containers</groupId>
<artifactId>jersey-container-servlet</artifactId>
<version>2.35</version>
</dependency>
<dependency>
<groupId>org.glassfish.jersey.media</groupId>
<artifactId>jersey-media-moxy</artifactId>
<version>2.35</version>
</dependency>
</dependencies>
配置和创建资源类
在 web.xml 中配置 Jersey Servlet，或者使用 Jersey 的 Spring 自动配置（如果使用 Jersey with Spring Boot）。
// User.java (POJO)
// JAX-RS 通常使用 JAXB 注解
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement // 必须添加此注解，JAXB 才能处理
public class User {
private int id;
private String name;
private String email;
// 构造方法、Getters 和 Setters...
// ... (与 Servlet 示例中的 User 类相同)
}
// UserResource.java
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import java.util.Arrays;
import java.util.List;
@Path("/api/users")
public class UserResource {
@GET
@Produces(MediaType.APPLICATION_XML) // 声明此方法返回 XML
public List<User> getAllUsers() {
return Arrays.asList(
new User(1, "张三", "zhangsan@example.com"),
new User(2, "李四", "lisi@example.com")
);
}
}
访问 http://localhost:8080/your-app-name/api/users，同样会得到 XML 响应。
总结与对比
| 方案 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| 传统 Servlet | - 理解底层原理 - 无额外依赖（JDK自带） |
- 代码繁琐，需要手动处理很多细节 - 不适合复杂项目 |
学习、面试、简单的内部工具 |
| Spring Boot | - 开发效率极高 - 自动化配置（序列化、响应头） - 强大的生态系统 |
- 引入了 Spring 框架的学习成本 | 现代 Java Web 应用的首选 |
| JAX-RS (Jersey) | - 标准 API，实现解耦 - 专注于 RESTful 服务 |
- 配置相对 Spring Boot 略显复杂 | 构建 RESTful 服务，特别是需要遵循 Java EE 标准的企业项目 |
推荐：
- 对于新项目，强烈推荐使用 Spring Boot，它是最流行、最高效、社区支持最好的选择。
- 如果你正在维护一个传统的 Java EE 项目，并且需要快速添加一个 XML 接口，JAX-RS (Jersey/RESTEasy) 是一个很好的选择。
- 如果你想了解 HTTP 响应的底层机制，或者在一个非常简单的环境中（如没有Servlet容器之外的依赖），可以从 Servlet 开始学习。
