package com
.example
.kucun2
.entity
.data;
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
.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
.Field;
import
java.lang.reflect
.Type;
import
java.util
.*;
import
okhttp3
.Call;
import
okhttp3
.Callback;
import
okhttp3
.OkHttpClient;
import
okhttp3
.Request;
import
okhttp3
.Response;
public class Data {
// 数据集合声明（保持原有属性名不变）
public static SynchronizedList<Bancai> bancais = new SynchronizedList<>(Bancai
.class);
public static SynchronizedList<Caizhi> caizhis = new SynchronizedList<>(Caizhi
.class);
public static SynchronizedList<Mupi> mupis = new SynchronizedList<>(Mupi
.class);
public static SynchronizedList<Chanpin> chanpins = new SynchronizedList<>(Chanpin
.class);
public static SynchronizedList<Chanpin_Zujian> chanpin_zujians = new SynchronizedList<>(Chanpin_Zujian
.class);
public static SynchronizedList<Dingdan> dingdans = new SynchronizedList<>(Dingdan
.class);
public static SynchronizedList<Dingdan_Chanpin> dingdan_chanpins = new SynchronizedList<>(Dingdan_Chanpin
.class);
public static SynchronizedList<Dingdan_chanpin_zujian> Dingdan_chanpin_zujians = new SynchronizedList<>(Dingdan_chanpin_zujian
.class);
public static SynchronizedList<Kucun> kucuns = new SynchronizedList<>(Kucun
.class);
public static SynchronizedList<Zujian> zujians = new SynchronizedList<>(Zujian
.class);
public static SynchronizedList<User> users = new SynchronizedList<>(Bancai
.class);
public static SynchronizedList<Jinhuo> jinhuoList = new SynchronizedList<>(Bancai
.class);
public static SynchronizedList<Jinhuo> jinhuos = new SynchronizedList<>(Bancai
.class);
private static final Gson gson = new Gson();
private static
OkHttpClient client ;
private static final String TAG = "DataLoader";
public static void loadAllData(Context context, LoadDataCallback callback) {
if (Looper
.myLooper() != Looper
.getMainLooper()) {
throw new IllegalStateException("Data
.loadAllData must be called on main thread");
}
// 确保使用安全的客户端
if (client == null) {
client= MyAppFnction
.getClient();
}
//禁用同步
SynchronizableEntity
.setSyncEnabled(false);
String
url = MyAppFnction
.getStringResource("string", "
url") +
MyAppFnction
.getStringResource("string", "
url_all");
Log
.d("
url", "loadAllData
: " +
url);
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);
if (callback != null)safeCallback(callback, false);
}
@Override
public void onResponse(Call call, Response response) throws IOException {
if (!response
.isSuccessful()) {
Log
.e(TAG, "
Unexpected response code
: " + response
.code());
if (callback != null) safeCallback(callback, false);
return;
}
String responseData = response
.body()
.string();
SynchronizableEntity
.setSyncEnabled(true);
ensurePreservedObjects();
parseAndAssignData(responseData, context, callback);
}
});
}
// 解析并赋值数据
private static void parseAndAssignData(String jsonData, Context context, LoadDataCallback callback) {
// 创建包含所有数据类型的TypeToken
ensurePreservedObjects();
Type informationType = new TypeToken<Information<AllDataResponse>>(){}
.getType();
Information<AllDataResponse> information = gson
.fromJson(jsonData, informationType);
Log
.e(TAG, "Invalid response data"+jsonData);
if (information == null || information
.getData() == null || information
.getStatus() != 200) {
Log
.e(TAG, "Invalid response data");
if (callback != null) callback
.onFailure();
return;
}
AllDataResponse allData = information
.getData();
SafeLogger
.d("data","数据："+gson
.toJson(allData));
safeInitializeList(allData
.bancais);
safeInitializeList(allData
.caizhis);
safeInitializeList(allData
.mupis);
safeInitializeList(allData
.chanpins);
safeInitializeList(allData
.chanpin_zujians);
safeInitializeList(allData
.dingdans);
safeInitializeList(allData
.dingdan_chanpins);
safeInitializeList(allData
.Dingdan_chanpin_zujians);
safeInitializeList(allData
.kucuns);
safeInitializeList(allData
.zujians);
safeInitializeList(allData
.users);
safeInitializeList(allData
.jinhuos);
SafeLogger
.d("data","数据：非空"+gson
.toJson(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(jinhuoList, allData
.jinhuos);
SafeLogger
.d("data","数据：data
.bancais"+gson
.toJson(Data
.bancais));
// 在设置引用关系前关闭同步
SynchronizableEntity
.setSyncEnabled(false);
Log
.d("DataParse", "开始解析JSON数据");
resolveReferences();
Log
.d("DataParse", "解析完成，实体关系建立");
// 为所有实体设置正确状态（已存在服务器）
setAllEntitiesState(SynchronizableEntity
.SyncState
.MODIFIED);
ensurePreservedObjects();
// 启用同步
SynchronizableEntity
.setSyncEnabled(true);
if (callback != null) callback
.onSuccess();
}
public static void safeCallback(LoadDataCallback callback, boolean success) {
new Handler(Looper
.getMainLooper())
.post(() -> {
if (success) {
callback
.onSuccess();
} else {
callback
.onFailure();
}
});
}
// 更新列表内容但保持对象引用不变
private static <T extends SynchronizableEntity> void updateList(List<T> existingList, List<T> newList) {
if (newList == null) return;
// 创建临时列表保留预置对象
List<T> preservedObjects = new ArrayList<>();
for (T item
: existingList) {
if (item != null && item
.isPreservedObject()) {
preservedObjects
.add(item);
}
}
// 清除原有列表并添加保留对象
existingList
.clear();
existingList
.addAll(preservedObjects);
// 添加新数据，跳过预置对象的ID
for (T newItem
: newList) {
if (newItem
.getId() != null && newItem
.getId() != -1) {
existingList
.add(newItem);
}
}
}
// 添加确保预置对象存在的
方法
private static void ensurePreservedObjects() {
if (!containsPreservedObject(bancais)) bancais
.add(createInstance(Bancai
.class));
if (!containsPreservedObject(caizhis)) caizhis
.add(createInstance(Caizhi
.class));
if (!containsPreservedObject(mupis)) mupis
.add(createInstance(Mupi
.class));
if (!containsPreservedObject(chanpins)) chanpins
.add(createInstance(Chanpin
.class));
if (!containsPreservedObject(chanpin_zujians)) chanpin_zujians
.add(createInstance(Chanpin_Zujian
.class));
if (!containsPreservedObject(dingdans)) dingdans
.add(createInstance(Dingdan
.class));
if (!containsPreservedObject(kucuns)) kucuns
.add(createInstance(Kucun
.class));
if (!containsPreservedObject(zujians)) zujians
.add(createInstance(Zujian
.class));
if (!containsPreservedObject(Dingdan_chanpin_zujians)) Dingdan_chanpin_zujians
.add(createInstance(Dingdan_chanpin_zujian
.class));
if (!containsPreservedObject(dingdan_chanpins)) dingdan_chanpins
.add(createInstance(Dingdan_Chanpin
.class));
if (!containsPreservedObject(jinhuos)) jinhuos
.add(createInstance(Jinhuo
.class));
if (!containsPreservedObject(users)) users
.add(createInstance(User
.class));
// 为其他需要预置对象的列表添加
...
}
// 检查列表是否包含预置对象
private static <T extends SynchronizableEntity> boolean containsPreservedObject(List<T> list) {
for (T item
: list) {
if (item != null && item
.isPreservedObject()) {
Log
.d(TAG, "containsPreservedObject
: "+item
.getId());
item= (T) createInstance(item
.getClass());
return true;
}
}
return !list
.isEmpty();
}
/**
* 根据传入的Class对象创建对应类型的实例
* @param clazz 目标类型对应的Class对象
* @param <T> 目标类型泛型参数
* @return 指定类型的实例
*/
public static <T> T createInstance(Class<T> clazz) {
try {
// 通过反射调用无参构造函数创建实例
T g=clazz
.getDeclaredConstructor()
.newInstance();
// Log
.d("g",""+g);
Field[] fields = clazz
.getDeclaredFields();
for (Field f
: fields
) {
f
.setAccessible(true);
if(f
.getType()
.equals(String
.class)){
f
.set(g,"无");
}
if(f
.getType()
.equals(Integer
.class)||f
.getType()
.equals(Double
.class)){
f
.set(g,-1);
}
if (f
.getType()
.equals(Date
.class)){
f
.set(g,new Date());
}
Log
.d("g",""+f
.get(g));
}
clazz
.getMethod("setId",Integer
.class)
.invoke(g,-1);
clazz
.getMethod("setState",
SynchronizableEntity
. SyncState
.class)
.invoke(g,SynchronizableEntity
.SyncState
.PRESERVED);
return g;
} catch (Exception e) {
Log
.d(TAG, "createInstance
: "+e
.getLocalizedMessage());
throw new RuntimeException("创建实例失败
: " + clazz
.getName(), e);
}
}
// // 创建预置板材对象
// private static<T> T createPreservedBancai(Class<T> t) {
// Bancai preserved = new Bancai();
// preserved
.setId(-1);
// preserved
.setState(SynchronizableEntity
.SyncState
.PRESERVED);
// return preserved;
// }
// 解析对象间的引用关系（使用ID关联）
private static void resolveReferences() {
// 创建ID到对象的映射
Map<Integer, Bancai> bancaiMap = createIdMap(bancais);
Map<Integer, Caizhi> caizhiMap = createIdMap(caizhis);
Map<Integer, Mupi> mupiMap = createIdMap(mupis);
Map<Integer, Chanpin> chanpinMap = createIdMap(chanpins);
Map<Integer, Zujian> zujianMap = createIdMap(zujians);
Map<Integer, Dingdan> dingdanMap = createIdMap(dingdans);
Map<Integer, Kucun> kucunMap = createIdMap(kucuns);
Log
.d("RefResolution", "开始解析实体关系
...");
// 解析Bancai引用
for (Bancai bancai
: bancais) {
if (bancai
.getCaizhi() != null) {
bancai
.setCaizhi(caizhiMap
.get(bancai
.getCaizhi()
.getId()));
}
if (bancai
.getMupi1() != null) {
bancai
.setMupi1(mupiMap
.get(bancai
.getMupi1()
.getId()));
}
if (bancai
.getMupi2() != null) {
bancai
.setMupi2(mupiMap
.get(bancai
.getMupi2()
.getId()));
}
}
// 解析Kucun引用
for (Kucun kucun
: kucuns) {
if(kucun==null)break;
if (kucun
.getBancai() != null) {
kucun
.setBancai(bancaiMap
.get(kucun
.getBancai()
.getId()));
}
}
// 解析订单相关的嵌套对象
for (Dingdan_Chanpin dc
: dingdan_chanpins) {
if(dc==null)break;
if (dc
.getDingdan() != null) {
dc
.setDingdan(dingdanMap
.get(dc
.getDingdan()
.getId()));
}
if (dc
.getChanpin() != null) {
dc
.setChanpin(chanpinMap
.get(dc
.getChanpin()
.getId()));
}
}
// 解析产品相关的嵌套对象
for (Chanpin_Zujian cz
: chanpin_zujians) {
if(cz==null)break;
if (cz
.getChanpin() != null) {
cz
.setChanpin(chanpinMap
.get(cz
.getChanpin()
.getId()));
}
if (cz
.getZujian() != null) {
cz
.setZujian(zujianMap
.get(cz
.getZujian()
.getId()));
}
if (cz
.getBancai() != null) {
cz
.setBancai(bancaiMap
.get(cz
.getBancai()
.getId()));
}
}
// 解析库存关联
for (Kucun k
: kucuns) {
if(k==null)break;
if (k
.getBancai() != null) {
k
.setBancai(bancaiMap
.get(k
.getBancai()
.getId()));
}
}
// 添加缺失的实体关系解析
for (Dingdan_chanpin_zujian dm
: Dingdan_chanpin_zujians) {
if (dm
.getZujian() != null) {
// 确保组件和板材关联
dm
.setZujian(chanpin_zujians
.stream()
.filter(cz -> cz
.getId()
.equals(dm
.getZujian()
.getId()))
.findFirst()
.orElse(null));
if (dm
.getBancai() != null) {
dm
.setBancai(bancais
.stream()
.filter(b -> b
.getId()
.equals(dm
.getBancai()
.getId()))
.findFirst()
.orElse(null));
}
}
}
}
// 创建ID到对象的映射
private static <T extends EntityClassGrassrootsid> Map<Integer, T> createIdMap(List<T> list) {
return createSafeIdMap(list);
}
// 回调接口
public interface LoadDataCallback {
void onSuccess();
void onFailure();
}
// 确保列表不为null
private static <T> void safeInitializeList(List<T> list) {
if (list == null) {
list = new ArrayList<>();
}
}
// 安全创建ID映射
private static <T extends EntityClassGrassrootsid> Map<Integer, T> createSafeIdMap(List<T> list) {
Map<Integer, T> map = new HashMap<>();
if (list != null) {
for (T item
: safeIterable(list)) {
if (item != null && item
.getId() != null) {
map
.put(item
.getId(), item);
}
}
}
return map;
}
// 安全迭代
方法（处理空集合）
private static <T> Iterable<T> safeIterable(List<T> list) {
return list != null ? list
: Collections
.emptyList();
}
// 内部类用于解析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;
}
// 新增
方法：设置所有实体状态
private static void setAllEntitiesState(SynchronizableEntity
.SyncState state) {
setListState(bancais, state);
setListState(caizhis, state);
setListState(mupis, state);
setListState(Dingdan_chanpin_zujians, state);
setListState(dingdans, state);
setListState(chanpins, state);
setListState(chanpin_zujians, state);
setListState(zujians, state);
setListState(jinhuoList, state);
setListState(kucuns, state);
setListState(users, state);
setListState(caizhis, state);
//
... 其他列表
}
private static <T extends SynchronizableEntity> void setListState(List<T> list, SynchronizableEntity
.SyncState state) {
for (T entity
: list) {
entity
.setState(state);
}
}
} E FATAL EXCEPTION
: OkHttp Dispatcher
Process
: com
.example
.kucun2, PID
: 10514
java.lang.RuntimeException
: 鍒涘缓瀹炰緥澶辫触
: com
.example
.kucun2
.entity
.Bancai
at com
.example
.kucun2
.entity
.data
.Data
.createInstance(Data
.java:260)
at com
.example
.kucun2
.entity
.data
.Data
.ensurePreservedObjects(Data
.java:191)
at com
.example
.kucun2
.entity
.data
.Data
.-$$Nest$smensurePreservedObjects(Unknown Source
:0)
at com
.example
.kucun2
.entity
.data
.Data$1
.onResponse(Data
.java:81)
at
okhttp3
.internal
.connection
.RealCall$AsyncCall
.run(RealCall
.kt
:519)
at
java.util
.concurrent
.ThreadPoolExecutor
.runWorker(ThreadPoolExecutor
.java:1145)
at
java.util
.concurrent
.ThreadPoolExecutor$Worker
.run(ThreadPoolExecutor
.java:644)
at
java.lang.Thread
.run(Thread
.java:1042)
Caused by
: java.lang.IllegalArgumentException: field com
.example
.kucun2
.entity
.Bancai
.houdu has type
java.lang.Double, got
java.lang.Integer
at
java.lang.reflect
.Field
.set(Native Method)
at com
.example
.kucun2
.entity
.data
.Data
.createInstance(Data
.java:242)
... 7 more
扫一扫
4575
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
