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> 开始是填充数据
本文介绍了如何使用onpropertychange事件来监听HTML元素属性的变化。这一机制能够更细致地捕捉到页面上发生的改动，尤其适用于输入框等元素的实时状态监控。
扫一扫
1621
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
