/* 文件路径: DataPreserver/Data.java */
package com.example.kucun2.DataPreserver;
import android.content.Context;
import android.util.Log;
import com.example.kucun2.entity.*;
import com.example.kucun2.entity.data.SynchronizableEntity;
import com.example.kucun2.entity.data.SynchronizedList;
import java.util.ArrayList;
import java.util.List;
/**
* 数据管理中心（简化版）
* 提供对所有业务数据的统一访问入口
*/
public class Data {
// 单例实例
private static final Data instance = new Data();
private static final DataAssociator dataAssociator = new DataAssociator(instance.dataStore);
// 数据存储核心
private final DataStore dataStore = new DataStore();
// 初始化预置对象
static {
// new DataPreserver(instance.dataStore).ensurePreservedObjects();
}
// ====================== 数据访问接口 ======================
public static SynchronizedList<Bancai> bancais() {
return instance.dataStore.bancais;
}
public static SynchronizedList<Caizhi> caizhis() {
return instance.dataStore.caizhis;
}
public static SynchronizedList<Mupi> mupis() {
return instance.dataStore.mupis;
}
public static SynchronizedList<Chanpin> chanpins() {
return instance.dataStore.chanpins;
}
public static SynchronizedList<Chanpin_Zujian> chanpin_zujians() {
return instance.dataStore.chanpin_zujians;
}
public static SynchronizedList<Dingdan> dingdans() {
return instance.dataStore.dingdans;
}
public static SynchronizedList<Dingdan_Chanpin> dingdan_chanpins() {
return instance.dataStore.dingdan_chanpins;
}
public static SynchronizedList<Dingdan_bancai> Dingdan_bancais() {
return instance.dataStore.dingdan_bancais;
}
public static SynchronizedList<Kucun> kucuns() {
return instance.dataStore.kucuns;
}
public static SynchronizedList<Zujian> zujians() {
return instance.dataStore.zujians;
}
public static SynchronizedList<User> users() {
return instance.dataStore.users;
}
public static SynchronizedList<Jinhuo> jinhuos() {
return instance.dataStore.jinhuos;
}
// ====================== 核心操作方法 ======================
/**
* 添加实体
* @param entity 要添加的实体
* @param <T> 实体类型
*/
public static <T extends SynchronizableEntity> void add(T entity) {
Class<T> entityClass = (Class<T>) entity.getClass();
SynchronizedList<T> list = (SynchronizedList<T>) getList(entityClass);
if (list != null) {
list.addAsync(entity, new SyncCallback<T>(entity,"add") {
@Override
public void onFailure(T item, String error) {
Log.e("Data", "添加失败: " + error);
}
});
}
}
/**
* 更新实体
* @param entity 更新后的实体
* @param <T> 实体类型
*/
public static <T extends SynchronizableEntity> void update(T entity) {
Class<T> entityClass = (Class<T>) entity.getClass();
T existing = (T) findById(entity.getId(), entityClass);
if (existing != null) {
existing.updateFrom(entity);
existing.sync("update", new SynchronizableEntity.SyncCallback() {
@Override
public void onSyncSuccess(SynchronizableEntity entity) {
notifyDataChanged(entityClass, "update", entity.getId());
}
@Override
public void onSyncFailure(String error) {
Log.e("Data", "更新失败: " + error);
}
});
}
}
/**
* 删除实体
* @param id 实体ID
* @param type 实体类型
* @param <T> 实体类型
*/
public static <T extends SynchronizableEntity> void delete(int id, Class<T> type) {
T entity = findById(id, type);
if (entity != null) {
SynchronizedList<T> list = getList(type);
if (list != null) {
list.removeAsync(entity, new SyncCallback<T>(entity,"delete") {
@Override
public void onFailure(T item, String error) {
Log.e("Data", "删除失败: ");
}
});
}
}
}
/**
* 根据ID查找实体
* @param id 实体ID
* @param type 实体类型
* @return 找到的实体或null
*/
public static <T extends SynchronizableEntity> T findById(Integer id, Class<T> type) {
SynchronizedList<T> list = getList(type);
if (list != null) {
for (T entity : list.getViewList()) {
if (entity.getId() == id) {
return entity;
}
}
}
return null;
}
// ====================== 数据加载与持久化 ======================
/**
* 加载所有数据
*/
public static void loadAllData(Context context, Runnable onSuccess, Runnable onFailure) {
new DataLoader(instance.dataStore,
new DataAssociator(instance.dataStore)
// new DataPreserver(instance.dataStore)
).loadAllData(context, new DataLoader.LoadDataCallback() {
@Override
public void onSuccess() {
if (onSuccess != null) onSuccess.run();
}
@Override
public void onFailure() {
if (onFailure != null) onFailure.run();
}
});
}
/**
* 保存所有数据到本地
*/
public static void saveAllData(Context context) {
new DataExporter(instance.dataStore).saveToPreferences(
context,
new DataExporter(instance.dataStore).exportToJson()
);
}
// ====================== 辅助方法 ======================
/**
* 获取当前登录用户
*/
public static User getCurrentUser() {
for (User user : users().getViewList()) {
if (user.isCurrentUser()) {
return user;
}
}
return null;
}
/**
* 设置当前用户
*/
public static void setCurrentUser(User user) {
}
// ====================== 事件通知 ======================
public interface OnDataChangeListener {
// void onDataChanged();
void onDataChanged(Class<?> entityClass, String operationType, Integer itemId);
}
private static final List<OnDataChangeListener> listeners = new ArrayList<>();
public static void addDataChangeListener(OnDataChangeListener listener) {
listeners.add(listener);
}
public static void removeDataChangeListener(OnDataChangeListener listener) {
listeners.remove(listener);
}
private static <T extends SynchronizableEntity> void notifyDataChanged(Class<T> entityClass, String add, Integer id) {
for (OnDataChangeListener listener : listeners) {
listener.onDataChanged(entityClass,add,id);
}
}
// ====================== 内部工具类 ======================
/**
* 获取实体对应的列表
*/
@SuppressWarnings("unchecked")
private static <T extends SynchronizableEntity> SynchronizedList<T> getList(Class<T> type) {
if (type == Bancai.class) return (SynchronizedList<T>) instance.dataStore.bancais;
if (type == Caizhi.class) return (SynchronizedList<T>) instance.dataStore.caizhis;
if (type == Mupi.class) return (SynchronizedList<T>) instance.dataStore.mupis;
if (type == Chanpin.class) return (SynchronizedList<T>) instance.dataStore.chanpins;
if (type == Chanpin_Zujian.class) return (SynchronizedList<T>) instance.dataStore.chanpin_zujians;
if (type == Dingdan.class) return (SynchronizedList<T>) instance.dataStore.dingdans;
if (type == Dingdan_Chanpin.class) return (SynchronizedList<T>) instance.dataStore.dingdan_chanpins;
if (type == Dingdan_bancai.class) return (SynchronizedList<T>) instance.dataStore.dingdan_bancais;
if (type == Kucun.class) return (SynchronizedList<T>) instance.dataStore.kucuns;
if (type == Zujian.class) return (SynchronizedList<T>) instance.dataStore.zujians;
if (type == User.class) return (SynchronizedList<T>) instance.dataStore.users;
if (type == Jinhuo.class) return (SynchronizedList<T>) instance.dataStore.jinhuos;
return null;
}
/**
* 同步操作回调（简化版）
*/
private static class SyncCallback<T extends SynchronizableEntity>
implements SynchronizedList.OperationCallback<T> {
private final T item;
private final String trpe;
public SyncCallback(T ignoredItem, String trpe){
this.item = ignoredItem;
this.trpe = trpe;
}
@Override
public void onSuccess(T item) {
dataAssociator.
notifyDataChanged(item.getClass(),trpe,item.getId());
}
@Override
public void onFailure(T item, String error) {
Log.e("Data", "操作失败: " + error);
}
}
}
================================================================================
/* 文件路径: 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 com.example.kucun2.entity.RefTo;
import com.example.kucun2.entity.RefType;
import java.lang.reflect.Field;
import java.util.*;
/**
* 实体关联处理器
*
* 功能：自动处理实体间的引用关系，包括：
* 1. 正向引用（实体对其他实体的引用）
* 2. 反向引用（其他实体对当前实体的引用）
* 3. 双向关联（自动维护双向引用关系）
*/
public class DataAssociator {
private final DataStore dataStore;
// 反向映射缓存 [目标实体类 -> [反向字段名 -> 源实体类]]
private final Map<Class<?>, Map<String, Class<?>>> reverseMappingCache = new HashMap<>();
// 实体ID映射缓存 [实体类 -> [实体ID -> 实体实例]]
private final Map<Class<?>, Map<Integer, SynchronizableEntity>> idMapCache = new HashMap<>();
public DataAssociator(DataStore dataStore) {
this.dataStore = dataStore;
buildReverseMappingCache();
buildIdMapCache();
}
/**
* 构建反向映射缓存（系统启动时执行一次）
* 扫描所有实体类，缓存双向关联的元数据
*/
private void buildReverseMappingCache() {
for (Class<?> entityClass : dataStore.dataCollectionMap.keySet()) {
for (Field field : getAllFields(entityClass)) {
RefTo refAnnotation = field.getAnnotation(RefTo.class);
if (refAnnotation != null && refAnnotation.bidirectional()) {
Class<?> targetClass = refAnnotation.target();
String reverseField = refAnnotation.reverseField();
reverseMappingCache
.computeIfAbsent(targetClass, k -> new HashMap<>())
.put(reverseField, entityClass);
}
}
}
}
/**
* 构建ID映射缓存（每次数据加载后更新）
* 创建实体ID到实体实例的快速查找映射
*/
private void buildIdMapCache() {
idMapCache.clear();
for (Class<?> entityClass : dataStore.dataCollectionMap.keySet()) {
SynchronizedList<?> list = dataStore.getCollection(entityClass);
if (list == null) continue;
Map<Integer, SynchronizableEntity> idMap = new HashMap<>();
for (Object entity : list.getViewList()) {
SynchronizableEntity syncEntity = (SynchronizableEntity) entity;
idMap.put(syncEntity.getId(), syncEntity);
}
idMapCache.put(entityClass, idMap);
}
}
/**
* 自动处理所有实体关联关系
* 建议在数据加载完成后调用
*/
public void automaticAssociation() {
Log.d("DataAssociator", "开始处理实体关联...");
long startTime = System.currentTimeMillis();
// 处理所有正向引用
for (SynchronizedList<?> list : dataStore.dataCollectionMap.values()) {
for (Object entity : list.getViewList()) {
processForwardReferences((SynchronizableEntity) entity);
}
}
// 处理所有反向引用
for (SynchronizedList<?> list : dataStore.dataCollectionMap.values()) {
for (Object entity : list.getViewList()) {
processReverseReferences((SynchronizableEntity) entity);
}
}
long duration = System.currentTimeMillis() - startTime;
Log.d("DataAssociator", "实体关联处理完成, 耗时: " + duration + "ms");
}
/**
* 处理单个实体的正向引用
* 解析带有@RefTo注解的字段，并替换为实际实体引用
*/
private void processForwardReferences(SynchronizableEntity entity) {
for (Field field : getAllFields(entity.getClass())) {
RefTo refAnnotation = field.getAnnotation(RefTo.class);
if (refAnnotation == null) continue;
try {
field.setAccessible(true);
Class<?> targetClass = refAnnotation.target();
RefType refType = refAnnotation.type();
if (refType == RefType.SINGLE) {
// 处理单实体引用
SynchronizableEntity refEntity = (SynchronizableEntity) field.get(entity);
if (refEntity != null) {
SynchronizableEntity actualEntity = findActualEntity(refEntity, targetClass);
field.set(entity, actualEntity);
// 建立双向关联
if (refAnnotation.bidirectional()) {
linkBidirectional(entity, actualEntity, refAnnotation.reverseField());
}
}
} else if (refType == RefType.LIST) {
// 处理实体列表引用
List<SynchronizableEntity> refList = (List<SynchronizableEntity>) field.get(entity);
if (refList != null) {
List<SynchronizableEntity> actualList = new ArrayList<>();
for (SynchronizableEntity refItem : refList) {
SynchronizableEntity actualItem = findActualEntity(refItem, targetClass);
actualList.add(actualItem);
// 建立双向关联
if (refAnnotation.bidirectional()) {
linkBidirectional(entity, actualItem, refAnnotation.reverseField());
}
}
field.set(entity, actualList);
}
}
} catch (Exception e) {
Log.e("DataAssociator", "处理正向引用失败: " + e.getMessage());
}
}
}
/**
* 处理单个实体的反向引用
* 查找所有引用当前实体的其他实体，并更新其引用
*/
private void processReverseReferences(SynchronizableEntity entity) {
Class<?> entityClass = entity.getClass();
Map<String, Class<?>> reverseMappings = reverseMappingCache.get(entityClass);
if (reverseMappings == null) return;
for (Map.Entry<String, Class<?>> entry : reverseMappings.entrySet()) {
String reverseFieldName = entry.getKey();
Class<?> sourceClass = entry.getValue();
SynchronizedList<?> sourceList = dataStore.getCollection(sourceClass);
if (sourceList == null) continue;
for (Object sourceObj : sourceList.getViewList()) {
try {
updateReverseReference((SynchronizableEntity) sourceObj, reverseFieldName, entity);
} catch (Exception e) {
Log.e("DataAssociator", "处理反向引用失败: " + e.getMessage());
}
}
}
}
/**
* 更新单个反向引用
*/
private void updateReverseReference(SynchronizableEntity sourceEntity,
String reverseFieldName,
SynchronizableEntity targetEntity)
throws Exception {
Field reverseField = sourceEntity.getClass().getDeclaredField(reverseFieldName);
reverseField.setAccessible(true);
RefTo refAnnotation = reverseField.getAnnotation(RefTo.class);
if (refAnnotation == null) return;
if (refAnnotation.type() == RefType.SINGLE) {
// 更新单值反向引用
SynchronizableEntity currentRef = (SynchronizableEntity) reverseField.get(sourceEntity);
if (currentRef != null && currentRef.getId().equals(targetEntity.getId())) {
reverseField.set(sourceEntity, targetEntity);
}
} else if (refAnnotation.type() == RefType.LIST) {
// 更新列表反向引用
List<SynchronizableEntity> refList = (List<SynchronizableEntity>) reverseField.get(sourceEntity);
if (refList != null) {
for (int i = 0; i < refList.size(); i++) {
SynchronizableEntity refItem = refList.get(i);
if (refItem.getId().equals(targetEntity.getId())) {
refList.set(i, targetEntity);
}
}
}
}
}
/**
* 建立双向关联
*/
private void linkBidirectional(SynchronizableEntity source,
SynchronizableEntity target,
String reverseFieldName) {
try {
Field reverseField = target.getClass().getDeclaredField(reverseFieldName);
reverseField.setAccessible(true);
RefTo refAnnotation = reverseField.getAnnotation(RefTo.class);
if (refAnnotation == null) return;
if (refAnnotation.type() == RefType.SINGLE) {
// 单值关联：直接设置引用
reverseField.set(target, source);
} else if (refAnnotation.type() == RefType.LIST) {
// 列表关联：添加到引用列表
List<SynchronizableEntity> list = (List<SynchronizableEntity>) reverseField.get(target);
if (list == null) {
list = new ArrayList<>();
reverseField.set(target, list);
}
if (!list.contains(source)) {
list.add(source);
}
}
} catch (Exception e) {
Log.e("DataAssociator", "建立双向关联失败: " + e.getMessage());
}
}
/**
* 查找实际实体（使用ID映射缓存）
*/
private SynchronizableEntity findActualEntity(SynchronizableEntity refEntity, Class<?> targetClass) {
Map<Integer, SynchronizableEntity> idMap = idMapCache.get(targetClass);
if (idMap != null) {
SynchronizableEntity actualEntity = idMap.get(refEntity.getId());
if (actualEntity != null) {
return actualEntity;
}
}
return refEntity; // 找不到时返回原始引用
}
/**
* 获取类的所有字段（包括父类）
*/
private List<Field> getAllFields(Class<?> clazz) {
List<Field> fields = new ArrayList<>();
while (clazz != null && clazz != Object.class) {
Collections.addAll(fields, clazz.getDeclaredFields());
clazz = clazz.getSuperclass();
}
return fields;
}
/**
* 刷新ID映射缓存（数据变更后调用）
*/
public void refreshIdMapCache() {
buildIdMapCache();
}
}
================================================================================
/* 文件路径: DataPreserver/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.data.SynchronizableEntity;
import com.example.kucun2.entity.data.SynchronizedList;
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.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
public class DataExporter {
private final DataStore dataStore;
// 将 ExportData 改为静态内部类
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_bancai> dingdan_bancais;
public List<Kucun> kucuns;
public List<Zujian> zujians;
public List<User> users;
public List<Jinhuo> jinhuos;
}
public DataExporter(DataStore dataStore) {
this.dataStore = dataStore;
}
public String exportToJson() {
ExportData exportData = new ExportData();
exportData.bancais = new ArrayList<>(dataStore.bancais.getViewList());
exportData.caizhis = new ArrayList<>(dataStore.caizhis.getViewList());
exportData.mupis = new ArrayList<>(dataStore.mupis.getViewList());
exportData.chanpins = new ArrayList<>(dataStore.chanpins.getViewList());
exportData.chanpin_zujians = new ArrayList<>(dataStore.chanpin_zujians.getViewList());
exportData.dingdans = new ArrayList<>(dataStore.dingdans.getViewList());
exportData.dingdan_chanpins = new ArrayList<>(dataStore.dingdan_chanpins.getViewList());
exportData.dingdan_bancais = new ArrayList<>(dataStore.dingdan_bancais.getViewList());
exportData.kucuns = new ArrayList<>(dataStore.kucuns.getViewList());
exportData.zujians = new ArrayList<>(dataStore.zujians.getViewList());
exportData.users = new ArrayList<>(dataStore.users.getViewList());
exportData.jinhuos = new ArrayList<>(dataStore.jinhuos.getViewList());
Gson gson = new GsonBuilder()
.registerTypeAdapter(SynchronizableEntity.class, new SmartEntitySerializer())
.setPrettyPrinting()
.create();
return gson.toJson(exportData);
}
public void importFromJson(String json, Context context) {
// 使用 TypeToken 正确获取 ExportData 类型
Type exportDataType = new TypeToken<ExportData>(){}.getType();
Gson gson = new GsonBuilder()
.registerTypeAdapter(SynchronizableEntity.class, new SmartEntityDeserializer())
.create();
ExportData importData = gson.fromJson(json, exportDataType);
clearDataStorePreservingDefaults();
addAllToDataStore(importData);
saveToPreferences(context, json);
}
private void clearDataStorePreservingDefaults() {
preserveDefaults(dataStore.bancais);
preserveDefaults(dataStore.caizhis);
preserveDefaults(dataStore.mupis);
preserveDefaults(dataStore.chanpins);
preserveDefaults(dataStore.chanpin_zujians);
preserveDefaults(dataStore.dingdans);
preserveDefaults(dataStore.dingdan_chanpins);
preserveDefaults(dataStore.dingdan_bancais);
preserveDefaults(dataStore.kucuns);
preserveDefaults(dataStore.zujians);
preserveDefaults(dataStore.users);
preserveDefaults(dataStore.jinhuos);
}
private <T extends SynchronizableEntity> void preserveDefaults(SynchronizedList<T> list) {
List<T> preserved = new ArrayList<>();
for (T entity : list.getViewList()) {
if (entity.getId() == -1) {
preserved.add(entity);
}
}
list.getViewList().clear();
list.getViewList().addAll(preserved);
}
private void addAllToDataStore(ExportData data) {
if (data.bancais != null) dataStore.bancais.getViewList().addAll(data.bancais);
if (data.caizhis != null) dataStore.caizhis.getViewList().addAll(data.caizhis);
if (data.mupis != null) dataStore.mupis.getViewList().addAll(data.mupis);
if (data.chanpins != null) dataStore.chanpins.getViewList().addAll(data.chanpins);
if (data.chanpin_zujians != null) dataStore.chanpin_zujians.getViewList().addAll(data.chanpin_zujians);
if (data.dingdans != null) dataStore.dingdans.getViewList().addAll(data.dingdans);
if (data.dingdan_chanpins != null) dataStore.dingdan_chanpins.getViewList().addAll(data.dingdan_chanpins);
if (data.dingdan_bancais != null) dataStore.dingdan_bancais.getViewList().addAll(data.dingdan_bancais);
if (data.kucuns != null) dataStore.kucuns.getViewList().addAll(data.kucuns);
if (data.zujians != null) dataStore.zujians.getViewList().addAll(data.zujians);
if (data.users != null) dataStore.users.getViewList().addAll(data.users);
if (data.jinhuos != null) dataStore.jinhuos.getViewList().addAll(data.jinhuos);
}
public void saveToPreferences(Context context, String json) {
SharedPreferences prefs = context.getSharedPreferences("DataStore", Context.MODE_PRIVATE);
prefs.edit().putString("jsonData", json).apply();
}
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);
}
}
private static class SmartEntitySerializer implements JsonSerializer<SynchronizableEntity> {
@Override
public JsonElement serialize(SynchronizableEntity src, Type type, JsonSerializationContext context) {
JsonObject json = new JsonObject();
json.addProperty("id", src.getId());
json.addProperty("className", src.getClass().getName());
// 其他字段序列化...
return json;
}
}
private static class SmartEntityDeserializer implements JsonDeserializer<SynchronizableEntity> {
@Override
public SynchronizableEntity deserialize(JsonElement json, Type type, JsonDeserializationContext context) throws JsonParseException {
JsonObject obj = json.getAsJsonObject();
String className = obj.get("className").getAsString();
try {
Class<?> clazz = Class.forName(className);
SynchronizableEntity entity = (SynchronizableEntity) clazz.newInstance();
entity.setId(obj.get("id").getAsInt());
// 其他字段反序列化...
return entity;
} catch (Exception e) {
throw new JsonParseException(e);
}
}
}
}
================================================================================
/* 文件路径: 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.Information;
import com.example.kucun2.entity.data.*;
import com.example.kucun2.function.MyAppFunction;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.List;
/**
* 重构后的数据加载器：使用ApiClient处理网络请求
*/
public class DataLoader {
private static final String TAG = "DataLoader";
private final DataStore dataStore;
private final DataAssociator dataAssociator;
// private final DataPreserver dataPreserver;
public DataLoader(DataStore dataStore, DataAssociator dataAssociator
) {
this.dataStore = dataStore;
this.dataAssociator = dataAssociator;
}
public void loadAllData(Context context, LoadDataCallback callback) {
if (Looper.myLooper() != Looper.getMainLooper()) {
throw new IllegalStateException("必须在主线程调用Data.loadAllData");
}
// dataPreserver.ensurePreservedObjects();
String url = MyAppFunction.getApiUrl("url_all");
Log.d(TAG, "开始加载数据, URL: " + url);
// 使用ApiClient的get方法发送请求
ApiClient.get(url, new ApiClient.ApiCallback<DataLoader.AllDataResponse>(AllDataResponse.class) {
@Override
public void onSuccess(AllDataResponse allData) {
Log.d(TAG, "数据加载成功");
parseAndAssignData(allData, callback);
}
@Override
public void onError(int statusCode, String error) {
Log.e(TAG, "数据加载失败: " + error + ", 状态码: " + statusCode);
new Handler(Looper.getMainLooper()).post(callback::onFailure);
}
});
}
private void parseAndAssignData(AllDataResponse allData, LoadDataCallback callback) {
try {
mergeAllLists(allData);
dataAssociator.automaticAssociation();
callback.onSuccess();
} catch (Exception e) {
Log.e(TAG, "数据处理异常: " + e.getMessage());
callback.onFailure();
}
}
private void mergeAllLists(AllDataResponse allData) {
mergeList(dataStore.bancais, allData.bancais);
mergeList(dataStore.caizhis, allData.caizhis);
mergeList(dataStore.mupis, allData.mupis);
mergeList(dataStore.chanpins, allData.chanpins);
mergeList(dataStore.chanpin_zujians, allData.chanpin_zujians);
mergeList(dataStore.dingdans, allData.dingdans);
mergeList(dataStore.dingdan_chanpins, allData.dingdan_chanpins);
mergeList(dataStore.dingdan_bancais, allData.dingdan_bancais);
mergeList(dataStore.kucuns, allData.kucuns);
mergeList(dataStore.zujians, allData.zujians);
mergeList(dataStore.users, allData.users);
mergeList(dataStore.jinhuos, allData.jinhuos);
}
private <T extends SynchronizableEntity> void mergeList(
SynchronizedList<T> targetList,
List<T> newList) {
if (newList == null) return;
targetList.mergeList(newList);
}
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_bancai> dingdan_bancais;
public List<Kucun> kucuns;
public List<Zujian> zujians;
public List<User> users;
public List<Jinhuo> jinhuos;
}
}
================================================================================
/* 文件路径: DataPreserver/dataManagement.java */
package com.example.kucun2.DataPreserver;
public class dataManagement {
}
================================================================================
/* 文件路径: DataPreserver/DataPreserver.java */
//package com.example.kucun2.DataPreserver;
//
//import android.util.Log;
//import com.example.kucun2.entity.*;
//import com.example.kucun2.entity.data.SynchronizableEntity;
//import com.example.kucun2.entity.data.SynchronizedList;
//import java.lang.reflect.Field;
//import java.util.ArrayList;
//import java.util.Date;
//import java.util.List;
//
///**
// * 数据预置器：确保每个实体集合中都包含一个特殊的预置对象（ID=-1）
// * 用于表示"无选择"或"默认"状态，并为UI层提供空值处理方案
// */
//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.dingdan_chanpins, Dingdan_Chanpin.class);
// addIfMissing(dataStore.dingdan_bancais, Dingdan_bancai.class);
// addIfMissing(dataStore.kucuns, Kucun.class);
// addIfMissing(dataStore.zujians, Zujian.class);
// addIfMissing(dataStore.users, User.class);
// addIfMissing(dataStore.jinhuos, Jinhuo.class);
// }
//
// /**
// * 检查并添加缺失的预置对象
// * @param list 实体集合
// * @param clazz 实体类型
// */
// private <T extends SynchronizableEntity> void addIfMissing(SynchronizedList<T> list, Class<T> clazz) {
//// // 如果集合中不存在预置对象，则创建并添加
//// if (!containsPreservedObject(list)) {
//// list.getViewList().add(createPreservedInstance(clazz));
//// }
// }
//
// /**
// * 检查集合中是否已存在预置对象（ID=-1）
// * @param list 待检查的实体集合
// * @return 存在返回true，否则false
// */
// private <T extends SynchronizableEntity> boolean containsPreservedObject(SynchronizedList<T> list) {
//// for (T entity : list.getViewList()) {
//// if (entity.getId() == -1) {
//// return true; // 找到预置对象
//// }
//// }
//// return false; // 未找到预置对象
// }
//
// /**
// * 创建预置对象实例
// * @param clazz 实体类型
// * @return 创建的预置对象实例
// */
// public <T extends SynchronizableEntity> T createPreservedInstance(Class<T> clazz) {
//// try {
//// T instance = clazz.newInstance(); // 通过反射创建实例
//// setDefaultFieldValues(instance); // 设置默认字段值
//// instance.setId(-1); // 标记为预置对象
//// return instance;
//// } catch (Exception e) {
//// Log.e("DataPreserver", "创建实例失败: " + clazz.getName(), e);
//// throw new RuntimeException("无法创建实例", e); // 创建失败抛出运行时异常
//// }
// }
//
// /**
// * 为预置对象设置合理的默认值
// * @param instance 待设置的实体实例
// */
// private <T extends SynchronizableEntity> void setDefaultFieldValues(T instance) {
//// try {
//// // 遍历实体的所有字段
//// for (Field field : instance.getClass().getDeclaredFields()) {
//// field.setAccessible(true); // 允许访问私有字段
//// Class<?> type = field.getType(); // 字段类型
//// String fieldName = field.getName(); // 字段名
////
//// // 跳过id字段（单独处理）
//// if ("id".equals(fieldName)) continue;
////
//// // 根据字段类型设置默认值
//// 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)) {
//// // 实体引用字段：设置为同类型的预置对象
//// SynchronizableEntity preserved = getPreservedEntity(type);
//// field.set(instance, preserved);
//// } else if (List.class.isAssignableFrom(type)) {
//// // 列表字段：初始化为空列表
//// field.set(instance, new ArrayList<>());
//// }
//// }
//// } catch (Exception e) {
//// Log.e("DataPreserver", "设置默认值失败", e);
//// }
// }
//
// /**
// * 获取指定类型的预置对象
// * @param type 目标实体类型
// * @return 已存在的预置对象或null
// */
// private SynchronizableEntity getPreservedEntity(Class<?> type) {
// SynchronizedList<?> list = dataStore.dataCollectionMap.get(type);
// if (list != null) {
// // 在目标集合中查找预置对象
// for (SynchronizableEntity entity : list.getViewList()) {
// if (entity.getId() == -1) {
// return entity;// }
// }
// }
// return null; // 未找到返回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.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 核心数据存储中心，负责：
* 1. 集中管理所有业务实体集合
* 2. 提供类型安全的线程安全数据访问
* 3. 通过映射表实现类类型到数据集合的快速查找
*/
public class DataStore {
// ================= 业务实体集合 =================
// 每个集合使用SynchronizedList包装，保证线程安全
/** 板材集合 */
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_bancai> dingdan_bancais = new SynchronizedList<>(Dingdan_bancai.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);
// ================= 类类型映射表 =================
/**
* 实体类到数据集合的映射表
* Key: 实体类的Class对象
* Value: 对应的SynchronizedList实例
* 使用ConcurrentHashMap保证并发安全
*/
public final Map<Class<?>, SynchronizedList<?>> dataCollectionMap = new ConcurrentHashMap<>();
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_bancai.class, dingdan_bancais);
registerCollection(Kucun.class, kucuns);
registerCollection(Zujian.class, zujians);
registerCollection(User.class, users);
registerCollection(Jinhuo.class, jinhuos);
}
/**
* 注册实体类与数据集合的关联关系
* @param <T> 实体类型（需继承SynchronizableEntity）
* @param entityClass 实体类的Class对象
* @param list 对应的同步列表实例
*/
private <T extends SynchronizableEntity> void registerCollection(
Class<T> entityClass,
SynchronizedList<T> list
) {
dataCollectionMap.put(entityClass, list);
}
/**
* 根据实体类获取对应的数据集合（泛型方法）
* @param <T> 实体类型
* @param entityClass 实体类的Class对象
* @return 对应的同步列表实例
* @throws IllegalArgumentException 当类型未注册时抛出异常
*/
@SuppressWarnings("unchecked")
public <T extends SynchronizableEntity> SynchronizedList<T> getCollection(
Class<?> entityClass
) {
SynchronizedList<?> list = dataCollectionMap.get(entityClass);
if (list == null) {
throw new IllegalArgumentException("未注册的数据类型: " + entityClass.getName());
}
return (SynchronizedList<T>) list;
}
}
data接受外界新数据和更新数据时当同步成功后处理改实例的依赖关系并触发回调通知外界
最新发布
本文介绍了解决JSONObject重复引用问题的办法，即先将JSONObject转换成String，再转换回JSONObject。给出示例代码，通过特定方法处理包含重复引用的JSONObject对象bussinessData。
扫一扫
526
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
