1. Google Guice là gì?

Google Guice là một framework DI gọn nhẹ, mã nguồn mở giúp chúng ta phát triển các ứng dụng dạng module được phát triển và quản lý bởi Google. Guice hỗ trợ từ Java 6 trở lên nhé anh em.

Trong Guice, annotation @Inject được sử dụng để tiêm phụ thuộc. Nó cho phép chúng ta inject sự phụ thuộc tại các constructor, field hoặc method. Sử dụng Guice, chúng ta có thể xác định scope của instance đối tượng phụ thuộc. Nó cũng có các tính năng để tích hợp với Spring và Aspect Oriented Programming (AOP).

2. Cài đặt Google Guice

Để sử dụng Google Guice, anh em thêm thư viện Guice vào trong file pom.xml như sau:

<!-- https://mvnrepository.com/artifact/com.google.inject/guice -->
<dependency>
    <groupId>com.google.inject</groupId>
    <artifactId>guice</artifactId>
    <version>4.2.2</version>
</dependency>

Hoặc muốn sử dụng các version khác thì anh em có thể truy cập vào 👉 đây 👈. Cứ version nào nhiều người sử dụng mà “phang” thôi =))).

3. Ví dụ cơ bản về Dependency Injection với Google Guice

Để sử dụng Guice cần nhớ 2 thông tin quan trọng sau:

• Nói với Guice cái gì cần được inject với annotation @Inject.
• Nói với Guice cách inject mô-đun: implement Asbstract Module, bind các interface với các implementation mong muốn.

Quay trở lại với ví dụ em gái Eimi Fukada trong bài trước lần này tôi sẽ sử dụng Guice nha:

GuiceModule.java

package org.blogtms;

import com.google.inject.AbstractModule;

public class GuiceModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(Outfit.class).to(Bikini.class);
        bind(Accessories.class).to(GucciAccessories.class);
        bind(HairStyle.class).to(KoreanHairStyle.class);
    }
}

Girl.java thêm @Inject

package org.blogtms;

import com.google.inject.Inject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

//@Component
public class Girl {

    @Autowired
    Outfit outfit;

    @Autowired
    Accessories accessories;

    @Autowired
    HairStyle hairStyle;

    @Inject
    public Girl(Outfit outfit, Accessories accessories, HairStyle hairStyle) {
        this.outfit = outfit;
        this.accessories = accessories;
        this.hairStyle = hairStyle;
    }
}

Main.java

package org.blogtms;

import com.google.inject.Guice;
import com.google.inject.Injector;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

//@SpringBootApplication
public class Main {
    public static void main(String[] args) {
//        ApplicationContext context = SpringApplication.run(Main.class, args);
//
//        Girl girl = context.getBean(Girl.class);

        Injector injector = Guice.createInjector(new GuiceModule());

        Girl girl = injector.getInstance(Girl.class);
    }
}

Thế là xong rồi =)))

Trong ví dụ trên, chúng ta thấy một số phần thay đổi so với ví dụ ở bài trước:

• Tạo một class extends từ AbstractModule, lớp này được sử dụng để định nghĩa cách mà một class/ interface sẽ được inject bởi một implement cụ thể nào. Trong ví dụ này, Outfit sẽ được inject bởi implement Bikini.
• Lớp Girl có dependency với Outfit. Trong ví dụ này, chúng ta sử dụng @Inject tại hàm xây dựng (constructor) để inject đối tượng Outfit.
• Khởi tạo Guice Injector với config.
• Lấy thể hiện đối tượng với các dependency để sử dụng.

4. Scope trong Google Guice

Theo mặc định, Guice trả về một instance mới mỗi lần nó cần cung cấp một giá trị. Hành vi này có thể cấu hình thông qua phạm vi (scope). Scope cho phép chúng ta tái sử dụng instance.

Các loại Scope được hỗ trợ bởi Google Guice:

• @Singleton : một instance duy nhất được sử dụng trong toàn bộ ứng dụng.
• @SessionScoped : mỗi session sẽ có một instance khác nhau.
• @RequestScoped : mỗi request sẽ có một instance khác nhau.

Trên đây là giới thiệu cơ bản về Google Guice. Nó cung cấp một cách tiếp cận mới cho Dependency Injection, tận dụng thế mạnh của Annotation và Generic để giúp chúng ta dễ dàng hơn trong việc quản lý và sử dụng các Dependency, cũng như dễ dàng phát triển các ứng dụng dạng module.

Tài liệu tham khảo:

• https://github.com/google/guice
• https://www.tutorialspoint.com/guice/index.htm

Cảm ơn anh em đã theo dõi bài viết 🙋‍♂️. Vẫn như mọi khi, đây là source code

The post Dependency Injection (DI) framework – Google Guice appeared first on Tomoshare.

1. Dependency Injection là gì?

Theo tài liệu thì:

Dependency Injection is a design pattern, …

Nôm na Dependency Injection (DI) là một kỹ thuật cho phép xóa bỏ sự phụ thuộc giữa các module, làm cho ứng dụng dễ dàng hơn trong việc thay đổi module, bảo trì code và testing.

DI cung cấp cho một đối tượng các thể hiện phụ thuộc (dependencies) của nó từ bên ngoài truyền vào mà không phải khởi tạo trực tiếp từ trong class sử dụng.

2. Nhiệm vụ của dependency injection

• Tạo các đối tượng.
• Quản lý sự phụ thuộc (dependencies) giữa các đối tượng.
• Cung cấp (inject) các phụ thuộc được yêu cầu cho đối tượng (được truyền từ bên ngoài đối tượng).

3. Nguyên tắc hoạt động của DI

• Các module không giao tiếp trực tiếp với nhau, mà thông qua interface. Module cấp thấp sẽ implement interface, module cấp cao sẽ gọi module cấp thấp thông qua interface.
• Việc khởi tạo các module cấp thấp sẽ do DI Container/ IoC Container thực hiện.
• Việc Module nào gắn với interface nào sẽ được config trong file properties, trong file XML hoặc thông qua Annotation. Annotation là một cách thường được sử dụng trong các Framework, chẳng hạn như @Inject với CDI, @Autowired với Spring hay @ManagedProperty với JSF.

4. Các dạng Dependency Injection

• Constructor Injection: Các dependency sẽ được container truyền vào (inject vào) 1 class thông qua constructor của class đó. Đây là cách thông dụng nhất.
• Setter Injection: Các dependency sẽ được truyền vào 1 class thông qua các hàm Setter.
• Fields/ properties: Các dependency sẽ được truyền vào 1 class một cách trực tiếp vào các field.
• Interface Injection: Class cần inject sẽ implement 1 interface. Interface này chứa 1 hàm tên Inject. Container sẽ injection dependency vào 1 class thông qua việc gọi hàm Inject của interface đó. Đây là cách rườm rà và cũng ít được sử dụng.
• Service Locator: nó hoạt động như một mapper, cho phép thay đổi code tại thời điểm run-time mà không cần biên dịch lại ứng dụng hoặc phải khởi động lại.

Anh em đọc đến đây đã hiểu Dependency Injection là gì chưa? Anh em nào đã thông não thì có thể bỏ qua, anh em nào vẫn lơ tơ mơ thì tiếp tục, full hd không che phía dưới =)))).

5. Ví dụ sử dụng Dependency Injection.

Bikini.java

package org.tmsblog.patterns.di;

public class Bikini {
    public void wear() {
        System.out.println("Đã mặc bikini");
    }
}

Girl.java

package org.tmsblog.patterns.di;

public class Girl {

    private Bikini outfit = new Bikini();
    
    public void result() {
        outfit.wear();
    }
}

Ví dụ anh em tạo 1 Girl, anh em sẽ tạo ra thêm 1 bộ Bikini đi kèm với cô gái đó. Lúc này, Bikini tồn tại mang ý nghĩa là dependency (phụ thuộc) của Girl.

Khi khởi tạo thuộc tính như này, vô tình tạo ra một điểm thắt nút trong chương trình, giả sử, Girl muốn mặc một bộ Quần Jeans + áo hai dây thì anh em sẽ phải thay class Bikini thành JeansWithTshirt(quần jeans với áo T-shirt) ư?

Hay nguy hiểm hơn, bộ đồ Bikini bị hỏng? (code lớp Bikini không hoạt động?) nó sẽ ảnh hưởng trực tiếp tới Girl.

Vấn đề là ở đó, chúng ta cùng đọc lại nguyên tắc D của SOLID:

• Các mô-đun cấp cao không được nhập bất cứ thứ gì từ các mô-đun cấp thấp. Cả hai nên phụ thuộc vào sự trừu tượng

Bây giờ chúng ta sẽ áp dụng Dependency Injection để giải quyết vấn đề trên.

Girl.java

package org.tmsblog.patterns.di;

public class Girl {

    private final Outfit anything;

    public Girl(Outfit anything) {
        this.anything = anything;
    }
}

Bikini.java

package org.tmsblog.patterns.di;

public class Bikini implements Outfit{
   @Override
    public void wear() {
        System.out.println("Đã mặc bikini");
    }
}

Outfit.java

package org.tmsblog.patterns.di;

public interface Outfit {
    public void wear();
}

Main.java

package org.tmsblog.patterns.di;

public class Main {
    public static void main(String[] args) {
        Outfit bikini = new Bikini();

        Girl fukada = new Girl(bikini);
        //Vậy là đã lấy được đối tượng Girl nha
    }
}

Với đoạn code ở trên, chúng ta đã gần như tách được Bikini ra hoàn toàn khỏi Girl. điều này làm giảm sự phụ thuộc giữa Girl và Bikini. Mà tăng tính tùy biến, linh hoạt cho code.

Bây giờ Girl sẽ hoạt động với Outfit mà thôi. Và Outfit ở đâu ra? Chúng ta tạo ra và đưa nó vào (Inject) cô gái Girl.

Khái niệm Dependency Injection từ đây mà ra:
Dependency Injection là việc các Object nên phụ thuộc vào các Abstract Class và thể hiện chi tiết của nó sẽ được Inject vào đối tượng lúc runtime.

Bây giờ muốn Girl mặc gì khác, anh em chỉ cần tạo một Class kế thừa Outfit và Inject nó vào Girl là xong!

Dependency Injection giúp chúng ta dễ dàng mở rộng code và giảm sự phụ thuộc giữa các dependency với nhau. Tuy nhiên, lúc này, khi code bạn sẽ phải kiêm thêm nhiệm vụ Inject dependency (tiêm sự phụ thuộc). Thử tưởng tượng một Class có hàng chục dependency thì bạn sẽ phải tự tay inject từng ý cái. Việc này lại dẫn tới khó khăn trong việc code, quản lý code và dependency

package org.tmsblog.patterns.di;

public class Main {
    public static void main(String[] args) {
       Outfit bikini = new Bikini();
       Accessories gucci = new GucciAccessories();
       HairStyle hair = new KoreanHairStyle();
       Girl fukada = new Girl(bikini, gucci, hair);
    }
}

Vãi chưởng nhỉ, lúc này có thằng nào làm hộ được chúng ta việc này thì tốt biết mấy =))).

Bây giờ giả sử, chúng ta định nghĩa trước toàn bộ các dependency có trong Project, mô tả nó và tống nó vào 1 cái kho và giao cho một thằng tên là framework quản lý. Bất kỳ các Class nào khi khởi tạo, nó cần dependency gì, thì cái framework này sẽ tự tìm trong kho rồi inject vào đối tượng thay chúng ta. sẽ tiện hơn phải không?

Úi dời ơi, tuyệt chứ nhỉ, đó cũng chính là nguyên lý chính của Inversion of Control (IOC) – Đảo chiều sự điều khiển

Nguyên văn Wiki:

• Inversion of Control is a programming principle. flow of control within the application is not controlled by the application itself, but rather by the underlying framework.

Khi đó, code chúng ta sẽ chỉ cần như này, để lấy ra đối tượng Girl, còn trong Girl.java anh em tiêm chích Accessories và HairStyle như Outfit nha:

package org.tmsblog.patterns.di;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Main.class, args);

        Girl girl = context.getBean(Girl.class);
        // Anh em muốn lấy gì từ Girl thì cứ chấm mút ra nha =))
    }
}

Lời kết:

Dependency Injection và IoC container là những khái niệm rất quan trọng, hầu hết các ứng dụng, framework hiện tại đều sử dụng nó. Chúng ta cần tìm hiểu để biết rõ DI và IoC được ứng dụng trong trường hợp nào. Nếu áp dụng hợp lý code của chúng ta sẽ ít kết dính hơn (loose coupling), dễ bảo trì, dễ test hơn, tổ chức ứng dụng hợp lý và gọn gàng hơn.

Source Code tham khảo tại đây:

The post Thông não Dependency Injection bằng Eimi Fukada appeared first on Tomoshare.

1. Factory Method Pattern là gì?

Factory Method Design Pattern hay gọi ngắn gọn là Factory Pattern là một trong những Pattern thuộc nhóm Creational Design Pattern. Nhiệm vụ của Factory Pattern là quản lý và trả về các đối tượng theo yêu cầu, giúp cho việc khởi tạo đổi tượng một cách linh hoạt hơn.

Trong Factory Pattern, chúng ta tạo đối tượng mà không để lộ logic tạo đối tượng ở phía người dùng và tham chiếu đến đối tượng mới được tạo ra bằng cách sử dụng một interface chung.

Factory Pattern được sử dụng khi có một class cha (super-class) với nhiều class con (sub-class), dựa trên đầu vào và phải trả về 1 trong những class con đó.

2. Cài đặt Factory Pattern như thế nào?

Một Factory Pattern bao gồm các thành phần cơ bản sau:

• Super Class: môt supper class trong Factory Pattern có thể là một interface, abstract class hay một class thông thường.
• Sub Classes: các sub class sẽ implement các phương thức của supper class theo nghiệp vụ riêng của nó.
• Factory Class: một class chịu tránh nhiệm khởi tạo các đối tượng sub class dựa theo tham số đầu vào. Lưu ý: lớp này là Singleton hoặc cung cấp một public static method cho việc truy xuất và khởi tạo đối tượng. Factory class sử dụng if-else hoặc switch-case để xác định class con đầu ra.

Ví dụ: Tất cả hệ thống Football Club có cung cấp API để truy cập đến hệ thống của họ. Team được giao nhiệm vụ thiết kế một API để client có thể sử dụng dịch vụ của một CLB bất kỳ. Hiện tại, phía client chỉ cần sử dụng dịch vụ của 1 số đội bóng như Becamex Bình Dương, Hoàng Anh Gia Lai, Hà Nội, … Tuy nhiên để dễ mở rộng sau này, và phía client mong muốn không cần phải thay đổi code của họ khi cần sử dụng thêm dịch vụ của đội bóng khác. Với yêu cầu như vậy, chúng ta có thể sử dụng một Pattern phù hợp là Factory Method Pattern.

Hệ thống được minh họa như sau:

Chương trình được cài đặt theo Factory Pattern như sau:

Supper Class:

package com.tmsblog.patterns.creational.factorymethod;

public interface FC {
    String getFCName();
}

Sub Classes:

package com.tmsblog.patterns.creational.factorymethod;
 
public class BECAMEXBinhDuong implements FC {
 
    @Override
    public String getFCName() {
        return "Becamex Binh Duong";
    }
}

package com.tmsblog.patterns.creational.factorymethod;
 
public class HAGL implements FC {
 
    @Override
    public String getFCName() {
        return "Hoang Anh Gia Lai";
    }
}

package com.tmsblog.patterns.creational.factorymethod;
 
public class Hanoi implements FC {
 
    @Override
    public String getFCName() {
        return "Ha Noi";
    }
}

Factory class:

package org.tmsblog.patterns.creational.factorymethod;

import org.tmsblog.enums.FCType;

public class FCFactory {
    public FCFactory() {
    }

    public static final FC getFC(FCType fcType) {
        switch (fcType) {
            case BECAMEX_BD:
                return new BECAMEXBinhDuong();
            case HAGL:
                return new HAGL();
            case HANOI:
                return new Hanoi();
            default:
                throw new IllegalArgumentException("This fc type is unsupported");
        }
    }
}

FC type:

package org.tmsblog.enums;

public enum FCType {
    BECAMEX_BD, HAGL, HANOI
}

Client:

package org.tmsblog.patterns.creational.factorymethod;

import org.tmsblog.enums.FCType;

public class Client {
    public static void main(String[] args) {
        FC fc = FCFactory.getFC(FCType.HANOI);
        System.out.println(fc.getFCName());
    }
}

Như anh em thấy, phía client chỉ cần gọi duy nhất một phương thức FCFactory.getFC() là có thể sử dụng được dịch vụ của một CLB bất kỳ.

Khi hệ thống muốn cung cấp thêm dịch vụ của một CLB khác, chẳng hạn Viettel, thì cần tạo thêm một class mới implement từ interface FC, và thêm vào logic khởi tạo FC trong Factory là xong. Nó không làm ảnh hưởng đến code ở phía Client.

3. Sử dụng Factory Pattern khi nào?

Factory Pattern được sử dụng khi:

• Chúng ta có một super class với nhiều class con và dựa trên đầu vào, chúng ta cần trả về một class con. Mô hình này giúp chúng ta đưa trách nhiệm của việc khởi tạo một lớp từ phía người dùng (client) sang lớp Factory.
• Chúng ta không biết sau này sẽ cần đến những lớp con nào nữa. Khi cần mở rộng, hãy tạo ra sub class và implement thêm vào factory method cho việc khởi tạo sub class này.

4. Lợi ích của Factory Pattern là gì?

Lợi ích của Factory Pattern:

• Factory Pattern giúp giảm sự phụ thuộc giữa các module (loose coupling): cung cấp 1 hướng tiếp cận với Interface thay vì các implement. Giúp chuơng trình độc lập với những lớp cụ thể mà chúng ta cần tạo 1 đối tượng, code ở phía client không bị ảnh hưởng khi thay đổi logic ở factory hay sub class.
• Mở rộng code dễ dàng hơn: khi cần mở rộng, chỉ việc tạo ra sub class và implement thêm vào factory method.
• Khởi tạo các Objects mà che giấu đi xử lí logic của việc khởi tạo đấy. Người dùng không biết logic thực sực được khởi tạo bên dưới phương thức factory.
• Dễ dàng quản lý life cycle của các Object được tạo bởi Factory Pattern.
• Thống nhất về naming convention: giúp cho các developer có thể hiểu về cấu trúc source code.

Anh em có thể thấy Factory Pattern được áp dụng trong:

• JDK: java.util.Calendar, ResourceBundle, NumberFormat, …
• BeanFactory trong Spring Framework.
• SessionFactory trong Hibernate Framework.

Như vậy tôi đã giới thiệu xong về Factory Method Pattern, hy vọng bài viết sẽ giúp ích cho anh em trong quá trình xây dựng và phát triển ứng dụng. Hẹn gặp lại ở các bài viết tiếp theo.

Tài liệu tham khảo:

• https://refactoring.guru/design-patterns/factory-method
• https://sourcemaking.com/design_patterns/factory_method
• https://www.tutorialspoint.com/design_pattern/factory_pattern.htm

The post Hướng dẫn Java Design Pattern – Factory Method appeared first on Tomoshare.

Đôi khi, trong quá trình phân tích thiết kế một hệ thống, chúng ta mong muốn có những đối tượng cần tồn tại duy nhất và có thể truy xuất mọi lúc mọi nơi. Làm thế nào để hiện thực được một đối tượng như thế khi xây dựng mã nguồn? Chúng ta có thể nghĩ tới việc sử dụng một biến toàn cục (global variable : public static final). Tuy nhiên, việc sử dụng biến toàn cục nó phá vỡ quy tắc của OOP (encapsulation). Để giải bài toán trên, người ta hướng đến một giải pháp là sử dụng Singleton pattern.

1. Singleton Pattern là gì?

Singleton là 1 trong 5 design pattern của nhóm Creational Design Pattern.

Singleton đảm bảo chỉ duy nhất một thể hiện (instance) được tạo ra và nó sẽ cung cấp cho anh em một method để có thể truy xuất được thể hiện duy nhất đó mọi lúc mọi nơi trong chương trình.

Sử dụng Singleton khi chúng ta muốn:

• Đảm bảo rằng chỉ có một instance của lớp.
• Việc quản lý việc truy cập tốt hơn vì chỉ có một thể hiện duy nhất.
• Có thể quản lý số lượng thể hiện của một lớp trong giớn hạn chỉ định.

2. Implement Singleton Pattern như thế nào?

Có rất nhiều cách để implement Singleton Pattern. Nhưng dù cho việc implement bằng cách nào đi nữa cũng dựa vào nguyên tắc dưới đây cơ bản dưới đây:

• private constructor để hạn chế truy cập từ class bên ngoài.
• Đặt private static final variable đảm bảo biến chỉ được khởi tạo trong class.
• Có một method public static để return instance được khởi tạo ở trên.

3. Những cách nào để implement Singleton Pattern

Dựa trên những nguyên tắc thiết kế Singleton ở trên, chúng ta có các cách implement singleton như sau:

3.1. Eager initialization

Singleton Class được khởi tạo ngay khi được gọi đến.

package com.tmsblog.patterns.creational.singleton;
 
public class EagerInitializedSingleton {
 
    private static final EagerInitializedSingleton INSTANCE = new EagerInitializedSingleton();
 
    private EagerInitializedSingleton() {}
 
    public static EagerInitializedSingleton getInstance() {
        return INSTANCE;
    }
}

Eager initialization là cách tiếp cận tốt, dễ cài đặt, tuy nhiên nó có một nhược điểm mặc dù instance đã được khởi tạo nhưng có thể sẽ không dùng tới và nó dễ dàng bị phá vỡ bởi Reflection.

3.2. Static block initialization

Cách làm tương tự như Eager initialization chỉ khác phần static block cung cấp thêm lựa chọn cho việc handle exception hay các xử lý khác.

package com.tmsblog.patterns.creational.singleton;
 
public class StaticBlockSingleton {
 
    private static final StaticBlockSingleton INSTANCE;
 
    private StaticBlockSingleton() {}
 
    // Static block initialization for exception handling
    static {
        try {
            INSTANCE = new StaticBlockSingleton();
        } catch (Exception e) {
            throw new RuntimeException("Exception occured in creating singleton instance");
        }
    }
 
    public static StaticBlockSingleton getInstance() {
        return INSTANCE;
    }
}

3.3. Lazy Initialization

Là một cách làm mang tính mở rộng hơn so với 2 cách làm trên và hoạt động tốt trong môi trường đơn luồng (single-thread).

package com.tmsblog.patterns.creational.singleton;
 
public class LazyInitializedSingleton {
 
    private static LazyInitializedSingleton instance;
 
    private LazyInitializedSingleton() {}
 
    public static LazyInitializedSingleton getInstance() {
        if (instance == null) {
            instance = new LazyInitializedSingleton();
        }
        return instance;
    }
}

Cách này đã khắc phục được nhược điểm của cách Eager initialization, chỉ khi nào getInstance() được gọi thì instance mới được khởi tạo. Tuy nhiên, cách này chỉ sử dụng tốt trong trường hợp đơn luồng (single-thread), trường hợp nếu có nhiều luồng (multi-thread) cùng chạy và cùng gọi hàm getInstance() tại cùng một thời điểm thì có thể có nhiều hơn 1 thể hiện của instance. Để khắc phục nhược điểm này chúng ta sử dụng Thread Safe Singleton.

Một nhược điểm nữa của Lazy Initialization cần quan tâm là: đối với thao tác create instance quá chậm thì người dùng có phải chờ lâu cho lần sử dụng đầu tiên.

3.4. Thread Safe Singleton

Cách đơn giản nhất là chúng ta gọi phương thức synchronized của hàm getInstance() và như vậy hệ thống đảm bảo rằng tại cùng một thời điểm chỉ có thể có 1 luồng có thể truy cập vào hàm getInstance() và đảm bảo rằng chỉ có duy nhất 1 thể hiện của class.

package com.tmsblog.patterns.creational.singleton;
 
public class ThreadSafeLazyInitializedSingleton {
 
    private static volatile ThreadSafeLazyInitializedSingleton instance;
 
    private ThreadSafeLazyInitializedSingleton() {}
 
    public static synchronized ThreadSafeLazyInitializedSingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeLazyInitializedSingleton();
        }
        return instance;
    }
}

Biến volatile trong Java có tác dụng thông báo sự thay đổi giá trị của biến tới các thread khác nhau nếu biến này đang được sử dụng trong nhiều thread.

Cách này có nhược điểm là một phương thức synchronized sẽ chạy rất chậm và tốn hiệu năng, bất kỳ Thread nào gọi đến đều phải chờ nếu có một Thread khác đang sử dụng. Có những tác vụ xử lý trước và sau khi tạo thể hiện không cần thiết phải block. Vì vậy chúng ta cần cải tiến nó đi 1 chút với Double Check Locking Singleton.

3.5. Double Check Locking Singleton

Để implement theo cách này, chúng ta sẽ kiểm tra sự tồn tại thể hiện của lớp, với sự hỗ trợ của đồng bộ hóa, hai lần trước khi khởi tạo. Phải khai báo volatile cho instance để tránh lớp làm việc không chính xác do quá trình tối ưu hóa của trình biên dịch.

package com.tmsblog.patterns.creational.singleton;
 
public class DoubleCheckLockingSingleton {
 
    private static volatile DoubleCheckLockingSingleton instance;
 
    private DoubleCheckLockingSingleton() {}
 
    public static DoubleCheckLockingSingleton getInstance() {
        // Do something before get instance ...
        if (instance == null) {
            // Do the task too long before create instance ...
            // Block so other threads cannot come into while initialize
            synchronized (DoubleCheckLockingSingleton.class) {
                // Re-check again. Maybe another thread has initialized before
                if (instance == null) {
                    instance = new DoubleCheckLockingSingleton();
                }
            }
        }
        // Do something after get instance ...
        return instance;
    }
}

3.6. Bill Pugh Singleton Implementation

Với cách làm này bạn sẽ tạo ra static nested class với vai trò 1 Helper khi muốn tách biệt chức năng cho 1 class function rõ ràng hơn. Đây là cách thường hay được sử dụng và có hiệu suất tốt (theo các chuyên gia đánh giá :v).

package com.tmsblog.patterns.creational.singleton;
 
public class BillPughSingleton {
 
    private BillPughSingleton() {}
 
    public static BillPughSingleton getInstance() {
        return SingletonHelper.INSTANCE;
    }
 
    private static class SingletonHelper {
        private static final BillPughSingleton INSTANCE = new BillPughSingleton();
    }
}

Khi Singleton được tải vào bộ nhớ thì SingletonHelper chưa được tải vào. Nó chỉ được tải khi và chỉ khi phương thức getInstance() được gọi. Với cách này tránh được lỗi cơ chế khởi tạo instance của Singleton trong Multi-Thread, performance cao do tách biệt được quá trình xử lý. Do đó, cách làm này được đánh giá là cách triển khai Singleton nhanh và hiệu quả nhất.

3.7. Phá vỡ cấu trúc Singleton Pattern bằng Reflection

Reflection có thể được dùng để phá vỡ Pattern của Eager Initialization ở trên.

package com.tmsblog.patterns.creational.singleton;
 
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
 
public class ReflectionBreakSingleton {
 
    public static void main(String[] args)
            throws InstantiationException, IllegalAccessException, InvocationTargetException {
         
        EagerInitializedSingleton instanceOne = EagerInitializedSingleton.getInstance();
        EagerInitializedSingleton instanceTwo = null;
 
        Constructor<?>[] constructors = EagerInitializedSingleton.class.getDeclaredConstructors();
        for (Constructor<?> constructor : constructors) {
            constructor.setAccessible(true);
            instanceTwo = (EagerInitializedSingleton) constructor.newInstance();
        }
 
        System.out.println(instanceOne.hashCode());
        System.out.println(instanceTwo.hashCode());
    }
}

Output của chương trình:

2018699554
1311053135

Tương tự Eager Initialization, implement theo Bill Pugh Singleton cũng bị break bởi Reflection.

3.8. Enum Singleton

Khi dùng enum thì các params chỉ được khởi tạo 1 lần duy nhất, đây cũng là cách giúp anh em tạo ra Singleton instance.

package com.tmsblog.patterns.creational.singleton;
 
/**
 * Singleton implementation using enum initialization
 */
public enum EnumSingleton {
 
    INSTANCE;
}

Lưu ý:

• Enum có thể sử dụng như một Singleton, nhưng nó có nhược điểm là không thể extends từ một lớp được, nên khi sử dụng cần xem xét vấn đề này.
• Hàm constructor của enum là lazy, nghĩa là khi được sử dụng mới chạy hàm khởi tạo và nó chỉ chạy duy nhất một lần. Nếu muốn sử dụng như một eager singleton thì cần gọi thực thi trong một static block khi start chương trình.

So sánh giữa 2 cách sử dụng enum initialization và static block initialization method, enum có một điểm rất mạnh khi giải quyết về vấn đề Serialization/ Deserialization.

3.9. Serialization and Singleton

Đôi khi trong các hệ thống phân tán (distributed system), chúng ta cần implement interface Serializable trong lớp Singleton để chúng ta có thể lưu trữ trạng thái của nó trong file hệ thống và truy xuất lại nó sau.

package com.tmsblog.patterns.creational.singleton;
 
import java.io.ObjectStreamException;
import java.io.Serializable;
 
public class SerializedSingleton implements Serializable {
 
    private static final long serialVersionUID = 1741825395699241705L;
 
    private SerializedSingleton() {}
 
    private static class SingletonHelper {
        private static final SerializedSingleton instance = new SerializedSingleton();
    }
 
    public static SerializedSingleton getInstance() {
        return SingletonHelper.instance;
    }
     
    /**
     * Special hook provided by serialization where developer can control what object needs to sent.
     * However this method is invoked on the new object instance created by de serialization process.
     *
     * @return
     * @throws ObjectStreamException
     */
//    private Object readResolve() throws ObjectStreamException {
//        return SingletonHelper.instance;
//    }
 
}

Đoạn code test quá trình Serialize/ Deserialize:

package com.tmsblog.patterns.creational.singleton;
 
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
 
public class SingletonSerializedTest {
 
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
 
        SerializedSingleton serializedSingleton1 = SerializedSingleton.getInstance();
        EnumSingleton enumSingleton1 = EnumSingleton.INSTANCE;
 
        ObjectOutput out = new ObjectOutputStream(new FileOutputStream("SingletonSerializedTest.txt"));
        out.writeObject(serializedSingleton1);
        out.writeObject(enumSingleton1);
        out.close();
 
        // De-serialize from file to object
        ObjectInput in = new ObjectInputStream(new FileInputStream("SingletonSerializedTest.txt"));
        SerializedSingleton serializedSingleton2 = (SerializedSingleton) in.readObject();
        EnumSingleton enumSingleton2 = (EnumSingleton) in.readObject();
        in.close();
 
        System.out.println("serializedSingleton1 hashCode=" + serializedSingleton1.hashCode());
        System.out.println("serializedSingleton2 hashCode=" + serializedSingleton2.hashCode());
        System.out.println("enumSingleton1 hashCode=" + enumSingleton1.hashCode());
        System.out.println("enumSingleton2 hashCode=" + enumSingleton2.hashCode());
    }
}

Output của chương trình:

serializedSingleton1 hashCode=1028566121
serializedSingleton2 hashCode=1747585824
enumSingleton1 hashCode=1118140819
enumSingleton2 hashCode=1118140819

Như trong ví dụ trên, Deserialize đối tượng của SerializedSingleton khác với đối tượng gốc. Tuy nhiên vấn đề này không xảy ra khi sử dụng enum.

Thực tế thì vẫn có cách khắc phục khi sử dụng class SerializedSingleton là implement một phương thức readResolve(). Nhưng khi chúng ta thật sự gặp vấn đề và cần sử dụng Serialize/ Deserialize, thì nên sử dụng enum sẽ đơn giản hơn.

4. Sử dụng Singleton Pattern khi nào?

Dưới đây là một số trường hợp sử dụng của Singleton Pattern thường gặp:

• Vì class dùng Singleton chỉ tồn tại 1 Instance (thể hiện) nên nó thường được dùng cho các trường hợp giải quyết các bài toán cần truy cập vào các ứng dụng như: Shared resource, Logger, Configuration, Caching, Thread pool, …
• Một số design pattern khác cũng sử dụng Singleton để triển khai: Abstract Factory, Builder, Prototype, Facade,…
• Đã được sử dụng trong một số class của core java như: java.lang.Runtime, java.awt.Desktop.

5. Tổng kết

Có rất nhiều cách implement cho Singleton, anh em có thể sử dụng BillPughSingleton vì có hiệu suất cao, sử dụng LazyInitializedSingleton cho những ứng dụng chỉ làm việc với ứng dụng single-thread và sử dụng DoubleCheckLockingSingleton khi làm việc với ứng dụng multi-thread. Tùy theo trường hợp cụ thể, anh em hãy chọn cho mình cách implement phù hợp nhé.

Tài liệu tham khảo:

• https://community.oracle.com/docs/DOC-918906
• https://www.journaldev.com/1377/java-singleton-design-pattern-best-practices-examples
• http://www.javacreed.com/the-broken-singleton/
• https://www.geeksforgeeks.org/prevent-singleton-pattern-reflection-serialization-cloning/
• http://www.java67.com/2015/09/thread-safe-singleton-in-java-using-double-checked-locking-pattern.html

The post Hướng dẫn Java Design Pattern – Singleton appeared first on Tomoshare.