package com
.example
.kucun2
.ui
.jinhuo;
import android
.app
.AlertDialog;
import android
.app
.DatePickerDialog;
import android
.os
.Bundle;
import android
.util
.Log;
import android
.view
.LayoutInflater;
import android
.view
.View;
import android
.view
.ViewGroup;
import android
.widget
.AdapterView;
import android
.widget
.Button;
import android
.widget
.EditText;
import android
.widget
.RadioGroup;
import android
.widget
.SearchView;
import android
.widget
.Spinner;
import android
.widget
.Toast;
import androidx
.annotation
.NonNull;
import androidx
.fragment
.app
.Fragment;
import com
.example
.kucun2
.R;
import com
.example
.kucun2
.entity
.*;
import com
.example
.kucun2
.entity
.data
.Data;
import com
.example
.kucun2
.entity
.data
.ReflectionJsonUtils;
import com
.example
.kucun2
.function
.Adapter;
import java
.text
.ParseException;
import java
.text
.SimpleDateFormat;
import java
.util
.ArrayList;
import java
.util
.Calendar;
import java
.util
.Date;
import java
.util
.List;
import java
.util
.Locale;
public class AddInventoryFragment extends Fragment {
// UI组件声明
private Spinner spinnerDingdan, spinnerChanpin, spinnerZujian, spinne
rBancai;
private EditText etShuliang;
private RadioGroup rgType;
private Button btnNewDingdan, btnAddChanpin, btnAddZujian;
// 当前选中项
private Dingdan selectedDingdan;
private Chanpin selectedChanpin;
private Zujian selectedZujian;
private Bancai selectedBancai;
private View rootView;
// 日期格式化工具
private final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd", Locale
.getDefault());
private static final String TAG = "AddInventoryFragment";
@Override
public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
rootView = inflater
.inflate(R
.layout
.fragment_add_inventory, container, false);
initViews(rootView);
setupEventListeners();
return rootView;
}
/** 初始化UI组件 */
private void initViews(View view) {
spinnerDingdan = view
.findViewById(R
.id
.spinner_dingdan);
spinnerChanpin = view
.findViewById(R
.id
.spinner_chanpin);
spinnerZujian = view
.findViewById(R
.id
.spinner_zujian);
spinne
rBancai = view
.findViewById(R
.id
.spinner_bancai);
etShuliang = view
.findViewById(R
.id
.et_shuliang);
rgType = view
.findViewById(R
.id
.rg_type);
btnNewDingdan = view
.findViewById(R
.id
.btn_new_dingdan);
btnAddChanpin = view
.findViewById(R
.id
.btn_add_chanpin);
btnAddZujian = view
.findViewById(R
.id
.btn_add_zujian);
}
/** 设置事件监听器 */
private void setupEventListeners() {
// 新建订单按钮
btnNewDingdan
.setOnClickListener(v -> showNewDingdanDialog());
// 添加产品按钮
btnAddChanpin
.setOnClickListener(v -> showAddChanpinDialog());
// 添加组件按钮
btnAddZujian
.setOnClickListener(v -> {
if (selectedChanpin == null) {
Toast
.makeText(getContext(), "请先选择产品", Toast
.LENGTH_SHORT)
.show();
return;
}
showCreateZujianDialog();
});
// 提交按钮
rootView
.findViewById(R
.id
.btn_submit)
.setOnClickListener(v -> addInventoryRecord());
// 订单下拉框监听
spinnerDingdan
.setOnItemSelectedListener(new AdapterView
.OnItemSelectedListener() {
@Override
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
selectedDingdan = (Dingdan) parent
.getItemAtPosition(position);
setupChanpinSpinner(selectedDingdan);
}
@Override
public void onNothingSelected(AdapterView<?> parent) {}
});
}
/** 设置订单下拉框 */
private void setupDingdanSpinner() {
Adapter
.setupDingdanSpinner(spinnerDingdan, Data
.dingdans, getContext());
}
/** 设置产品下拉框 */
private void setupChanpinSpinner(Dingdan dingdan) {
List<Chanpin> chanpins = new ArrayList<>();
if (dingdan != null && dingdan
.getDingdanChanpin() != null) {
for (Dingdan_Chanpin dc : dingdan
.getDingdanChanpin()) {
if (dc != null && dc
.getChanpin() != null) {
chanpins
.add(dc
.getChanpin());
}
}
}
Adapter
.setupChanpinSpinner(spinnerChanpin, chanpins, getContext());
spinnerChanpin
.setOnItemSelectedListener(new AdapterView
.OnItemSelectedListener() {
@Override
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
selectedChanpin = (Chanpin) parent
.getItemAtPosition(position);
if (selectedChanpin != null) {
setupZujianSpinner(selectedChanpin);
}
}
@Override
public void onNothingSelected(AdapterView<?> parent) {}
});
}
/** 设置组件下拉框 */
private void setupZujianSpinner(Chanpin chanpin) {
List<Zujian> zujians = new ArrayList<>();
for (Chanpin_Zujian cz : chanpin
.getChanpinZujian()) {
zujians
.add(cz
.getZujian());
}
Adapter
.setupZujianSpinner(spinnerZujian, zujians, getContext());
spinnerZujian
.setOnItemSelectedListener(new AdapterView
.OnItemSelectedListener() {
@Override
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
selectedZujian = (Zujian) parent
.getItemAtPosition(position);
setupBancaiSpinner(selectedChanpin, selectedZujian);
}
@Override
public void onNothingSelected(AdapterView<?> parent) {}
});
}
/** 设置板材下拉框 */
private void setupBancaiSpinner(Chanpin chanpin, Zujian zujian) {
List<Bancai> bancais = new ArrayList<>();
for (Chanpin_Zujian cz : chanpin
.getChanpinZujian()) {
if (cz
.getZujian()
.getId()
.equals(zujian
.getId())) {
bancais
.add(cz
.getBancai());
}
}
Adapter
.setupBancaiSpinners(spinne
rBancai, bancais, getContext());
}
/** 添加库存记录 */
private void addInventoryRecord() {
// 验证必填项
if (selectedDingdan == null || selectedChanpin == null ||
selectedZujian == null || selectedBancai == null) {
Toast
.makeText(getContext(), "请选择订单、产品、组件和板材", Toast
.LENGTH_SHORT)
.show();
return;
}
String shuliangStr = etShuliang
.getText()
.toString()
.trim();
if (shuliangStr
.isEmpty()) {
Toast
.makeText(getContext(), "请输入数量", Toast
.LENGTH_SHORT)
.show();
return;
}
try {
int shuliang = Integer
.parseInt(shuliangStr);
boolean isJinhuo = rgType
.getCheckedRadioButtonId() == R
.id
.rb_jinhuo;
User currentUser = new User(1, "当前用户", "user", "password", 1);
createRecord(selectedDingdan, selectedChanpin, selectedZujian,
selectedBancai, shuliang, isJinhuo, currentUser);
Toast
.makeText(getContext(), "记录添加成功", Toast
.LENGTH_SHORT)
.show();
etShuliang
.setText("");
} catch (NumberFormatException e) {
Toast
.makeText(getContext(), "请输入有效的数量", Toast
.LENGTH_SHORT)
.show();
}
}
/** 创建库存记录 */
private void createRecord(Dingdan dingdan, Chanpin chanpin, Zujian zujian,
Bancai bancai, int shuliang, boolean isJinhuo, User user) {
if (isJinhuo) {
Jinhuo jinhuo = new Jinhuo();
jinhuo
.setId(Data
.jinhuos
.size() + 1);
jinhuo
.setDingdan(dingdan);
jinhuo
.setChanpin(chanpin);
jinhuo
.setZujian(zujian);
jinhuo
.setBancai(bancai);
jinhuo
.setShuliang(shuliang);
jinhuo
.setDate(new Date());
jinhuo
.setUser(user);
Data
.jinhuos
.add(jinhuo);
} else {
shuliang = -shuliang;
}
updateKucun(bancai, shuliang);
}
/** 更新库存 */
private void updateKucun(Bancai bancai, int changeAmount) {
for (Kucun k : Data
.kucuns) {
if (k
.getBancai()
.getId()
.equals(bancai
.getId())) {
k
.setShuliang(k
.getShuliang() + changeAmount);
return;
}
}
// 创建新库存记录
Kucun newKucun = new Kucun();
newKucun
.setId(Data
.kucuns
.size() + 1);
newKucun
.setBancai(bancai);
newKucun
.setShuliang(Math
.max(changeAmount, 0));
Data
.kucuns
.add(newKucun);
}
/** 显示添加产品对话框 */
private void showAddChanpinDialog() {
if (selectedDingdan == null) {
Toast
.makeText(getContext(), "请先选择订单", Toast
.LENGTH_SHORT)
.show();
return;
}
AlertDialog
.Builder builder = new AlertDialog
.Builder(requireContext());
builder
.setTitle("添加产品到订单");
View dialogView = LayoutInflater
.from(requireContext())
.inflate(R
.layout
.dialog_add_chanpin, null);
Spinner spinnerChanpinSelection = dialogView
.findViewById(R
.id
.spinner_chanpin_selection);
// 设置产品下拉框
if (Data
.chanpins
.isEmpty()) {
Toast
.makeText(getContext(), "没有可用的产品，请先创建产品", Toast
.LENGTH_SHORT)
.show();
return;
}
Adapter
.setupChanpinSpinner(spinnerChanpinSelection, Data
.chanpins, getContext());
builder
.setView(dialogView);
builder
.setPositiveButton("添加", (dialog, which) -> {
Chanpin selected = (Chanpin) spinnerChanpinSelection
.getSelectedItem();
if (selected != null) addChanpinToDingdan(selected);
});
builder
.setNegativeButton("取消", null);
builder
.show();
}
/** 添加产品到订单 */
private void addChanpinToDingdan(Chanpin chanpin) {
// 检查是否已添加
for (Dingdan_Chanpin dc : selectedDingdan
.getDingdanChanpin()) {
if (dc
.getChanpin()
.getId()
.equals(chanpin
.getId())) {
Toast
.makeText(getContext(), "该产品已添加到订单", Toast
.LENGTH_SHORT)
.show();
return;
}
}
// 创建关联对象
Dingdan_Chanpin dc = new Dingdan_Chanpin();
dc
.setChanpin(chanpin);
dc
.setDingdan(selectedDingdan);
selectedDingdan
.getDingdanChanpin()
.add(dc);
// 刷新UI
setupChanpinSpinner(selectedDingdan);
spinnerChanpin
.setSelection(selectedDingdan
.getDingdanChanpin()
.size() - 1);
Toast
.makeText(getContext(), "产品添加成功", Toast
.LENGTH_SHORT)
.show();
}
/** 显示新建订单对话框 */
private void showNewDingdanDialog() {
AlertDialog
.Builder builder = new AlertDialog
.Builder(requireContext());
builder
.setTitle("新建订单");
View dialogView = LayoutInflater
.from(requireContext())
.inflate(R
.layout
.dialog_new_dingdan, null);
// 初始化视图
EditText etOrderNumber = dialogView
.findViewById(R
.id
.et_order_number);
EditText etOrderDate = dialogView
.findViewById(R
.id
.et_order_date);
Button btnPickOrderDate = dialogView
.findViewById(R
.id
.btn_pick_order_date);
// 设置默认日期
etOrderDate
.setText(dateFormat
.format(new Date()));
// 日期选择器
btnPickOrderDate
.setOnClickListener(v -> showDatePicker(etOrderDate));
builder
.setView(dialogView);
builder
.setPositiveButton("创建", (dialog, which) -> {
String orderNumber = etOrderNumber
.getText()
.toString()
.trim();
if (orderNumber
.isEmpty()) {
Toast
.makeText(getContext(), "请输入订单号", Toast
.LENGTH_SHORT)
.show();
return;
}
// 检查订单号是否重复
for (Dingdan d : Data
.dingdans) {
if (d
.getNumber()
.equals(orderNumber)) {
Toast
.makeText(getContext(), "订单号已存在", Toast
.LENGTH_SHORT)
.show();
return;
}
}
try {
Date orderDate = dateFormat
.parse(etOrderDate
.getText()
.toString());
createAndSaveDingdan(orderNumber, orderDate, null);
} catch (ParseException e) {
Toast
.makeText(getContext(), "日期格式错误", Toast
.LENGTH_SHORT)
.show();
}
});
builder
.setNegativeButton("取消", null);
builder
.show();
}
/** 创建并保存订单 */
private void createAndSaveDingdan(String orderNumber, Date orderDate, Date deliveryDate) {
Dingdan newDingdan = new Dingdan();
newDingdan
.setId(Data
.dingdans
.size() + 1);
newDingdan
.setNumber(orderNumber);
newDingdan
.setXiadan(orderDate);
newDingdan
.setJiaohuo(deliveryDate);
newDingdan
.setDingdanChanpin(new ArrayList<>());
Data
.dingdans
.add(newDingdan);
// 刷新UI
setupDingdanSpinner();
spinnerDingdan
.setSelection(Data
.dingdans
.size() - 1);
Toast
.makeText(getContext(), "新建订单成功", Toast
.LENGTH_SHORT)
.show();
}
/** 显示日期选择器 */
private void showDatePicker(EditText targetField) {
Calendar cal = Calendar
.getInstance();
new DatePickerDialog(requireContext(),
(view, year, month, dayOfMonth) -> {
Calendar selected = Calendar
.getInstance();
selected
.set(year, month, dayOfMonth);
targetField
.setText(dateFormat
.format(selected
.getTime()));
},
cal
.get(Calendar
.YEAR),
cal
.get(Calendar
.MONTH),
cal
.get(Calendar
.DAY_OF_MONTH)
)
.show();
}
/** 显示创建组件对话框 */
private void showCreateZujianDialog() {
AlertDialog
.Builder builder = new AlertDialog
.Builder(requireContext());
builder
.setTitle("添加新组件");
View dialogView = LayoutInflater
.from(requireContext())
.inflate(R
.layout
.dialog_create_zujian_bancai, null);
// 初始化视图
Spinner etZujianName = dialogView
.findViewById(R
.id
.et_zujian_name);
Spinner spinne
rbancai = dialogView
.findViewById(R
.id
.spinner_bancai);
SearchView searchBancai = dialogView
.findViewById(R
.id
.search_bancai);
// 设置适配器
Adapter
.setupZujianSpinner(etZujianName, Data
.zujians, getContext());
Adapter
.setupBancaiSpinners(spinne
rbancai, Data
.bancais, getContext());
// 设置搜索功能
searchBancai
.setOnQueryTextListener(new SearchView
.OnQueryTextListener() {
@Override
public boolean onQueryTextSubmit(String query) { return false; }
@Override
public boolean onQueryTextChange(String newText) {
List<Bancai> filtered = new ArrayList<>();
for (Bancai b : Data
.bancais) {
if (b
.TableText()
.toLowerCase()
.contains(newText
.toLowerCase())) {
filtered
.add(b);
}
}
Adapter
.setupBancaiSpinners(spinne
rbancai, filtered, getContext());
return true;
}
});
builder
.setView(dialogView);
builder
.setPositiveButton("创建", (dialog, which) -> {
Zujian zujian = (Zujian) etZujianName
.getSelectedItem();
Bancai bancai = (Bancai) spinne
rbancai
.getSelectedItem();
if (zujian == null || bancai == null) {
Toast
.makeText(getContext(), "请选择组件和板材", Toast
.LENGTH_SHORT)
.show();
return;
}
// 创建关联对象
Chanpin_Zujian cz = new Chanpin_Zujian();
cz
.setZujian(zujian);
cz
.setBancai(bancai);
cz
.setChanpin(selectedChanpin);
selectedChanpin
.getChanpinZujian()
.add(cz);
// 刷新UI
setupZujianSpinner(selectedChanpin);
spinnerZujian
.setSelection(selectedChanpin
.getChanpinZujian()
.size() - 1);
Toast
.makeText(getContext(), "组件添加成功", Toast
.LENGTH_SHORT)
.show();
});
builder
.setNegativeButton("取消", null);
builder
.show();
}
}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
.*;
import java
.util
.*;
import java
.util
.stream
.Collectors;
import okhttp3
.*;
/**
* 核心数据管理类
* 负责：
* 1
. 声明所有实体类的静态存储列表
* 2
. 从服务器加载全量数据
* 3
. 管理实体间的关联关系
* 4
. 处理数据同步状态
*/
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 = GsonFactory
.createWithIdSerialization();
private static OkHttpClient client;
private static final String TAG = "DataLoader";
// 静态初始化：建立实体类型与列表的映射关系
static {
try {
// 通过反射获取所有SynchronizedList字段
for (Field field : Data
.class
.getDeclaredFields()) {
if (SynchronizedList
.class
.equals(field
.getType())) {
SynchronizedList<?> list = (SynchronizedList<?>) field
.get(null);
if (list != null) {
// 将实体类型与列表关联
dataCollectionMap
.put(list
.getEntityType(), (SynchronizedList<SynchronizableEntity>) list);
}
}
}
} catch (IllegalAccessException e) {
throw new RuntimeException("初始化dataCollectionMap失败", e);
}
}
// ====================== 核心数据加载方法 ======================
/**
* 从服务器加载全量数据
* @param context Android上下文
* @param callback 加载结果回调
*/
public static void loadAllData(Context context, LoadDataCallback callback) {
// 主线程检查
if (Looper
.myLooper() != Looper
.getMainLooper()) {
throw new IllegalStateException("必须在主线程调用Data
.loadAllData");
}
ensurePreservedObjects(); // 确保存在预置对象
// 使用传入的 Context 获取主线程 Handler
Handler mainHandler = new Handler(context
.getMainLooper());
// 确保使用安全的客户端
if (client == null) {
client = MyAppFnction
.getClient();
}
SynchronizableEntity
.setSyncEnabled(false);
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);
SynchronizableEntity
.setSyncEnabled(true);
mainHandler
.post(() -> {
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());
SynchronizableEntity
.setSyncEnabled(true);
mainHandler
.post(() -> {
if (callback != null) callback
.onFailure();
});
return;
}
String responseData = response
.body()
.string();
SynchronizableEntity
.setSyncEnabled(true);
ensurePreservedObjects();
// 在主线程处理解析
mainHandler
.post(() -> {
parseAndAssignData(responseData, context, callback);
});
}
});
}
// ====================== 数据处理私有方法 ======================
/**
* 解析JSON数据并更新到实体列表
*/
private static void parseAndAssignData(String jsonData, Context context, LoadDataCallback callback) {
try {
// 解析顶层响应结构
Type responseType = new TypeToken<Information<AllDataResponse>>() {}
.getType();
Information<AllDataResponse> info = gson
.fromJson(jsonData, responseType);
// 验证响应有效性
if (info == null || info
.getData() == null || info
.getStatus() != 200) {
throw new IllegalStateException("无效服务器响应");
}
AllDataResponse allData = info
.getData();
SafeLogger
.d("data", "原始数据: " + gson
.toJson(allData));
// 更新所有数据列表
updateAllLists(allData);
automaticAssociation(); // 建立实体关联
setAllEntitiesState(SynchronizableEntity
.SyncState
.MODIFIED); // 设置状态
safeCallback(callback, true); // 成功回调
} catch (Exception e) {
Log
.e(TAG, "数据处理异常: " + e
.getMessage());
safeCallback(callback, false);
} finally {
SynchronizableEntity
.setSyncEnabled(true); // 重新启用同步
}
}
/**
* 批量更新所有实体列表
*/
private static void updateAllLists(AllDataResponse 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);
}
/**
* 安全更新单个列表（保留预置对象）
*/
private static <T extends SynchronizableEntity> void updateList(
List<T> existingList,
List<T> newList
) {
if (newList == null) return;
// 保留现有列表中的预置对象
List<T> preservedItems = existingList
.stream()
.filter(item -> item != null && item
.isPreservedObject())
.collect(Collectors
.toList());
// 清空后重新添加（预置对象 + 有效新数据）
existingList
.clear();
existingList
.addAll(preservedItems);
existingList
.addAll(newList
.stream()
.filter(item -> item != null && item
.getId() != null && item
.getId() != -1)
.collect(Collectors
.toList())
);
}
/**
* 确保每个列表都有预置对象（用于表示空值/默认值）
*/
private static void ensurePreservedObjects() {
// 为每个实体类型检查并添加预置对象
addIfMissing(bancais, Bancai
.class);
addIfMissing(caizhis, Caizhi
.class);
addIfMissing(mupis, Mupi
.class);
addIfMissing(chanpins, Chanpin
.class);
addIfMissing(chanpin_zujians, Chanpin_Zujian
.class);
addIfMissing(dingdans, Dingdan
.class);
addIfMissing(kucuns, Kucun
.class);
addIfMissing(zujians, Zujian
.class);
addIfMissing(Dingdan_chanpin_zujians, Dingdan_chanpin_zujian
.class);
addIfMissing(dingdan_chanpins, Dingdan_Chanpin
.class);
addIfMissing(jinhuos, Jinhuo
.class);
addIfMissing(users, User
.class);
}
private static <T extends SynchronizableEntity> void addIfMissing(
List<T> list,
Class<T> clazz
) {
if (!containsPreservedObject(list)) {
list
.add(createInstance(clazz));
}
}
/**
* 检查列表是否包含预置对象
*
* @param list 目标实体列表
* @return 是否包含预置对象
*/
private static <T extends SynchronizableEntity> boolean containsPreservedObject(List<T> list) {
return list
.stream()
.anyMatch(item ->
item != null &&
item
.isPreservedObject()
);
}
/**
* 自动建立实体间关联关系（通过反射实现）
*/
private static void automaticAssociation() {
for (Class<?> entityClass : dataCollectionMap
.keySet()) {
try {
associateEntities(dataCollectionMap
.get(entityClass));
} catch (Exception e) {
Log
.e(TAG, entityClass
.getSimpleName() + " 关联失败", e);
}
}
}
private static <T extends SynchronizableEntity> void associateEntities(
SynchronizedList<T> list
) throws IllegalAccessException, ClassNotFoundException {
for (T entity : list) {
if (entity == null) continue;
for (Field field : entity
.getClass()
.getDeclaredFields()) {
field
.setAccessible(true);
Class<?> fieldType = field
.getType();
// 处理实体引用字段
if (SynchronizableEntity
.class
.isAssignableFrom(fieldType)) {
associateSingleReference(entity, field);
}
// 处理实体列表字段
else if (List
.class
.isAssignableFrom(fieldType)) {
associateReferenceList(entity, field);
}
// 处理基础类型字段
else {
setDefaultPrimitiveValue(entity, field);
}
}
}
}
// ====================== 关联辅助方法 ======================
private static void associateSingleReference(
SynchronizableEntity entity,
Field field
) throws IllegalAccessException {
SynchronizableEntity ref = (SynchronizableEntity) field
.get(entity);
Class<?> targetType = field
.getType();
// 查找目标实体
SynchronizableEntity target = findTargetEntity(ref, targetType);
field
.set(entity, target);
}
private static void associateReferenceList(
SynchronizableEntity entity,
Field field
) throws IllegalAccessException, ClassNotFoundException {
// 获取列表泛型类型
Type genericType = field
.getGenericType();
if (!(genericType instanceof ParameterizedType)) return;
Class<?> itemType = Class
.forName(
((ParameterizedType) genericType)
.getActualTypeArguments()[0]
.getTypeName()
);
// 只处理实体列表
if (!SynchronizableEntity
.class
.isAssignableFrom(itemType)) return;
List<SynchronizableEntity> refList = (List<SynchronizableEntity>) field
.get(entity);
if (refList == null) {
refList = new ArrayList<>();
field
.set(entity, refList);
}
// 清理空值并重建引用
refList
.removeAll(Collections
.singleton(null));
for (int i = 0; i < refList
.size(); i++) {
refList
.set(i, findTargetEntity(refList
.get(i), itemType));
}
}
/**
* 查找关联实体（优先匹配ID，找不到则使用预置对象）
*/
private static SynchronizableEntity findTargetEntity(
SynchronizableEntity ref,
Class<?> targetType
) {
SynchronizedList<SynchronizableEntity> targetList = dataCollectionMap
.get(targetType);
if (targetList == null) return null;
// 无效引用时返回预置对象
if (ref == null || ref
.getId() == null || ref
.getId() < 0) {
return targetList
.stream()
.filter(SynchronizableEntity::isPreservedObject)
.findFirst()
.orElse(null);
}
// 按ID查找目标实体
return targetList
.stream()
.filter(e -> ref
.getId()
.equals(e
.getId()))
.findFirst()
.orElseGet(() -> targetList
.stream() // 找不到时回退到预置对象
.filter(SynchronizableEntity::isPreservedObject)
.findFirst()
.orElse(null)
);
}
// ====================== 工具方法 ======================
/**
* 创建带默认值的实体实例（用作预置对象）
*/
public static <T> T createInstance(Class<T> clazz) {
try {
T instance = clazz
.getDeclaredConstructor()
.newInstance();
// 设置基础字段默认值
for (Field field : clazz
.getDeclaredFields()) {
field
.setAccessible(true);
setDefaultFieldValue(instance, field);
}
// 设置特殊字段
clazz
.getMethod("setId", Integer
.class)
.invoke(instance, -1);
clazz
.getMethod("setState", SynchronizableEntity
.SyncState
.class)
.invoke(instance, SynchronizableEntity
.SyncState
.PRESERVED);
return instance;
} catch (Exception e) {
Log
.e("Data", "创建实例失败: " + clazz
.getName(), e);
try {
return clazz
.newInstance(); // 回退创建
} catch (Exception ex) {
throw new RuntimeException("无法创建实例", ex);
}
}
}
private static <T> void setDefaultFieldValue(T instance, Field field)
throws IllegalAccessException {
Class<?> type = field
.getType();
if (type == String
.class) field
.set(instance, "无");
else if (type == Integer
.class || type == int
.class) field
.set(instance, -1);
else if (type == Double
.class || type == double
.class) field
.set(instance, -1
.0);
else if (type == Boolean
.class || type == boolean
.class) field
.set(instance, false);
else if (type == Date
.class) field
.set(instance, new Date());
else if (SynchronizableEntity
.class
.isAssignableFrom(type)) {
field
.set(instance, getPreservedEntity((Class<?>) type));
}
else if (List
.class
.isAssignableFrom(type)) {
field
.set(instance, new ArrayList<>());
}
}
private static SynchronizableEntity getPreservedEntity(Class<?> type) {
return dataCollectionMap
.get(type)
.stream()
.filter(SynchronizableEntity::isPreservedObject)
.findFirst()
.orElse(null);
}
private static void setDefaultPrimitiveValue(
SynchronizableEntity entity,
Field field
) throws IllegalAccessException {
if (field
.get(entity) != null) return;
Class<?> type = field
.getType();
if (type == String
.class) field
.set(entity, "无");
else if (type == Integer
.class || type == int
.class) field
.set(entity, -1);
else if (type == Double
.class || type == double
.class) field
.set(entity, -1
.0);
else if (type == Boolean
.class || type == boolean
.class) field
.set(entity, false);
else if (type == Date
.class) field
.set(entity, new Date());
}
/**
* 主线程安全回调
*/
private static void safeCallback(LoadDataCallback callback, boolean success) {
new Handler(Looper
.getMainLooper())
.post(() -> {
if (callback == null) return;
if (success) callback
.onSuccess();
else callback
.onFailure();
});
}
/**
* 设置所有实体同步状态
*/
private static void setAllEntitiesState(SynchronizableEntity
.SyncState state) {
dataCollectionMap
.values()
.forEach(list ->
list
.forEach(entity -> {
if (entity != null) entity
.setState(state);
})
);
}
// ====================== 内部类/接口 ======================
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_chanpin_zujians;
public List<Kucun> kucuns;
public List<Zujian> zujians;
public List<User> users;
public List<Jinhuo> jinhuos;
}
}在data中获得数据加载
扫一扫
1327
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
