Tight-coupling and loose-coupling between Java objects

POJI và POJO

Trước khi tìm hiểu về Tight-coupling và loose-coupling ta tìm hiểu POJI và POJO là gì.

1. POJI

La viết tắt của Plain Old Java Interface. Một POJI là một interface Java thuần, nó không extend interface của bất kì framework hay technology nào.

Ví dụ:

// POJI
public interface MyInterface1 {
    public void Method1();

    public Integer Method2();
}
// MyInterface1 là POJI

public interface MyInterface2 extends Serializable {
    public void Method1();

    public Integer Method2();
}
// MyInterface2 là POJI vì Serializable là một core interface (tức nó là một POJI)

public interface MyInterface3 extends MyInterface1 {
    // Some themods
}
// MyInterface3 là POJI vì MyInterface1 là user interface.
// --------------------------------------------------
// Not POJI
public interface MyServlet extends javax.servlet.Servlet {
    // Some themods
}

public interface MyInterface4 extends MyServlet {
    // Some themods
}
// MyServlet và MyInterface4 không phải POJI vì Servlet không phải là POJI (là interface của framework Servlet)

Public interface MyInterface5 extends java.rmi.Remote {
    // Some themods
}
// MyInterface5 không phải POJI vì Remote là interface của RMI technology.

1. POJO

Là viết tắt của Plain Old Java Object. Một POJO là một class Java thuần, tức là nó không extend/implement bất kỳ class/interface của framework hay một technology nào.

Ví dụ: // POJO

public class MyClass1 {
    // Some methods
}
// MyClass1 là một POJO

public class MyClass2 implements Serializable {
    // Some methods
}
// MyClass2 là một POJO vì Serializable là một POJI

public class MyClass3 extends MyClass1 {
    // Some methods
}
// MyClass3 là một POJO vì MyClass1 là một POJO

public class MyClass implements MyInterface1 {
    // Some methods
}
// MyClass là một POJO vì MyInterface1 là một POJI.
// Ta gọi là POJI/POJO model.
// --------------------------------------------------
// Not POJO
public class MyClass4 implements javax.servlet.Servlet {
    // Some methods
}
// MyClass4 không là một POJO vì Servlet không phải một POJI

public class MyClass5 extends MyClass4 {
    // Some methods
}
// MyClass5 không là một POJO vì MyClass4 không phải một POJO

Tight-coupling và Loose-coupling

1. Tight-coupling

Lập trình OOP nói chúng và Java nói riêng thì việc Class A có logic gọi logic của Class B là hết sức thông thường. Tại Class A sẽ khởi tạo 1 đối tượng của Class B để sử dụng logic của Class B. Khi đó ta nói tồn tại tight-coupling giữa Clas A và Class B.

public class Travel {
    Car car = new Car();
    void startJourney() {
        car.travel();
    }
}

public class Car {
    void move() {
        System.out.prinln("Move by Car");
    }
}

public class Train {
    void move() {
        System.out.prinln("Move by Train");
    }
}

Ở ví dụ trên ta nói class Travel dependent class Car, hay class Car dependency của class Travel. Trong trường hợp này class Travel tight coupled (phụ thuộc/ghép đôi một cách chặt chẽ) với class Car. Nghĩa là khi clas Cả thay đổi method move() thì clas Travel cũng phải thay đổi theo. Hay khi startJourney() muốn đổi từ Car sang Train thì ta phải viết lại Travel như sau.

public clas Travel {
    Train train = new Train();
    void startJourney() {
        train.travel();
    }
}

1. Loose-coupling

Để loại bỏ tight coupled giữa clas Travel và class Car ta phải tổ chức các class theo mô hình POJI/POJO như sau.

public interface Vehicle {

    void move();

}

public class Car implements Vehicle {
    @Override
    void move() {
        System.out.prinln("Move by Car");
    }
}

public class Train implements Vehicle {
    @Override
    void move() {
        System.out.prinln("Move by Train");
    }
}

public clas Travel {
    Vehicle v = new Car();
    void setV(Vehicle v) {
        this.v = v;
    }

    void startJourney() {
        v.move();
    }
}

Với cách tổ chức theo mô hình POJI/POJO như trên thì class Travel không còn bị phụ thuộc chặt chẽ vào class Cả hay class Train nữa. Ta nói class Travle và class Car là loose-coupling.