spring-petclinic纳米技术：微型设备数据集成
项目地址: https://gitcode.com/gh_mirrors/sp/spring-petclinic 引言：宠物医疗的微型化革命
在当代宠物医疗领域，传统诊疗模式正面临严峻挑战。宠物主人常常因工作繁忙而错过宠物的健康异常信号，兽医也难以获取宠物的实时生理数据。你是否也曾经历过因无法及时掌握宠物健康状况而导致的焦虑与遗憾？本文将详细介绍如何利用纳米技术（Nanotechnology）与Spring PetClinic项目进行微型设备数据集成，实现宠物健康数据的实时采集、传输、存储与分析，为宠物医疗带来全新的可能性。
读完本文，你将能够：
- 理解纳米传感器（Nano-sensor）与Spring PetClinic集成的核心原理
- 掌握数据采集模块的设计与实现方法
- 学会构建实时数据传输通道
- 实现微型设备数据的持久化存储
- 开发基于实时数据的健康监测与预警功能
技术架构概览
系统整体架构
Spring PetClinic微型设备数据集成系统采用分层架构设计，主要包含以下几个部分：
技术栈选择
| 技术领域 | 选型 | 优势 |
|---|---|---|
| 后端框架 | Spring Boot | 快速开发、丰富的生态系统、易于集成各种组件 |
| 数据持久化 | Spring Data JPA | 简化数据库操作、支持多种数据库 |
| 实时通信 | WebSocket | 全双工通信、低延迟、适合实时数据传输 |
| 传感器集成 | Bluetooth Low Energy | 低功耗、短距离通信、适合微型设备 |
| 时序数据存储 | TimescaleDB | 基于PostgreSQL，专为时间序列数据优化 |
| 前端框架 | Thymeleaf + Bootstrap | 服务端渲染、响应式设计、易于使用 |
数据采集模块设计
纳米传感器数据格式定义
纳米传感器采集的宠物健康数据需要统一的数据格式，以便后续处理和存储。定义如下数据结构：
public class SensorData {
private String deviceId; // 设备唯一标识
private LocalDateTime timestamp; // 数据采集时间戳
private Map<String, Double> metrics; // 健康指标键值对
private double batteryLevel; // 设备电池电量
private String signalStrength; // 信号强度
// Getters and Setters
public String getDeviceId() { return deviceId; }
public void setDeviceId(String deviceId) { this.deviceId = deviceId; }
public LocalDateTime getTimestamp() { return timestamp; }
public void setTimestamp(LocalDateTime timestamp) { this.timestamp = timestamp; }
public Map<String, Double> getMetrics() { return metrics; }
public void setMetrics(Map<String, Double> metrics) { this.metrics = metrics; }
public double getBatteryLevel() { return batteryLevel; }
public void setBatteryLevel(double batteryLevel) { this.batteryLevel = batteryLevel; }
public String getSignalStrength() { return signalStrength; }
public void setSignalStrength(String signalStrength) { this.signalStrength = signalStrength; }
}
数据采集服务实现
创建一个数据采集服务，负责从纳米传感器接收数据并进行初步处理：
@Service
public class SensorDataCollectionService {
private final DeviceRepository deviceRepository;
private final SensorDataRepository sensorDataRepository;
private final WebSocketService webSocketService;
@Autowired
public SensorDataCollectionService(DeviceRepository deviceRepository,
SensorDataRepository sensorDataRepository,
WebSocketService webSocketService) {
this.deviceRepository = deviceRepository;
this.sensorDataRepository = sensorDataRepository;
this.webSocketService = webSocketService;
}
@Async
public CompletableFuture<Void> processSensorData(SensorData data) {
// 1. 验证设备是否已注册
Device device = deviceRepository.findByDeviceId(data.getDeviceId())
.orElseThrow(() -> new DeviceNotFoundException("Device not registered: " + data.getDeviceId()));
// 2. 验证数据完整性
validateSensorData(data);
// 3. 关联宠物信息
Pet pet = device.getPet();
if (pet == null) {
throw new IllegalStateException("No pet associated with device: " + data.getDeviceId());
}
// 4. 保存原始数据
SensorDataRecord record = convertToSensorDataRecord(data, pet);
sensorDataRepository.save(record);
// 5. 实时推送数据到前端
webSocketService.broadcastSensorData(record);
return CompletableFuture.runAsync(() -> {
// 6. 异步进行数据分析
analyzeSensorData(record);
});
}
private void validateSensorData(SensorData data) {
// 实现数据验证逻辑
if (data.getMetrics() == null || data.getMetrics().isEmpty()) {
throw new InvalidSensorDataException("Sensor data metrics cannot be empty");
}
// 其他验证逻辑...
}
private SensorDataRecord convertToSensorDataRecord(SensorData data, Pet pet) {
// 实现数据转换逻辑
SensorDataRecord record = new SensorDataRecord();
record.setDeviceId(data.getDeviceId());
record.setPet(pet);
record.setTimestamp(data.getTimestamp());
record.setBatteryLevel(data.getBatteryLevel());
record.setSignalStrength(data.getSignalStrength());
// 存储关键指标
record.setHeartRate(data.getMetrics().getOrDefault("heartRate", 0.0));
record.setTemperature(data.getMetrics().getOrDefault("temperature", 0.0));
record.setActivityLevel(data.getMetrics().getOrDefault("activityLevel", 0.0));
return record;
}
private void analyzeSensorData(SensorDataRecord record) {
// 实现数据分析逻辑，检测异常情况
// ...
}
}
实时数据传输通道构建
WebSocket配置
为了实现实时数据传输，需要配置WebSocket：
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
config.enableSimpleBroker("/topic");
config.setApplicationDestinationPrefixes("/app");
}
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/sensor-websocket")
.setAllowedOrigins("*")
.withSockJS();
}
}
WebSocket服务实现
创建WebSocket服务类，用于向前端推送实时数据：
@Service
public class WebSocketService {
private final SimpMessagingTemplate messagingTemplate;
@Autowired
public WebSocketService(SimpMessagingTemplate messagingTemplate) {
this.messagingTemplate = messagingTemplate;
}
public void broadcastSensorData(SensorDataRecord record) {
// 广播给所有用户
messagingTemplate.convertAndSend("/topic/sensor-data",
new SensorDataDTO(record));
// 发送给特定宠物的主人
String ownerDestination = String.format("/topic/owners/%d/sensor-data",
record.getPet().getOwner().getId());
messagingTemplate.convertAndSend(ownerDestination, new SensorDataDTO(record));
}
public void sendAlertToOwner(Owner owner, Alert alert) {
String destination = String.format("/topic/owners/%d/alerts", owner.getId());
messagingTemplate.convertAndSend(destination, new AlertDTO(alert));
}
}
前端实时数据展示
使用JavaScript和Chart.js实现实时数据展示：
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<title>宠物健康实时监测</title>
<script src="https://cdn.bootcdn.net/ajax/libs/sockjs-client/1.5.1/sockjs.min.js"></script>
<script src="https://cdn.bootcdn.net/ajax/libs/stomp.js/2.3.3/stomp.min.js"></script>
<script src="https://cdn.bootcdn.net/ajax/libs/chart.js/3.7.0/chart.min.js"></script>
</head>
<body>
<div class="container">
<h1>宠物健康实时监测</h1>
<div class="card">
<div class="card-body">
<h5 class="card-title" th:text="${pet.name}">宠物名称</h5>
<div class="row">
<div class="col-md-6">
<canvas id="heartRateChart"></canvas>
</div>
<div class="col-md-6">
<canvas id="temperatureChart"></canvas>
</div>
</div>
</div>
</div>
</div>
<script th:inline="javascript">
// 初始化WebSocket连接
const socket = new SockJS('/sensor-websocket');
const stompClient = Stomp.over(socket);
// 获取宠物ID
const petId = [[${pet.id}]];
// 初始化图表
const heartRateChart = new Chart(
document.getElementById('heartRateChart'),
{
type: 'line',
data: {
labels: [],
datasets: [{
label: '心率 (bpm)',
data: [],
borderColor: 'rgb(255, 99, 132)',
tension: 0.1
}]
},
options: {
scales: {
x: {
title: {
display: true,
text: '时间'
}
},
y: {
title: {
display: true,
text: '心率 (bpm)'
}
}
}
}
}
);
const temperatureChart = new Chart(
document.getElementById('temperatureChart'),
{
type: 'line',
data: {
labels: [],
datasets: [{
label: '体温 (°C)',
data: [],
borderColor: 'rgb(54, 162, 235)',
tension: 0.1
}]
},
options: {
scales: {
x: {
title: {
display: true,
text: '时间'
}
},
y: {
title: {
display: true,
text: '体温 (°C)'
}
}
}
}
}
);
// 连接WebSocket并订阅消息
stompClient.connect({}, function(frame) {
console.log('Connected: ' + frame);
// 订阅特定宠物的传感器数据
stompClient.subscribe('/topic/pets/' + petId + '/sensor-data', function(message) {
const sensorData = JSON.parse(message.body);
updateCharts(sensorData);
});
// 订阅警报消息
stompClient.subscribe('/topic/owners/' + [[${owner.id}]] + '/alerts', function(message) {
const alert = JSON.parse(message.body);
showAlert(alert);
});
});
// 更新图表数据
function updateCharts(sensorData) {
const timestamp = new Date(sensorData.timestamp).toLocaleTimeString();
// 更新心率图表
if (heartRateChart.data.labels.length > 20) {
heartRateChart.data.labels.shift();
heartRateChart.data.datasets[0].data.shift();
}
heartRateChart.data.labels.push(timestamp);
heartRateChart.data.datasets[0].data.push(sensorData.heartRate);
heartRateChart.update();
// 更新体温图表
if (temperatureChart.data.labels.length > 20) {
temperatureChart.data.labels.shift();
temperatureChart.data.datasets[0].data.shift();
}
temperatureChart.data.labels.push(timestamp);
temperatureChart.data.datasets[0].data.push(sensorData.temperature);
temperatureChart.update();
}
// 显示警报
function showAlert(alert) {
const alertElement = document.createElement('div');
alertElement.className = 'alert alert-danger alert-dismissible fade show';
alertElement.role = 'alert';
alertElement.innerHTML = `
<strong>${alert.title}</strong> ${alert.message}
<button type="button" class="close" data-dismiss="alert" aria-label="Close">
<span aria-hidden="true">×</span>
</button>
`;
document.body.prepend(alertElement);
// 30秒后自动关闭警报
setTimeout(() => {
alertElement.classList.remove('show');
setTimeout(() => alertElement.remove(), 1000);
}, 30000);
}
</script>
</body>
</html>
数据持久化方案
数据库模型设计
为了存储微型设备数据，需要扩展Spring PetClinic的数据模型：
@Entity
@Table(name = "devices")
public class Device extends BaseEntity {
@Column(unique = true, nullable = false)
private String deviceId;
private String type;
private String model;
private LocalDate activationDate;
private LocalDate lastSyncDate;
@ManyToOne
@JoinColumn(name = "pet_id")
private Pet pet;
// Getters and Setters
}
@Entity
@Table(name = "sensor_data")
public class SensorDataRecord extends BaseEntity {
@Column(name = "device_id", nullable = false)
private String deviceId;
@ManyToOne
@JoinColumn(name = "pet_id", nullable = false)
private Pet pet;
@Column(nullable = false)
private LocalDateTime timestamp;
private double heartRate;
private double temperature;
private double activityLevel;
private double batteryLevel;
private String signalStrength;
// Getters and Setters
}
@Entity
@Table(name = "health_alerts")
public class Alert extends BaseEntity {
@ManyToOne
@JoinColumn(name = "pet_id", nullable = false)
private Pet pet;
@Column(nullable = false)
private String title;
@Column(nullable = false)
private String message;
@Column(nullable = false)
private LocalDateTime timestamp;
private boolean acknowledged;
private LocalDateTime acknowledgedAt;
@Enumerated(EnumType.STRING)
private AlertSeverity severity;
// Getters and Setters
}
public enum AlertSeverity {
INFO, WARNING, CRITICAL
}
时序数据存储集成
对于大量的传感器时序数据，使用TimescaleDB进行存储：
@Repository
public interface SensorDataRepository extends JpaRepository<SensorDataRecord, Long> {
// 按宠物和时间范围查询传感器数据
@Query(value = "SELECT * FROM sensor_data WHERE pet_id = :petId AND timestamp BETWEEN :start AND :end",
nativeQuery = true)
List<SensorDataRecord> findByPetAndTimestampBetween(
@Param("petId") Long petId,
@Param("start") LocalDateTime start,
@Param("end") LocalDateTime end);
// 使用TimescaleDB的时间桶功能进行数据聚合
@Query(value = "SELECT time_bucket('1 minute', timestamp) AS bucket, " +
"AVG(heart_rate) AS avg_heart_rate, " +
"AVG(temperature) AS avg_temperature, " +
"AVG(activity_level) AS avg_activity " +
"FROM sensor_data " +
"WHERE pet_id = :petId AND timestamp BETWEEN :start AND :end " +
"GROUP BY bucket " +
"ORDER BY bucket",
nativeQuery = true)
List<AggregatedSensorData> findAggregatedDataByPetAndTimeRange(
@Param("petId") Long petId,
@Param("start") LocalDateTime start,
@Param("end") LocalDateTime end);
}
健康监测与预警功能
异常检测算法实现
基于传感器数据实现异常检测算法，及时发现宠物健康异常：
@Service
public class HealthMonitoringService {
private final SensorDataRepository sensorDataRepository;
private final AlertRepository alertRepository;
private final PetRepository petRepository;
private final EmailService emailService;
@Autowired
public HealthMonitoringService(SensorDataRepository sensorDataRepository,
AlertRepository alertRepository,
PetRepository petRepository,
EmailService emailService) {
this.sensorDataRepository = sensorDataRepository;
this.alertRepository = alertRepository;
this.petRepository = petRepository;
this.emailService = emailService;
}
public void analyzeSensorData(SensorDataRecord record) {
Pet pet = record.getPet();
Owner owner = pet.getOwner();
// 基于阈值的异常检测
List<String> alerts = new ArrayList<>();
// 心率异常检测
if (record.getHeartRate() > getHeartRateThreshold(pet, "high") ||
record.getHeartRate() < getHeartRateThreshold(pet, "low")) {
alerts.add(String.format("心率异常: %.1f bpm", record.getHeartRate()));
}
// 体温异常检测
if (record.getTemperature() > getTemperatureThreshold(pet, "high") ||
record.getTemperature() < getTemperatureThreshold(pet, "low")) {
alerts.add(String.format("体温异常: %.1f °C", record.getTemperature()));
}
// 活动量异常检测
if (record.getActivityLevel() < getActivityThreshold(pet, "low")) {
alerts.add("活动量过低，可能表示宠物不适");
}
// 设备状态检测
if (record.getBatteryLevel() < 10) {
alerts.add(String.format("设备电量低: %.1f%%", record.getBatteryLevel()));
}
// 如果有异常，创建警报
if (!alerts.isEmpty()) {
createAlert(pet, "宠物健康异常", String.join("; ", alerts), AlertSeverity.WARNING);
// 如果是严重异常，发送邮件通知
if (alerts.size() >= 2 || record.getHeartRate() > getHeartRateThreshold(pet, "critical")) {
emailService.sendHealthAlertEmail(owner, pet, alerts);
}
}
}
private double getHeartRateThreshold(Pet pet, String type) {
// 根据宠物类型、年龄等因素获取相应的阈值
// 实际实现中可以从配置文件或数据库加载
if ("critical".equals(type)) {
return 180; // 举例值，实际应根据宠物种类调整
} else if ("high".equals(type)) {
return 160;
} else { // low
return 60;
}
}
private double getTemperatureThreshold(Pet pet, String type) {
// 类似心率阈值的实现
if ("high".equals(type)) {
return 39.0; // 举例值
} else { // low
return 37.0;
}
}
private double getActivityThreshold(Pet pet, String type) {
// 实现活动量阈值逻辑
return 10.0; // 举例值
}
private void createAlert(Pet pet, String title, String message, AlertSeverity severity) {
Alert alert = new Alert();
alert.setPet(pet);
alert.setTitle(title);
alert.setMessage(message);
alert.setTimestamp(LocalDateTime.now());
alert.setSeverity(severity);
alert.setAcknowledged(false);
alertRepository.save(alert);
// 实时推送警报给前端
webSocketService.sendAlertToOwner(pet.getOwner(), alert);
}
}
健康报告生成
利用收集的传感器数据，生成宠物健康报告：
@Service
public class HealthReportService {
private final SensorDataRepository sensorDataRepository;
private final PetRepository petRepository;
@Autowired
public HealthReportService(SensorDataRepository sensorDataRepository,
PetRepository petRepository) {
this.sensorDataRepository = sensorDataRepository;
this.petRepository = petRepository;
}
public HealthReport generateDailyReport(Pet pet) {
LocalDateTime endTime = LocalDateTime.now();
LocalDateTime startTime = endTime.minusDays(1);
List<SensorDataRecord> dailyData = sensorDataRepository.findByPetAndTimestampBetween(
pet.getId(), startTime, endTime);
if (dailyData.isEmpty()) {
return new HealthReport(pet, startTime, endTime, Collections.emptyList());
}
// 计算统计数据
HealthMetrics metrics = new HealthMetrics();
metrics.setAverageHeartRate(calculateAverage(dailyData, SensorDataRecord::getHeartRate));
metrics.setMaxHeartRate(calculateMax(dailyData, SensorDataRecord::getHeartRate));
metrics.setMinHeartRate(calculateMin(dailyData, SensorDataRecord::getHeartRate));
metrics.setAverageTemperature(calculateAverage(dailyData, SensorDataRecord::getTemperature));
metrics.setMaxTemperature(calculateMax(dailyData, SensorDataRecord::getTemperature));
metrics.setMinTemperature(calculateMin(dailyData, SensorDataRecord::getTemperature));
metrics.setAverageActivityLevel(calculateAverage(dailyData, SensorDataRecord::getActivityLevel));
// 分析数据趋势
List<HealthTrend> trends = analyzeTrends(dailyData);
// 生成健康建议
List<String> recommendations = generateRecommendations(pet, metrics, trends);
return new HealthReport(pet, startTime, endTime, metrics, trends, recommendations);
}
private double calculateAverage(List<SensorDataRecord> data, Function<SensorDataRecord, Double> extractor) {
return data.stream()
.mapToDouble(extractor)
.average()
.orElse(0.0);
}
private double calculateMax(List<SensorDataRecord> data, Function<SensorDataRecord, Double> extractor) {
return data.stream()
.mapToDouble(extractor)
.max()
.orElse(0.0);
}
private double calculateMin(List<SensorDataRecord> data, Function<SensorDataRecord, Double> extractor) {
return data.stream()
.mapToDouble(extractor)
.min()
.orElse(0.0);
}
private List<HealthTrend> analyzeTrends(List<SensorDataRecord> data) {
// 实现趋势分析逻辑
List<HealthTrend> trends = new ArrayList<>();
// 按小时分组数据
Map<Integer, List<SensorDataRecord>> hourlyData = data.stream()
.collect(Collectors.groupingBy(record -> record.getTimestamp().getHour()));
// 分析心率趋势
List<Double> hourlyHeartRates = new ArrayList<>();
for (int hour = 0; hour < 24; hour++) {
List<SensorDataRecord> hourData = hourlyData.getOrDefault(hour, Collections.emptyList());
hourlyHeartRates.add(calculateAverage(hourData, SensorDataRecord::getHeartRate));
}
trends.add(new HealthTrend("心率日变化", "heartRate", hourlyHeartRates));
// 分析体温趋势
List<Double> hourlyTemperatures = new ArrayList<>();
for (int hour = 0; hour < 24; hour++) {
List<SensorDataRecord> hourData = hourlyData.getOrDefault(hour, Collections.emptyList());
hourlyTemperatures.add(calculateAverage(hourData, SensorDataRecord::getTemperature));
}
trends.add(new HealthTrend("体温日变化", "temperature", hourlyTemperatures));
return trends;
}
private List<String> generateRecommendations(Pet pet, HealthMetrics metrics, List<HealthTrend> trends) {
// 实现基于数据的健康建议生成逻辑
List<String> recommendations = new ArrayList<>();
// 示例建议生成
if (metrics.getAverageHeartRate() > 140) {
recommendations.add("您的宠物平均心率偏高，建议减少剧烈活动，观察是否有异常表现。");
}
if (metrics.getAverageTemperature() > 38.5) {
recommendations.add("您的宠物平均体温偏高，请注意环境温度，确保宠物有充足饮水。");
}
return recommendations;
}
// 辅助类
public static class HealthReport {
private final Pet pet;
private final LocalDateTime startTime;
private final LocalDateTime endTime;
private final HealthMetrics metrics;
private final List<HealthTrend> trends;
private final List<String> recommendations;
// 构造函数、Getters
}
public static class HealthMetrics {
private double averageHeartRate;
private double maxHeartRate;
private double minHeartRate;
private double averageTemperature;
private double maxTemperature;
private double minTemperature;
private double averageActivityLevel;
// Getters and Setters
}
public static class HealthTrend {
private final String name;
private final String type;
private final List<Double> dataPoints;
// 构造函数、Getters
}
}
集成与部署
Spring PetClinic集成点
将微型设备数据集成到Spring PetClinic的关键位置：
- OwnerController扩展：添加设备管理功能
@Controller
@RequestMapping("/owners/{ownerId}")
public class OwnerController {
// 原有代码...
@GetMapping("/pets/{petId}/devices")
public String showPetDevices(@PathVariable("ownerId") int ownerId,
@PathVariable("petId") int petId, Model model) {
Owner owner = ownerRepository.findById(ownerId);
Pet pet = petRepository.findById(petId);
model.addAttribute("owner", owner);
model.addAttribute("pet", pet);
model.addAttribute("devices", deviceRepository.findByPet(pet));
return "owners/petDevices";
}
@GetMapping("/pets/{petId}/devices/new")
public String initAddDeviceForm(@PathVariable("ownerId") int ownerId,
@PathVariable("petId") int petId, Model model) {
Owner owner = ownerRepository.findById(ownerId);
Pet pet = petRepository.findById(petId);
model.addAttribute("owner", owner);
model.addAttribute("pet", pet);
model.addAttribute("device", new Device());
return "owners/createOrUpdateDeviceForm";
}
@PostMapping("/pets/{petId}/devices/new")
public String processAddDeviceForm(@PathVariable("ownerId") int ownerId,
@PathVariable("petId") int petId,
@Valid Device device, BindingResult result,
RedirectAttributes redirectAttributes) {
if (result.hasErrors()) {
return "owners/createOrUpdateDeviceForm";
}
Owner owner = ownerRepository.findById(ownerId);
Pet pet = petRepository.findById(petId);
device.setPet(pet);
device.setActivationDate(LocalDate.now());
deviceRepository.save(device);
redirectAttributes.addFlashAttribute("message", "设备已成功添加");
return "redirect:/owners/{ownerId}/pets/{petId}/devices";
}
@GetMapping("/pets/{petId}/sensor-data")
public String showSensorData(@PathVariable("ownerId") int ownerId,
@PathVariable("petId") int petId, Model model) {
Owner owner = ownerRepository.findById(ownerId);
Pet pet = petRepository.findById(petId);
model.addAttribute("owner", owner);
model.addAttribute("pet", pet);
// 获取最近的传感器数据
LocalDateTime startTime = LocalDateTime.now().minusHours(24);
model.addAttribute("recentData",
sensorDataRepository.findByPetAndTimestampBetween(petId, startTime, LocalDateTime.now()));
return "owners/petSensorData";
}
@GetMapping("/pets/{petId}/health-report")
public String showHealthReport(@PathVariable("ownerId") int ownerId,
@PathVariable("petId") int petId, Model model) {
Owner owner = ownerRepository.findById(ownerId);
Pet pet = petRepository.findById(petId);
HealthReport report = healthReportService.generateDailyReport(pet);
model.addAttribute("owner", owner);
model.addAttribute("pet", pet);
model.addAttribute("report", report);
return "owners/healthReport";
}
}
- VetController扩展：添加基于传感器数据的诊疗支持
@Controller
public class VetController {
// 原有代码...
@GetMapping("/vets/{vetId}/pets/{petId}/sensor-data")
public String showPetSensorDataForVet(@PathVariable("vetId") int vetId,
@PathVariable("petId") int petId, Model model) {
Vet vet = vetRepository.findById(vetId);
Pet pet = petRepository.findById(petId);
model.addAttribute("vet", vet);
model.addAttribute("pet", pet);
// 获取最近7天的传感器数据
LocalDateTime startTime = LocalDateTime.now().minusDays(7);
model.addAttribute("sensorData",
sensorDataRepository.findByPetAndTimestampBetween(petId, startTime, LocalDateTime.now()));
return "vets/petSensorData";
}
@GetMapping("/vets/{vetId}/pets/{petId}/health-report")
public String showPetHealthReportForVet(@PathVariable("vetId") int vetId,
@PathVariable("petId") int petId, Model model) {
Vet vet = vetRepository.findById(vetId);
Pet pet = petRepository.findById(petId);
HealthReport report = healthReportService.generateWeeklyReport(pet);
model.addAttribute("vet", vet);
model.addAttribute("pet", pet);
model.addAttribute("report", report);
return "vets/petHealthReport";
}
}
部署配置
创建Docker Compose配置，简化部署：
version: '3.8'
services:
app:
build: .
ports:
- "8080:8080"
depends_on:
- db
- timescaledb
environment:
- SPRING_DATASOURCE_URL=jdbc:postgresql://db:5432/petclinic
- SPRING_DATASOURCE_USERNAME=postgres
- SPRING_DATASOURCE_PASSWORD=postgres
- TIMESCALEDB_URL=jdbc:postgresql://timescaledb:5432/petclinic_timeseries
- TIMESCALEDB_USERNAME=postgres
- TIMESCALEDB_PASSWORD=postgres
volumes:
- ./data/app:/app/data
db:
image: postgres:13
ports:
- "5432:5432"
environment:
- POSTGRES_DB=petclinic
- POSTGRES_USER=postgres
- POSTGRES_PASSWORD=postgres
volumes:
- ./data/postgres:/var/lib/postgresql/data
timescaledb:
image: timescale/timescaledb:latest-pg13
ports:
- "5433:5432"
environment:
- POSTGRES_DB=petclinic_timeseries
- POSTGRES_USER=postgres
- POSTGRES_PASSWORD=postgres
volumes:
- ./data/timescaledb:/var/lib/postgresql/data
command: ["postgres", "-c", "shared_preload_libraries=timescaledb"]
data-gateway:
build: ./data-gateway
ports:
- "8081:8080"
depends_on:
- app
environment:
- SPRING_PROFILES_ACTIVE=production
- PETCLINIC_API_URL=http://app:8080/api
volumes:
- ./data/gateway:/app/data
结论与展望
项目成果总结
通过将纳米技术与Spring PetClinic集成，我们构建了一个功能完善的宠物健康监测系统。该系统能够：
- 实时采集宠物的生理数据，如心率、体温和活动量
- 通过WebSocket实现数据的实时传输与可视化
- 对采集的数据进行存储和分析，检测健康异常
- 生成详细的健康报告，提供个性化的健康建议
- 在发现异常情况时及时发出警报，通知宠物主人和兽医
未来发展方向
- AI驱动的健康预测：利用机器学习算法分析历史数据，预测宠物可能出现的健康问题
- 多传感器融合：集成更多类型的传感器，如血糖、血压等，提供更全面的健康监测
- 区块链数据安全：利用区块链技术确保宠物健康数据的安全性和隐私保护
- 增强现实诊疗：结合AR技术，让兽医能够直观地查看宠物的实时生理数据
- 物联网生态扩展：与智能家居设备集成，实现环境参数（如温度、湿度）与宠物健康数据的联动分析
结语
纳米技术与Spring PetClinic的结合为宠物医疗带来了革命性的变化。通过实时监测宠物的健康状况，我们能够更早地发现潜在的健康问题，提供更及时、更精准的医疗服务。这种技术不仅提高了宠物的生活质量，也为宠物主人带来了 peace of mind（心灵安宁）。
随着技术的不断进步，我们有理由相信，未来的宠物医疗将更加智能化、个性化，为我们的 furry friends（毛茸茸的朋友）提供更好的健康保障。
如果您觉得本文对您有帮助，请点赞、收藏并关注我们，获取更多关于宠物健康科技的最新资讯！下期我们将介绍如何利用AI技术对宠物行为进行分析，敬请期待！
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
