Spring Annotations

2021-07-08

Description: this article is talking about some annotations in Spring.

Pre class

IoC Containers

The Spring container is at the core of the Spring Framework. The container will create the objects, wire them together, configure them, and manage their complete life cycle from creation till destruction. The Spring container uses DI to manage the components that make ip an appliation. These objects are called Spring Beans

avatar

What is Spring Bean

The objects that form the backbone of your application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container. These beans are created with the configuration metadata that you supply to the container

@Autowired

this annotation is making a dependency which Spring is going to resolve and inject. We can use this annotation with a constructor, setter, or field injection.
it has a boolean argument called reuqired with a default value of true. It tunes Spring's behavior when it doesn't find a suitable bean to write. When true, an exception is thrown, otherwise, nothing is wired.


@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    boolean required() default true;
}

If we use constructor injection, all constructor arguments are mandatory.
- Constructor injection

	class Car {
    	Engine engine;

    @Autowired
    Car(Engine engine) {
        this.engine = engine;
    }
}

@Bean

makes a factory method which instantiates a Spring Bean: it is a method-level annotation. It is an alternative of XML <bean> tag. It tells the method to produce a bean to be managed by Spring Container

@Bean
Engine engine() {
   return new Engine();
}

Spring calls these methods when a new instance of the return type is required.
The resulting bean has the same name as the factory method. If we want to name it differently, we can do so with the name or the value arguments of this annotation(the argument value is an alias for the arguments name)

@Bean("engine")
Engine getEngine() {
    return new Engine();
}

**Note: all methods annotated with @Bean must be in @Configuration classes.**

@Required

it on setter methdos to mark dependencies that we want to populate through XML

@Required
void setColor(String color) {
    this.color = color;
}

<bean class="com.baeldung.annotations.Bike">
    <property name="color" value="green" />
</bean>

@Component

it is class-level annotation. It is used to mark a Java class as a bean. A java class annotated with @Component is found during the classpath. The spring framework pick it up and configure it in the application context as a Spring bean.

@Component  
public class Student  
{  
.......  
}

@Controller

the @Controller is a class-level annotation. It is a specializaton of @Component. It makes a class a web request handler. It is often used to serve web pages. By default, it returns a string that indicates which route to redirect. It is mostly used with @RequestMapping annotation.

@RestController
@RequestMapping(path = "api/v1/student")
public class StudentController {

    private final StudentService studentService;

//    this studentService will be autowired and do not need new
    @Autowired
    public StudentController(StudentService studentService) {
        this.studentService = studentService;
    }

    @GetMapping
    public List<Student> getStudents(){
        return studentService.getStudents();

    }

//    add student to db
    @PostMapping
    public void registerNewStudent(@RequestBody Student student){
        studentService.addNewStudent(student);
    }

//    delete student from db
    @DeleteMapping(path = "{studentId}")
    public void deleteStudent(@PathVariable("studentId") Long id){
        studentService.deleteStudent(id);
    }

//    update the student with name or email
    @PutMapping(path = "{studentId}")
    public void updateStudent(@PathVariable("studentId") Long id,
                              @RequestParam(required = false) String name,
                              @RequestParam(required = false) String email){
        studentService.updateStudent(id,name,email);

    }



}

@Service

it is a class level, it tells the Spring that class contains the business logic

@Service
public class StudentService {
    private final StudentRepository studentRepository;

    @Autowired
    public StudentService(StudentRepository studentRepository) {
        this.studentRepository = studentRepository;
    }

    public List<Student> getStudents() {
        return studentRepository.findAll();
    }

    public void addNewStudent(Student student) {
//        get all emails form repository
        Optional<Student> studentByEmail =
                studentRepository.findStudentByEmail(student.getEmail());
        if (studentByEmail.isPresent()) {
            throw new IllegalStateException("the email has already exist");
        }
//        save the student into db
        studentRepository.save(student);
    }

    public void deleteStudent(Long id) {
        studentRepository.deleteById(id);
    }

    //it's used to combine more than one writes on a database as a single atomic operation
    //when somebody call the method annotation with it all or none of the writers on the database
    //is executed
    @Transactional
    public void updateStudent(Long id, String name, String email) {
//        check whether the student exists
        Student student = studentRepository.findById(id)
                .orElseThrow(() ->
                        new IllegalStateException(
                                "student id " + id + " does not exist"

                        ));
        if (name != null && name.length() > 0 && !Objects.equals(student.getName(), name)) {
            student.setName(name);
        }

        if (email != null && email.length() > 0 && !Objects.equals(student.getEmail(), email)) {
            student.setEmail(email);
        }

    }
}

@Repository

it is a class-level annotation. The repository is a DAOs(Data Access Object) that access the database directly. The repository does all the operations related to the database

//responsible for data access
@Repository
public interface StudentRepository extends JpaRepository<Student, Long> {

//   find all emails in the db
    Optional<Student> findStudentByEmail(String email);

}

Configuration

is the top of any class to declare that this class provides one or more @Bean methods and may be processed by the Spring container to generate bean definitions and service requests for those beans at runtime

@Configuration
public class StudentConfig {
    @Bean
    CommandLineRunner commandLineRunner(StudentRepository repository){
        return args -> {
            Student student = new Student(
                "Jeremy",
                LocalDate.of(1995, 01, 01),
                "Jeremy123@gmail.com");
            Student student1 = new Student(
                    "Kobe",
                    LocalDate.of(2003, 01, 01),
                    "Kobe123@gmail.com");
            List<Student> students = new ArrayList<>();
            students.add(student);
            students.add(student1);
            repository.saveAll(students);
        };

    }
}

References:

[1] Spring Core Annotations
[2] Spring Boot Annotations
[3] Spring @Configuration annotation example
[4] Tutorialspoints