Android第十四次面试总结

OkHttp中获取数据与操作数据

 一、数据获取核心机制

1. ​同步请求(阻塞式)​
// 1. 创建HTTP客户端(全局应复用实例)
OkHttpClient client = new OkHttpClient();

// 2. 构建请求对象(GET示例)
Request request = new Request.Builder()
    .url("https://api.example.com/data")  // 必填目标URL
    .header("User-Agent", "MyApp/1.0")    // 添加自定义请求头
    .get()                                // 明确指定GET方法
    .build();

// 3. 执行同步请求(阻塞当前线程)
try (Response response = client.newCall(request).execute()) {
    // 4. 验证响应状态码 (200-299范围表示成功)
    if (response.isSuccessful()) {
        // 5. 提取响应体数据(string()只能调用一次)
        String rawData = response.body().string();
        
        // 6. 数据处理逻辑
        processData(rawData);
    } else {
        // 处理服务器错误(如404, 500等)
        System.err.println("请求失败:" + response.code());
    }
} catch (IOException e) {
    // 7. 处理网络错误(超时、DNS解析失败等)
    e.printStackTrace();
}

关键点说明​:

  • execute():同步调用会阻塞当前线程
  • 使用场景​:后台任务(日志上报、文件下载)
  • 注意事项​:
    • 响应体.string()只能调用一次(后续调用返回空)
    • 必须使用try-with-resources确保资源释放
    • Android需在子线程执行
2. ​异步请求(非阻塞)​
// 构建请求(同同步示例)
Request request = ...; 

// 发起异步请求
client.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        // 1. 网络层失败处理(如无网络、超时)
        Log.e("Network", "请求失败: " + e.getMessage());
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        // 2. 注意:此回调在异步线程执行!
        try {
            if (response.isSuccessful()) {
                // 3. 获取原始响应数据
                String responseData = response.body().string();
                
                // 4. 切回主线程处理数据(UI操作必须主线程)
                runOnUiThread(() -> {
                    updateUI(responseData);  // 更新UI组件
                    saveToLocal(responseData); // 数据持久化
                });
            } else {
                // 5. 处理业务错误(如400 Bad Request)
                Log.w("API", "业务错误:" + response.code());
            }
        } finally {
            // 6. 确保关闭响应资源(防止内存泄漏)
            response.close();
        }
    }
});

// Android线程切换工具方法
private void runOnUiThread(Runnable action) {
    new Handler(Looper.getMainLooper()).post(action);
}

核心优势​:

  • 非阻塞调用:避免主线程卡顿
  • 自动线程切换:网络IO在工作线程执行
  • 生命周期安全:支持请求取消(call.cancel()

 二、数据操作深度解析

1. JSON数据解析

场景:解析用户数据接口响应

{
  "user": {
    "id": 123,
    "name": "张伟",
    "email": "zhangwei@example.com",
    "created_at": "2023-08-15T10:30:00Z"
  }
}

方案1:原生JSONObject解析(适合简单结构)​

String json = response.body().string();

try {
    JSONObject root = new JSONObject(json);
    JSONObject user = root.getJSONObject("user");
    
    int id = user.getInt("id");
    String name = user.getString("name");
    String email = user.getString("email");
    
    // 日期字符串转换
    String dateStr = user.getString("created_at");
    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.US);
    Date createDate = format.parse(dateStr);
    
    // 构建业务对象
    User userObj = new User(id, name, email, createDate);
} catch (JSONException | ParseException e) {
    // 处理格式错误或字段缺失
}

方案2:Gson自动映射(推荐复杂结构)​

// 实体类定义
public class User {
    private int id;
    private String name;
    private String email;
    
    @SerializedName("created_at") // 自定义字段映射
    private Date createDate;

    // Getters & Setters
}

// 解析操作
Gson gson = new GsonBuilder()
    .registerTypeAdapter(Date.class, new DateDeserializer()) // 自定义日期解析
    .create();

// 直接映射JSON到Java对象
User user = gson.fromJson(json, User.class);

Gson日期转换器示例​:

class DateDeserializer implements JsonDeserializer<Date> {
    private final DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.US);

    @Override
    public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) 
        throws JsonParseException {
        try {
            return dateFormat.parse(json.getAsString());
        } catch (ParseException e) {
            throw new JsonParseException("日期格式错误", e);
        }
    }
}
2. XML数据解析

场景:解析RSS订阅源

<rss>
  <channel>
    <item>
      <title>OkHttp 4.9发布</title>
      <link>https://example.com/news/123</link>
      <pubDate>Wed, 15 Aug 2023 08:00:00 GMT</pubDate>
    </item>
  </channel>
</rss>

Pull解析实现​:

XmlPullParser parser = Xml.newPullParser();
parser.setInput(new StringReader(xmlData));

List<NewsItem> newsList = new ArrayList<>();
NewsItem currentItem = null;

int eventType = parser.getEventType();
while (eventType != XmlPullParser.END_DOCUMENT) {
    switch (eventType) {
        case XmlPullParser.START_TAG:
            String tagName = parser.getName();
            if ("item".equals(tagName)) {
                currentItem = new NewsItem();
            } else if (currentItem != null) {
                // 提取标签内文本
                if ("title".equals(tagName)) {
                    currentItem.setTitle(parser.nextText());
                } else if ("link".equals(tagName)) {
                    currentItem.setLink(parser.nextText());
                } else if ("pubDate".equals(tagName)) {
                    currentItem.setPublishDate(parseRssDate(parser.nextText()));
                }
            }
            break;
            
        case XmlPullParser.END_TAG:
            if ("item".equals(parser.getName())) {
                newsList.add(currentItem);
                currentItem = null;
            }
            break;
    }
    eventType = parser.next();
}
3. 数据加工处理

类型安全转换​:

// 带错误恢复的类型转换
public int safeParseInt(String value, int defaultValue) {
    try {
        return Integer.parseInt(value);
    } catch (NumberFormatException e) {
        logError("数字格式错误: " + value);
        return defaultValue;
    }
}

数据过滤(Java Stream API)​​:

List<User> users = getUsersFromResponse();

// 筛选VIP用户并提取邮箱列表
List<String> vipEmails = users.stream()
    .filter(u -> u.getLevel() >= 3)   // VIP等级条件
    .map(User::getEmail)              // 提取邮箱字段
    .filter(email -> email.contains("@")) // 邮箱有效性检查
    .collect(Collectors.toList());

响应缓存处理​:

// 创建带缓存的客户端
File cacheDir = new File(getCacheDir(), "okhttp_cache");
long cacheSize = 50 * 1024 * 1024; // 50MB

OkHttpClient client = new OkHttpClient.Builder()
    .cache(new Cache(cacheDir, cacheSize))
    .addNetworkInterceptor(new CacheControlInterceptor()) // 缓存控制
    .build();

// 自定义缓存策略拦截器
static class CacheControlInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Response original = chain.proceed(chain.request());
        return original.newBuilder()
            .header("Cache-Control", "public, max-age=" + 3600) // 缓存1小时
            .build();
    }
}

场景设计 

使用 ​Retrofit + OkHttp​ 获取小说数据是 Android 开发中处理网络请求的标准实践。以下从基础配置 -> 请求定义 -> 数据解析 -> 异常处理 -> 高级特性逐步详解,并提供完整代码示例​:


 一、核心步骤拆解

 ​添加依赖 (Gradle)​

// Retrofit 核心库 + OkHttp
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0' // Gson 转换器
implementation 'com.squareup.okhttp3:okhttp:4.11.0' // OkHttp 核心
implementation 'com.squareup.okhttp3:logging-interceptor:4.11.0' // 网络请求日志拦截器(调试用)

 ​创建 OkHttpClient(配置网络层)​

val okHttpClient = OkHttpClient.Builder()
    .addInterceptor(HttpLoggingInterceptor().apply {
        level = if (BuildConfig.DEBUG) HttpLoggingInterceptor.Level.BODY else HttpLoggingInterceptor.Level.NONE // 调试时打印完整请求日志
    })
    .addInterceptor { chain -> // 通用Header拦截器(如添加Token)
        val request = chain.request().newBuilder()
            .addHeader("Authorization", "Bearer $yourToken") 
            .addHeader("Accept", "application/json")
            .build()
        chain.proceed(request)
    }
    .connectTimeout(15, TimeUnit.SECONDS) // 连接超时
    .readTimeout(20, TimeUnit.SECONDS)    // 读取超时
    .build()

 ​创建 Retrofit 实例(配置API接口)​

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.your-novel-platform.com/") // 替换为小说平台API基地址
    .client(okHttpClient) // 绑定配置好的OkHttpClient
    .addConverterFactory(GsonConverterFactory.create()) // 指定Gson解析
    .build()

 ​定义 API 接口(核心!)​

interface NovelApiService {
    // 示例1:获取小说列表 (带分页)
    @GET("v1/novels")
    suspend fun getNovelList(
        @Query("page") page: Int = 1,
        @Query("size") size: Int = 20
    ): Response<NovelListResponse> // 封装了状态码和数据的响应体

    // 示例2:获取小说详情(路径参数)
    @GET("v1/novels/{novelId}")
    suspend fun getNovelDetail(
        @Path("novelId") novelId: String
    ): Response<NovelDetail>

    // 示例3:搜索小说(Body参数用POST更安全)
    @POST("v1/novels/search")
    suspend fun searchNovels(
        @Body request: SearchRequest // 包含关键词的RequestBody
    ): Response<List<Novel>>
}

 ​创建数据模型类(与API响应匹配)​

// 小说列表响应 (嵌套结构示例)
data class NovelListResponse(
    val code: Int, // 状态码 (0=成功)
    val message: String,
    val data: NovelListData 
)

data class NovelListData(
    val total: Int, 
    val list: List<NovelItem> 
)

data class NovelItem(
    val id: String,
    val title: String,
    val author: String,
    val coverUrl: String, 
    val description: String,
    val readCount: Long
)

// 小说详情模型
data class NovelDetail(
    val id: String,
    val title: String,
    val chapters: List<Chapter>, // 章节列表
    val category: String,
    val tags: List<String> 
)

// 章节数据模型
data class Chapter(
    val chapterId: String,
    val title: String,
    val content: String? // 注意:内容通常由另一个接口单独获取
)

 ​在 ViewModel/Repository 中发起请求

class NovelRepository(private val novelApi: NovelApiService) {

    // 获取小说列表(协程方式)
    suspend fun loadNovels(page: Int): Resource<NovelListData> { // Resource为自定义结果封装
        return try {
            val response = novelApi.getNovelList(page)
            if (response.isSuccessful && response.body()?.code == 0) {
                Resource.Success(response.body()!!.data)
            } else {
                Resource.Error(response.message() ?: "未知错误")
            }
        } catch (e: Exception) {
            Resource.Error(e.message ?: "网络异常")
        }
    }

    // 获取小说详情
    suspend fun loadNovelDetail(novelId: String): NovelDetail? {
        return try {
            val response = novelApi.getNovelDetail(novelId)
            if (response.isSuccessful) response.body() else null
        } catch (e: Exception) {
            null
        }
    }
}

 二、关键技术与原理

1. ​动态 URL 处理

  • @Path("novelId") → 替换路径中的变量 {novelId}

  • @Query("page") → 添加查询参数 ?page=1&size=20

  • @Body → 传递复杂的 JSON 对象(适合 POST/PUT)

2. ​线程调度与协程

  • Retrofit ​原生支持协程​(suspend 函数)

  • 无需手动切换线程:网络请求在 IO 线程执行,结果自动回调到主线程

3. ​响应处理模式

// 推荐方式:检查响应状态码 + body 业务状态码
if (response.isSuccessful && response.body()?.code == 0) {
    // 成功处理数据
} else {
    // 处理服务器返回的业务错误(如:code=40001 表示登录失效)
}

4. ​全局异常捕获

try {
    // 发起请求...
} catch (e: IOException) {
    // 网络层异常(超时、断网、域名解析失败)
} catch (e: HttpException) {
    // HTTP 状态码非200 (404, 500...)
    val errorJson = e.response()?.errorBody()?.string() // 获取错误body
}

 三、高级实战技巧

拦截器进阶用途

拦截器类型

作用场景

Token 刷新拦截器

当请求返回 401 Unauthorized 时,自动刷新 Token 并重试请求

重试拦截器

对特定错误(如超时)自动重试请求

公共参数拦截器

动态添加设备信息、版本号到 URL 或 Header 中

Stetho 调试拦截器

结合 Facebook Stetho 在 Chrome 中实时查看网络请求

 自定义 Gson 解析规则

val gson = GsonBuilder()
    .setDateFormat("yyyy-MM-dd HH:mm:ss") // 统一日期格式
    .registerTypeAdapter(String::class.java, StringSafeAdapter()) // 避免空字符串引起崩溃
    .create()

val retrofit = Retrofit.Builder()
    .addConverterFactory(GsonConverterFactory.create(gson)) // 传入定制Gson

 文件下载(获取小说封面/章节内容)

@Streaming // 关键注解:大文件下载需流式处理
@GET
suspend fun downloadFile(
    @Url fileUrl: String // 动态传入小说图片URL
): Response<ResponseBody> // 直接返回二进制流

// 使用示例:
val response = api.downloadFile(imageUrl)
response.body()?.let { body ->
    val file = File(cacheDir, "cover.jpg")
    body.byteStream().use { input ->
        FileOutputStream(file).use { output ->
            input.copyTo(output) // 写入本地文件
        }
    }
}

 完整调用流程(ViewModel 示例)

class NovelViewModel : ViewModel() {
    private val repository = NovelRepository(retrofit.create(NovelApiService::class.java))
    val novelList = MutableStateFlow<Resource<NovelListData>>(Resource.Loading)
    
    fun loadNovels(page: Int) {
        viewModelScope.launch {
            novelList.value = Resource.Loading
            novelList.value = repository.loadNovels(page)
        }
    }
}

Handler替代方案 

一、核心替代场景对比 

功能Handler 实现协程替代方案LiveData 替代方案
延时操作postDelayed()delay()无需直接替代
主线程切换post(Runnable)withContext(Dispatchers.Main)postValue() / setValue()
定时任务sendMessageDelayed()whileActive + delay()MutableLiveData + ViewModel
资源安全释放手动移除回调结构化并发自动取消自动生命周期感知
数据传递Message.obj协程返回值 / ChannelLiveData 观察模式

 二、Kotlin 协程替代方案详解

1. 主线程切换 (替代 post())

Handler 实现:​

handler.post(() -> {
    // 在主线程执行
    textView.setText("Updated");
});

协程替代方案:​

// 在任何协程上下文中
lifecycleScope.launch(Dispatchers.Default) {
    // 后台操作
    val result = fetchData()
    
    // 切换到主线程(替代Handler.post())
    withContext(Dispatchers.Main) {
        textView.text = result
        button.isEnabled = true
    }
}

优势:​

  • 顺序编程模型,避免回调嵌套
  • 自动处理线程池资源
  • 与生命周期自动绑定
2. 延时操作 (替代 postDelayed())

Handler 实现:​

handler.postDelayed(() -> {
    showNotification();
}, 3000);

协程替代方案:​

lifecycleScope.launch {
    // 非阻塞延迟 (不会占用线程资源)
    delay(3000)
    
    // 自动在主线程执行
    showNotification()
}

高级延时场景 - 定时轮询:​

private var pollingJob: Job? = null

fun startPolling() {
    pollingJob = lifecycleScope.launch {
        while (isActive) { // 结构化并发感知取消
            fetchUpdates()
            delay(60_000) // 每分钟执行一次
        }
    }
}

fun stopPolling() {
    pollingJob?.cancel() // 取消定时任务(替代removeCallbacks())
}
3. 复杂任务管理 (替代多个 Runnable)

传统 Handler 问题:​

Handler handler = new Handler();

handler.post(task1);
handler.post(task2);
handler.postDelayed(task3, 1000);

协程结构化并发:​

lifecycleScope.launch {
    // 同时发起多个任务
    val deferred1 = async { loadUserProfile() }
    val deferred2 = async { loadUserOrders() }
    
    // 等待所有任务完成
    val (profile, orders) = awaitAll(deferred1, deferred2)
    
    // 处理结果(自动在主线程)
    updateUI(profile, orders)
    
    // 顺序执行多个任务
    withContext(Dispatchers.IO) {
        saveToLocal(profile)
        uploadAnalytics(orders)
    }
}

三、LiveData 替代方案详解

1. 主线程数据更新 (替代 Handler 的 UI 更新)

Handler 实现:​

// 后台线程
new Thread(() -> {
    String data = getData();
    handler.post(() -> textView.setText(data));
}).start();

LiveData 替代方案:​

// ViewModel中
class MyViewModel : ViewModel() {
    private val _uiData = MutableLiveData<String>()
    val uiData: LiveData<String> = _uiData
    
    fun loadData() {
        viewModelScope.launch(Dispatchers.IO) {
            val result = repository.fetchData()
            _uiData.postValue(result) // 自动切换到主线程
        }
    }
}

// Activity中
viewModel.uiData.observe(this) { data ->
    textView.text = data // 已在主线程
}
2. 生命周期感知 (替代手动回调移除)

传统 Handler 的问题:​

// 可能泄漏Activity
handler.postDelayed(() -> {
    if (getActivity() != null) {
        updateUI(); // 危险!可能访问已销毁的Activity
    }
}, 10000);

LiveData 解决方案:​

class SafeViewModel : ViewModel() {
    private val _data = MutableLiveData<String>()
    val data: LiveData<String> = _data
    
    init {
        viewModelScope.launch {
            while (true) {
                delay(10000)
                val newData = fetchPeriodicData()
                _data.postValue(newData)
            }
        }
    }
}

// Activity中 - 自动处理生命周期
viewModel.data.observe(this) { data ->
    // 只有Activity处于活跃状态时才会触发
    updateUI(data)
}
3. 事件总线替代方案 (单次事件处理)

传统 Handler 广播问题:​

// 多个Handler处理同一消息
handler.sendMessage(Message.obtain().apply {
    what = MSG_UPDATE
    obj = data
});

LiveData 事件总线:​

// 单次事件包装器
class SingleLiveEvent<T> : MutableLiveData<T>() {
    private val pending = AtomicBoolean(false)

    override fun observe(owner: LifecycleOwner, observer: Observer<in T>) {
        super.observe(owner) { t ->
            if (pending.compareAndSet(true, false)) {
                observer.onChanged(t)
            }
        }
    }

    override fun setValue(t: T?) {
        pending.set(true)
        super.setValue(t)
    }
}

// ViewModel中使用
class EventViewModel : ViewModel() {
    private val _networkEvent = SingleLiveEvent<String>()
    val networkEvent: LiveData<String> = _networkEvent
    
    fun triggerEvent() {
        _networkEvent.value = "Event occurred at ${System.currentTimeMillis()}"
    }
}

MVVM 与 MVC 数据传输流向终极总结

 MVC 数据流向

单向环形闭环
用户操作 → View → Controller → Model → Controller → View更新

  • 核心特征​:Controller 作为中枢手动协调一切
  • 致命缺陷​:View 与 Model 隐性耦合,Controller 臃肿
  • Android 现状​:已被 Google 官方废弃

 MVVM 数据流向

双向自动通道
用户操作 → View → ViewModel ↔ Model
Model变更 → ViewModel → 自动 → View更新

  • 革命性突破​:
    • 数据绑定实现自动同步
    • ViewModel 完全解耦视图
    • 单向数据流确保可预测性
  • Android 未来​:
    Jetpack 官方架构(ViewModel + LiveData/Flow)

 本质区别

MVCMVVM
驱动力用户操作驱动数据变更驱动
更新方式手动命令式更新自动声明式更新
测试性需模拟视图独立测试业务逻辑
代码量冗余胶水代码多简洁易维护
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值