What is the difference between using "autowired" annotation and "private final" to a repository in the service layer?

I've seen tutorials where they use different syntax to accomplish the same thing. Once a POST request to create a student object comes in via the controller, the service layer injects the repository using these two methods.

method 1:

@Service
@AllArgsConstructor
@Transactional
public class StudentService {
    private final StudentRepository studentRepo;
    // complete service code using studentRepo
}

As well as Method 2:

@Service
public class StudentService {
    @Autowire
    private StudentRepository studentRepo;
    // complete service code using studentRepo
}

I read that it has something to do with constructor and field injection but I'm seriously not understanding how this syntax addresses the difference. Any explanations or resources for me to better understand?
Thank you in advance!

You are stacking a lot of frameworks which are adding to the confusion. The confusion is probably due to the fact you are using Lombok. The @AllArgsConstructor automatically adds a constructor with all the arguments needed to construct an instance of the service.

> @AllArgsConstructor generates a constructor with 1 parameter for each field in your class. Fields marked with @NonNull result in null checks on those parameters. - Source: Lombok Documentation

Using the @AllArgsConstructor effectively generates the following class

@Service
@Transactional
public class StudentService {

    private final StudentRepository studentRepo;

    public StudentService(StudentRepository studentRepo) {
        this.studentRepo=studentRepo;
    }
    // complete service code using studentRepo
}

Now as this class has only a single constructor Spring will use this to do dependency injection. This is called constructor based dependency injection.

@Service
@Transactional
public class StudentService {
    @Autowire
    private StudentRepository studentRepo;
    // complete service code using studentRepo
}

Whereas this is called field based dependency injection.

IMHO you should prefer constructor based dependency injection for the simple reason it is very easy to use and right in your face. You can easily test it while with field injection writing a unit test is hard(er) as you need reflection to inject the field.

See also Dependency Injection in Java for a more thorough explanation of different dependency injection styles.

Dependency injection can be achieved in different ways. The two ways that you're talking about and probably not understand clearly are:

1. Field Injection:

@Service
public class StudentService {
  @Autowired
  private StudentRepository studentRepo;
   // complete service code using studentRepo
}

2. Constructor Based DI:

@Service
//@AllArgsConstructor <-- commenting this for now. Probably your source of confusion
@Transactional
public class StudentService {
    private final StudentRepository studentRepo;

     // For Spring Boot 1.4 and above, using @Autowired on constructor is optional
     // Dependency being injected through constructor
    public StudentService(StudentRepository studentRepo) {
             this.studentRepo = studentRepo;
    }
     // complete service code using studentRepo
}

Now, if you put @AllArgsConstructor (an annotation from project lombok), the constructor would be generated with all the member fields for you in the .class file and required DI would take place.