在Spring Boot应用中，发现代码中存在大量的IF-ELSE语句，我们可以通过如下的一些方式来进行优化，从而可以提升代码的可读性、可维护性和可扩展性。

使用策略模式 (Strategy Pattern)

在策略模式中定义一系列算法的方法，我们可以在运行时选择不同的算法，来处理不同的实现逻辑，如下所示。可以创建一个接口或抽象类来定义算法，然后为每种具体情况实现这个接口或抽象类。

public interface Operation {
    int apply(int a, int b);
}

public class Addition implements Operation {
    @Override
    public int apply(int a, int b) {
        return a + b;
    }
}

public class Subtraction implements Operation {
    @Override
    public int apply(int a, int b) {
        return a - b;
    }
}

public class OperationContext {
    private Operation operation;

    public void setOperation(Operation operation) {
        this.operation = operation;
    }

    public int executeOperation(int a, int b) {
        return operation.apply(a, b);
    }
}

// 使用策略模式
OperationContext context = new OperationContext();
context.setOperation(new Addition());
System.out.println(context.executeOperation(5, 3)); // 输出8

context.setOperation(new Subtraction());
System.out.println(context.executeOperation(5, 3)); // 输出2

使用枚举和枚举策略

如果在代码中IF-ELSE语句是基于某个枚举类型的值来进行判断的，我们可以将逻辑移到枚举类中来进行处理，来简化IF语句操作，如下所示。

public enum Operation {
    ADD {
        @Override
        public int apply(int a, int b) {
            return a + b;
        }
    },
    SUBTRACT {
        @Override
        public int apply(int a, int b) {
            return a - b;
        }
    };

    public abstract int apply(int a, int b);
}

// 使用枚举
Operation operation = Operation.ADD;
System.out.println(operation.apply(5, 3)); // 输出8

operation = Operation.SUBTRACT;
System.out.println(operation.apply(5, 3)); // 输出2

使用Map代替多重IF-ELSE

除了上面的方法之外，我们还可以通过Map的方式来代替多重的IFELSE操作，如下所示，通过键值来调用对应的处理逻辑。

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;

public class OperationExecutor {
    private static final Map<String, BiFunction<Integer, Integer, Integer>> operations = new HashMap<>();

    static {
        operations.put("add", (a, b) -> a + b);
        operations.put("subtract", (a, b) -> a - b);
        // 可以添加更多操作
    }

    public static int execute(String operation, int a, int b) {
        return operations.get(operation).apply(a, b);
    }

    public static void main(String[] args) {
        System.out.println(execute("add", 5, 3)); // 输出8
        System.out.println(execute("subtract", 5, 3)); // 输出2
    }
}

使用Spring的依赖注入 (Dependency Injection)

除了利用Java的实现来解决问题之外，我们还可以通过Spring依赖注入的方式来实现，我们可以将不同的实现注入到需要的地方，从而避免IF-ELSE语句。如下所示。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

public interface Operation {
    int apply(int a, int b);
}

@Service("additionService")
public class Addition implements Operation {
    @Override
    public int apply(int a, int b) {
        return a + b;
    }
}

@Service("subtractionService")
public class Subtraction implements Operation {
    @Override
    public int apply(int a, int b) {
        return a - b;
    }
}

@Service
public class OperationContext {
    private final Map<String, Operation> operations;

    @Autowired
    public OperationContext(Map<String, Operation> operations) {
        this.operations = operations;
    }

    public int execute(String operation, int a, int b) {
        return operations.get(operation).apply(a, b);
    }
}

// 使用依赖注入
@Autowired
private OperationContext operationContext;

public void someMethod() {
    System.out.println(operationContext.execute("additionService", 5, 3)); // 输出8
    System.out.println(operationContext.execute("subtractionService", 5, 3)); // 输出2
}

总结

通过上面的这些方法都可以有效的减少代码中的IF-ELSE语句的使用，从而使得代码更加简洁、清晰和易于维护。至于最终选择何种方式主要还是要取决于具体的应用场景和需求。