=、equals()、isAssignableFrom()、isInstance()、instanceof()

本文详细解释了Java中==与equals的区别,==用于比较基本类型值和引用类型地址,而equals默认比较引用地址,但如String类重写后比较内容。此外,还介绍了isAssignableFrom、getClass与class.name.class的区别及instanceof和isInstance的使用场景。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

==:

当==作用于基本数据类型时,比较的是他们两个的值

当==作用于引用类型的变量时,比较的是引用类型变量所指向对象的地址

equals:

equals不能作用域基本数据类型

如果没有对equals方法进行重写,则比较的是引用类型的变量所指向的对象的地址;

诸如String、Date等类对equals方法进行了重写的话,比较的是所指向的对象的内容。

        int a=3;
        int b=3;

        System.out.println(a==b);//true

        String str1=new String("abc");
        String str2=new String("abc");

        System.out.println(str1==str2);//false
        System.out.println(str1.equals(str2));//true

未重写的equals--Object:

比较的仍是地址信息

重写的equals--String:

1.先比较两个对象的地址是否相同,地址相同的话内容肯定就一样

2.在比较该对象是否是String类型的

3.类型相同时在比较其长度

4.长度相同时将其拆分成字符数组,再一一进行比较

简而言之:

==比较的是地址

equals比较的是内容

isAssignableFrom:

jdk描述:

判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同,或是否是其超类或超接口。如果是则返回 true;否则返回 false。如果该 Class 表示一个基本类型,且指定的 Class 参数正是该 Class 对象,则该方法返回 true;否则返回 false

        Father f = new Father();
        Child c = new Child();

        System.out.println(Father.class.isAssignableFrom(Child.class));//true
        System.out.println(Child.class.isAssignableFrom(Father.class));//false

getClass()和类名.class:

getClass():从一个类的实例获得类类型

类名.class:当前类的类类型

相同点:

都可以获得某个类的类类型

不同点:

出现时期不同:

getClass()和Class.forName()是运行时加载,是动态加载

类名.class是编译器加载,是静态加载

instanceof:

java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。

        Father f = new Father();
        Child c = new Child();

        System.out.println(c instanceof Father);//true
        System.out.println(f instanceof Child);//false

总结:

isAssignableForm:当前类是否为该类的父类或是其接口

                            isAssignableFrom是父-->子

                            isAssignableFrom是接口->实现

instanceof :当前类是否为该类的子类或是其接口的实现类

                            instanceof 是子-->父

                            instanceof 是实现-->接口

isInstance:

jdk描述:

判定指定的 Object 是否与此 Class 所表示的对象赋值兼容。此方法是 Java 语言 instanceof 运算符的动态等效方法。如果指定的 Object 参数非空,且能够在不引发 ClassCastException 的情况下被强制转换成该 Class 对象所表示的引用类型,则该方法返回 true;否则返回 false

特别地,当该 Class 对象表示一个已声明的类时,若指定的 Object 参数是所表示类(或其任一子类)的一个实例,则此方法返回 true;否则返回 false。如果此 Class 对象表示一个数组类,且通过身份转换或扩展引用转换,指定的 Object 参数能转换为一个数组类的对象,则返回 true;否则返回 false。如果此 Class 对象表示一个接口,且指定 Object 参数的类或任一超类实现了此接口,则此方法返回 true;否则返回 false。如果此 Class 对象表示一个基本类型,则此方法返回 false

        System.out.println(c instanceof Father);//true
        System.out.println(f instanceof Child);//false       
        System.out.println(Child.class.isInstance(f));//false
        System.out.println(Father.class.isInstance(c));//true
        Father f1 =c;
        //Child c1 = (Child) f;//报错

此方法是 Java 语言 instanceof 运算符的动态等效方法。如果指定的 Object 参数非空,且能够在不引发 ClassCastException 的情况下被强制转换成该 Class 对象所表示的引用类型,则该方法返回 true;否则返回 false

即当一个对象转为另一个对象不会抛出异常时,isInstance运算为treu,否则为false

package com.example.kucun2.entity.data; import android.util.Log; import androidx.annotation.NonNull; import com.google.gson.Gson; import java.io.IOException; 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.Collection; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.ListIterator; import java.util.Set; import okhttp3.Call; import okhttp3.Callback; import okhttp3.MediaType; import okhttp3.OkHttpClient; import okhttp3.Request; import okhttp3.RequestBody; import okhttp3.Response; /** * 支持数据变更自动同步的泛型集合类 * @param <T> 继承自 SynchronizableEntity 的实体类型 */ public class SynchronizedList<T extends SynchronizableEntity> implements List<T> { private final List<T> list = new ArrayList<>(); private final OkHttpClient client = new OkHttpClient(); private static final Gson gson = new Gson(); private static final MediaType JSON = MediaType.get("application/json; charset=utf-8"); private final Class<T> entityClass; // 类型标记 // 添加批量操作模式标志 private boolean batchMode = false; // 属性变更监听器 private final List<PropertyChangeListener<T>> listeners = new ArrayList<>(); public SynchronizedList(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.InvocationHandler handler = java.lang.reflect.Proxy.getInvocationHandler(proxy); if (handler instanceof IProxyHandler) { //没有IProxyHandler类 return ((IProxyHandler) handler).getOriginal(); } } catch (Exception e) { Log.e("SynchronizedList", "Failed to get proxy handler", e); } } return proxy; } /** * 同步实体到后端 * * @param entity 要同步的实体 */ private void syncEntity(T entity) { if (batchMode) return; String operation = "add"; T originalEntity = getOriginal(entity); String endpoint = originalEntity.getEndpoint(operation); String json = gson.toJson(originalEntity); RequestBody body = RequestBody.create(json, JSON); Request request = new Request.Builder() .url(endpoint) .method(getHttpMethod(operation), body) .build(); client.newCall(request).enqueue(new Callback() { @Override public void onFailure(@NonNull Call call, @NonNull IOException e) { Log.e("SynchronizedList", "同步失败: " + entity.getClass().getSimpleName(), e); } @Override public void onResponse(@NonNull Call call, @NonNull Response response) { if (!response.isSuccessful()) { Log.e("SynchronizedList", "同步失败: " + response.code() + " - " + response.message()); } response.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 operation) { switch (operation) { case "add": return "POST"; case "update": return "PUT"; case "delete": return "DELETE"; default: return "POST"; } } // 获取类实现的所有接口(包括父类接口) private Class<?>[] getInterfaces(Class<?> clazz) { Set<Class<?>> interfaces = new HashSet<>(); while (clazz != null) { interfaces.addAll(Arrays.asList(clazz.getInterfaces())); clazz = clazz.getSuperclass(); } return interfaces.toArray(new Class<?>[0]); } /** * 创建代理对象,用于监听属性变更 */ private T createProxy(T original) { if (!entityClass.isInstance(original)) { throw new IllegalArgumentException("Invalid entity type"); } return (T) java.lang.reflect.Proxy.newProxyInstance( original.getClass().getClassLoader(), getInterfaces(original.getClass()), new EntityProxyHandler(original) ); // if (!entityClass.isInstance(original)) { // throw new IllegalArgumentException("Invalid entity type"); // } // // 这里使用动态代理模式监听setter方法调用 // return (T) java.lang.reflect.Proxy.newProxyInstance( // original.getClass().getClassLoader(), // original.getClass().getInterfaces(), // (proxy, method, args) -> { // // 只拦截setter方法 // if (method.getName().startsWith("set") && args.length == 1) { // String propertyName = method.getName().substring(3); // propertyName = propertyName.substring(0, 1).toLowerCase() + propertyName.substring(1); // // // 获取旧值 // Object oldValue = original.getClass() // .getMethod("get" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(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 contains(Object o) { return list.contains(o); } @NonNull @Override public Iterator<T> iterator() { return list.iterator(); } @NonNull @Override public Object[] toArray() { return list.toArray(); } @NonNull @Override public <T1> T1[] toArray(@NonNull 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 containsAll(@NonNull Collection<?> c) { return list.containsAll(c); } @Override public boolean addAll(@NonNull Collection<? extends T> c) { boolean modified = false; for (T t : c) { modified |= add(t); } return modified; } @Override public boolean addAll(int index, @NonNull Collection<? extends T> c) { for (T t : c) { add(index++, t); } return true; } @Override public boolean removeAll(@NonNull Collection<?> c) { for (Object o : c) { T entity = safeCast(o); if (entity != null) { syncEntity(entity); } } return list.removeAll(c); } @Override public boolean retainAll(@NonNull Collection<?> c) { List<T> toRemove = new ArrayList<>(); for (T t : list) { if (!c.contains(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); } @NonNull @Override public ListIterator<T> listIterator() { return list.listIterator(); } @NonNull @Override public ListIterator<T> listIterator(int index) { return list.listIterator(index); } @NonNull @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) { for (PropertyChangeListener<T> listener : listeners) { listener.onPropertyChange(entity, propertyName, oldValue, newValue); } } // 修改代理处理器以支持获取原始对象 /* 完整的 EntityProxyHandler 实现 */ private class EntityProxyHandler implements IProxyHandler/*报错*/, java.lang.reflect.InvocationHandler { private final T original; public EntityProxyHandler(T original) { this.original = original; } @Override public T getOriginal() { return original; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 处理 setter 方法 if (method.getName().startsWith("set") && args.length == 1) { String propertyName = method.getName().substring(3); propertyName = propertyName.substring(0, 1).toLowerCase() + propertyName.substring(1); // 获取旧值 Object oldValue = getPropertyValue(propertyName); // 调用原始方法 Object result = method.invoke(original, args); // 触发属性变更监听 firePropertyChange(original, propertyName, oldValue, args[0]); // 批量模式下不自动同步 if (!batchMode) { syncEntity(original); } return result; } // 特殊处理 getOriginal() 方法 if ("getOriginal".equals(method.getName()) && method.getParameterCount() == 0) { return original; } return method.invoke(original, args); } private Object getPropertyValue(String propertyName) { String getterName = "get" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1); try { Method getter = original.getClass().getMethod(getterName); return getter.invoke(original); } catch (Exception e) { Log.e("ProxyHandler", "Failed to get property value: " + propertyName, e); return null; } } } }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);//参数不对报错 // 结束批量模式(会触发一次全量同步) 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; 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; } }
06-10
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; 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; } }package com.example.kucun2.entity.data; import android.util.Log; import androidx.annotation.NonNull; import com.google.gson.Gson; import java.io.IOException; 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.Collection; 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.Response; /** * 支持数据变更自动同步的泛型集合类 * @param <T> 继承自 SynchronizableEntity 的实体类型 */ public class SynchronizedList<T extends SynchronizableEntity> implements List<T> { private final List<T> list = new ArrayList<>(); private final OkHttpClient client = new OkHttpClient(); private static final Gson gson = new Gson(); private static final MediaType JSON = MediaType.get("application/json; charset=utf-8"); private final Class<T> entityClass; // 类型标记 // 添加批量操作模式标志 private boolean batchMode = false; // 属性变更监听器 private final List<PropertyChangeListener<T>> listeners = new ArrayList<>(); public SynchronizedList(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.InvocationHandler handler = java.lang.reflect.Proxy.getInvocationHandler(proxy); if (handler instanceof IProxyHandler) { Object original = ((IProxyHandler) handler).getOriginal(); // 安全类型检查 if (entityClass.isInstance(original)) { return (T) original; } } } catch (Exception e) { Log.e("SynchronizedList", "Failed to get proxy handler", e); } } return proxy; } /** * 同步实体到后端 * * @param entity 要同步的实体 */ private void syncEntity(T entity) { if (batchMode) return; String operation = "add"; T originalEntity = getOriginal(entity); String endpoint = originalEntity.getEndpoint(operation); String json = gson.toJson(originalEntity); RequestBody body = RequestBody.create(json, JSON); Request request = new Request.Builder() .url(endpoint) .method(getHttpMethod(operation), body) .build(); client.newCall(request).enqueue(new Callback() { @Override public void onFailure(@NonNull Call call, @NonNull IOException e) { Log.e("SynchronizedList", "同步失败: " + entity.getClass().getSimpleName(), e); } @Override public void onResponse(@NonNull Call call, @NonNull Response response) { if (!response.isSuccessful()) { Log.e("SynchronizedList", "同步失败: " + response.code() + " - " + response.message()); } response.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 operation) { switch (operation) { case "add": return "POST"; case "update": return "PUT"; case "delete": return "DELETE"; default: return "POST"; } } // 获取类实现的所有接口(包括父类接口) private Class<?>[] getInterfaces(Class<?> clazz) { Set<Class<?>> interfaces = new HashSet<>(); while (clazz != null) { interfaces.addAll(Arrays.asList(clazz.getInterfaces())); 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 IllegalArgumentException("Invalid entity type"); } // 为原始对象创建代理 return (T) java.lang.reflect.Proxy.newProxyInstance( original.getClass().getClassLoader(), getInterfaces(original.getClass()), new EntityProxyHandler(original) ); // if (!entityClass.isInstance(original)) { // throw new IllegalArgumentException("Invalid entity type"); // } // // 这里使用动态代理模式监听setter方法调用 // return (T) java.lang.reflect.Proxy.newProxyInstance( // original.getClass().getClassLoader(), // original.getClass().getInterfaces(), // (proxy, method, args) -> { // // 只拦截setter方法 // if (method.getName().startsWith("set") && args.length == 1) { // String propertyName = method.getName().substring(3); // propertyName = propertyName.substring(0, 1).toLowerCase() + propertyName.substring(1); // // // 获取旧值 // Object oldValue = original.getClass() // .getMethod("get" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(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 contains(Object o) { return list.contains(o); } @NonNull @Override public Iterator<T> iterator() { return list.iterator(); } @NonNull @Override public Object[] toArray() { return list.toArray(); } @NonNull @Override public <T1> T1[] toArray(@NonNull 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 containsAll(@NonNull Collection<?> c) { return list.containsAll(c); } @Override public boolean addAll(@NonNull Collection<? extends T> c) { boolean modified = false; for (T t : c) { modified |= add(t); } return modified; } @Override public boolean addAll(int index, @NonNull Collection<? extends T> c) { for (T t : c) { add(index++, t); } return true; } @Override public boolean removeAll(@NonNull Collection<?> c) { for (Object o : c) { T entity = safeCast(o); if (entity != null) { syncEntity(entity); } } return list.removeAll(c); } @Override public boolean retainAll(@NonNull Collection<?> c) { List<T> toRemove = new ArrayList<>(); for (T t : list) { if (!c.contains(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); } @NonNull @Override public ListIterator<T> listIterator() { return list.listIterator(); } @NonNull @Override public ListIterator<T> listIterator(int index) { return list.listIterator(index); } @NonNull @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 (Exception e) { Log.e("SynchronizedList", "Listener error", e); } } } // 修改代理处理器以支持获取原始对象 /* 完整的 EntityProxyHandler 实现 */ private class EntityProxyHandler implements IProxyHandler, java.lang.reflect.InvocationHandler { 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().substring(3); propName = Character.toLowerCase(propName.charAt(0)) + propName.substring(1); propertyValues.put(propName, method.invoke(original)); } catch (Exception 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.substring(3); propertyName = Character.toLowerCase(propertyName.charAt(0)) + propertyName.substring(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.substring(3); propertyName = Character.toLowerCase(propertyName.charAt(0)) + propertyName.substring(1); return propertyValues.getOrDefault(propertyName, method.invoke(original)); } return method.invoke(original, args); } private Object getPropertyValue(String propertyName) { String getterName = "get" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1); try { Method getter = original.getClass().getMethod(getterName); return getter.invoke(original); } catch (Exception e) { Log.e("ProxyHandler", "Failed to get property value: " + propertyName, e); return null; } } } // 在 SynchronizedList 类中添加 private interface IProxyHandler { Object getOriginal(); } }app/all返回json数据:{ “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> 开始是填充数据
06-10
package com.kucun.Service; import java.io.Serializable; import java.lang.reflect.*; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; import java.util.stream.Collectors; import javax.persistence.metamodel.Attribute; import javax.persistence.metamodel.EntityType; import javax.persistence.metamodel.Metamodel; import javax.persistence.metamodel.PluralAttribute; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.dao.DataAccessException; import org.springframework.data.domain.Example; import org.springframework.data.domain.ExampleMatcher; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Service; import com.kucun.data.entity.Bancai; import com.kucun.data.entity.Caizhi; import com.kucun.data.entity.Chanpin; import com.kucun.data.entity.Chanpin_zujian; import com.kucun.data.entity.Dingdan; import com.kucun.data.entity.Dingdan_chanpin; import com.kucun.data.entity.Dingdan_chanpin_zujian; import com.kucun.data.entity.EntityBasis; import com.kucun.data.entity.Information; import com.kucun.data.entity.Kucun; import com.kucun.data.entity.Mupi; import com.kucun.data.entity.User; import com.kucun.data.entity.Zujian; import com.kucun.dataDo.BancaiRepository; import com.kucun.dataDo.CaizhiRepository; import com.kucun.dataDo.ChanpinRepository; import com.kucun.dataDo.ChanpinZujianRepository; import com.kucun.dataDo.DingdanChanpinRepository; import com.kucun.dataDo.DingdanChanpinZujianRepository; import com.kucun.dataDo.DingdanRepository; import com.kucun.dataDo.KucunRepository; import com.kucun.dataDo.MupiRepository; import com.kucun.dataDo.UserRepository; import com.kucun.dataDo.ZujianRepository; @Service public class AppService { // 注入所有需要的Repository @Autowired private CaizhiRepository caizhiRepository; @Autowired private BancaiRepository bancaiRepository; @Autowired private ChanpinRepository chanpinRepository; @Autowired private DingdanRepository dingdanRepository; @Autowired private MupiRepository mupiRepository; @Autowired private ZujianRepository zujianRepository; @Autowired private KucunRepository kucunRepository; @Autowired private UserRepository userRepository; @Autowired private ChanpinZujianRepository chanpinZujianRepository; @Autowired private DingdanChanpinZujianRepository dingdanChanpinZujianRepository; @Autowired private DingdanChanpinRepository dingdanChanpinRepository; @Autowired private DynamicRepositoryService repositoryService; // private Map<String, JpaRepository<?, ?>> shiti; // // // @Override // public void setApplicationContext(ApplicationContext context) { // this.shiti = getJpaRepositories(context); // } // // public Map<String, JpaRepository<?, ?>> getJpaRepositories(ApplicationContext context) { // return context.getBeansWithAnnotation(Repository.class) // .entrySet() // .stream() // .filter(entry -> entry.getValue() instanceof JpaRepository) // .collect(Collectors.toMap( // entry -> { // JpaRepository<?, ?> repo = (JpaRepository<?, ?>) entry.getValue(); // return getEntityClass(repo).getName(); // }, // entry -> (JpaRepository<?, ?>) entry.getValue() // )); // } // // public static Class<?> getEntityClass(JpaRepository<?, ?> repo) { // try { // // 处理Spring代理类 // Object target = repo; // while (target instanceof Advised) { // target = ((Advised) target).getTargetSource().getTarget(); // } // // // 通过Spring的ResolvableType解析泛型 // ResolvableType resolvableType = ResolvableType.forClass( // target.getClass()).as(JpaRepository.class); // // if (resolvableType.getGenerics().length > 0) { // Class<?> entityClass = resolvableType.getGeneric(0).resolve(); // if (entityClass != null) { // return entityClass; // } // } // // throw new IllegalStateException("无法解析实体类型"); // } catch (Exception e) { // throw new RuntimeException("获取实体类失败: " + e.getMessage(), e); // } // } // // public Information getAllDataWithChildIdse() { // Map<String, Object> response = new HashMap<>(); // // response.put("caizhis", (caizhiRepository.findAll())); // response.put("bancais", (bancaiRepository.findAll())); // response.put("chanpins", (chanpinRepository.findAll())); // response.put("dingdans", (dingdanRepository.findAll())); // response.put("mupis", (mupiRepository.findAll())); // response.put("zujians", (zujianRepository.findAll())); // response.put("kucuns", (kucunRepository.findAll())); // response.put("users", (userRepository.findAll())); // response.put("chanpin_zujians", (chanpinZujianRepository.findAll())); // response.put("chanpin_zujians", (dingdanChanpinZujianRepository.findAll())); // response.put("chanpin_zujians", (dingdanChanpinRepository.findAll())); // // return Information.NewSuccess(response); // } public Information getAllDataWithChildIdse() { Map<String, Object> response = new HashMap<>(); for (String key : repositoryService.getRepositoryNameMap().keySet()) { response.put(key+"s", (repositoryService.getJpaRepository(key).findAll())); } return Information.NewSuccess(response); } public Information getAllDataWithChildIdse(String e) { JpaRepository<?, ?> jp = repositoryService.getJpaRepository(e); System.out.println(jp); return Information.NewSuccess(jp.findAll()); } public Information getAddEntity(Object e) { Class<?> entityClass = e.getClass(); try { // 处理关联字段 handleAssociations(e); @SuppressWarnings("unchecked") JpaRepository<Object, Serializable> jp = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(entityClass); Object savedEntity = jp.save(e); if(savedEntity!=null) { if(savedEntity instanceof Bancai) { initializeKucunForBancai((Bancai)savedEntity); } } return Information.NewSuccess(savedEntity); } catch (Exception ex) { return Information.Newfail(500, "创建失败: " + ex.getMessage(), null); } } // 单独封装库存初始化方法 private void initializeKucunForBancai(Bancai bancai) throws Exception { Kucun kucun = new Kucun(null, bancai, 0); // 初始库存为0 try { bancai.setKucun(kucunRepository.save(kucun)); } catch (Exception e) { // TODO: handle exception throw new Exception("initializeKucunForBancai"+e); } } // 处理关联对象(转换为托管实体) private void handleAssociations(Object entity) throws Exception { Class<?> clazz = entity.getClass(); for (Field field : clazz.getDeclaredFields()) { field.setAccessible(true); Object value = field.get(entity); if (value == null) continue; // 处理单个关联实体 if (isEntityBasisField(field)) { EntityBasis associatedEntity = (EntityBasis) value; JpaRepository<Object, Serializable> repo = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(associatedEntity.getClass()); // 获取托管状态的关联实体 Object managedEntity = repo.findById(associatedEntity.getId()) .orElseThrow(() -> new RuntimeException("关联实体不存在")); field.set(entity, managedEntity); } // 处理集合关联 else if (isCollectionField(field)) { Collection<?> collection = (Collection<?>) value; List<Object> managedEntities = new ArrayList<>(); for (Object item : collection) { if (item instanceof EntityBasis) { EntityBasis eb = (EntityBasis) item; JpaRepository<Object, Serializable> repo = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(eb.getClass()); Object managedEntity = repo.findById(eb.getId()) .orElseThrow(() -> new RuntimeException("关联实体不存在")); managedEntities.add(managedEntity); } } // 更新集合为托管实体 if (!managedEntities.isEmpty()) { field.set(entity, managedEntities); } } } } /** * 更新 * @param e 实体待id * @return */ /** * 更新实体 * @param e 包含ID的实体 * @return 操作结果 */ public Information getupdateEntity(Object e) { if(e == null) { return Information.Newfail(403, "参数为空", null); } Class<?> entityClass = e.getClass(); try { Field idField = entityClass.getDeclaredField("id"); idField.setAccessible(true); Object idValue = idField.get(e); // 修正:应检查id是否为空,而不是不为空 if(idValue == null) { return Information.Newfail(403, "Id为空", null); } // 获取Repository @SuppressWarnings("unchecked") JpaRepository<Object, Serializable> jp = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(entityClass); // 从数据库加载现有实体(托管状态) Object existingEntity = jp.findById((Serializable) idValue) .orElseThrow(() -> new RuntimeException("实体不存在")); // 复制属性(排除关联字段) copyNonNullProperties(e, existingEntity); // 保存托管状态的实体 Object updatedEntity = jp.save(existingEntity); return Information.NewSuccess(updatedEntity); } catch (Exception ex) { return Information.Newfail(500, "更新失败: " + ex.getMessage(), null); } } /** * 删除 * @param entity * @return */ public Information getdeleteEntity(EntityBasis entity) { Map<String, Object> response = new HashMap<>(); JpaRepository<Object, Integer> jp= (JpaRepository<Object, Integer>) repositoryService.getJpaRepository(entity.getClass().getSimpleName().toLowerCase()); if(!jp.existsById(entity.getId())) { return Information.NewFail("没有该数据"); } Object d=jp.findById(entity.getId()).orElse(null); for (Class<?> nt : repositoryService.getRepositoryMap().keySet()) { for (Field ent : nt.getDeclaredFields()) { if(ent.getClass().equals(entity.getClass())) { Object o=null; try { o = nt.newInstance(); ent.set(o, d); } catch (InstantiationException | IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(o); if(getSELECTEntity(o).getData()!=null) { return Information.NewFail("已在其他地方使用了,无法删除"); } } } } try { jp.deleteById(((EntityBasis)entity).getId()); } catch (Exception e) { // TODO: handle exception System.out.println(e.getLocalizedMessage()); } if(jp.existsById(entity.getId())) { System.out.println("删除失败"); return Information.NewFail("删除失败"); } return Information.NewSuccess(response); } // 复制非空属性(忽略关联字段) private void copyNonNullProperties(Object source, Object target) throws IllegalAccessException { Class<?> clazz = source.getClass(); for (Field field : clazz.getDeclaredFields()) { field.setAccessible(true); Object value = field.get(source); // 跳过关联字段特殊字段 if (value != null && !isEntityBasisField(field) && !isCollectionField(field) && !field.getName().equals("id")) { Field targetField; try { targetField = target.getClass().getDeclaredField(field.getName()); targetField.setAccessible(true); targetField.set(target, value); } catch (NoSuchFieldException e) { // 忽略不存在的字段 } } } } // 检查是否为关联实体字段 private boolean isEntityBasisField(Field field) { return EntityBasis.class.isAssignableFrom(field.getType()); } // 检查是否为集合字段 private boolean isCollectionField(Field field) { return Collection.class.isAssignableFrom(field.getType()) || Map.class.isAssignableFrom(field.getType()); } /** * 根据非空属性值动态查询实体 * @param entity 包含查询条件的实体对象(非空属性作为查询条件) * @return 查询结果信息(成功时包含数据列表) */ public <T>Information getSELECTEntity(T entity) { if (entity == null) { return Information.NewFail("查询参数不能为空"); } Class<T> entityClass = (Class<T>) entity.getClass(); try { // 1. 获取非泛型的Repository JpaRepository repository = repositoryService.getJpaRepository(entityClass); // 2. 构建非泛型的Example查询 ExampleMatcher matcher = ExampleMatcher.matching() .withIgnoreNullValues() .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING); // 这里直接使用原始类型Example Example<T> example = Example.of(entity);//he type Example is not generic; it cannot be parameterized with arguments <T>the method of(T) is undefined for the type Example // 3. 执行查询 List<?> result = repository.findAll(example); return Information.NewSuccess(result); } catch (ClassCastException e) { return Information.NewFail("Repository类型不匹配: " + e.getMessage()); } catch (DataAccessException e) { return Information.NewFail("数据库访问错误: " + e.getMessage()); } catch (Exception e) { return Information.NewFail("系统错误: " + e.getMessage()); } } private List<Map<String, Object>> convertEntityBasis(List<EntityBasis> entities) { return entities.stream().map(entity -> { Map<String, Object> map = new HashMap<>(); Field[] fields = entity.getClass().getDeclaredFields(); try { // 添加实体自身的基本字段 map.put("id", entity.getId()); // 处理所有字段 for (Field field : fields) { field.setAccessible(true); // 允许访问私有字段 Object fieldValue = field.get(entity); if (fieldValue != null) { String fieldName = field.getName(); // 处理集合类型关联 if (isCollection(field)) { if (!((Collection<?>) fieldValue).isEmpty()) { List<Map<String, Object>> collectionItems = ((Collection<?>) fieldValue) .stream() .filter(item -> item instanceof EntityBasis) .map(item -> { Map<String, Object> itemMap = new HashMap<>(); itemMap.put("id", ((EntityBasis) item).getId()); return itemMap; }) .collect(Collectors.toList()); map.put(fieldName, collectionItems); } } // 处理单个实体关联 else if (implementsInterface(field, EntityBasis.class)) { Map<String, Object> associatedMap = new HashMap<>(); associatedMap.put("id", ((EntityBasis) fieldValue).getId()); map.put(fieldName, associatedMap); } // 处理其他基本类型字段 else if (!isSpecialField(fieldName)) { map.put(fieldName, fieldValue); } } } } catch (IllegalAccessException e) { e.printStackTrace(); } return map; }).collect(Collectors.toList()); } // 判断是否为特殊字段(需要排除的字段) private boolean isSpecialField(String fieldName) { return fieldName.equals("handler") || fieldName.equals("hibernateLazyInitializer"); } /** *-判断属性是否为集合类型 * @param field * @return */ boolean isCollection(Field field) { Class<?> type = field.getType(); // 检查是否为Java内置集合类型 if (Collection.class.isAssignableFrom(type) || Map.class.isAssignableFrom(type) || type.isArray()) { return true; } // 检查是否实现集合相关接口(如Iterable) for (Class<?> interfaceType : type.getInterfaces()) { if (Iterable.class.isAssignableFrom(interfaceType)) { return true; } } return false; } /** * -判断属性是否实现特定接口 * @param field * @param targetInterface * @return */ boolean implementsInterface(Field field, Class<?> targetInterface) { Class<?> type = field.getType(); // 检查类本身是否实现接口 if (targetInterface.isAssignableFrom(type)) { return true; } // 检查实现的接口是否继承目标接口 for (Class<?> interfaceType : type.getInterfaces()) { if (targetInterface.isAssignableFrom(interfaceType)) { return true; } } return false; } private Object convertDingdanChanpins(List<Dingdan_chanpin> findAll) { // TODO Auto-generated method stub return null; } private Object convertDingdanChanpinZujians(List<Dingdan_chanpin_zujian> findAll) { // TODO Auto-generated method stub return null; } } 删除功能完善
最新发布
06-18
package com.example.kucun2.entity.data; import android.util.Log; import androidx.annotation.NonNull; import com.example.kucun2.function.MyAppFnction; import com.google.gson.Gson; import java.beans.PropertyChangeEvent; import java.beans.PropertyChangeListener; import java.io.IOException; import java.util.*; import okhttp3.*; /** * 支持数据变更自动同步的泛型集合类 * 移除了代理机制,改用基类的事件监听 */ public class SynchronizedList<T extends SynchronizableEntity> implements List<T> { private final List<T> list = new ArrayList<>(); private final OkHttpClient client = new OkHttpClient(); private static final Gson gson = new Gson(); private static final MediaType JSON = MediaType.get("application/json; charset=utf-8"); // 批量操作模式标志 private boolean batchMode = false; // 实体变更监听器 private final EntityChangeListener<T> listener = entity -> { if (!batchMode) syncEntity(entity); }; // 直接接受Class参数的构造函数 public SynchronizedList(Class<T> T) {} // 添加监听器的方法 private void registerListener(T entity) { if (entity != null) { entity.addPropertyChangeListener(listener); } } private void unregisterListener(T entity) { if (entity != null) { entity.removePropertyChangeListener(listener); } } private String getUrl() { return MyAppFnction.getStringResource("string", "url"); } /** * 同步实体到后端 */ private static void syncEntity(SynchronizableEntity entity) { String operation = "update"; // 默认为更新操作 String endpoint = entity.getEndpoint(operation); String json = gson.toJson(entity); RequestBody body = RequestBody.create(json, JSON); Request request = new Request.Builder() .url(getUrl() + endpoint) .put(body) // 统一使用PUT方法 .build(); client.newCall(request).enqueue(new Callback() { @Override public void onFailure(@NonNull Call call, @NonNull IOException e) { Log.e("SynchronizedList", "同步失败: " + entity.getClass().getSimpleName(), e); } @Override public void onResponse(@NonNull Call call, @NonNull Response response) { if (!response.isSuccessful()) { Log.e("SynchronizedList", "同步失败: " + response.code()); } response.close(); } }); } // 批量操作方法 public void beginBatch() { this.batchMode = true; } public void endBatch() { this.batchMode = false; syncAllEntities(); } private void syncAllEntities() { for (T entity : list) { syncEntity(entity); } } // List接口实现(添加时注册监听器,移除时取消监听) @Override public boolean add(T t) { registerListener(t); boolean result = list.add(t); if (!batchMode) syncEntity(t); return result; } @Override public void add(int index, T element) { registerListener(element); list.add(index, element); if (!batchMode) syncEntity(element); } @Override public boolean remove(Object o) { if (o instanceof SynchronizableEntity) { T entity = (T) o; unregisterListener(entity); if (!batchMode) syncEntity(entity); } return list.remove(o); } @Override public T remove(int index) { T entity = list.get(index); if (entity != null) { unregisterListener(entity); if (!batchMode) syncEntity(entity); } return list.remove(index); } @Override public boolean addAll(@NonNull Collection<? extends T> c) { for (T t : c) registerListener(t); return list.addAll(c); } @Override public boolean removeAll(@NonNull Collection<?> c) { for (Object o : c) { if (o instanceof SynchronizableEntity) { unregisterListener((T) o); } } return list.removeAll(c); } @Override public boolean retainAll(@NonNull Collection<?> c) { return false; } @Override public void clear() { for (T t : list) { unregisterListener(t); if (!batchMode) syncEntity(t); } list.clear(); } @Override public T get(int index) { return list.get(index); } @Override public int size() { return list.size(); } @Override public boolean isEmpty() { return list.isEmpty(); } @Override public boolean contains(Object o) { return list.contains(o); } @NonNull @Override public Iterator<T> iterator() { return list.iterator(); } @NonNull @Override public Object[] toArray() { return list.toArray(); } @NonNull @Override public <T1> T1[] toArray(@NonNull T1[] a) { return list.toArray(a); } @Override public boolean containsAll(@NonNull Collection<?> c) { return list.containsAll(c); } @Override public boolean addAll(int index, @NonNull Collection<? extends T> c) { for (T element : c) { registerListener(element); } boolean result = list.addAll(index, c); if (!batchMode) { for (T element : c) { syncEntity(element); } } return result; } @Override public T set(int index, T element) { T oldElement = list.set(index, element); // 取消旧元素的监听 if (oldElement != null) { unregisterListener(oldElement); if (!batchMode) syncEntity(oldElement); } // 注册新元素的监听 registerListener(element); if (!batchMode) { syncEntity(element); } return oldElement; } @Override public int indexOf(Object o) { return list.indexOf(o); } @Override public int lastIndexOf(Object o) { return list.lastIndexOf(o); } @NonNull @Override public ListIterator<T> listIterator() { return list.listIterator(); } @NonNull @Override public ListIterator<T> listIterator(int index) { return list.listIterator(index); } @NonNull @Override public List<T> subList(int fromIndex, int toIndex) { // 创建子列表的同步包装器 return new SynchronizedListWrapper(list.subList(fromIndex, toIndex)); } // 其他List接口方法保持原样... // [此处省略未修改的List接口方法实现] /** * 实体变更监听接口 */ public interface EntityChangeListener<T> extends PropertyChangeListener { default void onPropertyChange(T entity, String propertyName, Object oldValue, Object newValue) { syncEntity((SynchronizableEntity) entity); } } // ==================== 内部辅助类 ==================== private class SynchronizedListWrapper implements List<T> { private final List<T> wrapped; public SynchronizedListWrapper(List<T> list) { this.wrapped = list; } @Override public boolean add(T element) { registerListener(element); boolean result = wrapped.add(element); if (!batchMode) syncEntity(element); return result; } @Override public void add(int index, T element) { registerListener(element); wrapped.add(index, element); if (!batchMode) syncEntity(element); } @Override public T set(int index, T element) { T oldElement = wrapped.get(index); if (oldElement != null) { unregisterListener(oldElement); if (!batchMode) syncEntity(oldElement); } registerListener(element); T result = wrapped.set(index, element); if (!batchMode) syncEntity(element); return result; } @Override public T remove(int index) { T element = wrapped.get(index); if (element != null) { unregisterListener(element); if (!batchMode) syncEntity(element); } return wrapped.remove(index); } @Override public boolean remove(Object o) { if (o instanceof SynchronizableEntity) { T entity = (T) o; if (wrapped.contains(entity)) { unregisterListener(entity); if (!batchMode) syncEntity(entity); } } return wrapped.remove(o); } @Override public boolean addAll(@NonNull Collection<? extends T> c) { for (T element : c) { registerListener(element); } boolean result = wrapped.addAll(c); if (!batchMode) { for (T element : c) { syncEntity(element); } } return result; } @Override public boolean addAll(int index, @NonNull Collection<? extends T> c) { for (T element : c) { registerListener(element); } boolean result = wrapped.addAll(index, c); if (!batchMode) { for (T element : c) { syncEntity(element); } } return result; } @Override public boolean removeAll(@NonNull Collection<?> c) { // 先取消所有要移除元素的监听器 for (Object o : c) { if (o instanceof SynchronizableEntity) { T entity = (T) o; if (wrapped.contains(entity)) { unregisterListener(entity); if (!batchMode) syncEntity(entity); } } } return wrapped.removeAll(c); } @Override public boolean retainAll(@NonNull Collection<?> c) { // 找出要移除的元素 List<T> toRemove = new ArrayList<>(); for (T element : wrapped) { if (!c.contains(element)) { toRemove.add(element); } } // 取消这些元素的监听器 for (T element : toRemove) { unregisterListener(element); if (!batchMode) syncEntity(element); } return wrapped.retainAll(c); } @Override public void clear() { // 取消所有元素的监听器 for (T element : wrapped) { unregisterListener(element); if (!batchMode) syncEntity(element); } wrapped.clear(); } // ---------------- 以下是非修改方法,直接委托给包装列表 ---------------- @Override public int size() { return wrapped.size(); } @Override public boolean isEmpty() { return wrapped.isEmpty(); } @Override public boolean contains(Object o) { return wrapped.contains(o); } @NonNull @Override public Iterator<T> iterator() { return wrapped.iterator(); } @NonNull @Override public Object[] toArray() { return wrapped.toArray(); } @NonNull @Override public <T1> T1[] toArray(@NonNull T1[] a) { return wrapped.toArray(a); } @Override public boolean containsAll(@NonNull Collection<?> c) { return wrapped.containsAll(c); } @Override public T get(int index) { return wrapped.get(index); } @Override public int indexOf(Object o) { return wrapped.indexOf(o); } @Override public int lastIndexOf(Object o) { return wrapped.lastIndexOf(o); } @NonNull @Override public ListIterator<T> listIterator() { return wrapped.listIterator(); } @NonNull @Override public ListIterator<T> listIterator(int index) { return wrapped.listIterator(index); } @NonNull @Override public List<T> subList(int fromIndex, int toIndex) { return new SynchronizedListWrapper(wrapped.subList(fromIndex, toIndex)); } } }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; } }package com.example.kucun2.entity.data; import android.util.Log; 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 { // 使用标准属性变更支持类 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(){ } }
06-11
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值