Xác định mối quan hệ giữa các đối tượng

Do SQLite là một cơ sở dữ liệu quan hệ nên bạn có thể xác định mối quan hệ giữa các thực thể. Tuy nhiên, trong khi hầu hết các thư viện ánh xạ quan hệ đối tượng cho phép các đối tượng thực thể tham chiếu lẫn nhau thì Room cấm điều này một cách rõ ràng. Để biết lý do kỹ thuật đằng sau quyết định này, hãy xem phần Tìm hiểu lý do Room không cho phép tham chiếu đối tượng.

2 phương pháp khả thi

Trong Room, có hai cách để xác định và truy vấn mối quan hệ giữa các thực thể: sử dụng lớp dữ liệu trung gian với đối tượng được nhúng hoặc phương thức truy vấn quan hệ với kiểu dữ liệu trả về đa ánh xạ (multimap).

Lớp dữ liệu trung gian

Trong cách tiếp cận lớp dữ liệu trung gian, bạn xác định một lớp dữ liệu giúp mô hình hoá mối quan hệ giữa các thực thể Room của bạn. Lớp dữ liệu này duy trì ghép nối giữa các bản sao của một thực thể và các bản sao của một thực thể khác dưới dạng đối tượng được nhúng. Sau đó, phương thức truy vấn có thể trả về các bản sao của lớp dữ liệu này để sử dụng trong ứng dụng.

Ví dụ: bạn có thể xác định lớp dữ liệu UserBook để biểu diễn người dùng thư viện với cuốn sách cụ thể được cho mượn và xác định phương thức truy vấn để truy xuất danh sách các thực thể UserBook từ cơ sở dữ liệu:

@Dao
interface UserBookDao {
    @Query(
        "SELECT user.name AS userName, book.name AS bookName " +
        "FROM user, book " +
        "WHERE user.id = book.user_id"
    )
    fun loadUserAndBookNames(): LiveData<List<UserBook>>
}

data class UserBook(val userName: String?, val bookName: String?)

@Dao
public interface UserBookDao {
   @Query("SELECT user.name AS userName, book.name AS bookName " +
          "FROM user, book " +
          "WHERE user.id = book.user_id")
   public LiveData<List<UserBook>> loadUserAndBookNames();
}

public class UserBook {
    public String userName;
    public String bookName;
}

Loại dữ liệu trả về nhiều bản đồ

Trong phương pháp tiếp cận loại dữ liệu trả về nhiều bản đồ, bạn không cần phải xác định thêm lớp dữ liệu nào cả. Thay vào đó, bạn xác định loại dữ liệu trả về nhiều bản đồ cho phương thức dựa trên cấu trúc bản đồ bạn muốn và trực tiếp xác định mối quan hệ giữa các thực thể trong truy vấn SQL.

Ví dụ: phương thức truy vấn sau đây trả về mối liên kết của các thực thể User và Book để biểu diễn người dùng thư viện với cuốn sách cụ thể được cho mượn:

@Query(
    "SELECT * FROM user" +
    "JOIN book ON user.id = book.user_id"
)
fun loadUserAndBookNames(): Map<User, List<Book>>

@Query(
    "SELECT * FROM user" +
    "JOIN book ON user.id = book.user_id"
)
public Map<User, List<Book>> loadUserAndBookNames();

Chọn một phương pháp

Room hỗ trợ cả hai phương pháp này, vì vậy, bạn có thể sử dụng phương pháp phù hợp nhất với ứng dụng của mình. Phần này thảo luận một số lý do bạn có thể thích một trong hai phương pháp đó.

Phương pháp lớp dữ liệu trung gian giúp bạn không phải viết các truy vấn SQL phức tạp, nhưng cũng có thể làm tăng tính phức tạp của mã nếu các lớp dữ liệu bổ sung yêu cầu như vậy. Tóm lại, phương pháp kiểu dữ liệu trả về đa ánh xạ đòi hỏi các truy vấn SQL làm nhiều việc hơn; còn phương pháp lớp dữ liệu trung gian sẽ yêu cầu mã làm nhiều việc hơn.

Nếu không có lý do cụ thể để sử dụng lớp dữ liệu trung gian, bạn nên sử dụng phương pháp sử dụng kiểu dữ liệu trả về đa ánh xạ. Để tìm hiểu thêm về phương pháp này, hãy xem phần Trả về cấu trúc đa ánh xạ.

Phần còn lại của hướng dẫn này minh hoạ cách xác định các mối quan hệ khi sử dụng phương pháp lớp dữ liệu trung gian.

Tạo đối tượng nhúng

Đôi khi, bạn muốn biểu thị một thực thể hoặc đối tượng dữ liệu dưới dạng một tổng thể ràng buộc trong logic cơ sở dữ liệu, ngay cả khi đối tượng đó chứa nhiều trường. Trong các trường hợp này, bạn có thể sử dụng chú giải @Embedded để biểu thị một đối tượng bạn muốn phân rã vào các trường con trong bảng. Sau đó, bạn có thể truy vấn các trường nhúng giống như với các cột riêng lẻ khác.

Ví dụ: lớp User có thể gồm một trường thuộc loại Address đại diện cho thành phần (composition) của các trường có tên street, city, state và postCode. Để lưu trữ các cột đã được phân rã riêng rẽ trong bảng, hãy bao gồm trường Address trong lớp User được chú giải bằng @Embedded, như minh hoạ trong đoạn mã sau đây:

data class Address(
    val street: String?,
    val state: String?,
    val city: String?,
    @ColumnInfo(name = "post_code") val postCode: Int
)

@Entity
data class User(
    @PrimaryKey val id: Int,
    val firstName: String?,
    @Embedded val address: Address?
)

public class Address {
    public String street;
    public String state;
    public String city;

    @ColumnInfo(name = "post_code") public int postCode;
}

@Entity
public class User {
    @PrimaryKey public int id;

    public String firstName;

    @Embedded public Address address;
}

Khi này, bảng biểu diễn đối tượng User chứa các cột có tên như sau: id, firstName, street, state, city và post_code.

Nếu một thực thể có nhiều trường nhúng cùng loại, thì bạn có thể khiến mỗi cột là duy nhất bằng cách đặt thuộc tính prefix. Sau đó, Room sẽ thêm giá trị được cung cấp vào đầu tên mỗi cột trong đối tượng nhúng.

Định nghĩa mối quan hệ một với một

Mối quan hệ một với một giữa hai thực thể là mối quan hệ trong đó mỗi bản sao của thực thể mẹ tương ứng với đúng một bản sao của thực thể con và ngược lại.

Ví dụ: xem xét một ứng dụng phát nhạc trực tuyến trong đó người dùng có thư viện bài hát mà họ sở hữu. Mỗi người dùng chỉ có một thư viện và mỗi thư viện tương ứng với đúng một người dùng. Do đó, có một mối quan hệ một với một giữa thực thể User và thực thể Library.

Để xác định mối quan hệ một với một, trước tiên, tạo một lớp cho mỗi thực thể. Một trong các thực thể phải gồm một biến là tham chiếu đến khoá chính của thực thể kia.

@Entity
data class User(
    @PrimaryKey val userId: Long,
    val name: String,
    val age: Int
)

@Entity
data class Library(
    @PrimaryKey val libraryId: Long,
    val userOwnerId: Long
)

@Entity
public class User {
    @PrimaryKey public long userId;
    public String name;
    public int age;
}

@Entity
public class Library {
    @PrimaryKey public long libraryId;
    public long userOwnerId;
}

Để truy vấn danh sách người dùng và thư viện tương ứng, trước tiên, bạn phải mô hình hoá mối quan hệ một với một giữa 2 thực thể. Để thực hiện việc này, hãy tạo 1 lớp dữ liệu mới, trong đó mỗi bản sao sẽ chứa 1 bản sao của thực thể mẹ và 1 bản sao tương ứng của thực thể con. Thêm chú thích @Relation vào bản sao của thực thể con, trong đó parentColumn được đặt làm tên cho cột khoá chính của thực thể mẹ và entityColumn được đặt làm tên cho cột của thực thể con mà tham chiếu đến khoá chính của thực thể mẹ.

data class UserAndLibrary(
    @Embedded val user: User,
    @Relation(
         parentColumn = "userId",
         entityColumn = "userOwnerId"
    )
    val library: Library
)

public class UserAndLibrary {
    @Embedded public User user;
    @Relation(
         parentColumn = "userId",
         entityColumn = "userOwnerId"
    )
    public Library library;
}

Cuối cùng, thêm 1 phương thức vào lớp DAO sẽ trả về tất cả các bản sao của lớp dữ liệu có vai trò ghép nối thực thể mẹ và thực thể con. Phương thức này đòi hỏi Room chạy 2 truy vấn. Vì vậy, hãy thêm chú giải @Transaction vào phương thức này để đảm bảo toàn bộ thao tác sẽ được thực hiện tỉ mỉ.

@Transaction
@Query("SELECT * FROM User")
fun getUsersAndLibraries(): List<UserAndLibrary>

@Transaction
@Query("SELECT * FROM User")
public List<UserAndLibrary> getUsersAndLibraries();

Định nghĩa mối quan hệ một với nhiều

Mối quan hệ một với nhiều giữa hai thực thể là mối quan hệ trong đó mỗi bản sao của thực thể mẹ tương ứng với không hoặc nhiều bản sao của thực thể con, nhưng mỗi bản sao của thực thể con chỉ có thể tương ứng với đúng một bản sao của thực thể mẹ.

Trong ví dụ về ứng dụng phát nhạc trực tuyến, giả sử người dùng có thể sắp xếp các bài hát của họ vào danh sách phát. Mỗi người dùng có thể tạo số lượng danh sách phát tuỳ thích nhưng mỗi danh sách phát chỉ do duy nhất 1 người dùng tạo ra. Do đó, có một mối quan hệ một với nhiều giữa thực thể User và thực thể Playlist.

Để xác định mối quan hệ một với nhiều, trước tiên, hãy tạo 1 lớp cho 2 thực thể. Như trong mối quan hệ một với một, thực thể con phải bao gồm 1 biến tham chiếu đến khoá chính của thực thể mẹ.

@Entity
data class User(
    @PrimaryKey val userId: Long,
    val name: String,
    val age: Int
)

@Entity
data class Playlist(
    @PrimaryKey val playlistId: Long,
    val userCreatorId: Long,
    val playlistName: String
)

@Entity
public class User {
    @PrimaryKey public long userId;
    public String name;
    public int age;
}

@Entity
public class Playlist {
    @PrimaryKey public long playlistId;
    public long userCreatorId;
    public String playlistName;
}

Để truy vấn danh sách người dùng và danh sách phát tương ứng, trước tiên, bạn phải mô hình hoá mối quan hệ một với nhiều giữa 2 thực thể. Để thực hiện việc này, hãy tạo 1 lớp dữ liệu mới, trong đó mỗi bản sao sẽ chứa 1 bản sao của thực thể mẹ và 1 danh sách tất cả các bản sao của thực thể con tương ứng. Thêm chú thích @Relation vào bản sao của thực thể con, trong đó parentColumn được đặt làm tên cho cột khoá chính của thực thể mẹ và entityColumn được đặt làm tên cho cột của thực thể con mà tham chiếu đến khoá chính của thực thể mẹ.

data class UserWithPlaylists(
    @Embedded val user: User,
    @Relation(
          parentColumn = "userId",
          entityColumn = "userCreatorId"
    )
    val playlists: List<Playlist>
)

public class UserWithPlaylists {
    @Embedded public User user;
    @Relation(
         parentColumn = "userId",
         entityColumn = "userCreatorId"
    )
    public List<Playlist> playlists;
}

Cuối cùng, thêm 1 phương thức vào lớp DAO sẽ trả về tất cả các bản sao của lớp dữ liệu có vai trò ghép nối thực thể mẹ và thực thể con. Phương thức này đòi hỏi Room chạy 2 truy vấn. Vì vậy, hãy thêm chú giải @Transaction vào phương thức này để đảm bảo toàn bộ thao tác sẽ được thực hiện tỉ mỉ.

@Transaction
@Query("SELECT * FROM User")
fun getUsersWithPlaylists(): List<UserWithPlaylists>

@Transaction
@Query("SELECT * FROM User")
public List<UserWithPlaylists> getUsersWithPlaylists();

Định nghĩa mối quan hệ nhiều với nhiều

Mối quan hệ nhiều với nhiều giữa hai thực thể là mối quan hệ trong đó mỗi bản sao của thực thể mẹ tương ứng với không hoặc nhiều bản sao của thực thể con và ngược lại.

Trong ví dụ về ứng dụng phát nhạc trực tuyến, hãy xem xét các bài hát trong danh sách phát do người dùng lập ra. Mỗi danh sách phát có thể bao gồm nhiều bài hát và mỗi bài hát có thể thuộc nhiều danh sách phát khác nhau. Do đó, có mối quan hệ nhiều với nhiều giữa thực thể Playlist và thực thể Song.

Để xác định mối quan hệ nhiều với nhiều, trước tiên, hãy tạo một lớp cho mỗi thực thể. Mối quan hệ nhiều với nhiều khác hẳn với các loại quan hệ khác bởi vì thường không có tham chiếu đến thực thể mẹ trong thực thể con. Thay vào đó, hãy tạo một lớp thứ ba để đại diện cho một thực thể liên kết hoặc bảng tham chiếu chéo giữa hai thực thể. Bảng tham chiếu chéo phải có cột cho khoá chính từ mỗi thực thể trong mối quan hệ nhiều với nhiều được thể hiện trong bảng. Trong ví dụ này, mỗi hàng trong bảng tham chiếu chéo tương ứng với một cặp gồm bản sao Playlist và bản sao Song trong đó bài hát tham chiếu sẽ được đưa vào danh sách phát để tham chiếu đến.

@Entity
data class Playlist(
    @PrimaryKey val playlistId: Long,
    val playlistName: String
)

@Entity
data class Song(
    @PrimaryKey val songId: Long,
    val songName: String,
    val artist: String
)

@Entity(primaryKeys = ["playlistId", "songId"])
data class PlaylistSongCrossRef(
    val playlistId: Long,
    val songId: Long
)

@Entity
public class Playlist {
    @PrimaryKey public long playlistId;
    public String playlistName;
}

@Entity
public class Song {
    @PrimaryKey public long songId;
    public String songName;
    public String artist;
}

@Entity(primaryKeys = {"playlistId", "songId"})
public class PlaylistSongCrossRef {
    public long playlistId;
    public long songId;
}

Bước tiếp theo phụ thuộc vào cách bạn muốn truy vấn các thực thể liên quan này.

• Nếu bạn muốn truy vấndanh sách phát và danh sáchbài hát tương ứng với từng danh sách phát, tạo một lớp dữ liệu mới chứa mộtPlaylist đối tượng và danh sách tất cả đối tượng Song chứa danh sách phát.
• Nếu bạn muốn truy vấn bài hát và danh sách các danh sách phát tương ứng với từng bài hát, tạo một lớp dữ liệu mới chứa một đối tượng Song duy nhất và một danh sách của tất cả các đối tượng Playlist mà chứa bài hát.

Trong cả hai trường hợp, mô hình hoá mối quan hệ giữa các thực thể bằng cách sử dụng thuộc tính associateBy trong chú thích @Relation của từng lớp này để xác định thực thể tham chiếu chéo cung cấp mối quan hệ giữa thực thể Playlist và thực thể Song.

data class PlaylistWithSongs(
    @Embedded val playlist: Playlist,
    @Relation(
         parentColumn = "playlistId",
         entityColumn = "songId",
         associateBy = Junction(PlaylistSongCrossRef::class)
    )
    val songs: List<Song>
)

data class SongWithPlaylists(
    @Embedded val song: Song,
    @Relation(
         parentColumn = "songId",
         entityColumn = "playlistId",
         associateBy = Junction(PlaylistSongCrossRef::class)
    )
    val playlists: List<Playlist>
)

public class PlaylistWithSongs {
    @Embedded public Playlist playlist;
    @Relation(
         parentColumn = "playlistId",
         entityColumn = "songId",
         associateBy = @Junction(PlaylistSongCrossref.class)
    )
    public List<Song> songs;
}

public class SongWithPlaylists {
    @Embedded public Song song;
    @Relation(
         parentColumn = "songId",
         entityColumn = "playlistId",
         associateBy = @Junction(PlaylistSongCrossref.class)
    )
    public List<Playlist> playlists;
}

Cuối cùng, thêm một phương thức vào lớp DAO để hiển thị chức năng truy vấn mà ứng dụng của bạn cần.

• getPlaylistsWithSongs: phương thức này truy vấn cơ sở dữ liệu và trả về tất cả đối tượng PlaylistWithSongs thu được.
• getSongsWithPlaylists: phương thức này truy vấn cơ sở dữ liệu và trả về tất cả đối tượng SongWithPlaylists thu được.

Mỗi phương thức này đòi hỏi Room phải chạy hai phương thức truy vấn. Vì vậy, hãy thêm chú thích @Transaction vào cả hai phương thức để đảm bảo thực hiện toàn bộ thao tác một cách tỉ mỉ.

@Transaction
@Query("SELECT * FROM Playlist")
fun getPlaylistsWithSongs(): List<PlaylistWithSongs>

@Transaction
@Query("SELECT * FROM Song")
fun getSongsWithPlaylists(): List<SongWithPlaylists>

@Transaction
@Query("SELECT * FROM Playlist")
public List<PlaylistWithSongs> getPlaylistsWithSongs();

@Transaction
@Query("SELECT * FROM Song")
public List<SongWithPlaylists> getSongsWithPlaylists();

Định nghĩa mối quan hệ lồng ghép

Đôi khi, bạn cần truy vấn một tập hợp gồm ba bảng trở lên và tất cả đều liên quan đến nhau. Trong trường hợp đó, bạn sẽ xác định mối quan hệ lồng ghép giữa các bảng.

Giả sử trong ví dụ về ứng dụng phát nhạc trực tuyến, bạn muốn truy vấn tất cả người dùng, danh sách phát của mỗi người dùng và tất cả bài hát trong từng danh sách phát của từng người dùng. Người dùng có mối quan hệ một với nhiều với danh sách phát và danh sách phát có mối quan hệ nhiều với nhiều với bài hát. Mã ví dụ sau đây hiển thị các lớp đại diện cho các thực thể này, cũng như bảng tham chiếu chéo cho mối quan hệ nhiều với nhiều giữa danh sách phát và bài hát:

@Entity
data class User(
    @PrimaryKey val userId: Long,
    val name: String,
    val age: Int
)

@Entity
data class Playlist(
    @PrimaryKey val playlistId: Long,
    val userCreatorId: Long,
    val playlistName: String
)

@Entity
data class Song(
    @PrimaryKey val songId: Long,
    val songName: String,
    val artist: String
)

@Entity(primaryKeys = ["playlistId", "songId"])
data class PlaylistSongCrossRef(
    val playlistId: Long,
    val songId: Long
)

@Entity
public class User {
    @PrimaryKey public long userId;
    public String name;
    public int age;
}

@Entity
public class Playlist {
    @PrimaryKey public long playlistId;
    public long userCreatorId;
    public String playlistName;
}
@Entity
public class Song {
    @PrimaryKey public long songId;
    public String songName;
    public String artist;
}

@Entity(primaryKeys = {"playlistId", "songId"})
public class PlaylistSongCrossRef {
    public long playlistId;
    public long songId;
}

Trước tiên, hãy mô hình hoá mối quan hệ giữa hai bảng trong tập hợp của bạn như bình thường, sử dụng lớp dữ liệu và chú giải @Relation. Ví dụ sau đây hiển thị một lớp PlaylistWithSongs mà mô hình hoá mối quan hệ nhiều với nhiều giữa lớp thực thể Playlist và lớp thực thể Song:

data class PlaylistWithSongs(
    @Embedded val playlist: Playlist,
    @Relation(
         parentColumn = "playlistId",
         entityColumn = "songId",
         associateBy = Junction(PlaylistSongCrossRef::class)
    )
    val songs: List<Song>
)

public class PlaylistWithSongs {
    @Embedded public Playlist playlist;
    @Relation(
         parentColumn = "playlistId",
         entityColumn = "songId",
         associateBy = Junction(PlaylistSongCrossRef.class)
    )
    public List<Song> songs;
}

Sau khi xác định một lớp dữ liệu đại diện cho mối quan hệ này, hãy tạo một lớp dữ liệu khác mà mô hình hoá mối quan hệ giữa một bảng khác từ tập hợp của bạn và lớp mối quan hệ đầu tiên, "lồng" mối quan hệ hiện có vào trong mối quan hệ mới. Ví dụ sau đây hiển thị một lớp UserWithPlaylistsAndSongs mà mô hình hoá mối quan hệ một với nhiều giữa lớp thực thể User và lớp mối quan hệ PlaylistWithSongs:

data class UserWithPlaylistsAndSongs(
    @Embedded val user: User
    @Relation(
        entity = Playlist::class,
        parentColumn = "userId",
        entityColumn = "userCreatorId"
    )
    val playlists: List<PlaylistWithSongs>
)

public class UserWithPlaylistsAndSongs {
    @Embedded public User user;
    @Relation(
        entity = Playlist.class,
        parentColumn = "userId",
        entityColumn = "userCreatorId"
    )
    public List<PlaylistWithSongs> playlists;
}

Lớp UserWithPlaylistsAndSongs gián tiếp mô hình hoá mối quan hệ giữa cả ba lớp thực thể: User, Playlist và Song. Điều này được minh hoạ trong hình 1.

Hình 1. Sơ đồ các lớp mối quan hệ trong ví dụ về ứng dụng phát nhạc trực tuyến.

Nếu còn bất kỳ bảng nào khác trong tập hợp của bạn, tạo một lớp để mô hình hoá mối quan hệ giữa từng bảng còn lại và lớp mối quan hệ mà mô hình hoá mối quan hệ giữa tất cả các bảng trước đó. Điều này tạo ra một chuỗi các mối quan hệ lồng ghép giữa tất cả các bảng bạn muốn truy vấn.

Cuối cùng, hãy thêm một phương thức vào lớp DAO để hiển thị chức năng truy vấn mà ứng dụng của bạn cần. Phương thức này đòi hỏi Room chạy nhiều truy vấn. Vì vậy, hãy thêm chú thích @Transaction để đảm bảo rằng toàn bộ thao tác sẽ được thực hiện tỉ mỉ.

@Transaction
@Query("SELECT * FROM User")
fun getUsersWithPlaylistsAndSongs(): List<UserWithPlaylistsAndSongs>

@Transaction
@Query("SELECT * FROM User")
public List<UserWithPlaylistsAndSongs> getUsersWithPlaylistsAndSongs();

Tài nguyên khác

Để tìm hiểu thêm về việc xác định mối quan hệ giữa các thực thể trong Room, hãy xem các tài nguyên khác dưới đây.

Mẫu

• Android Sunflower
• Tivi

Video

• Tính năng mới trong Room (Android Dev Summit '19)

Blog

• Mối quan hệ của cơ sở dữ liệu với Room