全面掌握AntiX系统开发框架的高级特性与最佳实践通过真实项目案例学习如何充分发挥框架优势构建稳定高效的企业级应用系统

威震华夏关云长

引言

在当今快速发展的软件开发领域，选择合适的开发框架对于构建高效、稳定且可维护的企业级应用系统至关重要。AntiX系统开发框架作为一个现代化的企业级开发解决方案，提供了一套全面的工具和功能，帮助开发团队快速构建高性能、可扩展的应用程序。本文将深入探讨AntiX框架的高级特性、最佳实践，并通过真实项目案例展示如何充分利用该框架的优势，构建稳定高效的企业级应用系统。

AntiX框架概述

AntiX是一个全栈企业级开发框架，旨在简化复杂业务应用的开发过程。它采用模块化设计，提供了从前端到后端的完整解决方案，使开发团队能够专注于业务逻辑而非底层技术细节。

核心架构

AntiX框架基于分层架构设计，主要包括以下几个核心组件：

1. 表示层：提供用户界面和交互功能
2. 业务逻辑层：处理核心业务规则和流程
3. 数据访问层：管理与数据库的交互
4. 基础设施层：提供横切关注点支持，如安全性、事务管理等

主要特点

• 高性能：采用优化的执行引擎和缓存机制，确保应用响应迅速
• 可扩展性：支持水平扩展和微服务架构，适应业务增长需求
• 开发效率：提供丰富的代码生成工具和模板，加速开发过程
• 易于维护：清晰的架构设计和完善的文档支持，降低维护成本

AntiX框架的高级特性

1. 依赖注入与控制反转

AntiX框架提供了强大的依赖注入(DI)和控制反转(IoC)容器，使组件之间的耦合度降到最低，提高代码的可测试性和可维护性。

2. // 定义服务接口
3. public interface UserService {
4.     User getUserById(Long id);
5.     void saveUser(User user);
6. }
8. // 实现服务
9. @Service
10. public class UserServiceImpl implements UserService {
11.     private final UserRepository userRepository;
12.    
13.     // 通过构造函数注入依赖
14.     @Autowired
15.     public UserServiceImpl(UserRepository userRepository) {
16.         this.userRepository = userRepository;
17.     }
18.    
19.     @Override
20.     public User getUserById(Long id) {
21.         return userRepository.findById(id).orElse(null);
22.     }
23.    
24.     @Override
25.     @Transactional
26.     public void saveUser(User user) {
27.         userRepository.save(user);
28.     }
29. }
31. // 在控制器中使用服务
32. @RestController
33. @RequestMapping("/api/users")
34. public class UserController {
35.     private final UserService userService;
36.    
37.     @Autowired
38.     public UserController(UserService userService) {
39.         this.userService = userService;
40.     }
41.    
42.     @GetMapping("/{id}")
43.     public ResponseEntity<User> getUser(@PathVariable Long id) {
44.         User user = userService.getUserById(id);
45.         return ResponseEntity.ok(user);
46.     }
47. }

复制代码

2. 面向切面编程(AOP)

AntiX框架支持面向切面编程，允许开发者将横切关注点（如日志、安全、事务等）与业务逻辑分离，提高代码的模块化程度。

2. // 定义切面
3. @Aspect
4. @Component
5. public class LoggingAspect {
6.    
7.     private static final Logger logger = LoggerFactory.getLogger(LoggingAspect.class);
8.    
9.     // 定义切入点
10.     @Pointcut("execution(* com.example.antix.service.*.*(..))")
11.     public void serviceMethods() {}
12.    
13.     // 前置通知
14.     @Before("serviceMethods()")
15.     public void logMethodCall(JoinPoint joinPoint) {
16.         String methodName = joinPoint.getSignature().getName();
17.         logger.info("Entering method: {}", methodName);
18.     }
19.    
20.     // 后置通知
21.     @AfterReturning(pointcut = "serviceMethods()", returning = "result")
22.     public void logMethodReturn(JoinPoint joinPoint, Object result) {
23.         String methodName = joinPoint.getSignature().getName();
24.         logger.info("Exiting method: {} with result: {}", methodName, result);
25.     }
26.    
27.     // 异常通知
28.     @AfterThrowing(pointcut = "serviceMethods()", throwing = "exception")
29.     public void logMethodException(JoinPoint joinPoint, Throwable exception) {
30.         String methodName = joinPoint.getSignature().getName();
31.         logger.error("Exception in method: {}: {}", methodName, exception.getMessage());
32.     }
33. }

复制代码

3. 高级数据访问与ORM集成

AntiX框架提供了强大的数据访问层，支持多种数据库和ORM框架，如Hibernate、MyBatis等，并提供了简化的API和高级查询功能。

2. // 定义实体
3. @Entity
4. @Table(name = "users")
5. public class User {
6.     @Id
7.     @GeneratedValue(strategy = GenerationType.IDENTITY)
8.     private Long id;
9.    
10.     @Column(nullable = false)
11.     private String username;
12.    
13.     @Column(nullable = false)
14.     private String email;
15.    
16.     @Column(nullable = false)
17.     private String password;
18.    
19.     // getters and setters
20. }
22. // 定义Repository接口
23. public interface UserRepository extends JpaRepository<User, Long>, JpaSpecificationExecutor<User> {
24.    
25.     // 自定义查询方法
26.     User findByUsername(String username);
27.    
28.     @Query("SELECT u FROM User u WHERE u.email = :email")
29.     User findByEmail(@Param("email") String email);
30.    
31.     // 使用规范进行动态查询
32.     default List<User> findUsersByCriteria(String username, String email) {
33.         return findAll((Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) -> {
34.             List<Predicate> predicates = new ArrayList<>();
35.             
36.             if (StringUtils.hasText(username)) {
37.                 predicates.add(cb.like(root.get("username"), "%" + username + "%"));
38.             }
39.             
40.             if (StringUtils.hasText(email)) {
41.                 predicates.add(cb.like(root.get("email"), "%" + email + "%"));
42.             }
43.             
44.             return cb.and(predicates.toArray(new Predicate[0]));
45.         });
46.     }
47. }

复制代码

4. 事件驱动架构支持

AntiX框架内置了事件驱动架构支持，允许组件之间通过事件进行松耦合通信，提高系统的可扩展性和灵活性。

2. // 定义事件
3. public class UserCreatedEvent {
4.     private final User user;
5.     private final LocalDateTime createdAt;
6.    
7.     public UserCreatedEvent(User user) {
8.         this.user = user;
9.         this.createdAt = LocalDateTime.now();
10.     }
11.    
12.     // getters
13. }
15. // 定义事件发布者
16. @Service
17. public class UserServiceImpl implements UserService {
18.     private final UserRepository userRepository;
19.     private final ApplicationEventPublisher eventPublisher;
20.    
21.     @Autowired
22.     public UserServiceImpl(UserRepository userRepository, ApplicationEventPublisher eventPublisher) {
23.         this.userRepository = userRepository;
24.         this.eventPublisher = eventPublisher;
25.     }
26.    
27.     @Override
28.     @Transactional
29.     public void saveUser(User user) {
30.         userRepository.save(user);
31.         // 发布事件
32.         eventPublisher.publishEvent(new UserCreatedEvent(user));
33.     }
34. }
36. // 定义事件监听器
37. @Component
38. public class UserEventListener {
39.    
40.     private static final Logger logger = LoggerFactory.getLogger(UserEventListener.class);
41.    
42.     @EventListener
43.     public void handleUserCreatedEvent(UserCreatedEvent event) {
44.         User user = event.getUser();
45.         logger.info("User created: {} at {}", user.getUsername(), event.getCreatedAt());
46.         
47.         // 执行其他业务逻辑，如发送欢迎邮件等
48.         sendWelcomeEmail(user);
49.     }
50.    
51.     private void sendWelcomeEmail(User user) {
52.         // 邮件发送逻辑
53.     }
54. }

复制代码

5. 高级缓存机制

AntiX框架提供了强大的缓存支持，包括本地缓存和分布式缓存，帮助提高应用性能。

2. // 启用缓存
3. @Configuration
4. @EnableCaching
5. public class CacheConfig {
6.    
7.     @Bean
8.     public CacheManager cacheManager() {
9.         // 使用Redis作为分布式缓存
10.         RedisCacheManager.Builder builder = RedisCacheManager.builder(redisConnectionFactory())
11.                 .cacheDefaults(cacheConfiguration())
12.                 .withInitialCacheConfigurations(getCacheConfigurations());
13.         
14.         return builder.build();
15.     }
16.    
17.     @Bean
18.     public RedisConnectionFactory redisConnectionFactory() {
19.         return new LettuceConnectionFactory();
20.     }
21.    
22.     private RedisCacheConfiguration cacheConfiguration() {
23.         return RedisCacheConfiguration.defaultCacheConfig()
24.                 .entryTtl(Duration.ofMinutes(30))
25.                 .disableCachingNullValues()
26.                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
27.     }
28.    
29.     private Map<String, RedisCacheConfiguration> getCacheConfigurations() {
30.         Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
31.         
32.         // 用户缓存，TTL为1小时
33.         cacheConfigurations.put("users", RedisCacheConfiguration.defaultCacheConfig()
34.                 .entryTtl(Duration.ofHours(1))
35.                 .disableCachingNullValues());
36.         
37.         // 产品缓存，TTL为2小时
38.         cacheConfigurations.put("products", RedisCacheConfiguration.defaultCacheConfig()
39.                 .entryTtl(Duration.ofHours(2))
40.                 .disableCachingNullValues());
41.         
42.         return cacheConfigurations;
43.     }
44. }
46. // 在服务中使用缓存
47. @Service
48. public class UserServiceImpl implements UserService {
49.     private final UserRepository userRepository;
50.    
51.     @Autowired
52.     public UserServiceImpl(UserRepository userRepository) {
53.         this.userRepository = userRepository;
54.     }
55.    
56.     @Override
57.     @Cacheable(value = "users", key = "#id")
58.     public User getUserById(Long id) {
59.         return userRepository.findById(id).orElse(null);
60.     }
61.    
62.     @Override
63.     @CacheEvict(value = "users", key = "#user.id")
64.     public void saveUser(User user) {
65.         userRepository.save(user);
66.     }
67.    
68.     @Override
69.     @CacheEvict(value = "users", allEntries = true)
70.     public void clearUserCache() {
71.         // 清除所有用户缓存
72.     }
73. }

复制代码

6. 安全框架集成

AntiX框架提供了全面的安全支持，包括认证、授权、加密等功能，保护企业应用免受安全威胁。

2. // 安全配置
3. @Configuration
4. @EnableWebSecurity
5. public class SecurityConfig extends WebSecurityConfigurerAdapter {
6.    
7.     @Autowired
8.     private UserDetailsService userDetailsService;
9.    
10.     @Bean
11.     public PasswordEncoder passwordEncoder() {
12.         return new BCryptPasswordEncoder();
13.     }
14.    
15.     @Override
16.     protected void configure(AuthenticationManagerBuilder auth) throws Exception {
17.         auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
18.     }
19.    
20.     @Override
21.     protected void configure(HttpSecurity http) throws Exception {
22.         http
23.             .csrf().disable()
24.             .authorizeRequests()
25.                 .antMatchers("/api/public/**").permitAll()
26.                 .antMatchers("/api/admin/**").hasRole("ADMIN")
27.                 .antMatchers("/api/user/**").hasAnyRole("USER", "ADMIN")
28.                 .anyRequest().authenticated()
29.             .and()
30.             .sessionManagement()
31.                 .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
32.             .and()
33.             .addFilter(new JwtAuthenticationFilter(authenticationManager()))
34.             .addFilter(new JwtAuthorizationFilter(authenticationManager()));
35.     }
36. }
38. // JWT认证过滤器
39. public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
40.    
41.     private final AuthenticationManager authenticationManager;
42.    
43.     public JwtAuthenticationFilter(AuthenticationManager authenticationManager) {
44.         this.authenticationManager = authenticationManager;
45.         setFilterProcessesUrl("/api/login");
46.     }
47.    
48.     @Override
49.     public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response)
50.             throws AuthenticationException {
51.         try {
52.             UserCredentials credentials = new ObjectMapper()
53.                     .readValue(request.getInputStream(), UserCredentials.class);
54.             
55.             return authenticationManager.authenticate(
56.                     new UsernamePasswordAuthenticationToken(
57.                             credentials.getUsername(),
58.                             credentials.getPassword(),
59.                             new ArrayList<>())
60.             );
61.         } catch (IOException e) {
62.             throw new RuntimeException(e);
63.         }
64.     }
65.    
66.     @Override
67.     protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response,
68.             FilterChain chain, Authentication auth) throws IOException, ServletException {
69.         String token = Jwts.builder()
70.                 .setSubject(((User) auth.getPrincipal()).getUsername())
71.                 .setExpiration(new Date(System.currentTimeMillis() + 864_000_000)) // 10天
72.                 .signWith(SignatureAlgorithm.HS512, "SecretKey".getBytes())
73.                 .compact();
74.         
75.         response.addHeader("Authorization", "Bearer " + token);
76.     }
77. }
79. // 方法级安全
80. @Service
81. public class OrderServiceImpl implements OrderService {
82.    
83.     @PreAuthorize("hasRole('ADMIN') or #order.userId == authentication.principal.id")
84.     public Order getOrder(Order order) {
85.         // 获取订单逻辑
86.     }
87.    
88.     @PostAuthorize("returnObject.userId == authentication.principal.id")
89.     public Order findOrderById(Long orderId) {
90.         // 查找订单逻辑
91.     }
92. }

复制代码

AntiX框架的最佳实践

1. 项目结构组织

良好的项目结构是构建可维护应用的基础。以下是AntiX框架推荐的项目结构：

2. project-root/
3. ├── src/
4. │   ├── main/
5. │   │   ├── java/
6. │   │   │   └── com/
7. │   │   │       └── example/
8. │   │   │           └── application/
9. │   │   │               ├── Application.java
10. │   │   │               ├── config/
11. │   │   │               │   ├── SecurityConfig.java
12. │   │   │               │   ├── CacheConfig.java
13. │   │   │               │   └── DatabaseConfig.java
14. │   │   │               ├── controller/
15. │   │   │               │   ├── UserController.java
16. │   │   │               │   └── OrderController.java
17. │   │   │               ├── service/
18. │   │   │               │   ├── UserService.java
19. │   │   │               │   ├── UserServiceImpl.java
20. │   │   │               │   ├── OrderService.java
21. │   │   │               │   └── OrderServiceImpl.java
22. │   │   │               ├── repository/
23. │   │   │               │   ├── UserRepository.java
24. │   │   │               │   └── OrderRepository.java
25. │   │   │               ├── model/
26. │   │   │               │   ├── User.java
27. │   │   │               │   └── Order.java
28. │   │   │               ├── dto/
29. │   │   │               │   ├── UserDto.java
30. │   │   │               │   └── OrderDto.java
31. │   │   │               ├── exception/
32. │   │   │               │   ├── ResourceNotFoundException.java
33. │   │   │               │   └── GlobalExceptionHandler.java
34. │   │   │               └── util/
35. │   │   │                   └── DateUtils.java
36. │   │   └── resources/
37. │   │       ├── application.properties
38. │   │       ├── application-dev.properties
39. │   │       ├── application-prod.properties
40. │   │       └── static/
41. │   │       └── templates/
42. │   └── test/
43. │       └── java/
44. │           └── com/
45. │               └── example/
46. │                   └── application/
47. │                       ├── service/
48. │                       │   ├── UserServiceTest.java
49. │                       │   └── OrderServiceTest.java
50. │                       └── controller/
51. │                           ├── UserControllerTest.java
52. │                           └── OrderControllerTest.java
53. ├── .gitignore
54. ├── pom.xml
55. └── README.md

复制代码

2. 配置管理

AntiX框架支持多种配置方式，推荐使用外部化配置，便于不同环境的部署和管理。

2. # application.properties - 基础配置
3. # 应用配置
4. app.name=AntiX Application
5. app.version=1.0.0
7. # 服务器配置
8. server.port=8080
9. server.servlet.context-path=/api
11. # 数据库配置
12. spring.datasource.url=jdbc:mysql://localhost:3306/antix_db
13. spring.datasource.username=root
14. spring.datasource.password=password
15. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
17. # JPA配置
18. spring.jpa.hibernate.ddl-auto=update
19. spring.jpa.show-sql=true
20. spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
21. spring.jpa.properties.hibernate.format_sql=true
23. # 日志配置
24. logging.level.root=INFO
25. logging.level.com.example.application=DEBUG
26. logging.file.name=logs/antix-application.log
28. # 环境特定配置
29. spring.profiles.active=dev

复制代码

2. # application-dev.properties - 开发环境配置
3. # 数据库配置
4. spring.datasource.url=jdbc:mysql://localhost:3306/antix_db_dev
5. spring.datasource.username=dev_user
6. spring.datasource.password=dev_password
8. # 日志配置
9. logging.level.root=DEBUG
10. logging.level.com.example.application=TRACE
12. # 开发工具配置
13. spring.devtools.restart.enabled=true
14. spring.devtools.livereload.enabled=true

复制代码

2. # application-prod.properties - 生产环境配置
3. # 数据库配置
4. spring.datasource.url=jdbc:mysql://prod-db-host:3306/antix_db_prod
5. spring.datasource.username=prod_user
6. spring.datasource.password=${DB_PASSWORD:}
8. # 日志配置
9. logging.level.root=WARN
10. logging.level.com.example.application=INFO
11. logging.file.name=/var/log/antix/antix-application.log
13. # 性能配置
14. server.tomcat.max-threads=200
15. server.tomcat.min-spare-threads=20

复制代码

3. 异常处理

统一的异常处理可以提高应用的健壮性和用户体验。

2. // 自定义异常类
3. public class ResourceNotFoundException extends RuntimeException {
4.     public ResourceNotFoundException(String message) {
5.         super(message);
6.     }
7.    
8.     public ResourceNotFoundException(String resourceName, String fieldName, Object fieldValue) {
9.         super(String.format("%s not found with %s: '%s'", resourceName, fieldName, fieldValue));
10.     }
11. }
13. // 全局异常处理器
14. @ControllerAdvice
15. public class GlobalExceptionHandler {
16.    
17.     private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
18.    
19.     // 处理资源未找到异常
20.     @ExceptionHandler(ResourceNotFoundException.class)
21.     public ResponseEntity<ErrorResponse> handleResourceNotFound(ResourceNotFoundException ex) {
22.         ErrorResponse errorResponse = new ErrorResponse(
23.                 HttpStatus.NOT_FOUND.value(),
24.                 ex.getMessage(),
25.                 System.currentTimeMillis()
26.         );
27.         
28.         logger.error("Resource not found: {}", ex.getMessage());
29.         return new ResponseEntity<>(errorResponse, HttpStatus.NOT_FOUND);
30.     }
31.    
32.     // 处理验证异常
33.     @ExceptionHandler(MethodArgumentNotValidException.class)
34.     public ResponseEntity<ErrorResponse> handleValidationExceptions(MethodArgumentNotValidException ex) {
35.         List<String> errors = ex.getBindingResult()
36.                 .getFieldErrors()
37.                 .stream()
38.                 .map(error -> error.getField() + ": " + error.getDefaultMessage())
39.                 .collect(Collectors.toList());
40.         
41.         ErrorResponse errorResponse = new ErrorResponse(
42.                 HttpStatus.BAD_REQUEST.value(),
43.                 "Validation failed",
44.                 errors,
45.                 System.currentTimeMillis()
46.         );
47.         
48.         logger.error("Validation error: {}", errors);
49.         return new ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);
50.     }
51.    
52.     // 处理所有其他异常
53.     @ExceptionHandler(Exception.class)
54.     public ResponseEntity<ErrorResponse> handleAllExceptions(Exception ex) {
55.         ErrorResponse errorResponse = new ErrorResponse(
56.                 HttpStatus.INTERNAL_SERVER_ERROR.value(),
57.                 "An unexpected error occurred",
58.                 System.currentTimeMillis()
59.         );
60.         
61.         logger.error("Unexpected error: {}", ex.getMessage(), ex);
62.         return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
63.     }
64. }
66. // 错误响应DTO
67. public class ErrorResponse {
68.     private int status;
69.     private String message;
70.     private List<String> errors;
71.     private long timestamp;
72.    
73.     // 构造函数、getters和setters
74. }

复制代码

4. 测试策略

全面的测试是确保应用质量的关键。AntiX框架支持多种测试类型，包括单元测试、集成测试和端到端测试。

2. // 单元测试示例
3. @RunWith(MockitoJUnitRunner.class)
4. public class UserServiceTest {
5.    
6.     @Mock
7.     private UserRepository userRepository;
8.    
9.     @Mock
10.     private UserMapper userMapper;
11.    
12.     @InjectMocks
13.     private UserServiceImpl userService;
14.    
15.     @Test
16.     public void testGetUserById() {
17.         // 准备测试数据
18.         User user = new User();
19.         user.setId(1L);
20.         user.setUsername("testuser");
21.         user.setEmail("test@example.com");
22.         
23.         UserDto userDto = new UserDto();
24.         userDto.setId(1L);
25.         userDto.setUsername("testuser");
26.         userDto.setEmail("test@example.com");
27.         
28.         // 模拟依赖行为
29.         when(userRepository.findById(1L)).thenReturn(Optional.of(user));
30.         when(userMapper.toDto(user)).thenReturn(userDto);
31.         
32.         // 调用测试方法
33.         UserDto result = userService.getUserById(1L);
34.         
35.         // 验证结果
36.         assertNotNull(result);
37.         assertEquals(1L, result.getId().longValue());
38.         assertEquals("testuser", result.getUsername());
39.         assertEquals("test@example.com", result.getEmail());
40.         
41.         // 验证依赖调用
42.         verify(userRepository).findById(1L);
43.         verify(userMapper).toDto(user);
44.     }
45.    
46.     @Test(expected = ResourceNotFoundException.class)
47.     public void testGetUserByIdNotFound() {
48.         // 模拟依赖行为
49.         when(userRepository.findById(1L)).thenReturn(Optional.empty());
50.         
51.         // 调用测试方法，预期抛出异常
52.         userService.getUserById(1L);
53.         
54.         // 验证依赖调用
55.         verify(userRepository).findById(1L);
56.         verify(userMapper, never()).toDto(any());
57.     }
58. }
60. // 集成测试示例
61. @RunWith(SpringRunner.class)
62. @SpringBootTest
63. @AutoConfigureMockMvc
64. @Transactional
65. public class UserControllerIntegrationTest {
66.    
67.     @Autowired
68.     private MockMvc mockMvc;
69.    
70.     @Autowired
71.     private UserRepository userRepository;
72.    
73.     @Test
74.     public void testGetUserById() throws Exception {
75.         // 准备测试数据
76.         User user = new User();
77.         user.setUsername("testuser");
78.         user.setEmail("test@example.com");
79.         user.setPassword("password");
80.         user = userRepository.save(user);
81.         
82.         // 执行测试请求
83.         mockMvc.perform(get("/api/users/{id}", user.getId()))
84.                 .andExpect(status().isOk())
85.                 .andExpect(jsonPath("$.id").value(user.getId()))
86.                 .andExpect(jsonPath("$.username").value("testuser"))
87.                 .andExpect(jsonPath("$.email").value("test@example.com"));
88.     }
89.    
90.     @Test
91.     public void testCreateUser() throws Exception {
92.         // 准备测试数据
93.         String userJson = "{"username":"newuser","email":"newuser@example.com","password":"password"}";
94.         
95.         // 执行测试请求
96.         mockMvc.perform(post("/api/users")
97.                 .contentType(MediaType.APPLICATION_JSON)
98.                 .content(userJson))
99.                 .andExpect(status().isCreated())
100.                 .andExpect(jsonPath("$.username").value("newuser"))
101.                 .andExpect(jsonPath("$.email").value("newuser@example.com"));
102.         
103.         // 验证数据库中的数据
104.         User savedUser = userRepository.findByUsername("newuser");
105.         assertNotNull(savedUser);
106.         assertEquals("newuser@example.com", savedUser.getEmail());
107.     }
108. }

复制代码

5. 性能优化

性能优化是构建高效企业级应用的关键。以下是AntiX框架中的一些性能优化策略：

2. // 使用缓存优化查询性能
3. @Service
4. public class ProductServiceImpl implements ProductService {
5.    
6.     private final ProductRepository productRepository;
7.    
8.     @Autowired
9.     public ProductServiceImpl(ProductRepository productRepository) {
10.         this.productRepository = productRepository;
11.     }
12.    
13.     @Override
14.     @Cacheable(value = "products", key = "#id")
15.     public Product getProductById(Long id) {
16.         return productRepository.findById(id).orElse(null);
17.     }
18.    
19.     @Override
20.     @Cacheable(value = "products", key = "'category:' + #category")
21.     public List<Product> getProductsByCategory(String category) {
22.         return productRepository.findByCategory(category);
23.     }
24.    
25.     @Override
26.     @Caching(
27.         put = @CachePut(value = "products", key = "#product.id"),
28.         evict = @CacheEvict(value = "products", key = "'category:' + #product.category")
29.     )
30.     public Product updateProduct(Product product) {
31.         return productRepository.save(product);
32.     }
33. }
35. // 使用异步处理提高吞吐量
36. @Service
37. public class NotificationServiceImpl implements NotificationService {
38.    
39.     private static final Logger logger = LoggerFactory.getLogger(NotificationServiceImpl.class);
40.    
41.     @Override
42.     @Async
43.     public void sendEmail(String to, String subject, String body) {
44.         // 模拟发送邮件的耗时操作
45.         try {
46.             Thread.sleep(1000);
47.             logger.info("Email sent to {} with subject: {}", to, subject);
48.         } catch (InterruptedException e) {
49.             Thread.currentThread().interrupt();
50.         }
51.     }
52.    
53.     @Override
54.     @Async("taskExecutor")
55.     public Future<String> sendSms(String phoneNumber, String message) {
56.         // 模拟发送短信的耗时操作
57.         try {
58.             Thread.sleep(500);
59.             String result = "SMS sent to " + phoneNumber;
60.             logger.info(result);
61.             return new AsyncResult<>(result);
62.         } catch (InterruptedException e) {
63.             Thread.currentThread().interrupt();
64.             return new AsyncResult<>("Failed to send SMS due to interruption");
65.         }
66.     }
67. }
69. // 配置异步任务执行器
70. @Configuration
71. @EnableAsync
72. public class AsyncConfig implements AsyncConfigurer {
73.    
74.     @Override
75.     public Executor getAsyncExecutor() {
76.         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
77.         executor.setCorePoolSize(5);
78.         executor.setMaxPoolSize(10);
79.         executor.setQueueCapacity(25);
80.         executor.setThreadNamePrefix("AntiX-Async-");
81.         executor.initialize();
82.         return executor;
83.     }
84.    
85.     @Bean(name = "taskExecutor")
86.     public Executor taskExecutor() {
87.         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
88.         executor.setCorePoolSize(10);
89.         executor.setMaxPoolSize(20);
90.         executor.setQueueCapacity(50);
91.         executor.setThreadNamePrefix("AntiX-Task-");
92.         executor.initialize();
93.         return executor;
94.     }
95. }

复制代码

真实项目案例分析

案例1：电子商务平台

某大型零售企业需要构建一个高性能、高可用的电子商务平台，支持每日百万级别的用户访问和交易处理。平台需要包括商品管理、订单处理、用户管理、支付集成等核心功能。

1. 高并发处理：特别是在促销活动期间，系统需要处理大量并发请求
2. 数据一致性：确保订单、库存和支付数据的一致性
3. 系统扩展性：随着业务增长，系统需要能够水平扩展
4. 用户体验：确保页面加载速度和交易流程的流畅性

2. // 商品服务
3. @SpringBootApplication
4. @EnableDiscoveryClient
5. @EnableCaching
6. public class ProductServiceApplication {
7.     public static void main(String[] args) {
8.         SpringApplication.run(ProductServiceApplication.class, args);
9.     }
10. }
12. // 订单服务
13. @SpringBootApplication
14. @EnableDiscoveryClient
15. @EnableCaching
16. public class OrderServiceApplication {
17.     public static void main(String[] args) {
18.         SpringApplication.run(OrderServiceApplication.class, args);
19.     }
20. }
22. // 用户服务
23. @SpringBootApplication
24. @EnableDiscoveryClient
25. @EnableCaching
26. public class UserServiceApplication {
27.     public static void main(String[] args) {
28.         SpringApplication.run(UserServiceApplication.class, args);
29.     }
30. }

复制代码

2. // 使用分布式锁处理高并发场景
3. @Service
4. public class InventoryServiceImpl implements InventoryService {
5.    
6.     private final InventoryRepository inventoryRepository;
7.     private final RedisTemplate<String, String> redisTemplate;
8.    
9.     @Autowired
10.     public InventoryServiceImpl(InventoryRepository inventoryRepository, RedisTemplate<String, String> redisTemplate) {
11.         this.inventoryRepository = inventoryRepository;
12.         this.redisTemplate = redisTemplate;
13.     }
14.    
15.     @Override
16.     @Transactional
17.     public boolean reduceInventory(Long productId, int quantity) {
18.         String lockKey = "inventory_lock:" + productId;
19.         String requestId = UUID.randomUUID().toString();
20.         
21.         try {
22.             // 获取分布式锁
23.             boolean locked = acquireLock(lockKey, requestId, 10);
24.             if (!locked) {
25.                 throw new BusinessException("Failed to acquire lock for product: " + productId);
26.             }
27.             
28.             // 检查库存
29.             Inventory inventory = inventoryRepository.findByProductId(productId);
30.             if (inventory == null || inventory.getQuantity() < quantity) {
31.                 return false;
32.             }
33.             
34.             // 减少库存
35.             inventory.setQuantity(inventory.getQuantity() - quantity);
36.             inventoryRepository.save(inventory);
37.             
38.             return true;
39.         } finally {
40.             // 释放锁
41.             releaseLock(lockKey, requestId);
42.         }
43.     }
44.    
45.     private boolean acquireLock(String lockKey, String requestId, int expireTime) {
46.         return Boolean.TRUE.equals(redisTemplate.opsForValue().setIfAbsent(lockKey, requestId, expireTime, TimeUnit.SECONDS));
47.     }
48.    
49.     private boolean releaseLock(String lockKey, String requestId) {
50.         String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
51.         DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
52.         Long result = redisTemplate.execute(redisScript, Collections.singletonList(lockKey), requestId);
53.         return result != null && result == 1;
54.     }
55. }

复制代码

2. // 订单创建事件
3. public class OrderCreatedEvent {
4.     private final Order order;
5.     private final LocalDateTime createdAt;
6.    
7.     public OrderCreatedEvent(Order order) {
8.         this.order = order;
9.         this.createdAt = LocalDateTime.now();
10.     }
11.    
12.     // getters
13. }
15. // 订单服务发布事件
16. @Service
17. public class OrderServiceImpl implements OrderService {
18.    
19.     private final OrderRepository orderRepository;
20.     private final ApplicationEventPublisher eventPublisher;
21.    
22.     @Autowired
23.     public OrderServiceImpl(OrderRepository orderRepository, ApplicationEventPublisher eventPublisher) {
24.         this.orderRepository = orderRepository;
25.         this.eventPublisher = eventPublisher;
26.     }
27.    
28.     @Override
29.     @Transactional
30.     public Order createOrder(Order order) {
31.         // 保存订单
32.         order = orderRepository.save(order);
33.         
34.         // 发布订单创建事件
35.         eventPublisher.publishEvent(new OrderCreatedEvent(order));
36.         
37.         return order;
38.     }
39. }
41. // 库存服务监听事件
42. @Service
43. public class InventoryEventListener {
44.    
45.     private final InventoryService inventoryService;
46.    
47.     @Autowired
48.     public InventoryEventListener(InventoryService inventoryService) {
49.         this.inventoryService = inventoryService;
50.     }
51.    
52.     @EventListener
53.     @Async
54.     public void handleOrderCreatedEvent(OrderCreatedEvent event) {
55.         Order order = event.getOrder();
56.         
57.         // 减少库存
58.         for (OrderItem item : order.getItems()) {
59.             boolean success = inventoryService.reduceInventory(item.getProductId(), item.getQuantity());
60.             if (!success) {
61.                 // 库存不足，处理回滚逻辑
62.                 throw new InsufficientInventoryException("Insufficient inventory for product: " + item.getProductId());
63.             }
64.         }
65.     }
66. }
68. // 支付服务监听事件
69. @Service
70. public class PaymentEventListener {
71.    
72.     private final PaymentService paymentService;
73.    
74.     @Autowired
75.     public PaymentEventListener(PaymentService paymentService) {
76.         this.paymentService = paymentService;
77.     }
78.    
79.     @EventListener
80.     @Async
81.     public void handleOrderCreatedEvent(OrderCreatedEvent event) {
82.         Order order = event.getOrder();
83.         
84.         // 处理支付
85.         PaymentResult result = paymentService.processPayment(order);
86.         if (!result.isSuccess()) {
87.             // 支付失败，处理回滚逻辑
88.             throw new PaymentFailedException("Payment failed for order: " + order.getId());
89.         }
90.     }
91. }

复制代码

2. // 商品缓存配置
3. @Configuration
4. @EnableCaching
5. public class CacheConfig {
6.    
7.     @Bean
8.     public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
9.         RedisCacheConfiguration defaultConfig = RedisCacheConfiguration.defaultCacheConfig()
10.                 .entryTtl(Duration.ofMinutes(30))
11.                 .disableCachingNullValues()
12.                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
13.         
14.         // 商品缓存配置
15.         RedisCacheConfiguration productCacheConfig = RedisCacheConfiguration.defaultCacheConfig()
16.                 .entryTtl(Duration.ofHours(1))
17.                 .disableCachingNullValues()
18.                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
19.         
20.         Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
21.         cacheConfigurations.put("products", productCacheConfig);
22.         
23.         return RedisCacheManager.builder(redisConnectionFactory)
24.                 .cacheDefaults(defaultConfig)
25.                 .withInitialCacheConfigurations(cacheConfigurations)
26.                 .build();
27.     }
28. }
30. // 商品服务实现
31. @Service
32. public class ProductServiceImpl implements ProductService {
33.    
34.     private final ProductRepository productRepository;
35.    
36.     @Autowired
37.     public ProductServiceImpl(ProductRepository productRepository) {
38.         this.productRepository = productRepository;
39.     }
40.    
41.     @Override
42.     @Cacheable(value = "products", key = "#id")
43.     public Product getProductById(Long id) {
44.         return productRepository.findById(id).orElse(null);
45.     }
46.    
47.     @Override
48.     @Cacheable(value = "products", key = "'category:' + #category + ':page:' + #page + ':size:' + #size")
49.     public Page<Product> getProductsByCategory(String category, int page, int size) {
50.         Pageable pageable = PageRequest.of(page, size, Sort.by("name").ascending());
51.         return productRepository.findByCategory(category, pageable);
52.     }
53.    
54.     @Override
55.     @Caching(
56.         put = @CachePut(value = "products", key = "#product.id"),
57.         evict = {
58.             @CacheEvict(value = "products", key = "'category:' + #product.category + ':page:*'"),
59.             @CacheEvict(value = "products", key = "'featured'")
60.         }
61.     )
62.     public Product updateProduct(Product product) {
63.         return productRepository.save(product);
64.     }
65.    
66.     @Override
67.     @CacheEvict(value = "products", allEntries = true)
68.     public void refreshProductCache() {
69.         // 清除所有产品缓存
70.     }
71. }

复制代码

通过使用AntiX框架，该电子商务平台成功实现了以下目标：

1. 高并发处理能力：系统能够平稳处理每秒5000+的请求峰值，促销活动期间无宕机情况
2. 数据一致性：通过分布式事务和事件驱动架构，确保了订单、库存和支付数据的一致性
3. 系统扩展性：采用微服务架构，各服务可独立扩展，系统整体吞吐量提升了3倍
4. 用户体验提升：页面加载时间从平均3秒减少到800毫秒，用户转化率提高了25%

案例2：金融风控系统

一家大型金融机构需要构建一个实时风控系统，用于检测和预防金融交易中的欺诈行为。系统需要能够实时分析大量交易数据，识别可疑模式，并采取相应措施。

1. 实时数据处理：需要在毫秒级别处理大量交易数据
2. 复杂规则引擎：需要实现灵活且高效的风控规则
3. 高可用性：系统需要7x24小时不间断运行
4. 数据安全：确保敏感金融数据的安全性和合规性

2. // 交易事件处理器
3. @Service
4. public class TransactionEventHandler {
5.    
6.     private final RiskRuleEngine ruleEngine;
7.     private final AlertService alertService;
8.     private final TransactionRepository transactionRepository;
9.    
10.     @Autowired
11.     public TransactionEventHandler(RiskRuleEngine ruleEngine, AlertService alertService,
12.                                  TransactionRepository transactionRepository) {
13.         this.ruleEngine = ruleEngine;
14.         this.alertService = alertService;
15.         this.transactionRepository = transactionRepository;
16.     }
17.    
18.     @EventListener
19.     @Async("transactionProcessor")
20.     public void handleTransactionEvent(TransactionEvent event) {
21.         Transaction transaction = event.getTransaction();
22.         
23.         // 保存交易记录
24.         transactionRepository.save(transaction);
25.         
26.         // 执行风控规则
27.         RiskAssessmentResult result = ruleEngine.assessRisk(transaction);
28.         
29.         // 根据风险等级采取相应措施
30.         if (result.getRiskLevel() == RiskLevel.HIGH) {
31.             // 高风险交易，阻止并生成警报
32.             blockTransaction(transaction);
33.             alertService.createHighRiskAlert(transaction, result);
34.         } else if (result.getRiskLevel() == RiskLevel.MEDIUM) {
35.             // 中等风险交易，需要人工审核
36.             alertService.createMediumRiskAlert(transaction, result);
37.         }
38.         
39.         // 更新交易状态
40.         updateTransactionStatus(transaction, result);
41.     }
42.    
43.     private void blockTransaction(Transaction transaction) {
44.         // 阻止交易的逻辑
45.         transaction.setStatus(TransactionStatus.BLOCKED);
46.         transactionRepository.save(transaction);
47.     }
48.    
49.     private void updateTransactionStatus(Transaction transaction, RiskAssessmentResult result) {
50.         // 更新交易状态的逻辑
51.         if (transaction.getStatus() != TransactionStatus.BLOCKED) {
52.             transaction.setStatus(TransactionStatus.COMPLETED);
53.             transaction.setRiskScore(result.getScore());
54.             transactionRepository.save(transaction);
55.         }
56.     }
57. }
59. // 配置异步任务处理器
60. @Configuration
61. @EnableAsync
62. public class AsyncConfig {
63.    
64.     @Bean(name = "transactionProcessor")
65.     public Executor transactionProcessor() {
66.         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
67.         executor.setCorePoolSize(10);
68.         executor.setMaxPoolSize(50);
69.         executor.setQueueCapacity(1000);
70.         executor.setThreadNamePrefix("TransactionProcessor-");
71.         executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
72.         executor.initialize();
73.         return executor;
74.     }
75. }

复制代码

2. // 风控规则接口
3. public interface RiskRule {
4.     String getName();
5.     RiskAssessmentResult evaluate(Transaction transaction);
6. }
8. // 规则引擎实现
9. @Service
10. public class RiskRuleEngineImpl implements RiskRuleEngine {
11.    
12.     private final List<RiskRule> rules;
13.    
14.     @Autowired
15.     public RiskRuleEngineImpl(List<RiskRule> rules) {
16.         this.rules = rules;
17.     }
18.    
19.     @Override
20.     public RiskAssessmentResult assessRisk(Transaction transaction) {
21.         int totalScore = 0;
22.         List<String> triggeredRules = new ArrayList<>();
23.         
24.         // 执行所有规则
25.         for (RiskRule rule : rules) {
26.             RiskAssessmentResult result = rule.evaluate(transaction);
27.             if (result.getScore() > 0) {
28.                 totalScore += result.getScore();
29.                 triggeredRules.add(rule.getName());
30.             }
31.         }
32.         
33.         // 确定风险等级
34.         RiskLevel riskLevel = determineRiskLevel(totalScore);
35.         
36.         return new RiskAssessmentResult(totalScore, riskLevel, triggeredRules);
37.     }
38.    
39.     private RiskLevel determineRiskLevel(int score) {
40.         if (score >= 80) {
41.             return RiskLevel.HIGH;
42.         } else if (score >= 50) {
43.             return RiskLevel.MEDIUM;
44.         } else {
45.             return RiskLevel.LOW;
46.         }
47.     }
48. }
50. // 示例规则：大额交易检测
51. @Component
52. public class LargeAmountRule implements RiskRule {
53.    
54.     private static final int THRESHOLD = 10000; // 10,000元
55.     private static final int SCORE = 30;
56.    
57.     @Override
58.     public String getName() {
59.         return "LargeAmountRule";
60.     }
61.    
62.     @Override
63.     public RiskAssessmentResult evaluate(Transaction transaction) {
64.         if (transaction.getAmount().compareTo(BigDecimal.valueOf(THRESHOLD)) > 0) {
65.             return new RiskAssessmentResult(SCORE, RiskLevel.MEDIUM, Collections.singletonList(getName()));
66.         }
67.         return new RiskAssessmentResult(0, RiskLevel.LOW, Collections.emptyList());
68.     }
69. }
71. // 示例规则：异常地点检测
72. @Component
73. public class UnusualLocationRule implements RiskRule {
74.    
75.     private final UserLocationHistoryRepository locationHistoryRepository;
76.    
77.     @Autowired
78.     public UnusualLocationRule(UserLocationHistoryRepository locationHistoryRepository) {
79.         this.locationHistoryRepository = locationHistoryRepository;
80.     }
81.    
82.     @Override
83.     public String getName() {
84.         return "UnusualLocationRule";
85.     }
86.    
87.     @Override
88.     public RiskAssessmentResult evaluate(Transaction transaction) {
89.         // 获取用户历史交易地点
90.         List<String> usualLocations = locationHistoryRepository.findFrequentLocations(transaction.getUserId());
91.         
92.         // 检查当前交易地点是否在常见地点中
93.         if (!usualLocations.contains(transaction.getLocation())) {
94.             return new RiskAssessmentResult(40, RiskLevel.MEDIUM, Collections.singletonList(getName()));
95.         }
96.         return new RiskAssessmentResult(0, RiskLevel.LOW, Collections.emptyList());
97.     }
98. }
100. // 示例规则：高频交易检测
101. @Component
102. public class HighFrequencyRule implements RiskRule {
103.    
104.     private final TransactionRepository transactionRepository;
105.    
106.     @Autowired
107.     public HighFrequencyRule(TransactionRepository transactionRepository) {
108.         this.transactionRepository = transactionRepository;
109.     }
110.    
111.     @Override
112.     public String getName() {
113.         return "HighFrequencyRule";
114.     }
115.    
116.     @Override
117.     public RiskAssessmentResult evaluate(Transaction transaction) {
118.         // 检查过去1小时内的交易次数
119.         LocalDateTime oneHourAgo = LocalDateTime.now().minusHours(1);
120.         int transactionCount = transactionRepository.countByUserIdAndTimeAfter(
121.             transaction.getUserId(), oneHourAgo);
122.         
123.         // 如果过去1小时内交易超过5次，认为是高频交易
124.         if (transactionCount > 5) {
125.             return new RiskAssessmentResult(50, RiskLevel.HIGH, Collections.singletonList(getName()));
126.         }
127.         return new RiskAssessmentResult(0, RiskLevel.LOW, Collections.emptyList());
128.     }
129. }

复制代码

2. // 健康检查端点
3. @RestController
4. @RequestMapping("/api/health")
5. public class HealthCheckController {
6.    
7.     private final DatabaseHealthIndicator databaseHealthIndicator;
8.     private final RedisHealthIndicator redisHealthIndicator;
9.     private final KafkaHealthIndicator kafkaHealthIndicator;
10.    
11.     @Autowired
12.     public HealthCheckController(DatabaseHealthIndicator databaseHealthIndicator,
13.                                RedisHealthIndicator redisHealthIndicator,
14.                                KafkaHealthIndicator kafkaHealthIndicator) {
15.         this.databaseHealthIndicator = databaseHealthIndicator;
16.         this.redisHealthIndicator = redisHealthIndicator;
17.         this.kafkaHealthIndicator = kafkaHealthIndicator;
18.     }
19.    
20.     @GetMapping
21.     public ResponseEntity<Map<String, Object>> health() {
22.         Map<String, Object> healthStatus = new HashMap<>();
23.         
24.         // 检查数据库状态
25.         Health dbHealth = databaseHealthIndicator.health();
26.         healthStatus.put("database", dbHealth.getStatus());
27.         
28.         // 检查Redis状态
29.         Health redisHealth = redisHealthIndicator.health();
30.         healthStatus.put("redis", redisHealth.getStatus());
31.         
32.         // 检查Kafka状态
33.         Health kafkaHealth = kafkaHealthIndicator.health();
34.         healthStatus.put("kafka", kafkaHealth.getStatus());
35.         
36.         // 确定整体状态
37.         Status overallStatus = Status.UP;
38.         for (Object status : healthStatus.values()) {
39.             if (status != Status.UP) {
40.                 overallStatus = Status.DOWN;
41.                 break;
42.             }
43.         }
44.         
45.         healthStatus.put("status", overallStatus);
46.         healthStatus.put("timestamp", System.currentTimeMillis());
47.         
48.         HttpStatus httpStatus = overallStatus == Status.UP ? HttpStatus.OK : HttpStatus.SERVICE_UNAVAILABLE;
49.         return ResponseEntity.status(httpStatus).body(healthStatus);
50.     }
51. }
53. // 数据库健康指示器
54. @Component
55. public class DatabaseHealthIndicator implements HealthIndicator {
56.    
57.     private final DataSource dataSource;
58.    
59.     @Autowired
60.     public DatabaseHealthIndicator(DataSource dataSource) {
61.         this.dataSource = dataSource;
62.     }
63.    
64.     @Override
65.     public Health health() {
66.         try (Connection connection = dataSource.getConnection()) {
67.             if (connection.isValid(1)) {
68.                 return Health.up().withDetail("database", "Available").build();
69.             } else {
70.                 return Health.down().withDetail("database", "Connection is not valid").build();
71.             }
72.         } catch (SQLException e) {
73.             return Health.down().withException(e).build();
74.         }
75.     }
76. }
78. // Redis健康指示器
79. @Component
80. public class RedisHealthIndicator implements HealthIndicator {
81.    
82.     private final RedisConnectionFactory redisConnectionFactory;
83.    
84.     @Autowired
85.     public RedisHealthIndicator(RedisConnectionFactory redisConnectionFactory) {
86.         this.redisConnectionFactory = redisConnectionFactory;
87.     }
88.    
89.     @Override
90.     public Health health() {
91.         try {
92.             RedisConnection connection = redisConnectionFactory.getConnection();
93.             String info = connection.info();
94.             connection.close();
95.             
96.             return Health.up().withDetail("redis", "Available").build();
97.         } catch (Exception e) {
98.             return Health.down().withException(e).build();
99.         }
100.     }
101. }
103. // 断路器模式实现
104. @Service
105. public class ExternalRiskServiceProxy {
106.    
107.     private final ExternalRiskService externalRiskService;
108.     private final CircuitBreaker circuitBreaker;
109.    
110.     @Autowired
111.     public ExternalRiskServiceProxy(ExternalRiskService externalRiskService) {
112.         this.externalRiskService = externalRiskService;
113.         
114.         // 配置断路器
115.         CircuitBreakerConfig config = CircuitBreakerConfig.custom()
116.                 .failureRateThreshold(50)
117.                 .waitDurationInOpenState(Duration.ofSeconds(30))
118.                 .ringBufferSizeInHalfOpenState(10)
119.                 .ringBufferSizeInClosedState(100)
120.                 .build();
121.         
122.         this.circuitBreaker = CircuitBreaker.of("externalRiskService", config);
123.     }
124.    
125.     public RiskData getExternalRiskData(String userId) {
126.         return circuitBreaker.executeSupplier(() -> externalRiskService.getRiskData(userId));
127.     }
128. }

复制代码

2. // 数据加密服务
3. @Service
4. public class EncryptionServiceImpl implements EncryptionService {
5.    
6.     private final String encryptionKey;
7.    
8.     @Autowired
9.     public EncryptionServiceImpl(@Value("${app.encryption.key}") String encryptionKey) {
10.         this.encryptionKey = encryptionKey;
11.     }
12.    
13.     @Override
14.     public String encrypt(String data) {
15.         try {
16.             Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
17.             SecretKeySpec keySpec = new SecretKeySpec(encryptionKey.getBytes(), "AES");
18.             GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(128, new byte[12]);
19.             
20.             cipher.init(Cipher.ENCRYPT_MODE, keySpec, gcmParameterSpec);
21.             byte[] encryptedData = cipher.doFinal(data.getBytes());
22.             
23.             return Base64.getEncoder().encodeToString(encryptedData);
24.         } catch (Exception e) {
25.             throw new EncryptionException("Failed to encrypt data", e);
26.         }
27.     }
28.    
29.     @Override
30.     public String decrypt(String encryptedData) {
31.         try {
32.             Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
33.             SecretKeySpec keySpec = new SecretKeySpec(encryptionKey.getBytes(), "AES");
34.             GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(128, new byte[12]);
35.             
36.             cipher.init(Cipher.DECRYPT_MODE, keySpec, gcmParameterSpec);
37.             byte[] decodedData = Base64.getDecoder().decode(encryptedData);
38.             byte[] decryptedData = cipher.doFinal(decodedData);
39.             
40.             return new String(decryptedData);
41.         } catch (Exception e) {
42.             throw new EncryptionException("Failed to decrypt data", e);
43.         }
44.     }
45. }
47. // 敏感数据处理器
48. @Aspect
49. @Component
50. public class SensitiveDataAspect {
51.    
52.     private final EncryptionService encryptionService;
53.    
54.     @Autowired
55.     public SensitiveDataAspect(EncryptionService encryptionService) {
56.         this.encryptionService = encryptionService;
57.     }
58.    
59.     @Around("@annotation(SensitiveData)")
60.     public Object handleSensitiveData(ProceedingJoinPoint joinPoint) throws Throwable {
61.         Object result = joinPoint.proceed();
62.         
63.         // 处理返回结果中的敏感数据
64.         if (result instanceof Transaction) {
65.             Transaction transaction = (Transaction) result;
66.             // 加密敏感字段
67.             if (transaction.getCardNumber() != null) {
68.                 transaction.setCardNumber(encryptionService.encrypt(transaction.getCardNumber()));
69.             }
70.             if (transaction.getAccountNumber() != null) {
71.                 transaction.setAccountNumber(encryptionService.encrypt(transaction.getAccountNumber()));
72.             }
73.         }
74.         
75.         return result;
76.     }
77. }
79. // 审计日志服务
80. @Service
81. public class AuditLogServiceImpl implements AuditLogService {
82.    
83.     private final AuditLogRepository auditLogRepository;
84.    
85.     @Autowired
86.     public AuditLogServiceImpl(AuditLogRepository auditLogRepository) {
87.         this.auditLogRepository = auditLogRepository;
88.     }
89.    
90.     @Override
91.     @Async
92.     public void logAction(String userId, String action, String details) {
93.         AuditLog auditLog = new AuditLog();
94.         auditLog.setUserId(userId);
95.         auditLog.setAction(action);
96.         auditLog.setDetails(details);
97.         auditLog.setTimestamp(LocalDateTime.now());
98.         
99.         auditLogRepository.save(auditLog);
100.     }
101.    
102.     @Override
103.     public Page<AuditLog> getAuditLogs(String userId, LocalDateTime startTime, LocalDateTime endTime,
104.                                       Pageable pageable) {
105.         if (startTime != null && endTime != null) {
106.             return auditLogRepository.findByUserIdAndTimestampBetween(userId, startTime, endTime, pageable);
107.         } else if (startTime != null) {
108.             return auditLogRepository.findByUserIdAndTimestampAfter(userId, startTime, pageable);
109.         } else if (endTime != null) {
110.             return auditLogRepository.findByUserIdAndTimestampBefore(userId, endTime, pageable);
111.         } else {
112.             return auditLogRepository.findByUserId(userId, pageable);
113.         }
114.     }
115. }

复制代码

通过使用AntiX框架，该金融风控系统成功实现了以下目标：

1. 实时处理能力：系统能够在100毫秒内完成交易风险评估，支持每秒10000+的交易处理量
2. 灵活的规则引擎：实现了可插拔的风控规则，新规则可在不重启系统的情况下动态加载
3. 高可用性：系统实现了99.99%的可用性，全年非计划停机时间不超过52分钟
4. 数据安全合规：所有敏感数据均加密存储，系统通过了金融行业的安全合规审计

构建稳定高效企业级应用的策略

1. 架构设计原则

AntiX框架支持领域驱动设计方法，帮助开发团队构建与业务领域紧密匹配的应用架构。

2. // 值对象 - 金额
3. public class Money {
4.     private final BigDecimal amount;
5.     private final Currency currency;
6.    
7.     public Money(BigDecimal amount, Currency currency) {
8.         if (amount == null || currency == null) {
9.             throw new IllegalArgumentException("Amount and currency cannot be null");
10.         }
11.         if (amount.compareTo(BigDecimal.ZERO) < 0) {
12.             throw new IllegalArgumentException("Amount cannot be negative");
13.         }
14.         
15.         this.amount = amount;
16.         this.currency = currency;
17.     }
18.    
19.     // 业务方法
20.     public Money add(Money other) {
21.         if (!this.currency.equals(other.currency)) {
22.             throw new IllegalArgumentException("Cannot add money with different currencies");
23.         }
24.         return new Money(this.amount.add(other.amount), this.currency);
25.     }
26.    
27.     public Money subtract(Money other) {
28.         if (!this.currency.equals(other.currency)) {
29.             throw new IllegalArgumentException("Cannot subtract money with different currencies");
30.         }
31.         BigDecimal newAmount = this.amount.subtract(other.amount);
32.         if (newAmount.compareTo(BigDecimal.ZERO) < 0) {
33.             throw new IllegalArgumentException("Insufficient funds");
34.         }
35.         return new Money(newAmount, this.currency);
36.     }
37.    
38.     // getters
39. }
41. // 聚合根 - 订单
42. @Entity
43. @Table(name = "orders")
44. public class Order {
45.     @Id
46.     @GeneratedValue(strategy = GenerationType.IDENTITY)
47.     private Long id;
48.    
49.     @Embedded
50.     private OrderId orderId;
51.    
52.     @Embedded
53.     private CustomerId customerId;
54.    
55.     @ElementCollection
56.     @CollectionTable(name = "order_items", joinColumns = @JoinColumn(name = "order_id"))
57.     private List<OrderItem> items = new ArrayList<>();
58.    
59.     @Embedded
60.     private Money totalAmount;
61.    
62.     @Enumerated(EnumType.STRING)
63.     private OrderStatus status;
64.    
65.     @CreationTimestamp
66.     private LocalDateTime createdAt;
67.    
68.     @UpdateTimestamp
69.     private LocalDateTime updatedAt;
70.    
71.     // 业务方法
72.     public void addItem(Product product, int quantity) {
73.         if (status != OrderStatus.NEW) {
74.             throw new IllegalStateException("Cannot add items to an order that is not in NEW status");
75.         }
76.         
77.         OrderItem item = new OrderItem(product.getId(), product.getName(), product.getPrice(), quantity);
78.         items.add(item);
79.         recalculateTotal();
80.     }
81.    
82.     public void removeItem(Long productId) {
83.         if (status != OrderStatus.NEW) {
84.             throw new IllegalStateException("Cannot remove items from an order that is not in NEW status");
85.         }
86.         
87.         items.removeIf(item -> item.getProductId().equals(productId));
88.         recalculateTotal();
89.     }
90.    
91.     public void confirm() {
92.         if (items.isEmpty()) {
93.             throw new IllegalStateException("Cannot confirm an empty order");
94.         }
95.         this.status = OrderStatus.CONFIRMED;
96.     }
97.    
98.     public void cancel() {
99.         if (status == OrderStatus.SHIPPED || status == OrderStatus.DELIVERED) {
100.             throw new IllegalStateException("Cannot cancel an order that has been shipped or delivered");
101.         }
102.         this.status = OrderStatus.CANCELLED;
103.     }
104.    
105.     private void recalculateTotal() {
106.         BigDecimal total = items.stream()
107.                 .map(item -> item.getUnitPrice().multiply(BigDecimal.valueOf(item.getQuantity())))
108.                 .reduce(BigDecimal.ZERO, BigDecimal::add);
109.         
110.         this.totalAmount = new Money(total, items.get(0).getUnitPrice().getCurrency());
111.     }
112.    
113.     // getters
114. }
116. // 仓储接口
117. public interface OrderRepository {
118.     Order save(Order order);
119.     Optional<Order> findById(OrderId orderId);
120.     List<Order> findByCustomerId(CustomerId customerId);
121. }
123. // 仓储实现
124. @Repository
125. public class OrderRepositoryImpl implements OrderRepository {
126.    
127.     @PersistenceContext
128.     private EntityManager entityManager;
129.    
130.     @Override
131.     public Order save(Order order) {
132.         if (order.getId() == null) {
133.             entityManager.persist(order);
134.             return order;
135.         } else {
136.             return entityManager.merge(order);
137.         }
138.     }
139.    
140.     @Override
141.     public Optional<Order> findById(OrderId orderId) {
142.         try {
143.             Order order = entityManager.createQuery(
144.                     "SELECT o FROM Order o WHERE o.orderId = :orderId", Order.class)
145.                     .setParameter("orderId", orderId)
146.                     .getSingleResult();
147.             return Optional.of(order);
148.         } catch (NoResultException e) {
149.             return Optional.empty();
150.         }
151.     }
152.    
153.     @Override
154.     public List<Order> findByCustomerId(CustomerId customerId) {
155.         return entityManager.createQuery(
156.                 "SELECT o FROM Order o WHERE o.customerId = :customerId", Order.class)
157.                 .setParameter("customerId", customerId)
158.                 .getResultList();
159.     }
160. }
162. // 应用服务
163. @Service
164. @Transactional
165. public class OrderApplicationService {
166.    
167.     private final OrderRepository orderRepository;
168.     private final ProductRepository productRepository;
169.     private final OrderEventPublisher eventPublisher;
170.    
171.     @Autowired
172.     public OrderApplicationService(OrderRepository orderRepository,
173.                                  ProductRepository productRepository,
174.                                  OrderEventPublisher eventPublisher) {
175.         this.orderRepository = orderRepository;
176.         this.productRepository = productRepository;
177.         this.eventPublisher = eventPublisher;
178.     }
179.    
180.     public OrderId createOrder(CustomerId customerId) {
181.         Order order = new Order(OrderId.generate(), customerId);
182.         orderRepository.save(order);
183.         
184.         // 发布订单创建事件
185.         eventPublisher.publishOrderCreatedEvent(order);
186.         
187.         return order.getOrderId();
188.     }
189.    
190.     public void addProductToOrder(OrderId orderId, ProductId productId, int quantity) {
191.         Order order = orderRepository.findById(orderId)
192.                 .orElseThrow(() -> new OrderNotFoundException(orderId));
193.         
194.         Product product = productRepository.findById(productId)
195.                 .orElseThrow(() -> new ProductNotFoundException(productId));
196.         
197.         order.addItem(product, quantity);
198.         orderRepository.save(order);
199.         
200.         // 发布订单更新事件
201.         eventPublisher.publishOrderUpdatedEvent(order);
202.     }
203.    
204.     public void confirmOrder(OrderId orderId) {
205.         Order order = orderRepository.findById(orderId)
206.                 .orElseThrow(() -> new OrderNotFoundException(orderId));
207.         
208.         order.confirm();
209.         orderRepository.save(order);
210.         
211.         // 发布订单确认事件
212.         eventPublisher.publishOrderConfirmedEvent(order);
213.     }
214. }

复制代码

AntiX框架支持构建微服务架构，使应用能够模块化、可扩展且易于维护。

2. // 用户服务API
3. @FeignClient(name = "user-service", path = "/api/users")
4. public interface UserServiceClient {
5.    
6.     @GetMapping("/{id}")
7.     ResponseEntity<UserDto> getUserById(@PathVariable("id") Long id);
8.    
9.     @GetMapping("/search")
10.     ResponseEntity<List<UserDto>> searchUsers(@RequestParam("query") String query);
11.    
12.     @PostMapping
13.     ResponseEntity<UserDto> createUser(@RequestBody UserCreateDto userCreateDto);
14.    
15.     @PutMapping("/{id}")
16.     ResponseEntity<UserDto> updateUser(@PathVariable("id") Long id, @RequestBody UserUpdateDto userUpdateDto);
17.    
18.     @DeleteMapping("/{id}")
19.     ResponseEntity<Void> deleteUser(@PathVariable("id") Long id);
20. }
22. // 产品服务API
23. @FeignClient(name = "product-service", path = "/api/products")
24. public interface ProductServiceClient {
25.    
26.     @GetMapping("/{id}")
27.     ResponseEntity<ProductDto> getProductById(@PathVariable("id") Long id);
28.    
29.     @GetMapping("/category/{category}")
30.     ResponseEntity<List<ProductDto>> getProductsByCategory(@PathVariable("category") String category);
31.    
32.     @GetMapping("/search")
33.     ResponseEntity<Page<ProductDto>> searchProducts(@RequestParam("query") String query,
34.                                                    @RequestParam("page") int page,
35.                                                    @RequestParam("size") int size);
36.    
37.     @PostMapping
38.     ResponseEntity<ProductDto> createProduct(@RequestBody ProductCreateDto productCreateDto);
39.    
40.     @PutMapping("/{id}")
41.     ResponseEntity<ProductDto> updateProduct(@PathVariable("id") Long id, @RequestBody ProductUpdateDto productUpdateDto);
42.    
43.     @DeleteMapping("/{id}")
44.     ResponseEntity<Void> deleteProduct(@PathVariable("id") Long id);
45. }
47. // 订单服务实现
48. @Service
49. public class OrderServiceImpl implements OrderService {
50.    
51.     private final OrderRepository orderRepository;
52.     private final UserServiceClient userServiceClient;
53.     private final ProductServiceClient productServiceClient;
54.     private final OrderEventPublisher eventPublisher;
55.    
56.     @Autowired
57.     public OrderServiceImpl(OrderRepository orderRepository,
58.                           UserServiceClient userServiceClient,
59.                           ProductServiceClient productServiceClient,
60.                           OrderEventPublisher eventPublisher) {
61.         this.orderRepository = orderRepository;
62.         this.userServiceClient = userServiceClient;
63.         this.productServiceClient = productServiceClient;
64.         this.eventPublisher = eventPublisher;
65.     }
66.    
67.     @Override
68.     @Transactional
69.     public OrderDto createOrder(Long userId, List<OrderItemCreateDto> items) {
70.         // 验证用户存在
71.         ResponseEntity<UserDto> userResponse = userServiceClient.getUserById(userId);
72.         if (!userResponse.getStatusCode().is2xxSuccessful() || userResponse.getBody() == null) {
73.             throw new UserNotFoundException(userId);
74.         }
75.         
76.         // 创建订单
77.         Order order = new Order();
78.         order.setUserId(userId);
79.         order.setStatus(OrderStatus.NEW);
80.         order.setCreatedAt(LocalDateTime.now());
81.         
82.         // 添加订单项
83.         for (OrderItemCreateDto itemDto : items) {
84.             // 验证产品存在
85.             ResponseEntity<ProductDto> productResponse = productServiceClient.getProductById(itemDto.getProductId());
86.             if (!productResponse.getStatusCode().is2xxSuccessful() || productResponse.getBody() == null) {
87.                 throw new ProductNotFoundException(itemDto.getProductId());
88.             }
89.             
90.             ProductDto product = productResponse.getBody();
91.             OrderItem item = new OrderItem();
92.             item.setProductId(product.getId());
93.             item.setProductName(product.getName());
94.             item.setUnitPrice(product.getPrice());
95.             item.setQuantity(itemDto.getQuantity());
96.             item.setTotalPrice(product.getPrice().multiply(BigDecimal.valueOf(itemDto.getQuantity())));
97.             
98.             order.addItem(item);
99.         }
100.         
101.         // 计算总金额
102.         order.calculateTotal();
103.         
104.         // 保存订单
105.         order = orderRepository.save(order);
106.         
107.         // 发布订单创建事件
108.         eventPublisher.publishOrderCreatedEvent(order);
109.         
110.         // 转换为DTO并返回
111.         return convertToDto(order);
112.     }
113.    
114.     @Override
115.     public OrderDto getOrderById(Long id) {
116.         Order order = orderRepository.findById(id)
117.                 .orElseThrow(() -> new OrderNotFoundException(id));
118.         
119.         return convertToDto(order);
120.     }
121.    
122.     @Override
123.     public Page<OrderDto> getOrdersByUserId(Long userId, int page, int size) {
124.         Pageable pageable = PageRequest.of(page, size, Sort.by("createdAt").descending());
125.         Page<Order> orders = orderRepository.findByUserId(userId, pageable);
126.         
127.         return orders.map(this::convertToDto);
128.     }
129.    
130.     private OrderDto convertToDto(Order order) {
131.         OrderDto dto = new OrderDto();
132.         dto.setId(order.getId());
133.         dto.setUserId(order.getUserId());
134.         dto.setStatus(order.getStatus());
135.         dto.setTotalAmount(order.getTotalAmount());
136.         dto.setItems(order.getItems().stream()
137.                 .map(this::convertItemToDto)
138.                 .collect(Collectors.toList()));
139.         dto.setCreatedAt(order.getCreatedAt());
140.         dto.setUpdatedAt(order.getUpdatedAt());
141.         
142.         return dto;
143.     }
144.    
145.     private OrderItemDto convertItemToDto(OrderItem item) {
146.         OrderItemDto dto = new OrderItemDto();
147.         dto.setProductId(item.getProductId());
148.         dto.setProductName(item.getProductName());
149.         dto.setUnitPrice(item.getUnitPrice());
150.         dto.setQuantity(item.getQuantity());
151.         dto.setTotalPrice(item.getTotalPrice());
152.         
153.         return dto;
154.     }
155. }
157. // 服务网关配置
158. @Configuration
159. public class GatewayConfig {
160.    
161.     @Bean
162.     public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
163.         return builder.routes()
164.                 .route("user-service", r -> r.path("/api/users/**")
165.                         .uri("lb://user-service"))
166.                 .route("product-service", r -> r.path("/api/products/**")
167.                         .uri("lb://product-service"))
168.                 .route("order-service", r -> r.path("/api/orders/**")
169.                         .uri("lb://order-service"))
170.                 .build();
171.     }
172. }

复制代码

2. 性能优化策略

2. // 多级缓存配置
3. @Configuration
4. @EnableCaching
5. public class CacheConfig {
6.    
7.     @Bean
8.     public CacheManager cacheManager() {
9.         CompositeCacheManager cacheManager = new CompositeCacheManager(
10.                 caffeineCacheManager(),
11.                 redisCacheManager()
12.         );
13.         cacheManager.setFallbackToNoOpCache(false);
14.         return cacheManager;
15.     }
16.    
17.     @Bean
18.     public CaffeineCacheManager caffeineCacheManager() {
19.         CaffeineCacheManager cacheManager = new CaffeineCacheManager();
20.         cacheManager.setCaffeine(Caffeine.newBuilder()
21.                 .initialCapacity(100)
22.                 .maximumSize(1000)
23.                 .expireAfterWrite(5, TimeUnit.MINUTES));
24.         return cacheManager;
25.     }
26.    
27.     @Bean
28.     public RedisCacheManager redisCacheManager() {
29.         RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
30.                 .entryTtl(Duration.ofHours(1))
31.                 .disableCachingNullValues()
32.                 .serializeValuesWith(RedisSerializationContext.SerializationPair
33.                         .fromSerializer(new GenericJackson2JsonRedisSerializer()));
34.         
35.         return RedisCacheManager.builder(redisConnectionFactory())
36.                 .cacheDefaults(config)
37.                 .build();
38.     }
39.    
40.     @Bean
41.     public RedisConnectionFactory redisConnectionFactory() {
42.         return new LettuceConnectionFactory();
43.     }
44. }
46. // 缓存使用示例
47. @Service
48. public class ProductServiceImpl implements ProductService {
49.    
50.     private final ProductRepository productRepository;
51.    
52.     @Autowired
53.     public ProductServiceImpl(ProductRepository productRepository) {
54.         this.productRepository = productRepository;
55.     }
56.    
57.     @Override
58.     @Cacheable(value = "products", key = "#id", unless = "#result == null")
59.     public Product getProductById(Long id) {
60.         return productRepository.findById(id).orElse(null);
61.     }
62.    
63.     @Override
64.     @Cacheable(value = "products", key = "'category:' + #category + ':page:' + #page + ':size:' + #size")
65.     public Page<Product> getProductsByCategory(String category, int page, int size) {
66.         Pageable pageable = PageRequest.of(page, size);
67.         return productRepository.findByCategory(category, pageable);
68.     }
69.    
70.     @Override
71.     @Caching(
72.         put = @CachePut(value = "products", key = "#product.id"),
73.         evict = {
74.             @CacheEvict(value = "products", key = "'category:' + #product.category + ':page:*'"),
75.             @CacheEvict(value = "products", key = "'featured'")
76.         }
77.     )
78.     public Product updateProduct(Product product) {
79.         return productRepository.save(product);
80.     }
81.    
82.     @Override
83.     @CacheEvict(value = "products", allEntries = true)
84.     public void refreshProductCache() {
85.         // 清除所有产品缓存
86.     }
87. }

复制代码

2. // 异步服务配置
3. @Configuration
4. @EnableAsync
5. public class AsyncConfig implements AsyncConfigurer {
6.    
7.     @Override
8.     public Executor getAsyncExecutor() {
9.         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
10.         executor.setCorePoolSize(5);
11.         executor.setMaxPoolSize(10);
12.         executor.setQueueCapacity(25);
13.         executor.setThreadNamePrefix("AntiX-Async-");
14.         executor.initialize();
15.         return executor;
16.     }
17.    
18.     @Override
19.     public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
20.         return new CustomAsyncExceptionHandler();
21.     }
22. }
24. // 自定义异步异常处理器
25. public class CustomAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
26.    
27.     private static final Logger logger = LoggerFactory.getLogger(CustomAsyncExceptionHandler.class);
28.    
29.     @Override
30.     public void handleUncaughtException(Throwable ex, Method method, Object... params) {
31.         logger.error("Exception in async method: {}", method.getName(), ex);
32.         
33.         // 可以在这里添加通知逻辑，如发送邮件、短信等
34.     }
35. }
37. // 异步服务实现
38. @Service
39. public class NotificationServiceImpl implements NotificationService {
40.    
41.     private static final Logger logger = LoggerFactory.getLogger(NotificationServiceImpl.class);
42.    
43.     @Override
44.     @Async
45.     public void sendEmail(String to, String subject, String body) {
46.         try {
47.             // 模拟发送邮件的耗时操作
48.             Thread.sleep(1000);
49.             logger.info("Email sent to {} with subject: {}", to, subject);
50.         } catch (InterruptedException e) {
51.             Thread.currentThread().interrupt();
52.         }
53.     }
54.    
55.     @Override
56.     @Async("taskExecutor")
57.     public Future<String> sendSms(String phoneNumber, String message) {
58.         try {
59.             // 模拟发送短信的耗时操作
60.             Thread.sleep(500);
61.             String result = "SMS sent to " + phoneNumber;
62.             logger.info(result);
63.             return new AsyncResult<>(result);
64.         } catch (InterruptedException e) {
65.             Thread.currentThread().interrupt();
66.             return new AsyncResult<>("Failed to send SMS due to interruption");
67.         }
68.     }
69.    
70.     @Override
71.     @Async
72.     public void sendPushNotification(String userId, String title, String message) {
73.         try {
74.             // 模拟发送推送通知的耗时操作
75.             Thread.sleep(300);
76.             logger.info("Push notification sent to user {} with title: {}", userId, title);
77.         } catch (InterruptedException e) {
78.             Thread.currentThread().interrupt();
79.         }
80.     }
81. }

复制代码

2. // 数据库配置
3. @Configuration
4. @EnableJpaRepositories(basePackages = "com.example.antix.repository")
5. @EnableTransactionManagement
6. public class DatabaseConfig {
7.    
8.     @Bean
9.     @Primary
10.     @ConfigurationProperties(prefix = "spring.datasource")
11.     public DataSource dataSource() {
12.         return DataSourceBuilder.create().type(HikariDataSource.class).build();
13.     }
14.    
15.     @Bean
16.     public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
17.         LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
18.         em.setDataSource(dataSource());
19.         em.setPackagesToScan("com.example.antix.model");
20.         
21.         HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
22.         em.setJpaVendorAdapter(vendorAdapter);
23.         
24.         Properties properties = new Properties();
25.         properties.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
26.         properties.setProperty("hibernate.show_sql", "false");
27.         properties.setProperty("hibernate.format_sql", "false");
28.         properties.setProperty("hibernate.hbm2ddl.auto", "none");
29.         properties.setProperty("hibernate.jdbc.batch_size", "30");
30.         properties.setProperty("hibernate.order_inserts", "true");
31.         properties.setProperty("hibernate.order_updates", "true");
32.         properties.setProperty("hibernate.jdbc.fetch_size", "100");
33.         properties.setProperty("hibernate.cache.use_second_level_cache", "true");
34.         properties.setProperty("hibernate.cache.use_query_cache", "true");
35.         properties.setProperty("hibernate.cache.region.factory_class", "org.hibernate.cache.ehcache.EhCacheRegionFactory");
36.         properties.setProperty("hibernate.cache.provider_configuration_file_resource_path", "classpath:ehcache.xml");
37.         
38.         em.setJpaProperties(properties);
39.         
40.         return em;
41.     }
42.    
43.     @Bean
44.     public PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
45.         JpaTransactionManager transactionManager = new JpaTransactionManager();
46.         transactionManager.setEntityManagerFactory(entityManagerFactory);
47.         return transactionManager;
48.     }
49. }
51. // 批量操作示例
52. @Service
53. public class ProductBatchServiceImpl implements ProductBatchService {
54.    
55.     private final ProductRepository productRepository;
56.     private final EntityManager entityManager;
57.    
58.     @Autowired
59.     public ProductBatchServiceImpl(ProductRepository productRepository, EntityManager entityManager) {
60.         this.productRepository = productRepository;
61.         this.entityManager = entityManager;
62.     }
63.    
64.     @Override
65.     @Transactional
66.     public void batchInsertProducts(List<Product> products) {
67.         final int batchSize = 30;
68.         
69.         for (int i = 0; i < products.size(); i++) {
70.             Product product = products.get(i);
71.             entityManager.persist(product);
72.             
73.             if (i > 0 && i % batchSize == 0) {
74.                 // 刷新并清除会话，避免内存溢出
75.                 entityManager.flush();
76.                 entityManager.clear();
77.             }
78.         }
79.         
80.         // 刷新剩余的记录
81.         entityManager.flush();
82.         entityManager.clear();
83.     }
84.    
85.     @Override
86.     @Transactional
87.     public void batchUpdateProducts(List<Product> products) {
88.         final int batchSize = 30;
89.         
90.         for (int i = 0; i < products.size(); i++) {
91.             Product product = products.get(i);
92.             entityManager.merge(product);
93.             
94.             if (i > 0 && i % batchSize == 0) {
95.                 // 刷新并清除会话，避免内存溢出
96.                 entityManager.flush();
97.                 entityManager.clear();
98.             }
99.         }
100.         
101.         // 刷新剩余的记录
102.         entityManager.flush();
103.         entityManager.clear();
104.     }
105.    
106.     @Override
107.     @Transactional
108.     public void batchDeleteProducts(List<Long> productIds) {
109.         final int batchSize = 30;
110.         
111.         for (int i = 0; i < productIds.size(); i++) {
112.             Long productId = productIds.get(i);
113.             Product product = entityManager.find(Product.class, productId);
114.             if (product != null) {
115.                 entityManager.remove(product);
116.             }
117.             
118.             if (i > 0 && i % batchSize == 0) {
119.                 // 刷新并清除会话，避免内存溢出
120.                 entityManager.flush();
121.                 entityManager.clear();
122.             }
123.         }
124.         
125.         // 刷新剩余的记录
126.         entityManager.flush();
127.         entityManager.clear();
128.     }
129. }
131. // 查询优化示例
132. @Repository
133. public class ProductRepositoryImpl implements ProductRepositoryCustom {
134.    
135.     @PersistenceContext
136.     private EntityManager entityManager;
137.    
138.     @Override
139.     public List<Product> findProductsByCriteria(ProductSearchCriteria criteria) {
140.         CriteriaBuilder cb = entityManager.getCriteriaBuilder();
141.         CriteriaQuery<Product> query = cb.createQuery(Product.class);
142.         Root<Product> product = query.from(Product.class);
143.         
144.         List<Predicate> predicates = new ArrayList<>();
145.         
146.         // 添加名称过滤条件
147.         if (StringUtils.hasText(criteria.getName())) {
148.             predicates.add(cb.like(product.get("name"), "%" + criteria.getName() + "%"));
149.         }
150.         
151.         // 添加类别过滤条件
152.         if (StringUtils.hasText(criteria.getCategory())) {
153.             predicates.add(cb.equal(product.get("category"), criteria.getCategory()));
154.         }
155.         
156.         // 添加价格范围过滤条件
157.         if (criteria.getMinPrice() != null) {
158.             predicates.add(cb.ge(product.get("price"), criteria.getMinPrice()));
159.         }
160.         if (criteria.getMaxPrice() != null) {
161.             predicates.add(cb.le(product.get("price"), criteria.getMaxPrice()));
162.         }
163.         
164.         // 添加状态过滤条件
165.         if (criteria.getStatus() != null) {
166.             predicates.add(cb.equal(product.get("status"), criteria.getStatus()));
167.         }
168.         
169.         // 组合所有条件
170.         query.where(predicates.toArray(new Predicate[0]));
171.         
172.         // 添加排序
173.         if (criteria.getSortBy() != null) {
174.             Path<Object> sortPath = product.get(criteria.getSortBy());
175.             if (criteria.getSortDirection() == Sort.Direction.DESC) {
176.                 query.orderBy(cb.desc(sortPath));
177.             } else {
178.                 query.orderBy(cb.asc(sortPath));
179.             }
180.         }
181.         
182.         // 创建查询并设置分页
183.         TypedQuery<Product> typedQuery = entityManager.createQuery(query);
184.         if (criteria.getPage() != null && criteria.getSize() != null) {
185.             typedQuery.setFirstResult(criteria.getPage() * criteria.getSize());
186.             typedQuery.setMaxResults(criteria.getSize());
187.         }
188.         
189.         return typedQuery.getResultList();
190.     }
191. }

复制代码

3. 安全策略

2. // 安全配置
3. @Configuration
4. @EnableWebSecurity
5. @EnableGlobalMethodSecurity(prePostEnabled = true)
6. public class SecurityConfig extends WebSecurityConfigurerAdapter {
7.    
8.     @Autowired
9.     private UserDetailsService userDetailsService;
10.    
11.     @Autowired
12.     private JwtAuthenticationEntryPoint unauthorizedHandler;
13.    
14.     @Bean
15.     public PasswordEncoder passwordEncoder() {
16.         return new BCryptPasswordEncoder();
17.     }
18.    
19.     @Bean
20.     public JwtAuthenticationFilter jwtAuthenticationFilter() {
21.         return new JwtAuthenticationFilter();
22.     }
23.    
24.     @Override
25.     public void configure(AuthenticationManagerBuilder authenticationManagerBuilder) throws Exception {
26.         authenticationManagerBuilder
27.                 .userDetailsService(userDetailsService)
28.                 .passwordEncoder(passwordEncoder());
29.     }
30.    
31.     @Bean(BeanIds.AUTHENTICATION_MANAGER)
32.     @Override
33.     public AuthenticationManager authenticationManagerBean() throws Exception {
34.         return super.authenticationManagerBean();
35.     }
36.    
37.     @Override
38.     protected void configure(HttpSecurity http) throws Exception {
39.         http
40.                 .cors()
41.                 .and()
42.                 .csrf()
43.                 .disable()
44.                 .exceptionHandling()
45.                 .authenticationEntryPoint(unauthorizedHandler)
46.                 .and()
47.                 .sessionManagement()
48.                 .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
49.                 .and()
50.                 .authorizeRequests()
51.                 .antMatchers("/api/auth/**")
52.                 .permitAll()
53.                 .antMatchers("/api/public/**")
54.                 .permitAll()
55.                 .antMatchers("/api/admin/**")
56.                 .hasRole("ADMIN")
57.                 .antMatchers(HttpMethod.GET, "/api/products/**", "/api/categories/**")
58.                 .permitAll()
59.                 .anyRequest()
60.                 .authenticated();
61.         
62.         // 添加JWT过滤器
63.         http.addFilterBefore(jwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
64.     }
65. }
67. // JWT认证过滤器
68. public class JwtAuthenticationFilter extends OncePerRequestFilter {
69.    
70.     @Autowired
71.     private JwtTokenProvider tokenProvider;
72.    
73.     @Autowired
74.     private UserDetailsService userDetailsService;
75.    
76.     private static final Logger logger = LoggerFactory.getLogger(JwtAuthenticationFilter.class);
77.    
78.     @Override
79.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
80.             throws ServletException, IOException {
81.         try {
82.             String jwt = getJwtFromRequest(request);
83.             
84.             if (StringUtils.hasText(jwt) && tokenProvider.validateToken(jwt)) {
85.                 Long userId = tokenProvider.getUserIdFromJWT(jwt);
86.                
87.                 UserDetails userDetails = userDetailsService.loadUserById(userId);
88.                 UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
89.                         userDetails, null, userDetails.getAuthorities());
90.                 authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
91.                
92.                 SecurityContextHolder.getContext().setAuthentication(authentication);
93.             }
94.         } catch (Exception ex) {
95.             logger.error("Could not set user authentication in security context", ex);
96.         }
97.         
98.         filterChain.doFilter(request, response);
99.     }
100.    
101.     private String getJwtFromRequest(HttpServletRequest request) {
102.         String bearerToken = request.getHeader("Authorization");
103.         if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
104.             return bearerToken.substring(7);
105.         }
106.         return null;
107.     }
108. }
110. // 方法级安全示例
111. @Service
112. public class OrderServiceImpl implements OrderService {
113.    
114.     @Override
115.     @PreAuthorize("hasRole('USER') or hasRole('ADMIN')")
116.     public Order getOrderById(Long id) {
117.         // 获取订单逻辑
118.     }
119.    
120.     @Override
121.     @PreAuthorize("hasRole('ADMIN')")
122.     public List<Order> getAllOrders() {
123.         // 获取所有订单逻辑
124.     }
125.    
126.     @Override
127.     @PreAuthorize("#order.userId == authentication.principal.id or hasRole('ADMIN')")
128.     public void updateOrder(Order order) {
129.         // 更新订单逻辑
130.     }
131.    
132.     @Override
133.     @PreAuthorize("#order.userId == authentication.principal.id or hasRole('ADMIN')")
134.     public void deleteOrder(Order order) {
135.         // 删除订单逻辑
136.     }
137. }

复制代码

2. // 加密服务
3. @Service
4. public class EncryptionServiceImpl implements EncryptionService {
5.    
6.     private final String encryptionKey;
7.     private final String salt;
8.    
9.     @Autowired
10.     public EncryptionServiceImpl(
11.             @Value("${app.encryption.key}") String encryptionKey,
12.             @Value("${app.encryption.salt}") String salt) {
13.         this.encryptionKey = encryptionKey;
14.         this.salt = salt;
15.     }
16.    
17.     @Override
18.     public String encrypt(String data) {
19.         try {
20.             SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
21.             KeySpec spec = new PBEKeySpec(encryptionKey.toCharArray(), salt.getBytes(), 65536, 256);
22.             SecretKey tmp = factory.generateSecret(spec);
23.             SecretKey secretKey = new SecretKeySpec(tmp.getEncoded(), "AES");
24.             
25.             Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
26.             cipher.init(Cipher.ENCRYPT_MODE, secretKey);
27.             
28.             byte[] iv = new byte[16];
29.             new SecureRandom().nextBytes(iv);
30.             IvParameterSpec ivSpec = new IvParameterSpec(iv);
31.             
32.             cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivSpec);
33.             byte[] encryptedData = cipher.doFinal(data.getBytes());
34.             
35.             byte[] combined = new byte[iv.length + encryptedData.length];
36.             System.arraycopy(iv, 0, combined, 0, iv.length);
37.             System.arraycopy(encryptedData, 0, combined, iv.length, encryptedData.length);
38.             
39.             return Base64.getEncoder().encodeToString(combined);
40.         } catch (Exception e) {
41.             throw new EncryptionException("Failed to encrypt data", e);
42.         }
43.     }
44.    
45.     @Override
46.     public String decrypt(String encryptedData) {
47.         try {
48.             byte[] combined = Base64.getDecoder().decode(encryptedData);
49.             
50.             byte[] iv = new byte[16];
51.             byte[] encrypted = new byte[combined.length - iv.length];
52.             System.arraycopy(combined, 0, iv, 0, iv.length);
53.             System.arraycopy(combined, iv.length, encrypted, 0, encrypted.length);
54.             
55.             SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
56.             KeySpec spec = new PBEKeySpec(encryptionKey.toCharArray(), salt.getBytes(), 65536, 256);
57.             SecretKey tmp = factory.generateSecret(spec);
58.             SecretKey secretKey = new SecretKeySpec(tmp.getEncoded(), "AES");
59.             
60.             Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
61.             IvParameterSpec ivSpec = new IvParameterSpec(iv);
62.             
63.             cipher.init(Cipher.DECRYPT_MODE, secretKey, ivSpec);
64.             byte[] decryptedData = cipher.doFinal(encrypted);
65.             
66.             return new String(decryptedData);
67.         } catch (Exception e) {
68.             throw new EncryptionException("Failed to decrypt data", e);
69.         }
70.     }
71. }
73. // 敏感数据处理器
74. @Aspect
75. @Component
76. public class SensitiveDataAspect {
77.    
78.     private final EncryptionService encryptionService;
79.    
80.     @Autowired
81.     public SensitiveDataAspect(EncryptionService encryptionService) {
82.         this.encryptionService = encryptionService;
83.     }
84.    
85.     @Around("@annotation(EncryptSensitiveData)")
86.     public Object encryptSensitiveData(ProceedingJoinPoint joinPoint) throws Throwable {
87.         Object result = joinPoint.proceed();
88.         
89.         // 处理返回结果中的敏感数据
90.         if (result instanceof User) {
91.             User user = (User) result;
92.             // 加密敏感字段
93.             if (user.getEmail() != null) {
94.                 user.setEmail(encryptionService.encrypt(user.getEmail()));
95.             }
96.             if (user.getPhone() != null) {
97.                 user.setPhone(encryptionService.encrypt(user.getPhone()));
98.             }
99.             if (user.getIdCard() != null) {
100.                 user.setIdCard(encryptionService.encrypt(user.getIdCard()));
101.             }
102.         }
103.         
104.         return result;
105.     }
106.    
107.     @Around("@annotation(DecryptSensitiveData)")
108.     public Object decryptSensitiveData(ProceedingJoinPoint joinPoint) throws Throwable {
109.         Object[] args = joinPoint.getArgs();
110.         
111.         // 处理方法参数中的敏感数据
112.         for (int i = 0; i < args.length; i++) {
113.             if (args[i] instanceof User) {
114.                 User user = (User) args[i];
115.                 // 解密敏感字段
116.                 if (user.getEmail() != null) {
117.                     user.setEmail(encryptionService.decrypt(user.getEmail()));
118.                 }
119.                 if (user.getPhone() != null) {
120.                     user.setPhone(encryptionService.decrypt(user.getPhone()));
121.                 }
122.                 if (user.getIdCard() != null) {
123.                     user.setIdCard(encryptionService.decrypt(user.getIdCard()));
124.                 }
125.             }
126.         }
127.         
128.         return joinPoint.proceed(args);
129.     }
130. }

复制代码

4. 监控与运维

2. // 自定义健康指标
3. @Component
4. public class CustomHealthIndicator implements HealthIndicator {
5.    
6.     private final DatabaseHealthIndicator databaseHealthIndicator;
7.     private final RedisHealthIndicator redisHealthIndicator;
8.     private final ExternalServiceHealthIndicator externalServiceHealthIndicator;
9.    
10.     @Autowired
11.     public CustomHealthIndicator(DatabaseHealthIndicator databaseHealthIndicator,
12.                                RedisHealthIndicator redisHealthIndicator,
13.                                ExternalServiceHealthIndicator externalServiceHealthIndicator) {
14.         this.databaseHealthIndicator = databaseHealthIndicator;
15.         this.redisHealthIndicator = redisHealthIndicator;
16.         this.externalServiceHealthIndicator = externalServiceHealthIndicator;
17.     }
18.    
19.     @Override
20.     public Health health() {
21.         // 检查数据库状态
22.         Health dbHealth = databaseHealthIndicator.health();
23.         
24.         // 检查Redis状态
25.         Health redisHealth = redisHealthIndicator.health();
26.         
27.         // 检查外部服务状态
28.         Health externalServiceHealth = externalServiceHealthIndicator.health();
29.         
30.         // 确定整体状态
31.         Status overallStatus = Status.UP;
32.         List<String> details = new ArrayList<>();
33.         
34.         if (dbHealth.getStatus() != Status.UP) {
35.             overallStatus = Status.DOWN;
36.             details.add("Database is not available: " + dbHealth.getDetails());
37.         }
38.         
39.         if (redisHealth.getStatus() != Status.UP) {
40.             overallStatus = overallStatus == Status.UP ? Status.UP : Status.DOWN;
41.             details.add("Redis is not available: " + redisHealth.getDetails());
42.         }
43.         
44.         if (externalServiceHealth.getStatus() != Status.UP) {
45.             overallStatus = overallStatus == Status.UP ? Status.UP : Status.DOWN;
46.             details.add("External service is not available: " + externalServiceHealth.getDetails());
47.         }
48.         
49.         if (overallStatus == Status.UP) {
50.             return Health.up()
51.                     .withDetail("database", dbHealth.getDetails())
52.                     .withDetail("redis", redisHealth.getDetails())
53.                     .withDetail("externalService", externalServiceHealth.getDetails())
54.                     .build();
55.         } else {
56.             return Health.down()
57.                     .withDetail("reason", String.join("; ", details))
58.                     .withDetail("database", dbHealth.getDetails())
59.                     .withDetail("redis", redisHealth.getDetails())
60.                     .withDetail("externalService", externalServiceHealth.getDetails())
61.                     .build();
62.         }
63.     }
64. }
66. // 自定义指标
67. @Service
68. public class CustomMetrics {
69.    
70.     private final MeterRegistry meterRegistry;
71.     private final Counter orderCounter;
72.     private final Timer orderProcessingTimer;
73.    
74.     @Autowired
75.     public CustomMetrics(MeterRegistry meterRegistry) {
76.         this.meterRegistry = meterRegistry;
77.         this.orderCounter = Counter.builder("orders.created")
78.                 .description("Number of orders created")
79.                 .register(meterRegistry);
80.         
81.         this.orderProcessingTimer = Timer.builder("orders.processing.time")
82.                 .description("Time taken to process orders")
83.                 .register(meterRegistry);
84.     }
85.    
86.     public void incrementOrderCounter() {
87.         orderCounter.increment();
88.     }
89.    
90.     public Timer.Sample startOrderProcessingTimer() {
91.         return Timer.start(meterRegistry);
92.     }
93.    
94.     public void stopOrderProcessingTimer(Timer.Sample sample) {
95.         sample.stop(orderProcessingTimer);
96.     }
97. }
99. // 使用自定义指标
100. @Service
101. public class OrderServiceImpl implements OrderService {
102.    
103.     private final OrderRepository orderRepository;
104.     private final CustomMetrics customMetrics;
105.    
106.     @Autowired
107.     public OrderServiceImpl(OrderRepository orderRepository, CustomMetrics customMetrics) {
108.         this.orderRepository = orderRepository;
109.         this.customMetrics = customMetrics;
110.     }
111.    
112.     @Override
113.     @Transactional
114.     public Order createOrder(Order order) {
115.         Timer.Sample sample = customMetrics.startOrderProcessingTimer();
116.         
117.         try {
118.             // 创建订单逻辑
119.             Order savedOrder = orderRepository.save(order);
120.             
121.             // 增加订单计数器
122.             customMetrics.incrementOrderCounter();
123.             
124.             return savedOrder;
125.         } finally {
126.             // 停止计时器
127.             customMetrics.stopOrderProcessingTimer(sample);
128.         }
129.     }
130. }

复制代码

2. // 日志配置
3. @Configuration
4. public class LoggingConfig {
5.    
6.     @Bean
7.     public InMemoryLogAppender inMemoryLogAppender() {
8.         InMemoryLogAppender appender = new InMemoryLogAppender();
9.         appender.setName("InMemoryLogAppender");
10.         appender.setThreshold(Level.INFO);
11.         appender.setMaxSize(1000);
12.         
13.         PatternLayoutEncoder encoder = new PatternLayoutEncoder();
14.         encoder.setPattern("%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n");
15.         encoder.start();
16.         
17.         appender.setEncoder(encoder);
18.         appender.start();
19.         
20.         Logger rootLogger = LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
21.         if (rootLogger instanceof ch.qos.logback.classic.Logger) {
22.             ((ch.qos.logback.classic.Logger) rootLogger).addAppender(appender);
23.         }
24.         
25.         return appender;
26.     }
27. }
29. // 审计日志服务
30. @Service
31. public class AuditLogServiceImpl implements AuditLogService {
32.    
33.     private final AuditLogRepository auditLogRepository;
34.    
35.     @Autowired
36.     public AuditLogServiceImpl(AuditLogRepository auditLogRepository) {
37.         this.auditLogRepository = auditLogRepository;
38.     }
39.    
40.     @Override
41.     @Async
42.     public void logAction(String userId, String action, String details) {
43.         AuditLog auditLog = new AuditLog();
44.         auditLog.setUserId(userId);
45.         auditLog.setAction(action);
46.         auditLog.setDetails(details);
47.         auditLog.setTimestamp(LocalDateTime.now());
48.         auditLog.setIpAddress(getCurrentIpAddress());
49.         auditLog.setUserAgent(getCurrentUserAgent());
50.         
51.         auditLogRepository.save(auditLog);
52.     }
53.    
54.     @Override
55.     public Page<AuditLog> getAuditLogs(String userId, LocalDateTime startTime, LocalDateTime endTime,
56.                                       Pageable pageable) {
57.         Specification<AuditLog> spec = Specification.where(null);
58.         
59.         if (StringUtils.hasText(userId)) {
60.             spec = spec.and((root, query, cb) -> cb.equal(root.get("userId"), userId));
61.         }
62.         
63.         if (startTime != null) {
64.             spec = spec.and((root, query, cb) -> cb.greaterThanOrEqualTo(root.get("timestamp"), startTime));
65.         }
66.         
67.         if (endTime != null) {
68.             spec = spec.and((root, query, cb) -> cb.lessThanOrEqualTo(root.get("timestamp"), endTime));
69.         }
70.         
71.         return auditLogRepository.findAll(spec, pageable);
72.     }
73.    
74.     private String getCurrentIpAddress() {
75.         // 获取当前请求的IP地址
76.         RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
77.         if (requestAttributes instanceof ServletRequestAttributes) {
78.             HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest();
79.             String ipAddress = request.getHeader("X-Forwarded-For");
80.             if (ipAddress == null || ipAddress.isEmpty() || "unknown".equalsIgnoreCase(ipAddress)) {
81.                 ipAddress = request.getHeader("Proxy-Client-IP");
82.             }
83.             if (ipAddress == null || ipAddress.isEmpty() || "unknown".equalsIgnoreCase(ipAddress)) {
84.                 ipAddress = request.getHeader("WL-Proxy-Client-IP");
85.             }
86.             if (ipAddress == null || ipAddress.isEmpty() || "unknown".equalsIgnoreCase(ipAddress)) {
87.                 ipAddress = request.getRemoteAddr();
88.             }
89.             return ipAddress;
90.         }
91.         return "unknown";
92.     }
93.    
94.     private String getCurrentUserAgent() {
95.         // 获取当前请求的User-Agent
96.         RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
97.         if (requestAttributes instanceof ServletRequestAttributes) {
98.             HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest();
99.             return request.getHeader("User-Agent");
100.         }
101.         return "unknown";
102.     }
103. }
105. // 审计日志切面
106. @Aspect
107. @Component
108. public class AuditLogAspect {
109.    
110.     private final AuditLogService auditLogService;
111.    
112.     @Autowired
113.     public AuditLogAspect(AuditLogService auditLogService) {
114.         this.auditLogService = auditLogService;
115.     }
116.    
117.     @AfterReturning(pointcut = "@annotation(auditLog)", returning = "result")
118.     public void logAfterReturning(JoinPoint joinPoint, AuditLog auditLog, Object result) {
119.         String userId = getCurrentUserId();
120.         String action = auditLog.action();
121.         String details = createLogDetails(joinPoint, result);
122.         
123.         auditLogService.logAction(userId, action, details);
124.     }
125.    
126.     @AfterThrowing(pointcut = "@annotation(auditLog)", throwing = "exception")
127.     public void logAfterThrowing(JoinPoint joinPoint, AuditLog auditLog, Exception exception) {
128.         String userId = getCurrentUserId();
129.         String action = auditLog.action();
130.         String details = "Failed: " + exception.getMessage();
131.         
132.         auditLogService.logAction(userId, action, details);
133.     }
134.    
135.     private String getCurrentUserId() {
136.         // 获取当前用户ID
137.         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
138.         if (authentication != null && authentication.isAuthenticated() && !authentication.getPrincipal().equals("anonymousUser")) {
139.             return authentication.getName();
140.         }
141.         return "anonymous";
142.     }
143.    
144.     private String createLogDetails(JoinPoint joinPoint, Object result) {
145.         StringBuilder details = new StringBuilder();
146.         details.append("Method: ").append(joinPoint.getSignature().toShortString());
147.         
148.         // 添加参数信息
149.         Object[] args = joinPoint.getArgs();
150.         if (args.length > 0) {
151.             details.append(", Parameters: [");
152.             for (int i = 0; i < args.length; i++) {
153.                 if (i > 0) {
154.                     details.append(", ");
155.                 }
156.                 details.append(args[i] != null ? args[i].toString() : "null");
157.             }
158.             details.append("]");
159.         }
160.         
161.         // 添加返回值信息
162.         if (result != null) {
163.             details.append(", Result: ").append(result.toString());
164.         }
165.         
166.         return details.toString();
167.     }
168. }

复制代码

总结与展望

AntiX系统开发框架作为一个全面的企业级开发解决方案，提供了丰富的特性和工具，帮助开发团队构建稳定、高效、可维护的应用系统。通过本文的介绍，我们深入了解了AntiX框架的高级特性和最佳实践，并通过真实项目案例展示了如何充分发挥框架优势。

关键要点总结

1. 模块化架构：AntiX框架采用模块化设计，使开发者能够根据项目需求选择合适的组件，避免不必要的复杂性。
2. 依赖注入与控制反转：通过DI和IoC容器，AntiX框架降低了组件之间的耦合度，提高了代码的可测试性和可维护性。
3. 面向切面编程：AOP支持使开发者能够将横切关注点与业务逻辑分离，提高代码的模块化程度。
4. 高级数据访问：AntiX框架提供了强大的数据访问层支持，包括ORM集成、查询优化和批量操作等功能。
5. 事件驱动架构：通过事件驱动机制，AntiX框架支持松耦合的组件通信，提高系统的可扩展性和灵活性。
6. 缓存机制：多级缓存支持帮助提高应用性能，减少数据库负载。
7. 安全框架集成：全面的安全支持，包括认证、授权、数据加密等功能，保护企业应用免受安全威胁。
8. 微服务支持：AntiX框架支持构建微服务架构，使应用能够模块化、可扩展且易于维护。
9. 性能优化：通过异步处理、缓存策略和数据库优化等技术，AntiX框架帮助构建高性能应用。
10. 监控与运维：全面的监控、日志和健康检查支持，使应用的运维更加高效。

模块化架构：AntiX框架采用模块化设计，使开发者能够根据项目需求选择合适的组件，避免不必要的复杂性。

依赖注入与控制反转：通过DI和IoC容器，AntiX框架降低了组件之间的耦合度，提高了代码的可测试性和可维护性。

面向切面编程：AOP支持使开发者能够将横切关注点与业务逻辑分离，提高代码的模块化程度。

高级数据访问：AntiX框架提供了强大的数据访问层支持，包括ORM集成、查询优化和批量操作等功能。

事件驱动架构：通过事件驱动机制，AntiX框架支持松耦合的组件通信，提高系统的可扩展性和灵活性。

缓存机制：多级缓存支持帮助提高应用性能，减少数据库负载。

安全框架集成：全面的安全支持，包括认证、授权、数据加密等功能，保护企业应用免受安全威胁。

微服务支持：AntiX框架支持构建微服务架构，使应用能够模块化、可扩展且易于维护。

性能优化：通过异步处理、缓存策略和数据库优化等技术，AntiX框架帮助构建高性能应用。

监控与运维：全面的监控、日志和健康检查支持，使应用的运维更加高效。

未来发展方向

1. 云原生支持：未来AntiX框架将进一步增强对云原生应用的支持，包括容器化部署、服务网格和云平台集成等。
2. AI/ML集成：随着人工智能和机器学习技术的发展，AntiX框架将提供更多AI/ML集成支持，使开发者能够轻松构建智能化应用。
3. 低代码/无代码开发：AntiX框架将引入更多低代码/无代码开发工具，降低开发门槛，提高开发效率。
4. 实时数据处理：增强对实时数据流处理的支持，满足实时分析和决策需求。
5. 边缘计算支持：随着边缘计算的兴起，AntiX框架将提供更多边缘计算场景下的开发支持。

云原生支持：未来AntiX框架将进一步增强对云原生应用的支持，包括容器化部署、服务网格和云平台集成等。

AI/ML集成：随着人工智能和机器学习技术的发展，AntiX框架将提供更多AI/ML集成支持，使开发者能够轻松构建智能化应用。

低代码/无代码开发：AntiX框架将引入更多低代码/无代码开发工具，降低开发门槛，提高开发效率。

实时数据处理：增强对实时数据流处理的支持，满足实时分析和决策需求。

边缘计算支持：随着边缘计算的兴起，AntiX框架将提供更多边缘计算场景下的开发支持。

通过持续创新和改进，AntiX框架将继续为企业级应用开发提供强大支持，帮助开发团队应对不断变化的业务需求和技术挑战。