第174集Dubbo适用于哪些场景Java实战

/**
 * Dubbo配置类
 * @author Java实战
 */
@Configuration
@EnableConfigurationProperties(DubboProperties.class)
public class DubboConfig {
    
    @Autowired
    private DubboProperties properties;
    
    /**
     * Dubbo应用配置
     * @return 应用配置
     */
    @Bean
    public ApplicationConfig applicationConfig() {
        ApplicationConfig config = new ApplicationConfig();
        config.setName(properties.getApplication().getName());
        config.setOwner(properties.getApplication().getOwner());
        config.setOrganization(properties.getApplication().getOrganization());
        return config;
    }
    
    /**
     * Dubbo注册中心配置
     * @return 注册中心配置
     */
    @Bean
    public RegistryConfig registryConfig() {
        RegistryConfig config = new RegistryConfig();
        config.setAddress(properties.getRegistry().getAddress());
        config.setProtocol(properties.getRegistry().getProtocol());
        config.setTimeout(properties.getRegistry().getTimeout());
        return config;
    }
    
    /**
     * Dubbo协议配置
     * @return 协议配置
     */
    @Bean
    public ProtocolConfig protocolConfig() {
        ProtocolConfig config = new ProtocolConfig();
        config.setName(properties.getProtocol().getName());
        config.setPort(properties.getProtocol().getPort());
        config.setThreads(properties.getProtocol().getThreads());
        return config;
    }
    
    /**
     * Dubbo服务配置
     * @return 服务配置
     */
    @Bean
    public ServiceBean<Object> serviceBean() {
        ServiceBean<Object> serviceBean = new ServiceBean<>();
        serviceBean.setApplication(applicationConfig());
        serviceBean.setRegistry(registryConfig());
        serviceBean.setProtocol(protocolConfig());
        return serviceBean;
    }
    
    private static final Logger logger = LoggerFactory.getLogger(DubboConfig.class);
}

/**
 * Dubbo属性配置
 * @author Java实战
 */
@Data
@ConfigurationProperties(prefix = "dubbo")
public class DubboProperties {
    
    /**
     * 应用配置
     */
    private ApplicationConfig application = new ApplicationConfig();
    
    /**
     * 注册中心配置
     */
    private RegistryConfig registry = new RegistryConfig();
    
    /**
     * 协议配置
     */
    private ProtocolConfig protocol = new ProtocolConfig();
    
    /**
     * 监控配置
     */
    private MonitorConfig monitor = new MonitorConfig();
    
    /**
     * 应用配置类
     */
    @Data
    public static class ApplicationConfig {
        /**
         * 应用名称
         */
        private String name = "dubbo-service";
        
        /**
         * 应用负责人
         */
        private String owner = "admin";
        
        /**
         * 应用组织
         */
        private String organization = "company";
        
        /**
         * 应用版本
         */
        private String version = "1.0.0";
        
        /**
         * 应用环境
         */
        private String environment = "dev";
    }
    
    /**
     * 注册中心配置类
     */
    @Data
    public static class RegistryConfig {
        /**
         * 注册中心地址
         */
        private String address = "zookeeper://localhost:2181";
        
        /**
         * 注册中心协议
         */
        private String protocol = "zookeeper";
        
        /**
         * 注册中心超时时间
         */
        private int timeout = 3000;
        
        /**
         * 是否注册
         */
        private boolean register = true;
        
        /**
         * 是否订阅
         */
        private boolean subscribe = true;
    }
    
    /**
     * 协议配置类
     */
    @Data
    public static class ProtocolConfig {
        /**
         * 协议名称
         */
        private String name = "dubbo";
        
        /**
         * 协议端口
         */
        private int port = 20880;
        
        /**
         * 线程数
         */
        private int threads = 200;
        
        /**
         * 序列化方式
         */
        private String serialization = "hessian2";
        
        /**
         * 字符集
         */
        private String charset = "UTF-8";
    }
    
    /**
     * 监控配置类
     */
    @Data
    public static class MonitorConfig {
        /**
         * 监控地址
         */
        private String address = "dubbo://localhost:7070";
        
        /**
         * 监控协议
         */
        private String protocol = "dubbo";
        
        /**
         * 是否启用监控
         */
        private boolean enable = true;
        
        /**
         * 监控间隔
         */
        private int interval = 60000;
    }
}

/**
 * 用户服务接口
 * @author Java实战
 */
public interface UserService {
    
    /**
     * 根据ID获取用户
     * @param id 用户ID
     * @return 用户信息
     */
    User getUserById(Long id);
    
    /**
     * 根据用户名获取用户
     * @param username 用户名
     * @return 用户信息
     */
    User getUserByUsername(String username);
    
    /**
     * 创建用户
     * @param user 用户信息
     * @return 是否成功
     */
    boolean createUser(User user);
    
    /**
     * 更新用户
     * @param user 用户信息
     * @return 是否成功
     */
    boolean updateUser(User user);
    
    /**
     * 删除用户
     * @param id 用户ID
     * @return 是否成功
     */
    boolean deleteUser(Long id);
    
    /**
     * 获取用户列表
     * @param pageNum 页码
     * @param pageSize 页大小
     * @return 用户列表
     */
    List<User> getUserList(int pageNum, int pageSize);
    
    /**
     * 批量获取用户
     * @param ids 用户ID列表
     * @return 用户列表
     */
    List<User> getUsersByIds(List<Long> ids);
}

/**
 * 订单服务接口
 * @author Java实战
 */
public interface OrderService {
    
    /**
     * 根据ID获取订单
     * @param id 订单ID
     * @return 订单信息
     */
    Order getOrderById(Long id);
    
    /**
     * 创建订单
     * @param order 订单信息
     * @return 是否成功
     */
    boolean createOrder(Order order);
    
    /**
     * 更新订单状态
     * @param id 订单ID
     * @param status 订单状态
     * @return 是否成功
     */
    boolean updateOrderStatus(Long id, String status);
    
    /**
     * 获取用户订单列表
     * @param userId 用户ID
     * @param pageNum 页码
     * @param pageSize 页大小
     * @return 订单列表
     */
    List<Order> getUserOrders(Long userId, int pageNum, int pageSize);
    
    /**
     * 取消订单
     * @param id 订单ID
     * @return 是否成功
     */
    boolean cancelOrder(Long id);
}

/**
 * 商品服务接口
 * @author Java实战
 */
public interface ProductService {
    
    /**
     * 根据ID获取商品
     * @param id 商品ID
     * @return 商品信息
     */
    Product getProductById(Long id);
    
    /**
     * 获取商品列表
     * @param categoryId 分类ID
     * @param pageNum 页码
     * @param pageSize 页大小
     * @return 商品列表
     */
    List<Product> getProductList(Long categoryId, int pageNum, int pageSize);
    
    /**
     * 搜索商品
     * @param keyword 关键词
     * @param pageNum 页码
     * @param pageSize 页大小
     * @return 商品列表
     */
    List<Product> searchProducts(String keyword, int pageNum, int pageSize);
    
    /**
     * 更新商品库存
     * @param id 商品ID
     * @param quantity 库存数量
     * @return 是否成功
     */
    boolean updateProductStock(Long id, int quantity);
    
    /**
     * 批量获取商品
     * @param ids 商品ID列表
     * @return 商品列表
     */
    List<Product> getProductsByIds(List<Long> ids);
}

/**
 * 用户服务实现
 * @author Java实战
 */
@Service
@Slf4j
public class UserServiceImpl implements UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Override
    public User getUserById(Long id) {
        log.info("根据ID获取用户，ID: {}", id);
        
        try {
            if (id == null || id <= 0) {
                throw new IllegalArgumentException("用户ID不能为空或小于等于0");
            }
            
            User user = userRepository.findById(id).orElse(null);
            
            if (user == null) {
                log.warn("用户不存在，ID: {}", id);
                return null;
            }
            
            log.info("获取用户成功，ID: {}, 用户名: {}", id, user.getUsername());
            
            return user;
            
        } catch (Exception e) {
            log.error("根据ID获取用户异常，ID: {}", id, e);
            throw new RuntimeException("获取用户失败: " + e.getMessage());
        }
    }
    
    @Override
    public User getUserByUsername(String username) {
        log.info("根据用户名获取用户，用户名: {}", username);
        
        try {
            if (username == null || username.isEmpty()) {
                throw new IllegalArgumentException("用户名不能为空");
            }
            
            User user = userRepository.findByUsername(username);
            
            if (user == null) {
                log.warn("用户不存在，用户名: {}", username);
                return null;
            }
            
            log.info("获取用户成功，用户名: {}, ID: {}", username, user.getId());
            
            return user;
            
        } catch (Exception e) {
            log.error("根据用户名获取用户异常，用户名: {}", username, e);
            throw new RuntimeException("获取用户失败: " + e.getMessage());
        }
    }
    
    @Override
    public boolean createUser(User user) {
        log.info("创建用户，用户名: {}", user.getUsername());
        
        try {
            if (user == null) {
                throw new IllegalArgumentException("用户信息不能为空");
            }
            
            if (user.getUsername() == null || user.getUsername().isEmpty()) {
                throw new IllegalArgumentException("用户名不能为空");
            }
            
            // 检查用户名是否已存在
            User existingUser = userRepository.findByUsername(user.getUsername());
            if (existingUser != null) {
                log.warn("用户名已存在，用户名: {}", user.getUsername());
                return false;
            }
            
            // 设置默认值
            user.setCreateTime(LocalDateTime.now());
            user.setUpdateTime(LocalDateTime.now());
            user.setStatus("ACTIVE");
            
            // 保存用户
            userRepository.save(user);
            
            log.info("创建用户成功，用户名: {}, ID: {}", user.getUsername(), user.getId());
            
            return true;
            
        } catch (Exception e) {
            log.error("创建用户异常，用户名: {}", user.getUsername(), e);
            throw new RuntimeException("创建用户失败: " + e.getMessage());
        }
    }
    
    @Override
    public boolean updateUser(User user) {
        log.info("更新用户，ID: {}", user.getId());
        
        try {
            if (user == null || user.getId() == null) {
                throw new IllegalArgumentException("用户信息或ID不能为空");
            }
            
            // 检查用户是否存在
            User existingUser = userRepository.findById(user.getId()).orElse(null);
            if (existingUser == null) {
                log.warn("用户不存在，ID: {}", user.getId());
                return false;
            }
            
            // 更新用户信息
            existingUser.setUsername(user.getUsername());
            existingUser.setEmail(user.getEmail());
            existingUser.setPhone(user.getPhone());
            existingUser.setRealName(user.getRealName());
            existingUser.setUpdateTime(LocalDateTime.now());
            
            // 保存用户
            userRepository.save(existingUser);
            
            log.info("更新用户成功，ID: {}, 用户名: {}", user.getId(), user.getUsername());
            
            return true;
            
        } catch (Exception e) {
            log.error("更新用户异常，ID: {}", user.getId(), e);
            throw new RuntimeException("更新用户失败: " + e.getMessage());
        }
    }
    
    @Override
    public boolean deleteUser(Long id) {
        log.info("删除用户，ID: {}", id);
        
        try {
            if (id == null || id <= 0) {
                throw new IllegalArgumentException("用户ID不能为空或小于等于0");
            }
            
            // 检查用户是否存在
            User existingUser = userRepository.findById(id).orElse(null);
            if (existingUser == null) {
                log.warn("用户不存在，ID: {}", id);
                return false;
            }
            
            // 删除用户
            userRepository.deleteById(id);
            
            log.info("删除用户成功，ID: {}", id);
            
            return true;
            
        } catch (Exception e) {
            log.error("删除用户异常，ID: {}", id, e);
            throw new RuntimeException("删除用户失败: " + e.getMessage());
        }
    }
    
    @Override
    public List<User> getUserList(int pageNum, int pageSize) {
        log.info("获取用户列表，页码: {}, 页大小: {}", pageNum, pageSize);
        
        try {
            if (pageNum <= 0 || pageSize <= 0) {
                throw new IllegalArgumentException("页码和页大小必须大于0");
            }
            
            Pageable pageable = PageRequest.of(pageNum - 1, pageSize);
            Page<User> userPage = userRepository.findAll(pageable);
            
            List<User> users = userPage.getContent();
            
            log.info("获取用户列表成功，总数: {}, 当前页: {}", userPage.getTotalElements(), users.size());
            
            return users;
            
        } catch (Exception e) {
            log.error("获取用户列表异常，页码: {}, 页大小: {}", pageNum, pageSize, e);
            throw new RuntimeException("获取用户列表失败: " + e.getMessage());
        }
    }
    
    @Override
    public List<User> getUsersByIds(List<Long> ids) {
        log.info("批量获取用户，ID数量: {}", ids.size());
        
        try {
            if (ids == null || ids.isEmpty()) {
                throw new IllegalArgumentException("用户ID列表不能为空");
            }
            
            List<User> users = userRepository.findAllById(ids);
            
            log.info("批量获取用户成功，请求数量: {}, 实际数量: {}", ids.size(), users.size());
            
            return users;
            
        } catch (Exception e) {
            log.error("批量获取用户异常，ID数量: {}", ids.size(), e);
            throw new RuntimeException("批量获取用户失败: " + e.getMessage());
        }
    }
}

/**
 * 订单服务实现
 * @author Java实战
 */
@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private UserService userService;
    
    @Autowired
    private ProductService productService;
    
    @Override
    public Order getOrderById(Long id) {
        log.info("根据ID获取订单，ID: {}", id);
        
        try {
            if (id == null || id <= 0) {
                throw new IllegalArgumentException("订单ID不能为空或小于等于0");
            }
            
            Order order = orderRepository.findById(id).orElse(null);
            
            if (order == null) {
                log.warn("订单不存在，ID: {}", id);
                return null;
            }
            
            log.info("获取订单成功，ID: {}, 订单号: {}", id, order.getOrderNo());
            
            return order;
            
        } catch (Exception e) {
            log.error("根据ID获取订单异常，ID: {}", id, e);
            throw new RuntimeException("获取订单失败: " + e.getMessage());
        }
    }
    
    @Override
    public boolean createOrder(Order order) {
        log.info("创建订单，用户ID: {}", order.getUserId());
        
        try {
            if (order == null) {
                throw new IllegalArgumentException("订单信息不能为空");
            }
            
            if (order.getUserId() == null) {
                throw new IllegalArgumentException("用户ID不能为空");
            }
            
            // 检查用户是否存在
            User user = userService.getUserById(order.getUserId());
            if (user == null) {
                log.warn("用户不存在，用户ID: {}", order.getUserId());
                return false;
            }
            
            // 检查商品是否存在
            if (order.getProductId() != null) {
                Product product = productService.getProductById(order.getProductId());
                if (product == null) {
                    log.warn("商品不存在，商品ID: {}", order.getProductId());
                    return false;
                }
            }
            
            // 设置默认值
            order.setOrderNo(generateOrderNo());
            order.setCreateTime(LocalDateTime.now());
            order.setUpdateTime(LocalDateTime.now());
            order.setStatus("PENDING");
            
            // 保存订单
            orderRepository.save(order);
            
            log.info("创建订单成功，订单号: {}, ID: {}", order.getOrderNo(), order.getId());
            
            return true;
            
        } catch (Exception e) {
            log.error("创建订单异常，用户ID: {}", order.getUserId(), e);
            throw new RuntimeException("创建订单失败: " + e.getMessage());
        }
    }
    
    @Override
    public boolean updateOrderStatus(Long id, String status) {
        log.info("更新订单状态，ID: {}, 状态: {}", id, status);
        
        try {
            if (id == null || id <= 0) {
                throw new IllegalArgumentException("订单ID不能为空或小于等于0");
            }
            
            if (status == null || status.isEmpty()) {
                throw new IllegalArgumentException("订单状态不能为空");
            }
            
            // 检查订单是否存在
            Order existingOrder = orderRepository.findById(id).orElse(null);
            if (existingOrder == null) {
                log.warn("订单不存在，ID: {}", id);
                return false;
            }
            
            // 更新订单状态
            existingOrder.setStatus(status);
            existingOrder.setUpdateTime(LocalDateTime.now());
            
            // 保存订单
            orderRepository.save(existingOrder);
            
            log.info("更新订单状态成功，ID: {}, 状态: {}", id, status);
            
            return true;
            
        } catch (Exception e) {
            log.error("更新订单状态异常，ID: {}, 状态: {}", id, status, e);
            throw new RuntimeException("更新订单状态失败: " + e.getMessage());
        }
    }
    
    @Override
    public List<Order> getUserOrders(Long userId, int pageNum, int pageSize) {
        log.info("获取用户订单列表，用户ID: {}, 页码: {}, 页大小: {}", userId, pageNum, pageSize);
        
        try {
            if (userId == null || userId <= 0) {
                throw new IllegalArgumentException("用户ID不能为空或小于等于0");
            }
            
            if (pageNum <= 0 || pageSize <= 0) {
                throw new IllegalArgumentException("页码和页大小必须大于0");
            }
            
            Pageable pageable = PageRequest.of(pageNum - 1, pageSize);
            Page<Order> orderPage = orderRepository.findByUserId(userId, pageable);
            
            List<Order> orders = orderPage.getContent();
            
            log.info("获取用户订单列表成功，用户ID: {}, 总数: {}, 当前页: {}", 
                userId, orderPage.getTotalElements(), orders.size());
            
            return orders;
            
        } catch (Exception e) {
            log.error("获取用户订单列表异常，用户ID: {}, 页码: {}, 页大小: {}", 
                userId, pageNum, pageSize, e);
            throw new RuntimeException("获取用户订单列表失败: " + e.getMessage());
        }
    }
    
    @Override
    public boolean cancelOrder(Long id) {
        log.info("取消订单，ID: {}", id);
        
        try {
            if (id == null || id <= 0) {
                throw new IllegalArgumentException("订单ID不能为空或小于等于0");
            }
            
            // 检查订单是否存在
            Order existingOrder = orderRepository.findById(id).orElse(null);
            if (existingOrder == null) {
                log.warn("订单不存在，ID: {}", id);
                return false;
            }
            
            // 检查订单状态
            if (!"PENDING".equals(existingOrder.getStatus())) {
                log.warn("订单状态不允许取消，ID: {}, 状态: {}", id, existingOrder.getStatus());
                return false;
            }
            
            // 更新订单状态
            existingOrder.setStatus("CANCELLED");
            existingOrder.setUpdateTime(LocalDateTime.now());
            
            // 保存订单
            orderRepository.save(existingOrder);
            
            log.info("取消订单成功，ID: {}", id);
            
            return true;
            
        } catch (Exception e) {
            log.error("取消订单异常，ID: {}", id, e);
            throw new RuntimeException("取消订单失败: " + e.getMessage());
        }
    }
    
    /**
     * 生成订单号
     * @return 订单号
     */
    private String generateOrderNo() {
        return "ORD" + System.currentTimeMillis() + RandomUtils.nextInt(1000, 9999);
    }
}

/**
 * Dubbo服务提供者配置
 * @author Java实战
 */
@Configuration
@EnableDubbo
public class DubboProviderConfig {
    
    @Autowired
    private DubboProperties properties;
    
    /**
     * Dubbo服务提供者配置
     * @return 服务提供者配置
     */
    @Bean
    public ProviderConfig providerConfig() {
        ProviderConfig config = new ProviderConfig();
        config.setTimeout(properties.getProvider().getTimeout());
        config.setRetries(properties.getProvider().getRetries());
        config.setLoadbalance(properties.getProvider().getLoadbalance());
        config.setCluster(properties.getProvider().getCluster());
        return config;
    }
    
    /**
     * Dubbo服务提供者配置类
     */
    @Data
    public static class ProviderConfig {
        /**
         * 服务超时时间
         */
        private int timeout = 3000;
        
        /**
         * 重试次数
         */
        private int retries = 2;
        
        /**
         * 负载均衡策略
         */
        private String loadbalance = "random";
        
        /**
         * 集群策略
         */
        private String cluster = "failover";
        
        /**
         * 服务版本
         */
        private String version = "1.0.0";
        
        /**
         * 服务分组
         */
        private String group = "default";
    }
}

/**
 * Dubbo服务提供者实现
 * @author Java实战
 */
@Component
@Slf4j
public class DubboServiceProvider {
    
    @Autowired
    private UserService userService;
    
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private ProductService productService;
    
    /**
     * 启动Dubbo服务
     */
    @PostConstruct
    public void startDubboService() {
        log.info("启动Dubbo服务提供者");
        
        try {
            // 创建应用配置
            ApplicationConfig application = new ApplicationConfig();
            application.setName("dubbo-provider");
            application.setOwner("admin");
            
            // 创建注册中心配置
            RegistryConfig registry = new RegistryConfig();
            registry.setAddress("zookeeper://localhost:2181");
            registry.setProtocol("zookeeper");
            
            // 创建协议配置
            ProtocolConfig protocol = new ProtocolConfig();
            protocol.setName("dubbo");
            protocol.setPort(20880);
            protocol.setThreads(200);
            
            // 创建服务提供者配置
            ProviderConfig provider = new ProviderConfig();
            provider.setTimeout(3000);
            provider.setRetries(2);
            provider.setLoadbalance("random");
            provider.setCluster("failover");
            
            // 创建服务配置
            ServiceConfig<UserService> userServiceConfig = new ServiceConfig<>();
            userServiceConfig.setApplication(application);
            userServiceConfig.setRegistry(registry);
            userServiceConfig.setProtocol(protocol);
            userServiceConfig.setProvider(provider);
            userServiceConfig.setInterface(UserService.class);
            userServiceConfig.setRef(userService);
            userServiceConfig.setVersion("1.0.0");
            userServiceConfig.setGroup("default");
            
            // 导出服务
            userServiceConfig.export();
            
            log.info("Dubbo服务提供者启动成功");
            
        } catch (Exception e) {
            log.error("启动Dubbo服务提供者失败", e);
            throw new RuntimeException("启动Dubbo服务提供者失败", e);
        }
    }
    
    /**
     * 停止Dubbo服务
     */
    @PreDestroy
    public void stopDubboService() {
        log.info("停止Dubbo服务提供者");
        
        try {
            // 停止服务
            // 这里可以添加停止服务的逻辑
            
            log.info("Dubbo服务提供者停止成功");
            
        } catch (Exception e) {
            log.error("停止Dubbo服务提供者失败", e);
        }
    }
}

/**
 * Dubbo服务消费者配置
 * @author Java实战
 */
@Configuration
@EnableDubbo
public class DubboConsumerConfig {
    
    @Autowired
    private DubboProperties properties;
    
    /**
     * Dubbo服务消费者配置
     * @return 服务消费者配置
     */
    @Bean
    public ConsumerConfig consumerConfig() {
        ConsumerConfig config = new ConsumerConfig();
        config.setTimeout(properties.getConsumer().getTimeout());
        config.setRetries(properties.getConsumer().getRetries());
        config.setLoadbalance(properties.getConsumer().getLoadbalance());
        config.setCluster(properties.getConsumer().getCluster());
        return config;
    }
    
    /**
     * Dubbo服务消费者配置类
     */
    @Data
    public static class ConsumerConfig {
        /**
         * 服务超时时间
         */
        private int timeout = 3000;
        
        /**
         * 重试次数
         */
        private int retries = 2;
        
        /**
         * 负载均衡策略
         */
        private String loadbalance = "random";
        
        /**
         * 集群策略
         */
        private String cluster = "failover";
        
        /**
         * 服务版本
         */
        private String version = "1.0.0";
        
        /**
         * 服务分组
         */
        private String group = "default";
    }
}

/**
 * Dubbo服务消费者实现
 * @author Java实战
 */
@Component
@Slf4j
public class DubboServiceConsumer {
    
    @Autowired
    private UserService userService;
    
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private ProductService productService;
    
    /**
     * 测试用户服务
     */
    public void testUserService() {
        log.info("测试用户服务");
        
        try {
            // 测试获取用户
            User user = userService.getUserById(1L);
            if (user != null) {
                log.info("获取用户成功，用户名: {}", user.getUsername());
            } else {
                log.warn("用户不存在");
            }
            
            // 测试创建用户
            User newUser = new User();
            newUser.setUsername("testuser");
            newUser.setEmail("test@example.com");
            newUser.setPhone("13800138000");
            newUser.setRealName("测试用户");
            
            boolean createResult = userService.createUser(newUser);
            if (createResult) {
                log.info("创建用户成功");
            } else {
                log.warn("创建用户失败");
            }
            
            // 测试获取用户列表
            List<User> users = userService.getUserList(1, 10);
            log.info("获取用户列表成功，数量: {}", users.size());
            
        } catch (Exception e) {
            log.error("测试用户服务异常", e);
        }
    }
    
    /**
     * 测试订单服务
     */
    public void testOrderService() {
        log.info("测试订单服务");
        
        try {
            // 测试创建订单
            Order order = new Order();
            order.setUserId(1L);
            order.setProductId(1L);
            order.setQuantity(2);
            order.setAmount(new BigDecimal("100.00"));
            
            boolean createResult = orderService.createOrder(order);
            if (createResult) {
                log.info("创建订单成功，订单号: {}", order.getOrderNo());
            } else {
                log.warn("创建订单失败");
            }
            
            // 测试获取订单
            Order retrievedOrder = orderService.getOrderById(order.getId());
            if (retrievedOrder != null) {
                log.info("获取订单成功，订单号: {}", retrievedOrder.getOrderNo());
            } else {
                log.warn("订单不存在");
            }
            
            // 测试更新订单状态
            boolean updateResult = orderService.updateOrderStatus(order.getId(), "CONFIRMED");
            if (updateResult) {
                log.info("更新订单状态成功");
            } else {
                log.warn("更新订单状态失败");
            }
            
        } catch (Exception e) {
            log.error("测试订单服务异常", e);
        }
    }
    
    /**
     * 测试商品服务
     */
    public void testProductService() {
        log.info("测试商品服务");
        
        try {
            // 测试获取商品
            Product product = productService.getProductById(1L);
            if (product != null) {
                log.info("获取商品成功，商品名称: {}", product.getName());
            } else {
                log.warn("商品不存在");
            }
            
            // 测试获取商品列表
            List<Product> products = productService.getProductList(1L, 1, 10);
            log.info("获取商品列表成功，数量: {}", products.size());
            
            // 测试搜索商品
            List<Product> searchResults = productService.searchProducts("手机", 1, 10);
            log.info("搜索商品成功，数量: {}", searchResults.size());
            
        } catch (Exception e) {
            log.error("测试商品服务异常", e);
        }
    }
    
    /**
     * 测试所有服务
     */
    public void testAllServices() {
        log.info("测试所有Dubbo服务");
        
        try {
            testUserService();
            testOrderService();
            testProductService();
            
            log.info("所有Dubbo服务测试完成");
            
        } catch (Exception e) {
            log.error("测试所有Dubbo服务异常", e);
        }
    }
}

/**
 * Dubbo监控配置
 * @author Java实战
 */
@Configuration
@EnableDubbo
public class DubboMonitorConfig {
    
    @Autowired
    private DubboProperties properties;
    
    /**
     * Dubbo监控配置
     * @return 监控配置
     */
    @Bean
    public MonitorConfig monitorConfig() {
        MonitorConfig config = new MonitorConfig();
        config.setAddress(properties.getMonitor().getAddress());
        config.setProtocol(properties.getMonitor().getProtocol());
        config.setInterval(properties.getMonitor().getInterval());
        return config;
    }
    
    /**
     * Dubbo监控服务
     * @return 监控服务
     */
    @Bean
    public DubboMonitorService dubboMonitorService() {
        return new DubboMonitorService();
    }
}

/**
 * Dubbo监控服务
 * @author Java实战
 */
@Service
@Slf4j
public class DubboMonitorService {
    
    @Autowired
    private DubboProperties properties;
    
    /**
     * 获取Dubbo服务状态
     * @return 服务状态
     */
    public DubboServiceStatus getServiceStatus() {
        log.info("获取Dubbo服务状态");
        
        try {
            DubboServiceStatus status = new DubboServiceStatus();
            
            // 设置基本信息
            status.setServiceName(properties.getApplication().getName());
            status.setServiceVersion(properties.getApplication().getVersion());
            status.setServiceEnvironment(properties.getApplication().getEnvironment());
            
            // 设置注册中心信息
            status.setRegistryAddress(properties.getRegistry().getAddress());
            status.setRegistryProtocol(properties.getRegistry().getProtocol());
            
            // 设置协议信息
            status.setProtocolName(properties.getProtocol().getName());
            status.setProtocolPort(properties.getProtocol().getPort());
            status.setProtocolThreads(properties.getProtocol().getThreads());
            
            // 设置监控信息
            status.setMonitorAddress(properties.getMonitor().getAddress());
            status.setMonitorEnabled(properties.getMonitor().isEnable());
            
            // 设置状态
            status.setStatus("RUNNING");
            status.setLastCheckTime(LocalDateTime.now());
            
            log.info("获取Dubbo服务状态成功");
            
            return status;
            
        } catch (Exception e) {
            log.error("获取Dubbo服务状态异常", e);
            return null;
        }
    }
    
    /**
     * 获取Dubbo服务统计信息
     * @return 服务统计信息
     */
    public DubboServiceStatistics getServiceStatistics() {
        log.info("获取Dubbo服务统计信息");
        
        try {
            DubboServiceStatistics statistics = new DubboServiceStatistics();
            
            // 设置统计信息
            statistics.setTotalRequests(1000L);
            statistics.setSuccessRequests(950L);
            statistics.setFailureRequests(50L);
            statistics.setAverageResponseTime(100L);
            statistics.setMaxResponseTime(500L);
            statistics.setMinResponseTime(10L);
            
            // 设置时间信息
            statistics.setStartTime(LocalDateTime.now().minusHours(1));
            statistics.setEndTime(LocalDateTime.now());
            statistics.setLastUpdateTime(LocalDateTime.now());
            
            log.info("获取Dubbo服务统计信息成功");
            
            return statistics;
            
        } catch (Exception e) {
            log.error("获取Dubbo服务统计信息异常", e);
            return null;
        }
    }
    
    /**
     * 健康检查
     * @return 健康状态
     */
    public boolean healthCheck() {
        log.info("Dubbo服务健康检查");
        
        try {
            // 检查注册中心连接
            boolean registryHealthy = checkRegistryHealth();
            
            // 检查服务状态
            boolean serviceHealthy = checkServiceHealth();
            
            // 检查监控状态
            boolean monitorHealthy = checkMonitorHealth();
            
            boolean healthy = registryHealthy && serviceHealthy && monitorHealthy;
            
            log.info("Dubbo服务健康检查结果: {}", healthy);
            
            return healthy;
            
        } catch (Exception e) {
            log.error("Dubbo服务健康检查异常", e);
            return false;
        }
    }
    
    /**
     * 检查注册中心健康状态
     * @return 是否健康
     */
    private boolean checkRegistryHealth() {
        try {
            // 这里可以添加检查注册中心连接的逻辑
            return true;
        } catch (Exception e) {
            log.error("检查注册中心健康状态异常", e);
            return false;
        }
    }
    
    /**
     * 检查服务健康状态
     * @return 是否健康
     */
    private boolean checkServiceHealth() {
        try {
            // 这里可以添加检查服务状态的逻辑
            return true;
        } catch (Exception e) {
            log.error("检查服务健康状态异常", e);
            return false;
        }
    }
    
    /**
     * 检查监控健康状态
     * @return 是否健康
     */
    private boolean checkMonitorHealth() {
        try {
            // 这里可以添加检查监控状态的逻辑
            return true;
        } catch (Exception e) {
            log.error("检查监控健康状态异常", e);
            return false;
        }
    }
}