I recently started learning Spring Boot, and I'm encountering an error. I believe the error exists in the Service Class. I tried removing the field injection (@Autowired) and implemented constructor injection instead, but that did not work . I'm getting this error: "The injection point has the following annotations: @org.springframework.beans.factory.annotation.Autowired(required=true)"

We encounter the error message "The injection point has the following annotations: - @org.springframework.beans.factory.annotation.Autowired(required=true)," it typically indicates an issue with autowiring in a Spring application, this error occurs when Spring tries to autowire a bean but cannot find a suitable candidate for injection. The @Autowired annotation with required=true means that Spring must find a bean to inject, and if it fails to do so, it throws this error.

To resolve this issue, we need to ensure that the bean we are trying to autowire is correctly configured and available in the Spring application context. We can do this by checking the following:

  1. Ensure that the bean we are trying to inject exists in the application context and is correctly configured as a Spring bean.
  2. Verify that the component scan or bean definitions include the package where the bean is located.
  3. Check for any typos or errors in the bean name or configuration.
  4. If using XML configuration, ensure that the bean is declared correctly with the appropriate attributes.

Here's an example illustrating how we can use @Autowired annotation in a Spring component:

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

public class ProductService {

    private final ProductRepository repository;

    public ProductService(ProductRepository repository) {
this.repository = repository; } }

In this example, ProductService class is annotated with @Component to indicate that it's a Spring-managed component. The constructor is annotated with @Autowired, indicating that Spring should inject an instance of ProductRepository when creating a ProductService  instance.


I encountered an issue where I attempted to use the @Service annotation on a Spring interface named UserService. However, I consistently received an error indicating that Spring couldn't locate a bean of type UserService. This occurred because @Service cannot be directly applied to interfaces in Spring.

To resolve this issue, I created a new class called UserServiceImpl that implements the UserService interface. Then, I added the @Service annotation to this implementation class.

Example Code:

        public class UserServiceImpl implements UserService {

            private UserRepository userRepository;

            public List<User> getAllUsers() {
                return userRepository.findAll();

            // Other methods for managing user data

By moving the @Service annotation to the UserServiceImpl class, I successfully instantiated it as a Spring bean, resolving the issue and enabling its use within my application.


We were advised to remove exclude = {DataSourceAutoConfiguration.class } from the @SpringBootApplication (

  exclude = {DataSourceAutoConfiguration.class }, class if you are using:

@SpringBootApplication (
        "com.devops.maven", "com.devop.application"}

public class LoanApplication {
    public static void main(String[] args) {
        SpringApplication.run(LoanApplication.class, args);

It remove the DataSourceAutoConfiguration class, allowing Spring Boot to automatically configure the data source based on the application's properties. 


While working on a microservice project, I encountered an error indicating that the model class was present, but the database configuration was missing. Interestingly, other microservices in the project had the necessary database configuration.

To address this issue, I created the required database configuration for the problematic microservice. Once the configuration was added, the problem was successfully resolved.

You can try constructor injection,in Spring Boot, constructor injection is a recommended practice for injecting dependencies into services. When using constructor injection, it's also a good practice to make the injected fields final to ensure immutability and thread safety. 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

public class ProductService {

    private final ProductRepository productRepository;

    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;

ProductService is annotated with @Service, marking it as a Spring-managed service component. The ProductRepository dependency is injected via the constructor of ProductService

The productRepository field is declared final, ensuring that its reference cannot be changed once it's initialized in the constructor, it ensures that the ProductService class is immutable after construction, which enhances thread safety and helps maintain a clear and predictable state throughout its lifecycle.

The error message indicates that Spring cannot find any bean of type com.primesolutions.fileupload.service.AzureFileUploadService.

To resolve this, ensure that your AzureFileUploadService is annotated with either @Service or @Component, as shown in the following example:

        public class AzureFileUploadService {
            private FileStorageProperties props;

            // @Autowired is optional in this case
            public AzureFileUploadService(FileStorageProperties fileStorageProperties) {
                this.props = fileStorageProperties;
                this.fileStorageLocation = Paths.get(fileStorageProperties.getUploadDir())

            public void init() {
                try {
                } catch (Exception ex) {

Additionally, ensure that the AzureFileUploadService class is located in a sub-package of your FileApplication class. For example, if FileApplication is in package com.my.package, then AzureFileUploadService should be in the same package.


If you are using below format of code then change your code:

@Autowired(required = true)
private ProductRepository productRepository;


@Autowired(required = true)
public void setproductRepository(ProductRepository productRepository) {
this.productRepository= productRepository;

Instead, we can simply add:

private ProductRepository productRepository;

it simplifies the dependency injection configuration by removing redundant annotations. By using @Autowired without specifying required and @Qualifier, we rely on Spring's default behavior to inject the bean, which often results in cleaner and more concise code.