解密Spring Boot深入理解条件装配与条件注解

/**
 * 只有当应用程序的类路径中存在 RedisTemplate 类时，RedisConfiguration 类中定义的 redisTemplate() 方法才会被注册为 Bean，并被 Spring 容器管理
 * 如果类路径中不存在 RedisTemplate 类，则该配置类中的 Bean 将被忽略
 */
@Configuration
@ConditionalOnClass({org.springframework.data.redis.core.RedisTemplate.class})
public class RedisConfiguration {
    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 配置 RedisTemplate 的相关属性
        return redisTemplate;
    }
}

/**
 * MyService 类被标记为 @ConditionalOnBean(MyBean.class)，这意味着只有当容器中存在 MyBean 类型的 Bean 时，MyService 才会被创建并添加到容器中
 */
@Configuration
public class MyConfiguration {
    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
    @ConditionalOnBean(MyBean.class)
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

/**
 * MyService 类被标记为 @ConditionalOnBean({MyBean.class, AnotherBean.class})，这意味着只有当容器中同时存在 MyBean 和 AnotherBean 类型的 Bean 时，MyService 才会被创建并添加到容器中
 */
@Configuration
public class MyConfiguration {
    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
    @Bean
    public AnotherBean anotherBean() {
        return new AnotherBean();
    }
    @ConditionalOnBean({MyBean.class, AnotherBean.class})
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

/**
 * MyService 类被标记为 @ConditionalOnBean(name = {"myBean", "anotherBean"})，这意味着只有当容器中同时存在名称为 "myBean" 和 "anotherBean" 的 Bean 时，MyService 才会被创建并添加到容器中
 */
@Configuration
public class MyConfiguration {
    @Bean(name = "myBean")
    public MyBean myBean() {
        return new MyBean();
    }
    @Bean(name = "anotherBean")
    public AnotherBean anotherBean() {
        return new AnotherBean();
    }
    @ConditionalOnBean(name = {"myBean", "anotherBean"})
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

/**
 * @ConditionalOnProperty 注解指定了一个名为myapp.feature.enabled 的属性，当这个属性存在并且其值为"true"时，MyFeatureConfiguration 配置类中的配置会生效
 * havingValue 参数指定了期望的属性值，如果没有指定havingValue，则默认匹配任何非空值
 * matchIfMissing 参数指定了当配置文件中未设置该属性时，是否应该匹配。如果设置为 true，则表示当属性不存在时也匹配，这样可以设置默认行为
 */
@Configuration
@ConditionalOnProperty(
    name = "myapp.feature.enabled",
    havingValue = "true",
    matchIfMissing = true
)
public class MyFeatureConfiguration {
}

myapp.feature.enabled=true

/**
 * 检查配置文件中的 my.config.enabled 属性是否等于 'true'
 * 如果等于 'true'，则表达式结果为 true`，MyBean 实例将会被创建
 * 否则，表达式结果为 false，配置将被忽略，不会创建 MyBean 实例
 */
@Configuration
public class MyConfig {
    @Bean
    @ConditionalOnExpression("#{environment.getProperty('my.config.enabled') == 'true'}")
    public MyBean myBean() {
        // 配置生效时创建 MyBean 实例
        return new MyBean();
    }
}

/**
 * 使用 @ConditionalOnMissingBean 注解来判断容器中是否已经存在了 MyService 类型的 Bean
 * 如果不存在，则创建一个 MyServiceImpl 实例并返回
 * 否则，不进行任何操作。
 */
@Configuration
public class MyConfiguration {
    @Bean
    @ConditionalOnMissingBean(MyService.class)
    public MyService myService() {
        return new MyServiceImpl();
    }
}

/**
 * 邮件服务接口
 */
public interface EmailService {
    void sendWelcomeEmail(String email);
}
/**
 * 发送欢迎邮件
 */
@Service
public class EmailServiceImpl implements EmailService {
    @Override
    public void sendWelcomeEmail(String email) {
        // 发送欢迎邮件的逻辑
        System.out.println("Sending welcome email to: " + email);
    }
}

public interface UserService {
    public void registerUser(String email);
}
/**
 * 在用户注册时检查是否已经存在该用户，如果不存在则发送欢迎邮件
 */
@Service
public class UserServiceImpl implements UserService {
    private final UserMapper userMapper;
    private final EmailService emailService;
    @Autowired
    public UserServiceImpl(UserMapper userMapper, EmailService emailService) {
        this.userMapper = userMapper;
        this.emailService = emailService;
    }
    @Override
    public void registerUser(String email) {
        if(!userMapper.existsByEmail(email)) {
            userMapper.save(email);
            emailService.sendWelcomeEmail(email);
        }else {
            throw new IllegalArgumentException("Email already exists");
        }
    }
}

/**
 * 不想使用数据库，直接使用HashSet来模拟存储用户信息的email
 * 使用一个HashSet来存储注册过的email，HashSet不允许存储重复的元素
 * @author LEK
 */
@Repository
public class UserMapper {
    private final Set<String> registeredEmails = new HashSet<>();
    public boolean existsByEmail(String email) {
        return registeredEmails.contains(email);
    }
    public void save(String email) {
        if (Objects.nonNull(email) && !email.isEmpty()) {
            registeredEmails.add(email);
        }
    }
}

@Configuration
public class EmailConfig {
    /**
     * 邮件配置
     * */
    @Bean
    @ConditionalOnMissingBean(EmailService.class)
    public EmailServiceImpl email() {
        return new EmailServiceImpl();
    }
}

@SpringBootTest
public class UserServiceImplTest {
    @Autowired
    private UserService userService;
    @Test
    public void testRegisterExistingUser() {
        String existingEmail = "existing@example.com";
        userService.registerUser(existingEmail);
        // 注册已存在的用户，预期会抛出 IllegalArgumentException
        userService.registerUser(existingEmail);
    }
}