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<Chanp
in> chanp
ins = new SynchronizedList<>(Chanp
in.
class);
public static SynchronizedList<Chanp
in_Zujian> chanp
inZujians = new SynchronizedList<>(Chanp
in_Zujian.
class);
public static SynchronizedList<D
ingdan> d
ingdans = new SynchronizedList<>(D
ingdan.
class);
public static SynchronizedList<D
ingdan_Chanp
in> d
ingdanChanp
ins = new SynchronizedList<>(D
ingdan_Chanp
in.
class);
public static SynchronizedList<D
ingdan_Bancai> d
ingdanBancais = new SynchronizedList<>(D
ingdan_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<J
inhuo> j
inhuoList = new SynchronizedList<>(J
inhuo.
class);
private static f
inal Gson gson = new Gson();
private static f
inal OkHttpClient client = new OkHttpClient();
private static f
inal Str
ing TAG = "DataLoader";
// 加载所有数据的方法
public static void loadAllData(Context context, LoadDataCallback callback) {
// 开始批量模式
for (SynchronizedList<?> list
: getAllSyncLists()) {
list.beg
inBatch();
}
Str
ing url = MyAppFnction.getStr
ingResource("Str
ing", "url") +
MyAppFnction.getStr
ingResource("Str
ing", "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().str
ing(), context,callback);
// 结束批量模式（会触发一次全量同步）
for (SynchronizedList<?> list
: getAllSyncLists()) {
list.endBatch();
}
if (callback != null) callback.onSuccess();
}
});
}
// 获取所有同步列表的方法
private static List<SynchronizedList<?>> getAllSyncLists() {
return Arrays.asList(bancais, caizhis, mupis, chanp
ins,
chanp
inZujians, d
ingdans, d
ingdanChanp
ins,
d
ingdanBancais, kucuns, zujians, users, j
inhuoList);
}
// 解析并赋值数据
private static void parseAndAssignData(Str
ing 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(chanp
ins, allData.chanp
ins);
updateList(chanp
inZujians, allData.chanp
in_zujians);
updateList(d
ingdans, allData.d
ingdans);
updateList(d
ingdanChanp
ins, allData.d
ingdan_chanp
ins);
updateList(d
ingdanBancais, allData.d
ingdan_bancais);
updateList(kucuns, allData.kucuns);
updateList(zujians, allData.zujians);
updateList(users, allData.users);
updateList(j
inhuoList, allData.j
inhuos);
resolveReferences();
if (callback != null) callback.onSuccess();
}
// 更新列表内容但保持对象引用不变
private static <T> void updateList(List<T> exist
ingList, List<T> newList) {
if (newList == null) return;
exist
ingList.clear();
for (T item
: newList) {
exist
ingList.add(item); // 会被包装成代理对象
}
}
// 解析对象间的引用关系（使用ID关联）
// 改进的引用解析方法
private static void resolveReferences() {
// 创建全局对象映射
Map<
Integer, Entity
ClassGrassrootsid> globalMap = new HashMap<>();
// 填充全局映射表
addToGlobalMap(globalMap, bancais);
addToGlobalMap(globalMap, caizhis);
addToGlobalMap(globalMap, mupis);
addToGlobalMap(globalMap, chanp
ins);
addToGlobalMap(globalMap, zujians);
addToGlobalMap(globalMap, d
ingdans);
addToGlobalMap(globalMap, kucuns);
addToGlobalMap(globalMap, users);
// 解析所有实体的引用
resolveListReferences(bancais, globalMap);
resolveListReferences(kucuns, globalMap);
resolveListReferences(d
ingdanChanp
ins, globalMap);
resolveListReferences(chanp
inZujians, globalMap);
resolveListReferences(d
ingdanBancais, globalMap);
resolveListReferences(j
inhuoList, globalMap);
}
// 添加对象到全局映射表
private static void addToGlobalMap(Map<
Integer, Entity
ClassGrassrootsid> map,
SynchronizedList<?> list) {
for (Object item
: list) {
Object orig
inal = getOrig
inalFromList(list, item);
if (orig
inal
instance
of Entity
ClassGrassrootsid) {
Entity
ClassGrassrootsid entity = (Entity
ClassGrassrootsid) orig
inal;
map.put(entity.getId(), entity);
}
}
}
// 解析列表中所有实体的引用
private static void resolveListReferences(SynchronizedList<?> list,
Map<
Integer, Entity
ClassGrassrootsid> globalMap) {
for (Object item
: list) {
Object orig
inal = getOrig
inalFromList(list, item);
resolveEntityReferences(orig
inal, globalMap);
}
}
// 安全获取原始对象（无需类型转换）
@SuppressWarn
ings("unchecked")
private static <T> T getOrig
inalFromList(SynchronizedList<?> list, Object item) {
try {
// 使用反射调用getOrig
inal方法
Method getOrig
inal = list.get
Class().get
Method("getOrig
inal", Object.
class);
return (T) getOrig
inal.
invoke(list, item);
} catch (Exception e) {
Log.e("Data", "Failed to get orig
inal object", e);
return (T) item;
}
}
//解析集合中的引用
private static void resolveCollectionReferences(Collection<?> collection,
Map<
Integer, Entity
ClassGrassrootsid> globalMap) {
for (Object item
: collection) {
if (item
instance
of Entity
ClassGrassrootsid) {
Entity
ClassGrassrootsid ref = (Entity
ClassGrassrootsid) item;
Entity
ClassGrassrootsid resolved = globalMap.get(ref.getId());
if (resolved != null && ref.get
Class().is
Instance(resolved)) {
// 注意：直接替换集合元素需要特殊处理
// 实际项目应考虑使用CopyOnWrite集合或创建新集合
if (collection
instance
of List) {
int
index = ((List<?>) collection).
index
Of(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, Entity
ClassGrassrootsid> globalMap) {
if (entity == null) return;
Class<?> clazz = entity.get
Class();
for (Field field
: clazz.getDeclaredFields()) {
try {
field.setAccessible(true);
// 处理基本类型字段
if (Entity
ClassGrassrootsid.
class.isAssignableFrom(field.getType())) {
Entity
ClassGrassrootsid ref = (Entity
ClassGrassrootsid) field.get(entity);
if (ref != null && ref.getId() != null) {
Entity
ClassGrassrootsid resolved = globalMap.get(ref.getId());
if (resolved != null && field.getType().is
Instance(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 resolv
ing field
: " + field.getName(), e);
}
}
}
// 创建ID到对象的映射
private static <T extends Entity
ClassGrassrootsid> 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, Entity
ClassGrassrootsid> globalMap) {
for (Field field
: entity.get
Class().getDeclaredFields()) {
if (Entity
ClassGrassrootsid.
class.isAssignableFrom(field.getType())) {
try {
field.setAccessible(true);
Entity
ClassGrassrootsid ref = (Entity
ClassGrassrootsid) field.get(entity);
if (ref != null) {
Entity
ClassGrassrootsid resolved = globalMap.get(ref.getId());
if (resolved != null && field.getType().isAssignableFrom(resolved.get
Class())) {
field.set(entity, resolved);
}
}
} catch (Exception e) {
Log.e("Data", "Error resolv
ing reference", e);
}
}
}
}
// 内部类用于解析JSON响应
public static
class AllDataResponse {
public List<Bancai> bancais;
public List<Caizhi> caizhis;
public List<Mupi> mupis;
public List<Chanp
in> chanp
ins;
public List<Chanp
in_Zujian> chanp
in_zujians;
public List<D
ingdan> d
ingdans;
public List<D
ingdan_Chanp
in> d
ingdan_chanp
ins;
public List<D
ingdan_Bancai> d
ingdan_bancais;
public List<Kucun> kucuns;
public List<Zujian> zujians;
public List<User> users;
public List<J
inhuo> j
inhuos;
}
}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 f
inal List<T> list = new ArrayList<>();
private f
inal OkHttpClient client = new OkHttpClient();
private static f
inal Gson gson = new Gson();
private static f
inal MediaType JSON = MediaType.get("application/json; charset=utf-8");
private f
inal
Class<T> entity
Class; // 类型标记
// 添加批量操作模式标志
private boolean batchMode = false;
// 属性变更监听器
private f
inal List<
PropertyChangeListener<T>> listeners = new ArrayList<>();
public SynchronizedList(
Class<T> entity
Class) {
Type super
Class = get
Class().getGenericSuper
class();
ParameterizedType type = (ParameterizedType) super
Class;
Type[] typeArgs = type.getActualTypeArguments();
this.entity
Class = (
Class<T>) typeArgs[0];
}
// 安全的类型转换方法
private T safeCast(Object o) {
if (o != null && entity
Class.is
Instance(o)) {
return entity
Class.cast(o);
}
return null;
}
public
interface
PropertyChangeListener<T> {
void on
PropertyChange(T entity, Str
ing
propertyName, Object oldValue, Object newValue);
}
public void add
PropertyChangeListener(
PropertyChangeListener<T> listener) {
listeners.add(listener);
}
public void remove
PropertyChangeListener(
PropertyChangeListener<T> listener) {
listeners.remove(listener);
}
// 添加方法来获取原始对象
@SuppressWarn
ings("unchecked")
public T getOrig
inal(T proxy) {
if (proxy == null) return null;
// 检查是否为代理对象
if (java.lang.reflect.Proxy.isProxy
Class(proxy.get
Class())) {
try {
java.lang.reflect.
InvocationHandler handler =
java.lang.reflect.Proxy.get
InvocationHandler(proxy);
if (handler
instance
of IProxyHandler) {
Object orig
inal = ((IProxyHandler) handler).getOrig
inal();
// 安全类型检查
if (entity
Class.is
Instance(orig
inal)) {
return (T) orig
inal;
}
}
} catch (Exception e) {
Log.e("SynchronizedList", "Failed to get proxy handler", e);
}
}
return proxy;
}
/**
* 同步实体到后端
*
* @param entity 要同步的实体
*/
private void syncEntity(T entity) {
if (batchMode) return;
Str
ing operation = "add";
T orig
inalEntity = getOrig
inal(entity);
Str
ing endpo
int = orig
inalEntity.getEndpo
int(operation);
Str
ing json = gson.toJson(orig
inalEntity);
RequestBody body = RequestBody.create(json, JSON);
Request request = new Request.Builder()
.url(endpo
int)
.
method(getHttp
Method(operation), body)
.build();
client.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(@NonNull Call call, @NonNull IOException e) {
Log.e("SynchronizedList", "同步失败
: " + entity.get
Class().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 beg
inBatch() {
this.batchMode = true;
}
public void endBatch() {
this.batchMode = false;
// 批量结束后触发一次全量同步
syncAllEntities();
}
private void syncAllEntities() {
for (T entity
: list) {
syncEntity(entity);
}
}
private Str
ing getHttp
Method(Str
ing operation) {
switch (operation) {
case "add"
:
return "POST";
case "update"
:
return "PUT";
case "delete"
:
return "DELETE";
default
:
return "POST";
}
}
// 获取类实现的所有接口（包括父类接口）
private
Class<?>[] get
Interfaces(
Class<?> clazz) {
Set<
Class<?>>
interfaces = new HashSet<>();
while (clazz != null) {
interfaces.addAll(Arrays.asList(clazz.get
Interfaces()));
clazz = clazz.getSuper
class();
}
return
interfaces.toArray(new
Class<?>[0]);
}
/**
* 创建代理对象，用于监听属性变更
*/
// 优化 createProxy 方法
private T createProxy(T orig
inal) {
if (orig
inal == null) return null;
if (!entity
Class.is
Instance(orig
inal)) {
throw new
IllegalArgumentException("
Invalid entity type");
}
// 为原始对象创建代理
return (T) java.lang.reflect.Proxy.newProxy
Instance(
orig
inal.get
Class().get
ClassLoader(),
get
Interfaces(orig
inal.get
Class()),
new EntityProxyHandler(orig
inal)
);
// if (!entity
Class.is
Instance(orig
inal)) {
// throw new
IllegalArgumentException("
Invalid entity type");
// }
// // 这里使用动态代理模式监听
setter方法调用
// return (T) java.lang.reflect.Proxy.newProxy
Instance(
// orig
inal.get
Class().get
ClassLoader(),
// orig
inal.get
Class().get
Interfaces(),
// (proxy,
method, args) -> {
// // 只拦截
setter方法
// if (
method.getName().startsWith("set") && args.length == 1) {
// Str
ing
propertyName =
method.getName().substr
ing(3);
//
propertyName =
propertyName.substr
ing(0, 1).toLowerCase() +
propertyName.substr
ing(1);
//
// // 获取旧值
// Object oldValue = orig
inal.get
Class()
// .get
Method("get" +
propertyName.substr
ing(0, 1).toUpperCase() +
propertyName.substr
ing(1))
// .
invoke(orig
inal);
//
// // 调用原始方法
// Object result =
method.
invoke(orig
inal, args);
//
// // 触发监听器
// for (
PropertyChangeListener<T> listener
: listeners) {
// listener.on
PropertyChange(orig
inal,
propertyName, oldValue, args[0]);
// }
//
// // 自动同步到后端
// syncEntity(orig
inal);
// return result;
// }
// return
method.
invoke(orig
inal, args);
// }
// );
}
// 以下是List接口的实现
@Override
public
int size() {
return list.size();
}
@Override
public boolean isEmpty() {
return list.isEmpty();
}
@Override
public boolean conta
ins(Object o) {
return list.conta
ins(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 conta
insAll(@NonNull Collection<?> c) {
return list.conta
insAll(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 reta
inAll(@NonNull Collection<?> c) {
List<T> toRemove = new ArrayList<>();
for (T t
: list) {
if (!c.conta
ins(t)) {
toRemove.add(t);
}
}
// 使用安全转换
for (T entity
: toRemove) {
syncEntity(entity);
}
return list.reta
inAll(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
index
Of(Object o) {
return list.
index
Of(o);
}
@Override
public
int last
Index
Of(Object o) {
return list.last
Index
Of(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 from
Index,
int to
Index) {
return list.subList(from
Index, to
Index);
}
// 触发属性变更通知
// 添加类型安全的属性监听
private void fire
PropertyChange(T entity, Str
ing
propertyName, Object oldValue, Object newValue) {
if (oldValue != null && newValue != null && oldValue.equals(newValue)) {
return; // 值未变化时不触发监听
}
for (
PropertyChangeListener<T> listener
: listeners) {
try {
listener.on
PropertyChange(entity,
propertyName, oldValue, newValue);
} catch (Exception e) {
Log.e("SynchronizedList", "Listener error", e);
}
}
}
// 修改代理处理器以支持获取原始对象
/*
完整的 EntityProxyHandler
实现
*/
private
class EntityProxyHandler implements IProxyHandler, java.lang.reflect.
InvocationHandler {
private f
inal T orig
inal;
private f
inal Map<Str
ing, Object>
propertyValues = new HashMap<>();
public EntityProxyHandler(T orig
inal) {
this.orig
inal = orig
inal;
// 初始化属性缓存
for (
Method method : orig
inal.get
Class().get
Methods()) {
if (
method.getName().startsWith("get") &&
method.getParameterCount() == 0) {
try {
Str
ing propName =
method.getName().substr
ing(3);
propName = Character.toLowerCase(propName.charAt(0)) + propName.substr
ing(1);
propertyValues.put(propName,
method.
invoke(orig
inal));
} catch (Exception e) {
Log.e("ProxyHandler", "Failed to cache
property", e);
}
}
}
}
@Override
public T getOrig
inal() {
return orig
inal;
}
@Override
public Object
invoke(Object proxy,
Method method, Object[] args) throws Throwable {
Str
ing
methodName =
method.getName();
// 处理
setter 方法
if (
methodName.startsWith("set") && args != null && args.length == 1) {
Str
ing
propertyName =
methodName.substr
ing(3);
propertyName = Character.toLowerCase(
propertyName.charAt(0)) +
propertyName.substr
ing(1);
Object oldValue =
propertyValues.get(
propertyName);
Object newValue = args[0];
// 调用原始方法
Object result =
method.
invoke(orig
inal, args);
propertyValues.put(
propertyName, newValue);
// 触发监听
fire
PropertyChange(orig
inal,
propertyName, oldValue, newValue);
// 非批量模式下自动同步
if (!batchMode) {
syncEntity(orig
inal);
}
return result;
}
// 特殊处理 getOrig
inal 方法
if ("getOrig
inal".equals(
methodName)) {
return orig
inal;
}
// 处理 getter 方法（使用缓存）
if (
methodName.startsWith("get") &&
method.getParameterCount() == 0) {
Str
ing
propertyName =
methodName.substr
ing(3);
propertyName = Character.toLowerCase(
propertyName.charAt(0)) +
propertyName.substr
ing(1);
return
propertyValues.getOrDefault(
propertyName,
method.
invoke(orig
inal));
}
return
method.
invoke(orig
inal, args);
}
private Object get
PropertyValue(Str
ing
propertyName) {
Str
ing getterName = "get" +
propertyName.substr
ing(0, 1).toUpperCase() +
propertyName.substr
ing(1);
try {
Method getter = orig
inal.get
Class().get
Method(getterName);
return getter.
invoke(orig
inal);
} catch (Exception e) {
Log.e("ProxyHandler", "Failed to get
property value
: " +
propertyName, e);
return null;
}
}
}
// 在 SynchronizedList 类中添加
private
interface IProxyHandler {
Object getOrig
inal();
}
}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
}
],
“d
ingdans”
: [
{
“d
ingdanChanp
inZujian”
: [
],
"number"
: "直接入库",
"id"
: 1,
"d
ingdanChanp
in"
: [
{"id"
:1}
]
}
],
"mupis"
: [
{
"name"
: "千和板",
"id"
: 1,
"you"
: null
},
{
"name"
: "桃花芯",
"id"
: 2,
"you"
: null
},
{
"name"
: "杉木",
"id"
: 3,
"you"
: null
}
],
"chanp
ins"
: [
{
"chanp
inZujian"
: [
{
"id"
: 1
}
],
"bianhao"
: "直接入库",
"id"
: 1,
"d
ingdanChanp
in"
: [
{"id"
:1}
]
}
],
"kucuns"
: [
{
"bancai"
: {
"Id"
: 1
},
"shuliang"
: 12,
"id"
: 1
},
{
"bancai"
: {
"Id"
: 2
},
"shuliang"
: 32,
"id"
: 2
}
],
"chanp
in_zujians"
: [
{
"chanp
in"
: {
"Id"
: 1
},
"bancai"
: {
"id"
: 1
},
"id"
: 1,
"zujian"
: {
"Id"
: 1
},
"one_howmany"
: 15
}
],
"zujians"
: [
{
"chanp
inZujian"
: [
{
"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"
}
]
}
}
<str
ing name=“url”>https
://tian.sef/Kucun2</str
ing>
<str
ing name=“url_all”>/app/all</str
ing>
<str
ing name=“url_bancis”>/app/bancai/all</str
ing>
<str
ing name=“url_caizhis”>/app/caizhi/all</str
ing>
<str
ing name=“url_mupis”>/app/mupi/all</str
ing>
<str
ing name=“url_d
ingdans”>/app/d
ingdan/all</str
ing>
<str
ing name=“url_chanp
ins”>/app/chanp
in/all</str
ing>
<str
ing name=“url_zujians”>/app/zujian/all</str
ing>
<str
ing name="url_chanp
in_zujians">/app/chanp
in_zujian/all</str
ing>
<str
ing name="url_d
ingdan_zujians">/app/d
ingdan_zujian/all</str
ing>
<str
ing name="url_d
ingdan_chanp
ins">/app/d
ingdan_chanp
in/all</str
ing>
<str
ing name="url_j
inhuos">/app/j
inhuo/all</str
ing>
<str
ing name="url_add_bancai">/app/bancai/add</str
ing>
<str
ing name="url_add_d
ingdan">/app/d
ingdan/add</str
ing>
<str
ing name="url_add_chanp
in">/app/chanp
in/add</str
ing>
<str
ing name="url_add_zujian">/app/zujian/add</str
ing>
<str
ing name="url_add_caizhi">/app/caizhi/add</str
ing>
<str
ing name="url_add_mupi">/app/mupi/add</str
ing>
<str
ing name="url_add_d
ingdan_chanp
in">/app/d
ingdan_chanpi/add</str
ing>
<str
ing name="url_add_d
ingdan_zujian">/app/d
ingdan_zujian/add</str
ing>
<str
ing name="url_add_chanp
in_zujian">/app/chanp
in_zujian/add</str
ing>
<str
ing name="url_add_j
inhuo">/app/j
inhuo/add</str
ing>
<str
ing name="url_log
in">/user/log
in</str
ing> 开始是填充数据
博客提及类型格式转化错误，重点在于判断JavaBean类里对应表的字段的属性是否一致，涉及Java开发与数据库表字段匹配问题。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
