下面是针对你现有代码的系统化优化建议与示例改造，重点覆盖结构优化、性能优化、可读性增强、安全性改进与错误处理优化，并结合 Spring/JdbcTemplate 的最佳实践。建议按模块逐步落地，避免一次性大改造成风险。
一、问题诊断（现状与风险）
- 控制器直接返回原始 Map 列表和纯文本，接口契约不清晰，HTTP 状态码不规范。
- 缺少输入校验和分页，search 会拉取全部数据，容易发生慢查询与内存压力。
- SQL 拼接存在注入风险（字符串拼接关键字和字段值）。
- SimpleDateFormat 作为共享字段且 create 方法加 synchronized，吞吐量差；SimpleDateFormat 本身非线程安全。
- N+1 查询（逐条订单再查 items），导致大量往返数据库。
- 同步导出在请求线程执行，阻塞请求并且文件路径硬编码，潜在安全与并发问题。
- 使用 double 表示金额有精度问题。
- 错误处理直接 printStackTrace；没有统一异常响应与日志标准。
- 使用字段注入，增加测试与维护成本。
- service 层返回字符串，缺少领域模型与 DTO。
二、重构总体思路
- 分层与数据结构：Controller 只处理 HTTP 交互，Service 负责业务，Repository/DAO 负责SQL访问。使用 DTO 明确输入输出。
- 注入方式与并发：使用构造器注入，避免共享可变状态；使用 java.time 替代 SimpleDateFormat；移除 synchronized。
- 校验与分页：引入 Bean Validation（@Valid/@Validated），对 keyword/page/size 等做边界与格式校验；统一默认分页参数。
- SQL 安全与性能：使用 NamedParameterJdbcTemplate 或 JdbcTemplate 的参数绑定；对 LIKE 做转义；N+1 改为 IN 查询批量加载或一次 JOIN 并在内存聚合；加索引。
- 导出异步化：将导出移出请求线程，采用异步任务或消息队列；提供任务ID与状态查询；安全的文件路径与文件名。
- 金额类型：改用 BigDecimal。
- 错误处理与日志：统一异常处理（@ControllerAdvice），返回结构化错误；使用 SLF4J 统一日志；不要打印堆栈到控制台。
- 统一响应：通过 ResponseEntity，返回标准 JSON（包含数据与元信息）。
三、示例改造代码（精简可直接落地）
- DTO 与响应模型
定义清晰输入输出，避免 Map 到处传递。
package com.example.demo.dto;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Positive;
import jakarta.validation.constraints.Size;
import java.math.BigDecimal;
import java.time.OffsetDateTime;
import java.util.List;
public class CreateOrderRequest {
@NotBlank
@Size(max = 100)
private String customer;
@NotNull
@Positive
private BigDecimal amount;
// getters/setters
}
public class OrderItemDto {
private Long id;
private Long orderId;
private String sku;
private Integer qty;
private BigDecimal price;
// getters/setters
}
public class OrderDto {
private Long id;
private String customer;
private BigDecimal amount;
private OffsetDateTime createdAt;
private List<OrderItemDto> items;
// getters/setters
}
public class PageResponse<T> {
private List<T> content;
private long total; // 可选：返回总数，如果需要 count
private int page;
private int size;
// getters/setters, 构造器
}
public class OrderCreatedResponse {
private Long id;
private String status;
// getters/setters, 构造器
}
public class ExportJobResponse {
private String jobId;
private String status; // QUEUED/RUNNING/DONE/FAILED
private String filePath; // 完成后填充
// getters/setters
}
- Controller（构造器注入、校验、分页、标准响应）
package com.example.demo;
import com.example.demo.dto.*;
import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.Size;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/orders")
@Validated
public class OrderController {
private final OrderService service;
public OrderController(OrderService service) {
this.service = service;
}
@GetMapping("/search")
public ResponseEntity<PageResponse<OrderDto>> search(
@RequestParam(required = false) @Size(max = 100) String keyword,
@RequestParam(defaultValue = "0") @Min(0) int page,
@RequestParam(defaultValue = "20") @Min(1) @Max(200) int size) {
PageResponse<OrderDto> result = service.search(keyword, page, size);
return ResponseEntity.ok(result);
}
@PostMapping("/create")
public ResponseEntity<OrderCreatedResponse> create(@RequestBody @Validated CreateOrderRequest body) {
Long id = service.create(body);
return ResponseEntity.ok(new OrderCreatedResponse(id, "ok"));
}
// 将导出独立成异步任务
@PostMapping("/export")
public ResponseEntity<ExportJobResponse> export(
@RequestParam(required = false) @Size(max = 100) String keyword,
@RequestParam(defaultValue = "0") @Min(0) int page,
@RequestParam(defaultValue = "100") @Min(1) @Max(1000) int size) {
ExportJobResponse job = service.exportAsync(keyword, page, size);
return ResponseEntity.accepted().body(job);
}
@GetMapping("/export/{jobId}")
public ResponseEntity<ExportJobResponse> exportStatus(@PathVariable String jobId) {
return ResponseEntity.ok(service.getExportStatus(jobId));
}
}
- Service（参数化 SQL、N+1 修复、java.time、异步导出）
package com.example.demo;
import com.example.demo.dto.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.*;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.io.BufferedWriter;
import java.io.IOException;
import java.math.BigDecimal;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
@Service
public class OrderService {
private static final Logger log = LoggerFactory.getLogger(OrderService.class);
private final NamedParameterJdbcTemplate jdbc;
private final ThreadPoolTaskExecutor executor;
// 简单内存任务管理示例，生产可替换为持久化
private final Map<String, ExportJobResponse> jobs = new ConcurrentHashMap<>();
public OrderService(NamedParameterJdbcTemplate jdbc) {
this.jdbc = jdbc;
// 可在配置类中定义更完善的线程池
this.executor = new ThreadPoolTaskExecutor();
this.executor.setCorePoolSize(2);
this.executor.setMaxPoolSize(4);
this.executor.setQueueCapacity(100);
this.executor.setThreadNamePrefix("export-");
this.executor.initialize();
}
@Transactional
public Long create(CreateOrderRequest body) {
String sql = "INSERT INTO orders(customer, amount, created_at) VALUES(:customer, :amount, :createdAt)";
MapSqlParameterSource params = new MapSqlParameterSource()
.addValue("customer", body.getCustomer().trim())
.addValue("amount", body.getAmount())
.addValue("createdAt", OffsetDateTime.now(ZoneOffset.UTC)); // 让驱动处理时间类型
KeyHolder kh = new GeneratedKeyHolder();
int r = jdbc.update(sql, params, kh);
if (r <= 0) {
throw new RuntimeException("Insert failed");
}
Number key = kh.getKey();
return key == null ? null : key.longValue();
}
@Transactional(readOnly = true)
public PageResponse<OrderDto> search(String keyword, int page, int size) {
String pattern = likePattern(keyword);
MapSqlParameterSource params = new MapSqlParameterSource()
.addValue("pattern", pattern)
.addValue("limit", size)
.addValue("offset", page * size);
String baseWhere = pattern == null ? "" : " WHERE customer LIKE :pattern ESCAPE '\\\\' ";
String sql = "SELECT id, customer, amount, created_at FROM orders" + baseWhere +
" ORDER BY created_at DESC LIMIT :limit OFFSET :offset";
List<OrderDto> orders = jdbc.query(sql, params, orderMapper());
// N+1 修复：批量查询 items
List<Long> ids = orders.stream().map(OrderDto::getId).collect(Collectors.toList());
Map<Long, List<OrderItemDto>> itemsMap = Collections.emptyMap();
if (!ids.isEmpty()) {
MapSqlParameterSource p2 = new MapSqlParameterSource().addValue("ids", ids);
String sqlItems = "SELECT id, order_id, sku, qty, price FROM order_items WHERE order_id IN (:ids)";
List<OrderItemDto> items = jdbc.query(sqlItems, p2, orderItemMapper());
itemsMap = items.stream().collect(Collectors.groupingBy(OrderItemDto::getOrderId));
}
orders.forEach(o -> o.setItems(itemsMap.getOrDefault(o.getId(), Collections.emptyList())));
// 可选：总数统计（若页面需要）
long total = countOrders(pattern);
PageResponse<OrderDto> resp = new PageResponse<>();
resp.setContent(orders);
resp.setTotal(total);
resp.setPage(page);
resp.setSize(size);
return resp;
}
public ExportJobResponse exportAsync(String keyword, int page, int size) {
String jobId = UUID.randomUUID().toString();
ExportJobResponse job = new ExportJobResponse();
job.setJobId(jobId);
job.setStatus("QUEUED");
jobs.put(jobId, job);
executor.execute(() -> {
ExportJobResponse j = jobs.get(jobId);
j.setStatus("RUNNING");
try {
PageResponse<OrderDto> data = search(keyword, page, size);
Path file = Files.createTempFile("orders-", ".csv");
try (BufferedWriter bw = Files.newBufferedWriter(file)) {
// 简易CSV写出，生产建议使用 Commons CSV 并处理转义
bw.write("id,customer,amount,created_at\n");
for (OrderDto o : data.getContent()) {
bw.write(o.getId() + "," + safeCsv(o.getCustomer()) + "," + o.getAmount() + "," + o.getCreatedAt() + "\n");
}
}
j.setFilePath(file.toAbsolutePath().toString());
j.setStatus("DONE");
log.info("Export done: {}", j.getFilePath());
} catch (Exception e) {
log.error("Export job failed", e);
j.setStatus("FAILED");
}
});
return job;
}
public ExportJobResponse getExportStatus(String jobId) {
ExportJobResponse job = jobs.get(jobId);
if (job == null) {
ExportJobResponse missing = new ExportJobResponse();
missing.setJobId(jobId);
missing.setStatus("NOT_FOUND");
return missing;
}
return job;
}
private RowMapper<OrderDto> orderMapper() {
return (rs, rowNum) -> {
OrderDto o = new OrderDto();
o.setId(rs.getLong("id"));
o.setCustomer(rs.getString("customer"));
o.setAmount(rs.getBigDecimal("amount"));
// 建议数据库使用 timestamp with time zone；驱动映射为 OffsetDateTime
OffsetDateTime odt = rs.getObject("created_at", OffsetDateTime.class);
o.setCreatedAt(odt);
return o;
};
}
private RowMapper<OrderItemDto> orderItemMapper() {
return (rs, rowNum) -> {
OrderItemDto i = new OrderItemDto();
i.setId(rs.getLong("id"));
i.setOrderId(rs.getLong("order_id"));
i.setSku(rs.getString("sku"));
i.setQty(rs.getInt("qty"));
i.setPrice(rs.getBigDecimal("price"));
return i;
};
}
private long countOrders(String pattern) throws DataAccessException {
String where = pattern == null ? "" : " WHERE customer LIKE :pattern ESCAPE '\\\\' ";
String sql = "SELECT COUNT(*) FROM orders" + where;
MapSqlParameterSource p = new MapSqlParameterSource().addValue("pattern", pattern);
Long total = jdbc.queryForObject(sql, p, Long.class);
return total == null ? 0L : total;
}
// 处理 LIKE 特殊字符转义，并限制空关键词
private String likePattern(String keyword) {
if (keyword == null || keyword.isBlank()) return null;
String k = keyword.trim();
// 转义 % 和 _（以 \ 为转义符）
k = k.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_");
return "%" + k + "%";
}
private String safeCsv(String s) {
if (s == null) return "";
String v = s.replace("\"", "\"\"");
return "\"" + v + "\"";
}
}
- 统一异常处理（示例）
package com.example.demo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.Map;
@ControllerAdvice
public class GlobalExceptionHandler {
private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
@ExceptionHandler({MethodArgumentNotValidException.class, BindException.class, IllegalArgumentException.class})
public ResponseEntity<Object> handleBadRequest(Exception e) {
log.warn("Bad request", e);
Map<String, Object> body = new HashMap<>();
body.put("error", "BAD_REQUEST");
body.put("message", e.getMessage());
return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(body);
}
@ExceptionHandler(DataAccessException.class)
public ResponseEntity<Object> handleDb(Exception e) {
log.error("DB error", e);
Map<String, Object> body = new HashMap<>();
body.put("error", "DB_ERROR");
body.put("message", "Database operation failed");
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(body);
}
@ExceptionHandler(Exception.class)
public ResponseEntity<Object> handleGeneric(Exception e) {
log.error("Server error", e);
Map<String, Object> body = new HashMap<>();
body.put("error", "INTERNAL_ERROR");
body.put("message", "Unexpected error");
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(body);
}
}
四、具体优化点清单（便于检查落地）
- 结构优化
- 使用 DTO 定义输入输出，避免 Map；统一响应模型。
- 控制器不参与业务和 SQL；Service 纯业务；未来可抽取 Repository。
- 构造器注入替代字段注入，利于测试与不可变设计。
- 性能优化
- 引入分页参数 page/size 及默认值，限制最大 size。
- 修复 N+1，通过 IN 批量加载或 JOIN。
- LIKE 查询转义与合理索引；customer、created_at 建索引；order_items(order_id) 索引。
- 读操作使用 @Transactional(readOnly=true)。
- 可读性增强
- 明确的命名、DTO 字段类型与 RowMapper；移除 printStackTrace。
- 统一日志规范（info/warn/error）。
- 安全性改进
- 所有 SQL 使用参数绑定，避免注入。
- LIKE 关键字转义；限制 keyword 长度。
- 导出文件使用临时目录与受控路径；不要使用硬编码绝对路径。
- 不在日志中输出敏感数据。
- 错误处理优化
- 使用 @ControllerAdvice 统一异常响应；返回标准错误码与消息。
- 使用 ResponseEntity 设置 HTTP 状态码。
- 对输入进行 Bean Validation。
- 金额与时间
- 金额使用 BigDecimal，避免 double 精度问题。
- 时间使用 OffsetDateTime/Instant；避免 SimpleDateFormat 与 synchronized。
- 导出异步化
- 使用线程池或 @Async 将导出移出请求线程；返回 jobId 与状态。
- 导出内容建议使用 CSV 库处理转义与大数据量（分批写入、流式）。
- SQL/数据库建议
- 索引：orders(customer), orders(created_at), order_items(order_id)。
- 若按金额或时间过滤，考虑复合索引。
- 大数据分页建议键集分页（基于 created_at+id）提升性能。
五、可选进一步改进
- 替换 JdbcTemplate 为 JOOQ 或 MyBatis，获得更强的类型安全与可维护性。
- 接口契约标准化（如返回 code/message/data 格式）；引入 OpenAPI/Swagger 文档。
- 导出使用消息队列（如 RabbitMQ/Kafka）与独立任务执行器，避免服务实例重启丢失任务。
- 引入审计字段与统一拦截器（created_by、updated_at 等）。
- 在 Controller 层引入限流与防刷策略，对导出接口做权限与速率限制。
以上改造可以逐步分阶段实施：先分页与参数化 SQL，再修复 N+1，随后统一错误处理与日志，最后迁移导出到异步。这样能快速消除高风险问题，同时稳步提升可维护性与性能。
