package com
.example
.kucun2
.entity
.data;
import
android.content.Context;
import
android.util
.Log;
import com
.example
.kucun2
.entity
.*;
import com
.example
.kucun2
.functi
on.MyAppFncti
on;
import com
.google
.gs
on.Gs
on;
import com
.google
.gs
on.reflect
.TypeToken;
import
java.io
.IOExcepti
on;
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
.Resp
onse;
public class Data {
// 数据集合声明（保持原有属性名不变）
public static Synchr
onizedList<Bancai> bancais = new Synchr
onizedList<>
(Bancai
.class
);
public static Synchr
onizedList<Caizhi> caizhis = new Synchr
onizedList<>
(Caizhi
.class
);
public static Synchr
onizedList<Mupi> mupis = new Synchr
onizedList<>
(Mupi
.class
);
public static Synchr
onizedList<Chanpin> chanpins = new Synchr
onizedList<>
(Chanpin
.class
);
public static Synchr
onizedList<Chanpin_Zujian> chanpinZujians = new Synchr
onizedList<>
(Chanpin_Zujian
.class
);
public static Synchr
onizedList<Dingdan> dingdans = new Synchr
onizedList<>
(Dingdan
.class
);
public static Synchr
onizedList<Dingdan_Chanpin> dingdanChanpins = new Synchr
onizedList<>
(Dingdan_Chanpin
.class
);
public static Synchr
onizedList<Dingdan_Bancai> dingdanBancais = new Synchr
onizedList<>
(Dingdan_Bancai
.class
);
public static Synchr
onizedList<Kucun> kucuns = new Synchr
onizedList<>
(Kucun
.class
);
public static Synchr
onizedList<Zujian> zujians = new Synchr
onizedList<>
(Zujian
.class
);
public static Synchr
onizedList<User> users = new Synchr
onizedList<>
(User
.class
);
public static Synchr
onizedList<Jinhuo> jinhuoList = new Synchr
onizedList<>
(Jinhuo
.class
);
private static final Gs
on gs
on = new Gs
on();
private static final OkHttpClient client = new OkHttpClient
();
private static final
String TAG = "DataLoader";
// 加载所有数据的方法
public static void loadAllData
(Context context, LoadDataCallback callback
) {
// 开始批量模式
for
(Synchr
onizedList<?> list : getAllSyncLists
()) {
list
.beginBatch
();
}
String url = MyAppFncti
on.getStringResource
("
String", "url"
) +
MyAppFncti
on.getStringResource
("
String", "url_all"
);
Request request = new Request
.Builder
()
.url
(url
)
.build
();
client
.newCall
(request
).enqueue
(new Callback
() {
@Override
public void
onFailure
(Call call, IOExcepti
on e
) {
Log
.e
(TAG, "Failed to load data", e
);
if
(callback !=
null) callback
.onFailure
();
}
@Override
public void
onResp
onse
(Call call, Resp
onse resp
onse
) throws IOExcepti
on {
parseAndAssignData
(resp
onse
.body
().string(),
context,callback
);
// 结束批量模式（会触发一次全量同步）
for
(Synchr
onizedList<?> list : getAllSyncLists
()) {
list
.endBatch
();
}
if
(callback !=
null) callback
.onSuccess
();
}
}
);
}
// 获取所有同步列表的方法
private static List<Synchr
onizedList<?>> getAllSyncLists
() {
return Arrays
.asList
(bancais, caizhis, mupis, chanpins,
chanpinZujians, dingdans, dingdanChanpins,
dingdanBancais, kucuns, zujians, users, jinhuoList
);
}
// 解析并赋值数据
private static void parseAndAssignData
(String js
onData,
Context context, LoadDataCallback callback
) {
// 创建包含所有数据类型的TypeToken
Type informati
onType = new TypeToken<Informati
on<AllDataResp
onse>>
(){}
.getType
();
Informati
on<AllDataResp
onse> informati
on = gs
on.fromJs
on(js
onData, informati
onType
);
if
(informati
on ==
null || informati
on.getData
() ==
null || informati
on.getStatus
() != 200
) {
Log
.e
(TAG, "Invalid resp
onse data"
);
if
(callback !=
null) callback
.onFailure
();
return;
}
AllDataResp
onse allData = informati
on.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
);
resolve
References
();
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 resolve
References
() {
// 创建全局对象映射
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
);
// 解析所有实体的引用
resolveList
References
(bancais, globalMap
);
resolveList
References
(kucuns, globalMap
);
resolveList
References
(dingdanChanpins, globalMap
);
resolveList
References
(chanpinZujians, globalMap
);
resolveList
References
(dingdanBancais, globalMap
);
resolveList
References
(jinhuoList, globalMap
);
}
// 添加对象到全局映射表
private static void addToGlobalMap
(Map<
Integer, EntityClassGrassrootsid> map,
Synchr
onizedList<?> 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 resolveList
References
(Synchr
onizedList<?> list,
Map<
Integer, EntityClassGrassrootsid> globalMap
) {
for
(Object item : list
) {
Object original = getOriginalFromList
(list, item
);
resolveEntity
References
(original, globalMap
);
}
}
// 安全获取原始对象（无需类型转换）
@SuppressWarnings
("unchecked"
)
private static <T> T getOriginalFromList
(Synchr
onizedList<?> list,
Object item
) {
try {
// 使用反射调用getOriginal方法
Method getOriginal = list
.getClass
().getMethod
("getOriginal",
Object.class
);
return
(T
) getOriginal
.invoke
(list, item
);
} catch
(Excepti
on e
) {
Log
.e
("Data", "Failed to get original
object", e
);
return
(T
) item;
}
}
//解析集合中的引用
private static void resolveCollecti
onReferences
(Collecti
on<?> collecti
on,
Map<
Integer, EntityClassGrassrootsid> globalMap
) {
for
(Object item : collecti
on) {
if
(item instanceof EntityClassGrassrootsid
) {
EntityClassGrassrootsid ref =
(EntityClassGrassrootsid
) item;
EntityClassGrassrootsid resolved = globalMap
.get
(ref
.getId
());
if
(resolved !=
null && ref
.getClass
().isInstance
(resolved
)) {
// 注意：直接替换集合元素需要特殊处理
// 实际项目应考虑使用Copy
OnWrite集合或创建新集合
if
(collecti
on instanceof List
) {
int index =
((List<?>
) collecti
on).indexOf
(ref
);
if
(index != -1
) {
try {
((List<
Object>
) collecti
on).set
(index, resolved
);
} catch
(Excepti
on e
) {
Log
.e
("Data", "Failed to update collecti
on", e
);
}
}
}
}
}
}
}
// 解析单个实体的引用
private static void resolveEntity
References
(Object entity,
Map<
Integer, EntityClassGrassrootsid> globalMap
) {
if
(entity ==
null) return;
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
(Collecti
on.class
.isAssignableFrom
(field
.getType
())) {
Collecti
on<?> collecti
on =
(Collecti
on<?>
) field
.get
(entity
);
if
(collecti
on !=
null) {
resolveCollecti
onReferences
(collecti
on, globalMap
);
}
}
} catch
(Excepti
on 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
(Excepti
on e
) {
Log
.e
("Data", "Error resolving
reference", e
);
}
}
}
}
// 内部类用于解析JS
ON响应
public static class AllDataResp
onse {
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;
}
}package com
.example
.kucun2
.entity
.data;
import
android.util
.Log;
import
androidx
.annotati
on.N
onNull;
import com
.google
.gs
on.Gs
on;
import
java.io
.IOExcepti
on;
import
java.lang.reflect
.Method;
import
java.lang.reflect
.ParameterizedType;
import
java.lang.reflect
.Type;
import
java.util
.ArrayList;
import
java.util
.Arrays;
import
java.util
.Collecti
on;
import
java.util
.HashMap;
import
java.util
.HashSet;
import
java.util
.Iterator;
import
java.util
.List;
import
java.util
.ListIterator;
import
java.util
.Map;
import
java.util
.Set;
import okhttp3
.Call;
import okhttp3
.Callback;
import okhttp3
.MediaType;
import okhttp3
.OkHttpClient;
import okhttp3
.Request;
import okhttp3
.RequestBody;
import okhttp3
.Resp
onse;
/**
* 支持数据变更自动同步的泛型集合类
* @param <T> 继承自 Synchr
onizableEntity 的实体类型
*/
public class Synchr
onizedList<T extends Synchr
onizableEntity> implements List<T> {
private final List<T> list = new ArrayList<>
();
private final OkHttpClient client = new OkHttpClient
();
private static final Gs
on gs
on = new Gs
on();
private static final MediaType JS
ON = MediaType
.get
("applicati
on/js
on; charset=utf-8"
);
private final Class<T> entityClass; // 类型标记
// 添加批量操作模式标志
private boolean batchMode = false;
// 属性变更监听器
private final List<PropertyChangeListener<T>> listeners = new ArrayList<>
();
public Synchr
onizedList
(Class<T> entityClass
) {
Type superClass = getClass
().getGenericSuperclass
();
ParameterizedType type =
(ParameterizedType
) superClass;
Type[] typeArgs = type
.getActualTypeArguments
();
this
.entityClass =
(Class<T>
) typeArgs[0];
}
// 安全的类型转换方法
private T safeCast
(Object o
) {
if
(o !=
null && entityClass
.isInstance
(o
)) {
return entityClass
.cast
(o
);
}
return
null;
}
public
interface PropertyChangeListener<T> {
void
onPropertyChange
(T entity,
String propertyName,
Object oldValue,
Object newValue
);
}
public void addPropertyChangeListener
(PropertyChangeListener<T> listener
) {
listeners
.add
(listener
);
}
public void removePropertyChangeListener
(PropertyChangeListener<T> listener
) {
listeners
.remove
(listener
);
}
// 添加方法来获取原始对象
@SuppressWarnings
("unchecked"
)
public T getOriginal
(T proxy
) {
if
(proxy ==
null) return
null;
// 检查是否为代理对象
if
(java.lang.reflect
.Proxy
.isProxyClass
(proxy
.getClass
())) {
try {
java.lang.reflect
.Invocati
onHandler handler =
java.lang.reflect
.Proxy
.getInvocati
onHandler
(proxy
);
if
(handler instanceof IProxyHandler
) {
Object original =
((IProxyHandler
) handler
).getOriginal
();
// 安全类型检查
if
(entityClass
.isInstance
(original
)) {
return
(T
) original;
}
}
} catch
(Excepti
on e
) {
Log
.e
("Synchr
onizedList", "Failed to get proxy handler", e
);
}
}
return proxy;
}
/**
* 同步实体到后端
*
* @param entity 要同步的实体
*/
private void syncEntity
(T entity
) {
if
(batchMode
) return;
String operati
on = "add";
T originalEntity = getOriginal
(entity
);
String endpo
int = originalEntity
.getEndpo
int(operati
on);
String js
on = gs
on.toJs
on(originalEntity
);
RequestBody body = RequestBody
.create
(js
on, JS
ON);
Request request = new Request
.Builder
()
.url
(endpo
int)
.method
(getHttpMethod
(operati
on), body
)
.build
();
client
.newCall
(request
).enqueue
(new Callback
() {
@Override
public void
onFailure
(@N
onNull Call call, @N
onNull IOExcepti
on e
) {
Log
.e
("Synchr
onizedList", "同步失败: " + entity
.getClass
().getSimpleName
(), e
);
}
@Override
public void
onResp
onse
(@N
onNull Call call, @N
onNull Resp
onse resp
onse
) {
if
(!resp
onse
.isSuccessful
()) {
Log
.e
("Synchr
onizedList", "同步失败: " +
resp
onse
.code
() + " - " + resp
onse
.message
());
}
resp
onse
.close
();
}
}
);
}
// 添加用于批量操作的方法
public void beginBatch
() {
this
.batchMode = true;
}
public void endBatch
() {
this
.batchMode = false;
// 批量结束后触发一次全量同步
syncAllEntities
();
}
private void syncAllEntities
() {
for
(T entity : list
) {
syncEntity
(entity
);
}
}
private
String getHttpMethod
(String operati
on) {
switch
(operati
on) {
case "add":
return "POST";
case "update":
return "PUT";
case "delete":
return "DELETE";
default:
return "POST";
}
}
// 获取类实现的所有接口（包括父类接口）
private Class<?>[] get
Interfaces
(Class<?> clazz
) {
Set<Class<?>>
interfaces = new HashSet<>
();
while
(clazz !=
null) {
interfaces
.addAll
(Arrays
.asList
(clazz
.get
Interfaces
()));
clazz = clazz
.getSuperclass
();
}
return
interfaces
.toArray
(new Class<?>[0]
);
}
/**
* 创建代理对象，用于监听属性变更
*/
// 优化 createProxy 方法
private T createProxy
(T original
) {
if
(original ==
null) return
null;
if
(!entityClass
.isInstance
(original
)) {
throw new IllegalArgumentExcepti
on("Invalid entity type"
);
}
// 为原始对象创建代理
return
(T
) java.lang.reflect
.Proxy
.newProxyInstance
(
original
.getClass
().getClassLoader
(),
get
Interfaces
(original
.getClass
()),
new EntityProxyHandler
(original
)
);
// if
(!entityClass
.isInstance
(original
)) {
// throw new IllegalArgumentExcepti
on("Invalid entity type"
);
// }
// // 这里使用动态代理模式监听setter方法调用
// return
(T
) java.lang.reflect
.Proxy
.newProxyInstance
(
// original
.getClass
().getClassLoader
(),
// original
.getClass
().get
Interfaces
(),
//
(proxy, method, args
) -> {
// // 只拦截setter方法
// if
(method
.getName
().startsWith
("set"
) && args
.length == 1
) {
//
String propertyName = method
.getName
().sub
string(3
);
// propertyName = propertyName
.sub
string(0, 1
).toLowerCase
() + propertyName
.sub
string(1
);
//
// // 获取旧值
//
Object oldValue = original
.getClass
()
//
.getMethod
("get" + propertyName
.sub
string(0, 1
).toUpperCase
() + propertyName
.sub
string(1
))
//
.invoke
(original
);
//
// // 调用原始方法
//
Object result = method
.invoke
(original, args
);
//
// // 触发监听器
// for
(PropertyChangeListener<T> listener : listeners
) {
// listener
.onPropertyChange
(original, propertyName, oldValue, args[0]
);
// }
//
// // 自动同步到后端
// syncEntity
(original
);
// return result;
// }
// return method
.invoke
(original, args
);
// }
//
);
}
// 以下是List接口的实现
@Override
public
int size
() {
return list
.size
();
}
@Override
public boolean isEmpty
() {
return list
.isEmpty
();
}
@Override
public boolean c
ontains
(Object o
) {
return list
.c
ontains
(o
);
}
@N
onNull
@Override
public Iterator<T> iterator
() {
return list
.iterator
();
}
@N
onNull
@Override
public
Object[] toArray
() {
return list
.toArray
();
}
@N
onNull
@Override
public <T1> T1[] toArray
(@N
onNull T1[] a
) {
return list
.toArray
(a
);
}
@Override
public boolean add
(T t
) {
T proxy = createProxy
(t
);
boolean result = list
.add
(proxy
);
if
(!batchMode
) {
syncEntity
(proxy
);
}
return result; // 添加时创建代理
}
@Override
public boolean remove
(Object o
) {
T entity = safeCast
(o
);
if
(entity !=
null) {
syncEntity
((T
) entity
); // 删除前同步
}
return list
.remove
(o
);
}
@Override
public boolean c
ontainsAll
(@N
onNull Collecti
on<?> c
) {
return list
.c
ontainsAll
(c
);
}
@Override
public boolean addAll
(@N
onNull Collecti
on<? extends T> c
) {
boolean modified = false;
for
(T t : c
) {
modified |= add
(t
);
}
return modified;
}
@Override
public boolean addAll
(int index, @N
onNull Collecti
on<? extends T> c
) {
for
(T t : c
) {
add
(index++, t
);
}
return true;
}
@Override
public boolean removeAll
(@N
onNull Collecti
on<?> c
) {
for
(Object o : c
) {
T entity = safeCast
(o
);
if
(entity !=
null) {
syncEntity
(entity
);
}
}
return list
.removeAll
(c
);
}
@Override
public boolean retainAll
(@N
onNull Collecti
on<?> c
) {
List<T> toRemove = new ArrayList<>
();
for
(T t : list
) {
if
(!c
.c
ontains
(t
)) {
toRemove
.add
(t
);
}
}
// 使用安全转换
for
(T entity : toRemove
) {
syncEntity
(entity
);
}
return list
.retainAll
(c
);
}
@Override
public void clear
() {
for
(T t : list
) {
syncEntity
(t
); // 清空前同步
}
list
.clear
();
}
@Override
public T get
(int index
) {
return list
.get
(index
);
}
@Override
public T set
(int index, T element
) {
T old = list
.set
(index, createProxy
(element
));
if
(old !=
null) {
syncEntity
(old
); // 替换旧元素前同步
}
return old;
}
@Override
public void add
(int index, T element
) {
list
.add
(index, createProxy
(element
));
}
@Override
public T remove
(int index
) {
T removed = list
.remove
(index
);
if
(removed !=
null) {
syncEntity
(removed
); // 删除前同步
}
return removed;
}
@Override
public
int indexOf
(Object o
) {
return list
.indexOf
(o
);
}
@Override
public
int lastIndexOf
(Object o
) {
return list
.lastIndexOf
(o
);
}
@N
onNull
@Override
public ListIterator<T> listIterator
() {
return list
.listIterator
();
}
@N
onNull
@Override
public ListIterator<T> listIterator
(int index
) {
return list
.listIterator
(index
);
}
@N
onNull
@Override
public List<T> subList
(int fromIndex,
int toIndex
) {
return list
.subList
(fromIndex, toIndex
);
}
// 触发属性变更通知
// 添加类型安全的属性监听
private void firePropertyChange
(T entity,
String propertyName,
Object oldValue,
Object newValue
) {
if
(oldValue !=
null && newValue !=
null && oldValue
.equals
(newValue
)) {
return; // 值未变化时不触发监听
}
for
(PropertyChangeListener<T> listener : listeners
) {
try {
listener
.onPropertyChange
(entity, propertyName, oldValue, newValue
);
} catch
(Excepti
on e
) {
Log
.e
("Synchr
onizedList", "Listener error", e
);
}
}
}
// 修改代理处理器以支持获取原始对象
/*
完整的 EntityProxyHandler
实现
*/
private class EntityProxyHandler implements IProxyHandler,
java.lang.reflect
.Invocati
onHandler {
private final T original;
private final Map<
String,
Object> propertyValues = new HashMap<>
();
public EntityProxyHandler
(T original
) {
this
.original = original;
// 初始化属性缓存
for
(Method method : original
.getClass
().getMethods
()) {
if
(method
.getName
().startsWith
("get"
) && method
.getParameterCount
() == 0
) {
try {
String propName = method
.getName
().sub
string(3
);
propName = Character
.toLowerCase
(propName
.charAt
(0
)) + propName
.sub
string(1
);
propertyValues
.put
(propName, method
.invoke
(original
));
} catch
(Excepti
on e
) {
Log
.e
("ProxyHandler", "Failed to cache property", e
);
}
}
}
}
@Override
public T getOriginal
() {
return original;
}
@Override
public
Object invoke
(Object proxy, Method method,
Object[] args
) throws Throwable {
String methodName = method
.getName
();
// 处理 setter 方法
if
(methodName
.startsWith
("set"
) && args !=
null && args
.length == 1
) {
String propertyName = methodName
.sub
string(3
);
propertyName = Character
.toLowerCase
(propertyName
.charAt
(0
)) + propertyName
.sub
string(1
);
Object oldValue = propertyValues
.get
(propertyName
);
Object newValue = args[0];
// 调用原始方法
Object result = method
.invoke
(original, args
);
propertyValues
.put
(propertyName, newValue
);
// 触发监听
firePropertyChange
(original, propertyName, oldValue, newValue
);
// 非批量模式下自动同步
if
(!batchMode
) {
syncEntity
(original
);
}
return result;
}
// 特殊处理 getOriginal 方法
if
("getOriginal"
.equals
(methodName
)) {
return original;
}
// 处理 getter 方法（使用缓存）
if
(methodName
.startsWith
("get"
) && method
.getParameterCount
() == 0
) {
String propertyName = methodName
.sub
string(3
);
propertyName = Character
.toLowerCase
(propertyName
.charAt
(0
)) + propertyName
.sub
string(1
);
return propertyValues
.getOrDefault
(propertyName, method
.invoke
(original
));
}
return method
.invoke
(original, args
);
}
private
Object getPropertyValue
(String propertyName
) {
String getterName = "get" + propertyName
.sub
string(0, 1
).toUpperCase
() + propertyName
.sub
string(1
);
try {
Method getter = original
.getClass
().getMethod
(getterName
);
return getter
.invoke
(original
);
} catch
(Excepti
on e
) {
Log
.e
("ProxyHandler", "Failed to get property value: " + propertyName, e
);
return
null;
}
}
}
// 在 Synchr
onizedList 类中添加
private
interface IProxyHandler {
Object getOriginal
();
}
}app/all返回js
on数据：{
“status”: “200”,
“text”: “success”,
“data”: {
“bancais”: [
{
“houdu”: 15,
“mupi1”: {
“id”: 1
},
“mupi2”: {
“id”: 1
},
“caizhi”: {
“id”: 1
},
“kucun”: {
“id”: 1
},
“id”: 1
},
{
“houdu”: 15,
“mupi1”: {
“id”: 2
},
“mupi2”: {
“id”: 2
},
“caizhi”: {
“id”: 1
},
“kucun”: {
“id”: 2
},
“id”: 2
}
],
“dingdans”: [
{
“dingdanChanpinZujian”: [
],
"number": "直接入库",
"id": 1,
"dingdanChanpin": [
{"id":1}
]
}
],
"mupis": [
{
"name": "千和板",
"id": 1,
"you":
null
},
{
"name": "桃花芯",
"id": 2,
"you":
null
},
{
"name": "杉木",
"id": 3,
"you":
null
}
],
"chanpins": [
{
"chanpinZujian": [
{
"id": 1
}
],
"bianhao": "直接入库",
"id": 1,
"dingdanChanpin": [
{"id":1}
]
}
],
"kucuns": [
{
"bancai": {
"Id": 1
},
"shuliang": 12,
"id": 1
},
{
"bancai": {
"Id": 2
},
"shuliang": 32,
"id": 2
}
],
"chanpin_zujians": [
{
"chanpin": {
"Id": 1
},
"bancai": {
"id": 1
},
"id": 1,
"zujian": {
"Id": 1
},
"
one_howmany": 15
}
],
"zujians": [
{
"chanpinZujian": [
{
"id": 1
}
],
"name": "前板",
"id": 1
}
],
"caizhis": [
{
"name": "千和板",
"bancai": [
{
"id": 1
},
{
"id": 2
}
],
"id": 1
},
{
"name": "杉木",
"bancai": [
],
"id": 3
},
{
"name": "桃花芯",
"bancai": [
],
"id": 2
}
],
"users": [
{
"role": 0,
"name": "超管",
"id": 1,
"andy": "123456"
}
]
}
}
<
string name=“url”>https://tian
.sef/Kucun2</
string>
<
string name=“url_all”>/app/all</
string>
<
string name=“url_bancis”>/app/bancai/all</
string>
<
string name=“url_caizhis”>/app/caizhi/all</
string>
<
string name=“url_mupis”>/app/mupi/all</
string>
<
string name=“url_dingdans”>/app/dingdan/all</
string>
<
string name=“url_chanpins”>/app/chanpin/all</
string>
<
string name=“url_zujians”>/app/zujian/all</
string>
<
string name="url_chanpin_zujians">/app/chanpin_zujian/all</
string>
<
string name="url_dingdan_zujians">/app/dingdan_zujian/all</
string>
<
string name="url_dingdan_chanpins">/app/dingdan_chanpin/all</
string>
<
string name="url_jinhuos">/app/jinhuo/all</
string>
<
string name="url_add_bancai">/app/bancai/add</
string>
<
string name="url_add_dingdan">/app/dingdan/add</
string>
<
string name="url_add_chanpin">/app/chanpin/add</
string>
<
string name="url_add_zujian">/app/zujian/add</
string>
<
string name="url_add_caizhi">/app/caizhi/add</
string>
<
string name="url_add_mupi">/app/mupi/add</
string>
<
string name="url_add_dingdan_chanpin">/app/dingdan_chanpi/add</
string>
<
string name="url_add_dingdan_zujian">/app/dingdan_zujian/add</
string>
<
string name="url_add_chanpin_zujian">/app/chanpin_zujian/add</
string>
<
string name="url_add_jinhuo">/app/jinhuo/add</
string>
<
string name="url_login">/user/login</
string> 开始是填充数据
博客提到content未实例化，可在Activity的onCreate方法中进行处理，涉及Android开发中Activity的使用及内容实例化操作。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
712
