Spring Boot CSV
最后修改于 2023 年 8 月 2 日
在本文中，我们将使用 Spring Boot RESTful 应用程序提供 CSV 格式的内容。我们使用 Opencsv 库。
CSV（逗号分隔值） 是一种简单的数据格式，其中值（大多数）由逗号字符分隔，每一行代表一条记录。数据存储在纯文本文件中。它作为电子表格和数据库中常用的导入和导出格式非常流行。Opencsv 是一个用于 Java 的开源、简单的 CSV 解析器库。
Spring Boot CSV 示例
我们的应用程序是一个 Spring Boot RESTful 应用程序，它以 CSV 格式从 H2 数据库返回数据。
build.gradle
...
src
├── main
│ ├── java
│ │ └── com
│ │ └── zetcode
│ │ ├── Application.java
│ │ ├── controller
│ │ │ └── CityController.java
│ │ ├── model
│ │ │ └── City.java
│ │ ├── repository
│ │ │ └── CityRepository.java
│ │ ├── service
│ │ │ ├── CityService.java
│ │ │ └── ICityService.java
│ │ └── util
│ │ └── WriteCsvToResponse.java
│ └── resources
│ ├── application.yml
│ └── import.sql
└── test
├── java
└── resources
这是项目结构。
plugins {
id 'org.springframework.boot' version '3.1.1'
id 'io.spring.dependency-management' version '1.1.0'
id 'java'
}
group = 'com.zetcode'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web'
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
implementation 'com.opencsv:opencsv:5.6'
runtimeOnly 'com.h2database:h2'
}
这是 Gradle 构建文件。h2 依赖项添加了 H2 数据库的驱动程序。opencsv 依赖项添加了 Opencsv 库的驱动程序。
Spring Boot 启动器是一组方便的依赖项描述符，我们可以将其包含在我们的应用程序中。它们大大简化了应用程序配置。spring-boot-starter-web 是一个用于构建 Web（包括 RESTful）应用程序的启动器，使用 Spring MVC。它使用 Tomcat 作为默认的嵌入式容器。spring-boot-starter-data-jpa 是一个用于将 Spring Data JPA 与 Hibernate 一起使用的启动器。
spring:
main:
banner-mode: "off"
jpa:
database: h2
hibernate:
dialect: org.hibernate.dialect.H2Dialect
ddl-auto: create-drop
logging:
level:
org:
springframework: ERROR
application.yml 文件包含 Spring Boot 应用程序的各种配置设置。通过 banner-mode 属性，我们关闭了 Spring banner。
JPA 的 database 值指定要操作的目标数据库。在本例中，我们指定了 Hibernate 方言，即 org.hibernate.dialect.H2Dialect。ddl-auto 是数据定义语言模式；create-drop 选项会自动创建和删除数据库模式。
H2 数据库在内存中运行。此外，我们将 Spring 框架的日志级别设置为 ERROR。application.yml 文件位于 src/main/resources 目录中。
package com.zetcode.model;
import java.util.Objects;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
@Entity
@Table(name = "cities")
public class City {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private int population;
public City() {
}
public City(Long id, String name, int population) {
this.id = id;
this.name = name;
this.population = population;
}
public Long getId() {
return id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPopulation() {
return population;
}
public void setPopulation(int population) {
this.population = population;
}
@Override
public int hashCode() {
int hash = 7;
hash = 79 * hash + Objects.hashCode(this.id);
hash = 79 * hash + Objects.hashCode(this.name);
hash = 79 * hash + this.population;
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final City other = (City) obj;
if (this.population != other.population) {
return false;
}
if (!Objects.equals(this.name, other.name)) {
return false;
}
return Objects.equals(this.id, other.id);
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("City{");
sb.append("id=").append(id);
sb.append(", name='").append(name).append('\'');
sb.append(", population=").append(population);
sb.append('}');
return sb.toString();
}
}
这是 City 实体。每个实体都必须定义至少两件事：@Entity 注解和一个带有 @Id 注解的 Id 字段。我们将 ddl-auto 选项设置为 create-drop，这意味着 Hibernate 将从该实体创建表模式。
@Entity
@Table(name = "cities")
public class City {
@Entity 注解指定该类是一个实体，并映射到数据库表。@Table 实体指定用于映射的数据库表的名称。
@Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
@Id 注解指定了实体的标识符，@GeneratedValue 提供了为主键值生成策略的规范。
INSERT INTO cities(name, population) VALUES('Bratislava', 432000);
INSERT INTO cities(name, population) VALUES('Budapest', 1759000);
INSERT INTO cities(name, population) VALUES('Prague', 1280000);
INSERT INTO cities(name, population) VALUES('Warsaw', 1748000);
INSERT INTO cities(name, population) VALUES('Los Angeles', 3971000);
INSERT INTO cities(name, population) VALUES('New York', 8550000);
INSERT INTO cities(name, population) VALUES('Edinburgh', 464000);
INSERT INTO cities(name, population) VALUES('Berlin', 3671000);
模式由 Hibernate 自动创建；之后，执行 import.sql 文件以填充表数据。
package com.zetcode.repository;
import com.zetcode.model.City;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface CityRepository extends CrudRepository<City, Long> {
}
通过扩展 Spring 的 CrudRepository，我们将为我们的数据存储库实现一些方法，包括 findAll 和 findById。通过这种方式，我们节省了大量的样板代码。
package com.zetcode.service;
import com.zetcode.model.City;
import java.util.List;
public interface ICityService {
List<City> findAll();
City findById(Long id);
}
ICityService 提供了从数据源获取所有城市以及按其 Id 获取城市的方法合同。
package com.zetcode.service;
import com.zetcode.model.City;
import com.zetcode.repository.CityRepository;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class CityService implements ICityService {
private final CityRepository repository;
public CityService(CityRepository repository) {
this.repository = repository;
}
@Override
public List<City> findAll() {
return (List<City>) repository.findAll();
}
@Override
public City findById(Long id) {
return repository.findById(id).orElse(new City());
}
}
CityService 包含 findAll 和 findById 方法的实现。我们使用存储库从数据库中检索数据。
private final CityRepository repository;
public CityService(CityRepository repository) {
this.repository = repository;
}
CityRepository 被注入。
return (List<City>) repository.findAll();
存储库的 findAll 方法返回城市列表。
return repository.findById(id).orElse(new City());
存储库的 findById 方法返回一个特定的城市对象。如果未找到城市，我们将发送一个空的城市对象。
package com.zetcode.controller;
import com.zetcode.model.City;
import com.zetcode.service.ICityService;
import com.zetcode.util.WriteCsvToResponse;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
@RestController
public class CityController {
private final ICityService cityService;
public CityController(ICityService cityService) {
this.cityService = cityService;
}
@RequestMapping(value = "/cities", produces = "text/csv")
public void findCities(HttpServletResponse response) throws IOException {
List<City> cities = cityService.findAll();
WriteCsvToResponse.writeCities(response.getWriter(), cities);
}
@RequestMapping(value = "/cities/{cityId}", produces = "text/csv")
public void findCity(@PathVariable Long cityId, HttpServletResponse response) throws IOException {
City city = cityService.findById(cityId);
WriteCsvToResponse.writeCity(response.getWriter(), city);
}
}
这是 Spring Boot RESTful 应用程序的控制器类。@RestController 注解创建一个 RESTful 控制器。虽然传统的 MVC 控制器使用 ModelAndView，但 RESTful 控制器只是返回对象，并且对象数据（通常）以 JSON 或 XML 格式直接写入 HTTP 响应。在我们的例子中，我们选择了 CSV 格式。
private final ICityService cityService;
public CityController(ICityService cityService) {
this.cityService = cityService;
}
我们将 ICityService 注入到 countryService 字段中。
@RequestMapping(value = "/cities", produces = "text/csv")
public void findCities(HttpServletResponse response) throws IOException {
...
}
@RequestMapping 注解用于将 Web 请求映射到 Spring 控制器方法。produces 选项设置媒体类型，在本例中为 text/csv。我们使用 /cities 路径将请求映射到控制器的 findCities 方法。默认请求是 GET 请求。
List<City> cities = cityService.findAll(); WriteCsvToResponse.writeCities(response.getWriter(), cities);
我们调用 cityService 的 findAll 以获取所有城市。我们将 CSV 数据写入 HttpServletResponse 对象。Java bean 到 CSV 数据的映射委托给 WriteCsvToResponse 类。
@RequestMapping(value = "/cities/{cityId}", produces = "text/csv")
public void findCity(@PathVariable Long cityId, HttpServletResponse response) throws IOException {
City city = cityService.findById(cityId);
WriteCsvToResponse.writeCity(response.getWriter(), city);
}
在第二个方法中，我们有一个包含要检索的城市 Id 的 URL 路径；我们使用 @PathVariable 注解将 URL 模板变量绑定到方法 cityId 参数。
package com.zetcode.util;
import com.opencsv.CSVWriter;
import com.opencsv.bean.ColumnPositionMappingStrategy;
import com.opencsv.bean.StatefulBeanToCsv;
import com.opencsv.bean.StatefulBeanToCsvBuilder;
import com.opencsv.exceptions.CsvException;
import com.zetcode.model.City;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.PrintWriter;
import java.util.List;
public class WriteCsvToResponse {
private static final Logger LOGGER = LoggerFactory.getLogger(WriteCsvToResponse.class);
public static void writeCities(PrintWriter writer, List<City> cities) {
try {
var builder = getStatefulBean(writer);
builder.write(cities);
} catch (CsvException ex) {
LOGGER.error("Error mapping Bean to CSV", ex);
}
}
public static void writeCity(PrintWriter writer, City city) {
try {
var builder = getStatefulBean(writer);
builder.write(city);
} catch (CsvException ex) {
LOGGER.error("Error mapping Bean to CSV", ex);
}
}
private static StatefulBeanToCsv<City> getStatefulBean(PrintWriter writer) {
ColumnPositionMappingStrategy<City> mapStrategy
= new ColumnPositionMappingStrategy<>();
mapStrategy.setType(City.class);
String[] columns = new String[]{"id", "name", "population"};
mapStrategy.setColumnMapping(columns);
StatefulBeanToCsv<City> builder = new StatefulBeanToCsvBuilder<City>(writer)
.withQuotechar(CSVWriter.NO_QUOTE_CHARACTER)
.withMappingStrategy(mapStrategy)
.withSeparator(',')
.build();
return builder;
}
}
在 WriteCsvToResponse 中，我们使用 Opencsv 库将 Java bean 转换为 CSV 并将最终输出写入 HttpServletResponse。
ColumnPositionMappingStrategy<City> mapStrategy
= new ColumnPositionMappingStrategy<>();
mapStrategy.setType(City.class);
MappingStrategy 定义了如何将 Java 属性映射到 CSV 列名。ColumnPositionMappingStrategy 使用列位置进行映射。
String[] columns = new String[]{"id", "name", "population"};
mapStrategy.setColumnMapping(columns);
我们设置列名。
StatefulBeanToCsv<City> builder = new StatefulBeanToCsvBuilder<City>(writer)
.withQuotechar(CSVWriter.NO_QUOTE_CHARACTER)
.withMappingStrategy(mapStrategy)
.withSeparator(',')
.build();
StatefulBeanToCsv 类将 bean 以 CSV 格式写入 writer，保留状态信息并对要应用的映射策略进行智能猜测。
var builder = getStatefulBean(writer); builder.write(cities);
bean 被写入响应对象。
package com.zetcode;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
Application 设置了 Spring Boot 应用程序。@SpringBootApplication 启用了自动配置和组件扫描。
$ ./gradlew bootRun
我们运行应用程序。
$ curl localhost:8080/cities 1,Bratislava,432000 2,Budapest,1759000 3,Prague,1280000 4,Warsaw,1748000 5,Los Angeles,3971000 6,New York,8550000 7,Edinburgh,464000 8,Berlin,3671000
使用 curl 命令，我们可以获取所有城市。
$ curl localhost:8080/cities/1 1,Bratislava,432000
在这里，我们获取一个由其 Id 标识的城市。
在本文中，我们从 Spring Boot RESTful 应用程序以 CSV 格式将数据返回给客户端。我们使用了 Opencsv 库。