<!-- Web开发起步依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- 数据访问起步依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<!-- 安全框架起步依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

<!-- 测试起步依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

/**
 * SpringBoot版本选择指南
 */
public class VersionSelectionGuide {
    
    /**
     * 生产环境版本选择
     */
    public void productionVersionSelection() {
        // 推荐使用LTS版本
        // SpringBoot 2.7.x (Java 8+)
        // SpringBoot 3.0.x (Java 17+)
        
        // 考虑因素：
        // 1. Java版本兼容性
        // 2. 第三方库支持
        // 3. 团队技术栈
        // 4. 迁移成本
    }
    
    /**
     * 新项目版本选择
     */
    public void newProjectVersionSelection() {
        // 建议使用最新稳定版本
        // SpringBoot 3.1.x (推荐)
        
        // 优势：
        // 1. 最新特性支持
        // 2. 更好的性能
        // 3. 安全更新
        // 4. 长期支持
    }
}

/**
 * SpringBoot与Spring Framework关系
 */
public class SpringRelationship {
    
    /**
     * SpringBoot是Spring Framework的扩展
     */
    public void springBootExtension() {
        // SpringBoot = Spring Framework + 自动配置 + 起步依赖 + 内嵌服务器
        
        // 1. 基于Spring Framework
        // 2. 简化配置过程
        // 3. 提供生产就绪特性
        // 4. 约定优于配置
    }
    
    /**
     * 核心组件关系
     */
    public void coreComponentRelation() {
        // ApplicationContext (Spring Framework)
        // ↓
        // SpringApplication (SpringBoot)
        // ↓
        // 自动配置 + 起步依赖
        // ↓
        // 完整的应用程序
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <!-- 继承SpringBoot父项目 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.5</version>
        <relativePath/>
    </parent>
    
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    
    <properties>
        <java.version>17</java.version>
    </properties>
    
    <dependencies>
        <!-- Web起步依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- 测试起步依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <!-- SpringBoot Maven插件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

/**
 * SpringBoot应用主启动类
 * @SpringBootApplication 是一个组合注解，包含：
 * - @SpringBootConfiguration：标识配置类
 * - @EnableAutoConfiguration：启用自动配置
 * - @ComponentScan：组件扫描
 */
@SpringBootApplication
public class DemoApplication {
    
    public static void main(String[] args) {
        // 启动SpringBoot应用
        SpringApplication.run(DemoApplication.class, args);
    }
    
    /**
     * 自定义SpringApplication配置
     */
    public static void customSpringApplication(String[] args) {
        SpringApplication app = new SpringApplication(DemoApplication.class);
        
        // 设置应用类型
        app.setWebApplicationType(WebApplicationType.SERVLET);
        
        // 设置Banner模式
        app.setBannerMode(Banner.Mode.CONSOLE);
        
        // 添加监听器
        app.addListeners(new ApplicationStartedEventListener());
        
        // 启动应用
        app.run(args);
    }
}

/**
 * 第一个REST控制器
 */
@RestController
@RequestMapping("/api")
public class HelloController {
    
    /**
     * 简单的GET请求处理
     */
    @GetMapping("/hello")
    public String hello() {
        return "Hello, SpringBoot!";
    }
    
    /**
     * 带参数的请求处理
     */
    @GetMapping("/hello/{name}")
    public Map<String, Object> helloWithName(@PathVariable String name) {
        Map<String, Object> result = new HashMap<>();
        result.put("message", "Hello, " + name + "!");
        result.put("timestamp", LocalDateTime.now());
        return result;
    }
    
    /**
     * POST请求处理
     */
    @PostMapping("/hello")
    public ResponseEntity<String> createHello(@RequestBody Map<String, String> request) {
        String name = request.get("name");
        if (name == null || name.trim().isEmpty()) {
            return ResponseEntity.badRequest().body("Name is required");
        }
        
        return ResponseEntity.ok("Hello, " + name + "! Created successfully.");
    }
}

# 使用Maven运行
./mvnw spring-boot:run

# 或者先打包再运行
./mvnw clean package
java -jar target/demo-0.0.1-SNAPSHOT.jar

# 指定端口运行
java -jar target/demo-0.0.1-SNAPSHOT.jar --server.port=8081

# 指定配置文件
java -jar target/demo-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev

/**
 * 包结构设计原则
 */
public class PackageStructureGuide {
    
    /**
     * 按层分包（推荐）
     */
    public void layerBasedPackaging() {
        // com.example.demo
        // ├── controller/     # 控制器层
        // ├── service/        # 服务层  
        // ├── repository/     # 数据访问层
        // ├── model/          # 实体类
        // ├── dto/            # 数据传输对象
        // ├── config/         # 配置类
        // ├── exception/      # 异常处理
        // └── util/           # 工具类
        
        // 优点：
        // 1. 结构清晰
        // 2. 职责分明
        // 3. 易于维护
    }
    
    /**
     * 按功能分包
     */
    public void featureBasedPackaging() {
        // com.example.demo
        // ├── user/           # 用户模块
        // │   ├── UserController.java
        // │   ├── UserService.java
        // │   ├── UserRepository.java
        // │   └── User.java
        // ├── product/        # 产品模块
        // │   ├── ProductController.java
        // │   ├── ProductService.java
        // │   ├── ProductRepository.java
        // │   └── Product.java
        // └── common/         # 公共模块
        
        // 优点：
        // 1. 高内聚
        // 2. 模块化
        // 3. 便于团队协作
    }
}

# 服务器配置
server:
  port: 8080
  servlet:
    context-path: /api
    encoding:
      charset: UTF-8
      enabled: true
  tomcat:
    uri-encoding: UTF-8
    max-threads: 200
    min-spare-threads: 10

# Spring配置
spring:
  # 应用配置
  application:
    name: demo-application
  
  # 环境配置
  profiles:
    active: dev
  
  # 数据源配置
  datasource:
    url: jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: ${MYSQL_PASSWORD:123456}
    driver-class-name: com.mysql.cj.jdbc.Driver
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000
  
  # JPA配置
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL8Dialect
        format_sql: true
  
  # Redis配置
  redis:
    host: localhost
    port: 6379
    password: ${REDIS_PASSWORD:}
    database: 0
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: -1ms
  
  # 缓存配置
  cache:
    type: redis
    redis:
      time-to-live: 600000
      cache-null-values: false
  
  # Jackson配置
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: Asia/Shanghai
    default-property-inclusion: non_null

# 日志配置
logging:
  level:
    root: INFO
    com.example.demo: DEBUG
    org.springframework.web: DEBUG
    org.hibernate.SQL: DEBUG
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"
    file: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"
  file:
    name: logs/application.log
    max-size: 10MB
    max-history: 30

# Actuator配置
management:
  endpoints:
    web:
      exposure:
        include: "*"
      base-path: /actuator
  endpoint:
    health:
      show-details: always
    info:
      enabled: true
  info:
    env:
      enabled: true
    java:
      enabled: true

# 自定义配置
app:
  name: Demo Application
  version: 1.0.0
  description: SpringBoot示例应用
  thread-pool:
    core-size: 5
    max-size: 10
    queue-capacity: 25
  jwt:
    secret: ${JWT_SECRET:mySecretKey}
    expiration: 86400000

# application-dev.yml (开发环境)
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/demo_dev
    username: dev_user
    password: dev_password
  
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true
  
  redis:
    host: localhost
    port: 6379

logging:
  level:
    root: DEBUG
    com.example.demo: TRACE

---
# application-prod.yml (生产环境)
spring:
  datasource:
    url: jdbc:mysql://prod-db:3306/demo_prod
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
  
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false
  
  redis:
    host: ${REDIS_HOST}
    port: ${REDIS_PORT}
    password: ${REDIS_PASSWORD}

logging:
  level:
    root: WARN
    com.example.demo: INFO
  file:
    name: /var/log/demo/application.log

management:
  endpoints:
    web:
      exposure:
        include: "health,info,metrics"

/**
 * 条件注解使用示例
 */
@Configuration
public class CustomAutoConfiguration {
    
    @ConditionalOnClass(DataSource.class)
    @ConditionalOnMissingBean
    public DataSource dataSource() {
        // 数据源配置
    }
    
    @ConditionalOnProperty(prefix = "custom", name = "enabled", havingValue = "true")
    @ConditionalOnBean(DataSource.class)
    public CustomService customService() {
        // 自定义服务配置
    }
}

/**
 * 配置属性绑定
 */
@ConfigurationProperties(prefix = "app")
@Validated
public class AppProperties {
    @NotEmpty
    private String name;
    
    @Min(0)
    @Max(100)
    private int threadPool;
    
    // getter and setter
}

/**
 * SpringBoot应用主类
 */
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

/**
 * 自定义配置类
 */
@Configuration
@EnableConfigurationProperties(AppProperties.class)
public class CustomConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public CustomService customService() {
        return new CustomService();
    }
}

/**
 * RESTful接口示例
 */
@RestController
@RequestMapping("/api")
public class UserController {
    
    @GetMapping("/users")
    public List<User> getUsers() {
        // 获取用户列表
    }
    
    @PostMapping("/users")
    public ResponseEntity<User> createUser(@Valid @RequestBody User user) {
        // 创建用户
    }
    
    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        // 更新用户
    }
    
    @DeleteMapping("/users/{id}")
    public void deleteUser(@PathVariable Long id) {
        // 删除用户
    }
}

/**
 * 全局异常处理
 */
@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleException(Exception ex) {
        // 通用异常处理
    }
    
    @ExceptionHandler(ValidationException.class)
    public ResponseEntity<ErrorResponse> handleValidationException(ValidationException ex) {
        // 参数校验异常处理
    }
    
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResponse> handleBusinessException(BusinessException ex) {
        // 业务异常处理
    }
}

/**
 * JPA实体类
 */
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String username;
    
    @Column(nullable = false)
    private String password;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List<Order> orders;
}

/**
 * JPA Repository
 */
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByUsername(String username);
    
    @Query("SELECT u FROM User u WHERE u.username LIKE %:keyword%")
    List<User> searchUsers(@Param("keyword") String keyword);
}

/**
 * 事务管理示例
 */
@Service
@Transactional
public class UserService {
    
    @Transactional(readOnly = true)
    public User getUser(Long id) {
        // 查询用户
    }
    
    @Transactional(rollbackFor = Exception.class)
    public User createUser(User user) {
        // 创建用户
    }
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateUser(User user) {
        // 更新用户
    }
}

/**
 * 安全配置
 */
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/api/public/**").permitAll()
                .antMatchers("/api/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            .and()
            .formLogin()
            .and()
            .oauth2Login()
            .and()
            .csrf().disable();
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

/**
 * JWT工具类
 */
@Component
public class JwtTokenProvider {
    
    @Value("${jwt.secret}")
    private String jwtSecret;
    
    @Value("${jwt.expiration}")
    private long jwtExpiration;
    
    public String generateToken(Authentication authentication) {
        // 生成JWT token
    }
    
    public boolean validateToken(String token) {
        // 验证JWT token
    }
    
    public String getUsernameFromToken(String token) {
        // 从JWT token中获取用户名
    }
}

/**
 * 服务注册配置
 */
@SpringBootApplication
@EnableDiscoveryClient
public class ServiceApplication {
    
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

/**
 * 熔断降级示例
 */
@Service
public class UserService {
    
    @HystrixCommand(fallbackMethod = "getDefaultUser",
        commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000"),
            @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "20"),
            @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50"),
            @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "5000")
        })
    public User getUser(Long id) {
        // 调用用户服务
    }
    
    public User getDefaultUser(Long id) {
        // 降级返回默认用户
    }
}

# application.yml
spring:
  profiles:
    active: dev
  datasource:
    url: jdbc:mysql://localhost:3306/demo
    username: root
    password: ${MYSQL_PASSWORD}
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
  redis:
    host: localhost
    port: 6379
  cache:
    type: redis
    redis:
      time-to-live: 60000

server:
  port: 8080
  servlet:
    context-path: /api

logging:
  level:
    root: INFO
    com.example: DEBUG
  file:
    name: logs/application.log

management:
  endpoints:
    web:
      exposure:
        include: "*"
  endpoint:
    health:
      show-details: always

/**
 * SpringBoot启动流程分析
 */
public class SpringBootStartupAnalysis {
    
    /**
     * 1. 创建SpringApplication
     */
    public void createSpringApplication() {
        // 设置应用类型
        // SERVLET, REACTIVE, NONE
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        
        // 加载ApplicationContextInitializer
        setInitializers(getSpringFactoriesInstances(ApplicationContextInitializer.class));
        
        // 加载ApplicationListener
        setListeners(getSpringFactoriesInstances(ApplicationListener.class));
        
        // 推断主应用类
        this.mainApplicationClass = deduceMainApplicationClass();
    }
    
    /**
     * 2. 准备环境
     */
    public void prepareEnvironment() {
        // 创建环境对象
        // StandardServletEnvironment, StandardReactiveWebEnvironment
        ConfigurableEnvironment environment = getOrCreateEnvironment();
        
        // 配置环境
        configureEnvironment(environment, args);
        
        // 绑定环境变量
        ConfigurationPropertySources.attach(environment);
        
        // 发布环境准备事件
        listeners.environmentPrepared(environment);
    }
    
    /**
     * 3. 创建ApplicationContext
     */
    public void createApplicationContext() {
        // 根据应用类型创建上下文
        // AnnotationConfigServletWebServerApplicationContext
        // AnnotationConfigReactiveWebServerApplicationContext
        // AnnotationConfigApplicationContext
        context = createApplicationContext();
        
        // 准备上下文
        prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        
        // 加载Bean定义
        load(context, sources.toArray(new Object[0]));
    }
    
    /**
     * 4. 刷新上下文
     */
    public void refreshContext() {
        // 刷新上下文
        refreshContext(context);
        
        // 注册关闭钩子
        registerShutdownHook();
    }
    
    /**
     * 5. 执行Runner
     */
    public void callRunners() {
        // 获取所有Runner
        Collection<ApplicationRunner> applicationRunners = context.getBeansOfType(ApplicationRunner.class).values();
        Collection<CommandLineRunner> commandLineRunners = context.getBeansOfType(CommandLineRunner.class).values();
        
        // 排序并执行
        AnnotationAwareOrderComparator.sort(applicationRunners);
        AnnotationAwareOrderComparator.sort(commandLineRunners);
        
        // 先执行ApplicationRunner
        for (ApplicationRunner runner : applicationRunners) {
            runner.run(args);
        }
        
        // 再执行CommandLineRunner
        for (CommandLineRunner runner : commandLineRunners) {
            runner.run(args.getSourceArgs());
        }
    }
}

/**
 * 自动配置原理深度解析
 */
public class AutoConfigurationPrinciple {
    
    /**
     * @EnableAutoConfiguration注解分析
     */
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage  // 自动配置包
    @Import(AutoConfigurationImportSelector.class)  // 导入自动配置选择器
    public @interface EnableAutoConfiguration {
        String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
        Class<?>[] exclude() default {};
        String[] excludeName() default {};
    }
    
    /**
     * AutoConfigurationImportSelector核心逻辑
     */
    public class AutoConfigurationImportSelector implements DeferredImportSelector {
        
        @Override
        public String[] selectImports(AnnotationMetadata annotationMetadata) {
            if (!isEnabled(annotationMetadata)) {
                return NO_IMPORTS;
            }
            
            // 1. 获取自动配置元数据
            AutoConfigurationMetadata autoConfigurationMetadata = 
                AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
            
            // 2. 获取自动配置条目
            AutoConfigurationEntry autoConfigurationEntry = 
                getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
            
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
        
        /**
         * 获取自动配置条目
         */
        protected AutoConfigurationEntry getAutoConfigurationEntry(
                AutoConfigurationMetadata autoConfigurationMetadata,
                AnnotationMetadata annotationMetadata) {
            
            if (!isEnabled(annotationMetadata)) {
                return EMPTY_ENTRY;
            }
            
            // 获取注解属性
            AnnotationAttributes attributes = getAttributes(annotationMetadata);
            
            // 获取候选配置
            List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
            
            // 去重
            configurations = removeDuplicates(configurations);
            
            // 获取排除项
            Set<String> exclusions = getExclusions(annotationMetadata, attributes);
            
            // 检查排除项
            checkExcludedClasses(configurations, exclusions);
            
            // 移除排除项
            configurations.removeAll(exclusions);
            
            // 过滤配置
            configurations = filter(configurations, autoConfigurationMetadata);
            
            // 触发自动配置导入事件
            fireAutoConfigurationImportEvents(configurations, exclusions);
            
            return new AutoConfigurationEntry(configurations, exclusions);
        }
        
        /**
         * 获取候选配置
         */
        protected List<String> getCandidateConfigurations(
                AnnotationMetadata metadata, AnnotationAttributes attributes) {
            
            // 从spring.factories文件中加载配置
            List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
                getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
            
            Assert.notEmpty(configurations, 
                "No auto configuration classes found in META-INF/spring.factories. " +
                "If you are using a custom packaging, make sure that file is correct.");
            
            return configurations;
        }
    }
    
    /**
     * 典型的自动配置类示例 - WebMvcAutoConfiguration
     */
    @Configuration(proxyBeanMethods = false)
    @ConditionalOnWebApplication(type = Type.SERVLET)
    @ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
    @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
    @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
    @AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
            ValidationAutoConfiguration.class })
    public class WebMvcAutoConfiguration {
        
        @Configuration(proxyBeanMethods = false)
        @Import(EnableWebMvcConfiguration.class)
        @EnableConfigurationProperties({ WebMvcProperties.class, ResourceProperties.class })
        @Order(0)
        public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer {
            
            private final WebMvcProperties mvcProperties;
            private final ResourceProperties resourceProperties;
            
            public WebMvcAutoConfigurationAdapter(WebMvcProperties mvcProperties, 
                                                ResourceProperties resourceProperties) {
                this.mvcProperties = mvcProperties;
                this.resourceProperties = resourceProperties;
            }
            
            @Override
            public void configurePathMatch(PathMatchConfigurer configurer) {
                // 配置路径匹配
                configurer.setUseTrailingSlashMatch(this.mvcProperties.getPathmatch().isUseTrailingSlashMatch());
                configurer.setUseSuffixPatternMatch(this.mvcProperties.getPathmatch().isUseSuffixPattern());
            }
            
            @Override
            public void addResourceHandlers(ResourceHandlerRegistry registry) {
                // 配置静态资源处理
                if (!this.resourceProperties.isAddMappings()) {
                    return;
                }
                Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
                CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
                
                if (!registry.hasMappingForPattern("/webjars/**")) {
                    customizeResourceHandlerRegistration(registry.addResourceHandler("/webjars/**")
                            .addResourceLocations("classpath:/META-INF/resources/webjars/")
                            .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
                }
                
                String staticPathPattern = this.mvcProperties.getStaticPathPattern();
                if (!registry.hasMappingForPattern(staticPathPattern)) {
                    customizeResourceHandlerRegistration(registry.addResourceHandler(staticPathPattern)
                            .addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations()))
                            .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
                }
            }
        }
    }
}

/**
 * 条件注解完整解析
 */
public class ConditionalAnnotations {
    
    /**
     * 类路径条件注解
     */
    @ConditionalOnClass(DataSource.class)  // 类路径存在DataSource类
    @ConditionalOnMissingClass("com.example.CustomDataSource")  // 类路径不存在指定类
    public DataSource dataSource() {
        return new HikariDataSource();
    }
    
    /**
     * Bean条件注解
     */
    @ConditionalOnBean(DataSource.class)  // 容器中存在DataSource类型的Bean
    @ConditionalOnMissingBean(name = "customService")  // 容器中不存在名为customService的Bean
    @ConditionalOnSingleCandidate(DataSource.class)  // 容器中只有一个DataSource Bean或有一个主要的
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
    
    /**
     * 属性条件注解
     */
    @ConditionalOnProperty(
        prefix = "app.feature",  // 属性前缀
        name = "enabled",        // 属性名
        havingValue = "true",    // 期望值
        matchIfMissing = false   // 属性不存在时是否匹配
    )
    public FeatureService featureService() {
        return new FeatureService();
    }
    
    /**
     * 资源条件注解
     */
    @ConditionalOnResource(resources = "classpath:config/custom.properties")
    public CustomConfig customConfig() {
        return new CustomConfig();
    }
    
    /**
     * Web应用条件注解
     */
    @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
    public ServletWebServerFactory servletWebServerFactory() {
        return new TomcatServletWebServerFactory();
    }
    
    @ConditionalOnNotWebApplication
    public CommandLineRunner commandLineRunner() {
        return args -> System.out.println("Non-web application started");
    }
    
    /**
     * 表达式条件注解
     */
    @ConditionalOnExpression("${app.feature.enabled:false} and ${app.environment} == 'production'")
    public ProductionService productionService() {
        return new ProductionService();
    }
    
    /**
     * Java版本条件注解
     */
    @ConditionalOnJava(JavaVersion.EIGHT)
    public Java8SpecificService java8Service() {
        return new Java8SpecificService();
    }
    
    /**
     * JNDI条件注解
     */
    @ConditionalOnJndi("java:comp/env/jdbc/MyDataSource")
    public DataSource jndiDataSource() {
        // JNDI数据源配置
        return null;
    }
}

/**
 * 自定义条件注解示例
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnCustomCondition.class)
public @interface ConditionalOnCustom {
    String value() default "";
    String[] profiles() default {};
}

/**
 * 自定义条件实现
 */
public class OnCustomCondition implements Condition {
    
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 获取注解属性
        MultiValueMap<String, Object> attributes = 
            metadata.getAllAnnotationAttributes(ConditionalOnCustom.class.getName());
        
        if (attributes == null) {
            return false;
        }
        
        String value = (String) attributes.getFirst("value");
        String[] profiles = (String[]) attributes.getFirst("profiles");
        
        Environment environment = context.getEnvironment();
        
        // 检查属性条件
        if (StringUtils.hasText(value)) {
            String property = environment.getProperty("custom.condition." + value);
            if (!"true".equals(property)) {
                return false;
            }
        }
        
        // 检查环境条件
        if (profiles != null && profiles.length > 0) {
            return environment.acceptsProfiles(Profiles.of(profiles));
        }
        
        return true;
    }
}

/**
 * 使用自定义条件注解
 */
@Configuration
public class CustomConfiguration {
    
    @Bean
    @ConditionalOnCustom(value = "feature1", profiles = {"dev", "test"})
    public Feature1Service feature1Service() {
        return new Feature1Service();
    }
    
    @Bean
    @ConditionalOnCustom("feature2")
    public Feature2Service feature2Service() {
        return new Feature2Service();
    }
}

# src/main/resources/META-INF/spring.factories
# 自动配置类 - 最重要的配置
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.autoconfigure.CustomServiceAutoConfiguration,\
com.example.autoconfigure.CustomCacheAutoConfiguration,\
com.example.autoconfigure.CustomSecurityAutoConfiguration

# 应用监听器 - 监听应用生命周期事件
org.springframework.context.ApplicationListener=\
com.example.listener.CustomApplicationStartedListener,\
com.example.listener.CustomApplicationReadyListener

# 环境后处理器 - 处理环境配置
org.springframework.boot.env.EnvironmentPostProcessor=\
com.example.env.CustomEnvironmentPostProcessor

# 失败分析器 - 提供友好的错误信息
org.springframework.boot.diagnostics.FailureAnalyzer=\
com.example.diagnostics.CustomDataSourceFailureAnalyzer,\
com.example.diagnostics.CustomConnectionFailureAnalyzer

# 应用上下文初始化器 - 初始化应用上下文
org.springframework.context.ApplicationContextInitializer=\
com.example.context.CustomApplicationContextInitializer

# 自动配置导入过滤器 - 过滤不需要的自动配置
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
com.example.filter.CustomAutoConfigurationImportFilter

# Bean后处理器 - 处理Bean的创建和初始化
org.springframework.beans.factory.config.BeanPostProcessor=\
com.example.processor.CustomBeanPostProcessor

# 属性源定位器 - 定位配置文件
org.springframework.boot.env.PropertySourceLoader=\
com.example.loader.CustomPropertySourceLoader

# 运行监听器 - 监听SpringBoot运行过程
org.springframework.boot.SpringApplicationRunListener=\
com.example.listener.CustomSpringApplicationRunListener

/**
 * 使用自定义Starter的完整示例
 */
// 在应用中使用
@SpringBootApplication
public class Application {
    
    @Autowired
    private CustomService customService;
    
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
    
    @EventListener(ApplicationReadyEvent.class)
    public void onApplicationReady() {
        String result = customService.processData("test data");
        System.out.println("Result: " + result);
    }
}

// application.yml配置示例
/*
custom:
  service:
    enabled: true
    name: my-custom-service
    timeout: 10000
    retry-count: 5
    health-check: true
    metrics: true
    pool:
      max-active: 20
      max-idle: 10
      min-idle: 2
      max-wait: 5000

# 启用健康检查端点
management:
  endpoints:
    web:
      exposure:
        include: health,metrics,info
  endpoint:
    health:
      show-details: always
*/

/**
 * 自定义环境后处理器示例
 */
public class CustomEnvironmentPostProcessor implements EnvironmentPostProcessor {
    
    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
        // 添加自定义属性源
        Properties properties = new Properties();
        properties.setProperty("custom.service.auto-configured", "true");
        properties.setProperty("custom.service.version", "1.0.0");
        
        PropertiesPropertySource propertySource = new PropertiesPropertySource("customServiceProperties", properties);
        environment.getPropertySources().addLast(propertySource);
        
        // 根据环境设置默认值
        String activeProfile = environment.getProperty("spring.profiles.active", "default");
        if ("production".equals(activeProfile)) {
            properties.setProperty("custom.service.pool.max-active", "50");
            properties.setProperty("custom.service.timeout", "30000");
        }
    }
}

/**
 * 自定义失败分析器示例
 */
public class CustomServiceFailureAnalyzer extends AbstractFailureAnalyzer<CustomServiceException> {
    
    @Override
    protected FailureAnalysis analyze(Throwable rootFailure, CustomServiceException cause) {
        return new FailureAnalysis(
            "Custom service failed to start: " + cause.getMessage(),
            "Please check your custom.service configuration in application.yml. " +
            "Ensure that custom.service.enabled=true and all required properties are set.",
            cause
        );
    }
}

/**
 * 自定义应用上下文初始化器示例
 */
public class CustomApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        // 注册自定义Bean定义
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) applicationContext.getBeanFactory();
        
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(CustomInitializationService.class);
        builder.addPropertyValue("initializationTime", System.currentTimeMillis());
        
        registry.registerBeanDefinition("customInitializationService", builder.getBeanDefinition());
        
        // 添加自定义属性源
        ConfigurableEnvironment environment = applicationContext.getEnvironment();
        Map<String, Object> customProperties = new HashMap<>();
        customProperties.put("custom.initialization.timestamp", System.currentTimeMillis());
        customProperties.put("custom.initialization.source", "ApplicationContextInitializer");
        
        MapPropertySource propertySource = new MapPropertySource("customInitialization", customProperties);
        environment.getPropertySources().addFirst(propertySource);
    }
}

/**
 * 复杂配置属性绑定示例
 */
@ConfigurationProperties(prefix = "app")
@Validated
@Data
public class AppProperties {
    
    /**
     * 应用基本信息
     */
    @NotBlank(message = "应用名称不能为空")
    private String name;
    
    @NotBlank(message = "应用版本不能为空")
    private String version;
    
    /**
     * 应用描述
     */
    private String description = "SpringBoot应用";
    
    /**
     * 数据库配置
     */
    @Valid
    private Database database = new Database();
    
    /**
     * 缓存配置
     */
    @Valid
    private Cache cache = new Cache();
    
    /**
     * 安全配置
     */
    @Valid
    private Security security = new Security();
    
    /**
     * 线程池配置
     */
    @Valid
    private ThreadPool threadPool = new ThreadPool();
    
    /**
     * 功能开关配置
     */
    private Map<String, Boolean> features = new HashMap<>();
    
    /**
     * 外部服务配置
     */
    private Map<String, ExternalService> externalServices = new HashMap<>();
    
    @Data
    @Validated
    public static class Database {
        @NotBlank(message = "数据库URL不能为空")
        private String url;
        
        @NotBlank(message = "数据库用户名不能为空")
        private String username;
        
        @NotBlank(message = "数据库密码不能为空")
        private String password;
        
        @Min(value = 1, message = "最大连接池大小不能小于1")
        @Max(value = 100, message = "最大连接池大小不能超过100")
        private int maxPoolSize = 10;
        
        @Min(value = 0, message = "最小连接池大小不能小于0")
        private int minPoolSize = 5;
        
        @Min(value = 1000, message = "连接超时时间不能小于1000ms")
        private long connectionTimeout = 30000;
        
        @Min(value = 60000, message = "空闲超时时间不能小于60000ms")
        private long idleTimeout = 600000;
        
        private boolean showSql = false;
        private boolean formatSql = false;
    }
    
    @Data
    @Validated
    public static class Cache {
        @NotBlank(message = "缓存类型不能为空")
        private String type = "redis";
        
        @Min(value = 60, message = "默认过期时间不能小于60秒")
        private long defaultExpiration = 3600;
        
        private Map<String, Long> expirations = new HashMap<>();
        
        @Valid
        private Redis redis = new Redis();
        
        @Data
        public static class Redis {
            @NotBlank(message = "Redis主机不能为空")
            private String host = "localhost";
            
            @Min(value = 1, message = "Redis端口不能小于1")
            @Max(value = 65535, message = "Redis端口不能超过65535")
            private int port = 6379;
            
            private String password;
            
            @Min(value = 0, message = "数据库索引不能小于0")
            @Max(value = 15, message = "数据库索引不能超过15")
            private int database = 0;
            
            @Min(value = 1000, message = "连接超时时间不能小于1000ms")
            private long timeout = 5000;
            
            @Valid
            private Pool pool = new Pool();
            
            @Data
            public static class Pool {
                @Min(value = 1, message = "最大活跃连接数不能小于1")
                private int maxActive = 8;
                
                @Min(value = 0, message = "最大空闲连接数不能小于0")
                private int maxIdle = 8;
                
                @Min(value = 0, message = "最小空闲连接数不能小于0")
                private int minIdle = 0;
                
                @Min(value = -1, message = "最大等待时间不能小于-1")
                private long maxWait = -1;
            }
        }
    }
    
    @Data
    @Validated
    public static class Security {
        private boolean enabled = true;
        
        @Valid
        private Jwt jwt = new Jwt();
        
        @Valid
        private OAuth2 oauth2 = new OAuth2();
        
        private List<String> ignoredPaths = Arrays.asList("/health", "/info", "/metrics");
        
        @Data
        public static class Jwt {
            @NotBlank(message = "JWT密钥不能为空")
            private String secret = "default-secret-key-change-in-production";
            
            @Min(value = 60000, message = "JWT过期时间不能小于60000ms")
            private long expiration = 86400000; // 24小时
            
            @NotBlank(message = "JWT请求头不能为空")
            private String header = "Authorization";
            
            @NotBlank(message = "JWT前缀不能为空")
            private String prefix = "Bearer ";
            
            private String issuer = "SpringBoot-App";
        }
        
        @Data
        public static class OAuth2 {
            private Map<String, Provider> providers = new HashMap<>();
            
            @Data
            public static class Provider {
                @NotBlank(message = "客户端ID不能为空")
                private String clientId;
                
                @NotBlank(message = "客户端密钥不能为空")
                private String clientSecret;
                
                @NotBlank(message = "重定向URI不能为空")
                private String redirectUri;
                
                private List<String> scopes = new ArrayList<>();
                
                private String authorizationUri;
                private String tokenUri;
                private String userInfoUri;
            }
        }
    }
    
    @Data
    @Validated
    public static class ThreadPool {
        @Min(value = 1, message = "核心线程数不能小于1")
        private int coreSize = 5;
        
        @Min(value = 1, message = "最大线程数不能小于1")
        private int maxSize = 10;
        
        @Min(value = 0, message = "队列容量不能小于0")
        private int queueCapacity = 25;
        
        @Min(value = 60, message = "线程空闲时间不能小于60秒")
        private int keepAliveSeconds = 60;
        
        @NotBlank(message = "线程名前缀不能为空")
        private String threadNamePrefix = "async-";
        
        private boolean waitForTasksToCompleteOnShutdown = true;
        
        @Min(value = 0, message = "关闭等待时间不能小于0")
        private int awaitTerminationSeconds = 60;
    }
    
    @Data
    @Validated
    public static class ExternalService {
        @NotBlank(message = "服务URL不能为空")
        private String url;
        
        @Min(value = 1000, message = "连接超时时间不能小于1000ms")
        private long connectTimeout = 5000;
        
        @Min(value = 1000, message = "读取超时时间不能小于1000ms")
        private long readTimeout = 10000;
        
        @Min(value = 0, message = "重试次数不能小于0")
        private int retryCount = 3;
        
        private Map<String, String> headers = new HashMap<>();
        
        private boolean enabled = true;
    }
}

/**
 * 配置属性使用示例
 */
@Configuration
@EnableConfigurationProperties(AppProperties.class)
@Slf4j
public class AppConfiguration {
    
    private final AppProperties appProperties;
    
    public AppConfiguration(AppProperties appProperties) {
        this.appProperties = appProperties;
        log.info("Application configuration loaded: {}", appProperties.getName());
    }
    
    /**
     * 配置数据源
     */
    @Bean
    @Primary
    public DataSource dataSource() {
        AppProperties.Database dbConfig = appProperties.getDatabase();
        
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(dbConfig.getUrl());
        config.setUsername(dbConfig.getUsername());
        config.setPassword(dbConfig.getPassword());
        config.setMaximumPoolSize(dbConfig.getMaxPoolSize());
        config.setMinimumIdle(dbConfig.getMinPoolSize());
        config.setConnectionTimeout(dbConfig.getConnectionTimeout());
        config.setIdleTimeout(dbConfig.getIdleTimeout());
        
        return new HikariDataSource(config);
    }
    
    /**
     * 配置Redis连接工厂
     */
    @Bean
    @ConditionalOnProperty(prefix = "app.cache", name = "type", havingValue = "redis")
    public LettuceConnectionFactory redisConnectionFactory() {
        AppProperties.Cache.Redis redisConfig = appProperties.getCache().getRedis();
        
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName(redisConfig.getHost());
        config.setPort(redisConfig.getPort());
        config.setDatabase(redisConfig.getDatabase());
        if (StringUtils.hasText(redisConfig.getPassword())) {
            config.setPassword(redisConfig.getPassword());
        }
        
        LettuceClientConfiguration.Builder clientConfig = LettuceClientConfiguration.builder();
        clientConfig.commandTimeout(Duration.ofMillis(redisConfig.getTimeout()));
        
        AppProperties.Cache.Redis.Pool poolConfig = redisConfig.getPool();
        GenericObjectPoolConfig<?> poolConfiguration = new GenericObjectPoolConfig<>();
        poolConfiguration.setMaxTotal(poolConfig.getMaxActive());
        poolConfiguration.setMaxIdle(poolConfig.getMaxIdle());
        poolConfiguration.setMinIdle(poolConfig.getMinIdle());
        poolConfiguration.setMaxWaitMillis(poolConfig.getMaxWait());
        
        clientConfig.poolingClientConfiguration(LettucePoolingClientConfiguration.builder()
                .poolConfig(poolConfiguration)
                .build());
        
        return new LettuceConnectionFactory(config, clientConfig.build());
    }
    
    /**
     * 配置线程池
     */
    @Bean
    @Primary
    public TaskExecutor taskExecutor() {
        AppProperties.ThreadPool threadPoolConfig = appProperties.getThreadPool();
        
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(threadPoolConfig.getCoreSize());
        executor.setMaxPoolSize(threadPoolConfig.getMaxSize());
        executor.setQueueCapacity(threadPoolConfig.getQueueCapacity());
        executor.setKeepAliveSeconds(threadPoolConfig.getKeepAliveSeconds());
        executor.setThreadNamePrefix(threadPoolConfig.getThreadNamePrefix());
        executor.setWaitForTasksToCompleteOnShutdown(threadPoolConfig.isWaitForTasksToCompleteOnShutdown());
        executor.setAwaitTerminationSeconds(threadPoolConfig.getAwaitTerminationSeconds());
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        
        return executor;
    }
    
    /**
     * 配置JWT工具
     */
    @Bean
    @ConditionalOnProperty(prefix = "app.security", name = "enabled", havingValue = "true")
    public JwtTokenProvider jwtTokenProvider() {
        AppProperties.Security.Jwt jwtConfig = appProperties.getSecurity().getJwt();
        
        return new JwtTokenProvider(
            jwtConfig.getSecret(),
            jwtConfig.getExpiration(),
            jwtConfig.getHeader(),
            jwtConfig.getPrefix(),
            jwtConfig.getIssuer()
        );
    }
    
    /**
     * 配置外部服务客户端
     */
    @Bean
    public Map<String, RestTemplate> externalServiceClients() {
        Map<String, RestTemplate> clients = new HashMap<>();
        
        appProperties.getExternalServices().forEach((serviceName, serviceConfig) -> {
            if (serviceConfig.isEnabled()) {
                RestTemplate restTemplate = new RestTemplate();
                
                // 配置超时时间
                HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
                factory.setConnectTimeout((int) serviceConfig.getConnectTimeout());
                factory.setReadTimeout((int) serviceConfig.getReadTimeout());
                restTemplate.setRequestFactory(factory);
                
                // 添加拦截器设置默认头部
                restTemplate.getInterceptors().add((request, body, execution) -> {
                    serviceConfig.getHeaders().forEach((key, value) -> {
                        request.getHeaders().add(key, value);
                    });
                    return execution.execute(request, body);
                });
                
                clients.put(serviceName, restTemplate);
                log.info("Created RestTemplate for external service: {}", serviceName);
            }
        });
        
        return clients;
    }
}

app:
  name: SpringBoot Demo Application
  version: 1.0.0
  description: 这是一个SpringBoot示例应用
  
  database:
    url: jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: ${DB_PASSWORD:password123}
    max-pool-size: 20
    min-pool-size: 5
    connection-timeout: 30000
    idle-timeout: 600000
    show-sql: true
    format-sql: true
  
  cache:
    type: redis
    default-expiration: 3600
    expirations:
      user: 1800
      product: 7200
      order: 3600
    redis:
      host: ${REDIS_HOST:localhost}
      port: ${REDIS_PORT:6379}
      password: ${REDIS_PASSWORD:}
      database: 0
      timeout: 5000
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: -1
  
  security:
    enabled: true
    jwt:
      secret: ${JWT_SECRET:my-super-secret-jwt-key-for-production-use}
      expiration: 86400000
      header: Authorization
      prefix: "Bearer "
      issuer: SpringBoot-Demo-App
    oauth2:
      providers:
        google:
          client-id: ${GOOGLE_CLIENT_ID}
          client-secret: ${GOOGLE_CLIENT_SECRET}
          redirect-uri: http://localhost:8080/oauth2/callback/google
          scopes:
            - openid
            - profile
            - email
          authorization-uri: https://accounts.google.com/o/oauth2/auth
          token-uri: https://oauth2.googleapis.com/token
          user-info-uri: https://www.googleapis.com/oauth2/v2/userinfo
        github:
          client-id: ${GITHUB_CLIENT_ID}
          client-secret: ${GITHUB_CLIENT_SECRET}
          redirect-uri: http://localhost:8080/oauth2/callback/github
          scopes:
            - user:email
          authorization-uri: https://github.com/login/oauth/authorize
          token-uri: https://github.com/login/oauth/access_token
          user-info-uri: https://api.github.com/user
    ignored-paths:
      - /health
      - /info
      - /metrics
      - /swagger-ui/**
      - /v3/api-docs/**
  
  thread-pool:
    core-size: 5
    max-size: 10
    queue-capacity: 25
    keep-alive-seconds: 60
    thread-name-prefix: "async-task-"
    wait-for-tasks-to-complete-on-shutdown: true
    await-termination-seconds: 60
  
  features:
    user-registration: true
    email-verification: true
    sms-notification: false
    payment-gateway: true
    analytics: true
  
  external-services:
    payment-service:
      url: ${PAYMENT_SERVICE_URL:http://localhost:8081}
      connect-timeout: 5000
      read-timeout: 10000
      retry-count: 3
      enabled: true
      headers:
        Content-Type: application/json
        X-API-Version: v1
    notification-service:
      url: ${NOTIFICATION_SERVICE_URL:http://localhost:8082}
      connect-timeout: 3000
      read-timeout: 8000
      retry-count: 2
      enabled: true
      headers:
        Content-Type: application/json
        Authorization: Bearer ${NOTIFICATION_API_KEY}
    analytics-service:
      url: ${ANALYTICS_SERVICE_URL:http://localhost:8083}
      connect-timeout: 2000
      read-timeout: 5000
      retry-count: 1
      enabled: ${ANALYTICS_ENABLED:false}
      headers:
        Content-Type: application/json

/**
 * 配置属性使用示例
 */
@Configuration
@EnableConfigurationProperties(AppProperties.class)
public class AppConfiguration {
    
    private final AppProperties appProperties;
    
    public AppConfiguration(AppProperties appProperties) {
        this.appProperties = appProperties;
    }
    
    @Bean
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        AppProperties.Database db = appProperties.getDatabase();
        
        config.setJdbcUrl(db.getUrl());
        config.setUsername(db.getUsername());
        config.setPassword(db.getPassword());
        config.setMaximumPoolSize(db.getMaxPoolSize());
        config.setMinimumIdle(db.getMinPoolSize());
        config.setConnectionTimeout(db.getConnectionTimeout().toMillis());
        
        return new HikariDataSource(config);
    }
    
    @Bean
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        AppProperties.ThreadPool pool = appProperties.getThreadPool();
        
        executor.setCorePoolSize(pool.getCoreSize());
        executor.setMaxPoolSize(pool.getMaxSize());
        executor.setQueueCapacity(pool.getQueueCapacity());
        executor.setKeepAliveSeconds((int) pool.getKeepAliveTime().getSeconds());
        executor.setThreadNamePrefix(pool.getThreadNamePrefix());
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        
        return executor;
    }
    
    @Bean
    @ConditionalOnProperty(prefix = "app.cache", name = "enabled", havingValue = "true")
    public CacheManager cacheManager() {
        AppProperties.Cache cache = appProperties.getCache();
        
        switch (cache.getType()) {
            case REDIS:
                return createRedisCacheManager(cache);
            case CAFFEINE:
                return createCaffeineCacheManager(cache);
            default:
                return new NoOpCacheManager();
        }
    }
}

@SpringBootApplication
// 等价于
@SpringBootConfiguration  // 标识配置类
@EnableAutoConfiguration  // 启用自动配置
@ComponentScan           // 组件扫描

// 自动配置示例
@Configuration
@ConditionalOnClass(DataSource.class)
@ConditionalOnMissingBean(DataSource.class)
public class DataSourceAutoConfiguration {
    
    @Bean
    public DataSource dataSource() {
        return new HikariDataSource();
    }
}

# application.yml (主配置文件)
spring:
  profiles:
    active: dev

---
# application-dev.yml (开发环境)
server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/demo_dev
    username: dev_user
    password: dev_password

---
# application-prod.yml (生产环境)
server:
  port: 80
spring:
  datasource:
    url: jdbc:mysql://prod-server:3306/demo_prod
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}

@Configuration
@Profile("dev")
public class DevConfiguration {
    @Bean
    public DataSource devDataSource() {
        return new H2DataSource();
    }
}

@Configuration
@Profile("prod")
public class ProdConfiguration {
    @Bean
    public DataSource prodDataSource() {
        return new HikariDataSource();
    }
}

// 1. 创建配置属性类
@ConfigurationProperties(prefix = "my.service")
@Data
public class MyServiceProperties {
    private boolean enabled = true;
    private String name = "default";
    private int timeout = 5000;
}

// 2. 创建服务类
public class MyService {
    private final MyServiceProperties properties;
    
    public MyService(MyServiceProperties properties) {
        this.properties = properties;
    }
    
    public String process(String data) {
        return "Processed by " + properties.getName() + ": " + data;
    }
}

// 3. 创建自动配置类
@Configuration
@EnableConfigurationProperties(MyServiceProperties.class)
@ConditionalOnProperty(prefix = "my.service", name = "enabled", havingValue = "true", matchIfMissing = true)
@ConditionalOnClass(MyService.class)
public class MyServiceAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    public MyService myService(MyServiceProperties properties) {
        return new MyService(properties);
    }
}

// 4. 创建spring.factories文件
// META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.MyServiceAutoConfiguration

java -jar app.jar --server.port=8081 --spring.profiles.active=prod

@Value("${java:comp/env/server.port}")
private int serverPort;

java -Dserver.port=8081 -jar app.jar

export SERVER_PORT=8081
export SPRING_PROFILES_ACTIVE=prod

# application-prod.yml
server:
  port: 8081

# application.yml
server:
  port: 8080

@Configuration
@PropertySource("classpath:custom.properties")
public class CustomConfig {
    @Value("${custom.property}")
    private String customProperty;
}

@Value("${server.port:8080}")
private int serverPort; // 默认值8080

@ConfigurationProperties(prefix = "app")
@Data
public class AppProperties {
    private String name;
    private String version;
    private Database database = new Database();
    
    @Data
    public static class Database {
        private String url;
        private String username;
        private String password;
    }
}

// 对应配置
app:
  name: MyApp
  version: 1.0.0
  database:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: password

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class, RedisAutoConfiguration.class})
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@Configuration
@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class})
@ComponentScan
public class Application {
    // ...
}

spring:
  autoconfigure:
    exclude:
      - org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
      - org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration

@SpringBootApplication(excludeName = {
    "org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration"
})
public class Application {
    // ...
}

# application.yml
debug: true

java -jar app.jar --debug

# 启用autoconfig端点
management:
  endpoints:
    web:
      exposure:
        include: autoconfig

management:
  endpoints:
    web:
      exposure:
        include: conditions

@RestController
public class AutoConfigController {
    
    @Autowired
    private ApplicationContext applicationContext;
    
    @GetMapping("/autoconfig")
    public Map<String, Object> getAutoConfig() {
        ConditionEvaluationReport report = ConditionEvaluationReport.get(applicationContext.getBeanFactory());
        
        Map<String, Object> result = new HashMap<>();
        result.put("positiveMatches", report.getConditionAndOutcomesBySource().entrySet().stream()
            .filter(entry -> entry.getValue().isFullMatch())
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
        
        result.put("negativeMatches", report.getConditionAndOutcomesBySource().entrySet().stream()
            .filter(entry -> !entry.getValue().isFullMatch())
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
        
        return result;
    }
}