# 架构示例

## 目录
- [MVVM架构示例](#mvvm架构示例)
- [Clean Architecture示例](#clean-architecture示例)
- [组件化架构示例](#组件化架构示例)
- [其他架构示例](#其他架构示例)
- [架构对比](#架构对比)

---

## MVVM架构示例

### 项目结构

```
app/
├── data/
│   ├── model/          # 数据模型
│   ├── repository/     # 数据仓库
│   └── remote/        # 远程数据源
├── domain/
│   └── usecase/       # 用例
├── ui/
│   ├── activity/      # Activity
│   ├── fragment/       # Fragment
│   └── viewmodel/      # ViewModel
└── di/                 # 依赖注入
```

### ViewModel示例

```java
public class UserViewModel extends ViewModel {
    private MutableLiveData<User> user = new MutableLiveData<>();
    private MutableLiveData<String> error = new MutableLiveData<>();
    private UserRepository repository;
    
    public UserViewModel(UserRepository repository) {
        this.repository = repository;
    }
    
    public LiveData<User> getUser() {
        return user;
    }
    
    public LiveData<String> getError() {
        return error;
    }
    
    public void loadUser(int userId) {
        repository.getUser(userId, new Callback<User>() {
            @Override
            public void onSuccess(User user) {
                UserViewModel.this.user.postValue(user);
            }
            
            @Override
            public void onError(String error) {
                UserViewModel.this.error.postValue(error);
            }
        });
    }
}
```

### Repository示例

```java
public class UserRepository {
    private ApiService apiService;
    private UserDao userDao;
    
    public UserRepository(ApiService apiService, UserDao userDao) {
        this.apiService = apiService;
        this.userDao = userDao;
    }
    
    public void getUser(int userId, Callback<User> callback) {
        // 先检查本地缓存
        User localUser = userDao.getUserById(userId);
        if (localUser != null) {
            callback.onSuccess(localUser);
            return;
        }
        
        // 从网络加载
        apiService.getUser(userId).enqueue(new Callback<User>() {
            @Override
            public void onResponse(Call<User> call, Response<User> response) {
                if (response.isSuccessful()) {
                    User user = response.body();
                    userDao.insertUser(user);
                    callback.onSuccess(user);
                } else {
                    callback.onError("Network error");
                }
            }
            
            @Override
            public void onFailure(Call<User> call, Throwable t) {
                callback.onError(t.getMessage());
            }
        });
    }
}
```

### Activity示例

```java
public class MainActivity extends AppCompatActivity {
    private UserViewModel viewModel;
    private TextView nameTextView;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        // 创建ViewModel
        viewModel = ViewModelProviders.of(this).get(UserViewModel.class);
        
        // 观察数据
        viewModel.getUser().observe(this, new Observer<User>() {
            @Override
            public void onChanged(User user) {
                nameTextView.setText(user.getName());
            }
        });
        
        viewModel.getError().observe(this, new Observer<String>() {
            @Override
            public void onChanged(String error) {
                Toast.makeText(MainActivity.this, error, Toast.LENGTH_SHORT).show();
            }
        });
        
        // 加载数据
        viewModel.loadUser(1);
    }
}
```

---

## Clean Architecture示例

### 项目结构

```
app/
├── presentation/      # 表现层
│   ├── ui/
│   └── viewmodel/
├── domain/            # 领域层
│   ├── entity/
│   ├── usecase/
│   └── repository/
└── data/              # 数据层
    ├── repository/
    ├── datasource/
    └── model/
```

### Entity示例

```java
// 领域层实体
public class User {
    private int id;
    private String name;
    private String email;
    
    public User(int id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }
    
    // getters and setters
}
```

### UseCase示例

```java
public class GetUserUseCase {
    private UserRepository repository;
    
    public GetUserUseCase(UserRepository repository) {
        this.repository = repository;
    }
    
    public void execute(int userId, UseCaseCallback<User> callback) {
        repository.getUser(userId, callback);
    }
}

// 接口定义
public interface UseCaseCallback<T> {
    void onSuccess(T data);
    void onError(String error);
}
```

### Repository接口（领域层）

```java
// 领域层接口
public interface UserRepository {
    void getUser(int userId, UseCaseCallback<User> callback);
    void saveUser(User user, UseCaseCallback<Void> callback);
}
```

### Repository实现（数据层）

```java
// 数据层实现
public class UserRepositoryImpl implements UserRepository {
    private ApiService apiService;
    private UserDao userDao;
    
    public UserRepositoryImpl(ApiService apiService, UserDao userDao) {
        this.apiService = apiService;
        this.userDao = userDao;
    }
    
    @Override
    public void getUser(int userId, UseCaseCallback<User> callback) {
        // 实现逻辑
    }
}
```

### ViewModel示例

```java
public class UserViewModel extends ViewModel {
    private GetUserUseCase getUserUseCase;
    private MutableLiveData<User> user = new MutableLiveData<>();
    
    public UserViewModel(GetUserUseCase getUserUseCase) {
        this.getUserUseCase = getUserUseCase;
    }
    
    public void loadUser(int userId) {
        getUserUseCase.execute(userId, new UseCaseCallback<User>() {
            @Override
            public void onSuccess(User data) {
                user.postValue(data);
            }
            
            @Override
            public void onError(String error) {
                // 处理错误
            }
        });
    }
}
```

---

## 组件化架构示例

### 项目结构

```
project/
├── app/                    # 主应用模块
├── common/                 # 公共模块
│   ├── common_base/        # 基础库
│   ├── common_network/     # 网络库
│   ├── common_database/    # 数据库库
│   └── common_ui/          # UI组件库
├── feature_login/          # 登录组件
├── feature_home/           # 首页组件
├── feature_product/        # 商品组件
└── feature_user/           # 用户组件
```

### 组件间通信

#### 使用ARouter

```java
// 1. 在组件中定义路由
@Route(path = "/product/detail")
public class ProductDetailActivity extends AppCompatActivity {
    @Autowired
    String productId;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ARouter.getInstance().inject(this);
        // 使用productId
    }
}

// 2. 跳转到其他组件
ARouter.getInstance()
    .build("/product/detail")
    .withString("productId", "123")
    .navigation();
```

#### 使用接口通信

```java
// 1. 定义接口（common模块）
public interface ILoginService {
    void login(String username, String password, LoginCallback callback);
    boolean isLoggedIn();
}

// 2. 实现接口（feature_login模块）
public class LoginServiceImpl implements ILoginService {
    @Override
    public void login(String username, String password, LoginCallback callback) {
        // 登录逻辑
    }
}

// 3. 使用接口（其他组件）
ILoginService loginService = ServiceManager.getService(ILoginService.class);
loginService.login("user", "pass", callback);
```

### 组件独立运行

```java
// build.gradle (feature_login)
android {
    // 开发时可以独立运行
    if (isModule.toBoolean()) {
        // 组件模式
        apply plugin: 'com.android.library'
    } else {
        // 应用模式
        apply plugin: 'com.android.application'
    }
}

// 在gradle.properties中配置
isModule=true  // 组件模式
// isModule=false  // 应用模式
```

---

## 其他架构示例

### MVP架构示例

```java
// Model
public class UserModel {
    public void getUser(int id, Callback<User> callback) {
        // 获取用户数据
    }
}

// View接口
public interface UserView {
    void showUser(User user);
    void showError(String error);
}

// Presenter
public class UserPresenter {
    private UserView view;
    private UserModel model;
    
    public UserPresenter(UserView view) {
        this.view = view;
        this.model = new UserModel();
    }
    
    public void loadUser(int userId) {
        model.getUser(userId, new Callback<User>() {
            @Override
            public void onSuccess(User user) {
                view.showUser(user);
            }
            
            @Override
            public void onError(String error) {
                view.showError(error);
            }
        });
    }
}

// Activity实现View
public class MainActivity extends AppCompatActivity implements UserView {
    private UserPresenter presenter;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        presenter = new UserPresenter(this);
        presenter.loadUser(1);
    }
    
    @Override
    public void showUser(User user) {
        // 显示用户信息
    }
    
    @Override
    public void showError(String error) {
        Toast.makeText(this, error, Toast.LENGTH_SHORT).show();
    }
}
```

### MVI架构示例

```java
// State
public class UserState {
    public static class Loading extends UserState {}
    public static class Success extends UserState {
        private User user;
        public Success(User user) { this.user = user; }
    }
    public static class Error extends UserState {
        private String message;
        public Error(String message) { this.message = message; }
    }
}

// Intent
public class UserIntent {
    public static class LoadUser extends UserIntent {
        private int userId;
        public LoadUser(int userId) { this.userId = userId; }
    }
}

// ViewModel
public class UserViewModel extends ViewModel {
    private MutableLiveData<UserState> state = new MutableLiveData<>();
    private UserRepository repository;
    
    public LiveData<UserState> getState() {
        return state;
    }
    
    public void processIntent(UserIntent intent) {
        if (intent instanceof UserIntent.LoadUser) {
            loadUser(((UserIntent.LoadUser) intent).userId);
        }
    }
    
    private void loadUser(int userId) {
        state.setValue(new UserState.Loading());
        repository.getUser(userId, new Callback<User>() {
            @Override
            public void onSuccess(User user) {
                state.setValue(new UserState.Success(user));
            }
            
            @Override
            public void onError(String error) {
                state.setValue(new UserState.Error(error));
            }
        });
    }
}
```

---

## 架构对比

### 架构模式对比

| 特性 | MVC | MVP | MVVM | Clean Architecture |
|------|-----|-----|------|-------------------|
| View和Model耦合 | 耦合 | 解耦 | 解耦 | 完全解耦 |
| 测试性 | 差 | 好 | 好 | 优秀 |
| 代码量 | 少 | 中 | 中 | 多 |
| 学习曲线 | 平缓 | 中等 | 中等 | 陡峭 |
| 适用场景 | 小型项目 | 中大型项目 | 中大型项目 | 大型项目 |

### 选择建议

```java
// 小型项目（1-2人，功能简单）
// 推荐：MVC 或 MVP

// 中大型项目（3-10人，功能复杂）
// 推荐：MVVM 或 MVP

// 大型项目（10+人，多团队协作）
// 推荐：MVVM + 组件化 或 Clean Architecture

// 需要高度测试性
// 推荐：Clean Architecture
```

---

## 架构最佳实践

### 1. 分层清晰

```java
// ✅ 好的做法：清晰的分层
presentation/
domain/
data/

// ❌ 不好的做法：层次混乱
// 业务逻辑和UI混在一起
```

### 2. 依赖方向

```java
// ✅ 好的做法：依赖向内
presentation → domain ← data

// ❌ 不好的做法：循环依赖
presentation ↔ data
```

### 3. 接口隔离

```java
// ✅ 好的做法：使用接口
public interface UserRepository {
    void getUser(int id, Callback<User> callback);
}

// ❌ 不好的做法：直接依赖实现
public class UserViewModel {
    private UserRepositoryImpl repository; // 直接依赖实现
}
```

### 4. 单一职责

```java
// ✅ 好的做法：每个类职责单一
public class UserRepository {
    // 只负责数据获取
}

// ❌ 不好的做法：一个类做太多事情
public class UserManager {
    // 获取数据、处理业务、更新UI
}
```

---

## 总结

选择合适的架构模式对项目成功至关重要。建议根据项目规模、团队能力、业务复杂度等因素综合考虑，选择最适合的架构模式。

---

*最后更新：2024年*
