Why enterprise patterns matter in Spring Boot - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a Spring Boot main application class.

Spring Boot

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.[1](Application.class, args);
    }
}

Drag options to blanks, or click blank then click option'

Arun

Bstart

Claunch

Dexecute

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'start' or 'launch' instead of 'run' causes errors.

Forgetting to call a method to start the app.

The SpringApplication.run() method starts the Spring Boot application.

2fill in blank

medium

Complete the code to declare a Spring component for dependency injection.

Spring Boot

import org.springframework.stereotype.[1];

@[1]
public class Service {
    // service logic
}

Drag options to blanks, or click blank then click option'

AComponent

BService

CRepository

DController

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Service or @Repository when a generic component is needed.

Forgetting to annotate the class for Spring to detect it.

The @Component annotation marks a class as a Spring-managed component for dependency injection.

3fill in blank

hard

Fix the error in the code to inject a repository into a service using constructor injection.

Spring Boot

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

@Service
public class UserService {
    private final UserRepository userRepository;

    @Autowired
    public UserService([1] userRepository) {
        this.userRepository = userRepository;
    }
}

Drag options to blanks, or click blank then click option'

AUserService

BUserRepository

CRepository

DUserRepo

Attempts:

3 left

💡 Hint

Common Mistakes

Using the service class type as parameter causes errors.

Using incorrect or undefined types for injection.

The constructor parameter must be the type of the repository to inject, here UserRepository.

4fill in blank

hard

Fill both blanks to create a REST controller method that handles GET requests and returns a list.

Spring Boot

import org.springframework.web.bind.annotation.[1];
import org.springframework.web.bind.annotation.RestController;
import java.util.List;

@RestController
public class ItemController {

    @[2]("/items")
    public List<String> getItems() {
        return List.of("apple", "banana", "cherry");
    }
}

Drag options to blanks, or click blank then click option'

AGetMapping

BPostMapping

CRequestMapping

DDeleteMapping

Attempts:

3 left

💡 Hint

Common Mistakes

Using @PostMapping or @DeleteMapping for GET requests.

Importing a different annotation than the one used.

The method should be annotated with @GetMapping to handle GET requests. The import must match the annotation used.

5fill in blank

hard

Fill all three blanks to define a Spring Data JPA repository interface for an entity User with Long id.

Spring Boot

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.[1];

@[1]
public interface UserRepository extends JpaRepository<[2], [3]> {
}

Drag options to blanks, or click blank then click option'

ARepository

BUser

CLong

DService

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Service instead of @Repository.

Mixing up entity and ID types in JpaRepository.

The interface should be annotated with @Repository. It extends JpaRepository with the entity User and ID type Long.

Practice

1. Why do enterprise patterns matter in Spring Boot applications?

easy

A. They remove the need for testing.

B. They make the application run faster by default.

C. They automatically generate user interfaces.

D. They organize large applications into clear, manageable parts.

Solution

1. Step 1: Understand the purpose of enterprise patterns

   Enterprise patterns help organize complex applications into smaller, understandable parts.

2. Step 2: Relate to Spring Boot support

   Spring Boot supports these patterns to make building and maintaining apps easier, not to speed up or auto-generate UI.

3. Final Answer:

   They organize large applications into clear, manageable parts. -> Option D

4. Quick Check:

   Enterprise patterns = organize apps [OK]

Hint: Think about how big projects stay organized [OK]

Common Mistakes:

• Confusing patterns with performance improvements
• Assuming patterns remove testing needs
• Believing patterns auto-create UI

2. Which of the following is the correct way to define a Spring Boot service class following enterprise patterns?

easy

A. @Service public class UserService { }

B. public class UserService { }

C. @Controller public class UserService { }

D. @Repository public class UserService { }

Solution

1. Step 1: Identify the correct stereotype annotation for a service

   In Spring Boot, @Service marks a service layer class following enterprise patterns.

2. Step 2: Check other annotations

   @Controller is for web controllers, @Repository is for data access, and no annotation means no special role.

3. Final Answer:

   @Service public class UserService { } -> Option A

4. Quick Check:

   @Service = service layer class [OK]

Hint: Service classes use @Service annotation [OK]

Common Mistakes:

• Using @Controller for service classes
• Omitting stereotype annotations
• Confusing @Repository with @Service

3. Given this Spring Boot code snippet, what will be the output when calling userService.getUserName(1) if the user exists?

@Service
public class UserService {
    public String getUserName(int id) {
        if (id == 1) return "Alice";
        else return "Unknown";
    }
}

medium

A. "Alice"

B. "Unknown"

C. null

D. Compilation error

Solution

1. Step 1: Analyze the method logic for id = 1

   The method returns "Alice" if id equals 1.

2. Step 2: Confirm no errors or null returns

   Since id is 1, it returns "Alice" directly, no errors or null.

3. Final Answer:

   "Alice" -> Option A

4. Quick Check:

   id=1 returns "Alice" [OK]

Hint: Check the if condition for the given id [OK]

Common Mistakes:

• Assuming default return is null
• Confusing else branch output
• Thinking code has syntax errors

4. Identify the error in this Spring Boot repository interface following enterprise patterns:

public interface UserRepository {
    User findById(int id);
}

medium

A. Missing @Repository annotation

B. User class must be final

C. Interface should extend JpaRepository or similar

D. Method name should be getUserById

Solution

1. Step 1: Check interface declaration for Spring Data JPA

   Repository interfaces should extend JpaRepository or a similar interface to work properly.

2. Step 2: Verify other options

   @Repository annotation is optional if extending JpaRepository; method name is fine; User class finality is unrelated.

3. Final Answer:

   Interface should extend JpaRepository or similar -> Option C

4. Quick Check:

   Repository interface must extend JpaRepository [OK]

Hint: Repositories extend JpaRepository for Spring Data support [OK]

Common Mistakes:

• Forgetting to extend JpaRepository
• Thinking @Repository is always required
• Changing method names unnecessarily

5. You want to build a Spring Boot app that is easy to maintain and test. Which enterprise pattern combination helps achieve this best?

hard

A. Put all logic in one class annotated with @SpringBootApplication

B. Use layered architecture with @Controller, @Service, and @Repository layers

C. Use only @RestController and skip service layer

D. Write all database queries directly in controller methods

Solution

1. Step 1: Understand layered architecture benefits

   Separating concerns into controller, service, and repository layers makes code easier to maintain and test.

2. Step 2: Evaluate other options

   Putting all logic in one class or skipping layers leads to messy, hard-to-test code.

3. Final Answer:

   Use layered architecture with @Controller, @Service, and @Repository layers -> Option B

4. Quick Check:

   Layered architecture = maintainable, testable [OK]

Hint: Separate concerns into layers for clarity [OK]

Common Mistakes:

• Mixing all logic in one class
• Skipping service layer thinking it's simpler
• Writing DB code in controllers