@Service annotation in Spring Boot - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to mark the class as a service in Spring Boot.

Spring Boot

[1]
public class UserService {
    // service methods
}

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

A@Repository

B@Service

C@Controller

D@ComponentScan

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Controller instead of @Service

Forgetting to add any annotation

The @Service annotation marks the class as a service component in Spring Boot.

2fill in blank

medium

Complete the code to inject the service into a controller using Spring Boot.

Spring Boot

public class UserController {
    private final UserService userService;

    public UserController([1] userService) {
        this.userService = userService;
    }
}

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

AUserService

BInject

CService

D@Autowired

Attempts:

3 left

💡 Hint

Common Mistakes

Using annotation names as parameter type

Forgetting to use the service class type

The constructor parameter must be the type UserService to inject the service.

3fill in blank

hard

Fix the error in the service class declaration by adding the missing annotation.

Spring Boot

[1]
public class OrderService {
    public void processOrder() {
        // processing logic
    }
}

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

A@Repository

B@Component

C@Controller

D@Service

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Component instead of @Service

Not adding any annotation

The @Service annotation is required to register the class as a service bean.

4fill in blank

hard

Fill both blanks to create a service class and inject it into a controller.

Spring Boot

@Service
public class ProductService {
    public String getProduct() {
        return "Product";
    }
}

public class ProductController {
    private final [1] productService;

    public ProductController([2] productService) {
        this.productService = productService;
    }
}

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

AProductService

BUserService

COrderService

DProductController

Attempts:

3 left

💡 Hint

Common Mistakes

Using controller class name instead of service

Mixing different service class names

Both blanks require the service class name ProductService to correctly declare and inject the service.

5fill in blank

hard

Fill all three blanks to define a service, annotate it, and inject it into a controller.

Spring Boot

[1]
public class CustomerService {
    public String getCustomer() {
        return "Customer";
    }
}

public class CustomerController {
    private final [2] customerService;

    public CustomerController([3] customerService) {
        this.customerService = customerService;
    }
}

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

A@Service

BCustomerService

D@Controller

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Controller instead of @Service

Mismatching types in field and constructor

The service class must be annotated with @Service. The field and constructor parameter types must be CustomerService.

Practice

1. What is the main purpose of the @Service annotation in Spring Boot?

easy

A. To create a REST controller

B. To define a database entity

C. To mark a class as a service layer component for business logic

D. To configure application properties

Solution

1. Step 1: Understand the role of @Service

   The @Service annotation is used to mark classes that hold business logic in the service layer.

2. Step 2: Differentiate from other annotations

   It is not used for database entities (@Entity), REST controllers (@RestController), or configuration (@Configuration).

3. Final Answer:

   To mark a class as a service layer component for business logic -> Option C

4. Quick Check:

   @Service = service layer marker [OK]

Hint: Service annotation marks business logic classes [OK]

Common Mistakes:

• Confusing @Service with @Entity or @Controller
• Thinking @Service configures properties
• Assuming @Service creates REST endpoints

2. Which of the following is the correct way to declare a service class using @Service in Spring Boot?

easy

A. public class MyService() @Service {}

B. public class MyService @Service {}

C. public @Service class MyService {}

D. @Service public class MyService {}

Solution

1. Step 1: Recall Java annotation syntax

   Annotations must be placed before the class declaration without parentheses unless parameters are needed.

2. Step 2: Check each option's syntax

   @Service public class MyService {} correctly places @Service before the class declaration. Options B, C, and D have incorrect placement or syntax.

3. Final Answer:

   @Service public class MyService {} -> Option D

4. Quick Check:

   Annotation before class = correct syntax [OK]

Hint: Put @Service right before class keyword [OK]

Common Mistakes:

• Placing annotation after class name
• Adding parentheses without parameters
• Using annotation inside class declaration

3. Given the following code, what will be the output when myService.greet() is called?

@Service
public class MyService {
    public String greet() {
        return "Hello from Service!";
    }
}

medium

A. "Hello from Service!"

B. null

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Understand the method behavior

   The greet() method returns the string "Hello from Service!" when called.

2. Step 2: Check for errors or exceptions

   There is no syntax error or runtime exception in the code snippet.

3. Final Answer:

   "Hello from Service!" -> Option A

4. Quick Check:

   Method returns string = "Hello from Service!" [OK]

Hint: Method returns string directly, no errors [OK]

Common Mistakes:

• Assuming null return without initialization
• Thinking @Service causes errors
• Confusing method output with annotation effect

4. Identify the error in the following Spring Boot service class:

public class UserService {
    @Service
    public void saveUser() {
        // save logic
    }
}

medium

A. @Service should annotate the class, not the method

B. Method saveUser must return a value

C. Class must extend a Spring base class

D. Missing @Autowired on saveUser method

Solution

1. Step 1: Check annotation placement

   The @Service annotation is meant for classes, not methods.

2. Step 2: Verify method and class requirements

   The method can be void and does not require @Autowired. The class does not need to extend any base class.

3. Final Answer:

   @Service should annotate the class, not the method -> Option A

4. Quick Check:

   @Service on class only [OK]

Hint: @Service decorates classes, not methods [OK]

Common Mistakes:

• Putting @Service on methods
• Expecting methods to return values always
• Thinking @Autowired is needed on service methods

5. You want to create a service class that depends on a repository class. How should you use @Service and @Autowired together to follow Spring Boot best practices?

@Service
public class OrderService {
    private final OrderRepository orderRepository;

    // Constructor here
}

hard

A. Use @Service on the class and inject OrderRepository via field with @Autowired without constructor

B. Use @Service on the class and inject OrderRepository via constructor with @Autowired

C. Use @Service on the class and create OrderRepository manually inside methods

D. Use @Service on the class and no injection needed if repository is public

Solution

1. Step 1: Understand dependency injection best practice

   Constructor injection with @Autowired is preferred for mandatory dependencies.

2. Step 2: Apply @Service and constructor injection

   Annotate the class with @Service and create a constructor with @Autowired to inject OrderRepository.

3. Final Answer:

   Use @Service on the class and inject OrderRepository via constructor with @Autowired -> Option B

4. Quick Check:

   Constructor injection + @Service = best practice [OK]

Hint: Use constructor injection with @Autowired in @Service class [OK]

Common Mistakes:

• Using field injection instead of constructor injection
• Manually creating repository instances
• Skipping injection assuming public access suffices