/* ========== Dingdan_Chanpin
.java ========== */
package com
.example
.kucun2
.entity;
import com
.example
.kucun2
.entity
.data
.EntityClassGrassrootsid;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
/**
订单产品关联
*/
public class Dingdan_Chanpin extends SynchronizableEntity implements EntityClassGrassrootsid {
private Integer id;
private Dingdan dingdan;
private Chanpin chanpin;
private Integer shuliang;
public Dingdan_Chanpin(Integer id, Dingdan dingdan, Chanpin chanpin, Integer shuliang) {
this
.id = id;
this
.dingdan = dingdan;
this
.chanpin = chanpin;
this
.shuliang = shuliang;
}
@Override
public Integer getId() {
return id;
}
public void
setId(Integer id) {
Integer old
Value = this
.id;
this
.id = id;
fire
PropertyChange(“id”, old
Value, id);
}
public Dingdan getDingdan() {
return dingdan;
}
public void
setDingdan(Dingdan dingdan) {
Dingdan old
Value = this
.dingdan;
this
.dingdan = dingdan;
fire
PropertyChange(“dingdan”, old
Value, dingdan);
}
public Chanpin getChanpin() {
return chanpin;
}
public void
setChanpin(Chanpin chanpin) {
Chanpin old
Value = this
.chanpin;
this
.chanpin = chanpin;
fire
PropertyChange(“chanpin”, old
Value, chanpin);
}
public Integer getShuliang() {
return shuliang;
}
public void
setShuliang(Integer shuliang) {
Integer old
Value = this
.shuliang;
this
.shuliang = shuliang;
fire
PropertyChange(“shuliang”, old
Value, shuliang);
}
public Dingdan_Chanpin() {
}
}
/* ========== Dingdan_chanpin_zujian
.java ========== */
package com
.example
.kucun2
.entity;
import com
.example
.kucun2
.entity
.data
.EntityClassGrassrootsid;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
/**
、
订单板材关联
*/
public class Dingdan_chanpin_zujian extends SynchronizableEntity implements EntityClassGrassrootsid {
private Integer id;
private Dingdan dingdian;
private Chanpin_Zujian zujian;
private Bancai bancai;
private Integer shuliang;
@Override
public Integer getId() {
return id;
}
public void
setId(Integer id) {
Integer old
Value = this
.id;
this
.id = id;
fire
PropertyChange(“id”, old
Value, id);
}
public Dingdan getDingdian() {
return dingdian;
}
public void
setDingdian(Dingdan dingdian) {
Dingdan old
Value = this
.dingdian;
this
.dingdian = dingdian;
fire
PropertyChange(“dingdian”, old
Value, dingdian);
}
public Chanpin_Zujian getZujian() {
return zujian;
}
public void
setZujian(Chanpin_Zujian zujian) {
Chanpin_Zujian old
Value = this
.zujian;
this
.zujian = zujian;
fire
PropertyChange(“zujian”, old
Value, zujian);
}
public Bancai getBancai() {
return bancai;
}
public void
setBancai(Bancai bancai) {
Bancai old
Value = this
.bancai;
this
.bancai = bancai;
fire
PropertyChange(“bancai”, old
Value, bancai);
}
public Integer getShuliang() {
return shuliang;
}
public void
setShuliang(Integer shuliang) {
Integer old
Value = this
.shuliang;
this
.shuliang = shuliang;
fire
PropertyChange(“shuliang”, old
Value, shuliang);
}
public Dingdan_chanpin_zujian() {
}
}
/* ========== Information
.java ========== */
package com
.example
.kucun2
.entity;
import android
.annotation
.SuppressLint;
import androidx
.annotation
.Keep;
import com
.google
.gson
.Gson;
import com
.google
.gson
.JsonSyntaxException;
import com
.google
.gson
.reflect
.Type
Token;
import
java.lang
.reflect
.Type;
@Keep // 防止Proguard混淆
public class Information<T> {
private Integer status;
private String text;
private T data; // 使用泛型保证类型安全
private static final Gson gson = new Gson(); // Gson实例复用
// 构造
方法
public Information(Integer status, String text, T data) {
this
.status = status;
this
.text = text;
this
.data = data;
}
// JSON反序列化构造
方法
@SuppressLint(“NewApi”)
public Information(Integer status, String text, String jsonData, Type dataType) {
this
.status = status;
this
.text = text;
try {
this
.data = gson
.fromJson(jsonData, dataType);
} catch (JsonSyntaxException e) {
this
.data = null; // 处理解析失败
}
}
// 空构造
方法
public Information() {
}
// 序列化为JSON
public String
toJson() {
return gson
.toJson(this);
}
// 静态创建
方法
public static <T> Information<T> newSuccess(T data) {
return new Information<>(200, “success”, data);
}
public static Information<String> newSuccess(String text) {
return new Information<>(200, “success”, text);
}
public static <T> Information<T> newFail(int status, String text, T data) {
return new Information<>(status, text, data);
}
// Getter/
Setter
public Integer getStatus() {
return status;
}
public void
setStatus(Integer status) {
this
.status = status;
}
public String getText() {
return text;
}
public void
setText(String text) {
this
.text = text;
}
public T getData() {
return data;
}
public void
setData(T data) {
this
.data = data;
}
}
/* ========== Jinhuo
.java ========== */
package com
.example
.kucun2
.entity;
import com
.example
.kucun2
.entity
.data
.EntityClassGrassrootsid;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
import
java.util
.Date;
/**
进货消耗类
*/
public class Jinhuo extends SynchronizableEntity implements EntityClassGrassrootsid {
private Integer id;
//属于哪个订单
private Dingdan dingdan;
//属于哪个产品
private Chanpin chanpin;
//属于哪个组件
private Zujian zujian;
//进的什么板材
private Bancai bancai;
//进货数量
private Integer shuliang;
private Date date;
private User user;
public Jinhuo(Integer id, Dingdan dingdan, Chanpin chanpin, Zujian zujian, Bancai bancai, Integer shuliang,
Date date, User user) {
super();
this
.id = id;
this
.dingdan = dingdan;
this
.chanpin = chanpin;
this
.zujian = zujian;
this
.bancai = bancai;
this
.shuliang = shuliang;
this
.date = date;
this
.user = user;
}
public Jinhuo() {
super();
//
TODO Au
to-generated construc
tor stub
}
@Override
public Integer getId() {
return id;
}
public void
setId(Integer id) {
Integer old
Value = this
.id;
this
.id = id;
fire
PropertyChange(“id”, old
Value, id);
}
public Dingdan getDingdan() {
return dingdan;
}
public void
setDingdan(Dingdan dingdan) {
Dingdan old
Value = this
.dingdan;
this
.dingdan = dingdan;
fire
PropertyChange(“dingdan”, old
Value, dingdan);
}
public Chanpin getChanpin() {
return chanpin;
}
public void
setChanpin(Chanpin chanpin) {
Chanpin old
Value = this
.chanpin;
this
.chanpin = chanpin;
fire
PropertyChange(“chanpin”, old
Value, chanpin);
}
public Zujian getZujian() {
return zujian;
}
public void
setZujian(Zujian zujian) {
Zujian old
Value = this
.zujian;
this
.zujian = zujian;
fire
PropertyChange(“zujian”, old
Value, zujian);
}
public Bancai getBancai() {
return bancai;
}
public void
setBancai(Bancai bancai) {
Bancai old
Value = this
.bancai;
this
.bancai = bancai;
fire
PropertyChange(“bancai”, old
Value, bancai);
}
public Integer getShuliang() {
return shuliang;
}
public void
setShuliang(Integer shuliang) {
Integer old
Value = this
.shuliang;
this
.shuliang = shuliang;
fire
PropertyChange(“shuliang”, old
Value, shuliang);
}
public Date getDate() {
return date;
}
public void
setDate(Date date) {
Date old
Value = this
.date;
this
.date = date;
fire
PropertyChange(“date”, old
Value, date);
}
public User getUser() {
return user;
}
public void
setUser(User user) {
User old
Value = this
.user;
this
.user = user;
fire
PropertyChange(“user”, old
Value, user);
}
}
/* ========== Kucun
.java ========== */
package com
.example
.kucun2
.entity;
import com
.example
.kucun2
.entity
.data
.EntityClassGrassrootsid;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
/**
库存
*/
public class Kucun extends SynchronizableEntity implements EntityClassGrassrootsid {
private Integer id;
private Integer shuliang;
private Bancai bancai;
@Override
public Integer getId() {
return id;
}
public void
setId(Integer id) {
Integer old
Value = this
.id;
this
.id = id;
fire
PropertyChange(“id”, old
Value, id);
}
public Integer getShuliang() {
return shuliang;
}
public void
setShuliang(Integer shuliang) {
Integer old
Value = this
.shuliang;
this
.shuliang = shuliang;
fire
PropertyChange(“shuliang”, old
Value, shuliang);
}
public Bancai getBancai() {
return bancai;
}
public void
setBancai(Bancai bancai) {
Bancai old
Value = this
.bancai;
this
.bancai = bancai;
fire
PropertyChange(“bancai”, old
Value, bancai);
}
public Kucun() {
}
public Kucun(Integer id, Integer shuliang, Bancai bancai) {
this
.id = id;
this
.shuliang = shuliang;
this
.bancai = bancai;
}
}
/* ========== Mupi
.java ========== */
package com
.example
.kucun2
.entity;
import android
.annotation
.SuppressLint;
import com
.example
.kucun2
.entity
.data
.EntityClassGrassrootsid;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
import
java.util
.ArrayList;
import
java.util
.List;
public class Mupi extends SynchronizableEntity implements EntityClassGrassrootsid {
private Integer id;
private String
name;
/**
是否有油漆 */ private Boolean you = false;
private List<Bancai> bancais = new ArrayList<>();
@Override
public Integer getId() {
return id;
}
public void
setId(Integer id) {
Integer old
Value = this
.id;
this
.id = id;
fire
PropertyChange(“id”, old
Value, id);
}
public String get
Name() {
return
name;
}
public void
setName(String
name) {
String old
Value = this
.name;
this
.name =
name;
fire
PropertyChange(“
name”, old
Value,
name);
}
public Boolean getYou() {
if (you == null) {
you = false;
return false;
}
return you;
}
public void
setYou(Boolean you) {
if (you == null) return;
Boolean old
Value = this
.you;
this
.you = you;
fire
PropertyChange("you", old
Value, you);
}
public List<Bancai> getBancais() {
return bancais;
}
public void
setBancais(List<Bancai> bancais) {
List<Bancai> old
Value = this
.bancais;
this
.bancais = bancais;
fire
PropertyChange(“bancais”, old
Value, bancais);
}
public Mupi() {
}
public Mupi(Integer id, String
name, List<Bancai> bancais) {
this
.id = id;
this
.name =
name;
this
.bancais = bancais;
}
public Mupi(List<Bancai> bancais, Boolean you, String
name, Integer id) {
this
.bancais = bancais;
this
.you = you;
this
.name =
name;
this
.id = id;
}
// 3
. 木皮显示格式化
方法
public String formatMupiDisplay() {
return get
Name() + (getYou() ? "油"
: "");
}
}
/* ========== User
.java ========== */
package com
.example
.kucun2
.entity;
import com
.example
.kucun2
.entity
.data
.EntityClassGrassrootsid;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
/**
用户
*/
public class User extends SynchronizableEntity implements EntityClassGrassrootsid {
private Integer id;
private String
name;
private String andy;
private String pass;
private Integer role;
@Override
public Integer getId() {
return id;
}
public void
setId(Integer id) {
Integer old
Value = this
.id;
this
.id = id;
fire
PropertyChange(“id”, old
Value, id);
}
public String get
Name() {
return
name;
}
public void
setName(String
name) {
String old
Value = this
.name;
this
.name =
name;
fire
PropertyChange(“
name”, old
Value,
name);
}
public String getAndy() {
return andy;
}
public void
setAndy(String andy) {
String old
Value = this
.andy;
this
.andy = andy;
fire
PropertyChange(“andy”, old
Value, andy);
}
public String getPass() {
return pass;
}
public void
setPass(String pass) {
String old
Value = this
.pass;
this
.pass = pass;
fire
PropertyChange(“pass”, old
Value, pass);
}
public Integer getRole() {
return role;
}
public void
setRole(Integer role) {
Integer old
Value = this
.role;
this
.role = role;
fire
PropertyChange(“role”, old
Value, role);
}
public User(int id, String
name, String andy, String pass, int role) {
this
.id = id;
this
.name =
name;
this
.andy = andy;
this
.pass = pass;
this
.role = role;
}
public User() {
}
@Override
public String
toString() {
StringBuilder sb = new StringBuilder(“{”);
// 处理
属性名
sb
.append("“id”
: ");
// 处理不同数据类型
// 其他
对象类型
sb
.append((id != null) ? id
: “null”);
sb
.append(“,”);
// 处理
属性名
sb
.append(""
name"
: ");
// 处理不同数据类型
// 字符串类型处理（含转义）
sb
.append(“"”)
.append(
name
.replace(“\”, “\\”)
.replace(“"”, “\"”)
.replace(“\b”, “\b”)
.replace(“\f”, “\f”)
.replace(“\n”, “\n”)
.replace(“\r”, “\r”)
.replace(“\t”, “\t”))
.append(“"”);
sb
.append(“,”);
// 处理
属性名
sb
.append(""andy"
: ");
// 处理不同数据类型
// 字符串类型处理（含转义）
sb
.append(“"”)
.append(andy
.replace(“\”, “\\”)
.replace(“"”, “\"”)
.replace(“\b”, “\b”)
.replace(“\f”, “\f”)
.replace(“\n”, “\n”)
.replace(“\r”, “\r”)
.replace(“\t”, “\t”))
.append(“"”);
sb
.append(“,”);
// 处理
属性名
sb
.append(""pass"
: ");
// 处理不同数据类型
// 字符串类型处理（含转义）
sb
.append(“"”)
.append(pass
.replace(“\”, “\\”)
.replace(“"”, “\"”)
.replace(“\b”, “\b”)
.replace(“\f”, “\f”)
.replace(“\n”, “\n”)
.replace(“\r”, “\r”)
.replace(“\t”, “\t”))
.append(“"”);
sb
.append(“,”);
// 处理
属性名
sb
.append(""role"
: ");
// 处理不同数据类型
// 其他
对象类型
sb
.append((role != null) ? role
: “null”);
sb
.append(“}”);
return sb
.toString();
}
}
/* ========== Zujian
.java ========== */
package com
.example
.kucun2
.entity;
import com
.example
.kucun2
.entity
.data
.EntityClassGrassrootsid;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
/**
组件
*/
public class Zujian extends SynchronizableEntity implements EntityClassGrassrootsid {
private Integer id;
private String
name;
public Zujian() {
}
public Zujian(Integer id, String
name) {
this
.id = id;
this
.name =
name;
}
@Override
public Integer getId() {
return id;
}
public void
setId(Integer id) {
Integer old
Value = this
.id;
this
.id = id;
fire
PropertyChange(“id”, old
Value, id);
}
public String get
Name() {
return
name;
}
public void
setName(String
name) {
String old
Value = this
.name;
this
.name =
name;
fire
PropertyChange(“
name”, old
Value,
name);
}
}
/* ========== Bancai
.java ========== */
package com
.example
.kucun2
.entity;
import android
.annotation
.SuppressLint;
import com
.example
.kucun2
.entity
.data
.EntityClassGrassrootsid;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
import
java.util
.Collections;
import
java.util
.Map;
import
java.util
.Objects;
//板材
public class Bancai extends SynchronizableEntity implements EntityClassGrassrootsid {
private Integer id;
private Caizhi caizhi;
private Mupi mupi1;
private Mupi mupi2;
private Double houdu;
private Dingdan_chanpin_zujian Dingdan_chanpin_zujian;
public Bancai() {
}
@Override
public boolean equals(
Object o) {
if (this == o) return true;
if (o == null || getClass() != o
.getClass()) return false;
Bancai bancai = (Bancai) o;
return
Objects
.equals(id, bancai
.id) &&
Objects
.equals(caizhi, bancai
.caizhi) &&
Objects
.equals(mupi1, bancai
.mupi1) &&
Objects
.equals(mupi2, bancai
.mupi2) &&
Objects
.equals(houdu, bancai
.houdu);
}
@Override
public int hashCode() {
return
Objects
.hash(id, caizhi, mupi1, mupi2, houdu);
}
public Bancai(Integer id, Caizhi caizhi, Mupi mupi1, Mupi mupi2, Double houdu) {
this
.id = id;
this
.caizhi = caizhi;
this
.mupi1 = mupi1;
this
.mupi2 = mupi2;
this
.houdu = houdu;
}
@Override
public Integer getId() {
return id;
}
public void
setId(Integer id) {
Integer old
Value = this
.id;
this
.id = id;
fire
PropertyChange(“id”, old
Value, id);
}
public Caizhi getCaizhi() {
return caizhi;
}
public void
setCaizhi(Caizhi caizhi) {
Caizhi old
Value = this
.caizhi;
this
.caizhi = caizhi;
fire
PropertyChange(“caizhi”, old
Value, caizhi);
}
public Mupi getMupi1() {
return mupi1;
}
public void
setMupi1(Mupi mupi1) {
Mupi old
Value = this
.mupi1;
this
.mupi1 = mupi1;
fire
PropertyChange(“mupi1”, old
Value, mupi1);
}
public Mupi getMupi2() {
return mupi2;
}
public void
setMupi2(Mupi mupi2) {
Mupi old
Value = this
.mupi2;
this
.mupi2 = mupi2;
fire
PropertyChange(“mupi2”, old
Value, mupi2);
}
public Double getHoudu() {
return houdu;
}
public void
setHoudu(Double houdu) {
Double old
Value = this
.houdu;
this
.houdu = houdu;
fire
PropertyChange(“houdu”, old
Value, houdu);
}
/**
表格中显示的文字
@return
*/
@SuppressLint(“DefaultLocale”)
public String TableText() {
String boardInfo = “”;
boardInfo += String
.format(“%
.1f”, this
.getHoudu()) + this
.getCaizhi()
.get
Name() + “(”;
if (mupi1 != null) {
boardInfo += (this
.getMupi1()
.getYou() ? this
.getMupi1()
.get
Name() + “油”
: this
.getMupi1()
.get
Name());
}
if (mupi2 != null && mupi1 != null) {
boardInfo += “,”;
}
if (mupi2 != null) {
boardInfo += (this
.getMupi2()
.getYou() ? this
.getMupi2()
.get
Name() + “油”
: this
.getMupi2()
.get
Name());
}
boardInfo += “)”;
return boardInfo;
}
public com
.example
.kucun2
.entity
.Dingdan_chanpin_zujian getDingdan_chanpin_zujian() {
return Dingdan_chanpin_zujian;
}
public void
setDingdan_chanpin_zujian(com
.example
.kucun2
.entity
.Dingdan_chanpin_zujian dingdan_chanpin_zujian) {
com
.example
.kucun2
.entity
.Dingdan_chanpin_zujian old
Value = this
.Dingdan_chanpin_zujian;
Dingdan_chanpin_zujian = dingdan_chanpin_zujian;
fire
PropertyChange(“dingdan_chanpin_zujian”, old
Value, dingdan_chanpin_zujian);
}
}
/* ========== Caizhi
.java ========== */
package com
.example
.kucun2
.entity;
import com
.example
.kucun2
.entity
.data
.EntityClassGrassrootsid;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
import
java.util
.ArrayList;
import
java.util
.List;
import
java.util
.Objects;
//材质
public class Caizhi extends SynchronizableEntity implements EntityClassGrassrootsid {
private Integer id;
private String
name;
private List<Bancai> bancai = new ArrayList<>();
@Override
public Integer getId() {
return id;
}
public void
setId(Integer id) {
Integer old
Value = this
.id;
this
.id = id;
fire
PropertyChange(“id”, old
Value, id);
}
public String get
Name() {
return
name;
}
public void
setName(String
name) {
String old
Value = this
.name;
this
.name =
name;
fire
PropertyChange(“
name”, old
Value,
name);
}
@Override
public boolean equals(
Object o) {
if (this == o) return true;
if (o == null || getClass() != o
.getClass()) return false;
Caizhi caizhi = (Caizhi) o;
return
Objects
.equals(
name, caizhi
.name);
}
@Override
public int hashCode() {
return
Objects
.hashCode(
name);
}
public List<Bancai> getBancai() {
return bancai;
}
public void
setBancai(List<Bancai> bancai) {
List<Bancai> old
Value = this
.bancai;
this
.bancai = bancai;
fire
PropertyChange(“bancai”, old
Value, bancai);
}
}
/* ========== Chanpin
.java ========== */
package com
.example
.kucun2
.entity;
import com
.example
.kucun2
.entity
.data
.EntityClassGrassrootsid;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
import
java.util
.ArrayList;
import
java.util
.List;
//产品
public class Chanpin extends SynchronizableEntity implements EntityClassGrassrootsid {
private Integer id;
private String bianhao;
private List<Chanpin_Zujian> chanpinZujian = new ArrayList<>();
private List<Dingdan_Chanpin> dingdanChanpin = new ArrayList<>();
;
@Override
public Integer getId() {
return id;
}
public void
setId(Integer id) {
Integer old
Value = this
.id;
this
.id = id;
fire
PropertyChange(“id”, old
Value, id);
}
public List<Chanpin_Zujian> getChanpinZujian() {
return chanpinZujian;
}
public void
setChanpinZujian(List<Chanpin_Zujian> chanpinZujian) {
List<Chanpin_Zujian> old
Value = this
.chanpinZujian;
this
.chanpinZujian = chanpinZujian;
fire
PropertyChange(“chanpinZujian”, old
Value, chanpinZujian);
}
public List<Dingdan_Chanpin> getDingdanChanpin() {
return dingdanChanpin;
}
public void
setDingdanChanpin(List<Dingdan_Chanpin> dingdanChanpin) {
List<Dingdan_Chanpin> old
Value = this
.dingdanChanpin;
this
.dingdanChanpin = dingdanChanpin;
fire
PropertyChange(“dingdanChanpin”, old
Value, dingdanChanpin);
}
public Chanpin() {
}
public String getBianhao() {
return bianhao;
}
public void
setBianhao(String bianhao) {
String old
Value = this
.bianhao;
this
.bianhao = bianhao;
fire
PropertyChange(“bianhao”, old
Value, bianhao);
}
}
/* ========== Chanpin_Zujian
.java ========== */
package com
.example
.kucun2
.entity;
import com
.example
.kucun2
.entity
.data
.EntityClassGrassrootsid;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
//产品组件关联
public class Chanpin_Zujian extends SynchronizableEntity implements EntityClassGrassrootsid {
private Integer id;
private Chanpin chanpin;
private Zujian zujian;
private Double one_howmany;
private Bancai bancai;
public Chanpin_Zujian() {
super();
}
@Override
public Integer getId() {
return id;
}
public void
setId(Integer id) {
Integer old
Value = this
.id;
this
.id = id;
fire
PropertyChange(“id”, old
Value, id);
}
public Chanpin getChanpin() {
return chanpin;
}
public void
setChanpin(Chanpin chanpin) {
Chanpin old
Value = this
.chanpin;
this
.chanpin = chanpin;
fire
PropertyChange(“chanpin”, old
Value, chanpin);
}
public Zujian getZujian() {
return zujian;
}
public void
setZujian(Zujian zujian) {
Zujian old
Value = this
.zujian;
this
.zujian = zujian;
fire
PropertyChange(“zujian”, old
Value, zujian);
}
public Double ge
tOne_howmany() {
return one_howmany;
}
public void
setOne_howmany(Double one_howmany) {
Double old
Value = this
.one_howmany;
this
.one_howmany = one_howmany;
fire
PropertyChange(“one_howmany”, old
Value, one_howmany);
}
public Bancai getBancai() {
return bancai;
}
public void
setBancai(Bancai bancai) {
Bancai old
Value = this
.bancai;
this
.bancai = bancai;
fire
PropertyChange(“bancai”, old
Value, bancai);
}
}
/* ========== Dingdan
.java ========== */
package com
.example
.kucun2
.entity;
import com
.example
.kucun2
.entity
.data
.EntityClassGrassrootsid;
import com
.example
.kucun2
.entity
.data
.SynchronizableEntity;
import
java.util
.ArrayList;
import
java.util
.Date;
import
java.util
.List;
/**
订单
*/
public class Dingdan extends SynchronizableEntity implements EntityClassGrassrootsid {
private Integer id;
private String number;
private List<Dingdan_Chanpin> dingdanChanpin = new ArrayList<>();
;
private List<Dingdan_chanpin_zujian> dingdanChanpinZujian = new ArrayList<>();
;
private Date xiadan;
private Date jiaohuo;
public List<Dingdan_Chanpin> getDingdanChanpin() {
return dingdanChanpin;
}
public void
setDingdanChanpin(List<Dingdan_Chanpin> dingdanChanpin) {
List<Dingdan_Chanpin> old
Value = this
.dingdanChanpin;
this
.dingdanChanpin = dingdanChanpin;
fire
PropertyChange(“dingdanChanpin”, old
Value, dingdanChanpin);
}
@Override
public Integer getId() {
return id;
}
public void
setId(Integer id) {
Integer old
Value = this
.id;
this
.id = id;
fire
PropertyChange(“id”, old
Value, id);
}
public String getNumber() {
return number;
}
public void
setNumber(String number) {
String old
Value = this
.number;
this
.number = number;
fire
PropertyChange(“number”, old
Value, number);
}
public Date getXiadan() {
return xiadan;
}
public void
setXiadan(Date xiadan) {
Date old
Value = this
.xiadan;
this
.xiadan = xiadan;
fire
PropertyChange(“xiadan”, old
Value, xiadan);
}
public Date getJiaohuo() {
return jiaohuo;
}
public void
setJiaohuo(Date jiaohuo) {
Date old
Value = this
.jiaohuo;
this
.jiaohuo = jiaohuo;
fire
PropertyChange(“jiaohuo”, old
Value, jiaohuo);
}
public Dingdan() {
}
public List<Dingdan_chanpin_zujian> getDingdanChanpinZujian() {
return dingdanChanpinZujian;
}
public void
setDingdanChanpinZujian(List<Dingdan_chanpin_zujian> dingdanChanpinZujian) {
List<Dingdan_chanpin_zujian> old
Value = this
.dingdanChanpinZujian;
this
.dingdanChanpinZujian = dingdanChanpinZujian;
fire
PropertyChange(“dingdanChanpinZujian”, old
Value, dingdanChanpinZujian);
}
}
/* ========== EntityClassGrassrootsid
.java ========== */
package com
.example
.kucun2
.entity
.data;
public interface EntityClassGrassrootsid {
Integer getId();
void
setId(Integer id);
String getEndpoint(String type);
void sync();
}
/* ========== ReflectionJsonUtils
.java ========== */
package com
.example
.kucun2
.entity
.data;
import android
.util
.Log;
import
java.lang
.reflect
.Field;
import
java.lang
.reflect
.Modifier;
import
java.util
.ArrayList;
import
java.util
.Collection;
import
java.util
.HashMap;
import
java.util
.List;
import
java.util
.Map;
public class ReflectionJsonUtils {
/**
将任意
Java对象转换为JSON字符串
@param
obj 需要转换的
对象
@return JSON格式字符串
*/
public static String
toJson(
Object
obj) {
if (
obj == null) {
return “null”;
}
Class<?> clazz =
obj.getClass();
// 处理
基础类型
if (isPrimitiveOrWrapper(clazz) || clazz == String
.class) {
return handlePrimitive(
obj);
}
// 处理数组
if (clazz
.isArray()) {
return handleArray(
obj);
}
// 处理集合
if (Collection
.class
.isAssignableFrom(clazz)) {
return handleCollection((Collection<?>)
obj);
}
// 处理Map
if (Map
.class
.isAssignableFrom(clazz)) {
return handleMap((Map<?, ?>)
obj);
}
// 处理自定义
对象
return handle
Object(
obj);
}
/**
处理基本数据类型和字符串
*/
private static String handlePrimitive(
Object
obj) {
if (
obj == null) return “null”;
Class<?> clazz =
obj.getClass();
if (clazz == String
.class) {
return “"” + escapeString((String)
obj) + “"”;
}
if (clazz == Character
.class || clazz == char
.class) {
return “"” + escapeChar((Character)
obj) + “"”;
}
return
obj.toString();
}
/**
处理数组
*/
private static String handleArray(
Object array) {
Class<?> componentType = array
.getClass()
.getComponentType();
int length =
java.lang
.reflect
.Array
.getLength(array);
StringBuilder sb = new StringBuilder(“[”);
for (int i = 0; i < length; i++) {
Object element =
java.lang
.reflect
.Array
.get(array, i);
sb
.append(
toJson(element));
if (i < length - 1) {
sb
.append(",");
}
}
sb
.append(“]”);
return sb
.toString();
}
/**
处理集合
*/
private static String handleCollection(Collection<?> collection) {
StringBuilder sb = new StringBuilder(“[”);
int index = 0;
int size = collection
.size();
for (
Object element
: collection) {
sb
.append(
toJson(element));
if (index < size - 1) {
sb
.append(“,”);
}
index++;
}
sb
.append(“]”);
return sb
.toString();
}
/**
处理Map
*/
private static String handleMap(Map<?, ?> map) {
StringBuilder sb = new StringBuilder(“{”);
int index = 0;
int size = map
.size();
for (Map
.Entry<?, ?> entry
: map
.entry
Set()) {
Object key = entry
.getKey();
Object
value = entry
.get
Value();
if (!(key instance
of String) && !isPrimitiveOrWrapper(key
.getClass())) {
throw new IllegalArgumentException("Map keys must be strings or primitives for JSON conversion");
}
String keyStr = key instance
of String ? (String) key
: key
.toString();
sb
.append("\"")
.append(escapeString(keyStr))
.append("\"
:");
sb
.append(
toJson(
value));
if (index < size - 1) {
sb
.append(",");
}
index++;
}
sb
.append(“}”);
return sb
.toString();
}
/**
处理自定义
对象
*/
private static String handle
Object(
Object
obj) {
Class<?> clazz =
obj.getClass();
Field[] fields = getAllFields(clazz);
StringBuilder sb = new StringBuilder(“{”);
int index = 0;
for (Field field
: fields) {
// 跳过静态字段
if (Modifier
.isStatic(field
.getModifiers())) {
continue;
}
field
.setAccessible(true);
String field
Name = field
.get
Name();
Object field
Value = null;
try {
field
Value = field
.get(
obj);
} catch (IllegalAccessException e) {
// 忽略访问异常，字段
值保持null
Log
.e("ReflectionJsonUtils", "handle
Object
: " + e
.getLocalizedMessage());
}
sb
.append("\"")
.append(escapeString(field
Name))
.append("\"
:");
if (SynchronizableEntity
.class
.isAssignableFrom(field
.getType()) &&
field
Value != null && ((SynchronizableEntity) field
Value)
.getId() != null) {
try {
Log
.d("ReflectionJsonUtils", "isAssignableFrom
: " + sb);
sb
.append("{\"id\"
:")
.append(((SynchronizableEntity) field
Value)
.getId())
.append("}");
} catch (Exception e) {
sb
.append(
toJson(field
Value));
}
} else {
sb
.append(
toJson(field
Value));
}
if (index < fields
.length - 1) {
sb
.append(",");
}
index++;
}
sb
.append(“}”);
Log
.d(“ReflectionJsonUtils”, "handle
Object
: " + sb);
return sb
.toString();
}
// 获取类及其父类的所有字段
private static Field[] getAllFields(Class<?> type) {
List<Field> fields = new ArrayList<>();
while (type != null && type !=
Object
.class) {
Field[] declaredFields = type
.getDeclaredFields();
for (Field field
: declaredFields) {
// 跳过静态字段
if (!Modifier
.isStatic(field
.getModifiers())) {
fields
.add(field);
}
}
type = type
.getSuperclass();
}
return fields
.toArray(new Field[0]);
}
// 检查是否基本类型或其包装类
private static boolean isPrimitiveOrWrapper(Class<?> clazz) {
return clazz
.isPrimitive() ||
clazz == Boolean
.class ||
clazz == Character
.class ||
clazz == Byte
.class ||
clazz == Short
.class ||
clazz == Integer
.class ||
clazz == Long
.class ||
clazz == Float
.class ||
clazz == Double
.class ||
clazz == Void
.class;
}
// 转义JSON字符串中的特殊字符
private static String escapeString(String str) {
if (str == null) return “”;
return str
.replace(“\”, “\\”)
.replace(“"”, “\"”)
.replace(“/”, “\/”)
.replace(“\b”, “\b”)
.replace(“\f”, “\f”)
.replace(“\n”, “\n”)
.replace(“\r”, “\r”)
.replace(“\t”, “\t”);
}
// 转义特殊字符
private static String escapeChar(Character ch) {
if (ch == null) return “”;
return escapeString(String
.valueOf(ch));
}
}
/* ========== SynchronizableEntity
.java ========== */
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 boolean isPreserved
Object() {
return this
.getId() != null && this
.getId() == -1;
}
public enum SyncState {NEW, MODIFIED, DELETED, PRESERVED}
SyncState state = SyncState
.NEW;
private static boolean syncEnabled = true;
public static void
setSyncEnabled(boolean enabled) {
syncEnabled = enabled;
}
//
设置状态的
方法
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 add
PropertyChangeListener(
PropertyChangeListener listener) {
if (changeSupport == null) {
changeSupport = new
PropertyChangeSupport(this);
}
changeSupport
.add
PropertyChangeListener(listener);
}
// 移除
属性变更监听器
public void remove
PropertyChangeListener(
PropertyChangeListener listener) {
if (changeSupport != null) {
changeSupport
.remove
PropertyChangeListener(listener);
}
}
// 触发
属性变更通知（子类在
setter中调用）
protected void fire
PropertyChange(String
propertyName,
Object old
Value,
Object new
Value) {
if (changeSupport != null && changeSupport
.hasListeners(
propertyName)) {
// 更新
属性缓存（可选）
propertyCache
.put(
propertyName, new
Value);
// 触发变更事件
changeSupport
.fire
PropertyChange(
propertyName, old
Value, new
Value);
}
}
// 获取
属性当前
值（可选，用于
setter中获取旧
值）
protected <T> T getCached
Property(String
propertyName) {
return (T)
propertyCache
.get(
propertyName);
}
// 初始化
属性缓存（可选，在构造函数中调用）
protected void init
PropertyCache() {
// 初始化所有字段到缓存
for (
java.lang
.reflect
.Field field
: getClass()
.getDeclaredFields()) {
try {
field
.setAccessible(true);
propertyCache
.put(field
.get
Name(), 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()
.getSimple
Name()
.toLowerCase()); return MyAppFnction
.getStringResource(“string”, "url” + type + “_” + this
.getClass()
.getSimple
Name()
.toLowerCase()); }
public void sync() {
if (!syncEnabled) return; // 全局控制开关
if (this
.state == null) return;
try {
switch (this
.state) {
case NEW
:
create
ToServer();
break;
case MODIFIED
:
update
ToServer();
break;
case DELETED
:
deleteFromServer();
break;
}
} catch (Exception e) {
Log
.e("SyncError", "Sync failed for " + getClass()
.getSimple
Name(), e);
}
}
/**
创建实体到后端
*/
private void create
ToServer() {
String endpoint = MyAppFnction
.getStringResource(“string”, “url”) + getEndpoint(“add”);
Information<SynchronizableEntity> requestData = new Information<SynchronizableEntity>();
// 使用Volley、Retr
ofit或OkHttp执行POST请求
// 伪代码示例：
ApiClient
.post(endpoint, requestData, new ApiClient
.ApiCallback<SynchronizableEntity>() {
@Override
public void onSuccess(Information<SynchronizableEntity> e) {
// 解析服务器返回的ID
Log
.d(“onSuccess”, e
.toJson());
if (e
.getData() != null) {
setId(e
.getData()
.getId()); //
设置服务器返回的ID
}
state = SyncState
.MODIFIED;
state = SyncState
.MODIFIED;
}
});
}
/**
更新实体到后端
*/
private void update
ToServer() {
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);
}
}
/* ========== SynchronizedList
.java ========== */
package com
.example
.kucun2
.entity
.data;
import android
.annotation
.SuppressLint;
import android
.util
.Log;
import com
.google
.gson
.Gson;
import
java.beans
.PropertyChangeEvent;
import
java.beans
.PropertyChangeListener;
import
java.lang
.reflect
.InvocationTargetException;
import
java.util
.ArrayList;
import
java.util
.Collection;
import
java.util
.Itera
tor;
import
java.util
.List;
import
java.util
.ListItera
tor;
/**
支持数据变更自动同步的泛型集合类
基于SynchronizableEntity的事件机制实现数据变更自动同步
@param <T> 必须是SynchronizableEntity或其子类
*/
public class SynchronizedList<T extends SynchronizableEntity> implements List<T> {
// 使用ArrayList作为底层存储
private final List<T> list = new ArrayList<>();
public Class<T> getEntityType() {
return entityType;
}
private Class<T> entityType;
public SynchronizedList(Class<T> T) {
this
.entityType = 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 Itera
tor<T> itera
tor() {
return new SyncedItera
tor<>(list
.itera
tor(), entityChangeListener);
}
@Override
public
Object[]
toArray() {
return list
.toArray();
}
@Override
public <E> E[]
toArray(E[] a) {
return list
.toArray(a);
}
// 添加元素时注册监听器
@SuppressLint(“SuspiciousIndentation”)
@Override
public boolean add(T element) {
if (element != null) {
element
.add
PropertyChangeListener(entityChangeListener);
}
return list
.add(element);
}
// 移除元素时注销监听器
@Override
public boolean remove(
Object o) {
if (o instance
of SynchronizableEntity) {
((SynchronizableEntity) o)
.remove
PropertyChangeListener(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
.add
PropertyChangeListener(entityChangeListener);
}
}
return list
.addAll©;
}
@Override
public boolean addAll(int index, Collection<? extends T> c) {
for (T element
: c) {
if (element != null) {
element
.add
PropertyChangeListener(entityChangeListener);
}
}
return list
.addAll(index, c);
}
// 批量移除时逐个注销监听器
@Override
public boolean removeAll(Collection<?> c) {
for (
Object o
: c) {
if (o instance
of SynchronizableEntity) {
((SynchronizableEntity) o)
.remove
PropertyChangeListener(entityChangeListener);
}
}
return list
.removeAll©;
}
@Override
public boolean retainAll(Collection<?> c) {
// 先移除未保留元素的监听器
for (T element
: list) {
if (!c
.contains(element)) {
element
.remove
PropertyChangeListener(entityChangeListener);
}
}
return list
.retainAll©;
}
// 清空集合时移除所有监听器
@Override
public void clear() {
for (T element
: list) {
element
.remove
PropertyChangeListener(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
.remove
PropertyChangeListener(entityChangeListener);
}
if (element != null) {
element
.add
PropertyChangeListener(entityChangeListener);
}
return list
.set(index, element);
}
// 在指定位置添加元素时注册监听器
@Override
public void add(int index, T element) {
if (element != null) {
element
.add
PropertyChangeListener(entityChangeListener);
}
list
.add(index, element);
}
// 移除元素时注销监听器
@Override
public T remove(int index) {
T removed = list
.remove(index);
if (removed != null) {
removed
.remove
PropertyChangeListener(entityChangeListener);
}
return removed;
}
@Override
public int index
Of(
Object o) {
return list
.index
Of(o);
}
@Override
public int lastIndex
Of(
Object o) {
return list
.lastIndex
Of(o);
}
@Override
public ListItera
tor<T> listItera
tor() {
return new SyncedListItera
tor<>(list
.listItera
tor(), entityChangeListener);
}
@Override
public ListItera
tor<T> listItera
tor(int index) {
return new SyncedListItera
tor<>(list
.listItera
tor(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(); // 触发同步操作 } }
/*
增强的Itera
tor实现
移除元素时自动注销监听器
*/
private static class SyncedItera
tor<T extends SynchronizableEntity> implements Itera
tor<T> {
private final Itera
tor<T> itera
tor;
private final EntityChangeListener<T> listener;
private T current;
public SyncedItera
tor(Itera
tor<T> itera
tor, EntityChangeListener<T> listener) {
this
.itera
tor = itera
tor;
this
.listener = listener;
}
@Override
public boolean hasNext() {
return itera
tor
.hasNext();
}
@Override
public T next() {
current = itera
tor
.next();
return current;
}
@Override
public void remove() {
if (current != null) {
current
.remove
PropertyChangeListener(listener);
}
itera
tor
.remove();
}
}
/**
增强的ListItera
tor实现
支持添加/
设置元素时的监听器管理
*/
private static class SyncedListItera
tor<T extends SynchronizableEntity>
implements ListItera
tor<T> {
private final ListItera
tor<T> itera
tor;
private final EntityChangeListener<T> listener;
private T lastReturned;
public SyncedListItera
tor(ListItera
tor<T> itera
tor, EntityChangeListener<T> listener) {
this
.itera
tor = itera
tor;
this
.listener = listener;
}
@Override
public boolean hasNext() {
return itera
tor
.hasNext();
}
@Override
public T next() {
lastReturned = itera
tor
.next();
return lastReturned;
}
@Override
public boolean hasPrevious() {
return itera
tor
.hasPrevious();
}
@Override
public T previous() {
lastReturned = itera
tor
.previous();
return lastReturned;
}
@Override
public int nextIndex() {
return itera
tor
.nextIndex();
}
@Override
public int previousIndex() {
return itera
tor
.previousIndex();
}
@Override
public void remove() {
if (lastReturned != null) {
lastReturned
.remove
PropertyChangeListener(listener);
}
itera
tor
.remove();
}
@Override
public void
set(T e) {
if (lastReturned != null) {
lastReturned
.remove
PropertyChangeListener(listener);
}
if (e != null) {
e
.add
PropertyChangeListener(listener);
}
itera
tor
.set(e);
lastReturned = e;
}
@Override
public void add(T e) {
if (e != null) {
e
.add
PropertyChangeListener(listener);
}
itera
tor
.add(e);
}
}
}
/* ========== Data
.java ========== */
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
.Type
Token;
import
java.io
.IOException;
import
java.lang
.reflect
.;
import
java.util
.;
import
java.util
.stream
.Collec
tors;
import okhttp3
.;
/**
核心数据管理类
负责：
声明所有实体类的静态存储列表
从服务器加载全量数据
管理实体间的关联关系
处理数据同步状态 */ 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); private static User user;
// 实体类型与列表的映射表 <实体类, 对应的同步列表>
public static final Map<Class, SynchronizedList<SynchronizableEntity>> dataCollectionMap = new HashMap<>();
private static final Gson gson = GsonFac
tory
.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”);
}
ensurePreserved
Objects(); // 确保存在预置
对象
// 使用传入的 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);
ensurePreserved
Objects();
// 在主线程处理解析
mainHandler
.post(() -> {
parseAndAssignData(responseData, context, callback);
});
}
});
}
// ====================== 数据处理私有
方法 ======================
/**
解析JSON数据并更新到实体列表
*/
private static void parseAndAssignData(String jsonData, Context context, LoadDataCallback callback) {
try {
// 解析顶层响应结构
Type respon
seType = new Type
Token<Information<AllDataResponse>>() {}
.getType();
Information<AllDataResponse> info = gson
.fromJson(jsonData, respon
seType);
// 验证响应有效性
if (info == null || info
.getData() == null || info
.getStatus() != 200) {
throw new IllegalStateException(“无效服务器响应”);
}
AllDataResponse allData = info
.getData();
SafeLogger
.d(“data”, "原始数据
: " + gson
.toJson(allData));
// 更新所有数据列表
updateAllLists(allData);
au
tomaticAssociation(); // 建立实体关联
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
.isPreserved
Object())
.collect(Collec
tors
.toList());
// 清空后重新添加（预置
对象 + 有效新数据）
existingList
.clear();
existingList
.addAll(preservedItems);
existingList
.addAll(newList
.stream()
.filter(item -> item != null && item
.getId() != null && item
.getId() != -1)
.collect(Collec
tors
.toList())
);
}
/**
确保每个列表都有预置
对象（用于表示空
值/默认
值） / private static void ensurePreserved
Objects() { // 为每个实体类型检查并添加预置
对象 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 (!containsPreserved
Object(list)) {
list
.add(createInstance(clazz));
}
}
/*
检查列表是否包含预置
对象
@param list 目标实体列表
@return 是否包含预置
对象 / private static <T extends SynchronizableEntity> boolean containsPreserved
Object(List<T> list) { return list
.stream()
.anyMatch(item -> item != null && item
.isPreserved
Object() ); } /*
自动建立实体间关联关系（通过
反射实现） */ private static void au
tomaticAssociation() { for (Class<?> entityClass
: dataCollectionMap
.key
Set()) { try { associateEntities(dataCollectionMap
.get(entityClass)); } catch (Exception e) { Log
.e(TAG, entityClass
.getSimple
Name() + " 关联失败", 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 {
setDefaultPrimitive
Value(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 instance
of ParameterizedType)) return;
Class<?> itemType = Class
.for
Name(
((ParameterizedType) genericType)
.getActualTypeArguments()[0]
.getType
Name()
);
// 只处理实体列表
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
.single
ton(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
::isPreserved
Object)
.findFirst()
.orElse(null);
}
// 按ID查找目标实体
return targetList
.stream()
.filter(e -> ref
.getId()
.equals(e
.getId()))
.findFirst()
.orElseGet(() -> targetList
.stream() // 找不到时回退到预置
对象
.filter(SynchronizableEntity
::isPreserved
Object)
.findFirst()
.orElse(null)
);
}
// ====================== 工具
方法 ======================
/**
创建带默认
值的实体实例（用作预置
对象）
*/
public static <T> T createInstance(Class<T> clazz) {
try {
T instance = clazz
.getDeclaredConstruc
tor()
.newInstance();
//
设置基础字段默认
值
for (Field field
: clazz
.getDeclaredFields()) {
field
.setAccessible(true);
setDefaultField
Value(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
.get
Name(), e);
try {
return clazz
.newInstance(); // 回退创建
} catch (Exception ex) {
throw new RuntimeException(“无法创建实例”, ex);
}
}
}
private static <T> void
setDefaultField
Value(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
::isPreserved
Object)
.findFirst()
.orElse(null);
}
private static void
setDefaultPrimitive
Value(
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;
}
}
package com
.example
.kucun2
.entity
.data;
import static android
.content
.Content
Values
.TAG;
import android
.content
.Context;
import android
.util
.Log;
import com
.example
.kucun2
.R;
import com
.example
.kucun2
.entity
.Information;
import com
.example
.kucun2
.function
.MyAppFnction;
import com
.example
.kucun2
.function
.TLSUtils;
import com
.google
.gson
.Gson;
import com
.google
.gson
.reflect
.Type
Token;
import
java.io
.IOException;
import
java.lang
.reflect
.Type;
import
java.util
.Map;
import
javax
.net
.ssl
.SSLContext;
import
javax
.net
.ssl
.SSLSocketFac
tory;
import
javax
.net
.ssl
.X509TrustManager;
import okhttp3
.Call;
import okhttp3
.Callback;
import okhttp3
.MediaType;
import okhttp3
.OkHttpClient;
import okhttp3
.Request;
import okhttp3
.RequestBody;
import okhttp3
.Response;
import okhttp3
.ResponseBody;
public class ApiClient {
// 使用Volley、Retr
ofit或OkHttp实现以下
方法
private static final Gson gson = new Gson();
private static OkHttpClient client;
private static final String TAG = "DataLoader";
static {
}
public static <T, R> void post(String url, Information<T> requestData, ApiCallback<R> callback) {
// 1
. 构建请求体（JSON格式）
String jsonRequest = gson
.toJson(requestData);
RequestBody body = RequestBody
.create(MediaType
.parse("application/json; char
set=utf-8"), jsonRequest);
// 2
. 创建POST请求
Request request = new Request
.Builder()
.url(url)
.post(body)
.build();
Log
.d(TAG, "POST请求URL
: " + url);
Log
.d(TAG, "请求数据
: " + jsonRequest);
// 3
. 发送异步请求
client
.newCall(request)
.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
Log
.e(TAG, "请求失败
: " + e
.getMessage());
if (callback != null) {
//callback
.onError(-1, e
.getMessage());
}
}
@Override
public void onResponse(Call call, Response response) throws IOException {
try (ResponseBody responseBody = response
.body()) {
if (!response
.isSuccessful()) {
Log
.e(TAG, "服务器响应错误
: " + response
.code() + " - " + response
.message());
if (callback != null) {
// callback
.onError(response
.code(), response
.message());
}
return;
}
// 4
. 处理成功响应
String jsonResponse = responseBody
.string();
Log
.d(TAG, "服务器响应
: " + jsonResponse);
// 5
. 解析为Information
对象
// 注意：这里需要提前确定响应中data的类型（Type
Token）
Type respon
seType = new Type
Token<Information<R>>() {
}
.getType();
Information<R> responseInfo = gson
.fromJson(jsonResponse, respon
seType);
if (callback != null) {
callback
.onSuccess(responseInfo);
}
}
}
});
}
public static <T, R> void put(String url, Information<T> data, ApiCallback<T> callback) {
// 实现PUT请求逻辑
}
public static <R> void delete(String url, ApiCallback<R> callback) {
// 实现DELETE请求逻辑
}
public static interface ApiCallback<T> {
void onSuccess(Information<T> data);
// void onError(int statusCode, String error);
}
}<string
name=“url”>https
://192
.168
.31
.177
:3000</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>补全自动同步
本文介绍了一个实用的方法，该方法利用反射机制，能够为任意对象的指定属性设置新的值。这在需要动态修改对象状态的场景中非常有用。
扫一扫
943
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
