Skip to content

D
datax-cloud
Commit bd2fcb31 by yuwei
Options

2.0.0项目初始化

parent 205282c2
Showing with 894 additions and 122 deletions
datax-common/datax-common-core/src/main/java/cn/datax/common/config/JacksonConfig.java
package cn.datax.common.config;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
......@@ -23,12 +23,10 @@ import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.Locale;
import java.util.TimeZone;
@Configuration
......@@ -44,27 +42,16 @@ public class JacksonConfig {
.featuresToDisable(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE)
.timeZone(TimeZone.getTimeZone("Asia/Shanghai"))
.build();
objectMapper
.setLocale(Locale.CHINA)
// 通过该方法对mapper对象进行设置，所有序列化的对象都将按改规则进行系列化
// Include.Include.ALWAYS 默认
// Include.NON_DEFAULT 属性为默认值不序列化
// Include.NON_EMPTY 属性为 空（""） 或者为 NULL 都不序列化，则返回的json是没有这个字段的。这样对移动端会更省流量
// Include.NON_NULL 属性为NULL 不序列化
.setSerializationInclusion(JsonInclude.Include.NON_EMPTY)
.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false)
// 忽略未知字段
.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
// 该特性决定parser是否允许JSON字符串包含非引号控制字符（值小于32的ASCII字符，包含制表符和换行符）。 如果该属性关闭，则如果遇到这些字符，则会抛出异常。JSON标准说明书要求所有控制符必须使用引号，因此这是一个非标准的特性
.configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true)
// 忽略不能转移的字符
.configure(JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER, true)
// 单引号处理
.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true)
// 日期格式
.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
// 反序列化时，属性不存在的兼容处理
objectMapper.getDeserializationConfig().withoutFeatures(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
// 反序列化时候遇到不匹配的属性并不抛出异常
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
// 序列化时候遇到空对象不抛出异常
objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
// 反序列化的时候如果是无效子类型,不抛出异常
objectMapper.configure(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE, false);
// 不使用默认的dateTime进行序列化,
objectMapper.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS, false);
SimpleModule simpleModule = new SimpleModule()
.addSerializer(Long.class, ToStringSerializer.instance)
......@@ -83,5 +70,4 @@ public class JacksonConfig {
objectMapper.registerModule(javaTimeModule).registerModule(new ParameterNamesModule());
return objectMapper;
}
}
datax-common/datax-common-redis/src/main/java/cn/datax/common/redis/config/RedisConfig.java
......@@ -2,9 +2,12 @@ package cn.datax.common.redis.config;
import cn.datax.common.redis.service.RedisService;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
......@@ -17,7 +20,7 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
......@@ -30,20 +33,16 @@ import java.time.format.DateTimeFormatter;
public class RedisConfig {
/**
* 实例化 RedisTemplate 对象
* 自定义redis序列化的机制,重新定义一个ObjectMapper.防止和MVC的冲突
*
* @return
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
// 解决查询缓存转换异常的问题
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
// 解决jackson2无法反序列化LocalDateTime的问题
om.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
public RedisSerializer<Object> redisSerializer() {
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//使用JSR310提供的序列化类,里面包含了大量的JDK8时间序列化类
objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
JavaTimeModule javaTimeModule = new JavaTimeModule();
javaTimeModule.addSerializer(LocalDateTime.class,new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
javaTimeModule.addSerializer(LocalDate.class,new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
......@@ -51,14 +50,37 @@ public class RedisConfig {
javaTimeModule.addDeserializer(LocalDateTime.class,new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
javaTimeModule.addDeserializer(LocalDate.class,new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
javaTimeModule.addDeserializer(LocalTime.class,new LocalTimeDeserializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
om.registerModule(javaTimeModule);
jackson2JsonRedisSerializer.setObjectMapper(om);
RedisSerializer stringSerializer = new StringRedisSerializer();
redisTemplate.setKeySerializer(stringSerializer);
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.setHashKeySerializer(stringSerializer);
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
objectMapper.registerModule(javaTimeModule);
//反序列化时候遇到不匹配的属性并不抛出异常
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
//序列化时候遇到空对象不抛出异常
objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
//反序列化的时候如果是无效子类型,不抛出异常
objectMapper.configure(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE, false);
//不使用默认的dateTime进行序列化,
objectMapper.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS, false);
//启用反序列化所需的类型信息,在属性中添加@class
objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
//配置null值的序列化器
GenericJackson2JsonRedisSerializer.registerNullValueSerializer(objectMapper, null);
return new GenericJackson2JsonRedisSerializer(objectMapper);
}
/**
* 实例化 RedisTemplate 对象
*
* @return
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory, RedisSerializer<Object> redisSerializer) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setDefaultSerializer(redisSerializer);
redisTemplate.setConnectionFactory(redisConnectionFactory);
redisTemplate.setDefaultSerializer(redisSerializer);
redisTemplate.setValueSerializer(redisSerializer);
redisTemplate.setHashValueSerializer(redisSerializer);
redisTemplate.setKeySerializer(StringRedisSerializer.UTF_8);
redisTemplate.setHashKeySerializer(StringRedisSerializer.UTF_8);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
......
datax-modules/data-factory-service-parent/data-factory-service/src/main/java/cn/datax/service/data/factory/config/RedisCacheConfig.java
package cn.datax.service.data.factory.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
......@@ -21,15 +10,11 @@ import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import java.lang.reflect.Method;
import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
......@@ -58,40 +43,25 @@ public class RedisCacheConfig extends CachingConfigurerSupport {
}
@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory, RedisSerializer<Object> redisSerializer) {
return new RedisCacheManager(
RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
this.redisCacheConfigurationWithTtl(30),
this.redisCacheConfigurationMap()
this.redisCacheConfigurationWithTtl(30, redisSerializer),
this.redisCacheConfigurationMap(redisSerializer)
);
}
private Map<String, RedisCacheConfiguration> redisCacheConfigurationMap() {
private Map<String, RedisCacheConfiguration> redisCacheConfigurationMap(RedisSerializer<Object> redisSerializer) {
Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
redisCacheConfigurationMap.put("data:factory:sources", redisCacheConfigurationWithTtl(30));
redisCacheConfigurationMap.put("data:factory:sets", redisCacheConfigurationWithTtl(30));
redisCacheConfigurationMap.put("data:factory:sources", redisCacheConfigurationWithTtl(30, redisSerializer));
redisCacheConfigurationMap.put("data:factory:sets", redisCacheConfigurationWithTtl(30, redisSerializer));
return redisCacheConfigurationMap;
}
private RedisCacheConfiguration redisCacheConfigurationWithTtl(Integer minutes) {
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
// 解决jackson2无法反序列化LocalDateTime的问题
om.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
JavaTimeModule javaTimeModule = new JavaTimeModule();
javaTimeModule.addSerializer(LocalDateTime.class,new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
javaTimeModule.addSerializer(LocalDate.class,new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
javaTimeModule.addSerializer(LocalTime.class,new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
javaTimeModule.addDeserializer(LocalDateTime.class,new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
javaTimeModule.addDeserializer(LocalDate.class,new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
javaTimeModule.addDeserializer(LocalTime.class,new LocalTimeDeserializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
om.registerModule(javaTimeModule);
jackson2JsonRedisSerializer.setObjectMapper(om);
private RedisCacheConfiguration redisCacheConfigurationWithTtl(Integer minutes, RedisSerializer<Object> redisSerializer) {
RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer)
RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer)
).entryTtl(Duration.ofMinutes(minutes));
return redisCacheConfiguration;
}
......
datax-modules/data-market-service-parent/data-market-service/src/main/java/cn/datax/service/data/market/config/RedisCacheConfig.java
package cn.datax.service.data.market.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
......@@ -21,15 +10,11 @@ import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import java.lang.reflect.Method;
import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
......@@ -58,40 +43,50 @@ public class RedisCacheConfig extends CachingConfigurerSupport {
}
@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory, RedisSerializer<Object> redisSerializer) {
return new RedisCacheManager(
RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
this.redisCacheConfigurationWithTtl(30),
this.redisCacheConfigurationMap()
this.redisCacheConfigurationWithTtl(30, redisSerializer),
this.redisCacheConfigurationMap(redisSerializer)
);
}
private Map<String, RedisCacheConfiguration> redisCacheConfigurationMap() {
private Map<String, RedisCacheConfiguration> redisCacheConfigurationMap(RedisSerializer<Object> redisSerializer) {
Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
redisCacheConfigurationMap.put("data:market:apis", redisCacheConfigurationWithTtl(30));
redisCacheConfigurationMap.put("data:market:api:masks", redisCacheConfigurationWithTtl(30));
redisCacheConfigurationMap.put("data:market:apis", redisCacheConfigurationWithTtl(30, redisSerializer));
redisCacheConfigurationMap.put("data:market:api:masks", redisCacheConfigurationWithTtl(30, redisSerializer));
return redisCacheConfigurationMap;
}
private RedisCacheConfiguration redisCacheConfigurationWithTtl(Integer minutes) {
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
// 解决jackson2无法反序列化LocalDateTime的问题
om.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
JavaTimeModule javaTimeModule = new JavaTimeModule();
javaTimeModule.addSerializer(LocalDateTime.class,new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
javaTimeModule.addSerializer(LocalDate.class,new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
javaTimeModule.addSerializer(LocalTime.class,new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
javaTimeModule.addDeserializer(LocalDateTime.class,new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
javaTimeModule.addDeserializer(LocalDate.class,new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
javaTimeModule.addDeserializer(LocalTime.class,new LocalTimeDeserializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
om.registerModule(javaTimeModule);
jackson2JsonRedisSerializer.setObjectMapper(om);
private RedisCacheConfiguration redisCacheConfigurationWithTtl(Integer minutes, RedisSerializer<Object> redisSerializer) {
// ObjectMapper objectMapper = new ObjectMapper();
// objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
// //使用JSR310提供的序列化类,里面包含了大量的JDK8时间序列化类
// objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
// JavaTimeModule javaTimeModule = new JavaTimeModule();
// javaTimeModule.addSerializer(LocalDateTime.class,new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
// javaTimeModule.addSerializer(LocalDate.class,new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
// javaTimeModule.addSerializer(LocalTime.class,new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
// javaTimeModule.addDeserializer(LocalDateTime.class,new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
// javaTimeModule.addDeserializer(LocalDate.class,new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
// javaTimeModule.addDeserializer(LocalTime.class,new LocalTimeDeserializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
// objectMapper.registerModule(javaTimeModule);
// //反序列化时候遇到不匹配的属性并不抛出异常
// objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
// //序列化时候遇到空对象不抛出异常
// objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
// //反序列化的时候如果是无效子类型,不抛出异常
// objectMapper.configure(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE, false);
// //不使用默认的dateTime进行序列化,
// objectMapper.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS, false);
// //启用反序列化所需的类型信息,在属性中添加@class
// objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
// //配置null值的序列化器
// GenericJackson2JsonRedisSerializer.registerNullValueSerializer(objectMapper, null);
// GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer(objectMapper);
RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer)
RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer)
).entryTtl(Duration.ofMinutes(minutes));
return redisCacheConfiguration;
}
......
datax-modules/system-service-parent/system-service-api/src/main/java/cn/datax/service/system/api/dto/DictDto.java 0 → 100644
package cn.datax.service.system.api.dto;
import cn.datax.common.validate.ValidationGroups;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import java.io.Serializable;
/**
* <p>
* 字典编码信息表 实体DTO
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@ApiModel(value = "字典编码信息表Model")
@Data
public class DictDto implements Serializable {
private static final long serialVersionUID=1L;
@ApiModelProperty(value = "主键ID")
@NotBlank(message = "主键ID不能为空", groups = {ValidationGroups.Update.class})
private String id;
@ApiModelProperty(value = "字典名称")
@NotBlank(message = "字典名称不能为空", groups = {ValidationGroups.Insert.class, ValidationGroups.Update.class})
private String dictName;
@ApiModelProperty(value = "字典编码")
@NotBlank(message = "字典编码不能为空", groups = {ValidationGroups.Insert.class, ValidationGroups.Update.class})
private String dictCode;
@ApiModelProperty(value = "字典描述")
private String remark;
}
datax-modules/system-service-parent/system-service-api/src/main/java/cn/datax/service/system/api/dto/DictItemDto.java 0 → 100644
package cn.datax.service.system.api.dto;
import cn.datax.common.validate.ValidationGroups;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
/**
* <p>
* 字典项信息表 实体DTO
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@ApiModel(value = "字典项信息表Model")
@Data
public class DictItemDto implements Serializable {
private static final long serialVersionUID=1L;
@ApiModelProperty(value = "主键ID")
@NotBlank(message = "主键ID不能为空", groups = {ValidationGroups.Update.class})
private String id;
@ApiModelProperty(value = "字典ID")
@NotBlank(message = "字典ID不能为空", groups = {ValidationGroups.Insert.class, ValidationGroups.Update.class})
private String dictId;
@ApiModelProperty(value = "字典项文本")
@NotBlank(message = "字典项文本不能为空", groups = {ValidationGroups.Insert.class, ValidationGroups.Update.class})
private String itemText;
@ApiModelProperty(value = "字典项值")
@NotBlank(message = "字典项值不能为空", groups = {ValidationGroups.Insert.class, ValidationGroups.Update.class})
private String itemValue;
@ApiModelProperty(value = "排序")
@NotNull(message = "排序不能为空", groups = {ValidationGroups.Insert.class, ValidationGroups.Update.class})
private Integer itemSort;
@ApiModelProperty(value = "描述")
private String remark;
}
datax-modules/system-service-parent/system-service-api/src/main/java/cn/datax/service/system/api/entity/DictEntity.java 0 → 100644
package cn.datax.service.system.api.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import cn.datax.common.base.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* 字典编码信息表
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@TableName("sys_dict")
public class DictEntity extends BaseEntity {
private static final long serialVersionUID=1L;
/**
* 字典名称
*/
private String dictName;
/**
* 字典编码
*/
private String dictCode;
/**
* 字典描述
*/
private String remark;
}
datax-modules/system-service-parent/system-service-api/src/main/java/cn/datax/service/system/api/entity/DictItemEntity.java 0 → 100644
package cn.datax.service.system.api.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import cn.datax.common.base.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* 字典项信息表
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@TableName("sys_dict_item")
public class DictItemEntity extends BaseEntity {
private static final long serialVersionUID=1L;
/**
* 字典id
*/
private String dictId;
/**
* 字典项文本
*/
private String itemText;
/**
* 字典项值
*/
private String itemValue;
/**
* 排序
*/
private Integer itemSort;
/**
* 描述
*/
private String remark;
}
datax-modules/system-service-parent/system-service-api/src/main/java/cn/datax/service/system/api/query/DictItemQuery.java 0 → 100644
package cn.datax.service.system.api.query;
import cn.datax.common.base.BaseQueryParams;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 字典项信息表 查询实体
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class DictItemQuery extends BaseQueryParams {
private static final long serialVersionUID=1L;
private String itemText;
private String itemValue;
}
datax-modules/system-service-parent/system-service-api/src/main/java/cn/datax/service/system/api/query/DictQuery.java 0 → 100644
package cn.datax.service.system.api.query;
import cn.datax.common.base.BaseQueryParams;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 字典编码信息表 查询实体
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class DictQuery extends BaseQueryParams {
private static final long serialVersionUID=1L;
private String dictName;
private String dictCode;
}
datax-modules/system-service-parent/system-service-api/src/main/java/cn/datax/service/system/api/vo/DictItemVo.java 0 → 100644
package cn.datax.service.system.api.vo;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* <p>
* 字典项信息表 实体VO
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@Data
public class DictItemVo implements Serializable {
private static final long serialVersionUID=1L;
private String id;
private Integer status;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private LocalDateTime createTime;
private String dictId;
private String itemText;
private String itemValue;
private Integer itemSort;
private String remark;
}
datax-modules/system-service-parent/system-service-api/src/main/java/cn/datax/service/system/api/vo/DictVo.java 0 → 100644
package cn.datax.service.system.api.vo;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* <p>
* 字典编码信息表 实体VO
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@Data
public class DictVo implements Serializable {
private static final long serialVersionUID=1L;
private String id;
private Integer status;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private LocalDateTime createTime;
private String dictName;
private String dictCode;
private String remark;
}
datax-modules/system-service-parent/system-service/src/main/java/cn/datax/service/system/controller/DictController.java 0 → 100644
package cn.datax.service.system.controller;
import cn.datax.common.core.JsonPage;
import cn.datax.common.core.R;
import cn.datax.common.validate.ValidationGroups;
import cn.datax.service.system.api.dto.DictDto;
import cn.datax.service.system.api.entity.DictEntity;
import cn.datax.service.system.api.vo.DictVo;
import cn.datax.service.system.api.query.DictQuery;
import cn.datax.service.system.mapstruct.DictMapper;
import cn.datax.service.system.service.DictService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import cn.datax.common.base.BaseController;
import java.util.List;
import java.util.stream.Collectors;
/**
* <p>
* 字典编码信息表 前端控制器
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@Api(tags = {"字典编码信息表"})
@RestController
@RequestMapping("/dicts")
public class DictController extends BaseController {
@Autowired
private DictService dictService;
@Autowired
private DictMapper dictMapper;
/**
* 通过ID查询信息
*
* @param id
* @return
*/
@ApiOperation(value = "获取详细信息", notes = "根据url的id来获取详细信息")
@ApiImplicitParam(name = "id", value = "ID", required = true, dataType = "String", paramType = "path")
@GetMapping("/{id}")
public R getDictById(@PathVariable String id) {
DictEntity dictEntity = dictService.getById(id);
return R.ok().setData(dictMapper.toVO(dictEntity));
}
/**
* 分页查询信息
*
* @param dictQuery
* @return
*/
@ApiOperation(value = "分页查询", notes = "")
@ApiImplicitParams({
@ApiImplicitParam(name = "dictQuery", value = "查询实体dictQuery", required = true, dataTypeClass = DictQuery.class)
})
@GetMapping("/page")
public R getDictPage(DictQuery dictQuery) {
QueryWrapper<DictEntity> queryWrapper = new QueryWrapper<>();
IPage<DictEntity> page = dictService.page(new Page<>(dictQuery.getPageNum(), dictQuery.getPageSize()), queryWrapper);
List<DictVo> collect = page.getRecords().stream().map(dictMapper::toVO).collect(Collectors.toList());
JsonPage<DictVo> jsonPage = new JsonPage<>(page.getCurrent(), page.getSize(), page.getTotal(), collect);
return R.ok().setData(jsonPage);
}
/**
* 添加
* @param dict
* @return
*/
@ApiOperation(value = "添加信息", notes = "根据dict对象添加信息")
@ApiImplicitParam(name = "dict", value = "详细实体dict", required = true, dataType = "DictDto")
@PostMapping()
public R saveDict(@RequestBody @Validated({ValidationGroups.Insert.class}) DictDto dict) {
dictService.saveDict(dict);
return R.ok();
}
/**
* 修改
* @param dict
* @return
*/
@ApiOperation(value = "修改信息", notes = "根据url的id来指定修改对象，并根据传过来的信息来修改详细信息")
@ApiImplicitParams({
@ApiImplicitParam(name = "id", value = "ID", required = true, dataType = "String", paramType = "path"),
@ApiImplicitParam(name = "dict", value = "详细实体dict", required = true, dataType = "DictDto")
})
@PutMapping("/{id}")
public R updateDict(@PathVariable String id, @RequestBody @Validated({ValidationGroups.Update.class}) DictDto dict) {
dictService.updateDict(dict);
return R.ok();
}
/**
* 删除
* @param id
* @return
*/
@ApiOperation(value = "删除", notes = "根据url的id来指定删除对象")
@ApiImplicitParam(name = "id", value = "ID", required = true, dataType = "String", paramType = "path")
@DeleteMapping("/{id}")
public R deleteDictById(@PathVariable String id) {
dictService.deleteDictById(id);
return R.ok();
}
}
datax-modules/system-service-parent/system-service/src/main/java/cn/datax/service/system/controller/DictItemController.java 0 → 100644
package cn.datax.service.system.controller;
import cn.datax.common.core.JsonPage;
import cn.datax.common.core.R;
import cn.datax.common.validate.ValidationGroups;
import cn.datax.service.system.api.dto.DictItemDto;
import cn.datax.service.system.api.entity.DictItemEntity;
import cn.datax.service.system.api.vo.DictItemVo;
import cn.datax.service.system.api.query.DictItemQuery;
import cn.datax.service.system.mapstruct.DictItemMapper;
import cn.datax.service.system.service.DictItemService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import cn.datax.common.base.BaseController;
import java.util.List;
import java.util.stream.Collectors;
/**
* <p>
* 字典项信息表 前端控制器
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@Api(tags = {"字典项信息表"})
@RestController
@RequestMapping("/dict/items")
public class DictItemController extends BaseController {
@Autowired
private DictItemService dictItemService;
@Autowired
private DictItemMapper dictItemMapper;
/**
* 通过ID查询信息
*
* @param id
* @return
*/
@ApiOperation(value = "获取详细信息", notes = "根据url的id来获取详细信息")
@ApiImplicitParam(name = "id", value = "ID", required = true, dataType = "String", paramType = "path")
@GetMapping("/{id}")
public R getDictItemById(@PathVariable String id) {
DictItemEntity dictItemEntity = dictItemService.getById(id);
return R.ok().setData(dictItemMapper.toVO(dictItemEntity));
}
/**
* 分页查询信息
*
* @param dictItemQuery
* @return
*/
@ApiOperation(value = "分页查询", notes = "")
@ApiImplicitParams({
@ApiImplicitParam(name = "dictItemQuery", value = "查询实体dictItemQuery", required = true, dataTypeClass = DictItemQuery.class)
})
@GetMapping("/page")
public R getDictItemPage(DictItemQuery dictItemQuery) {
QueryWrapper<DictItemEntity> queryWrapper = new QueryWrapper<>();
IPage<DictItemEntity> page = dictItemService.page(new Page<>(dictItemQuery.getPageNum(), dictItemQuery.getPageSize()), queryWrapper);
List<DictItemVo> collect = page.getRecords().stream().map(dictItemMapper::toVO).collect(Collectors.toList());
JsonPage<DictItemVo> jsonPage = new JsonPage<>(page.getCurrent(), page.getSize(), page.getTotal(), collect);
return R.ok().setData(jsonPage);
}
/**
* 添加
* @param dictItem
* @return
*/
@ApiOperation(value = "添加信息", notes = "根据dictItem对象添加信息")
@ApiImplicitParam(name = "dictItem", value = "详细实体dictItem", required = true, dataType = "DictItemDto")
@PostMapping()
public R saveDictItem(@RequestBody @Validated({ValidationGroups.Insert.class}) DictItemDto dictItem) {
dictItemService.saveDictItem(dictItem);
return R.ok();
}
/**
* 修改
* @param dictItem
* @return
*/
@ApiOperation(value = "修改信息", notes = "根据url的id来指定修改对象，并根据传过来的信息来修改详细信息")
@ApiImplicitParams({
@ApiImplicitParam(name = "id", value = "ID", required = true, dataType = "String", paramType = "path"),
@ApiImplicitParam(name = "dictItem", value = "详细实体dictItem", required = true, dataType = "DictItemDto")
})
@PutMapping("/{id}")
public R updateDictItem(@PathVariable String id, @RequestBody @Validated({ValidationGroups.Update.class}) DictItemDto dictItem) {
dictItemService.updateDictItem(dictItem);
return R.ok();
}
/**
* 删除
* @param id
* @return
*/
@ApiOperation(value = "删除", notes = "根据url的id来指定删除对象")
@ApiImplicitParam(name = "id", value = "ID", required = true, dataType = "String", paramType = "path")
@DeleteMapping("/{id}")
public R deleteDictItemById(@PathVariable String id) {
dictItemService.deleteDictItemById(id);
return R.ok();
}
}
datax-modules/system-service-parent/system-service/src/main/java/cn/datax/service/system/dao/DictDao.java 0 → 100644
package cn.datax.service.system.dao;
import cn.datax.common.base.BaseDao;
import cn.datax.service.system.api.entity.DictEntity;
import org.apache.ibatis.annotations.Mapper;
/**
* <p>
* 字典编码信息表 Mapper 接口
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@Mapper
public interface DictDao extends BaseDao<DictEntity> {
}
datax-modules/system-service-parent/system-service/src/main/java/cn/datax/service/system/dao/DictItemDao.java 0 → 100644
package cn.datax.service.system.dao;
import cn.datax.common.base.BaseDao;
import cn.datax.service.system.api.entity.DictItemEntity;
import org.apache.ibatis.annotations.Mapper;
/**
* <p>
* 字典项信息表 Mapper 接口
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@Mapper
public interface DictItemDao extends BaseDao<DictItemEntity> {
}
datax-modules/system-service-parent/system-service/src/main/java/cn/datax/service/system/mapstruct/DictItemMapper.java 0 → 100644
package cn.datax.service.system.mapstruct;
import cn.datax.common.mapstruct.EntityMapper;
import cn.datax.service.system.api.dto.DictItemDto;
import cn.datax.service.system.api.entity.DictItemEntity;
import cn.datax.service.system.api.vo.DictItemVo;
import org.mapstruct.Mapper;
/**
* <p>
* 字典项信息表 Mapper 实体映射
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@Mapper(componentModel = "spring")
public interface DictItemMapper extends EntityMapper<DictItemDto, DictItemEntity, DictItemVo> {
}
datax-modules/system-service-parent/system-service/src/main/java/cn/datax/service/system/mapstruct/DictMapper.java 0 → 100644
package cn.datax.service.system.mapstruct;
import cn.datax.common.mapstruct.EntityMapper;
import cn.datax.service.system.api.dto.DictDto;
import cn.datax.service.system.api.entity.DictEntity;
import cn.datax.service.system.api.vo.DictVo;
import org.mapstruct.Mapper;
/**
* <p>
* 字典编码信息表 Mapper 实体映射
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@Mapper(componentModel = "spring")
public interface DictMapper extends EntityMapper<DictDto, DictEntity, DictVo> {
}
datax-modules/system-service-parent/system-service/src/main/java/cn/datax/service/system/service/DictItemService.java 0 → 100644
package cn.datax.service.system.service;
import cn.datax.service.system.api.entity.DictItemEntity;
import cn.datax.service.system.api.dto.DictItemDto;
import cn.datax.common.base.BaseService;
/**
* <p>
* 字典项信息表 服务类
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
public interface DictItemService extends BaseService<DictItemEntity> {
void saveDictItem(DictItemDto dictItem);
void updateDictItem(DictItemDto dictItem);
void deleteDictItemById(String id);
}
datax-modules/system-service-parent/system-service/src/main/java/cn/datax/service/system/service/DictService.java 0 → 100644
package cn.datax.service.system.service;
import cn.datax.service.system.api.entity.DictEntity;
import cn.datax.service.system.api.dto.DictDto;
import cn.datax.common.base.BaseService;
/**
* <p>
* 字典编码信息表 服务类
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
public interface DictService extends BaseService<DictEntity> {
void saveDict(DictDto dict);
void updateDict(DictDto dict);
void deleteDictById(String id);
}
datax-modules/system-service-parent/system-service/src/main/java/cn/datax/service/system/service/impl/DictItemServiceImpl.java 0 → 100644
package cn.datax.service.system.service.impl;
import cn.datax.service.system.api.entity.DictItemEntity;
import cn.datax.service.system.api.dto.DictItemDto;
import cn.datax.service.system.service.DictItemService;
import cn.datax.service.system.mapstruct.DictItemMapper;
import cn.datax.service.system.dao.DictItemDao;
import cn.datax.common.base.BaseServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
/**
* <p>
* 字典项信息表 服务实现类
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class DictItemServiceImpl extends BaseServiceImpl<DictItemDao, DictItemEntity> implements DictItemService {
@Autowired
private DictItemDao dictItemDao;
@Autowired
private DictItemMapper dictItemMapper;
@Override
@Transactional(rollbackFor = Exception.class)
public void saveDictItem(DictItemDto dictItemDto) {
DictItemEntity dictItem = dictItemMapper.toEntity(dictItemDto);
dictItemDao.insert(dictItem);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void updateDictItem(DictItemDto dictItemDto) {
DictItemEntity dictItem = dictItemMapper.toEntity(dictItemDto);
dictItemDao.updateById(dictItem);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void deleteDictItemById(String id) {
dictItemDao.deleteById(id);
}
}
datax-modules/system-service-parent/system-service/src/main/java/cn/datax/service/system/service/impl/DictServiceImpl.java 0 → 100644
package cn.datax.service.system.service.impl;
import cn.datax.service.system.api.entity.DictEntity;
import cn.datax.service.system.api.dto.DictDto;
import cn.datax.service.system.service.DictService;
import cn.datax.service.system.mapstruct.DictMapper;
import cn.datax.service.system.dao.DictDao;
import cn.datax.common.base.BaseServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
/**
* <p>
* 字典编码信息表 服务实现类
* </p>
*
* @author yuwei
* @since 2020-04-17
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class DictServiceImpl extends BaseServiceImpl<DictDao, DictEntity> implements DictService {
@Autowired
private DictDao dictDao;
@Autowired
private DictMapper dictMapper;
@Override
@Transactional(rollbackFor = Exception.class)
public void saveDict(DictDto dictDto) {
DictEntity dict = dictMapper.toEntity(dictDto);
dictDao.insert(dict);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void updateDict(DictDto dictDto) {
DictEntity dict = dictMapper.toEntity(dictDto);
dictDao.updateById(dict);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void deleteDictById(String id) {
dictDao.deleteById(id);
}
}
datax-modules/system-service-parent/system-service/src/main/resources/mapper/DictItemMapper.xml 0 → 100644
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.datax.service.system.dao.DictItemDao">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="cn.datax.service.system.api.entity.DictItemEntity">
<result column="id" property="id" />
<result column="status" property="status" />
<result column="create_by" property="createBy" />
<result column="create_time" property="createTime" />
<result column="update_by" property="updateBy" />
<result column="update_time" property="updateTime" />
<result column="dict_id" property="dictId" />
<result column="item_text" property="itemText" />
<result column="item_value" property="itemValue" />
<result column="item_sort" property="itemSort" />
<result column="remark" property="remark" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
id,
status,
create_by,
create_time,
update_by,
update_time,
dict_id, item_text, item_value, item_sort, remark
</sql>
</mapper>
datax-modules/system-service-parent/system-service/src/main/resources/mapper/DictMapper.xml 0 → 100644
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.datax.service.system.dao.DictDao">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="cn.datax.service.system.api.entity.DictEntity">
<result column="id" property="id" />
<result column="status" property="status" />
<result column="create_by" property="createBy" />
<result column="create_time" property="createTime" />
<result column="update_by" property="updateBy" />
<result column="update_time" property="updateTime" />
<result column="dict_name" property="dictName" />
<result column="dict_code" property="dictCode" />
<result column="remark" property="remark" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
id,
status,
create_by,
create_time,
update_by,
update_time,
dict_name, dict_code, remark
</sql>
</mapper>
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment