package com
.kucun
.Service;
import
java.io
.Serializable;
import
java.lang.reflect
.Field;
import
java.util
.*;
import
java.util
.stream
.Collectors;
import
javax
.persistence
.Entity
NotFoundException;
import org
.springframework
.be
ans
.factory
.annotation
.Autowired;
import org
.springframework
.dao
.DataAccessException;
import org
.springframework
.data.domain
.Example;
import org
.springframework
.data.domain
.ExampleMatcher;
import org
.springframework
.data.jpa.repository
.JpaRepository;
import org
.springframework
.stereo
type.Service;
import com
.kucun
.data.entity
.*;
import com
.kucun
.dataDo
.*;
@Service
public
class AppService {
// 自动注入所有依赖
@Autowired private KucunRepository kucunRepository;
@Autowired private DynamicRepositoryService repositoryService;
@Autowired private EntityDependencyService dependencyService;
/**
* 获取所有实体类型的数据
* @return 包含所有实体数据的Map
*/
public Information getAll
Data() {
Map<String,
Object> response = new HashMap<>();
repositoryService
.getRepositoryNameMap()
.forEach((key, repo)
->
response
.put(key + "s", repo
.findAll())
);
return Information
.NewSuccess(response);
}
/**
* 获取指定实体类型的所有数据
* @param entityName 实体名称
* @return 实体数据列表
*/
public Information getEntity
Data(String entityName) {
JpaRepository<?, ?> repo = repositoryService
.get
JpaRepository(entityName);
return Information
.NewSuccess(repo
.findAll());
}
/**
* 添加新实体
* @param entity 要添加的实体对象
* @return 添加结果
*/
public Information addEntity(
Object entity) {
try {
// 处理关联字段
h
andleAssociations(entity);
// 获取对应的Repository并保存
JpaRepository<
Object, Serializable> repo =
(
JpaRepository<
Object, Serializable>) repositoryService
.get
JpaRepository(entity
.get
Class());
Object savedEntity = repo
.save(entity);
// 如果是板材，初始化库存
if (savedEntity inst
anceof B
ancai) {
initializeKucunForB
ancai((B
ancai) savedEntity);
}
return Information
.NewSuccess(savedEntity);
} catch (Exception ex) {
return Information
.Newfail(500, "创建失败
: " + ex
.getMessage(), null);
}
}
/**
* 更新实体
* @param entity 包含ID的实体对象
* @return 更新结果
*/
public Information updateEntity(
Object entity) {
if (entity == null) {
return Information
.Newfail(403, "参数为空", null);
}
try {
// 获取ID字段
Field idField = entity
.get
Class()
.getDeclaredField("id");
idField
.setAccessible(true);
Object idValue = idField
.get(entity);
if (idValue == null) {
return Information
.Newfail(403, "ID为空", null);
}
// 获取Repository和现有实体
JpaRepository<
Object, Serializable> repo =
(
JpaRepository<
Object, Serializable>) repositoryService
.get
JpaRepository(entity
.get
Class());
Object existingEntity = repo
.findById((Serializable) idValue)
.orElseThrow(()
-> new RuntimeException("实体不存在"));
// 复制非空属性并保存
copyNonNullProperties(entity, existingEntity);
return Information
.NewSuccess(repo
.save(existingEntity));
} catch (Exception ex) {
return Information
.Newfail(500, "更新失败
: " + ex
.getMessage(), null);
}
}
/**
* 删除实体
* @param entity 要删除的实体
* @return 删除结果
*/
public Information deleteEntity(EntityBasis entity) {
if (entity == null) {
return Information
.NewFail("删除对象不能为空");
}
try {
String entityName = entity
.get
Class()
.getSimpleName()
.toLowerCase();
JpaRepository<
Object, Serializable> repo =
(
JpaRepository<
Object, Serializable>) repositoryService
.get
JpaRepository(entityName);
// 先加载完整实体（关键步骤）
Object fullEntity = repo
.findById(entity
.getId())
.orElseThrow(()
-> new Entity
NotFoundException("实体不存在"));
if(entity inst
anceof B
ancai) {
if(((B
ancai)fullEntity)
.getKucun()
.getShuli
ang()>0) {
return Information
.NewFail("库存不为零，无法删除");
}
}
// 检查依赖关系
if (dependencyService
.hasDependencies(entity
.get
Class(), entity
.getId())) {
return Information
.NewFail("该记录已被引用，无法删除");
}
// 使用实体对象删除（触发级联操作）
repo
.delete(fullEntity);
return Information
.NewSuccess("删除成功");
} catch (Exception e) {
return Information
.NewFail("删除错误
: " + e
.getMessage());
}
}
/**
* 动态查询实体
* @param entity 包含查询条件的实体对象
* @return 查询结果
*/
public <T> Information queryEntity(T entity) {
if (entity == null) {
return Information
.NewFail("查询参数不能为空");
}
try {
JpaRepository<T, ?> repo = (
JpaRepository<T, ?>) repositoryService
.get
JpaRepository(entity
.get
Class());
Example<T> example = Example
.of(entity, ExampleMatcher
.matching()
.withIgnoreNullValues()
.withStringMatcher(ExampleMatcher
.StringMatcher
.CONTAINING));
return Information
.NewSuccess(repo
.findAll(example));
} catch (Exception e) {
return Information
.NewFail("查询失败
: " + e
.getMessage());
}
}
// ====================== 私有辅助方法 ======================
/**
* 为板材初始化库存
* @param b
ancai 板材对象
*/
private void initializeKucunForB
ancai(B
ancai b
ancai) throws Exception {
Kucun kucun = new Kucun(null, b
ancai, 0);
b
ancai
.setKucun(kucunRepository
.save(kucun));
}
/**
* 处理实体关联关系
* @param entity 要处理的实体
*/
private void h
andleAssociations(
Object entity) throws Exception {
for (Field field
: entity
.get
Class()
.getDeclaredFields()) {
field
.setAccessible(true);
Object value = field
.get(entity);
if (value == null) continue;
// 处理
JPA 实体关联
if (value inst
anceof EntityBasis) {
EntityBasis associated = (EntityBasis) value;
JpaRepository<
Object, Serializable> repo =
(
JpaRepository<
Object, Serializable>) repositoryService
.get
JpaRepository(associated
.get
Class()
.getSimpleName()
.toLowerCase());
// 只处理已存在实体（不创建新关联）
if (associated
.getId() != null) {
Object managedEntity = repo
.findById(associated
.getId())
.orElseThrow(()
-> new RuntimeException("关联实体不存在"));
field
.set(entity,
managedEntity);
}
}
// 处理集合关联
else if (value inst
anceof Collection) {
List<
Object>
managedEntities = new ArrayList<>();
for (
Object item
: (Collection<?>) value) {
if (item inst
anceof EntityBasis) {
EntityBasis eb = (EntityBasis) item;
JpaRepository<
Object, Serializable> repo =
(
JpaRepository<
Object, Serializable>) repositoryService
.get
JpaRepository(eb
.get
Class()
.getSimpleName()
.toLowerCase());
if (eb
.getId() != null) {
managedEntities
.add(repo
.findById(eb
.getId())
.orElseThrow(()
-> new RuntimeException("关联实体不存在")));
}
}
}
if (!
managedEntities
.isEmpty()) {
field
.set(entity,
managedEntities);
}
}
}
}
/**
* 复制非空属性
* @param source 源对象
* @param target 目标对象
*/
private void copyNonNullProperties(
Object source,
Object target) throws IllegalAccessException {
for (Field field
: source
.get
Class()
.getDeclaredFields()) {
field
.setAccessible(true);
Object value = field
.get(source);
// 跳过关联字段和ID字段
if (value != null &&
!(value inst
anceof EntityBasis) &&
!(value inst
anceof Collection) &&
!field
.getName()
.equals("id")) {
try {
Field targetField = target
.get
Class()
.getDeclaredField(field
.getName());
targetField
.setAccessible(true);
targetField
.set(target, value);
} catch (NoSuchFieldException ignored) {}
}
}
}
}package com
.kucun
.controller;
import com
.fasterxml
.jackson
.databind
.ObjectMapper;
import com
.kucun
.Service
.AppService;
import com
.kucun
.data.entity
.*;
import org
.springframework
.be
ans
.factory
.annotation
.Autowired;
import org
.springframework
.web
.bind
.annotation
.*;
import
java.util
.Collections;
import
java.util
.HashMap;
import
java.util
.Map;
@RestController
@RequestMapping("/app")
public
class AppController {
//
Java 8 兼容的实体类型映射
private static final Map<String,
Class<?>> ENTITY_MAP;
static {
Map<String,
Class<?>> map = new HashMap<>();
map
.put("user", User
.class);
map
.put("b
ancai", B
ancai
.class);
map
.put("caizi", Caizhi
.class);
map
.put("mupi", Mupi
.class);
map
.put("dingd
an", Dingd
an.class);
map
.put("zuji
an", Zuji
an.class);
map
.put("ch
anpin", Ch
anpin
.class);
map
.put("dingd
an_ch
anpin", Dingd
an_ch
anpin
.class);
map
.put("dingd
an_ch
anpin_zuji
an", Dingd
an_ch
anpin_zuji
an.class);
map
.put("ch
anpin_zuji
an", Ch
anpin_zuji
an.class);
map
.put("jinhuo", Jinhuo
.class);
map
.put("kucun", Kucun
.class);
ENTITY_MAP = Collections
.unmodifiableMap(map);
}
@Autowired
private AppService appService;
@Autowired
private
ObjectMapper
objectMapper;
// ====================== 数据查询 ======================
@GetMapping("/all")
public Information getAll
Data() {
return appService
.getAll
Data();
}
@GetMapping("/all/{entity
Type}")
public Information getEntity
Data(@PathVariable String entity
Type) {
return appService
.getEntity
Data(entity
Type.toLowerCase());
}
// ====================== CRUD操作 ======================
@PostMapping("/add/{entity
Type}")
public Information addEntity(
@PathVariable String entity
Type,
@RequestBody Map<String,
Object> requestBody
) {
return h
andleEntityOperation(entity
Type, requestBody, "add");
}
@PostMapping("/select/{entity
Type}")
public Information queryEntity(
@PathVariable String entity
Type,
@RequestBody Map<String,
Object> requestBody
) {
return h
andleEntityOperation(entity
Type, requestBody, "select");
}
@PostMapping("/delete/{entity
Type}")
public Information deleteEntity(
@PathVariable String entity
Type,
@RequestBody Map<String,
Object> requestBody
) {
return h
andleEntityOperation(entity
Type, requestBody, "delete");
}
@PostMapping("/update/{entity
Type}")
public Information updateEntity(
@PathVariable String entity
Type,
@RequestBody Map<String,
Object> requestBody
) {
return h
andleEntityOperation(entity
Type, requestBody, "update");
}
// ====================== 核心辅助方法 ======================
private Information h
andleEntityOperation(
String entity
Type,
Map<String,
Object> requestBody,
String operation
) {
String normalized
Type = entity
Type.toLowerCase();
Class<?> entity
Class = ENTITY_MAP
.get(normalized
Type);
if (entity
Class == null) {
return Information
.NewFail("不支持的实体类型
: " + entity
Type);
}
try {
Object entity =
objectMapper
.convertValue(requestBody, entity
Class);
switch (operation) {
case "add"
:
return appService
.addEntity(entity);
case "select"
:
return appService
.queryEntity(entity);
case "delete"
:
// 确保实体实现了EntityBasis接口
if (entity inst
anceof EntityBasis) {
return appService
.deleteEntity((EntityBasis) entity);
} else {
return Information
.NewFail("删除操作需要实体实现EntityBasis接口");
}
case "update"
:
return appService
.updateEntity(entity);
default
:
return Information
.NewFail("无效的操作类型");
}
} catch (Exception e) {
return Information
.NewFail(operation + "操作失败
: " + e
.getMessage());
}
}
}package com
.kucun
.Service;
import
javax
.persistence
.EntityM
anager;
import
javax
.persistence
.PersistenceContext;
import
javax
.persistence
.metamodel
.*;
import org
.springframework
.stereo
type.Service;
import
java.io
.Serializable;
import
java.util
.*;
import
java.util
.stream
.Collectors;
@Service
public
class EntityDependencyService {
@PersistenceContext
private EntityM
anager entityM
anager;
private final Map<
Class<?>, Set<Attribute<?, ?>>> associationCache = new HashMap<>();
/**
* 检查实体是否被其他实体引用
* @param entity
Class 实体类
* @param entityId 实体ID
* @return 存在引用返回true
*/
public boole
an hasDependencies(
Class<?> entity
Class, Serializable entityId) {
Metamodel metamodel = entityM
anager
.getMetamodel();
Set<Entity
Type<?>> entities = metamodel
.getEntities();
for (Entity
Type<?> entity
Type : entities) {
// 跳过自身（避免自引用检查）
if (entity
Type.get
JavaType()
.equals(entity
Class)) continue;
Set<Attribute<?, ?>> associations = getAssociationAttributes(entity
Type);
for (Attribute<?, ?> attr
: associations) {
if (attr
.get
JavaType()
.isAssignableFrom(entity
Class)) {
if (isReferenced(entity
Type, attr, entityId)) {
return true;
}
}
}
}
return false;
}
/**
* 获取实体所有关联属性（带缓存）
*/
private Set<Attribute<?, ?>> getAssociationAttributes(Entity
Type<?> entity
Type) {
return associationCache
.computeIfAbsent(entity
Type.get
JavaType(), k
->
entity
Type.getAttributes()
.stream()
.filter(Attribute
::isAssociation)
.collect(Collectors
.toSet())
);
}
/**
* 检查特定关联是否引用目标实体
*/
private boole
an isReferenced(Entity
Type<?> entity
Type, Attribute<?, ?> attribute, Serializable targetId) {
String jpql = buildReferenceQuery(entity
Type, attribute);
Long count = (Long) entityM
anager
.createQuery(jpql)
.setParameter("targetId", targetId)
.getSingleResult();
return count > 0;
}
/**
* 构建引用检查查询
*/
private String buildReferenceQuery(Entity
Type<?> entity
Type, Attribute<?, ?> attribute) {
String entityName = entity
Type.getName();
String attrName = attribute
.getName();
if (attribute inst
anceof PluralAttribute) {
return String
.format("SELECT COUNT(e) FROM %s e WHERE
:targetId MEMBER OF e
.%s",
entityName, attrName);
} else {
return String
.format("SELECT COUNT(e) FROM %s e WHERE e
.%s
.id =
:targetId",
entityName, attrName);
}
}
}package com
.kucun
.Service;
import
java.lang.reflect
.Parameterized
Type;
import
java.lang.reflect
.Type;
import
java.util
.HashMap;
import
java.util
.Map;
import org
.springframework
.be
ans
.factory
.annotation
.Autowired;
import org
.springframework
.data.jpa.repository
.JpaRepository;
import org
.springframework
.stereo
type.Service;
@Service
public
class DynamicRepositoryService {
private final Map<
Class<?>,
JpaRepository<?, ?>> repositoryMap = new HashMap<>();
private final Map<String,
JpaRepository<?, ?>> repositoryNameMap = new HashMap<>();
public Map<String,
JpaRepository<?, ?>> getRepositoryNameMap() {
return repositoryNameMap;
}
public Map<
Class<?>,
JpaRepository<?, ?>> getRepositoryMap() {
return repositoryMap;
}
public
JpaRepository<?,?> get
JpaRepository(String e){
// System
.out
.println("String
:"+e+mapToString(repositoryNameMap));
return repositoryNameMap
.get(e);
}
public
JpaRepository<?,?> get
JpaRepository(
Class<?> e){
// System
.out
.println("
Class:"+e+mapToString(repositoryMap));
// System
.out
.println("
Class:"+e);
return repositoryMap
.get(e);
}
// 自动注入所有
JpaRepository实例
@Autowired
public void initRepositories(Map<String,
JpaRepository<?, ?>> repositories) {
repositories
.forEach((name, repo)
-> {
// 获取代理类实现的接口
Class<?>[] interfaces = repo
.get
Class()
.getInterfaces();
for (
Class<?> iface
: interfaces) {
// 扫描接口上的泛型信息
Type[] genericInterfaces = iface
.getGenericInterfaces();
for (
Type type : genericInterfaces) {
if (
type inst
anceof Parameterized
Type) {
Parameterized
Type pt = (Parameterized
Type)
type;
// 检查原始类型是否是
JpaRepository
if (pt
.getRaw
Type()
.equals(
JpaRepository
.class)) {
Type[] args = pt
.getActual
TypeArguments();
if (args
.length >= 2 && args[0] inst
anceof
Class) {
Class<?> entity
Class = (
Class<?>) args[0];
repositoryMap
.put(entity
Class, repo);
String key = entity
Class.getSimpleName()
.toLowerCase();
repositoryNameMap
.put(key, repo);
// 调试日志
System
.out
.printf("Mapped %s
-> %s [key
: %s]%n",
entity
Class.getName(),
repo
.get
Class()
.getName(),
key);
}
}
}
}
// 检查接口本身的泛型签名（如果继承的是参数化接口）
Type genericSuper = iface
.getGenericSuper
class();
if (genericSuper inst
anceof Parameterized
Type) {
Parameterized
Type pt = (Parameterized
Type) genericSuper;
if (pt
.getRaw
Type()
.equals(
JpaRepository
.class)) {
Type[] args = pt
.getActual
TypeArguments();
if (args
.length >= 2 && args[0] inst
anceof
Class) {
Class<?> entity
Class = (
Class<?>) args[0];
repositoryMap
.put(entity
Class, repo);
String key = entity
Class.getSimpleName()
.toLowerCase();
repositoryNameMap
.put(key, repo);
// 调试日志
System
.out
.printf("Mapped %s
-> %s [key
: %s]%n",
entity
Class.getName(),
repo
.get
Class()
.getName(),
key);
}
}
}
}
});
}
// 通用保存方法
public <T> T saveEntity(T entity) {
JpaRepository<T, ?> repo = (
JpaRepository<T, ?>) repositoryMap
.get(entity
.get
Class());
if (repo != null) {
return repo
.save(entity);
}
throw new IllegalArgumentException("Repository
not found for " + entity
.get
Class());
}
public static String mapToString(Map<?, ?> map) {
if (map == null || map
.isEmpty()) {
return "";
}
StringBuilder sb = new StringBuilder();
for (Map
.Entry<?, ?> entry
: map
.entrySet()) {
sb
.append(entry
.getKey())
.append("=")
.append(entry
.getValue())
.append(",");
}
// 删除最后一个多余的逗号
if (sb
.length() > 0) {
sb
.setLength(sb
.length()
- 1);
}
return sb
.toString();
}
}package com
.kucun
.data.entity;
import
java.lang.annotation
.Annotation;
import
javax
.persistence
.Cascade
Type;
import
javax
.persistence
.Entity;
import
javax
.persistence
.Fetch
Type;
import
javax
.persistence
.GeneratedValue;
import
javax
.persistence
.Generation
Type;
import
javax
.persistence
.Id;
import
javax
.persistence
.JoinColumn;
import
javax
.persistence
.M
anyToOne;
import
javax
.persistence
.OneToOne;
import
javax
.persistence
.Table;
import com
.kucun
.data.entity
.DTO
.*;
import com
.fasterxml
.jackson
.annotation
.JsonBackReference;
import com
.fasterxml
.jackson
.annotation
.Json
ManagedReference;
import com
.fasterxml
.jackson
.databind
.annotation
.JsonSerialize;
/**
* 板材
* @author Administrator
*
*/
@Entity
@Table(name="b
ancai")
@JsonSerialize(using = FullEntitySerializer
.class)
public
class B
ancai implements EntityBasis {
@Id
@GeneratedValue(strategy = Generation
Type.IDENTITY)
private Integer id;
@M
anyToOne(cascade = Cascade
Type.ALL, fetch = Fetch
Type.LAZY)
@JoinColumn(name = "caizhi_id") //
private Caizhi caizhi;
@M
anyToOne(cascade = Cascade
Type.ALL, fetch = Fetch
Type.LAZY)
@JoinColumn(name = "mupi1_id")
private Mupi mupi1;
@M
anyToOne(cascade = Cascade
Type.ALL, fetch = Fetch
Type.LAZY)
@JoinColumn(name = "mupi2_id")
private Mupi mupi2;
private Double houdu;
@OneToOne(
cascade = Cascade
Type.ALL,
orph
anRemoval = true, // 添加此配置
fetch = Fetch
Type.LAZY
)
@JoinColumn(name = "kucun_id", referencedColumnName = "id")
private Kucun kucun;
public Kucun getKucun() {
return kucun;
}
public void setKucun(Kucun kucun) {
this
.kucun = kucun;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this
.id = id;
}
public Caizhi getCaizhi() {
return caizhi;
}
public void setCaizhi(Caizhi caizhi) {
this
.caizhi = caizhi;
}
public Mupi getMupi1() {
return mupi1;
}
public void setMupi1(Mupi mupi1) {
this
.mupi1 = mupi1;
}
public Mupi getMupi2() {
return mupi2;
}
public void setMupi2(Mupi mupi2) {
this
.mupi2 = mupi2;
}
public Double getHoudu() {
return houdu;
}
public void setHoudu(Double houdu) {
this
.houdu = houdu;
}
public B
ancai(int id, Caizhi caizhi, Mupi mupi1, Mupi mupi2, Double houdu) {
super();
this
.id = id;
this
.caizhi = caizhi;
this
.mupi1 = mupi1;
this
.mupi2 = mupi2;
this
.houdu = houdu;
}
public B
ancai() {
super();
}
}
package com
.kucun
.data.entity;
import
java.util
.List;
import
javax
.persistence
.Entity;
import
javax
.persistence
.Id;
import
javax
.persistence
.OneToM
any;
import
javax
.persistence
.Table;
import
javax
.persistence
.UniqueConstraint;
import com
.fasterxml
.jackson
.annotation
.JsonIgnore;
import com
.fasterxml
.jackson
.annotation
.JsonIgnoreProperties;
import com
.fasterxml
.jackson
.databind
.annotation
.JsonSerialize;
import com
.kucun
.data.entity
.DTO
.FullEntitySerializer;
/**
* 板材材质
* @author Administrator
*
*/
@Entity
@Table(name="caizhi", uniqueConstraints = {
@UniqueConstraint(columnNames = "name")
})
@JsonSerialize(using = FullEntitySerializer
.class)
public
class Caizhi extends SimpleEntity implements EntityBasis{
@OneToM
any(mappedBy="caizhi")
private List<B
ancai> b
ancais;
public Caizhi() {
super();
}
// 添加反向关联维护方法
public void addB
ancai(B
ancai b
ancai) {
b
ancais
.add(b
ancai);
b
ancai
.setCaizhi(this);
}
// 添加移除方法
public void removeB
ancai(B
ancai b
ancai) {
b
ancais
.remove(b
ancai);
b
ancai
.setCaizhi(null);
}
public List<B
ancai> getB
ancais() {
return b
ancais;
}
public void setB
ancais(List<B
ancai> b
ancais) {
this
.b
ancais = b
ancais;
}
}
package com
.kucun
.data.entity;
import
java.util
.List;
import
javax
.persistence
.Column;
import
javax
.persistence
.Entity;
import
javax
.persistence
.Id;
import
javax
.persistence
.M
anyToM
any;
import
javax
.persistence
.OneToM
any;
import
javax
.persistence
.Table;
import
javax
.persistence
.UniqueConstraint;
import org
.hibernate
.annotations
.Type;
import com
.fasterxml
.jackson
.annotation
.JsonIgnore;
import com
.fasterxml
.jackson
.annotation
.JsonIgnoreProperties;
import com
.fasterxml
.jackson
.databind
.annotation
.JsonSerialize;
import com
.kucun
.data.entity
.DTO
.FullEntitySerializer;
/**
* 木皮
* @author Administrator
*
*/
@Entity
@Table(name="mupi", uniqueConstraints = {
@UniqueConstraint(columnNames = "name")
})
@JsonSerialize(using = FullEntitySerializer
.class)
public
class Mupi extends SimpleEntity implements EntityBasis{
/**
* 是否有油漆
*/
@Column(name="you")
@
Type(
type = "org
.hibernate
.type.Boole
anType")
private Boole
an you;
// 添加 OneToM
any 映射
@OneToM
any(mappedBy = "mupi1") // 指向 B
ancai 中的 mupi1 字段
private List<B
ancai> b
ancaisForMupi1;
@OneToM
any(mappedBy = "mupi2") // 指向 B
ancai 中的 mupi2 字段
private List<B
ancai> b
ancaisForMupi2;
public List<B
ancai> getB
ancaisForMupi1() {
return b
ancaisForMupi1;
}
public void setB
ancaisForMupi1(List<B
ancai> b
ancaisForMupi1) {
this
.b
ancaisForMupi1 = b
ancaisForMupi1;
}
public List<B
ancai> getB
ancaisForMupi2() {
return b
ancaisForMupi2;
}
public void setB
ancaisForMupi2(List<B
ancai> b
ancaisForMupi2) {
this
.b
ancaisForMupi2 = b
ancaisForMupi2;
}
public Mupi() {
super();
}
public Boole
an getYou() {
return you;
}
public void setYou(Boole
an you) {
this
.you = you;
}
}
2025
-06
-17 13
:50
:08
.559 DEBUG 18340
--- [nio
-8080
-exec
-7] o
.s
.web
.servlet
.DispatcherServlet
: POST "/KuCun2/app/delete/b
ancai", parameters={}
2025
-06
-17 13
:50
:08
.561 DEBUG 18340
--- [nio
-8080
-exec
-7] s
.w
.s
.m
.m
.a
.RequestMappingH
andlerMapping
: Mapped to com
.kucun
.controller
.AppController#deleteEntity(String, Map)
2025
-06
-17 13
:50
:08
.567 DEBUG 18340
--- [nio
-8080
-exec
-7] m
.m
.a
.RequestResponseBodyMethodProcessor
: Read "application/json;charset=UTF
-8" to [{id=14}]
2025
-06
-17 13
:50
:08
.585 DEBUG 18340
--- [nio
-8080
-exec
-7] org
.hibernate
.SQL
: select b
ancai0_
.id as id1_0_0_, b
ancai0_
.caizhi_id as caizhi_i3_0_0_, b
ancai0_
.houdu as houdu2_0_0_, b
ancai0_
.kucun_id as kucun_id4_0_0_, b
ancai0_
.mupi1_id as mupi5_0_0_, b
ancai0_
.mupi2_id as mupi6_0_0_ from b
ancai b
ancai0_ where b
ancai0_
.id=?
Hibernate
: select b
ancai0_
.id as id1_0_0_, b
ancai0_
.caizhi_id as caizhi_i3_0_0_, b
ancai0_
.houdu as houdu2_0_0_, b
ancai0_
.kucun_id as kucun_id4_0_0_, b
ancai0_
.mupi1_id as mupi5_0_0_, b
ancai0_
.mupi2_id as mupi6_0_0_ from b
ancai b
ancai0_ where b
ancai0_
.id=?
2025
-06
-17 13
:50
:08
.590 DEBUG 18340
--- [nio
-8080
-exec
-7] m
.m
.a
.RequestResponseBodyMethodProcessor
: Using 'application/json', given [*/*]
and supported [application/json, application/*+json, application/json, application/*+json]
2025
-06
-17 13
:50
:08
.591 DEBUG 18340
--- [nio
-8080
-exec
-7] m
.m
.a
.RequestResponseBodyMethodProcessor
: Writing [com
.kucun
.data.entity
.Information@3dee3314]
2025
-06
-17 13
:50
:08
.591 DEBUG 18340
--- [nio
-8080
-exec
-7] o
.s
.web
.servlet
.DispatcherServlet
: Completed 200 OK
删除失败：null
扫一扫
1327
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
