@Component
public class SmsUtil {
    public void send(String phone, String message) {
        // 发送短信逻辑
    }
}

@Service
public class OrderService {
    public Order createOrder(Long userId, List<OrderItem> items) {
        // 创建订单业务逻辑
        return new Order();
    }
}

@Repository
public class UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public User findById(Long id) {
        return jdbcTemplate.queryForObject(
            "SELECT * FROM t_user WHERE id = ?", User.class, id);
    }
}

@Controller
public class HealthController {
    // 可用于非REST场景，如视图渲染
}

@RestController
@RequestMapping("/api/users")
public class UserController {

    @GetMapping("/{id}")
    public Result<User> getUser(@PathVariable Long id) {
        return Result.success(userService.getById(id));
    }
}

@Service
public class OrderService {

    @Autowired                      // 按类型注入
    private UserService userService;

    @Autowired                      // 注入集合：注入所有类型匹配的Bean
    private List<PaymentStrategy> paymentStrategies;

    @Autowired                      // 注入Map：key=Bean名称, value=Bean实例
    private Map<String, PaymentStrategy> strategyMap;
}

@Service
public class PaymentFacade {

    @Autowired
    @Qualifier("alipay")           // 指定注入名为"alipay"的Bean
    private PaymentStrategy paymentStrategy;
}

@Component("alipay")
class AlipayStrategy implements PaymentStrategy { }

@Component("wechat")
class WechatStrategy implements PaymentStrategy { }

@Configuration
public class PaymentConfig {

    @Bean
    @Primary                       // 标记为首选
    public PaymentStrategy defaultPayment() {
        return new AlipayStrategy();
    }

    @Bean
    public PaymentStrategy wechatPayment() {
        return new WechatStrategy();
    }
}

@Service
public class UserService {

    @Resource(name = "userMapper") // 按名称注入，JDK原生注解
    private UserMapper userMapper;
}

@Configuration
public class AppConfig {

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    @Bean
    public ObjectMapper objectMapper() {
        return new ObjectMapper()
            .setSerializationInclusion(JsonInclude.Include.NON_NULL);
    }
}

@Configuration
public class DataSourceConfig {

    @Bean(name = "primaryDataSource")     // 自定义Bean名称
    @Primary
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mall");
        config.setUsername("root");
        config.setPassword("123456");
        return new HikariDataSource(config);
    }
}

@Configuration
@ComponentScan(basePackages = {
    "com.mallshop.mallbusiness",
    "com.mallshop.mallcommon"      // 扫描额外的包
})
public class AppConfig {
}

@Configuration
@Import({RedisConfig.class, MqConfig.class})  // 合并其他配置
public class AppConfig {
}

@Configuration
@ImportResource("classpath:spring-legacy.xml") // 兼容老XML配置
public class AppConfig {
}

@Configuration
public class ScopeConfig {

    @Bean
    @Scope("prototype")            // 每次获取都创建新实例
    public OrderReportGenerator reportGenerator() {
        return new OrderReportGenerator();
    }

    @Bean
    @Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
    // request作用域：每个HTTP请求一个实例（Web环境）
    public RequestContext requestContext() {
        return new RequestContext();
    }
}

@Service
@Lazy                            // 延迟初始化，首次使用时才创建
public class ReportService {
    public ReportService() {
        System.out.println("ReportService 被创建了");
    }
}

@Service
public class CacheWarmUpService {

    @Autowired
    private ProductDao productDao;

    @PostConstruct
    public void init() {
        // 依赖注入完成后执行：预热热门商品缓存
        List<Product> hotProducts = productDao.findHot(100);
        // 加载到Redis缓存...
        System.out.println("缓存预热完成，加载了 " + hotProducts.size() + " 条商品");
    }
}

@Service
public class ScheduledTaskManager {

    private ScheduledExecutorService executor = Executors.newScheduledThreadPool(4);

    @PreDestroy
    public void cleanup() {
        // 容器销毁前：优雅关闭线程池
        executor.shutdown();
        System.out.println("定时任务线程池已关闭");
    }
}

@Component
public class OssConfig {

    @Value("${oss.endpoint}")
    private String endpoint;

    @Value("${oss.access-key}")
    private String accessKey;

    @Value("${oss.secret-key}")
    private String secretKey;

    @Value("${oss.max-size:10485760}")  // 带默认值：10MB
    private Long maxSize;

    @Value("#{${oss.region-map}}")       // SpEL：注入Map
    private Map<String, String> regionMap;
}

oss:
  endpoint: https://oss-cn-hangzhou.aliyuncs.com
  access-key: LTAI5txxx
  secret-key: xxxxxxx
  region-map: "{'hangzhou': 'oss-cn-hangzhou', 'beijing': 'oss-cn-beijing'}"

@Configuration
@PropertySource("classpath:wechat-sdk.properties")   // 加载额外配置
@PropertySource("classpath:alipay-sdk.properties")
public class ThirdPartyConfig {

    @Value("${wechat.app-id}")
    private String wechatAppId;

    @Value("${alipay.app-id}")
    private String alipayAppId;
}

@Configuration
public class EnvConfig {

    @Bean
    @Profile("dev")                // 仅在dev环境生效
    public SmsService devSmsService() {
        return new MockSmsService();    // 开发环境用Mock，不真发短信
    }

    @Bean
    @Profile("prod")               // 仅在prod环境生效
    public SmsService prodSmsService() {
        return new AliyunSmsService();  // 生产环境用阿里云短信
    }
}

spring:
  profiles:
    active: dev

@Service
@DependsOn("cacheInitializer")    // 确保cacheInitializer先初始化
public class CacheQueryService {
}

@Component("cacheInitializer")
class CacheInitializer {
    @PostConstruct
    public void init() {
        // 先加载缓存基础数据
    }
}

@Configuration
@Order(1)                         // 数字越小优先级越高
public class DatabaseConfig {
}

@Configuration
@Order(2)
public class CacheConfig {
}

@SpringBootApplication
public class MallApplication {
    public static void main(String[] args) {
        SpringApplication.run(MallApplication.class, args);
    }
}

@Configuration
@EnableAutoConfiguration(exclude = {
    DataSourceAutoConfiguration.class   // 排除你不想要的自动配置
})
public class CustomAutoConfig {
}

@Component
@ConfigurationProperties(prefix = "mall.thread-pool")
public class ThreadPoolProperties {

    private Integer coreSize = 10;   // 可设默认值
    private Integer maxSize = 50;
    private Integer queueCapacity = 200;
    private String namePrefix = "mall-exec-";

    // getter / setter 必须存在
    public Integer getCoreSize() { return coreSize; }
    public void setCoreSize(Integer coreSize) { this.coreSize = coreSize; }
    // ... 其他getter/setter
}

mall:
  thread-pool:
    core-size: 20
    max-size: 100
    queue-capacity: 500
    name-prefix: "biz-exec-"

@Configuration
@EnableConfigurationProperties(ThreadPoolProperties.class) // 激活配置绑定
public class ThreadPoolConfig {

    @Bean
    public ThreadPoolExecutor bizExecutor(ThreadPoolProperties props) {
        return new ThreadPoolExecutor(
            props.getCoreSize(),
            props.getMaxSize(),
            60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(props.getQueueCapacity()),
            new ThreadFactoryBuilder().setNamePrefix(props.getNamePrefix()).build()
        );
    }
}

@Aspect
@Component
public class LoggingAspect {

    // 切点：匹配service包下所有类的所有方法
    @Pointcut("execution(* com.mallshop.mallbusiness.service..*.*(..))")
    public void serviceLayer() {
    }

    @Before("serviceLayer()")
    public void logBefore(JoinPoint joinPoint) {
        String method = joinPoint.getSignature().toShortString();
        Object[] args = joinPoint.getArgs();
        System.out.println(">>> 调用前：" + method + " 参数=" + Arrays.toString(args));
    }

    @AfterReturning(value = "serviceLayer()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        String method = joinPoint.getSignature().toShortString();
        System.out.println("<<< 调用成功：" + method + " 返回值=" + result);
    }

    @AfterThrowing(value = "serviceLayer()", throwing = "ex")
    public void logAfterThrowing(JoinPoint joinPoint, Exception ex) {
        String method = joinPoint.getSignature().toShortString();
        System.out.println("!!! 调用异常：" + method + " 异常=" + ex.getMessage());
    }

    @Around("serviceLayer()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();    // 执行目标方法
        long elapsed = System.currentTimeMillis() - start;
        System.out.println("方法耗时：" + elapsed + "ms");
        return result;
    }
}

@Configuration
@EnableAspectJAutoProxy           // 显式开启AOP代理
public class AopConfig {
}

@Service
public class OrderService {

    @Autowired
    private OrderDao orderDao;
    @Autowired
    private StockService stockService;

    @Transactional(rollbackFor = Exception.class)  // 任何异常都回滚
    public void createOrder(OrderCreateReq req) {
        // 这两步操作在同一个事务中
        orderDao.insertOrder(req.getOrder());
        stockService.deductStock(req.getSkuId(), req.getQuantity());
    }

    @Transactional(readOnly = true)                // 只读事务（性能优化）
    public Order queryOrder(Long orderId) {
        return orderDao.findById(orderId);
    }

    @Transactional(
        propagation = Propagation.REQUIRES_NEW,   // 挂起当前事务，开启新事务
        isolation = Isolation.READ_COMMITTED,     // 读已提交隔离级别
        timeout = 30                              // 超时30秒
    )
    public void createPaymentRecord(Payment payment) {
        paymentDao.insert(payment);
    }
}

@Configuration
@EnableTransactionManagement
public class TxConfig {
}

@Service
public class NotificationService {

    @Async
    public void sendRegisterEmail(String email) {
        // 这个方法会在独立的线程中执行
        // 调用方不会等待
        System.out.println(Thread.currentThread().getName() + " 正在发送邮件...");
        try { Thread.sleep(3000); } catch (InterruptedException e) { }
        System.out.println("邮件发送完成：" + email);
    }
}

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(200);
        executor.setThreadNamePrefix("async-");
        executor.initialize();
        return executor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (ex, method, params) ->
            System.err.println("异步方法异常：" + method.getName() + " " + ex.getMessage());
    }
}

@Component
public class ScheduledTasks {

    @Scheduled(cron = "0 0 3 * * ?")         // 每天凌晨3:00执行
    public void dailyReport() {
        System.out.println("生成每日报表...");
    }

    @Scheduled(fixedRate = 60000)            // 每60秒执行一次（以上次开始时间计）
    public void checkOrderTimeout() {
        System.out.println("检查超时未支付订单...");
    }

    @Scheduled(fixedDelay = 30000)           // 上次执行结束后30秒再执行
    public void cleanExpiredSession() {
        System.out.println("清理过期会话...");
    }
}

@Configuration
@EnableScheduling
public class ScheduleConfig {
}

@Service
public class ProductService {

    @Cacheable(
        value = "product",               // 缓存名称（类似命名空间）
        key = "#productId",              // SpEL：缓存的key
        unless = "#result == null"       // 结果为null时不缓存
    )
    public Product getById(Long productId) {
        // 第一次调用走数据库，后续从缓存取
        return productDao.findById(productId);
    }

    @Cacheable(
        value = "product-list",
        key = "'category:' + #categoryId + ':page:' + #page",
        condition = "#page <= 10"        // 仅缓存前10页
    )
    public List<Product> listByCategory(Long categoryId, int page) {
        return productDao.findByCategory(categoryId, page);
    }
}

@Service
public class ProductService {

    @CachePut(value = "product", key = "#product.id")
    public Product update(Product product) {
        productDao.update(product);
        return product;                  // 返回值会更新缓存
    }
}

@Service
public class ProductService {

    @CacheEvict(value = "product", key = "#productId")
    public void delete(Long productId) {
        productDao.deleteById(productId);
    }

    @CacheEvict(value = {"product", "product-list"}, allEntries = true)
    public void clearAllCache() {
        // 清空所有product相关缓存
    }
}

@Service
public class ProductService {

    @Caching(
        cacheable = {
            @Cacheable(value = "product", key = "#productId")
        },
        put = {
            @CachePut(value = "product-detail", key = "#result.skuCode")
        },
        evict = {
            @CacheEvict(value = "product-hot", allEntries = true)
        }
    )
    public Product getProductFullInfo(Long productId) {
        return productDao.findFullInfo(productId);
    }
}

@Service
@CacheConfig(cacheNames = "product")     // 统一指定缓存名称
public class ProductCacheService {

    @Cacheable(key = "#productId")       // 无需再写cacheNames
    public Product getById(Long productId) {
        return productDao.findById(productId);
    }

    @CacheEvict(key = "#productId")
    public void evict(Long productId) {
    }
}

@Configuration
@EnableCaching
public class CacheConfig {
}

@RestController
@RequestMapping("/api/users")
@Validated                        // 类级别：使方法参数校验生效
public class UserController {

    @PostMapping
    public Result createUser(@Valid @RequestBody UserCreateReq req) {
        // @Valid触发对req的校验
        userService.create(req);
        return Result.success();
    }

    @GetMapping
    public Result list(@Valid @PageableDefault Pageable pageable) {
        return Result.success(userService.list(pageable));
    }
}

public class UserCreateReq {

    @NotBlank(message = "用户名不能为空")
    @Size(min = 2, max = 20, message = "用户名长度2 ~ 20位")
    private String username;

    @NotBlank(message = "密码不能为空")
    @Size(min = 6, max = 32, message = "密码长度6 ~ 32位")
    private String password;

    @NotBlank(message = "手机号不能为空")
    @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式错误")
    private String phone;

    @Email(message = "邮箱格式错误")
    private String email;

    @Min(value = 0, message = "年龄不能为负数")
    @Max(value = 150, message = "年龄不能超过150")
    private Integer age;
}

@Entity
@Table(name = "t_user")                  // 映射到数据库表名
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 主键自增
    private Long id;

    @Column(name = "username", length = 50, nullable = false, unique = true)
    private String username;

    @Column(name = "real_name", length = 20)
    private String realName;

    @Column(name = "age")
    private Integer age;

    @Enumerated(EnumType.STRING)          // 枚举存为字符串
    @Column(name = "status")
    private UserStatus status;

    @Lob                                    // 大文本
    @Column(name = "remark")
    private String remark;

    @Version                                // 乐观锁版本号
    private Integer version;

    @CreatedDate                            // 自动设置创建时间（需配合@EnableJpaAuditing）
    private LocalDateTime createTime;

    @LastModifiedDate                       // 自动设置更新时间
    private LocalDateTime updateTime;

    @Transient                              // 不映射到数据库
    private String extraInfo;

    // getter / setter 省略
}

@Entity
@Table(name = "t_order")
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // 多对一：多个订单属于一个用户
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id", foreignKey = @ForeignKey(ConstraintMode.NO_CONSTRAINT))
    private User user;

    // 一对多：一个订单有多个订单明细
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderItem> items = new ArrayList<>();
}

@Entity
@Table(name = "t_order_item")
public class OrderItem {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "order_id")
    private Order order;

    // 一对一：一个订单明细对应一个商品SKU
    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "sku_id")
    private Sku sku;
}

@Entity
@Table(name = "t_role")
public class Role {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // 多对多：一个用户可以有多个角色
    @ManyToMany
    @JoinTable(
        name = "t_user_role",
        joinColumns = @JoinColumn(name = "role_id"),
        inverseJoinColumns = @JoinColumn(name = "user_id")
    )
    private List<User> users;
}

public interface UserRepository extends JpaRepository<User, Long> {

    // 方法命名自动解析为SQL
    List<User> findByUsernameLike(String username);

    // JPQL自定义查询
    @Query("SELECT u FROM User u WHERE u.status = :status AND u.age > :minAge")
    List<User> findActiveUsers(@Param("status") UserStatus status,
                               @Param("minAge") Integer minAge);

    // 原生SQL
    @Query(value = "SELECT * FROM t_user WHERE age > ?1 LIMIT ?2",
           nativeQuery = true)
    List<User> findTopByAge(Integer age, int limit);

    // 更新/删除操作必须加@Modifying
    @Modifying
    @Query("UPDATE User u SET u.status = :status WHERE u.id IN :ids")
    int batchUpdateStatus(@Param("status") UserStatus status,
                          @Param("ids") List<Long> ids);
}

// 1. 定义事件
public class UserRegisterEvent extends ApplicationEvent {
    private final Long userId;
    public UserRegisterEvent(Object source, Long userId) {
        super(source);
        this.userId = userId;
    }
    public Long getUserId() { return userId; }
}

// 2. 发布事件
@Service
public class UserService {

    @Autowired
    private ApplicationEventPublisher publisher;

    @Transactional
    public void register(UserCreateReq req) {
        User user = userDao.save(req.toUser());
        publisher.publishEvent(new UserRegisterEvent(this, user.getId()));
        // 发布事件后立即返回，监听器异步执行
    }
}

// 3. 监听事件
@Component
public class UserEventListener {

    @EventListener
    public void handleRegister(UserRegisterEvent event) {
        System.out.println("用户注册成功，发送欢迎邮件：" + event.getUserId());
    }
}

@Component
public class UserEventListener {

    @TransactionalEventListener(
        phase = TransactionPhase.AFTER_COMMIT,      // 事务提交后执行
        fallbackExecution = true                     // 无事务时也执行
    )
    public void afterRegister(UserRegisterEvent event) {
        // 只有事务提交成功后才执行
        // 如果注册失败回滚了，这里的逻辑不会触发
        sendWelcomeEmail(event.getUserId());
    }
}

@Configuration
public class StorageConfig {

    @Bean
    @ConditionalOnClass(name = "com.aliyun.oss.OSS")  // 有阿里云OSS依赖才创建
    public StorageService aliyunStorage() {
        return new AliyunOssStorageService();
    }

    @Bean
    @ConditionalOnMissingClass("com.aliyun.oss.OSS")  // 没有OSS依赖时创建
    public StorageService localStorage() {
        return new LocalFileStorageService();
    }
}

@Configuration
public class CacheConfig {

    @Bean
    @ConditionalOnMissingBean(CacheManager.class)  // 用户没自定义时才自动配置
    public CacheManager defaultCacheManager() {
        return new ConcurrentMapCacheManager();
    }
}

@Configuration
@ConditionalOnBean(DataSource.class)              // 有数据源时才创建JdbcTemplate
public class JdbcConfig {

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource ds) {
        return new JdbcTemplate(ds);
    }
}

@Configuration
public class FeatureFlagConfig {

    @Bean
    @ConditionalOnProperty(
        name = "mall.feature.sms.enabled",   // 配置项名称
        havingValue = "true",                // 期望的值
        matchIfMissing = false               // 配置项不存在时：不创建
    )
    public SmsService smsService() {
        return new AliyunSmsService();
    }
}

mall:
  feature:
    sms:
      enabled: true         # 控制短信服务是否启用

@Configuration
public class MqConfig {

    @Bean
    @ConditionalOnExpression(
        "'${mall.env}' == 'prod' and ${mall.mq.enabled:false}"
    )
    public MessageQueueService rocketMqService() {
        return new RocketMqService();
    }
}

@Configuration
@ConditionalOnWebApplication               // 仅在Web应用中生效
public class WebOnlyConfig {
    // 配置拦截器等Web专有组件
}

@Configuration
@ConditionalOnNotWebApplication            // 仅在非Web应用中生效
public class NonWebConfig {
    // 批处理任务、命令行工具等
}

<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
</dependency>

@Service
public class RemotePaymentService {

    @Retryable(
        value = {HttpServerErrorException.class, TimeoutException.class},
        maxAttempts = 3,                              // 最多重试3次
        backoff = @Backoff(delay = 2000, multiplier = 2) // 重试间隔2秒，每次翻倍
    )
    public PaymentResult callRemotePay(PaymentRequest request) {
        // 调用第三方支付接口（可能超时或服务异常）
        return restTemplate.postForObject(
            "https://api.pay.com/v1/pay", request, PaymentResult.class);
    }
}

@Service
public class RemotePaymentService {

    @Retryable(
        value = {HttpServerErrorException.class, TimeoutException.class},
        maxAttempts = 3,
        backoff = @Backoff(delay = 2000, multiplier = 2)
    )
    public PaymentResult callRemotePay(PaymentRequest request) {
        return restTemplate.postForObject(
            "https://api.pay.com/v1/pay", request, PaymentResult.class);
    }

    @Recover
    public PaymentResult recover(HttpServerErrorException ex,
                                  PaymentRequest request) {
        // 重试3次都失败后走降级：记录异常信息，返回降级结果
        System.err.println("支付接口调用失败，进入降级处理：" + ex.getMessage());
        return PaymentResult.fail("支付服务暂时不可用，请稍后重试");
    }
}

@Configuration
@EnableRetry
public class RetryConfig {
}

@SpringBootTest
class OrderServiceTest {

    @Autowired
    private OrderService orderService;

    @Test
    void testCreateOrder() {
        Order order = orderService.createOrder(1L, List.of(
            new OrderItem(1001L, 2)
        ));
        assertNotNull(order.getId());
    }
}