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:
delete
FromServer
();
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 delete
FromServer
() {
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集合框架中的迭代器接口Iterator的基本概念及其使用方法。详细解释了迭代器接口的三个核心方法：hasNext用于判断是否还有下一个元素；next用于获取下一个元素；remove则允许在迭代过程中删除元素。
扫一扫
1040
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
