14 Practical Spring Boot Code Optimization Tips for Cleaner Java Apps

Every time code optimization is discussed, many talk about theory, architecture, core ideas, but a good coding habit is essential. Below are fourteen practical Spring Boot code optimization tips that make optimization easy, like completing a small task.

1. Define configuration file properties

Store variables in yml and use @ConfigurationProperties instead of @Value.

Usage

Define a POJO with the prefix and inject it as a bean.

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

Inject the bean where needed:

@RestController
@RequiredArgsConstructor
public class PropertyController {

    final DeveloperProperty developerProperty;

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

2. Use @RequiredArgsConstructor instead of @Autowired

Constructor injection is recommended; Lombok’s @RequiredArgsConstructor generates the required constructor automatically.

3. Code modularization

Keep each method under 50 lines, split responsibilities, and apply the single‑responsibility principle.

4. Throw exceptions rather than return error codes

Avoid returning different messages for different outcomes; use exceptions to keep code clean.

5. Reduce unnecessary database queries

Minimize DB access; for example, avoid querying a record before deletion when the status already indicates it can be removed.

6. Never return null

Returning null leads to NullPointerExceptions; prefer empty collections or Optional.

7. Limit if‑else chains

Replace long if‑else chains with the Strategy pattern.

8. Keep business logic out of controllers

Move processing to the service layer for better maintainability and readability.

9. Leverage IntelliJ IDEA

IDE suggestions can replace verbose code with lambda expressions or other shortcuts.

10. Read source code

Study high‑quality open‑source projects (e.g., GitHub repos with >1000 stars) to learn design ideas and advanced APIs.

11. Apply design patterns

Use the 23 classic design patterns to write clean and robust code.

12. Embrace new knowledge

Continuously learn beyond routine CRUD work; build demos with newer technologies.

13. Master basic language features

Examples include efficient Map traversal and using Optional to avoid null checks.

HashMap<String, String> map = new HashMap<>();
map.put("name", "du");
for (Map.Entry<String, String> entry : map.entrySet()) {
    // process entry
}

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());
}

14. Use appropriate collections for existence checks

Prefer HashSet over List when checking element presence, achieving O(1) complexity.

HashSet<String> set = new HashSet<>();
// check if "a" exists
boolean exists = set.contains("a");