@Controller('users')
export class UsersController {
  constructor(private usersService: UsersService) {}

  @Get()
  async findAll(): Promise<User[]> {
    return this.usersService.findAll();
  }
  
  @Post()
  @UseGuards(AuthGuard)
  async create(@Body() createUserDto: CreateUserDto): Promise<User> {
    return this.usersService.create(createUserDto);
  }
}

// NestJS中常見的多層抽象
@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const request = context.switchToHttp().getRequest();
    const method = request.method;
    const url = request.url;
    
    const now = Date.now();
    return next
      .handle()
      .pipe(
        tap(() => {
          console.log(`${method} ${url} ${Date.now() - now}ms`);
        }),
      );
  }
}

// 使用node-signpdf實作PDF簽名
const { plainAddPlaceholder } = require('node-signpdf');
const fs = require('fs');
const { SignPdf } = require('node-signpdf');

async function signPdfBatch(pdfFiles, certFile, certPassword) {
  const certBuffer = fs.readFileSync(certFile);
  const signer = new SignPdf();
  
  const results = [];
  for (const pdfPath of pdfFiles) {
    try {
      // 讀取PDF檔案
      let pdfBuffer = fs.readFileSync(pdfPath);
      
      // 新增簽名佔位符
      pdfBuffer = plainAddPlaceholder({
        pdfBuffer,
        reason: '自動批次簽名',
        contactInfo: 'support@example.com',
        location: 'Taiwan',
        signatureLength: 8192
      });
      
      // 執行簽名
      const signedPdf = signer.sign(pdfBuffer, certBuffer, {
        passphrase: certPassword,
      });
      
      // 儲存簽名後的檔案
      const outputPath = pdfPath.replace('.pdf', '_signed.pdf');
      fs.writeFileSync(outputPath, signedPdf);
      
      results.push({
        original: pdfPath,
        signed: outputPath,
        success: true
      });
    } catch (error) {
      results.push({
        original: pdfPath,
        error: error.message,
        success: false
      });
    }
  }
  
  return results;
}

# 不確定的語法
email_pattern = re.compile(r'???')

# AI協助後的正確語法
email_pattern = re.compile(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}')

// AI生成的訂單處理服務
@Service
public class OrderProcessingService {
    @Autowired
    private OrderRepository orderRepository;
    
    public OrderResponse processOrder(OrderRequest request) {
        Order order = new Order();
        order.setItems(request.getItems());
        order.setCustomerId(request.getCustomerId());
        order.setStatus("PROCESSING");
        orderRepository.save(order);
        
        // 處理付款邏輯
        processPayment(order);
        
        return new OrderResponse(order.getId(), "Order created successfully");
    }
    
    private void processPayment(Order order) {
        // 實作付款處理邏輯
        System.out.println("Processing payment for order: " + order.getId());
    }
}

# 建立安裝目錄
mkdir -p ~/riscv-toolchain
cd ~/riscv-toolchain

# 下載預編譯的RISC-V GCC工具鏈
wget https://github.com/xpack-dev-tools/riscv-none-elf-gcc-xpack/releases/download/v13.2.0-2/xpack-riscv-none-elf-gcc-13.2.0-2-linux-x64.tar.gz

# 解壓縮
tar xf xpack-riscv-none-elf-gcc-13.2.0-2-linux-x64.tar.gz

# 加入環境變數（建議加入到~/.bashrc或~/.zshrc）
echo 'export PATH=$PATH:~/riscv-toolchain/xpack-riscv-none-elf-gcc-13.2.0-2/bin' >> ~/.bashrc
source ~/.bashrc

# 驗證安裝
riscv-none-elf-gcc --version

# 安裝依賴
sudo apt install libusb-1.0-0-dev libtool autoconf automake texinfo pkg-config

# 克隆OpenOCD原始碼
git clone https://github.com/openocd-org/openocd.git
cd openocd

# 設定和編譯
./bootstrap
./configure --enable-ftdi --enable-jlink --enable-stlink --enable-riscv
make -j$(nproc)
sudo make install

# 驗證安裝
openocd --version

# 下載最新版Eclipse IDE for C/C++ Developers
wget https://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/2023-09/R/eclipse-cpp-2023-09-R-linux-gtk-x86_64.tar.gz -O eclipse.tar.gz

# 解壓縮
tar xf eclipse.tar.gz -C ~/

# 建立桌面捷徑
cat > ~/.local/share/applications/eclipse.desktop << EOF
[Desktop Entry]
Name=Eclipse
Type=Application
Exec=~/eclipse/eclipse
Icon=~/eclipse/icon.xpm
Comment=Eclipse IDE
Terminal=false
Categories=Development;IDE;
EOF

# 使捷徑生效
chmod +x ~/.local/share/applications/eclipse.desktop

# 克隆MIK32 SDK
git clone https://github.com/MIK32/mik32-sdk.git
cd mik32-sdk

# 建立構建目錄
mkdir build && cd build

# 設定CMake專案
cmake ..

# 構建
make

#include "mik32.h"
#include "mik32_gpio.h"
#include "mik32_systick.h"

// 簡單延遲函式
void delay_ms(uint32_t ms) {
    // 假設系統時鐘為48MHz
    uint32_t ticks = ms * 48000;
    for (uint32_t i = 0; i < ticks; i++) {
        __NOP(); // 空操作
    }
}

int main(void) {
    // 初始化系統
    SystemInit();
    
    // 設定GPIO
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0;  // 假設LED連線到GPIO0
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
    GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
    GPIO_Init(GPIO0, &GPIO_InitStruct);
    
    // 主迴圈
    while (1) {
        // 切換LED狀態
        GPIO_ToggleBits(GPIO0, GPIO_Pin_0);
        delay_ms(500);  // 延遲500毫秒
    }
}

// 進入低功耗模式範例
void enter_sleep_mode() {
    // 設定低功耗模式
    PM_SleepConfig sleep_config;
    sleep_config.mode = PM_SLEEP_MODE_DEEP;
    sleep_config.retain_memory = true;
    sleep_config.retain_gpio = true;
    
    // 設定喚醒源
    PM_WakeupConfig wakeup_config;
    wakeup_config.rtc_wakeup = true;
    wake

# 乾淨架構下的單體應用：技術選型與團隊衝突的啟示

在現代軟體開發的浪潮中，微服務架構常被視為擴充套件性與彈性的代名詞，而單體應用則時常被視為過時的遺物。然而，我在一次重要專案中的經驗告訴我，這種二分法過於簡化。我們選擇在單體應用中實施乾淨架構（Clean Architecture），這個決定不僅徹底改變了我們的開發效率，也意外地引發了團隊內部的衝突與價值觀的碰撞。

## 為何選擇單體應用搭配乾淨架構？

當我們開始規劃這個專案時，我們面臨著典型的架構選擇困境。微服務固然時髦與具備諸多優勢，但對於我們當時的團隊規模和專案需求來說，它可能會帶來不必要的複雜性。

在評估過各種方案後，我決定採用單體應用搭配乾淨架構的方式，主要根據以下考量：

### 業務複雜度與團隊現況

我們的產品具有複雜的業務邏輯，但初期使用者量並不足以支撐微服務架構的維護成本。此外，團隊成員對領域驅動設計（DDD）有一定理解，這與乾淨架構的理念高度契合。

「當時我們的團隊剛經歷過一次重組，」我回憶道，「大家對於微服務的熱情很高，但我認為我們需要先建立穩固的領域模型基礎，而乾淨架構正好提供了這個框架。」

### 開發速度與可維護性的平衡

乾淨架構的核心優勢在於它能夠將業務邏輯與技術實作分離，這意味著我們可以：

- 讓業務規則獨立於框架、資料函式庫I等外部元素
- 確保系統更容易測試，因為核心業務邏輯可以獨立測試
- 降低變更的風險，因為架構天然支援關注點分離

「我過去在一家金融科技公司工作時，親眼目睹了一個緊耦合的單體應用如何演變成一場維護噩夢，」我對團隊解釋，「乾淨架構能讓我們擁有單體應用的簡單性，同時保持程式碼的可維護性和可測試性。」

## 乾淨架構的實際實施

理論很美好，但實踐總是充滿挑戰。我們如何將乾淨架構的理念落實到實際的程式碼中？

### 核心架構設計

我們將系統分為四個主要層次，從內到外依次是：

1. **實體層（Entities）**：包含業務規則和領域模型
2. **使用案例層（Use Cases）**：包含應用特定的業務規則
3. **介面適配層（Interface Adapters）**：包含控制器、閘道和介面轉換器
4. **框架與驅動層（Frameworks & Drivers）**：包含框架、工具和外部系統

「最關鍵的是依賴關係的方向，」我強調，「所有依賴都指向核心層，外層依賴內層，而內層絕不依賴外層。這看似簡單，實際執行時卻需要團隊的紀律性。」

### 具體的程式碼組織

我們採用了以下的目錄結構來實作這種分層：

這種結構讓新加入的開發者能夠快速理解程式碼的組織方式，並明確知道新功能應該放在哪裡。

### 相依性注入的實作

為了確保依賴關係的正確方向，我們大量使用了相依性注入。這裡有一個簡化的例子：

```typescript
// 領域層中的實體
class User {
  constructor(
    public id: string,
    public name: string,
    public email: string
  ) {}
}

// 應用層中的介面（往往內依賴）
interface UserRepository {
  findById(id: string): Promise<User>;
  save(user: User): Promise<void>;
}

// 應用層中的使用案例
class CreateUserUseCase {
  constructor(private userRepository: UserRepository) {}

  async execute(name: string, email: string): Promise<User> {
    const user = new User(generateId(), name, email);
    await this.userRepository.save(user);
    return user;
  }
}

// 基礎設施層中的實作（往往外依賴）
class PostgresUserRepository implements UserRepository {
  async findById(id: string): Promise<User> {
    // 實際的資料函式庫邏輯
  }

  async save(user: User): Promise<void> {
    // 實際的資料函式庫邏輯
  }
}

# app/models/cat.py
from datetime import date
from typing import Optional, List

from sqlalchemy import Column, Integer, String, Date, ForeignKey
from sqlalchemy.orm import relationship, Mapped

from app.db.base import Base

class Cat(Base):
    __tablename__ = "cats"
    
    id: Mapped[int] = Column(Integer, primary_key=True, index=True)
    name: Mapped[str] = Column(String, index=True)
    breed: Mapped[str] = Column(String)
    birth_date: Mapped[date] = Column(Date)
    bio: Mapped[Optional[str]] = Column(String, nullable=True)
    
    # 關聯到貓咪的技能
    skills: Mapped[List["Skill"]] = relationship("Skill", back_populates="cat")
    
    # 關聯到工作經歷
    experiences: Mapped[List["Experience"]] = relationship("Experience", back_populates="cat")


class Skill(Base):
    __tablename__ = "skills"
    
    id: Mapped[int] = Column(Integer, primary_key=True, index=True)
    name: Mapped[str] = Column(String)
    proficiency: Mapped[int] = Column(Integer)  # 1-5 的技能熟練度
    cat_id: Mapped[int] = Column(Integer, ForeignKey("cats.id"))
    
    cat: Mapped["Cat"] = relationship("Cat", back_populates="skills")


class Experience(Base):
    __tablename__ = "experiences"
    
    id: Mapped[int] = Column(Integer, primary_key=True, index=True)
    title: Mapped[str] = Column(String)
    company: Mapped[str] = Column(String)
    start_date: Mapped[date] = Column(Date)
    end_date: Mapped[Optional[date]] = Column(Date, nullable=True)
    description: Mapped[Optional[str]] = Column(String, nullable=True)
    cat_id: Mapped[int] = Column(Integer, ForeignKey("cats.id"))
    
    cat: Mapped["Cat"] = relationship("Cat", back_populates="experiences")

# app/db/session.py
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker

from app.core.config import settings

# 建立非同步資料函式庫
engine = create_async_engine(
    settings.SQLALCHEMY_DATABASE_URI,
    echo=settings.DB_ECHO,
    future=True
)

# 建立非同步工作階段工廠
async_session_factory = sessionmaker(
    engine, class_=AsyncSession, expire_on_commit=False
)

# 取得資料函式庫階段的非同步連貫的背景與環境管理器
async def get_db_session():
    async with async_session_factory() as session:
        yield session

# app/db/deps.py
from typing import Annotated

from litestar.di import Provide
from sqlalchemy.ext.asyncio import AsyncSession

from app.db.session import get_db_session

# 定義可注入的資料函式庫階段
DBSession = Annotated[AsyncSession, Provide(get_db_session)]

alembic init migrations

# alembic.ini
sqlalchemy.url = postgresql+asyncpg://user:password@localhost/catsdb

# migrations/env.py
from logging.config import fileConfig

from sqlalchemy import engine_from_config, pool
from sqlalchemy.ext.asyncio import AsyncEngine

from alembic import context

# 匯入Base和所有模型
from app.db.base import Base
from app.models.cat import Cat, Skill, Experience

# this is the Alembic Config object
config = context.config

# ... (其餘程式碼保持不變)

def run_migrations_online():
    """Run migrations in 'online' mode."""
    connectable = AsyncEngine(
        engine_from_config(
            config.get_section(config.config_ini_section),
            prefix="sqlalchemy.",
            poolclass=pool.NullPool,
            future=True,
        )
    )

    async def do_migrations(connection):
        context.configure(
            connection=connection,
            target_metadata=Base.metadata,
            compare_type=True,
        )

        with context.begin_transaction():
            context.run_migrations()

    asyncio.run(connectable.connect(), do_migrations)

# 生成遷移指令碼
alembic revision --autogenerate -m "Create cat tables"

# 應用遷移
alembic upgrade head

# app/schemas/cat.py
from datetime import date
from typing import List, Optional

from pydantic import BaseModel, Field


class SkillBase(BaseModel):
    name: str
    proficiency: int = Field(..., ge=1, le=5)


class SkillCreate(SkillBase):
    pass


class Skill(SkillBase):
    id: int
    cat_id: int

    class Config:
        orm_mode = True


class ExperienceBase(BaseModel):
    title: str
    company: str
    start_date: date
    end_date: Optional[date] = None
    description: Optional[str] = None


class ExperienceCreate(ExperienceBase):
    pass


class Experience(ExperienceBase):
    id: int
    cat_id: int

    class Config:
        orm_mode = True


class CatBase(BaseModel):
    name: str
    breed: str
    birth_date: date
    bio: Optional[str] = None


class CatCreate(CatBase):
    skills: Optional[List[SkillCreate]] = []
    experiences: Optional[List[ExperienceCreate]] = []


class Cat(CatBase):
    id: int
    skills: List[Skill] = []
    experiences: List[Experience] = []

    class Config:
        orm_mode = True

# app/api/endpoints/cats.py
from typing import List

from litestar import Controller, get, post, put, delete
from litestar.exceptions import NotFoundException
from sqlalchemy import select
from sqlalchemy.orm import selectinload

from app.db.deps import DBSession
from app.models.cat import Cat as CatModel, Skill as SkillModel, Experience as ExperienceModel
from app.schemas.cat import Cat, CatCreate


class CatsController(Controller):
    path = "/cats"
    tags = ["cats"]
    
    @get("/", summary="Get all cats")
    async def get_cats(self, db: DBSession) -> List[Cat]:
        stmt = select(CatModel).options(
            selectinload(CatModel.skills),
            selectinload(CatModel.experiences)
        )
        result = await db.execute(stmt)
        cats = result.scalars().all()
        return [Cat.from_orm(cat) for cat in cats]
    
    @get("/{cat_id:int}", summary="Get a specific cat by ID")
    async def get_cat(self, cat_id: int, db: DBSession) -> Cat:
        stmt = select(CatModel).where(CatModel.id == cat_id).options(
            selectinload(CatModel.skills),
            selectinload(CatModel.experiences)
        )
        result = await db.execute(stmt)
        cat = result.scalars().first()
        
        if not cat:
            raise NotFoundException(f"Cat with ID {cat_id} not found")
            
        return Cat.from_orm(cat)
    
    @post("/", summary="Create a new cat")
    async def create_cat(self, data: CatCreate, db: DBSession) -> Cat:
        # 建立貓咪基本資訊
        cat = CatModel(
            name=data.name,
            breed=data.breed,
            birth_date=data.birth_date,
            bio=data.bio
        )
        
        # 建立技能
        for skill_data in data.skills:
            skill = SkillModel(
                name=skill_data.name,
                proficiency=skill_data.proficiency,
                cat=cat
            )
            cat.skills.append(skill)
            
        # 建立工作經歷
        for exp_data in data.experiences:
            experience = ExperienceModel(
                title=exp_data.title,
                company=exp_data.company,
                start_date=exp_data.start_date,
                end_date=exp_data.end_date,
                description=exp_data.description,
                cat=cat
            )
            cat.experiences.append(experience)
            
        db.add(cat)
        await db.commit()
        await db.refresh(cat)
        
        return Cat.from_orm(cat)
    
    @put("/{cat_id:int}", summary="Update a cat")
    async def update_cat(self, cat_id: int, data: CatCreate, db: DBSession) -> Cat:
        # 查詢貓咪
        stmt = select(CatModel).where(CatModel.id == cat_id).options(
            selectinload(CatModel.skills),
            selectinload(CatModel.experiences)
        )
        result = await db.execute(stmt)
        cat = result.scalars().first()
        
        if not cat:
            raise NotFoundException(f"Cat with ID {cat_id} not found")
            
        # 更新貓咪基本資訊
        cat.name = data.name
        cat.breed = data.breed
        cat.birth_date = data.birth_date
        cat.bio = data.bio
        
        # 更新技能（先刪除舊的，再建立新的）
        for skill in cat.skills:
            await db.delete(skill)
            
        cat.skills = []
        for skill_data in data.skills:
            skill = SkillModel(
                name=skill_data.name,
                proficiency=skill_data.proficiency,
                cat=cat
            )
            cat.skills.append(skill)
            
        # 更新工作經歷（先刪除舊的，再建立新的）
        for exp in cat.experiences:
            await db.delete(exp)
            
        cat.experiences = []
        for exp_data in data.experiences:
            experience = ExperienceModel(
                title=exp_data.title,
                company=exp_data.company,
                start_date=exp_data.start_date,
                end_date=exp_data.end_date,
                description=exp_data.description,
                cat=cat
            )
            cat.experiences.append(experience)
            
        await db.commit
資料的安全性與完整性是每個系統設計者必須面對的重要課題。在分散式系統中，一致性問題更是核心挑戰。CAP理論提出了分散式系統無法同時滿足一致性(Consistency)、可用性(Availability)和分割槽容忍性(Partition Tolerance)三者的著名論斷，這迫使我們在設計時必須做出權衡。

在這樣的背景下，BASE模型應運而生，它與ACID模型形成了鮮明的對比。ACID模型強調交易的嚴格一致性，而BASE則採取了更為務實的方針，接受系統在某些時刻可能處於不一致狀態，但最終將達成一致。

當我在設計大型電商平台的後端架構時，就曾面臨這樣的權衡。傳統關聯式資料函式庫CID特性無法滿足平台的高併發需求，而採用BASE思想的NoSQL解決方案則提供了更高的可擴充套件性，雖然犧牲了某些即時一致性保證。

## 理解BASE模型的本質

BASE模型代表三個核心概念：基本可用(Basically Available)、軟狀態(Soft State)和最終一致性(Eventually Consistent)。這種模型與傳統的ACID截然不同，它更傾向於在分散式環境中實作高用性和可擴充套件性。

### 基本可用性的實踐意義

基本可用並非意味著系統永不宕機，而是即使部分功能不可用，核心服務仍能持續運作。我曾參與的一個支付系統就採用了這種思路—當推薦系統暫時不可用時，使用者仍然可以完成支付流程，只是缺少了個人化推薦這個非核心功能。

這種設計理念要求我們區分系統的關鍵路徑與非關鍵路徑，並為關鍵路徑提供更高的可用性保障。實際工作中，我通常會將功能分為P0、P1和P2三個優先順序，確保P0級功能即使在極端情況下也能正常運作。

### 軟狀態：接受暫時的不一致

軟狀態允許系統中的資料存在短暫的不一致狀態，這與ACID強調的即時一致性形成了鮮明對比。在實際應用中，這意味著我們接受資料在短時間內可能不準確，但系統會在合理時間內自我修復。

以我曾經參與的一個社交平台為例，當使用者發布內容時，並不會立即更新所有關注者的時間線。系統會在後台非同步處理這些更新操作，最終確保所有使用者都能看到最新內容。這種設計極大提升了系統的併發處理能力。

### 最終一致性：平衡可用性與一致性

最終一致性是BASE模型的核心，它保證系統在沒有新更新的情況下，最終所有節點都會達到一致狀態。這種一致性不是即時的，而是在一段時間後才能實作。

在一個大型電商平台的函式庫統中，我們採用了最終一致性模型。當使用者下單時，系統會立即預扣函式庫允許訂單繼續處理，而實際的函式庫料更新則透過非同步訊息處理。這種設計在保證使用者經驗的同時，也維持了系統的高併發能力。

## ACID與BASE的深度對比

傳統的ACID模型和新興的BASE模型代表了兩種不同的系統設計哲學。理解它們的差異對於選擇合適的資料處理方案至關重要。

### ACID特性的嚴格保證

ACID模型強調交易的原子性(Atomicity)、一致性(Consistency)、隔離性(Isolation)和永續性(Durability)。這些特性確保了資料的嚴格一致性和可靠性。

在金融系統設計中，我一直堅持使用ACID模型。例如，在處理銀行轉帳操作時，必須確保資金從一個帳戶扣除並準確地新增到另一個帳戶，這個過程必須是原子的，不能有任何中間狀態被外部觀察到。

### BASE模型的彈性與權衡

相比之下，BASE模型更加靈活，它願意在某些情況下放棄即時一致性，以換取更高的可用性和分割槽容忍性。

在處理使用者評論系統時，我傾向於採用BASE模型。使用者提交評論後，系統會立即確認接收，但評論可能需要一段時間才會顯示在所有使用者的介面上。這種設計大幅提高了系統的回應速度和併發處理能力。

### 選擇適合業務場景的模型

選擇ACID還是BASE，關鍵在於業務需求。在我的實踐中，通常按照以下原則進行選擇：

- 對於金融交易、函式庫心操作等要求強一致性的場景，優先選擇ACID模型
- 對於社互動動、內容推薦等可以容忍短暫不一致的場景，傾向於採用BASE模型

我曾經在一個電商平台同時使用這兩種模型：訂單支付流程採用ACID確保交易安全，而商品評論和推薦系統則採用BASE以提供更好的使用者經驗。

## 實作BASE模型的技術策略

理解BASE模型的概念後，關鍵是如何在實際系統中實作它。以下是一些我在實踐中常用的技術策略。

### 非同步處理與訊息佇列

非同步處理是實作BASE模型的核心技術。透過將操作分解為同步和非同步兩部分，系統可以在保持高回應速度的同時，確保最終一致性。

在我設計的一個訂單系統中，訂單建立是同步處理的，但通知、函式庫新和物流處理則透過RabbitMQ訊息佇列非同步完成。這種設計顯著提高了系統的併發處理能力。

```java
// 同步部分：建立訂單
public OrderResponse createOrder(OrderRequest request) {
    // 1. 驗證訂單資訊
    validateOrderRequest(request);
    
    // 2. 建立訂單記錄
    Order order = orderRepository.save(new Order(request));
    
    // 3. 非同步處理後續操作
    messageSender.sendMessage("order-created", order.getId());
    
    return new OrderResponse(order.getId(), "訂單建立成功");
}

// 非同步處理：監聽訊息並處理後續操作
@MessageListener(destination = "order-created")
public void processOrder(String orderId) {
    // 1. 更新函式庫    inventoryService.updateInventory(orderId);
    
    // 2. 傳送通知
    notificationService.sendOrderConfirmation(orderId);
    
    // 3. 建立物流請求
    logisticsService.createShipmentRequest(orderId);
}

@Transactional
public Document updateDocument(Long id, DocumentUpdateRequest update, Long version) {
    Document document = documentRepository.findById(id)
        .orElseThrow(() -> new DocumentNotFoundException(id));
    
    // 版本檢查
    if (!document.getVersion().equals(version)) {
        throw new ConcurrentModificationException("檔案已被其他使用者修改");
    }
    
    // 更新檔案
    document.setContent(update.getContent());
    document.setTitle(update.getTitle());
    document.setVersion(document.getVersion() + 1);
    
    return documentRepository.save(document);
}

public class OrderSaga {
    
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private PaymentService paymentService;
    
    @Autowired
    private InventoryService inventoryService;
    
    public void createOrder(OrderRequest request) {
        // 步驟1：建立訂單
        Order order = orderService.createOrder(request);
        
        try {
            // 步驟2：預留函式庫            inventoryService.reserveInventory(order.getItems());
            
            try {
                // 步驟3：處理支付
                paymentService.processPayment(order.getId(), order.getTotalAmount());
            } catch (Exception e) {
                // 補償步驟2：釋放函式庫                inventoryService.releaseInventory(order.getItems());
                throw e;
            }
        } catch (Exception e) {
            // 補償步驟1：取消訂單
            orderService.cancelOrder(order.getId());
            throw e;
        }
    }
}

// 關鍵操作：使用majority寫關注
db.payments.insertOne(
  { user: "user123", amount: 500, status: "completed" },
  { writeConcern: { w: "majority", wtimeout: 5000 } }
)

// 非關鍵操作：使用1寫關注提高效能
db.userActivities.insertOne(
  { user: "user123", activity: "login", timestamp: new Date() },
  { writeConcern: { w: 1 } }
)