泛型类的应用<T><D><K>

最新推荐文章于 2022-05-30 21:11:58 发布
最新推荐文章于 2022-05-30 21:11:58 发布
阅读量805 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： java 文章标签： 通用service 通用dao 泛型T springboot jpa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/java_Xianfeng/article/details/82458345

此DEMO实现了, 通用增删改查.  咱们只要创建了实体,那么对于该实体的增删改查方法都存在.不需要再去手动编写.

项目结构如下:

这里重点关注圈粉的地方.BaseModel,BaseRepository,BaseService.

BaseRepository可能有些人看起来会有些陌生, 这里我用的是spring jpa 实现的域数据库的映射,其实和mybatis的mapper类似.其他不多解释.咱们学java的,一眼就能看明白.为什么会有这三个父类的存在. 

OK,看代码.

BaseModel ,里边的属性都是咱们实体类的公共属性. 比如:id,创建人, 创建时间, 修改人,修改时间等. 就是所有的表都需要的字段.注意我的项目里边所有ID都是Long类型.

咱们自己的Repository继承BaseRepository,泛型里边加上咱们自己的model类User,以及ID的类型. 这样UserRepository里就存在所有的增删改查方法. 如果有自身的方法.就可以写.比如截图的findListByName等等.这些是自身方法, 增删改查就是父类的.

咱们的BaseService,注意看泛型D extends BaseRepository. 这样咱们的service就能调用到repository的增删改查方法.

以后还有其他service都可以向UserService这样继承一下.  不需要写其他任何东西. 就已经存在增删改查方法.或者其他通用方法.

 

Java - 泛型
旧时言的博客
02-20 391
【本节目标】 以能阅读 java 集合源码为目标学习泛型 了解泛型 了解通配符 1 什么是泛型 一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。----- 来源《Java编程思想》对泛型的介绍。 泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。 2 引出泛型 实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回
泛型
D_H_T的博客
04-14 298
泛型语法 例如List l=new ArrayList(); 在<>里填什么类型 这个集合就只能存储对应的类型 对应的遍历方法 for(Student s:l){ 直接通过变量名操作集合元素 }
掌握 Java 泛型类型(一)
热门推荐
如梦令
11-27 1万+
数据类型转换和错误为理解泛型类型为何如此有用，我们要将注意力转向 Java 语言中最容易引发错误的因素之一 － 需要不断地将表达式向下类型转换（downcast）为比其静态类型更为具体的数据类型（请参阅参考资料中的“The Double Descent bug pattern”，以了解进行数据类型转换时，可能会碰到的麻烦的某些方面）。程序中的每个向下类型转换对于 ClassCastExcept
D语言泛型
编程资料大全
02-29 154
比C++容易的泛型。 看看下面简单的例子： module testContainer; import std.stdio; import std.container; void main(){ SList!int myList; foreach(i;0..10){ myList.insert(i); } foreach(element;myList){ writeln(element); } }...
泛型详解
qq_36924683的博客
04-17 213
概述 泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。 什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实...
性能优化秘诀：C#泛型集合List<T>与Dictionary<TKey, TValue>的最优选择
[泛型集合](https://img-blog.csdnimg.cn/5d0b8437fe42494380f55955ae642c6d.png) # 1. C#集合概览与选择的重要性 在当今的软件开发领域，合理地选择和使用集合数据类型是构建高效和可维护代码的关键。C#作为一门...
C#泛型集合高级技巧：List<T>、Dictionary<TKey, TValue>的10大使用妙招
![泛型集合](https://www.simplilearn.com/ice9/free_resources_article_thumb/SetinJavaEx1.png) ...例如，`List<T>`, `Dictionary<TKey, TValue>`等都是泛型集合的典型代表。 ## 1.2 泛型集合的优
package com.example.kucun2.entity.data; import android.content.Context; import android.util.Log; import com.example.kucun2.entity.; import com.example.kucun2.function.MyAppFnction; import com.example.kucun2.function.TLSUtils; import com.google.gson.Gson; import com.google.gson.reflect.TypeToken; import java.io.IOException; import java.lang.reflect.Type; import java.util.; import javax.net.ssl.SSLContext; import javax.net.ssl.SSLSocketFactory; import javax.net.ssl.X509TrustManager; import okhttp3.Call; import okhttp3.Callback; import okhttp3.OkHttpClient; import okhttp3.Request; import okhttp3.Response; public class Data { // 数据集合声明（保持原有属性名不变） public static SynchronizedList<Bancai> bancais = new SynchronizedList<>(Bancai.class); public static SynchronizedList<Caizhi> caizhis = new SynchronizedList<>(Caizhi.class); public static SynchronizedList<Mupi> mupis = new SynchronizedList<>(Mupi.class); public static SynchronizedList<Chanpin> chanpins = new SynchronizedList<>(Chanpin.class); public static SynchronizedList<Chanpin_Zujian> chanpinZujians = new SynchronizedList<>(Chanpin_Zujian.class); public static SynchronizedList<Dingdan> dingdans = new SynchronizedList<>(Dingdan.class); public static SynchronizedList<Dingdan_Chanpin> dingdanChanpins = new SynchronizedList<>(Dingdan_Chanpin.class); public static SynchronizedList<Dingdan_chanpin_zujian> dingdanBancais = new SynchronizedList<>(Dingdan_chanpin_zujian.class); public static SynchronizedList<Kucun> kucuns = new SynchronizedList<>(Kucun.class); public static SynchronizedList<Zujian> zujians = new SynchronizedList<>(Zujian.class); public static SynchronizedList<User> users = new SynchronizedList<>(Bancai.class); public static SynchronizedList<Jinhuo> jinhuoList = new SynchronizedList<>(Bancai.class); private static final Gson gson = new Gson(); private static OkHttpClient client ; private static final String TAG = "DataLoader"; public static void loadAllData(Context context, LoadDataCallback callback) { // 确保使用安全的客户端 if (client == null) { client= MyAppFnction.getClient(); } String url = MyAppFnction.getStringResource("string", "url") + MyAppFnction.getStringResource("string", "url_all"); Log.d("url", "loadAllData: " + url); Request request = new Request.Builder() .url(url) .build(); client.newCall(request).enqueue(new Callback() { @Override public void onFailure(Call call, IOException e) { Log.e(TAG, "Failed to load data", e); if (callback != null) callback.onFailure(); } @Override public void onResponse(Call call, Response response) throws IOException { if (!response.isSuccessful()) { Log.e(TAG, "Unexpected response code: " + response.code()); if (callback != null) callback.onFailure(); return; } String responseData = response.body().string(); parseAndAssignData(responseData, context, callback); } }); } // 解析并赋值数据 private static void parseAndAssignData(String jsonData, Context context, LoadDataCallback callback) { // 创建包含所有数据类型的TypeToken Type informationType = new TypeToken<Information<AllDataResponse>>(){}.getType(); Information<AllDataResponse> information = gson.fromJson(jsonData, informationType); Log.e(TAG, "Invalid response data"+jsonData); if (information == null || information.getData() == null || information.getStatus() != 200) { Log.e(TAG, "Invalid response data"); if (callback != null) callback.onFailure(); return; } AllDataResponse allData = information.getData(); // 赋值到对应的列表（使用安全方法保持已有引用） updateList(bancais, allData.bancais); updateList(caizhis, allData.caizhis); updateList(mupis, allData.mupis); updateList(chanpins, allData.chanpins); updateList(chanpinZujians, allData.chanpin_zujians); updateList(dingdans, allData.dingdans); updateList(dingdanChanpins, allData.dingdan_chanpins); updateList(dingdanBancais, allData.dingdan_bancais); updateList(kucuns, allData.kucuns); updateList(zujians, allData.zujians); updateList(users, allData.users); updateList(jinhuoList, allData.jinhuos); resolveReferences(); if (callback != null) callback.onSuccess(); } // 更新列表内容但保持对象引用不变 private static <T> void updateList(List<T> existingList, List<T> newList) { if (newList == null) return; existingList.clear(); existingList.addAll(newList); } // 解析对象间的引用关系（使用ID关联） private static void resolveReferences() { // 创建ID到对象的映射 Map<Integer, Bancai> bancaiMap = createIdMap(bancais); Map<Integer, Caizhi> caizhiMap = createIdMap(caizhis); Map<Integer, Mupi> mupiMap = createIdMap(mupis); Map<Integer, Chanpin> chanpinMap = createIdMap(chanpins); Map<Integer, Zujian> zujianMap = createIdMap(zujians); Map<Integer, Dingdan> dingdanMap = createIdMap(dingdans); Map<Integer, Kucun> kucunMap = createIdMap(kucuns); // 解析Bancai引用 for (Bancai bancai : bancais) { if (bancai.getCaizhi() != null) { bancai.setCaizhi(caizhiMap.get(bancai.getCaizhi().getId())); } if (bancai.getMupi1() != null) { bancai.setMupi1(mupiMap.get(bancai.getMupi1().getId())); } if (bancai.getMupi2() != null) { bancai.setMupi2(mupiMap.get(bancai.getMupi2().getId())); } } // 解析Kucun引用 for (Kucun kucun : kucuns) { if (kucun.getBancai() != null) { kucun.setBancai(bancaiMap.get(kucun.getBancai().getId())); } } // 解析订单相关的嵌套对象 for (Dingdan_Chanpin dc : dingdanChanpins) { if (dc.getDingdan() != null) { dc.setDingdan(dingdanMap.get(dc.getDingdan().getId())); } if (dc.getChanpin() != null) { dc.setChanpin(chanpinMap.get(dc.getChanpin().getId())); } } // 解析产品相关的嵌套对象 for (Chanpin_Zujian cz : chanpinZujians) { if (cz.getChanpin() != null) { cz.setChanpin(chanpinMap.get(cz.getChanpin().getId())); } if (cz.getZujian() != null) { cz.setZujian(zujianMap.get(cz.getZujian().getId())); } if (cz.getBancai() != null) { cz.setBancai(bancaiMap.get(cz.getBancai().getId())); } } // 解析库存关联 for (Kucun k : kucuns) { if (k.getBancai() != null) { k.setBancai(bancaiMap.get(k.getBancai().getId())); } } } // 创建ID到对象的映射 private static <T extends EntityClassGrassrootsid> Map<Integer, T> createIdMap(List<T> list) { Map<Integer, T> map = new HashMap<>(); for (T item : list) { map.put(item.getId(), item); } return map; } // 回调接口 public interface LoadDataCallback { void onSuccess(); void onFailure(); } // 内部类用于解析JSON响应 public static class AllDataResponse { public List<Bancai> bancais; public List<Caizhi> caizhis; public List<Mupi> mupis; public List<Chanpin> chanpins; public List<Chanpin_Zujian> chanpin_zujians; public List<Dingdan> dingdans; public List<Dingdan_Chanpin> dingdan_chanpins; public List<Dingdan_chanpin_zujian> dingdan_bancais; public List<Kucun> kucuns; public List<Zujian> zujians; public List<User> users; public List<Jinhuo> jinhuos; } }package com.example.kucun2.entity.data; import android.util.Log; import java.beans.PropertyChangeEvent; import java.beans.PropertyChangeListener; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import java.util.List; import java.util.ListIterator; /** 支持数据变更自动同步的泛型集合类 基于SynchronizableEntity的事件机制实现数据变更自动同步 @param <T> 必须是SynchronizableEntity或其子类 */ public class SynchronizedList<T extends SynchronizableEntity> implements List<T> { // 使用ArrayList作为底层存储 private final List<T> list = new ArrayList<>(); public SynchronizedList(Class T ) { } // 实体变更监听器 private final EntityChangeListener<T> entityChangeListener = new EntityChangeListener<>(); @Override public int size() { return list.size(); } @Override public boolean isEmpty() { return list.isEmpty(); } @Override public boolean contains(Object o) { return list.contains(o); } @Override public Iterator<T> iterator() { return new SyncedIterator<>(list.iterator(), entityChangeListener); } @Override public Object[] toArray() { return list.toArray(); } @Override public <E> E[] toArray(E[] a) { return list.toArray(a); } // 添加元素时注册监听器 @Override public boolean add(T element) { if (element != null) { element.addPropertyChangeListener(entityChangeListener); } Log.d(“z”,“element”); return list.add(element); } // 移除元素时注销监听器 @Override public boolean remove(Object o) { if (o instanceof SynchronizableEntity) { ((SynchronizableEntity) o).removePropertyChangeListener(entityChangeListener); } return list.remove(o); } @Override public boolean containsAll(Collection<?> c) { return list.containsAll©; } // 批量添加时逐个注册监听器 @Override public boolean addAll(Collection<? extends T> c) { for (T element : c) { if (element != null) { element.addPropertyChangeListener(entityChangeListener); } } return list.addAll©; } @Override public boolean addAll(int index, Collection<? extends T> c) { for (T element : c) { if (element != null) { element.addPropertyChangeListener(entityChangeListener); } } return list.addAll(index, c); } // 批量移除时逐个注销监听器 @Override public boolean removeAll(Collection<?> c) { for (Object o : c) { if (o instanceof SynchronizableEntity) { ((SynchronizableEntity) o).removePropertyChangeListener(entityChangeListener); } } return list.removeAll©; } @Override public boolean retainAll(Collection<?> c) { // 先移除未保留元素的监听器 for (T element : list) { if (!c.contains(element)) { element.removePropertyChangeListener(entityChangeListener); } } return list.retainAll©; } // 清空集合时移除所有监听器 @Override public void clear() { for (T element : list) { element.removePropertyChangeListener(entityChangeListener); } list.clear(); } @Override public T get(int index) { return list.get(index); } // 替换元素时更新监听器 @Override public T set(int index, T element) { T oldElement = list.get(index); if (oldElement != null) { oldElement.removePropertyChangeListener(entityChangeListener); } if (element != null) { element.addPropertyChangeListener(entityChangeListener); } return list.set(index, element); } // 在指定位置添加元素时注册监听器 @Override public void add(int index, T element) { if (element != null) { element.addPropertyChangeListener(entityChangeListener); } list.add(index, element); } // 移除元素时注销监听器 @Override public T remove(int index) { T removed = list.remove(index); if (removed != null) { removed.removePropertyChangeListener(entityChangeListener); } return removed; } @Override public int indexOf(Object o) { return list.indexOf(o); } @Override public int lastIndexOf(Object o) { return list.lastIndexOf(o); } @Override public ListIterator<T> listIterator() { return new SyncedListIterator<>(list.listIterator(), entityChangeListener); } @Override public ListIterator<T> listIterator(int index) { return new SyncedListIterator<>(list.listIterator(index), entityChangeListener); } @Override public List<T> subList(int fromIndex, int toIndex) { return list.subList(fromIndex, toIndex); } /** 内部实体变更监听器 监听属性变化并触发同步操作 */ private static class EntityChangeListener<T extends SynchronizableEntity> implements PropertyChangeListener { @Override public void propertyChange(PropertyChangeEvent evt) { @SuppressWarnings(“unchecked”) T entity = (T) evt.getSource(); entity.sync(); // 触发同步操作 } } /** 增强的Iterator实现 移除元素时自动注销监听器 */ private static class SyncedIterator<T extends SynchronizableEntity> implements Iterator<T> { private final Iterator<T> iterator; private final EntityChangeListener<T> listener; private T current; public SyncedIterator(Iterator<T> iterator, EntityChangeListener<T> listener) { this.iterator = iterator; this.listener = listener; } @Override public boolean hasNext() { return iterator.hasNext(); } @Override public T next() { current = iterator.next(); return current; } @Override public void remove() { if (current != null) { current.removePropertyChangeListener(listener); } iterator.remove(); } } /** 增强的ListIterator实现 支持添加/设置元素时的监听器管理 */ private static class SyncedListIterator<T extends SynchronizableEntity> implements ListIterator<T> { private final ListIterator<T> iterator; private final EntityChangeListener<T> listener; private T lastReturned; public SyncedListIterator(ListIterator<T> iterator, EntityChangeListener<T> listener) { this.iterator = iterator; this.listener = listener; } @Override public boolean hasNext() { return iterator.hasNext(); } @Override public T next() { lastReturned = iterator.next(); return lastReturned; } @Override public boolean hasPrevious() { return iterator.hasPrevious(); } @Override public T previous() { lastReturned = iterator.previous(); return lastReturned; } @Override public int nextIndex() { return iterator.nextIndex(); } @Override public int previousIndex() { return iterator.previousIndex(); } @Override public void remove() { if (lastReturned != null) { lastReturned.removePropertyChangeListener(listener); } iterator.remove(); } @Override public void set(T e) { if (lastReturned != null) { lastReturned.removePropertyChangeListener(listener); } if (e != null) { e.addPropertyChangeListener(listener); } iterator.set(e); lastReturned = e; } @Override public void add(T e) { if (e != null) { e.addPropertyChangeListener(listener); } iterator.add(e); } } }package com.example.kucun2.entity.data; import android.util.Log; import com.example.kucun2.entity.Information; import com.example.kucun2.function.MyAppFnction; import java.beans.PropertyChangeListener; import java.beans.PropertyChangeSupport; import java.util.HashMap; import java.util.Map; public abstract class SynchronizableEntity implements EntityClassGrassrootsid { public enum SyncState { NEW, MODIFIED, DELETED } SyncState state = SyncState.NEW; // 设置状态的方法 public void setState(SyncState state) { this.state = state; } // 使用标准属性变更支持类 private transient PropertyChangeSupport changeSupport = new PropertyChangeSupport(this); // 属性缓存（可选，用于优化） private final Map<String, Object> propertyCache = new HashMap<>(); // 添加属性变更监听器 public void addPropertyChangeListener(PropertyChangeListener listener) { if (changeSupport == null) { changeSupport = new PropertyChangeSupport(this); } changeSupport.addPropertyChangeListener(listener); } // 移除属性变更监听器 public void removePropertyChangeListener(PropertyChangeListener listener) { if (changeSupport != null) { changeSupport.removePropertyChangeListener(listener); } } // 触发属性变更通知（子类在setter中调用） protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) { if (changeSupport != null && changeSupport.hasListeners(propertyName)) { // 更新属性缓存（可选） propertyCache.put(propertyName, newValue); // 触发变更事件 changeSupport.firePropertyChange(propertyName, oldValue, newValue); } } // 获取属性当前值（可选，用于setter中获取旧值） protected <T> T getCachedProperty(String propertyName) { return (T) propertyCache.get(propertyName); } // 初始化属性缓存（可选，在构造函数中调用） protected void initPropertyCache() { // 初始化所有字段到缓存 for (java.lang.reflect.Field field : getClass().getDeclaredFields()) { try { field.setAccessible(true); propertyCache.put(field.getName(), field.get(this)); } catch (Exception e) { // 忽略初始化异常 } } } /** * 添加url * @param type 操作增删改查 * @return 返回相对url */ public String getEndpoint(String type){ //从String.xml获取url Log.d("getEndpoint", "getEndpoint: "+"url_"+type+"_"+this.getClass().getSimpleName().toLowerCase()); return MyAppFnction.getStringResource("string","url_"+type+"_"+this.getClass().getSimpleName().toLowerCase()); } public void sync() { if (this.state == null) return; try { switch (this.state) { case NEW: createToServer(); break; case MODIFIED: updateToServer(); break; case DELETED: deleteFromServer(); break; } } catch (Exception e) { Log.e("SyncError", "Sync failed for " + getClass().getSimpleName(), e); } } /** * 创建实体到后端 */ private void createToServer() { String endpoint = MyAppFnction.getStringResource("string", "url") + getEndpoint("add"); Information<SynchronizableEntity> requestData = new Information<SynchronizableEntity>(); // 使用Volley、Retrofit或OkHttp执行POST请求 // 伪代码示例： ApiClient.post(endpoint, requestData, new ApiClient.ApiCallback<SynchronizableEntity>() { @Override public void onSuccess(Information<SynchronizableEntity> e) { // 解析服务器返回的ID Log.d("onSuccess",e.toJson()); // String serverId = parseServerId(response); // if (serverId != null) { // // 更新本地ID // setId(serverId); // 需要实体实现setId方法 // } state = SyncState.MODIFIED; } }); } /** * 更新实体到后端 */ private void updateToServer() { String endpoint = MyAppFnction.getStringResource("string", "url") + getEndpoint("update") + "/" + getId(); // 获取实体ID Information<SynchronizableEntity> requestData = new Information<SynchronizableEntity>(); ApiClient.post(endpoint, requestData, new ApiClient.ApiCallback<SynchronizableEntity>() { @Override public void onSuccess(Information<SynchronizableEntity> e) { // 解析服务器返回的ID Log.d("onSuccess",e.toJson()); // String serverId = parseServerId(response); // if (serverId != null) { // // 更新本地ID // setId(serverId); // 需要实体实现setId方法 // } // state = SyncState.MODIFIED; } }); } /** * 从后端删除实体 */ private void deleteFromServer() { String endpoint = MyAppFnction.getStringResource("string", "url") + getEndpoint("delete") + "/" + getId(); ApiClient.delete(endpoint, new ApiClient.ApiCallback<SynchronizableEntity>() { @Override public void onSuccess(Information<SynchronizableEntity> e) { Log.d("SyncDelete", "Successfully deleted " + getId()); } }); } /** * 将实体转换为请求映射 */ protected Information<SynchronizableEntity> toRequestMap(){ return Information.newSuccess(this); } } 初始加载数据时自动同步一直在出发
06-12
由于`SynchronizedList`中的元素都是`SynchronizableEntity`，我们可以这样写：在`SynchronizedList`类中（注意：这是一个泛型类，但我们可以写一个非泛型的方法）：publicvoidattachListenersToAll(){for(Telement:...
package com.example.kucun2.entity.data; import android.content.Context; import android.os.Handler; import android.os.Looper; import android.util.Log; import com.example.kucun2.entity.*; import com.example.kucun2.function.MyAppFnction; import com.example.kucun2.function.SafeLogger; import com.google.gson.Gson; import com.google.gson.reflect.TypeToken; import java.io.IOException; import java.lang.reflect.Field; import java.lang.reflect.ParameterizedType; 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> chanpin_zujians = new SynchronizedList<>(Chanpin_Zujian.class); public static SynchronizedList<Dingdan> dingdans = new SynchronizedList<>(Dingdan.class); public static SynchronizedList<Dingdan_Chanpin> dingdan_chanpins = new SynchronizedList<>(Dingdan_Chanpin.class); public static SynchronizedList<Dingdan_chanpin_zujian> Dingdan_chanpin_zujians = new SynchronizedList<>(Dingdan_chanpin_zujian.class); public static SynchronizedList<Kucun> kucuns = new SynchronizedList<>(Kucun.class); public static SynchronizedList<Zujian> zujians = new SynchronizedList<>(Zujian.class); public static SynchronizedList<User> users = new SynchronizedList<>(User.class); public static SynchronizedList<Jinhuo> jinhuos = new SynchronizedList<>(Jinhuo.class); public static final Map<Class,SynchronizedList<SynchronizableEntity>> dataCollectionMap=new HashMap<>(); private static final Gson gson = new Gson(); private static OkHttpClient client ; private static final String TAG = "DataLoader"; static { // 静态初始化块：在类加载时执行，保证所有静态字段已初始化 try { Field[] fields = Data.class.getDeclaredFields(); for (Field field : fields) { if (SynchronizedList.class.isAssignableFrom(field.getType())) { // 获取泛型类型参数 ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType(); Class<?> entityType = (Class<?>) parameterizedType.getActualTypeArguments()[0]; // 创建 SynchronizedList 并设置实体类型 SynchronizedList<?> list = new SynchronizedList<>((Class<SynchronizableEntity>) entityType); field.set(null, list); // 将列表添加到 dataCollectionMap if (list != null) { dataCollectionMap.put(entityType, (SynchronizedList<SynchronizableEntity>) list); } } } } catch (IllegalAccessException e) { throw new RuntimeException("初始化dataCollectionMap失败", e); } } public static void loadAllData(Context context, LoadDataCallback callback) { if (Looper.myLooper() != Looper.getMainLooper()) { throw new IllegalStateException("Data.loadAllData must be called on main thread"); } // 确保使用安全的客户端 if (client == null) { client= MyAppFnction.getClient(); } //禁用同步 SynchronizableEntity.setSyncEnabled(false); String url = MyAppFnction.getStringResource("string", "url") + MyAppFnction.getStringResource("string", "url_all"); Log.d("url", "loadAllData: " + url); Request request = new Request.Builder() .url(url) .build(); client.newCall(request).enqueue(new Callback() { @Override public void onFailure(Call call, IOException e) { Log.e(TAG, "Failed to load data", e); SynchronizableEntity.setSyncEnabled(true); if (callback != null)safeCallback(callback, false); } @Override public void onResponse(Call call, Response response) throws IOException { if (!response.isSuccessful()) { Log.e(TAG, "Unexpected response code: " + response.code()); if (callback != null) safeCallback(callback, false); return; } String responseData = response.body().string(); SynchronizableEntity.setSyncEnabled(true); ensurePreservedObjects(); parseAndAssignData(responseData, context, callback); } }); } // 解析并赋值数据 private static void parseAndAssignData(String jsonData, Context context, LoadDataCallback callback) { // 创建包含所有数据类型的TypeToken ensurePreservedObjects(); Type informationType = new TypeToken<Information<AllDataResponse>>(){}.getType(); Information<AllDataResponse> information = gson.fromJson(jsonData, informationType); Log.e(TAG, "Invalid response data"+jsonData); if (information == null || information.getData() == null || information.getStatus() != 200) { Log.e(TAG, "Invalid response data"); if (callback != null) callback.onFailure(); return; } AllDataResponse allData = information.getData(); SafeLogger.d("data","数据："+gson.toJson(allData)); safeInitializeList(allData.bancais); safeInitializeList(allData.caizhis); safeInitializeList(allData.mupis); safeInitializeList(allData.chanpins); safeInitializeList(allData.chanpin_zujians); safeInitializeList(allData.dingdans); safeInitializeList(allData.dingdan_chanpins); safeInitializeList(allData.Dingdan_chanpin_zujians); safeInitializeList(allData.kucuns); safeInitializeList(allData.zujians); safeInitializeList(allData.users); safeInitializeList(allData.jinhuos); SafeLogger.d("data","数据：非空"+gson.toJson(allData)); // 赋值到对应的列表（使用安全方法保持已有引用） updateList(bancais, allData.bancais); updateList(caizhis, allData.caizhis); updateList(mupis, allData.mupis); updateList(chanpins, allData.chanpins); updateList(chanpin_zujians, allData.chanpin_zujians); updateList(dingdans, allData.dingdans); updateList(dingdan_chanpins, allData.dingdan_chanpins); updateList(Dingdan_chanpin_zujians, allData.Dingdan_chanpin_zujians); updateList(kucuns, allData.kucuns); updateList(zujians, allData.zujians); updateList(users, allData.users); updateList(jinhuos, allData.jinhuos); SafeLogger.d("data","数据：data.bancais"+gson.toJson(Data.bancais)); // 在设置引用关系前关闭同步 SynchronizableEntity.setSyncEnabled(false); Log.d("DataParse", "开始解析JSON数据"); resolveReferences(); Log.d("DataParse", "解析完成，实体关系建立"); // 为所有实体设置正确状态（已存在服务器） setAllEntitiesState(SynchronizableEntity.SyncState.MODIFIED); ensurePreservedObjects(); // 启用同步 SynchronizableEntity.setSyncEnabled(true); if (callback != null) callback.onSuccess(); } public static void safeCallback(LoadDataCallback callback, boolean success) { new Handler(Looper.getMainLooper()).post(() -> { if (success) { callback.onSuccess(); } else { callback.onFailure(); } }); } // 更新列表内容但保持对象引用不变 private static <T extends SynchronizableEntity> void updateList(List<T> existingList, List<T> newList) { if (newList == null) return; // 创建临时列表保留预置对象 List<T> preservedObjects = new ArrayList<>(); for (T item : existingList) { if (item != null && item.isPreservedObject()) { preservedObjects.add(item); } } // 清除原有列表并添加保留对象 existingList.clear(); existingList.addAll(preservedObjects); // 添加新数据，跳过预置对象的ID for (T newItem : newList) { if (newItem.getId() != null && newItem.getId() != -1) { existingList.add(newItem); } } } // 添加确保预置对象存在的方法 private static void ensurePreservedObjects() { if (!containsPreservedObject(bancais)) bancais.add(createInstance(Bancai.class)); if (!containsPreservedObject(caizhis)) caizhis.add(createInstance(Caizhi.class)); if (!containsPreservedObject(mupis)) mupis.add(createInstance(Mupi.class)); if (!containsPreservedObject(chanpins)) chanpins.add(createInstance(Chanpin.class)); if (!containsPreservedObject(chanpin_zujians)) chanpin_zujians.add(createInstance(Chanpin_Zujian.class)); if (!containsPreservedObject(dingdans)) dingdans.add(createInstance(Dingdan.class)); if (!containsPreservedObject(kucuns)) kucuns.add(createInstance(Kucun.class)); if (!containsPreservedObject(zujians)) zujians.add(createInstance(Zujian.class)); if (!containsPreservedObject(Dingdan_chanpin_zujians)) Dingdan_chanpin_zujians.add(createInstance(Dingdan_chanpin_zujian.class)); if (!containsPreservedObject(dingdan_chanpins)) dingdan_chanpins.add(createInstance(Dingdan_Chanpin.class)); if (!containsPreservedObject(jinhuos)) jinhuos.add(createInstance(Jinhuo.class)); if (!containsPreservedObject(users)) users.add(createInstance(User.class)); // 为其他需要预置对象的列表添加... try { setDefaultAssociation(bancais); } catch (IllegalAccessException e) { throw new RuntimeException(e); } catch (ClassNotFoundException e) { throw new RuntimeException(e); } } // 检查列表是否包含预置对象 private static <T extends SynchronizableEntity> boolean containsPreservedObject(List<T> list) { for (T item : list) { if (item != null && item.isPreservedObject()) { Log.d(TAG, "containsPreservedObject: "+item.getId()); item= (T) createInstance(item.getClass()); return true; } } return !list.isEmpty(); } private static <T extends SynchronizableEntity> void setDefaultAssociation(SynchronizedList<T> e ) throws IllegalAccessException, ClassNotFoundException { for (T t:e) { Class clazz=t.getClass(); Field[] fields = clazz.getDeclaredFields(); for (Field f:fields){ f.setAccessible(true); Class s=f.getType(); if(SynchronizableEntity.class.isAssignableFrom(s)){ if (t.getId()<0 ||f.get(t)==null|| ((SynchronizableEntity)f.get(t)).getId()==null) { f.set(t, dataCollectionMap.get(s).get(-1)); }else { f.set(t, dataCollectionMap.get(s).get( ((SynchronizableEntity)f.get(t)).getId())); } } if (List.class.isAssignableFrom(s)){ Type genericSuperclass = s.getGenericSuperclass(); if (genericSuperclass instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) genericSuperclass; Type[] types = pt.getActualTypeArguments(); System.out.println("集合类型: " + types[0].getTypeName()); // User Class c=Class.forName(types[0].getTypeName()); if(SynchronizableEntity.class.isAssignableFrom(c)) { List<SynchronizableEntity> l = (List<SynchronizableEntity>) f.get(t); if (l == null) { l = new ArrayList(); } if (l.isEmpty() || t.getId() < 0) { l.add(dataCollectionMap.get(c).get(-1)); } if (!l.isEmpty()) { for (int i = 0; i < l.size(); i++) { l.set(i,dataCollectionMap.get(c).get( l.get(i).getId())); } } } } } } } } /** * 根据传入的Class对象创建对应类型的实例 * @param clazz 目标类型对应的Class对象 * @param <T> 目标类型泛型参数 * @return 指定类型的实例 */ public static <T> T createInstance(Class<T> clazz) { try { // 通过反射调用无参构造函数创建实例 T g=clazz.getDeclaredConstructor().newInstance(); // Log.d("g",""+g); Field[] fields = clazz.getDeclaredFields(); for (Field f: fields ) { f.setAccessible(true); if(f.getType().equals(String.class)){ f.set(g,"无"); } if(f.getType().equals(Integer.class)){ f.set(g,-1); }if(f.getType().equals(Double.class)){ f.set(g,-1.0); } if (f.getType().equals(Date.class)){ f.set(g,new Date()); } } Log.d("g",""+gson.toJson(g)); clazz.getMethod("setId",Integer.class).invoke(g,-1); clazz.getMethod("setState", SynchronizableEntity. SyncState.class) .invoke(g,SynchronizableEntity.SyncState.PRESERVED); return g; } catch (Exception e) { Log.d(TAG, "createInstance: "+e.getLocalizedMessage()); throw new RuntimeException("创建实例失败: " + clazz.getName(), e); } } // // 创建预置板材对象 // private static<T> T createPreservedBancai(Class<T> t) { // Bancai preserved = new Bancai(); // preserved.setId(-1); // preserved.setState(SynchronizableEntity.SyncState.PRESERVED); // return preserved; // } // 解析对象间的引用关系（使用ID关联） private static void resolveReferences() { // 创建ID到对象的映射 Map<Integer, Bancai> bancaiMap = createIdMap(bancais); Map<Integer, Caizhi> caizhiMap = createIdMap(caizhis); Map<Integer, Mupi> mupiMap = createIdMap(mupis); Map<Integer, Chanpin> chanpinMap = createIdMap(chanpins); Map<Integer, Zujian> zujianMap = createIdMap(zujians); Map<Integer, Dingdan> dingdanMap = createIdMap(dingdans); Map<Integer, Kucun> kucunMap = createIdMap(kucuns); Log.d("RefResolution", "开始解析实体关系..."); // 解析Bancai引用 for (Bancai bancai : bancais) { if (bancai.getCaizhi() != null) { bancai.setCaizhi(caizhiMap.get(bancai.getCaizhi().getId())); } if (bancai.getMupi1() != null) { bancai.setMupi1(mupiMap.get(bancai.getMupi1().getId())); } if (bancai.getMupi2() != null) { bancai.setMupi2(mupiMap.get(bancai.getMupi2().getId())); } } // 解析Kucun引用 for (Kucun kucun : kucuns) { if(kucun==null)break; if (kucun.getBancai() != null) { kucun.setBancai(bancaiMap.get(kucun.getBancai().getId())); } } // 解析订单相关的嵌套对象 for (Dingdan_Chanpin dc : dingdan_chanpins) { if(dc==null)break; if (dc.getDingdan() != null) { dc.setDingdan(dingdanMap.get(dc.getDingdan().getId())); } if (dc.getChanpin() != null) { dc.setChanpin(chanpinMap.get(dc.getChanpin().getId())); } } // 解析产品相关的嵌套对象 for (Chanpin_Zujian cz : chanpin_zujians) { if(cz==null)break; if (cz.getChanpin() != null) { cz.setChanpin(chanpinMap.get(cz.getChanpin().getId())); } if (cz.getZujian() != null) { cz.setZujian(zujianMap.get(cz.getZujian().getId())); } if (cz.getBancai() != null) { cz.setBancai(bancaiMap.get(cz.getBancai().getId())); } } // 解析库存关联 for (Kucun k : kucuns) { if(k==null)break; if (k.getBancai() != null) { k.setBancai(bancaiMap.get(k.getBancai().getId())); } } // 添加缺失的实体关系解析 for (Dingdan_chanpin_zujian dm : Dingdan_chanpin_zujians) { if (dm.getZujian() != null) { // 确保组件和板材关联 dm.setZujian(chanpin_zujians.stream() .filter(cz -> cz.getId().equals(dm.getZujian().getId())) .findFirst().orElse(null)); if (dm.getBancai() != null) { dm.setBancai(bancais.stream() .filter(b -> b.getId().equals(dm.getBancai().getId())) .findFirst().orElse(null)); } } } } // 创建ID到对象的映射 private static <T extends EntityClassGrassrootsid> Map<Integer, T> createIdMap(List<T> list) { return createSafeIdMap(list); } // 回调接口 public interface LoadDataCallback { void onSuccess(); void onFailure(); } // 确保列表不为null private static <T> void safeInitializeList(List<T> list) { if (list == null) { list = new ArrayList<>(); } } // 安全创建ID映射 private static <T extends EntityClassGrassrootsid> Map<Integer, T> createSafeIdMap(List<T> list) { Map<Integer, T> map = new HashMap<>(); if (list != null) { for (T item : safeIterable(list)) { if (item != null && item.getId() != null) { map.put(item.getId(), item); } } } return map; } // 安全迭代方法（处理空集合） private static <T> Iterable<T> safeIterable(List<T> list) { return list != null ? list : Collections.emptyList(); } // 内部类用于解析JSON响应 public static class AllDataResponse { public List<Bancai> bancais; public List<Caizhi> caizhis; public List<Mupi> mupis; public List<Chanpin> chanpins; public List<Chanpin_Zujian> chanpin_zujians; public List<Dingdan> dingdans; public List<Dingdan_Chanpin> dingdan_chanpins; public List<Dingdan_chanpin_zujian> Dingdan_chanpin_zujians; public List<Kucun> kucuns; public List<Zujian> zujians; public List<User> users; public List<Jinhuo> jinhuos; } // 新增方法：设置所有实体状态 private static void setAllEntitiesState(SynchronizableEntity.SyncState state) { setListState(bancais, state); setListState(caizhis, state); setListState(mupis, state); setListState(Dingdan_chanpin_zujians, state); setListState(dingdans, state); setListState(chanpins, state); setListState(chanpin_zujians, state); setListState(zujians, state); setListState(jinhuos, state); setListState(kucuns, state); setListState(users, state); setListState(caizhis, state); // ... 其他列表 } private static <T extends SynchronizableEntity> void setListState(List<T> list, SynchronizableEntity.SyncState state) { for (T entity : list) { entity.setState(state); } } } E FATAL EXCEPTION: main Process: com.example.kucun2, PID: 21888 java.lang.ExceptionInInitializerError at com.example.kucun2.MainActivity.loadAppData(MainActivity.java:100) at com.example.kucun2.MainActivity.onCreate(MainActivity.java:31) at android.app.Activity.performCreate(Activity.java:9441) at android.app.Activity.performCreate(Activity.java:9387) at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1526) at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:4644) at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:4876) at android.app.servertransaction.LaunchActivityItem.execute(LaunchActivityItem.java:112) at android.app.servertransaction.TransactionExecutor.executeNonLifecycleItem(TransactionExecutor.java:220) at android.app.servertransaction.TransactionExecutor.executeTransactionItems(TransactionExecutor.java:148) at android.app.servertransaction.TransactionExecutor.execute(TransactionExecutor.java:120) at android.app.ActivityThread$H.handleMessage(ActivityThread.java:3102) at android.os.Handler.dispatchMessage(Handler.java:109) at android.os.Looper.loopOnce(Looper.java:250) at android.os.Looper.loop(Looper.java:340) at android.app.ActivityThread.main(ActivityThread.java:9913) at java.lang.reflect.Method.invoke(Native Method) at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:621) at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:957) Caused by: java.lang.IllegalArgumentException: Entity type cannot be null at com.example.kucun2.entity.data.SynchronizedList.<init>(SynchronizedList.java:35) at com.example.kucun2.entity.data.Data.<clinit>(Data.java:26) ... 19 more
最新发布
06-13
但是，请注意：在静态字段初始化时，我们直接为这些字段赋值（例如：`publicstaticSynchronizedList<Bancai>bancais=newSynchronizedList<>(Bancai.class);`）。然后，在静态块中，我们又尝试通过反射重新创建这些...
泛型类java_Java泛型 - 通用类( Generic Classes)
weixin_36314117的博客
02-12 512
Java泛型 - 通用类( Generic Classes)泛型类声明看起来像非泛型类声明，除了类名后跟一个类型参数部分。泛型类的类型参数部分可以有一个或多个用逗号分隔的类型参数。 这些类称为参数化类或参数化类型，因为它们接受一个或多个参数。语法 (Syntax)public class Box {private T t;}哪里Box - Box是一个通用类。T - 传递给泛型类的泛型类型参数...
Java基础-泛型
d0d0bird的博客
01-07 306
Java基础-泛型 1.概述 Java泛型（generics）是JDK 5中引入的一个新特性，允许在定义类和接口的时候使用类型参数（type parameter）。声明的类型参数在使用时用具体的类型来替换。 可用于泛型类、泛型接口、泛型方法。 如何理解上面的定义呢，类型参数是什么？ 说起参数，都会想到定义方法时要定义形参，调用方法时要传入实参。当一个方法可以适配多种类型的参数， 可以将形参设为Ob...
java泛型详解
R_TJW的博客
08-29 953
java泛型 概述 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？ 顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参）， 然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制...
泛型概述一
d773689630的专栏
06-29 170
# 泛型概述 1. 为什么要用泛型: 泛型在定义方面与定义接口,方法,类很相似,区别在于参数. 方法接口类使用形参-->用值 泛型使用类型参数-->类型 ### 泛型的优点 1.在编译期间强类型检查,把代码检查提前至编译时:Java编译器将强类型检查用于通用代码,如果代码违反类型安全就会报错 2.消除类型转换 ``` //需要类型转换 ArrayList list=new ArrayList(); list.add("add"); String str=...
泛型接口的定义参考
weixin_34393428的博客
08-30 165
泛型接口的定义就是： public interface IDAL<T> where T : class { int Insert(T model); int Update(T model); int Delete(int id); T GetModel(int id); ILi...
Java泛型详解
qq_44707077的博客
08-03 656
文章目录第一次接触泛型 完成泛型概念好处泛型与多态无关泛型类基本原理泛型方法类型参数的限定泛型的上界泛型接口泛型通配符无限定通配符 `<？>`有限定通配符 `<? extends >`超类型通配符`< ? super >`泛型擦除为什么进行泛型擦除？运行时获取泛型信息泛型擦除与静态类型 第一次接触泛型 完成 使用容器类时 ArrayList<Integer> list = new ArrayList<>(); list.add(123); Inte
泛型使用
watson1360884839的博客
11-29 252
使用大写字母A,B,C,D......X,Y,Z定义的，就都是泛型，把T换成A也一样，这里T只是名字上的意义而已 ？ 表示不确定的java类型 T (type) 表示具体的一个java类型 K V (key value) 分别代表java键值中的Key Value E (element) 代表Element 一、List&lt;T&gt;，List&lt;?&gt;，T，Class&lt;...
泛型类的定义方法分享
qq_25073223的博客
05-30 469
泛型类的简介说明
Java泛型详解：＜T＞和Class＜T＞的使用。泛型类，泛型方法的详细使用实例
ly969434341的专栏
10-16 570
Java泛型详解：和Class的使用。泛型类，泛型方法的详细使用实例 https://blog.youkuaiyun.com/qq_27093465/article/details/73229016
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值