01
package cn.usehook.spring.health;
02

03
import java.util.Objects;
04
import org.springframework.jdbc.core.simple.JdbcClient;
05
import org.springframework.stereotype.Repository;
06

07
@Repository
08
public class HealthCheckHistoryRepository {
09

10
    private final JdbcClient jdbcClient;
11

12
    public HealthCheckHistoryRepository(JdbcClient jdbcClient) {
13
        this.jdbcClient = jdbcClient;
14
    }
15

16
    public void append(HealthStatus status) {
17
        Objects.requireNonNull(status, "status must not be null");
18

19
        jdbcClient.sql("""
20
            insert into health_check_history (service, status)
21
            values (:service, :status)
22
            """)
23
            .param("service", status.service())
24
            .param("status", status.status())
25
            .update();
26
    }
27
}

01
package cn.usehook.spring.health;
02

03
import cn.usehook.spring.config.HealthProperties;
04
import java.util.List;
05
import java.util.Locale;
06
import java.util.Optional;
07
import org.springframework.stereotype.Service;
08
import org.springframework.transaction.annotation.Transactional;
09

10
@Service
11
public class HealthService {
12

13
    private final HealthProperties properties;
14
    private final HealthStatusRepository repository;
15
    private final HealthCheckHistoryRepository historyRepository;
16

17
    public HealthService(
18
        HealthProperties properties,
19
        HealthStatusRepository repository,
20
        HealthCheckHistoryRepository historyRepository
21
    ) {
22
        this.properties = properties;
23
        this.repository = repository;
24
        this.historyRepository = historyRepository;
25
    }
26

27
    @Transactional
28
    public HealthStatus check() {
29
        return performCheck(properties.service());
30
    }
31

32
    @Transactional
33
    public HealthStatus check(String service) {
34
        return performCheck(service);
35
    }
36

37
    @Transactional(readOnly = true)
38
    public Optional<HealthStatus> find(String service) {
39
        return repository.findByService(normalizeService(service));
40
    }
41

42
    @Transactional(readOnly = true)
43
    public HealthStatus getRequired(String service) {
44
        String normalizedService = normalizeService(service);
45
        return repository.findByService(normalizedService)
46
            .orElseThrow(() -> new HealthStatusNotFoundException(normalizedService));
47
    }
48

49
    @Transactional(readOnly = true)
50
    public List<HealthStatus> findAll() {
51
        return repository.findAll();
52
    }
53

54
    private HealthStatus performCheck(String service) {
55
        String normalizedService = normalizeService(service);
56
        HealthStatus status = new HealthStatus(properties.status(), normalizedService);
57
        HealthStatus savedStatus = repository.save(status);
58
        historyRepository.append(savedStatus);
59
        return savedStatus;
60
    }
61

62
    private String normalizeService(String service) {
63
        if (service == null || service.isBlank()) {
64
            throw new InvalidServiceNameException(service);
65
        }
66
        return service.strip().toLowerCase(Locale.ROOT);
67
    }
68
}

1
@Transactional(rollbackFor = Exception.class)
2
public void importStatuses() throws Exception {
3
    // 数据库操作
4
}

1
try {
2
    historyRepository.append(status);
3
} catch (DataAccessException exception) {
4
    log.warn("Failed to append history", exception);
5
}

01
package cn.usehook.spring.health;
02

03
import org.junit.jupiter.api.Test;
04
import org.springframework.beans.factory.annotation.Autowired;
05
import org.springframework.boot.test.context.SpringBootTest;
06
import org.springframework.dao.DataAccessResourceFailureException;
07
import org.springframework.jdbc.core.simple.JdbcClient;
08
import org.springframework.test.context.bean.override.mockito.MockitoBean;
09

10
import static org.assertj.core.api.Assertions.assertThat;
11
import static org.assertj.core.api.Assertions.assertThatThrownBy;
12
import static org.mockito.ArgumentMatchers.any;
13
import static org.mockito.BDDMockito.willThrow;
14

15
@SpringBootTest
16
class HealthTransactionTests {
17

18
    private final HealthService healthService;
19
    private final HealthStatusRepository repository;
20
    private final JdbcClient jdbcClient;
21

22
    @MockitoBean
23
    private HealthCheckHistoryRepository historyRepository;
24

25
    @Autowired
26
    HealthTransactionTests(
27
        HealthService healthService,
28
        HealthStatusRepository repository,
29
        JdbcClient jdbcClient
30
    ) {
31
        this.healthService = healthService;
32
        this.repository = repository;
33
        this.jdbcClient = jdbcClient;
34
    }
35

36
    @Test
37
    void rollsBackLatestStatusWhenHistoryWriteFails() {
38
        String service = "rollback-test";
39
        deleteStatus(service);
40

41
        willThrow(new DataAccessResourceFailureException("simulated history failure"))
42
            .given(historyRepository)
43
            .append(any(HealthStatus.class));
44

45
        try {
46
            assertThatThrownBy(() -> healthService.check(service))
47
                .isInstanceOf(DataAccessResourceFailureException.class);
48
            assertThat(repository.findByService(service)).isEmpty();
49
        } finally {
50
            deleteStatus(service);
51
        }
52
    }
53

54
    private void deleteStatus(String service) {
55
        jdbcClient.sql("delete from health_status where service = :service")
56
            .param("service", service)
57
            .update();
58
    }
59
}