14 Practical Spring Boot Code Optimization Tips from a Senior Architect

The author, a senior architect, shares fourteen practical tips for optimizing Spring Boot projects, emphasizing clean code, maintainability, and performance.

1. Define configuration file information – Store common variables in a YAML file and bind them using @ConfigurationProperties instead of @Value. Example bean:

@Data
@ConfigurationProperties(prefix = "developer")
@Component
public class DeveloperProperty {
    private String name;
    private String website;
    private String qq;
    private String phoneNumber;
}

Inject the bean in a controller:

@RestController
@RequiredArgsConstructor
public class PropertyController {
    private final DeveloperProperty developerProperty;

    @GetMapping("/property")
    public Object index() {
        return developerProperty.getName();
    }
}

2. Use @RequiredArgsConstructor instead of @Autowired – Prefer constructor injection provided by Lombok’s @RequiredArgsConstructor for clearer dependencies.

3. Code modularization – Follow the Alibaba Java Development Manual recommendation that a method should not exceed 50 lines; split responsibilities into smaller, single‑purpose methods.

4. Throw exceptions rather than returning error codes – Use exceptions to signal error conditions, keeping business logic clean.

5. Reduce unnecessary database queries – Avoid redundant reads; fetch only required data and consider caching where appropriate.

6. Avoid returning null – Use Optional to express possible absence of a value, e.g.:

public List<CatalogueTreeNode> getChild(String pid) {
    if (V.isEmpty(pid)) {
        pid = BasicDic.TEMPORARY_DIRECTORY_ROOT;
    }
    CatalogueTreeNode node = treeNodeMap.get(pid);
    return Optional.ofNullable(node)
        .map(CatalogueTreeNode::getChild)
        .orElse(Collections.emptyList());
}

7. Reduce if‑else chains – Replace long if‑else if blocks with the Strategy pattern where suitable.

8. Keep controller thin – Move business logic to the service layer for better separation of concerns.

9. Leverage IntelliJ IDEA – Let the IDE suggest improvements such as converting anonymous classes to lambda expressions.

10. Read source code of popular open‑source projects – Studying high‑starred repositories on GitHub helps understand design decisions and advanced APIs.

11. Apply design patterns – Familiarize yourself with the 23 classic GoF patterns and use them to write more expressive and maintainable code.

12. Embrace new knowledge – Continuously learn beyond daily CRUD tasks; build demo projects to practice unfamiliar technologies.

13. Basic Java issues – Proper map traversal, optional null checks, and recursion tips (e.g., pass mutable objects as parameters to avoid object creation inside deep recursion).

HashMap<String, String> map = new HashMap<>();
map.put("name", "du");
for (String key : map.keySet()) {
    String value = map.get(key);
}
// Recommended modern way
for (Map.Entry<String, String> entry : map.entrySet()) {
    // use entry.getKey() and entry.getValue()
}

14. Use HashSet for existence checks – Checking membership in a HashSet is O(1) compared to O(n) for a List:

HashSet<String> set = new HashSet<>();
int index = hash(a);
return getNode(index) != null; // O(1) lookup

The article concludes with an invitation to join a senior architect community, share ideas, and access additional resources such as interview question collections and open‑source project links.