package com
.kucun
.Service;
import
java.io
.Serializable;
import
java.lang.reflect
.Field;
import
java.util
.*;
import
java.util
.stream
.Collectors;
import
javax
.persistence
.EntityNotFoundException;
import org
.springframework
.beans
.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
.stereotype
.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 getAllData() {
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 getEntityData(String entityName) {
JpaRepository<?, ?> repo = repositoryService
.getJpaRepository(entityName);
return Information
.NewSuccess(repo
.findAll());
}
/**
* 添加新实体
* @
param entity 要添加的实体对象
* @return 添加结果
*/
public Information addEntity(Object entity) {
try {
// 处理关联字段
handleAssociations(entity);
// 获取对应的Repository并保存
JpaRepository<Object, Serializable> repo =
(JpaRepository<Object, Serializable>) repositoryService
.getJpaRepository(entity
.getClass());
Object savedEntity = repo
.save(entity);
// 如果是板材，初始化库存
if (savedEntity instanceof Bancai) {
initializeKucunForBancai((Bancai) 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
.getClass()
.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
.getJpaRepository(entity
.getClass());
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
.getClass()
.getSimpleName()
.toLowerCase();
JpaRepository<Object, Serializable> repo =
(JpaRepository<Object, Serializable>) repositoryService
.getJpaRepository(entityName);
// 先加载完整实体（关键步骤）
Object fullEntity = repo
.findById(entity
.getId())
.orElseThrow(() -> new EntityNotFoundException("实体不存在"));
if(entity instanceof Bancai) {
if(((Bancai)fullEntity)
.getKucun()
.getShuliang()>0) {
return Information
.NewFail("库存不为零，无法删除");
}
}
// 检查依赖关系
if (dependencyService
.hasDependencies(entity
.getClass(), 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
.getJpaRepository(entity
.getClass());
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 bancai 板材对象
*/
private void initializeKucunForBancai(Bancai bancai) throws Exception {
Kucun kucun = new Kucun(null, bancai, 0);
bancai
.setKucun(kucunRepository
.save(kucun));
}
/**
* 处理实体关联关系
* @
param entity 要处理的实体
*/
private void handleAssociations(Object entity) throws Exception {
for (Field field
: entity
.getClass()
.getDeclaredFields()) {
field
.setAccessible(true);
Object value = field
.get(entity);
if (value == null) continue;
// 处理 JPA 实体关联
if (value instanceof EntityBasis) {
EntityBasis associated = (EntityBasis) value;
JpaRepository<Object, Serializable> repo =
(JpaRepository<Object, Serializable>) repositoryService
.getJpaRepository(associated
.getClass()
.getSimpleName()
.toLowerCase());
// 只处理已存在实体（不创建新关联）
if (associated
.getId() != null) {
Object managedEntity = repo
.findById(associated
.getId())
.orElseThrow(() -> new RuntimeException("关联实体不存在"));
field
.set(entity, managedEntity);
}
}
// 处理集合关联
else if (value instanceof Collection) {
List<Object> managedEntities = new ArrayList<>();
for (Object item
: (Collection<?>) value) {
if (item instanceof EntityBasis) {
EntityBasis eb = (EntityBasis) item;
JpaRepository<Object, Serializable> repo =
(JpaRepository<Object, Serializable>) repositoryService
.getJpaRepository(eb
.getClass()
.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
.getClass()
.getDeclaredFields()) {
field
.setAccessible(true);
Object value = field
.get(source);
// 跳过关联字段和ID字段
if (value != null &&
!(value instanceof EntityBasis) &&
!(value instanceof Collection) &&
!field
.getName()
.equals("id")) {
try {
Field targetField = target
.getClass()
.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
.beans
.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("bancai", Bancai
.class);
map
.put("caizi", Caizhi
.class);
map
.put("mupi", Mupi
.class);
map
.put("dingdan", Dingdan
.class);
map
.put("zujian", Zujian
.class);
map
.put("chanpin", Chanpin
.class);
map
.put("dingdan_chanpin", Dingdan_chanpin
.class);
map
.put("dingdan_chanpin_zujian", Dingdan_chanpin_zujian
.class);
map
.put("chanpin_zujian", Chanpin_zujian
.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 getAllData() {
return appService
.getAllData();
}
@GetMapping("/all/{entityType}")
public Information getEntityData(@PathVariable String entityType) {
return appService
.getEntityData(entityType
.toLowerCase());
}
// ====================== CRUD操作 ======================
@PostMapping("/add/{entityType}")
public Information addEntity(
@PathVariable String entityType,
@RequestBody Map<String, Object> requestBody
) {
return handleEntityOperation(entityType, requestBody, "add");
}
@PostMapping("/select/{entityType}")
public Information queryEntity(
@PathVariable String entityType,
@RequestBody Map<String, Object> requestBody
) {
return handleEntityOperation(entityType, requestBody, "select");
}
@PostMapping("/delete/{entityType}")
public Information deleteEntity(
@PathVariable String entityType,
@RequestBody Map<String, Object> requestBody
) {
return handleEntityOperation(entityType, requestBody, "delete");
}
@PostMapping("/update/{entityType}")
public Information updateEntity(
@PathVariable String entityType,
@RequestBody Map<String, Object> requestBody
) {
return handleEntityOperation(entityType, requestBody, "update");
}
// ====================== 核心辅助方法 ======================
private Information handleEntityOperation(
String entityType,
Map<String, Object> requestBody,
String operation
) {
String normalizedType = entityType
.toLowerCase();
Class<?> entityClass = ENTITY_MAP
.get(normalizedType);
if (entityClass == null) {
return Information
.NewFail("不支持的实体类型
: " + entityType);
}
try {
Object entity = objectMapper
.convertValue(requestBody, entityClass);
switch (operation) {
case "add"
:
return appService
.addEntity(entity);
case "select"
:
return appService
.queryEntity(entity);
case "delete"
:
// 确保实体实现了EntityBasis接口
if (entity instanceof 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
.EntityManager;
import
javax
.persistence
.PersistenceContext;
import
javax
.persistence
.metamodel
.*;
import org
.springframework
.stereotype
.Service;
import
java.io
.Serializable;
import
java.util
.*;
import
java.util
.stream
.Collectors;
@Service
public class EntityDependencyService {
@PersistenceContext
private EntityManager entityManager;
private final Map<Class<?>, Set<Attribute<?, ?>>> associationCache = new HashMap<>();
/**
* 检查实体是否被其他实体引用
* @
param entityClass 实体类
* @
param entityId 实体ID
* @return 存在引用返回true
*/
public boolean hasDependencies(Class<?> entityClass, Serializable entityId) {
Metamodel metamodel = entityManager
.getMetamodel();
Set<EntityType<?>> entities = metamodel
.getEntities();
for (EntityType<?> entityType
: entities) {
// 跳过自身（避免自引用检查）
if (entityType
.get
JavaType()
.equals(entityClass)) continue;
Set<Attribute<?, ?>> associations = getAssociationAttributes(entityType);
for (Attribute<?, ?> attr
: associations) {
if (attr
.get
JavaType()
.isAssignableFrom(entityClass)) {
if (isReferenced(entityType, attr, entityId)) {
return true;
}
}
}
}
return false;
}
/**
* 获取实体所有关联属性（带缓存）
*/
private Set<Attribute<?, ?>> getAssociationAttributes(EntityType<?> entityType) {
return associationCache
.computeIfAbsent(entityType
.get
JavaType(), k ->
entityType
.getAttributes()
.stream()
.filter(Attribute
::isAssociation)
.collect(Collectors
.toSet())
);
}
/**
* 检查特定关联是否引用目标实体
*/
private boolean isReferenced(EntityType<?> entityType, Attribute<?, ?> attribute, Serializable targetId) {
String jpql = buildReferenceQuery(entityType, attribute);
Long count = (Long) entityManager
.createQuery(jpql)
.set
Parameter("targetId", targetId)
.getSingleResult();
return count > 0;
}
/**
* 构建引用检查查询
*/
private String buildReferenceQuery(EntityType<?> entityType, Attribute<?, ?> attribute) {
String entityName = entityType
.getName();
String attrName = attribute
.getName();
if (attribute instanceof 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
.ParameterizedType;
import
java.lang.reflect
.Type;
import
java.util
.HashMap;
import
java.util
.Map;
import org
.springframework
.beans
.factory
.annotation
.Autowired;
import org
.springframework
.data
.jpa
.repository
.JpaRepository;
import org
.springframework
.stereotype
.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<?,?> getJpaRepository(String e){
// System
.out
.println("String
:"+e+mapToString(repositoryNameMap));
return repositoryNameMap
.get(e);
}
public JpaRepository<?,?> getJpaRepository(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
.getClass()
.getInterfaces();
for (Class<?> iface
: interfaces) {
// 扫描接口上的泛型信息
Type[] genericInterfaces = iface
.getGenericInterfaces();
for (Type type
: genericInterfaces) {
if (type instanceof
ParameterizedType) {
ParameterizedType pt = (
ParameterizedType) type;
// 检查原始类型是否是JpaRepository
if (pt
.getRawType()
.equals(JpaRepository
.class)) {
Type[] args = pt
.getActualTypeArguments();
if (args
.length >=
2 && args[0] instanceof Class) {
Class<?> entityClass = (Class<?>) args[0];
repositoryMap
.put(entityClass, repo);
String key = entityClass
.getSimpleName()
.toLowerCase();
repositoryNameMap
.put(key, repo);
// 调试日志
System
.out
.printf("Mapped %s -> %s [key
: %s]%n",
entityClass
.getName(),
repo
.getClass()
.getName(),
key);
}
}
}
}
// 检查接口本身的泛型签名（如果继承的是参数化接口）
Type genericSuper = iface
.getGenericSuperclass();
if (genericSuper instanceof
ParameterizedType) {
ParameterizedType pt = (
ParameterizedType) genericSuper;
if (pt
.getRawType()
.equals(JpaRepository
.class)) {
Type[] args = pt
.getActualTypeArguments();
if (args
.length >=
2 && args[0] instanceof Class) {
Class<?> entityClass = (Class<?>) args[0];
repositoryMap
.put(entityClass, repo);
String key = entityClass
.getSimpleName()
.toLowerCase();
repositoryNameMap
.put(key, repo);
// 调试日志
System
.out
.printf("Mapped %s -> %s [key
: %s]%n",
entityClass
.getName(),
repo
.getClass()
.getName(),
key);
}
}
}
}
});
}
// 通用保存方法
public <T> T saveEntity(T entity) {
JpaRepository<T, ?> repo = (JpaRepository<T, ?>) repositoryMap
.get(entity
.getClass());
if (repo != null) {
return repo
.save(entity);
}
throw new IllegalArgumentException("Repository not found for " + entity
.getClass());
}
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
.CascadeType;
import
javax
.persistence
.Entity;
import
javax
.persistence
.FetchType;
import
javax
.persistence
.GeneratedValue;
import
javax
.persistence
.GenerationType;
import
javax
.persistence
.Id;
import
javax
.persistence
.JoinColumn;
import
javax
.persistence
.ManyToOne;
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
.JsonManagedReference;
import com
.fasterxml
.jackson
.databind
.annotation
.JsonSerialize;
/**
* 板材
* @author Administrator
*
*/
@Entity
@Table(name="bancai")
@JsonSerialize(using = FullEntitySerializer
.class)
public class Bancai implements EntityBasis {
@Id
@GeneratedValue(strategy = GenerationType
.IDENTITY)
private Integer id;
@ManyToOne(cascade = CascadeType
.ALL, fetch = FetchType
.LAZY)
@JoinColumn(name = "caizhi_id") //
private Caizhi caizhi;
@ManyToOne(cascade = CascadeType
.ALL, fetch = FetchType
.LAZY)
@JoinColumn(name = "mupi
1_id")
private Mupi mupi
1;
@ManyToOne(cascade = CascadeType
.ALL, fetch = FetchType
.LAZY)
@JoinColumn(name = "mupi
2_id")
private Mupi mupi
2;
private Double houdu;
@OneToOne(
cascade = CascadeType
.ALL,
orphanRemoval = true, // 添加此配置
fetch = FetchType
.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 getMupi
1() {
return mupi
1;
}
public void setMupi
1(Mupi mupi
1) {
this
.mupi
1 = mupi
1;
}
public Mupi getMupi
2() {
return mupi
2;
}
public void setMupi
2(Mupi mupi
2) {
this
.mupi
2 = mupi
2;
}
public Double getHoudu() {
return houdu;
}
public void setHoudu(Double houdu) {
this
.houdu = houdu;
}
public Bancai(int id, Caizhi caizhi, Mupi mupi
1, Mupi mupi
2, Double houdu) {
super();
this
.id = id;
this
.caizhi = caizhi;
this
.mupi
1 = mupi
1;
this
.mupi
2 = mupi
2;
this
.houdu = houdu;
}
public Bancai() {
super();
}
}
package com
.kucun
.data
.entity;
import
java.util
.List;
import
javax
.persistence
.Entity;
import
javax
.persistence
.Id;
import
javax
.persistence
.OneToMany;
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{
@OneToMany(mappedBy="caizhi")
private List<Bancai> bancais;
public Caizhi() {
super();
}
// 添加反向关联维护方法
public void addBancai(Bancai bancai) {
bancais
.add(bancai);
bancai
.setCaizhi(this);
}
// 添加移除方法
public void removeBancai(Bancai bancai) {
bancais
.remove(bancai);
bancai
.setCaizhi(null);
}
public List<Bancai> getBancais() {
return bancais;
}
public void setBancais(List<Bancai> bancais) {
this
.bancais = bancais;
}
}
package com
.kucun
.data
.entity;
import
java.util
.List;
import
javax
.persistence
.Column;
import
javax
.persistence
.Entity;
import
javax
.persistence
.Id;
import
javax
.persistence
.ManyToMany;
import
javax
.persistence
.OneToMany;
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
.BooleanType")
private Boolean you;
// 添加 OneToMany 映射
@OneToMany(mappedBy = "mupi
1") // 指向 Bancai 中的 mupi
1 字段
private List<Bancai> bancaisForMupi
1;
@OneToMany(mappedBy = "mupi
2") // 指向 Bancai 中的 mupi
2 字段
private List<Bancai> bancaisForMupi
2;
public List<Bancai> getBancaisForMupi
1() {
return bancaisForMupi
1;
}
public void setBancaisForMupi
1(List<Bancai> bancaisForMupi
1) {
this
.bancaisForMupi
1 = bancaisForMupi
1;
}
public List<Bancai> getBancaisForMupi
2() {
return bancaisForMupi
2;
}
public void setBancaisForMupi
2(List<Bancai> bancaisForMupi
2) {
this
.bancaisForMupi
2 = bancaisForMupi
2;
}
public Mupi() {
super();
}
public Boolean getYou() {
return you;
}
public void setYou(Boolean you) {
this
.you = you;
}
}
20
25-06-
17
13
:50
:08
.559 DEBUG
18340 --- [nio-8080-exec-7] o
.s
.web
.servlet
.DispatcherServlet
: POST "/KuCun
2/app/delete/bancai",
parameters={}
20
25-06-
17
13
:50
:08
.56
1 DEBUG
18340 --- [nio-8080-exec-7] s
.w
.s
.m
.m
.a
.RequestMappingHandlerMapping
: Mapped to com
.kucun
.controller
.AppController#deleteEntity(String, Map)
20
25-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}]
20
25-06-
17
13
:50
:08
.585 DEBUG
18340 --- [nio-8080-exec-7] org
.hibernate
.SQL
: select bancai0_
.id as id
1_0_0_, bancai0_
.caizhi_id as caizhi_i3_0_0_, bancai0_
.houdu as houdu
2_0_0_, bancai0_
.kucun_id as kucun_id4_0_0_, bancai0_
.mupi
1_id as mupi5_0_0_, bancai0_
.mupi
2_id as mupi6_0_0_ from bancai bancai0_ where bancai0_
.id=?
Hibernate
: select bancai0_
.id as id
1_0_0_, bancai0_
.caizhi_id as caizhi_i3_0_0_, bancai0_
.houdu as houdu
2_0_0_, bancai0_
.kucun_id as kucun_id4_0_0_, bancai0_
.mupi
1_id as mupi5_0_0_, bancai0_
.mupi
2_id as mupi6_0_0_ from bancai bancai0_ where bancai0_
.id=?
20
25-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]
20
25-06-
17
13
:50
:08
.59
1 DEBUG
18340 --- [nio-8080-exec-7] m
.m
.a
.RequestResponseBodyMethodProcessor
: Writing [com
.kucun
.data
.entity
.Information@3dee33
14]
20
25-06-
17
13
:50
:08
.59
1 DEBUG
18340 --- [nio-8080-exec-7] o
.s
.web
.servlet
.DispatcherServlet
: Completed
200 OK
删除失败：null
本文解决了一个在Struts2.3.15.3版本中使用struts2-json-plugin-2.3.15.3.jar时启动Tomcat出现的问题。原因是该版本的struts2-json-plugin中的JSONResult类缺少DEFAULT_PARAM属性。解决方案包括调整log4j配置或将Struts2升级到2.3.16版本。
扫一扫
990
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
