Spring Core

Tổng hợp các Annotation trong Spring

nguyen.le , 15 min read

Giới thiệu nội dung bài viết

Chào bạn, trong bài viết hôm nay chúng ta sẽ tổng hợp các Annotation trong Spring Core.

1. @Autowire Annotation

Sử dụng để nhúng các Bean vào Bean cần dùng. Có thể nhúng qua Constructor, Setter và Biến.

Constructor

1
2
3
4
5
6
7
8
9
@RestController
public class CustomerController {
    private CustomerService customerService;
 
    @Autowired
    public CustomerController(CustomerService customerService) {
        this.customerService = customerService;
    }
}

Setter

1
2
3
4
5
6
7
8
9
10
11
12
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CustomerController {
    private CustomerService customerService;
 
    @Autowired
    public void setCustomerService(CustomerService customerService) {
        this.customerService = customerService;
    }
}

Field (biến)

1
2
3
4
5
@RestController
public class CustomerController {
    @Autowired
    private CustomerService customerService;
}

2. @Bean Annotation

Sử dụng để tạo các Bean trong ứng dụng Spring.

1
2
3
4
5
6
7
8
9
10
11
12
13
@Configuration
public class Application {

    @Bean
    public CustomerService customerService() {
        return new CustomerService();
    }

    @Bean
    public OrderService orderService() {
        return new OrderService();
    }
}

3. @Qualifier Annotation

Khi có nhiều Bean có cùng kiểu dữ liệu thì @Qualifier giúp chúng ta xác định nó là kiểu gì. Ví dụ như ta có 2 loại gửi tin nhắn là Email và SMS cùng implements 1 interface là Message Service. Chúng ta sử dụng @Qualifier để xác định đó là loại Email hay SMS vì chúng cùng 1 kiểu Message Service.

1
2
3
public interface MessageService {
    public void sendMsg(String message);
}

1
2
3
4
5
6
public class EmailService implements MessageService{

    public void sendMsg(String message) {
         System.out.println(message);
    }
}

1
2
3
4
5
6
public class SMSService implements MessageService{

    public void sendMsg(String message) {
         System.out.println(message);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public interface MessageProcessor {
    public void processMsg(String message);
}

public class MessageProcessorImpl implements MessageProcessor {

    private MessageService messageService;

    // setter based DI
    @Autowired
    @Qualifier("emailService")
    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }
 
    // constructor based DI
    @Autowired
    public MessageProcessorImpl(@Qualifier("emailService") MessageService messageService) {
        this.messageService = messageService;
    }
 
    public void processMsg(String message) {
        messageService.sendMsg(message);
    }
}

4. @Require Annotation

Sử dụng @Require thường dùng ở phương thức Setter nhằm bắt buộc phải nhúng giá trị vào.

1
2
3
4
@Required
void setColor(String color) {
    this.color = color;
}

5. @Value Annotation

Được sử dụng để lấy giá trị từ file properties.

1
2
3
@Value("${APP_NAME_NOT_FOUND}")

private String defaultAppName;

6. @Lazy Annotation

Sử dụng @Lazy để ngăn Spring IoC tạo Bean, chỉ tạo khi mình cần.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Configuration
public class AppConfig {

    @Lazy(value = true)
    @Bean
    public FirstBean firstBean() {
        return new FirstBean();
    }

    @Bean
    public SecondBean secondBean() {
        return new SecondBean();
    }
}

7. @Primary Annotation

Khi nhiều Bean có cùng một kiểu (type). Chúng ta có quyền ưu tiên cho Bean nào được load lên đầu tiên.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Component
@Primary
class Car implements Vehicle {}
 
@Component
class Bike implements Vehicle {}
 
@Component
class Driver {
    @Autowired
    Vehicle vehicle;
}
 
@Component
class Biker {
    @Autowired
    @Qualifier("bike")
    Vehicle vehicle;
}

8. @Scope Annotation

Dùng để nói lên phạm vi tồn tại của một Bean.

1
2
3
4
5
6
7
8
9
@Component
@Scope(value = ConfigurableBeanFactory.SCOPE_SINGLETON)
public class TwitterMessageService implements MessageService {
}

@Component
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class TwitterMessageService implements MessageService {
}

9. @Import Annotation

Dùng để nhúng 1 hoặc nhiều file configure lại với nhau.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Configuration
public class ConfigA {

    @Bean
    public A a() {
        return new A();
    }
}

@Configuration
@Import(ConfigA.class)
public class ConfigB {

    @Bean
    public B b() {
        return new B();
    }
}

10. PropertySource

Dùng để nạp các file properties từ bên ngoài vào Bean.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Configuration
@PropertySource("classpath:config.properties")
public class ProperySourceDemo implements InitializingBean {

    @Autowired
    Environment env;

    @Override
    public void afterPropertiesSet() throws Exception {
        setDatabaseConfig();
    }

    private void setDatabaseConfig() {
        DataSourceConfig config = new DataSourceConfig();
        config.setDriver(env.getProperty("jdbc.driver"));
        config.setUrl(env.getProperty("jdbc.url"));
        config.setUsername(env.getProperty("jdbc.username"));
        config.setPassword(env.getProperty("jdbc.password"));
        System.out.println(config.toString());
    }
}