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.example.kucun2.function.TLSUtils;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.io.IOException;
import java.lang.reflect.Type;
import java.util.;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.X509TrustManager;
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_chanpin_zujian> dingdanBancais = 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);
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 (client == null) {
client= MyAppFnction.getClient();
}
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);
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());
if (callback != null) callback.onFailure();
return;
}
String responseData = response.body().string();
parseAndAssignData(responseData, context, callback);
}
});
}
// 解析并赋值数据
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);
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();
// 赋值到对应的列表（使用安全方法保持已有引用）
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();
existingList.addAll(newList);
}
// 解析
对象间的引用关系（使用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);
// 解析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.getBancai() != null) {
kucun.setBancai(bancaiMap.get(kucun.getBancai().getId()));
}
}
// 解析订单相关的嵌套
对象
for (Dingdan_Chanpin dc : dingdanChanpins) {
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 : chanpinZujians) {
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.getBancai() != null) {
k.setBancai(bancaiMap.get(k.getBancai().getId()));
}
}
}
// 创建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();
}
// 内部类用于解析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_bancais;
public List<Kucun> kucuns;
public List<Zujian> zujians;
public List<User> users;
public List<Jinhuo> jinhuos;
}
}package com.example.kucun2.entity.data;
import android.util.Log;
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<>();
public SynchronizedList(Class T ) {
}
// 实体变更监听器
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);
}
Log.d(“z”,“element”);
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©;
}
// 批量
添加时逐个注册监听器
@Override
public boolean addAll(Collection<? extends T> c) {
for (T element : c) {
if (element != null) {
element.addPropertyChangeListener(entityChangeListener);
}
}
return list.addAll©;
}
@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©;
}
@Override
public boolean retainAll(Collection<?> c) {
// 先移除未保留元素的监听器
for (T element : list) {
if (!c.contains(element)) {
element.removePropertyChangeListener(entityChangeListener);
}
}
return list.retainAll©;
}
// 清空
集合时移除所有监听器
@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.util.Log;
import com.example.kucun2.entity.Information;
import com.example.kucun2.function.MyAppFnction;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.HashMap;
import java.util.Map;
public abstract class SynchronizableEntity implements EntityClassGrassrootsid {
public enum SyncState { NEW, MODIFIED, DELETED }
SyncState state = SyncState.NEW;
// 设置状态的方法
public void setState(SyncState state) {
this.state = state;
}
// 使用标准属性变更支持类
private transient PropertyChangeSupport changeSupport = new PropertyChangeSupport(this);
// 属性缓存（可选，用于优化）
private final Map<String, Object> propertyCache = new HashMap<>();
//
添加属性变更监听器
public void addPropertyChangeListener(PropertyChangeListener listener) {
if (changeSupport == null) {
changeSupport = new PropertyChangeSupport(this);
}
changeSupport.addPropertyChangeListener(listener);
}
// 移除属性变更监听器
public void removePropertyChangeListener(PropertyChangeListener listener) {
if (changeSupport != null) {
changeSupport.removePropertyChangeListener(listener);
}
}
// 触发属性变更通知（子类在setter中调用）
protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
if (changeSupport != null && changeSupport.hasListeners(propertyName)) {
// 更新属性缓存（可选）
propertyCache.put(propertyName, newValue);
// 触发变更事件
changeSupport.firePropertyChange(propertyName, oldValue, newValue);
}
}
// 获取属性当前值（可选，用于setter中获取旧值）
protected <T> T getCachedProperty(String propertyName) {
return (T) propertyCache.get(propertyName);
}
// 初始化属性缓存（可选，在构造函数中调用）
protected void initPropertyCache() {
// 初始化所有字段到缓存
for (java.lang.reflect.Field field : getClass().getDeclaredFields()) {
try {
field.setAccessible(true);
propertyCache.put(field.getName(), field.get(this));
} catch (Exception e) {
// 忽略初始化异常
}
}
}
/**
*
添加url
* @param type 操作增删改查
* @return 返回相对url
*/
public String getEndpoint(String type){
//从String.xml获取url
Log.d("getEndpoint", "getEndpoint: "+"url_"+type+"_"+this.getClass().getSimpleName().toLowerCase());
return MyAppFnction.getStringResource("string","url_"+type+"_"+this.getClass().getSimpleName().toLowerCase());
}
public void sync() {
if (this.state == null) return;
try {
switch (this.state) {
case NEW:
createToServer();
break;
case MODIFIED:
updateToServer();
break;
case DELETED:
deleteFromServer();
break;
}
} catch (Exception e) {
Log.e("SyncError", "Sync failed for " + getClass().getSimpleName(), e);
}
}
/**
* 创建实体到后端
*/
private void createToServer() {
String endpoint = MyAppFnction.getStringResource("string", "url") + getEndpoint("add");
Information<SynchronizableEntity> requestData = new Information<SynchronizableEntity>();
// 使用Volley、Retrofit或OkHttp执行POST请求
// 伪代码示例：
ApiClient.post(endpoint, requestData, new ApiClient.ApiCallback<SynchronizableEntity>() {
@Override
public void onSuccess(Information<SynchronizableEntity> e) {
// 解析服务器返回的ID
Log.d("onSuccess",e.toJson());
// String serverId = parseServerId(response);
// if (serverId != null) {
// // 更新本地ID
// setId(serverId); // 需要实体实现setId方法
// }
state = SyncState.MODIFIED;
}
});
}
/**
* 更新实体到后端
*/
private void updateToServer() {
String endpoint = MyAppFnction.getStringResource("string", "url") +
getEndpoint("update") + "/" + getId(); // 获取实体ID
Information<SynchronizableEntity> requestData = new Information<SynchronizableEntity>();
ApiClient.post(endpoint, requestData, new ApiClient.ApiCallback<SynchronizableEntity>() {
@Override
public void onSuccess(Information<SynchronizableEntity> e) {
// 解析服务器返回的ID
Log.d("onSuccess",e.toJson());
// String serverId = parseServerId(response);
// if (serverId != null) {
// // 更新本地ID
// setId(serverId); // 需要实体实现setId方法
// }
// state = SyncState.MODIFIED;
}
});
}
/**
* 从后端删除实体
*/
private void deleteFromServer() {
String endpoint = MyAppFnction.getStringResource("string", "url") +
getEndpoint("delete") + "/" + getId();
ApiClient.delete(endpoint, new ApiClient.ApiCallback<SynchronizableEntity>() {
@Override
public void onSuccess(Information<SynchronizableEntity> e) {
Log.d("SyncDelete", "Successfully deleted " + getId());
}
});
}
/**
* 将实体转换为请求映射
*/
protected Information<SynchronizableEntity> toRequestMap(){
return Information.newSuccess(this);
}
}
初始加载数据时自动同步一直在出发
本文介绍了一个简单的Java泛型集合操作示例，演示如何创建并填充一个包含MemberByKeyWord实体的List集合。通过实例化实体类并设置属性值，再将实体对象添加到集合中，展示了循环插入多个对象时的注意事项。
扫一扫
5414
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
