Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

Git, DevOps & ToolingMid21 phút đọc

Git: branching, merge vs rebase, conflict, reflog và quy trình Pull Request

Ôn 21 thẻ
Trong bài này

Cụm bài Git: 1. Commit và object model · 2. Remote, tag và backup · 3. Branching, merge, rebase và PR

Phần 1 đã nói commit là snapshot, branch chỉ là con trỏ tới commit, HEAD trỏ tới branch hiện tại. Phần này dùng nền đó cho làm việc nhóm: gộp branch, conflict, merge hay rebase, hoàn tác, chiến lược branching, reflog và Pull Request. Đọc xong, bạn biết lệnh nào an toàn trên nhánh chung và lệnh nào chỉ dùng trên nhánh riêng.

1. Branching

Ý chính: branch cho mỗi người một ngữ cảnh riêng để làm song song, xong việc thì gộp lại. Vì branch chỉ là con trỏ, tạo và xoá branch gần như không tốn gì.

Ví dụ trong slide: Dev A làm Hotel, Dev B làm Room, cùng commit trên một dòng phát triển, nên code lỗi của A làm hỏng luôn phần của B.

gitGraph
  commit id: "init"
  branch feature/hotel
  checkout feature/hotel
  commit id: "hotel entity"
  checkout main
  branch feature/room
  checkout feature/room
  commit id: "room entity"
  checkout feature/hotel
  commit id: "hotel api"
  checkout main
  merge feature/hotel
  merge feature/room
git checkout -b feature/hotel     # tạo và chuyển sang branch mới (cách cũ)
git switch -c feature/hotel       # cách mới, Git >= 2.23 — rõ nghĩa hơn
git checkout main                 # chuyển branch (cách cũ)
git switch main                   # cách mới
git merge feature/hotel           # gộp feature/hotel VÀO branch hiện tại
git branch -d feature/hotel       # xoá branch đã merge

Đặt tên branch

Ý chính: đặt tên theo loại việc, khớp commit type: feature/, fix/, refactor/, chore/, docs/, thường kèm mã ticket như feature/BK-123-search-by-city.

Tách branch từ đâu (release gần nhất, develop hay main) tuỳ chiến lược branching — xem mục 4.

Fast-forward và merge commit

Ý chính: nếu nhánh đích đứng yên, Git chỉ dời con trỏ; nếu cả hai cùng đi tiếp, Git tạo một commit gộp.

2. Merge conflict

Ý chính: conflict là lúc Git không tự quyết được nên lấy bên nào, nên bạn phải sửa tay. Sửa xong vẫn phải build và chạy test.

Ba trường hợp điển hình:

  • Hai nhánh cùng sửa cùng một vùng dòng trong cùng file.
  • Một nhánh sửa file X, nhánh kia xoá file X (modify/delete conflict).
  • Hai nhánh đổi tên một file thành hai tên khác nhau (rename/rename).

Git đánh dấu chỗ xung đột ngay trong file:

public BigDecimal totalPrice(Booking b) {
<<<<<<< HEAD
    return b.nightlyPrice().multiply(BigDecimal.valueOf(b.nights()));
=======
    return b.nightlyPrice().multiply(BigDecimal.valueOf(b.nights())).subtract(b.discount());
>>>>>>> feature/coupon
}

Các bước giải quyết:

  1. Mở file bị conflict (git status liệt kê là “both modified”).
  2. Giữ bên hiện tại, giữ bên kia, hoặc kết hợp cả hai. Kết hợp thường đúng nhất: ví dụ trên cần cả discount.
  3. Xoá hết các dấu <<<<<<<, =======, >>>>>>>.
  4. git add <file> rồi git commit (hoặc git rebase --continue nếu đang rebase).
  • git merge --abort / git rebase --abort quay về trạng thái trước khi bắt đầu.
  • Phòng hơn chữa: branch sống ngắn, đưa main vào thường xuyên, tách refactor lớn ra PR riêng, thống nhất formatter để không conflict vì khoảng trắng.
Công cụ hỗ trợ resolve: zdiff3 và rerere

git rerere (reuse recorded resolution) ghi nhớ cách bạn đã resolve một conflict để tự áp dụng lại lần sau gặp đúng conflict đó.

3. Merge vs rebase

Ý chính: cả hai đều đưa thay đổi của nhánh này vào nhánh kia. Merge giữ lịch sử như đã xảy ra; rebase viết lại commit của bạn để lịch sử thẳng — chỉ làm thế với commit chưa ai dùng.

# Đang ở feature/coupon, main đã có commit mới
git merge main      # tạo merge commit trên feature/coupon
git rebase main     # "nhấc" các commit của feature/coupon, đặt lại lên đầu main
gitGraph
  commit id: "A"
  commit id: "B"
  branch feature
  checkout feature
  commit id: "X"
  commit id: "Y"
  checkout main
  commit id: "C"
  checkout feature
  merge main id: "merge main"

Cách làm mình thấy hiệu quả ở các team:

  • Trong lúc làm: git pull --rebase để cập nhật nhánh feature cá nhân.
  • Trước khi mở PR: git rebase -i main để gộp, sửa commit cho sạch.
  • Khi merge PR: merge commit, squash and merge (gộp cả PR thành một commit — phổ biến nhất với trunk-based), hoặc rebase and merge.

Interactive rebase, squash, cherry-pick, revert

Ý chính: interactive rebase dọn commit trên nhánh riêng; cherry-pick chép một commit sang nhánh khác; revert hoàn tác bằng commit mới, an toàn trên main.

  • Squash: gộp nhiều commit thành một (git rebase -i HEAD~4, đổi pick thành squash hoặc fixup).
  • Cherry-pick: áp thay đổi của một commit lên nhánh khác, tạo commit mới với hash khác. Hợp cho hotfix, không nên là cách tích hợp chính vì sinh commit trùng nội dung ở hai nhánh.
  • Revert: thêm commit ngược lại, không viết lại lịch sử. Đây là cách đúng để hoàn tác trên main.
Lệnh chi tiết: rebase -i, fixup/autosquash, cherry-pick -x, revert merge commit

Slide gợi ý đọc thêm ba khái niệm này, nên mình viết luôn:

git rebase -i HEAD~4
# Mở editor:
# pick   1a2b3c feat(booking): add entity
# squash 4d5e6f wip            -> gộp vào commit phía trên
# fixup  7a8b9c fix typo       -> gộp, bỏ message
# reword 0c1d2e add api        -> sửa message

git commit --fixup=1a2b3c         # đánh dấu commit này là bản sửa cho 1a2b3c
git rebase -i --autosquash main   # tự xếp và gộp các commit fixup

git cherry-pick 9f8e7d            # chép một commit cụ thể sang nhánh hiện tại (vd: đưa hotfix sang nhánh release)
git cherry-pick -x 9f8e7d         # thêm dòng "cherry picked from ..." để truy vết

git revert 9f8e7d                 # tạo commit MỚI đảo ngược 9f8e7d — an toàn trên nhánh chung
git revert -m 1 <merge-commit>    # revert một merge commit, giữ cha thứ nhất

reset — ba chế độ

Ý chính: reset kéo con trỏ branch lùi lại, ba chế độ khác nhau ở chỗ thay đổi còn nằm đâu. Vì viết lại lịch sử, chỉ dùng trên nhánh riêng.

4. Chiến lược branching: Git Flow vs trunk-based

Ý chính: chọn theo cách bạn release. Phải duy trì nhiều phiên bản song song thì Git Flow; deploy liên tục với CI tốt thì trunk-based.

gitGraph
  commit id: "v1.0" tag: "v1.0"
  branch develop
  checkout develop
  commit id: "dev"
  branch feature/search
  checkout feature/search
  commit id: "search"
  checkout develop
  merge feature/search
  branch release/1.1
  checkout release/1.1
  commit id: "bump version"
  checkout main
  merge release/1.1 tag: "v1.1"
  checkout develop
  merge release/1.1

Câu “tách branch từ release gần nhất” trong slide đúng với Git Flow hay mô hình release branch. Với trunk-based, bạn luôn tách từ main mới nhất. Pipeline đi kèm trunk-based (CI trên PR, merge vào main là lên staging, release bằng tag) có ở CI/CD cho backend.

Góc nhìn senior: nghiên cứu DORA (sách Accelerate) cho thấy team hiệu suất cao thường dùng branch ngắn và tích hợp liên tục. Git Flow không “sai”, nhưng chi phí của nó (merge muộn, conflict lớn, release chậm) chỉ đáng khi phải duy trì nhiều phiên bản. Khi chọn, hỏi ba câu: deploy bao lâu một lần? có phải hỗ trợ nhiều version cùng lúc không? test tự động có đủ tin để main luôn xanh không?

5. Reflog: phao cứu sinh

Ý chính: Git ghi lại mọi lần HEAD và branch di chuyển, nên commit “mất” vì reset --hard, xoá nhầm branch hay rebase hỏng gần như luôn tìm lại được.

Reflog chỉ nằm trên máy bạn, mặc định giữ mục còn truy cập được khoảng 90 ngày, mục không còn truy cập được 30 ngày. Giống lịch sử trình duyệt: tab đã đóng vẫn mở lại được.

git reflog
# 3f2a1b0 HEAD@{0}: reset: moving to HEAD~3
# 9c8d7e6 HEAD@{1}: commit: feat(booking): add cancel api
# ...

git switch -c rescue 9c8d7e6       # tạo branch tại commit tưởng đã mất
# hoặc
git reset --hard HEAD@{1}          # quay về trạng thái ngay trước lần reset

git reflog show feature/coupon     # reflog của riêng một branch
git branch feature/coupon <hash>   # khôi phục branch đã xoá

Một công cụ nữa đáng biết: git bisect tìm commit gây bug bằng tìm kiếm nhị phân — mỗi bước loại một nửa số commit.

git bisect start
git bisect bad                 # commit hiện tại lỗi
git bisect good v1.2.0         # tag này còn chạy đúng
git bisect run ./mvnw -q test -Dtest=BookingPriceTest   # tự động chạy test ở từng bước
git bisect reset

6. Quy trình code review với Pull Request

Ý chính: mọi thay đổi vào main đi qua một PR nhỏ, có CI xanh và ít nhất một người duyệt. Reviewer ưu tiên thiết kế và tính đúng, để style cho máy lo.

sequenceDiagram
  participant Dev
  participant GH as GitHub
  participant CI
  participant Rev as Reviewer
  Dev->>Dev: git switch -c feature/BK-42-cancel-booking
  Dev->>GH: git push -u origin feature/BK-42-cancel-booking
  Dev->>GH: Mở Pull Request (mô tả, cách test, ảnh/log)
  GH->>CI: Chạy build, test, lint, scan bảo mật
  CI-->>GH: Kết quả (bắt buộc xanh)
  Rev->>GH: Review, comment
  Dev->>GH: Push commit sửa (hoặc fixup)
  Rev->>GH: Approve
  GH->>GH: Squash/merge vào main, xoá branch

Hai thói quen quan trọng nhất: PR nhỏ (lý tưởng < 400 dòng thay đổi) và tự review diff của mình trước khi nhờ người khác.

Checklist cho tác giả PR, reviewer và cấu hình bảo vệ trên GitHub

Tác giả PR:

  • PR nhỏ (lý tưởng < 400 dòng thay đổi). PR khổng lồ sẽ được review hời hợt.
  • Mô tả: vấn đề gì, giải pháp gì, vì sao chọn cách này, test thế nào, rủi ro gì.
  • Tự review diff của mình trước khi nhờ người khác.
  • Tách refactor thuần và thay đổi hành vi ra hai PR.

Reviewer, theo thứ tự ưu tiên:

  1. Thiết kế và tính đúng: giải quyết đúng vấn đề chưa, edge case, concurrency, transaction.
  2. Bảo mật và dữ liệu: input validation, phân quyền, secret, migration có an toàn không (khoá bảng? rollback được không?).
  3. Test: có test cho hành vi mới và bug vừa sửa không.
  4. Khả năng đọc, đặt tên.
  5. Style — để formatter/linter lo, đừng tốn công người.

Bảo vệ trên GitHub: branch protection cho main (cấm push thẳng, bắt buộc PR, CI xanh, ít nhất 1 approval) và file CODEOWNERS để tự gán người review theo thư mục.

Bài tập

Đề (diễn đạt lại): Tạo một repo GitHub chứa bài tập của khoá. Mỗi buổi học có một nhánh riêng (ví dụ “toán tử và điều kiện”, “mảng, chuỗi, I/O”). Từ nhánh buổi học, tạo nhánh con cho từng bài, đưa code vào, rồi merge các nhánh bài về nhánh buổi học.

Gợi ý: đừng đặt nhánh bài là <nhánh buổi>/01 — Git không cho branch a/b và a/b/c cùng tồn tại (xem lời giải).

Lời giải: repo bài tập theo buổi và nhánh bài
mkdir f01-homework && cd f01-homework
git init -b main
cat > .gitignore <<'EOF'
target/
out/
*.class
.idea/
*.iml
.DS_Store
EOF
echo "# Homework - Fundamentals of Backend" > README.md
git add .gitignore README.md
git commit -m "chore: init repository"

gh repo create f01-homework --private --source=. --remote=origin --push
# hoặc tạo trên web rồi: git remote add origin <url> && git push -u origin main

# --- Buổi 03 ---
git switch -c lesson/03-operators-conditions main
git push -u origin lesson/03-operators-conditions

git switch -c exercise/03-operators-conditions/01 lesson/03-operators-conditions
mkdir -p lesson03 && cp ~/old-code/lesson03/Ex01.java lesson03/
git add lesson03/Ex01.java
git commit -m "feat(lesson03): add exercise 01 - classify triangle"
git push -u origin exercise/03-operators-conditions/01

git switch lesson/03-operators-conditions
git merge --no-ff exercise/03-operators-conditions/01 -m "merge exercise 03/01 into lesson 03"
git push

# --- Buổi 05: lặp lại với exercise/05-arrays-text-io/02 ---
git switch -c lesson/05-arrays-text-io main
git switch -c exercise/05-arrays-text-io/02
# ... copy code, add, commit, push, switch về lesson, merge --no-ff

git log --oneline --graph --all     # kiểm tra cấu trúc

Giải thích:

  • --no-ff giữ lại merge commit, nên git log --graph cho thấy rõ bài nào gộp vào buổi nào — đúng mục đích bài tập.
  • Thực tế, bước merge nên đi qua Pull Request trên GitHub (exercise → lesson) để luyện quy trình review, thay vì merge ở máy.
  • .gitignore có ngay commit đầu nên không lỡ đẩy file .class hay cấu hình IDE lên.

Bài thêm (tự đặt): luyện conflict và reflog — tạo hai nhánh cùng sửa một dòng, merge cả hai vào main, resolve, rồi “lỡ tay” reset --hard và cứu lại.

Lời giải bài thêm: conflict và reflog
git switch -c a main && echo "price = 100" > p.txt && git add p.txt && git commit -m "a"
git switch -c b main && echo "price = 120" > p.txt && git add p.txt && git commit -m "b"
git switch main && git merge a && git merge b        # conflict ở p.txt
# sửa p.txt, xoá marker, git add p.txt, git commit
git reset --hard HEAD~2                              # "lỡ tay"
git reflog                                           # tìm lại hash merge commit
git reset --hard HEAD@{1}                            # cứu lại

Ghi nhớ

  • Giải thích được khi nào merge là fast-forward, khi nào Git tạo merge commit, và --no-ff để làm gì.
  • Biết khi nào rebase an toàn, khi nào không, và vì sao dùng --force-with-lease thay cho --force.
  • Chọn được giữa reset và revert, và nói được ba chế độ của reset.
  • Lập luận được Git Flow hay trunk-based cho một team dựa trên tần suất deploy, số version và độ tin của test.
  • Biết cứu commit bằng reflog và giới hạn của nó, và tìm commit gây bug bằng git bisect.

Câu hỏi phỏng vấn

Junior

Merge conflict xảy ra khi nào và giải quyết thế nào?

Khi Git không tự quyết được bên nào đúng: hai nhánh sửa cùng vùng dòng, hoặc một bên sửa còn bên kia xoá/đổi tên file.

Mở file, giữ một bên hoặc kết hợp, xoá các marker <<<<<<< ======= >>>>>>>, git add, rồi commit (hoặc rebase --continue). Sau đó build và chạy test, vì conflict có thể sai logic dù đúng cú pháp.

Fast-forward merge là gì? Khi nào Git tạo merge commit?

Fast-forward là khi Git chỉ dời con trỏ nhánh đích lên, không tạo commit mới; merge commit xuất hiện khi cả hai nhánh đều có commit mới.

Nếu nhánh đích chưa có commit mới kể từ lúc tách nhánh, Git dời con trỏ lên commit cuối của nhánh feature. Nếu cả hai đều đi tiếp, Git làm three-way merge dựa trên merge base và tạo merge commit có hai cha. git merge --no-ff ép tạo merge commit kể cả khi fast-forward được, để giữ dấu vết của feature.

Mid

Merge và rebase khác nhau thế nào? Khi nào dùng cái nào?

Merge giữ nguyên lịch sử bằng merge commit; rebase chép lại commit của bạn lên đầu nhánh đích, tạo hash mới và lịch sử thẳng.

Dùng rebase cho nhánh cá nhân chưa chia sẻ (cập nhật từ main, dọn commit trước PR). Dùng merge (hoặc squash merge qua PR) để đưa vào nhánh chung. Không rebase commit mà người khác đã dựa vào.

revert và reset khác nhau thế nào?

reset viết lại lịch sử, chỉ an toàn trên nhánh cá nhân; revert thêm commit ngược, an toàn trên nhánh chung.

reset di chuyển con trỏ branch về commit cũ. revert tạo một commit mới đảo ngược thay đổi của commit cũ, không đụng tới lịch sử đã có, nên dùng được trên main.

–force-with-lease khác –force thế nào?

--force ghi đè remote bất kể trên đó có gì; --force-with-lease từ chối nếu remote đã có commit bạn chưa thấy.

--force-with-lease chỉ ghi đè khi remote vẫn ở đúng commit bạn biết lần cuối (theo remote-tracking branch — bản sao trên máy bạn của nhánh remote). Nếu ai đó vừa push thêm, lệnh bị từ chối, tránh xoá mất công của đồng đội.

Squash merge có ưu nhược điểm gì?

Ưu: mỗi PR là một commit, lịch sử gọn, revert cả tính năng bằng một lệnh. Nhược: mất commit nhỏ bên trong và dễ conflict lặp nếu nhánh feature còn được dùng tiếp.

Mất chi tiết commit nhỏ làm khó bisect bên trong PR. Nếu nhánh feature tiếp tục được dùng sau khi squash, Git không nhận ra các commit của nó đã được merge, nên dễ sinh conflict lặp lại.

Cherry-pick dùng khi nào, có rủi ro gì?

Dùng khi cần đưa một commit cụ thể sang nhánh khác mà không merge cả nhánh, điển hình là đưa hotfix từ main sang nhánh release cũ.

Rủi ro: commit trùng nội dung nhưng khác hash ở hai nhánh, về sau merge hai nhánh có thể conflict. Commit được pick cũng có thể phụ thuộc vào commit khác chưa có ở nhánh đích. Dùng -x để ghi nguồn gốc.

Senior

Lỡ reset –hard mất 3 commit, hoặc xoá nhầm branch chưa merge. Bạn cứu thế nào?

Dùng git reflog tìm hash trước lần reset (hoặc commit cuối của branch đã xoá), rồi tạo branch tại đó hoặc reset về đó.

Lệnh: git branch rescue <hash> hoặc git reset --hard HEAD@{n}. Commit vẫn còn trong object database cho đến khi bị gc (garbage collection, mặc định cỡ 30–90 ngày). Thay đổi chưa từng stage/commit thì reflog không cứu được.

Git Flow hay trunk-based? Bạn chọn thế nào cho một team?

Tuỳ cách release: nhiều version song song thì Git Flow, deploy liên tục với CI mạnh thì trunk-based.

  • Git Flow hợp sản phẩm có phiên bản (app mobile, thư viện, on-premise), đổi lại tích hợp muộn, conflict lớn.
  • Trunk-based hợp dịch vụ web deploy liên tục: branch ngắn, main luôn deploy được, tính năng dở dang ẩn sau feature flag. Nó đòi hỏi CI nhanh, test tự động tin cậy, review nhanh.
  • Mình xem tần suất deploy, số version cần duy trì và độ trưởng thành của test, và thường nghiêng về trunk-based + release branch khi cần hotfix bản cũ.
Làm sao để tìm commit nào gây ra một bug hồi quy trong 500 commit gần nhất?

Dùng git bisect: tìm kiếm nhị phân giữa một commit tốt và một commit xấu, khoảng log2(500) ≈ 9 bước.

Mỗi bước bạn (hoặc một script qua git bisect run) báo commit đó tốt hay xấu, Git chia đôi khoảng còn lại. Bisect chỉ hiệu quả khi mỗi commit đều build và test được — đó là lý do commit hygiene quan trọng.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu tiếng Anh dùng trong phỏng vấn
merge conflict /mɜːrdʒ ˈkɑːnflɪkt/ xung đột khi gộp “We hit a merge conflict because both teams edited the pricing logic.”
rebase /ˌriːˈbeɪs/ đặt lại gốc nhánh “I rebase my feature branch onto main before opening a pull request.”
fast-forward /ˌfæst ˈfɔːrwərd/ tua thẳng con trỏ “Since main hadn’t moved, the merge was a fast-forward.”
squash /skwɑːʃ/ gộp commit “We squash each pull request into a single commit on main.”
cherry-pick /ˈtʃeri pɪk/ chép một commit sang nhánh khác “We cherry-picked the hotfix onto the release branch.”
revert /rɪˈvɜːrt/ hoàn tác bằng commit ngược “On a shared branch, revert is safer than reset.”
reflog /ˈriːflɑːɡ/ nhật ký di chuyển của ref “The reflog saved me after an accidental hard reset.”
trunk-based development /trʌŋk beɪst dɪˈveləpmənt/ phát triển trên nhánh chính “With trunk-based development, unfinished features hide behind flags.”
feature flag /ˈfiːtʃər flæɡ/ cờ bật/tắt tính năng “We merged the code behind a feature flag and enabled it gradually.”
regression /rɪˈɡreʃn/ lỗi hồi quy “I used git bisect to find the commit that introduced the regression.”

Ghi chép dựa trên khoá Fundamentals of Backend (Ronin Engineer), viết lại theo cách hiểu của mình.