/* 文件路径: DataPreserver/Data
.java */
package com
.example
.kucun2
.DataPreserver;
// 文件路径: kucun2/entity/data/Data
.java
import android
.content
.Context;
import com
.example
.kucun2
.entity
.*;
import com
.example
.kucun2
.entity
.data
.SynchronizedList;
import com
.example
.kucun2
.function
.MyAppFnction;
/**
* 数据门面类 - 提供统一接口，协调各组件
*/
public
class Data {
private static final Data instance = new Data();
private final DataStore dataStore = new DataStore();
private final DataLoader dataLoader;
private final DataAssociator dataAssociator;
private final DataPreserver dataPreserver;
private final DataExporter dataExporter;
// 使用静态初始化保证线程安全
static {
// 初始化各组件
instance
.dataPreserver
.ensurePreservedObjects();
}
private Data() {
// 创建依赖关系
dataPreserver = new DataPreserver(dataStore);
dataAssociator = new DataAssociator(dataStore);
dataExporter = new DataExporter(dataStore);
// 使用MyAppFnction中的安全客户端
dataLoader = new DataLoader(
dataStore,
dataAssociator,
dataPreserver,
MyAppFnction
.getClient()
);
}
// ====================== 静态访问器 ======================
public static SynchronizedList<Bancai> bancais() {
return instance
.dataStore
.bancais;
}
public static SynchronizedList<Caizhi> caizhis() {
return instance
.dataStore
.caizhis;
}
// 其他实体列表的访问方法
...
public static void loadAllData(Context context, DataLoader
.LoadDataCallback callback) {
instance
.dataLoader
.loadAllData(context, callback);
}
public static String exportToJson() {
return instance
.dataExporter
.exportToJson();
}
public static void importFromJson(String json, Context context) {
instance
.dataExporter
.importFromJson(json, context);
}
public static void loadFromPreferences(Context context) {
instance
.dataExporter
.loadFromPreferences(context);
}
// 其他方法
...
}
================================================================================
/* 文件路径: DataPreserver/DataAssociator
.java */
package com
.example
.kucun2
.DataPreserver;
import android
.util.Log;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
import com
.example
.kucun2
.entity
.data
.SynchronizedList;
import
java.lang.reflect
.Field;
import
java.lang.reflect
.ParameterizedType;
import
java.lang.reflect
.Type;
import
java.util.ArrayList;
import
java.util.Collections;
import
java.util.Date;
import
java.util.List;
import
java.util.Map;
/**
* 实体关联器 - 负责建立实体间关联关系
*/
public
class DataAssociator {
private static final String TAG = "DataAssociator";
private final DataStore dataStore;
public DataAssociator(DataStore dataStore) {
this
.dataStore = dataStore;
}
/**
* 自动建立实体间关联关系
*/
public void automaticAssociation() {
for (
Class<?> entity
Class : dataStore
.dataCollection
Map.keySet()) {
try {
associateEntities(dataStore
.dataCollection
Map.get(entity
Class));
} catch (Exception e) {
Log
.e(TAG, entity
Class.getSimpleName() + " 关联失败", e);
}
}
}
private void associateEntities(
SynchronizedList<SynchronizableEntity> list
) throws Exception {
for (SynchronizableEntity entity : list) {
if (entity == null) continue;
for (Field field : entity
.get
Class()
.getDeclaredFields()) {
field
.setAccessible(true);
Class<?> fieldType = field
.getType();
if (SynchronizableEntity
.class.isAssignableFrom(fieldType)) {
associateSingleReference(entity, field);
} else if (List
.class.isAssignableFrom(fieldType)) {
associateReferenceList(entity, field);
} else {
setDefaultPrimitiveValue(entity, field);
}
}
}
}
private void associateSingleReference(
SynchronizableEntity entity,
Field field
) throws Exception {
SynchronizableEntity ref = (SynchronizableEntity) field
.get(entity);
Class<?> targetType = field
.getType();
SynchronizableEntity target =
findTargetEntity(ref, targetType);
field
.set(entity, target);
}
private void associateReferenceList(
SynchronizableEntity entity,
Field field
) throws Exception {
Type genericType = field
.getGenericType();
if (!(genericType instanceof ParameterizedType)) return;
Class<?> itemType =
Class.forName(
((ParameterizedType) genericType)
.getActualTypeArguments()[0]
.getTypeName()
);
if (!SynchronizableEntity
.class.isAssignableFrom(itemType)) return;
List<SynchronizableEntity> refList = (List<SynchronizableEntity>) field
.get(entity);
if (refList == null) {
refList = new ArrayList<>();
field
.set(entity, refList);
}
refList
.removeAll(Collections
.singleton(null));
for (int i = 0; i < refList
.size(); i++) {
refList
.set(i,
findTargetEntity(refList
.get(i), itemType));
}
}
private SynchronizableEntity
findTargetEntity(
SynchronizableEntity ref,
Class<?> targetType) {
SynchronizedList<SynchronizableEntity> targetList = dataStore
.dataCollection
Map.get(targetType);
if (targetList == null) return null;
if (ref == null || ref
.getId() == null || ref
.getId() < 0) {
return targetList
.stream()
.filter(SynchronizableEntity::isPreservedObject)
.findFirst()
.orElse(null);
}
return targetList
.stream()
.filter(e -> ref
.getId()
.equals(e
.getId()))
.findFirst()
.orElseGet(() -> targetList
.stream()
.filter(SynchronizableEntity::isPreservedObject)
.findFirst()
.orElse(null)
);
}
private void setDefaultPrimitiveValue(
SynchronizableEntity entity,
Field field) throws Exception {
if (field
.get(entity) != null) return;
Class<?> type = field
.getType();
if (type == String
.class) field
.set(entity, "无");
else if (type == Integer
.class || type == int
.class) field
.set(entity, -1);
else if (type ==
Double.class || type ==
double.class) field
.set(entity, -1
.0);
else if (type == Boolean
.class || type == boolean
.class) field
.set(entity, false);
else if (type == Date
.class) field
.set(entity, new Date());
}
}
================================================================================
/* 文件路径: DataPreserver/DataExporter
.java */
// 文件路径: kucun2/entity/data/DataExporter
.java
package com
.example
.kucun2
.DataPreserver;
import android
.content
.Context;
import android
.content
.SharedPreferences;
import android
.util.Log;
import com
.example
.kucun2
.entity
.*;
import com
.example
.kucun2
.entity
.RefTo;
import com
.example
.kucun2
.entity
.RefType;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
import com
.google
.gson
.Gson;
import com
.google
.gson
.GsonBuilder;
import com
.google
.gson
.JsonArray;
import com
.google
.gson
.JsonDeserializationContext;
import com
.google
.gson
.JsonDeserializer;
import com
.google
.gson
.JsonElement;
import com
.google
.gson
.JsonNull;
import com
.google
.gson
.JsonObject;
import com
.google
.gson
.JsonParseException;
import com
.google
.gson
.JsonSerializationContext;
import com
.google
.gson
.JsonSerializer;
import com
.google
.gson
.reflect
.TypeToken;
import
java.lang.reflect
.Field;
import
java.lang.reflect
.ParameterizedType;
import
java.lang.reflect
.Type;
import
java.util.ArrayList;
import
java.util.Hash
Map;
import
java.util.List;
import
java.util.Map;
/**
* 数据导入导出器 - 负责数据的持久化和恢复
*
* 主要功能：
* 1
. 将内存中的数据导出为JSON格式
* 2
. 从JSON导入数据到内存
* 3
. 使用SharedPreferences持久化数据
* 4
. 处理实体间的关联关系序列化
*
* 序列化策略：
* - 普通字段：完整序列化
* - 关联字段：只序列化ID和类型信息
* - 关联列表：序列化为ID列表
*/
public
class DataExporter {
private static final String TAG = "DataExporter";
private final DataStore dataStore;
public DataExporter(DataStore dataStore) {
this
.dataStore = dataStore;
}
/**
* 导出所有数据为JSON字符串
*
* @return JSON格式的数据字符串
*/
public String exportToJson() {
ExportData exportData = new ExportData();
// 填充导出数据对象
exportData
.bancais = new ArrayList<>(dataStore
.bancais);
exportData
.caizhis = new ArrayList<>(dataStore
.caizhis);
exportData
.mupis = new ArrayList<>(dataStore
.mupis);
exportData
.chanpins = new ArrayList<>(dataStore
.chanpins);
exportData
.chanpin_zujians = new ArrayList<>(dataStore
.chanpin_zujians);
exportData
.dingdans = new ArrayList<>(dataStore
.dingdans);
exportData
.dingdan_chanpins = new ArrayList<>(dataStore
.dingdan_chanpins);
exportData
.dingdan_chanpin_zujians = new ArrayList<>(dataStore
.dingdan_chanpin_zujians);
exportData
.kucuns = new ArrayList<>(dataStore
.kucuns);
exportData
.zujians = new ArrayList<>(dataStore
.zujians);
exportData
.users = new ArrayList<>(dataStore
.users);
exportData
.jinhuos = new ArrayList<>(dataStore
.jinhuos);
// 创建自定义Gson实例
Gson gson = new GsonBuilder()
.setPrettyPrinting()
.registerTypeAdapter(SynchronizableEntity
.class, new SmartEntitySerializer())
.create();
return gson
.toJson(exportData);
}
/**
* 从JSON字符串导入数据
*
* @param json JSON格式的数据字符串
* @param context Android上下文
*/
public void importFromJson(String json, Context context) {
// 创建自定义Gson实例（带反序列化处理器）
Gson gson = new GsonBuilder()
.registerTypeAdapter(SynchronizableEntity
.class, new SmartEntityDeserializer())
.create();
Type exportType = new TypeToken<ExportData>(){}
.getType();
ExportData importData = gson
.fromJson(json, exportType);
// 清空现有数据（保留预置对象）
clearDataStorePreservingDefaults();
// 导入数据到DataStore
addAllToDataStore(importData);
// 保存到SharedPreferences
saveToPreferences(context, json);
Log
.i(TAG, "数据导入成功，共导入 " + importData
.dingdans
.size() + " 个订单");
}
/**
* 从SharedPreferences加载数据
*
* @param context Android上下文
*/
public void loadFromPreferences(Context context) {
SharedPreferences prefs = context
.getSharedPreferences("DataStore", Context
.MODE_PRIVATE);
String json = prefs
.getString("jsonData", null);
if (json != null) {
importFromJson(json, context);
}
}
/**
* 保存JSON到SharedPreferences
*/
private void saveToPreferences(Context context, String json) {
SharedPreferences prefs = context
.getSharedPreferences("DataStore", Context
.MODE_PRIVATE);
prefs
.edit()
.putString("jsonData", json)
.apply();
}
/**
* 清空DataStore但保留预置对象
*/
private void clearDataStorePreservingDefaults() {
// 为每个列表保留预置对象
retainPreservedItems(dataStore
.bancais);
retainPreservedItems(dataStore
.caizhis);
retainPreservedItems(dataStore
.mupis);
retainPreservedItems(dataStore
.chanpins);
retainPreservedItems(dataStore
.chanpin_zujians);
retainPreservedItems(dataStore
.dingdans);
retainPreservedItems(dataStore
.dingdan_chanpins);
retainPreservedItems(dataStore
.dingdan_chanpin_zujians);
retainPreservedItems(dataStore
.kucuns);
retainPreservedItems(dataStore
.zujians);
retainPreservedItems(dataStore
.users);
retainPreservedItems(dataStore
.jinhuos);
}
/**
* 保留列表中的预置对象
*/
private <T extends SynchronizableEntity> void retainPreservedItems(List<T> list) {
List<T> preserved = new ArrayList<>();
for (T item : list) {
if (item != null && item
.isPreservedObject()) {
preserved
.add(item);
}
}
list
.clear();
list
.addAll(preserved);
}
/**
* 将导入的数据添加到DataStore
*/
private void addAllToDataStore(ExportData importData) {
dataStore
.bancais
.addAll(importData
.bancais);
dataStore
.caizhis
.addAll(importData
.caizhis);
dataStore
.mupis
.addAll(importData
.mupis);
dataStore
.chanpins
.addAll(importData
.chanpins);
dataStore
.chanpin_zujians
.addAll(importData
.chanpin_zujians);
dataStore
.dingdans
.addAll(importData
.dingdans);
dataStore
.dingdan_chanpins
.addAll(importData
.dingdan_chanpins);
dataStore
.dingdan_chanpin_zujians
.addAll(importData
.dingdan_chanpin_zujians);
dataStore
.kucuns
.addAll(importData
.kucuns);
dataStore
.zujians
.addAll(importData
.zujians);
dataStore
.users
.addAll(importData
.users);
dataStore
.jinhuos
.addAll(importData
.jinhuos);
}
/**
* 智能实体序列化器 - 处理关联字段
*/
private
class SmartEntitySerializer implements JsonSerializer<SynchronizableEntity> {
@Override
public JsonElement serialize(SynchronizableEntity src, Type typeOfSrc,
JsonSerializationContext context) {
JsonObject json = new JsonObject();
try {
// 序列化所有字段
for (Field field : src
.get
Class()
.getDeclaredFields()) {
field
.setAccessible(true);
String fieldName = field
.getName();
Object value = field
.get(src);
// 检查是否关联字段
RefTo refAn
notation = field
.getAn
notation(RefTo
.class);
if (refAn
notation != null) {
// 处理关联字段
serializeReferenceField(json, fieldName, value, refAn
notation);
} else {
// 处理普通字段
serializeNormalField(json, context, fieldName, value);
}
}
// 添加实体类型信息
json
.addProperty("entityType", src
.get
Class()
.getSimpleName());
} catch (Exception e) {
Log
.e(TAG, "序列化实体失败: " + src
.get
Class()
.getSimpleName(), e);
}
return json;
}
private void serializeReferenceField(JsonObject json, String fieldName,
Object value, RefTo refAn
notation) {
if (refAn
notation
.type() == RefType
.SINGLE) {
// 单实体引用
if (value instanceof SynchronizableEntity) {
SynchronizableEntity refEntity = (SynchronizableEntity) value;
JsonObject refJson = new JsonObject();
refJson
.addProperty("id", refEntity
.getId());
refJson
.addProperty("type", refEntity
.get
Class()
.getSimpleName());
json
.add(fieldName, refJson);
}
} else {
// 实体列表引用
if (value instanceof List) {
JsonArray refArray = new JsonArray();
for (Object item : (List<?>) value) {
if (item instanceof SynchronizableEntity) {
SynchronizableEntity refEntity = (SynchronizableEntity) item;
JsonObject refJson = new JsonObject();
refJson
.addProperty("id", refEntity
.getId());
refJson
.addProperty("type", refEntity
.get
Class()
.getSimpleName());
refArray
.add(refJson);
}
}
json
.add(fieldName, refArray);
}
}
}
private void serializeNormalField(JsonObject json, JsonSerializationContext context,
String fieldName, Object value) {
if (value == null) {
json
.add(fieldName, JsonNull
.INSTANCE);
} else if (value instanceof String) {
json
.addProperty(fieldName, (String) value);
} else if (value instanceof Number) {
json
.addProperty(fieldName, (Number) value);
} else if (value instanceof Boolean) {
json
.addProperty(fieldName, (Boolean) value);
} else if (value instanceof Character) {
json
.addProperty(fieldName, (Character) value);
} else {
// 其他类型使用默认序列化
json
.add(fieldName, context
.serialize(value));
}
}
}
/**
* 智能实体反序列化器 - 处理关联字段
*/
private
class SmartEntityDeserializer implements JsonDeserializer<SynchronizableEntity> {
@Override
public SynchronizableEntity deserialize(JsonElement json, Type typeOfT,
JsonDeserializationContext context)
throws JsonParseException {
JsonObject jsonObject = json
.getAsJsonObject();
String entityType = jsonObject
.get("entityType")
.getAsString();
try {
// 创建实体实例
Class<?> clazz =
Class.forName("com
.example
.kucun2
.entity
." + entityType);
SynchronizableEntity entity = (SynchronizableEntity) clazz
.newInstance();
// 反序列化字段
for (Field field : clazz
.getDeclaredFields()) {
field
.setAccessible(true);
String fieldName = field
.getName();
if (jsonObject
.has(fieldName)) {
JsonElement fieldValue = jsonObject
.get(fieldName);
// 检查是否关联字段
RefTo refAn
notation = field
.getAn
notation(RefTo
.class);
if (refAn
notation != null) {
// 处理关联字段
deserializeReferenceField(entity, field, fieldValue, refAn
notation);
} else {
// 处理普通字段
deserializeNormalField(entity, field, fieldValue, context);
}
}
}
return entity;
} catch (Exception e) {
Log
.e(TAG, "反序列化实体失败: " + entityType, e);
return null;
}
}
private void deserializeReferenceField(SynchronizableEntity entity, Field field,
JsonElement fieldValue, RefTo refAn
notation)
throws IllegalAccessException {
if (refAn
notation
.type() == RefType
.SINGLE) {
// 单实体引用
if (fieldValue
.isJsonObject()) {
JsonObject refJson = fieldValue
.getAsJsonObject();
int id = refJson
.get("id")
.getAsInt();
String type = refJson
.get("type")
.getAsString();
// 创建临时引用对象（只有ID）
SynchronizableEntity refEntity = createReferenceEntity(id, type);
field
.set(entity, refEntity);
}
} else {
// 实体列表引用
if (fieldValue
.isJsonArray()) {
JsonArray refArray = fieldValue
.getAsJsonArray();
List<SynchronizableEntity> refList = new ArrayList<>();
for (JsonElement element : refArray) {
if (element
.isJsonObject()) {
JsonObject refJson = element
.getAsJsonObject();
int id = refJson
.get("id")
.getAsInt();
String type = refJson
.get("type")
.getAsString();
// 创建临时引用对象（只有ID）
refList
.add(createReferenceEntity(id, type));
}
}
field
.set(entity, refList);
}
}
}
private SynchronizableEntity createReferenceEntity(int id, String type) {
try {
Class<?> ref
Class =
Class.forName("com
.example
.kucun2
.entity
." + type);
SynchronizableEntity refEntity = (SynchronizableEntity) ref
Class.newInstance();
refEntity
.setId(id);
return refEntity;
} catch (Exception e) {
Log
.e(TAG, "创建引用实体失败: " + type, e);
return null;
}
}
private void deserializeNormalField(SynchronizableEntity entity, Field field,
JsonElement fieldValue,
JsonDeserializationContext context)
throws IllegalAccessException {
Class<?> fieldType = field
.getType();
if (fieldValue
.isJsonNull()) {
field
.set(entity, null);
} else if (fieldType == String
.class) {
field
.set(entity, fieldValue
.getAsString());
} else if (fieldType == Integer
.class || fieldType == int
.class) {
field
.set(entity, fieldValue
.getAsInt());
} else if (fieldType ==
Double.class || fieldType ==
double.class) {
field
.set(entity, fieldValue
.getAs
Double());
} else if (fieldType == Boolean
.class || fieldType == boolean
.class) {
field
.set(entity, fieldValue
.getAsBoolean());
} else if (fieldType == Long
.class || fieldType == long
.class) {
field
.set(entity, fieldValue
.getAsLong());
} else {
// 其他类型使用默认反序列化
Object value = context
.deserialize(fieldValue, fieldType);
field
.set(entity, value);
}
}
}
/**
* 导出数据结构（包含所有实体列表）
*/
public static
class ExportData {
public List<Bancai> bancais;
public List<Caizhi> caizhis;
public List<Mupi> mupis;
public List<Chanpin> chanpins;
public List<Chanpin_Zujian> chanpin_zujians;
public List<Dingdan> dingdans;
public List<Dingdan_Chanpin> dingdan_chanpins;
public List<Dingdan_chanpin_zujian> dingdan_chanpin_zujians;
public List<Kucun> kucuns;
public List<Zujian> zujians;
public List<User> users;
public List<Jinhuo> jinhuos;
}
}
================================================================================
/* 文件路径: DataPreserver/DataLoader
.java */
package com
.example
.kucun2
.DataPreserver;
import android
.content
.Context;
import android
.os
.Handler;
import android
.os
.Looper;
import android
.util.Log;
import com
.example
.kucun2
.entity
.*;
import com
.example
.kucun2
.entity
.In
formation;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
import com
.example
.kucun2
.function
.MyAppFnction;
import com
.example
.kucun2
.function
.SafeLogger;
import com
.google
.gson
.Gson;
import com
.google
.gson
.reflect
.TypeToken;
import
java.io
.IOException;
import
java.lang.reflect
.Type;
import
java.util.List;
import
java.util.concurrent
.ExecutorService;
import
java.util.concurrent
.Executors;
import
java.util.stream
.Collectors;
import okhttp3
.Call;
import okhttp3
.Callback;
import okhttp3
.OkHttpClient;
import okhttp3
.Request;
import okhttp3
.Response;
/**
* 数据加载器 - 负责从网络加载数据
*/
public
class DataLoader {
private static final String TAG = "DataLoader";
private final DataStore dataStore;
private final DataAssociator dataAssociator;
private final DataPreserver dataPreserver;
private final OkHttpClient client;
public DataLoader(DataStore dataStore, DataAssociator dataAssociator,
DataPreserver dataPreserver, OkHttpClient client) {
this
.dataStore = dataStore;
this
.dataAssociator = dataAssociator;
this
.dataPreserver = dataPreserver;
this
.client = client;
}
public void loadAllData(Context context, LoadDataCallback callback) {
if (Looper
.myLooper() != Looper
.getMainLooper()) {
throw new IllegalStateException("必须在主线程调用Data
.loadAllData");
}
dataPreserver
.ensurePreservedObjects(); // 确保存在预置对象
Handler mainHandler = new Handler(context
.getMainLooper());
ExecutorService executor = Executors
.newSingleThreadExecutor();
executor
.execute(() -> {
SynchronizableEntity
.setSyncEnabled(false);
String url = MyAppFnction
.getStringRe
source("string", "url") +
MyAppFnction
.getStringRe
source("string", "url_all");
Request request = new Request
.Builder()
.url(url)
.build();
client
.newCall(request)
.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
Log
.e(TAG, "Failed to load data", e);
SynchronizableEntity
.setSyncEnabled(true);
mainHandler
.post(() -> callback
.onFailure());
}
@Override
public void onResponse(Call call, Response response) throws IOException {
if (!response
.isSuccessful()) {
Log
.e(TAG, "Unexpected response code: " + response
.code());
SynchronizableEntity
.setSyncEnabled(true);
mainHandler
.post(() -> callback
.onFailure());
return;
}
String responseData = response
.body()
.string();
SynchronizableEntity
.setSyncEnabled(true);
dataPreserver
.ensurePreservedObjects();
mainHandler
.post(() -> {
parseAndAssignData(responseData, context, callback);
});
}
});
});
}
private void parseAndAssignData(String jsonData, Context context, LoadDataCallback callback) {
try {
Type responseType = new TypeToken<In
formation<AllDataResponse>>() {}
.getType();
In
formation<AllDataResponse> info = new Gson()
.fromJson(jsonData, responseType);
if (info == null || info
.getData() == null || info
.getStatus() != 200) {
throw new IllegalStateException("无效服务器响应");
}
AllDataResponse allData = info
.getData();
SafeLogger
.d("data", "原始数据: " + new Gson()
.toJson(allData));
updateAllLists(allData);
dataAssociator
.automaticAssociation();
setAllEntitiesState(SynchronizableEntity
.SyncState
.MODIFIED);
callback
.onSuccess();
} catch (Exception e) {
Log
.e(TAG, "数据处理异常: " + e
.getMessage());
callback
.onFailure();
} finally {
SynchronizableEntity
.setSyncEnabled(true);
}
}
private void updateAllLists(AllDataResponse allData) {
updateList(dataStore
.bancais, allData
.bancais);
updateList(dataStore
.caizhis, allData
.caizhis);
updateList(dataStore
.mupis, allData
.mupis);
updateList(dataStore
.chanpins, allData
.chanpins);
updateList(dataStore
.chanpin_zujians, allData
.chanpin_zujians);
updateList(dataStore
.dingdans, allData
.dingdans);
updateList(dataStore
.dingdan_chanpins, allData
.dingdan_chanpins);
updateList(dataStore
.dingdan_chanpin_zujians, allData
.dingdan_chanpin_zujians);
updateList(dataStore
.kucuns, allData
.kucuns);
updateList(dataStore
.zujians, allData
.zujians);
updateList(dataStore
.users, allData
.users);
updateList(dataStore
.jinhuos, allData
.jinhuos);
}
private <T extends SynchronizableEntity> void updateList(
List<T> existingList,
List<T> newList) {
if (newList == null) return;
List<T> preservedItems = existingList
.stream()
.filter(item -> item != null && item
.isPreservedObject())
.collect(Collectors
.toList());
existingList
.clear();
existingList
.addAll(preservedItems);
existingList
.addAll(newList
.stream()
.filter(item -> item != null && item
.getId() != null && item
.getId() != -1)
.collect(Collectors
.toList())
);
}
private void setAllEntitiesState(SynchronizableEntity
.SyncState state) {
dataStore
.dataCollection
Map.values()
.forEach(list ->
list
.forEach(entity -> {
if (entity != null) entity
.setState(state);
})
);
}
public interface LoadDataCallback {
void onSuccess();
void onFailure();
}
public static
class AllDataResponse {
public List<Bancai> bancais;
public List<Caizhi> caizhis;
public List<Mupi> mupis;
public List<Chanpin> chanpins;
public List<Chanpin_Zujian> chanpin_zujians;
public List<Dingdan> dingdans;
public List<Dingdan_Chanpin> dingdan_chanpins;
public List<Dingdan_chanpin_zujian> dingdan_chanpin_zujians;
public List<Kucun> kucuns;
public List<Zujian> zujians;
public List<User> users;
public List<Jinhuo> jinhuos;
}
}
================================================================================
/* 文件路径: DataPreserver/DataPreserver
.java */
// 文件路径: kucun2/entity/data/DataPreserver
.java
package com
.example
.kucun2
.DataPreserver;
import android
.util.Log;
import com
.example
.kucun2
.entity
.*;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
import
java.lang.reflect
.Field;
import
java.util.ArrayList;
import
java.util.Date;
import
java.util.List;
/**
* 预置对象管理器 - 负责处理空值/默认值
*/
public
class DataPreserver {
private final DataStore dataStore;
public DataPreserver(DataStore dataStore) {
this
.dataStore = dataStore;
}
/**
* 确保每个列表都有预置对象
*/
public void ensurePreservedObjects() {
addIfMissing(dataStore
.bancais, Bancai
.class);
addIfMissing(dataStore
.caizhis, Caizhi
.class);
addIfMissing(dataStore
.mupis, Mupi
.class);
addIfMissing(dataStore
.chanpins, Chanpin
.class);
addIfMissing(dataStore
.chanpin_zujians, Chanpin_Zujian
.class);
addIfMissing(dataStore
.dingdans, Dingdan
.class);
addIfMissing(dataStore
.kucuns, Kucun
.class);
addIfMissing(dataStore
.zujians, Zujian
.class);
addIfMissing(dataStore
.dingdan_chanpin_zujians, Dingdan_chanpin_zujian
.class);
addIfMissing(dataStore
.dingdan_chanpins, Dingdan_Chanpin
.class);
addIfMissing(dataStore
.jinhuos, Jinhuo
.class);
addIfMissing(dataStore
.users, User
.class);
}
private <T extends SynchronizableEntity> void addIfMissing(
List<T> list,
Class<T> clazz) {
if (!containsPreservedObject(list)) {
list
.add(createInstance(clazz));
}
}
private <T extends SynchronizableEntity> boolean containsPreservedObject(List<T> list) {
return list
.stream()
.anyMatch(item ->
item != null && item
.isPreservedObject()
);
}
/**
* 创建带默认值的实体实例
*/
public static <T> T createInstance(
Class<T> clazz) {
try {
T instance = clazz
.getDeclaredConstructor()
.newInstance();
setDefaultFieldValues(instance);
return instance;
} catch (Exception e) {
Log
.e("DataPreserver", "创建实例失败: " + clazz
.getName(), e);
try {
return clazz
.newInstance();
} catch (Exception ex) {
throw new RuntimeException("无法创建实例", ex);
}
}
}
private static <T> void setDefaultFieldValues(T instance) throws Exception {
for (Field field : instance
.get
Class()
.getDeclaredFields()) {
field
.setAccessible(true);
setDefaultFieldValue(instance, field);
}
// 设置特殊字段
instance
.get
Class()
.getMethod("setId", Integer
.class)
.invoke(instance, -1);
instance
.get
Class()
.getMethod("setState", SynchronizableEntity
.SyncState
.class)
.invoke(instance, SynchronizableEntity
.SyncState
.PRESERVED);
}
private static <T> void setDefaultFieldValue(T instance, Field field)
throws IllegalAccessException {
Class<?> type = field
.getType();
if (type == String
.class) field
.set(instance, "无");
else if (type == Integer
.class || type == int
.class) field
.set(instance, -1);
else if (type ==
Double.class || type ==
double.class) field
.set(instance, -1
.0);
else if (type == Boolean
.class || type == boolean
.class) field
.set(instance, false);
else if (type == Date
.class) field
.set(instance, new Date());
else if (SynchronizableEntity
.class.isAssignableFrom(type)) {
// 在DataStore中获取预置实体
field
.set(instance, getPreservedEntity((
Class<?>) type));
}
else if (List
.class.isAssignableFrom(type)) {
field
.set(instance, new ArrayList<>());
}
}
private static SynchronizableEntity getPreservedEntity(
Class<?> type) {
// 实际实现需要访问DataStore
return null; // 简化实现
}
}
================================================================================
/* 文件路径: DataPreserver/DataStore
.java */
package com
.example
.kucun2
.DataPreserver;
import com
.example
.kucun2
.entity
.*;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
import com
.example
.kucun2
.entity
.data
.SynchronizedList;
import
java.util.List;
import
java.util.Map;
import
java.util.concurrent
.ConcurrentHash
Map;
/**
* 数据存储中心 - 管理所有实体列表
*/
public
class DataStore {
// ====================== 实体存储区 ======================
public final SynchronizedList<Bancai> bancais = new SynchronizedList<>(Bancai
.class);
public final SynchronizedList<Caizhi> caizhis = new SynchronizedList<>(Caizhi
.class);
public final SynchronizedList<Mupi> mupis = new SynchronizedList<>(Mupi
.class);
public final SynchronizedList<Chanpin> chanpins = new SynchronizedList<>(Chanpin
.class);
public final SynchronizedList<Chanpin_Zujian> chanpin_zujians = new SynchronizedList<>(Chanpin_Zujian
.class);
public final SynchronizedList<Dingdan> dingdans = new SynchronizedList<>(Dingdan
.class);
public final SynchronizedList<Dingdan_Chanpin> dingdan_chanpins = new SynchronizedList<>(Dingdan_Chanpin
.class);
public final SynchronizedList<Dingdan_chanpin_zujian> dingdan_chanpin_zujians = new SynchronizedList<>(Dingdan_chanpin_zujian
.class);
public final SynchronizedList<Kucun> kucuns = new SynchronizedList<>(Kucun
.class);
public final SynchronizedList<Zujian> zujians = new SynchronizedList<>(Zujian
.class);
public final SynchronizedList<User> users = new SynchronizedList<>(User
.class);
public final SynchronizedList<Jinhuo> jinhuos = new SynchronizedList<>(Jinhuo
.class);
// 实体类型与列表的映射表
public final
Map<
Class, SynchronizedList<SynchronizableEntity>> dataCollection
Map = new ConcurrentHash
Map<>();
public DataStore() {
// 建立实体类型与列表的映射关系
registerCollection(Bancai
.class, bancais);
registerCollection(Caizhi
.class, caizhis);
registerCollection(Mupi
.class, mupis);
registerCollection(Chanpin
.class, chanpins);
registerCollection(Chanpin_Zujian
.class, chanpin_zujians);
registerCollection(Dingdan
.class, dingdans);
registerCollection(Dingdan_Chanpin
.class, dingdan_chanpins);
registerCollection(Dingdan_chanpin_zujian
.class, dingdan_chanpin_zujians);
registerCollection(Kucun
.class, kucuns);
registerCollection(Zujian
.class, zujians);
registerCollection(User
.class, users);
registerCollection(Jinhuo
.class, jinhuos);
}
private <T extends SynchronizableEntity> void registerCollection(
Class<T> entity
Class, SynchronizedList<T> list) {
dataCollection
Map.put(entity
Class, (SynchronizedList<SynchronizableEntity>) list);
}
}原型为package com
.example
.kucun2
.entity
.data;
import android
.content
.Context;
import android
.content
.SharedPreferences;
import android
.os
.Handler;
import android
.os
.Looper;
import android
.util.Log;
import com
.example
.kucun2
.entity
.*;
import com
.example
.kucun2
.function
.MyAppFnction;
import com
.example
.kucun2
.function
.SafeLogger;
import com
.google
.gson
.Gson;
import com
.google
.gson
.GsonBuilder;
import com
.google
.gson
.JsonDeserializationContext;
import com
.google
.gson
.JsonDeserializer;
import com
.google
.gson
.JsonElement;
import com
.google
.gson
.JsonObject;
import com
.google
.gson
.JsonParseException;
import com
.google
.gson
.JsonSerializationContext;
import com
.google
.gson
.JsonSerializer;
import com
.google
.gson
.reflect
.TypeToken;
import
java.io
.IOException;
import
java.lang.reflect
.*;
import
java.util.*;
import
java.util.concurrent
.ConcurrentHash
Map;
import
java.util.concurrent
.ExecutorService;
import
java.util.concurrent
.Executors;
import
java.util.stream
.Collectors;
import okhttp3
.*;
/**
* 核心数据管理中心
* 职责：
* 1
. 管理所有实体类的全局存储列表
* 2
. 处理网络数据加载与本地持久化
* 3
. 维护实体间关联关系
* 4
. 管理数据同步状态
*
* 优化点：
* - 使用ConcurrentHash
Map提升线程安全
* - 重构关联逻辑避免反射开销
* - 增强序列化/反序列化处理
* - 添加详细方法级注释
*/
public
class Data {
// ====================== 实体存储区 ======================
// 所有实体列表使用线程安全的SynchronizedList
// ====================== 静态数据列表声明 ======================
public static final SynchronizedList<Bancai> bancais = new SynchronizedList<>(Bancai
.class);
public static final SynchronizedList<Caizhi> caizhis = new SynchronizedList<>(Caizhi
.class);
public static final SynchronizedList<Mupi> mupis = new SynchronizedList<>(Mupi
.class);
public static final SynchronizedList<Chanpin> chanpins = new SynchronizedList<>(Chanpin
.class);
public static final SynchronizedList<Chanpin_Zujian> chanpin_zujians = new SynchronizedList<>(Chanpin_Zujian
.class);
public static final SynchronizedList<Dingdan> dingdans = new SynchronizedList<>(Dingdan
.class);
public static final SynchronizedList<Dingdan_Chanpin> dingdan_chanpins = new SynchronizedList<>(Dingdan_Chanpin
.class);
public static final SynchronizedList<Dingdan_chanpin_zujian> Dingdan_chanpin_zujians = new SynchronizedList<>(Dingdan_chanpin_zujian
.class);
public static final SynchronizedList<Kucun> kucuns = new SynchronizedList<>(Kucun
.class);
public static final SynchronizedList<Zujian> zujians = new SynchronizedList<>(Zujian
.class);
public static final SynchronizedList<User> users = new SynchronizedList<>(User
.class);
public static final SynchronizedList<Jinhuo> jinhuos = new SynchronizedList<>(Jinhuo
.class);
private static User user;
// 实体类型与列表的映射表 <实体类, 对应的同步列表>
public static final
Map<
Class, SynchronizedList<SynchronizableEntity>> dataCollection
Map = new ConcurrentHash
Map<>();;
private static final Gson gson = GsonFactory
.createGson();
private static OkHttpClient client;
private static final String TAG = "DataLoader";
// 静态初始化：建立实体类型与列表的映射关系
static {
try {
// 通过反射获取所有SynchronizedList字段
for (Field field : Data
.class.getDeclaredFields()) {
if (SynchronizedList
.class.equals(field
.getType())) {
SynchronizedList<?> list = (SynchronizedList<?>) field
.get(null);
if (list != null) {
// 将实体类型与列表关联
dataCollection
Map.put(list
.getEntityType(), (SynchronizedList<SynchronizableEntity>) list);
}
}
}
} catch (IllegalAccessException e) {
throw new RuntimeException("初始化dataCollection
Map失败", e);
}
}
// ====================== 核心数据加载方法 ======================
/**
* 从服务器加载全量数据
* @param context Android上下文
* @param callback 加载结果回调
*/
public static void loadAllData(Context context, LoadDataCallback callback) {
// 主线程检查
if (Looper
.myLooper() != Looper
.getMainLooper()) {
throw new IllegalStateException("必须在主线程调用Data
.loadAllData");
}
ensurePreservedObjects(); // 确保存在预置对象
// 使用传入的 Context 获取主线程 Handler
Handler mainHandler = new Handler(context
.getMainLooper());
// 确保使用安全的客户端
if (client == null) {
client = MyAppFnction
.getClient();
}
ExecutorService executor = Executors
.newSingleThreadExecutor();
executor
.execute(() -> {
SynchronizableEntity
.setSyncEnabled(false);
String url = MyAppFnction
.getStringRe
source("string", "url") +
MyAppFnction
.getStringRe
source("string", "url_all");
Request request = new Request
.Builder()
.url(url)
.build();
client
.newCall(request)
.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
Log
.e(TAG, "Failed to load data", e);
SynchronizableEntity
.setSyncEnabled(true);
mainHandler
.post(() -> {
if (callback != null) callback
.onFailure();
});
}
@Override
public void onResponse(Call call, Response response) throws IOException {
if (!response
.isSuccessful()) {
Log
.e(TAG, "Unexpected response code: " + response
.code());
SynchronizableEntity
.setSyncEnabled(true);
mainHandler
.post(() -> {
if (callback != null) callback
.onFailure();
});
return;
}
String responseData = response
.body()
.string();
SynchronizableEntity
.setSyncEnabled(true);
ensurePreservedObjects();
// 在主线程处理解析
mainHandler
.post(() -> {
parseAndAssignData(responseData, context, callback);
});
}
});
});
}
// ====================== 数据处理私有方法 ======================
/**
* 解析JSON数据并更新到实体列表
*/
private static void parseAndAssignData(String jsonData, Context context, LoadDataCallback callback) {
try {
// 解析顶层响应结构
Type responseType = new TypeToken<In
formation<AllDataResponse>>() {}
.getType();
In
formation<AllDataResponse> info = gson
.fromJson(jsonData, responseType);
Log
.d(TAG, "parseAndAssignData: "+jsonData);
// 验证响应有效性
if (info == null || info
.getData() == null || info
.getStatus() != 200) {
throw new IllegalStateException("无效服务器响应");
}
AllDataResponse allData = info
.getData();
SafeLogger
.d("data", "原始数据: " + gson
.toJson(allData));
// 更新所有数据列表
updateAllLists(allData);
automaticAssociation(); // 建立实体关联
setAllEntitiesState(SynchronizableEntity
.SyncState
.MODIFIED); // 设置状态
safeCallback(callback, true); // 成功回调
} catch (Exception e) {
Log
.e(TAG, "数据处理异常: " + e
.getMessage());
safeCallback(callback, false);
} finally {
SynchronizableEntity
.setSyncEnabled(true); // 重新启用同步
}
}
/**
* 批量更新所有实体列表
*/
private static void updateAllLists(AllDataResponse allData) {
updateList(bancais, allData
.bancais);
updateList(caizhis, allData
.caizhis);
updateList(mupis, allData
.mupis);
updateList(chanpins, allData
.chanpins);
updateList(chanpin_zujians, allData
.chanpin_zujians);
updateList(dingdans, allData
.dingdans);
updateList(dingdan_chanpins, allData
.dingdan_chanpins);
updateList(Dingdan_chanpin_zujians, allData
.Dingdan_chanpin_zujians);
updateList(kucuns, allData
.kucuns);
updateList(zujians, allData
.zujians);
updateList(users, allData
.users);
updateList(jinhuos, allData
.jinhuos);
}
/**
* 安全更新单个列表（保留预置对象）
*/
private static <T extends SynchronizableEntity> void updateList(
List<T> existingList,
List<T> newList
) {
if (newList == null) return;
// 保留现有列表中的预置对象
List<T> preservedItems = existingList
.stream()
.filter(item -> item != null && item
.isPreservedObject())
.collect(Collectors
.toList());
// 清空后重新添加（预置对象 + 有效新数据）
existingList
.clear();
existingList
.addAll(preservedItems);
existingList
.addAll(newList
.stream()
.filter(item -> item != null && item
.getId() != null && item
.getId() != -1)
.collect(Collectors
.toList())
);
}
/**
* 确保每个列表都有预置对象（用于表示空值/默认值）
*/
private static void ensurePreservedObjects() {
// 为每个实体类型检查并添加预置对象
addIfMissing(bancais, Bancai
.class);
addIfMissing(caizhis, Caizhi
.class);
addIfMissing(mupis, Mupi
.class);
addIfMissing(chanpins, Chanpin
.class);
addIfMissing(chanpin_zujians, Chanpin_Zujian
.class);
addIfMissing(dingdans, Dingdan
.class);
addIfMissing(kucuns, Kucun
.class);
addIfMissing(zujians, Zujian
.class);
addIfMissing(Dingdan_chanpin_zujians, Dingdan_chanpin_zujian
.class);
addIfMissing(dingdan_chanpins, Dingdan_Chanpin
.class);
addIfMissing(jinhuos, Jinhuo
.class);
addIfMissing(users, User
.class);
}
private static <T extends SynchronizableEntity> void addIfMissing(
List<T> list,
Class<T> clazz
) {
if (!containsPreservedObject(list)) {
list
.add(createInstance(clazz));
}
}
/**
* 检查列表是否包含预置对象
*
* @param list 目标实体列表
* @return 是否包含预置对象
*/
private static <T extends SynchronizableEntity> boolean containsPreservedObject(List<T> list) {
return list
.stream()
.anyMatch(item ->
item != null &&
item
.isPreservedObject()
);
}
/**
* 自动建立实体间关联关系（通过反射实现）
*/
private static void automaticAssociation() {
for (
Class<?> entity
Class : dataCollection
Map.keySet()) {
try {
associateEntities(dataCollection
Map.get(entity
Class));
} catch (Exception e) {
Log
.e(TAG, entity
Class.getSimpleName() + " 关联失败", e);
}
}
}
private static <T extends SynchronizableEntity> void associateEntities(
SynchronizedList<T> list
) throws IllegalAccessException,
ClassNotFoundException {
for (T entity : list) {
if (entity == null) continue;
for (Field field : entity
.get
Class()
.getDeclaredFields()) {
field
.setAccessible(true);
Class<?> fieldType = field
.getType();
// 处理实体引用字段
if (SynchronizableEntity
.class.isAssignableFrom(fieldType)) {
associateSingleReference(entity, field);
}
// 处理实体列表字段
else if (List
.class.isAssignableFrom(fieldType)) {
associateReferenceList(entity, field);
}
// 处理基础类型字段
else {
setDefaultPrimitiveValue(entity, field);
}
}
}
}
// ====================== 关联辅助方法 ======================
private static void associateSingleReference(
SynchronizableEntity entity,
Field field
) throws IllegalAccessException {
SynchronizableEntity ref = (SynchronizableEntity) field
.get(entity);
Class<?> targetType = field
.getType();
// 查找目标实体
SynchronizableEntity target =
findTargetEntity(ref, targetType);
field
.set(entity, target);
}
private static void associateReferenceList(
SynchronizableEntity entity,
Field field
) throws IllegalAccessException,
ClassNotFoundException {
// 获取列表泛型类型
Type genericType = field
.getGenericType();
if (!(genericType instanceof ParameterizedType)) return;
Class<?> itemType =
Class.forName(
((ParameterizedType) genericType)
.getActualTypeArguments()[0]
.getTypeName()
);
// 只处理实体列表
if (!SynchronizableEntity
.class.isAssignableFrom(itemType)) return;
List<SynchronizableEntity> refList = (List<SynchronizableEntity>) field
.get(entity);
if (refList == null) {
refList = new ArrayList<>();
field
.set(entity, refList);
}
// 清理空值并重建引用
refList
.removeAll(Collections
.singleton(null));
for (int i = 0; i < refList
.size(); i++) {
refList
.set(i,
findTargetEntity(refList
.get(i), itemType));
}
}
/**
* 查找关联实体（优先匹配ID，找不到则使用预置对象）
*/
private static SynchronizableEntity
findTargetEntity(
SynchronizableEntity ref,
Class<?> targetType
) {
SynchronizedList<SynchronizableEntity> targetList = dataCollection
Map.get(targetType);
if (targetList == null) return null;
// 无效引用时返回预置对象
if (ref == null || ref
.getId() == null || ref
.getId() < 0) {
return targetList
.stream()
.filter(SynchronizableEntity::isPreservedObject)
.findFirst()
.orElse(null);
}
// 按ID查找目标实体
return targetList
.stream()
.filter(e -> ref
.getId()
.equals(e
.getId()))
.findFirst()
.orElseGet(() -> targetList
.stream() // 找不到时回退到预置对象
.filter(SynchronizableEntity::isPreservedObject)
.findFirst()
.orElse(null)
);
}
// ====================== 工具方法 ======================
/**
* 创建带默认值的实体实例（用作预置对象）
*/
public static <T> T createInstance(
Class<T> clazz) {
try {
T instance = clazz
.getDeclaredConstructor()
.newInstance();
// 设置基础字段默认值
for (Field field : clazz
.getDeclaredFields()) {
field
.setAccessible(true);
setDefaultFieldValue(instance, field);
}
// 设置特殊字段
clazz
.getMethod("setId", Integer
.class)
.invoke(instance, -1);
clazz
.getMethod("setState", SynchronizableEntity
.SyncState
.class)
.invoke(instance, SynchronizableEntity
.SyncState
.PRESERVED);
return instance;
} catch (Exception e) {
Log
.e("Data", "创建实例失败: " + clazz
.getName(), e);
try {
return clazz
.newInstance(); // 回退创建
} catch (Exception ex) {
throw new RuntimeException("无法创建实例", ex);
}
}
}
private static <T> void setDefaultFieldValue(T instance, Field field)
throws IllegalAccessException {
Class<?> type = field
.getType();
if (type == String
.class) field
.set(instance, "无");
else if (type == Integer
.class || type == int
.class) field
.set(instance, -1);
else if (type ==
Double.class || type ==
double.class) field
.set(instance, -1
.0);
else if (type == Boolean
.class || type == boolean
.class) field
.set(instance, false);
else if (type == Date
.class) field
.set(instance, new Date());
else if (SynchronizableEntity
.class.isAssignableFrom(type)) {
field
.set(instance, getPreservedEntity((
Class<?>) type));
}
else if (List
.class.isAssignableFrom(type)) {
field
.set(instance, new ArrayList<>());
}
}
private static SynchronizableEntity getPreservedEntity(
Class<?> type) {
return dataCollection
Map.get(type)
.stream()
.filter(SynchronizableEntity::isPreservedObject)
.findFirst()
.orElse(null);
}
private static void setDefaultPrimitiveValue(
SynchronizableEntity entity,
Field field
) throws IllegalAccessException {
if (field
.get(entity) != null) return;
Class<?> type = field
.getType();
if (type == String
.class) field
.set(entity, "无");
else if (type == Integer
.class || type == int
.class) field
.set(entity, -1);
else if (type ==
Double.class || type ==
double.class) field
.set(entity, -1
.0);
else if (type == Boolean
.class || type == boolean
.class) field
.set(entity, false);
else if (type == Date
.class) field
.set(entity, new Date());
}
/**
* 主线程安全回调
*/
private static void safeCallback(LoadDataCallback callback, boolean success) {
new Handler(Looper
.getMainLooper())
.post(() -> {
if (callback == null) return;
if (success) callback
.onSuccess();
else callback
.onFailure();
});
}
/**
* 设置所有实体同步状态
*/
private static void setAllEntitiesState(SynchronizableEntity
.SyncState state) {
dataCollection
Map.values()
.forEach(list ->
list
.forEach(entity -> {
if (entity != null) entity
.setState(state);
})
);
}
public static String exportToJson() {
ExportData exportData = new ExportData();
exportData
.bancais = new ArrayList<>(bancais);
exportData
.caizhis = new ArrayList<>(caizhis);
// 初始化其他列表
...
Gson gson = new GsonBuilder()
.setPrettyPrinting()
.registerTypeAdapter(SynchronizableEntity
.class, new EntitySerializer())
.create();
return gson
.toJson(exportData);
}
public static void importFromJson(String json, Context context) {
Gson gson = new GsonBuilder()
.registerTypeAdapter(SynchronizableEntity
.class, new EntityDeserializer())
.create();
Type exportType = new TypeToken<ExportData>(){}
.getType();
ExportData importData = gson
.fromJson(json, exportType);
// 更新数据列表
updateList(bancais, importData
.bancais);
updateList(caizhis, importData
.caizhis);
// 更新其他列表
...
automaticAssociation();
setAllEntitiesState(SynchronizableEntity
.SyncState
.MODIFIED);
// 保存到SharedPreferences
saveToPreferences(context, json);
}
private static void saveToPreferences(Context context, String json) {
SharedPreferences prefs = context
.getSharedPreferences("DataStore", Context
.MODE_PRIVATE);
prefs
.edit()
.putString("jsonData", json)
.apply();
}
public static void loadFromPreferences(Context context) {
SharedPreferences prefs = context
.getSharedPreferences("DataStore", Context
.MODE_PRIVATE);
String json = prefs
.getString("jsonData", null);
if (json != null) {
importFromJson(json, context);
}
}
// ====================== 内部类/接口 ======================
public interface LoadDataCallback {
void onSuccess();
void onFailure();
}
/** JSON响应数据结构 */
public static
class AllDataResponse {
public List<Bancai> bancais;
public List<Caizhi> caizhis;
public List<Mupi> mupis;
public List<Chanpin> chanpins;
public List<Chanpin_Zujian> chanpin_zujians;
public List<Dingdan> dingdans;
public List<Dingdan_Chanpin> dingdan_chanpins;
public List<Dingdan_chanpin_zujian> Dingdan_chanpin_zujians;
public List<Kucun> kucuns;
public List<Zujian> zujians;
public List<User> users;
public List<Jinhuo> jinhuos;
}
// 在Data
.java中添加
public static
class ExportData {
public List<Bancai> bancais;
public List<Caizhi> caizhis;
public List<Mupi> mupis;
public List<Chanpin> chanpins;
public List<Chanpin_Zujian> chanpin_zujians;
public List<Dingdan> dingdans;
public List<Dingdan_Chanpin> dingdan_chanpins;
public List<Dingdan_chanpin_zujian> Dingdan_chanpin_zujians;
public List<Kucun> kucuns;
public List<Zujian> zujians;
public List<User> users;
public List<Jinhuo> jinhuos;
}
private static
class EntityDeserializer implements JsonDeserializer<SynchronizableEntity> {
@Override
public SynchronizableEntity deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
JsonObject obj = json
.getAsJsonObject();
String entityType = obj
.get("entityType")
.getAsString();
Integer id = obj
.get("id")
.getAsInt();
// 创建临时实体（只包含ID）
try {
Class<?> clazz =
Class.forName("com
.example
.kucun2
.entity
." + entityType);
SynchronizableEntity entity = (SynchronizableEntity) clazz
.newInstance();
entity
.setId(id);
return entity;
} catch (Exception e) {
return null;
}
}
}
private static
class EntitySerializer implements JsonSerializer<SynchronizableEntity> {
@Override
public JsonElement serialize(SynchronizableEntity src, Type typeOfSrc, JsonSerializationContext context) {
JsonObject obj = new JsonObject();
obj
.addProperty("id", src
.getId());
obj
.addProperty("entityType", src
.get
Class()
.getSimpleName());
return obj;
}
}
}补全com
.example
.kucun2
.DataPreserver
.Data
.java,是外部调用和原始data类一样
本文介绍在 MyBatis 中使用 @Param 注解时应注意的问题，特别是 @Param 注解与 ParamType 属性不能同时使用的情况，这对于正确配置 SQL 映射文件至关重要。
扫一扫
1242
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
