package com.example.kucun2.entity.data;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
* 支持数据变更自动同步的泛型集合类
* 基于SynchronizableEntity的事件机制实现数据变更自动同步
*
* @param <T> 必须是SynchronizableEntity或其子类
*/
public class SynchronizedList<T extends SynchronizableEntity> implements List<T> {
// 使用ArrayList作为底层存储
private final List<T> list = new ArrayList<>();
// 实体变更监听器
private final EntityChangeListener<T> entityChangeListener = new EntityChangeListener<>();
@Override
public int size() {
return list.size();
}
@Override
public boolean isEmpty() {
return list.isEmpty();
}
@Override
public boolean contains(Object o) {
return list.contains(o);
}
@Override
public Iterator<T> iterator() {
return new SyncedIterator<>(list.iterator(), entityChangeListener);
}
@Override
public Object[] toArray() {
return list.toArray();
}
@Override
public <E> E[] toArray(E[] a) {
return list.toArray(a);
}
// 添加元素时注册监听器
@Override
public boolean add(T element) {
if (element != null) {
element.addPropertyChangeListener(entityChangeListener);
}
return list.add(element);
}
// 移除元素时注销监听器
@Override
public boolean remove(Object o) {
if (o instanceof SynchronizableEntity) {
((SynchronizableEntity) o).removePropertyChangeListener(entityChangeListener);
}
return list.remove(o);
}
@Override
public boolean containsAll(Collection<?> c) {
return list.containsAll(c);
}
// 批量添加时逐个注册监听器
@Override
public boolean addAll(Collection<? extends T> c) {
for (T element : c) {
if (element != null) {
element.addPropertyChangeListener(entityChangeListener);
}
}
return list.addAll(c);
}
@Override
public boolean addAll(int index, Collection<? extends T> c) {
for (T element : c) {
if (element != null) {
element.addPropertyChangeListener(entityChangeListener);
}
}
return list.addAll(index, c);
}
// 批量移除时逐个注销监听器
@Override
public boolean removeAll(Collection<?> c) {
for (Object o : c) {
if (o instanceof SynchronizableEntity) {
((SynchronizableEntity) o).removePropertyChangeListener(entityChangeListener);
}
}
return list.removeAll(c);
}
@Override
public boolean retainAll(Collection<?> c) {
// 先移除未保留元素的监听器
for (T element : list) {
if (!c.contains(element)) {
element.removePropertyChangeListener(entityChangeListener);
}
}
return list.retainAll(c);
}
// 清空集合时移除所有监听器
@Override
public void clear() {
for (T element : list) {
element.removePropertyChangeListener(entityChangeListener);
}
list.clear();
}
@Override
public T get(int index) {
return list.get(index);
}
// 替换元素时更新监听器
@Override
public T set(int index, T element) {
T oldElement = list.get(index);
if (oldElement != null) {
oldElement.removePropertyChangeListener(entityChangeListener);
}
if (element != null) {
element.addPropertyChangeListener(entityChangeListener);
}
return list.set(index, element);
}
// 在指定位置添加元素时注册监听器
@Override
public void add(int index, T element) {
if (element != null) {
element.addPropertyChangeListener(entityChangeListener);
}
list.add(index, element);
}
// 移除元素时注销监听器
@Override
public T remove(int index) {
T removed = list.remove(index);
if (removed != null) {
removed.removePropertyChangeListener(entityChangeListener);
}
return removed;
}
@Override
public int indexOf(Object o) {
return list.indexOf(o);
}
@Override
public int lastIndexOf(Object o) {
return list.lastIndexOf(o);
}
@Override
public ListIterator<T> listIterator() {
return new SyncedListIterator<>(list.listIterator(), entityChangeListener);
}
@Override
public ListIterator<T> listIterator(int index) {
return new SyncedListIterator<>(list.listIterator(index), entityChangeListener);
}
@Override
public List<T> subList(int fromIndex, int toIndex) {
return list.subList(fromIndex, toIndex);
}
/**
* 内部实体变更监听器
* 监听属性变化并触发同步操作
*/
private static class EntityChangeListener<T extends SynchronizableEntity>
implements PropertyChangeListener {
@Override
public void propertyChange(PropertyChangeEvent evt) {
@SuppressWarnings("unchecked")
T entity = (T) evt.getSource();
entity.sync(); // 触发同步操作
}
}
/**
* 增强的Iterator实现
* 移除元素时自动注销监听器
*/
private static class SyncedIterator<T extends SynchronizableEntity> implements Iterator<T> {
private final Iterator<T> iterator;
private final EntityChangeListener<T> listener;
private T current;
public SyncedIterator(Iterator<T> iterator, EntityChangeListener<T> listener) {
this.iterator = iterator;
this.listener = listener;
}
@Override
public boolean hasNext() {
return iterator.hasNext();
}
@Override
public T next() {
current = iterator.next();
return current;
}
@Override
public void remove() {
if (current != null) {
current.removePropertyChangeListener(listener);
}
iterator.remove();
}
}
/**
* 增强的ListIterator实现
* 支持添加/设置元素时的监听器管理
*/
private static class SyncedListIterator<T extends SynchronizableEntity>
implements ListIterator<T> {
private final ListIterator<T> iterator;
private final EntityChangeListener<T> listener;
private T lastReturned;
public SyncedListIterator(ListIterator<T> iterator, EntityChangeListener<T> listener) {
this.iterator = iterator;
this.listener = listener;
}
@Override
public boolean hasNext() {
return iterator.hasNext();
}
@Override
public T next() {
lastReturned = iterator.next();
return lastReturned;
}
@Override
public boolean hasPrevious() {
return iterator.hasPrevious();
}
@Override
public T previous() {
lastReturned = iterator.previous();
return lastReturned;
}
@Override
public int nextIndex() {
return iterator.nextIndex();
}
@Override
public int previousIndex() {
return iterator.previousIndex();
}
@Override
public void remove() {
if (lastReturned != null) {
lastReturned.removePropertyChangeListener(listener);
}
iterator.remove();
}
@Override
public void set(T e) {
if (lastReturned != null) {
lastReturned.removePropertyChangeListener(listener);
}
if (e != null) {
e.addPropertyChangeListener(listener);
}
iterator.set(e);
lastReturned = e;
}
@Override
public void add(T e) {
if (e != null) {
e.addPropertyChangeListener(listener);
}
iterator.add(e);
}
}
}package com.example.kucun2.entity.data;
import android.content.Context;
import android.util.Log;
import com.example.kucun2.entity.*;
import com.example.kucun2.function.MyAppFnction;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
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> chanpinZujians = new SynchronizedList<>(Chanpin_Zujian.class);
public static SynchronizedList<Dingdan> dingdans = new SynchronizedList<>(Dingdan.class);
public static SynchronizedList<Dingdan_Chanpin> dingdanChanpins = new SynchronizedList<>(Dingdan_Chanpin.class);
public static SynchronizedList<Dingdan_Bancai> dingdanBancais = new SynchronizedList<>(Dingdan_Bancai.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<>(User.class);
public static SynchronizedList<Jinhuo> jinhuoList = new SynchronizedList<>(Jinhuo.class);
private static final Gson gson = new Gson();
private static final OkHttpClient client = new OkHttpClient();
private static final String TAG = "DataLoader";
// 加载所有数据的方法
public static void loadAllData(Context context, LoadDataCallback callback) {
// 开始批量模式
for (SynchronizedList<?> list : getAllSyncLists()) {
list.beginBatch();
}
String url = MyAppFnction.getStringResource("String", "url") +
MyAppFnction.getStringResource("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);
if (callback != null) callback.onFailure();
}
@Override
public void onResponse(Call call, Response response) throws IOException {
parseAndAssignData(response.body().string(), context,callback);
// 结束批量模式(会触发一次全量同步)
for (SynchronizedList<?> list : getAllSyncLists()) {
list.endBatch();
}
if (callback != null) callback.onSuccess();
}
});
}
// 获取所有同步列表的方法
private static List<SynchronizedList<?>> getAllSyncLists() {
return Arrays.asList(bancais, caizhis, mupis, chanpins,
chanpinZujians, dingdans, dingdanChanpins,
dingdanBancais, kucuns, zujians, users, jinhuoList);
}
// 解析并赋值数据
private static void parseAndAssignData(String jsonData, Context context, LoadDataCallback callback) {
// 创建包含所有数据类型的TypeToken
Type informationType = new TypeToken<Information<AllDataResponse>>(){}.getType();
Information<AllDataResponse> information = gson.fromJson(jsonData, informationType);
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();
// 赋值到对应的列表(使用安全方法保持已有引用)
updateList(bancais, allData.bancais);
updateList(caizhis, allData.caizhis);
updateList(mupis, allData.mupis);
updateList(chanpins, allData.chanpins);
updateList(chanpinZujians, allData.chanpin_zujians);
updateList(dingdans, allData.dingdans);
updateList(dingdanChanpins, allData.dingdan_chanpins);
updateList(dingdanBancais, allData.dingdan_bancais);
updateList(kucuns, allData.kucuns);
updateList(zujians, allData.zujians);
updateList(users, allData.users);
updateList(jinhuoList, allData.jinhuos);
resolveReferences();
if (callback != null) callback.onSuccess();
}
// 更新列表内容但保持对象引用不变
private static <T> void updateList(List<T> existingList, List<T> newList) {
if (newList == null) return;
existingList.clear();
for (T item : newList) {
existingList.add(item); // 会被包装成代理对象
}
}
// 解析对象间的引用关系(使用ID关联)
// 改进的引用解析方法
private static void resolveReferences() {
// 创建全局对象映射
Map<Integer, EntityClassGrassrootsid> globalMap = new HashMap<>();
// 填充全局映射表
addToGlobalMap(globalMap, bancais);
addToGlobalMap(globalMap, caizhis);
addToGlobalMap(globalMap, mupis);
addToGlobalMap(globalMap, chanpins);
addToGlobalMap(globalMap, zujians);
addToGlobalMap(globalMap, dingdans);
addToGlobalMap(globalMap, kucuns);
addToGlobalMap(globalMap, users);
// 解析所有实体的引用
resolveListReferences(bancais, globalMap);
resolveListReferences(kucuns, globalMap);
resolveListReferences(dingdanChanpins, globalMap);
resolveListReferences(chanpinZujians, globalMap);
resolveListReferences(dingdanBancais, globalMap);
resolveListReferences(jinhuoList, globalMap);
}
// 添加对象到全局映射表
private static void addToGlobalMap(Map<Integer, EntityClassGrassrootsid> map,
SynchronizedList<?> list) {
for (Object item : list) {
Object original = getOriginalFromList(list, item);
if (original instanceof EntityClassGrassrootsid) {
EntityClassGrassrootsid entity = (EntityClassGrassrootsid) original;
map.put(entity.getId(), entity);
}
}
}
// 解析列表中所有实体的引用
private static void resolveListReferences(SynchronizedList<?> list,
Map<Integer, EntityClassGrassrootsid> globalMap) {
for (Object item : list) {
Object original = getOriginalFromList(list, item);
resolveEntityReferences(original, globalMap);
}
}
// 安全获取原始对象(无需类型转换)
@SuppressWarnings("unchecked")
private static <T> T getOriginalFromList(SynchronizedList<?> list, Object item) {
try {
// 使用反射调用getOriginal方法
Method getOriginal = list.getClass().getMethod("getOriginal", Object.class);
return (T) getOriginal.invoke(list, item);
} catch (Exception e) {
Log.e("Data", "Failed to get original object", e);
return (T) item;
}
}
//解析集合中的引用
private static void resolveCollectionReferences(Collection<?> collection,
Map<Integer, EntityClassGrassrootsid> globalMap) {
for (Object item : collection) {
if (item instanceof EntityClassGrassrootsid) {
EntityClassGrassrootsid ref = (EntityClassGrassrootsid) item;
EntityClassGrassrootsid resolved = globalMap.get(ref.getId());
if (resolved != null && ref.getClass().isInstance(resolved)) {
// 注意:直接替换集合元素需要特殊处理
// 实际项目应考虑使用CopyOnWrite集合或创建新集合
if (collection instanceof List) {
int index = ((List<?>) collection).indexOf(ref);
if (index != -1) {
try {
((List<Object>) collection).set(index, resolved);
} catch (Exception e) {
Log.e("Data", "Failed to update collection", e);
}
}
}
}
}
}
}
// 解析单个实体的引用
private static void resolveEntityReferences(Object entity,
Map<Integer, EntityClassGrassrootsid> globalMap) {
if (entity == null) return;
// 如果是代理对象则获取原始对象
Object target = entity;
if (entity instanceof SynchronizedList.IProxyHandler) {
target = ((SynchronizedList.IProxyHandler) entity).getOriginal();
}
Class<?> clazz = entity.getClass();
for (Field field : clazz.getDeclaredFields()) {
try {
field.setAccessible(true);
// 处理基本类型字段
if (EntityClassGrassrootsid.class.isAssignableFrom(field.getType())) {
EntityClassGrassrootsid ref = (EntityClassGrassrootsid) field.get(entity);
if (ref != null && ref.getId() != null) {
EntityClassGrassrootsid resolved = globalMap.get(ref.getId());
if (resolved != null && field.getType().isInstance(resolved)) {
field.set(entity, resolved);
}
}
}
// 处理集合类型字段
else if (Collection.class.isAssignableFrom(field.getType())) {
Collection<?> collection = (Collection<?>) field.get(entity);
if (collection != null) {
resolveCollectionReferences(collection, globalMap);
}
}
} catch (Exception e) {
Log.e("Data", "Error resolving field: " + field.getName(), e);
}
}
}
// 创建ID到对象的映射
private static <T extends EntityClassGrassrootsid> Map<Integer, T> createIdMap(List<T> list) {
Map<Integer, T> map = new HashMap<>();
for (T item : list) {
map.put(item.getId(), item);
}
return map;
}
// 回调接口
public interface LoadDataCallback {
void onSuccess();
void onFailure();
}
private static void resolveFields(Object entity, Map<Integer, EntityClassGrassrootsid> globalMap) {
for (Field field : entity.getClass().getDeclaredFields()) {
if (EntityClassGrassrootsid.class.isAssignableFrom(field.getType())) {
try {
field.setAccessible(true);
EntityClassGrassrootsid ref = (EntityClassGrassrootsid) field.get(entity);
if (ref != null) {
EntityClassGrassrootsid resolved = globalMap.get(ref.getId());
if (resolved != null && field.getType().isAssignableFrom(resolved.getClass())) {
field.set(entity, resolved);
}
}
} catch (Exception e) {
Log.e("Data", "Error resolving reference", e);
}
}
}
}
// 内部类用于解析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_Bancai> dingdan_bancais;
public List<Kucun> kucuns;
public List<Zujian> zujians;
public List<User> users;
public List<Jinhuo> jinhuos;
}
}