springboot实现方法级别的环境隔离代码案例

在Spring Boot中，如果你想在@Service类中让某个方法具备环境隔离特性（即根据不同的环境执行不同的逻辑），有几种实现方式：

1. 使用 @Profile 注解方法级别（Spring 5+）

@Service
public class MyService {
    
    @Profile("dev")
    public void devMethod() {
        System.out.println("This is DEV environment method");
    }
    
    @Profile("prod")
    public void prodMethod() {
        System.out.println("This is PROD environment method");
    }
}

注意：Spring 5.x 开始支持在方法级别使用 @Profile，但需要确保你的Spring版本支持此特性。

2. 使用环境判断（推荐）

@Service
public class MyService {
    
    @Autowired
    private Environment env;
    
    public void environmentAwareMethod() {
        if (env.acceptsProfiles("dev")) {
            devLogic();
        } else if (env.acceptsProfiles("prod")) {
            prodLogic();
        }
    }
    
    private void devLogic() {
        System.out.println("DEV specific logic");
    }
    
    private void prodLogic() {
        System.out.println("PROD specific logic");
    }
}

3. 使用条件注解 + 方法委托

public interface EnvironmentSpecificService {
    void execute();
}

@Service
@Profile("dev")
public class DevServiceImpl implements EnvironmentSpecificService {
    @Override
    public void execute() {
        System.out.println("DEV implementation");
    }
}

@Service
@Profile("prod")
public class ProdServiceImpl implements EnvironmentSpecificService {
    @Override
    public void execute() {
        System.out.println("PROD implementation");
    }
}

@Service
public class MyService {
    
    @Autowired(required = false)
    private EnvironmentSpecificService environmentSpecificService;
    
    public void doWork() {
        if (environmentSpecificService != null) {
            environmentSpecificService.execute();
        } else {
            System.out.println("Default implementation");
        }
    }
}

4. 使用 SpEL 表达式

@Service
public class MyService {
    
    @Value("#{environment.acceptsProfiles('dev') ? devMethod() : prodMethod()}")
    public void environmentSpecificMethod() {
        // 这个方法的实现会被SpEL表达式替换
    }
    
    public void devMethod() {
        System.out.println("DEV method");
    }
    
    public void prodMethod() {
        System.out.println("PROD method");
    }
}

5. 使用策略模式 + 环境判断

public interface EnvironmentStrategy {
    void execute();
}

@Service
public class DevStrategy implements EnvironmentStrategy {
    @Override
    public void execute() {
        System.out.println("DEV strategy");
    }
}

@Service
public class ProdStrategy implements EnvironmentStrategy {
    @Override
    public void execute() {
        System.out.println("PROD strategy");
    }
}

@Service
public class MyService {
    
    @Autowired
    private Environment env;
    
    @Autowired
    private List<EnvironmentStrategy> strategies;
    
    public void executeEnvironmentSpecific() {
        strategies.stream()
            .filter(this::matchesCurrentEnvironment)
            .findFirst()
            .ifPresent(EnvironmentStrategy::execute);
    }
    
    private boolean matchesCurrentEnvironment(EnvironmentStrategy strategy) {
        if (strategy instanceof DevStrategy) {
            return env.acceptsProfiles("dev");
        } else if (strategy instanceof ProdStrategy) {
            return env.acceptsProfiles("prod");
        }
        return false;
    }
}

最佳实践建议

1. 简单场景：使用方法级别的环境判断（方式2）最简单直接
2. 复杂逻辑：推荐使用策略模式（方式5），更符合开闭原则
3. 需要复用：考虑将环境特定逻辑提取到单独的Service中（方式3）
4. Spring 5+：如果确定版本支持，方法级别的@Profile（方式1）最简洁

注意：方法级别的环境隔离可能会增加测试复杂性，确保为不同环境编写相应的测试用例。