Skip to content

S
SanyCoating
Commit 26e1aaff by daixiaohong
Options

["暂无"]:重庆三一重工代码提交

parents
正在显示 包含 4805 行增加 和 0 行删除
common/pom.xml 0 → 100644
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>iotmqtt</artifactId>
<groupId>org.jln.IOTmqtt</groupId>
<version>1.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>common</artifactId>
<dependencies>
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>${jwt-auth0.version}</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>${mybatis-plus.version}</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>${mybatis-plus.version}</version>
</dependency>
<!--httpClient请求工具-->
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.6</version>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpmime</artifactId>
<version>4.5.6</version>
</dependency>
<dependency>
<groupId>commons-httpclient</groupId>
<artifactId>commons-httpclient</artifactId>
<version>${commons-httpclient.version}</version>
</dependency>
<!-- swagger -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.5.0</version>
</dependency>
<!-- swagger-ui -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>${springfox-swagger2.version}</version>
</dependency>
<!-- 跨域依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>ma.glasnost.orika</groupId>
<artifactId>orika-core</artifactId>
<version>${orika-core.version}</version>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>${commons-codec.version}</version>
</dependency>
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>${commons-beanutils.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!---->
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-core</artifactId>
<version>8.5.15</version>
</dependency>
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.49.Final</version>
</dependency>
</dependencies>
</project>
\ No newline at end of file
common/src/main/java/com/jln/common/RedisUtil/RedisConfig.java 0 → 100644
package com.jln.common.RedisUtil;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.jln.common.config.StringRedisSerializer;
import com.jln.common.constant.LocalDateTimeConst;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.RedisSerializer;
import java.text.SimpleDateFormat;
/**
* @ClassName: redis配置信息
* @Description:
* @Author:三刀 Date:2020/9/16 15:39
* Version:1.0
**/
@Configuration
public class RedisConfig {
@Autowired
private RedisConnectionFactory factory;
@Bean
public RedisTemplate<String, Object> redisTemplate() {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setKeySerializer(keySerializer());
redisTemplate.setHashKeySerializer(keySerializer());
redisTemplate.setHashValueSerializer(valueSerializer());
redisTemplate.setValueSerializer(valueSerializer());
redisTemplate.setConnectionFactory(factory);
return redisTemplate;
}
@Bean
public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForHash();
}
@Bean
public ValueOperations<String, String> valueOperations(RedisTemplate<String, String> redisTemplate) {
return redisTemplate.opsForValue();
}
@Bean
public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForList();
}
@Bean
public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForSet();
}
@Bean
public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForZSet();
}
public Jackson2JsonRedisSerializer valueSerializer() {
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
// 只针对非空的值进行序列化
objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
// 将类型序列化到属性json字符串中
//objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
//objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
// 设置日期序列化方式
SimpleDateFormat dateFormat = new SimpleDateFormat(LocalDateTimeConst.DATE_TIME_PATTERN);
objectMapper.setDateFormat(dateFormat);
// 对于找不到匹配属性的时候忽略报错
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
// 不包含任何属性的bean也不报错
objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
// 去掉各种@JsonSerialize注解的解析
objectMapper.configure(MapperFeature.USE_ANNOTATIONS, false);
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
return jackson2JsonRedisSerializer;
}
/**
* 普通的 string 序列化方式 ,用来序列化 key
* key 之不用json 序列化方式,是因为虽然json也可以序列化普通字符串 但是会加上 ""
*/
public RedisSerializer keySerializer() {
StringRedisSerializer redisSerializer = new StringRedisSerializer();
return redisSerializer;
}
}
common/src/main/java/com/jln/common/annotation/DateTime.java 0 → 100644
package com.jln.common.annotation;
import com.jln.common.constant.LocalDateTimeConst;
import javax.validation.Payload;
/**
* @author 86180
* @version : DateTime, v 0.1 2020/2/15 10:59
*/
public @interface DateTime {
String message() default "时间格式错误，时间格式yyyy-MM-dd HH:mm:ss";
String format() default LocalDateTimeConst.DATE_TIME_PATTERN;
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
common/src/main/java/com/jln/common/annotation/IgnoreUserLoginToken.java 0 → 100644
package com.jln.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author 86180
* @version : IgnoreUserLoginToken, v 0.1 2020/1/16 10:53
*/
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface IgnoreUserLoginToken {
}
common/src/main/java/com/jln/common/annotation/LoginUser.java 0 → 100644
package com.jln.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginUser {
}
common/src/main/java/com/jln/common/annotation/PermissionAop.java 0 → 100644
package com.jln.common.annotation;
import java.lang.annotation.*;
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PermissionAop {
}
common/src/main/java/com/jln/common/annotation/UserLoginToken.java 0 → 100644
package com.jln.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author 86180
* @version : UserLoginToken, v 0.1 2020/1/15 9:47
*/
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface UserLoginToken {
boolean required() default true;
}
common/src/main/java/com/jln/common/annotation/ValidationRules.java 0 → 100644
package com.jln.common.annotation;
import java.lang.annotation.*;
/**
* 参数规则配置注解类
* @author asus
*/
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ValidationRules {
/**
* 定义参数规则编码
* @return
*/
String value() default "";
}
common/src/main/java/com/jln/common/annotation/ValidationRulesRepetition.java 0 → 100644
package com.jln.common.annotation;
import java.lang.annotation.*;
/**
* 参数规则配置注解类
* @author asus
*/
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ValidationRulesRepetition {
/**
* 定义参数规则编码
* @return
*/
String value() default "";
/**
* 批量规则编码接口
* @return
*/
boolean isList() default false;
/**
* 主键在类中的位置
* @return
*/
int idIndex() default -1;
/**
* 是否父类
* @return
*/
boolean isSuperclass() default false;
}
common/src/main/java/com/jln/common/config/ApplicationContextUtil.java 0 → 100644
package com.jln.common.config;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class ApplicationContextUtil implements ApplicationContextAware {
private static ApplicationContext applicationContext;
/**
* 服务器启动，Spring容器初始化时，当加载了当前类为bean组件后，
* 将会调用下面方法注入ApplicationContext实例
*/
@Override
public void setApplicationContext(ApplicationContext arg0) throws BeansException {
log.info("初始化了");
ApplicationContextUtil.applicationContext = arg0;
}
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
/**
* 外部调用这个getBean方法就可以手动获取到bean
* 用bean组件的name来获取bean
*
* @param beanName
* @return
*/
@SuppressWarnings("unchecked")
public static <T> T getBean(String beanName) {
return (T) applicationContext.getBean(beanName);
}
}
common/src/main/java/com/jln/common/config/CommonConfig.java 0 → 100644
package com.jln.common.config;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.io.File;
/**
* @author 86180
* @version : CommonConfig, v 0.1 2020/1/15 9:57
*/
@Configuration
public class CommonConfig implements WebMvcConfigurer {
private static final boolean isWindows = System.getProperty("os.name").toLowerCase().contains("win");
private static final Logger log = LoggerFactory.getLogger(CommonConfig.class);
/* @Autowired
private AuthenticationInterceptor authenticationInterceptor;*/
/* @Autowired
private LoginUserHandlerMethodArgumentResolver loginUserHandlerMethodArgumentResolver;
*/
@Value("${server.servlet.context-path}")
public String contextPath;
/* public void addInterceptors(InterceptorRegistry registry) {
log.info("加载token验证配置类");
registry.addInterceptor(authenticationInterceptor)
.addPathPatterns("/**")
.excludePathPatterns("/static/wf/**");//排除的静态资源
}*/
/* @Override
public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
log.info("加载用户数据");
argumentResolvers.add(loginUserHandlerMethodArgumentResolver);
}*/
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
log.info("加载swagger");
registry.addResourceHandler("swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
registry.addResourceHandler("/file/**").addResourceLocations("classpath:/file/");
registry.addResourceHandler("/static/**").addResourceLocations("classpath:/static/");
if(isWindows){
registry.addResourceHandler("/file/**").addResourceLocations("classpath:/file/");
}else{
File f = new File(this.getClass().getResource("").getPath());
String path=f.toString();
log.error("path:"+path);
path=path.substring(0,path.lastIndexOf("."));
path=path.substring(0,path.lastIndexOf("/"));
path=path.substring(0,path.lastIndexOf("."));
path=path.substring(0,path.lastIndexOf("/"));
String judge="target";
// int index = path.indexOf("target");
// path=path.substring(0,index+judge.length());
log.error("测试放行图片路径："+path);
registry.addResourceHandler("/file/**").addResourceLocations(path+"/file/");
}
}
//处理跨域
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedHeaders("*")
.allowedMethods("*")
.maxAge(3600)
.allowedOrigins("*")
.allowCredentials(true);
}
}
common/src/main/java/com/jln/common/config/DateConfig.java 0 → 100644
package com.jln.common.config;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.*;
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 com.jln.common.constant.LocalDateTimeConst;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.convert.converter.Converter;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
/**
* @author 86180
* @version : LocalDateTimeSerializerConfig, v 0.1 2020/2/24 17:43
*/
@Configuration
public class DateConfig {
/**
* LocalDate转换器，用于转换RequestParam和PathVariable参数
*/
@Bean
public Converter<String, LocalDate> localDateConverter() {
return new Converter<String, LocalDate>() {
@Override
public LocalDate convert(String source) {
return LocalDate.parse(source, DateTimeFormatter.ofPattern(LocalDateTimeConst.DATE_PATTERN));
}
};
}
/**
* LocalDateTime转换器，用于转换RequestParam和PathVariable参数
*/
@Bean
public Converter<String, LocalDateTime> localDateTimeConverter() {
return new Converter<String, LocalDateTime>() {
@Override
public LocalDateTime convert(String source) {
return LocalDateTime.parse(source, DateTimeFormatter.ofPattern(LocalDateTimeConst.DATE_TIME_PATTERN));
}
};
}
/**
* LocalTime转换器，用于转换RequestParam和PathVariable参数
*/
@Bean
public Converter<String, LocalTime> localTimeConverter() {
return new Converter<String, LocalTime>() {
@Override
public LocalTime convert(String source) {
return LocalTime.parse(source, DateTimeFormatter.ofPattern(LocalDateTimeConst.DEFAULT_TIME_FORMAT));
}
};
}
/**
* Date转换器，用于转换RequestParam和PathVariable参数
*/
@Bean
public Converter<String, Date> dateConverter() {
return new Converter<String, Date>() {
@Override
public Date convert(String source) {
SimpleDateFormat format = new SimpleDateFormat(LocalDateTimeConst.DATE_TIME_PATTERN);
try {
return format.parse(source);
} catch (ParseException e) {
throw new RuntimeException(e);
}
}
};
}
/**
* Json序列化和反序列化转换器，用于转换Post请求体中的json以及将我们的对象序列化为返回响应的json
*/
@Bean
public ObjectMapper objectMapper(){
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
objectMapper.disable(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE);
//LocalDateTime系列序列化和反序列化模块，继承自jsr310，我们在这里修改了日期格式
JavaTimeModule javaTimeModule = new JavaTimeModule();
javaTimeModule.addSerializer(LocalDateTime.class,new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(LocalDateTimeConst.DATE_TIME_PATTERN)));
javaTimeModule.addSerializer(LocalDate.class,new LocalDateSerializer(DateTimeFormatter.ofPattern(LocalDateTimeConst.DATE_PATTERN)));
javaTimeModule.addSerializer(LocalTime.class,new LocalTimeSerializer(DateTimeFormatter.ofPattern(LocalDateTimeConst.DEFAULT_TIME_FORMAT)));
javaTimeModule.addDeserializer(LocalDateTime.class,new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(LocalDateTimeConst.DATE_TIME_PATTERN)));
javaTimeModule.addDeserializer(LocalDate.class,new LocalDateDeserializer(DateTimeFormatter.ofPattern(LocalDateTimeConst.DATE_PATTERN)));
javaTimeModule.addDeserializer(LocalTime.class,new LocalTimeDeserializer(DateTimeFormatter.ofPattern(LocalDateTimeConst.DEFAULT_TIME_FORMAT)));
//Date序列化和反序列化
javaTimeModule.addSerializer(Date.class, new JsonSerializer<Date>() {
@Override
public void serialize(Date date, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
SimpleDateFormat formatter = new SimpleDateFormat(LocalDateTimeConst.DATE_TIME_PATTERN);
String formattedDate = formatter.format(date);
jsonGenerator.writeString(formattedDate);
}
});
javaTimeModule.addDeserializer(Date.class, new JsonDeserializer<Date>() {
@Override
public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
SimpleDateFormat format = new SimpleDateFormat(LocalDateTimeConst.DATE_TIME_PATTERN);
String date = jsonParser.getText();
try {
return format.parse(date);
} catch (ParseException e) {
throw new RuntimeException(e);
}
}
});
objectMapper.registerModule(javaTimeModule);
return objectMapper;
}
}
\ No newline at end of file
common/src/main/java/com/jln/common/config/GlobalConfig.java 0 → 100644
package com.jln.common.config;
import ma.glasnost.orika.MapperFacade;
import ma.glasnost.orika.MapperFactory;
import ma.glasnost.orika.MappingContext;
import ma.glasnost.orika.converter.BidirectionalConverter;
import ma.glasnost.orika.metadata.Type;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.PostConstruct;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.List;
/**
* @author 86180
* @version : GlobalConfig, v 0.1 2020/1/15 11:33
*/
@Configuration
public class GlobalConfig {
@Bean
public MapperFactoryBean loadFactory(){
return new MapperFactoryBean();
}
@Bean
public MapperFacade loadMapperFacade(MapperFactory factory){
return factory.getMapperFacade();
}
@Autowired
private MapperFactory mapperFactory;
/**
* 解决orika映射LocalDateTime报错问题
*/
@PostConstruct
public void init() {
mapperFactory.getConverterFactory().registerConverter(new LocalDateTimeConverter());
mapperFactory.getConverterFactory().registerConverter(new LocalDateConverter());
mapperFactory.getConverterFactory().registerConverter(new LocalTimeConverter());
}
private class LocalDateTimeConverter extends BidirectionalConverter<LocalDateTime, LocalDateTime> {
@Override
public LocalDateTime convertTo(LocalDateTime source, Type<LocalDateTime> type, MappingContext mappingContext) {
return LocalDateTime.from(source);
}
@Override
public LocalDateTime convertFrom(LocalDateTime source, Type<LocalDateTime> type, MappingContext mappingContext) {
return LocalDateTime.from(source);
}
}
private class LocalDateConverter extends BidirectionalConverter<LocalDate, LocalDate> {
@Override
public LocalDate convertTo(LocalDate source, Type<LocalDate> type, MappingContext mappingContext) {
return LocalDate.from(source);
}
@Override
public LocalDate convertFrom(LocalDate source, Type<LocalDate> type, MappingContext mappingContext) {
return LocalDate.from(source);
}
}
private class LocalTimeConverter extends BidirectionalConverter<LocalTime, LocalTime> {
@Override
public LocalTime convertTo(LocalTime source, Type<LocalTime> type, MappingContext mappingContext) {
return LocalTime.from(source);
}
@Override
public LocalTime convertFrom(LocalTime source, Type<LocalTime> type, MappingContext mappingContext) {
return LocalTime.from(source);
}
}
}
common/src/main/java/com/jln/common/config/JacksonHttpMessageConverter.java 0 → 100644
package com.jln.common.config;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializationConfig;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.BeanPropertyWriter;
import com.fasterxml.jackson.databind.ser.BeanSerializerModifier;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
/**
* @author 86180
* @version : JacksonHttpMessageConverter, v 0.1 2020/3/3 11:24
*/
public class JacksonHttpMessageConverter extends MappingJackson2HttpMessageConverter {
/**
* 处理数组类型的null值
*/
public class NullArrayJsonSerializer extends JsonSerializer<Object> {
@Override
public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
if (value == null) {
jgen.writeStartArray();
jgen.writeEndArray();
}
}
}
/**
* 处理字符串类型的null值
*/
public class NullStringJsonSerializer extends JsonSerializer<Object> {
@Override
public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException, JsonProcessingException {
jsonGenerator.writeString(StringUtils.EMPTY);
}
}
/**
* 处理数字类型的null值
*/
public class NullNumberJsonSerializer extends JsonSerializer<Object> {
@Override
public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException, JsonProcessingException {
jsonGenerator.writeNumber(0);
}
}
/**
* 处理布尔类型的null值
*/
public class NullBooleanJsonSerializer extends JsonSerializer<Object> {
@Override
public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException, JsonProcessingException {
jsonGenerator.writeBoolean(false);
}
}
public class MyBeanSerializerModifier extends BeanSerializerModifier {
@Override
public List<BeanPropertyWriter> changeProperties(SerializationConfig config, BeanDescription beanDesc, List<BeanPropertyWriter> beanProperties) {
//循环所有的beanPropertyWriter
for (Object beanProperty : beanProperties) {
BeanPropertyWriter writer = (BeanPropertyWriter) beanProperty;
//判断字段的类型，如果是array，list，set则注册nullSerializer
if (isArrayType(writer)) {
//给writer注册一个自己的nullSerializer
writer.assignNullSerializer(new NullArrayJsonSerializer());
} else if (isNumberType(writer)) {
writer.assignNullSerializer(new NullNumberJsonSerializer());
} else if (isBooleanType(writer)) {
writer.assignNullSerializer(new NullBooleanJsonSerializer());
} else if (isStringType(writer)) {
writer.assignNullSerializer(new NullStringJsonSerializer());
}
}
return beanProperties;
}
/**
* 是否是数组
*/
private boolean isArrayType(BeanPropertyWriter writer) {
Class<?> clazz = writer.getType().getRawClass();
return clazz.isArray() || Collection.class.isAssignableFrom(clazz);
}
/**
* 是否是string
*/
private boolean isStringType(BeanPropertyWriter writer) {
Class<?> clazz = writer.getType().getRawClass();
return CharSequence.class.isAssignableFrom(clazz) || Character.class.isAssignableFrom(clazz);
}
/**
* 是否是int
*/
private boolean isNumberType(BeanPropertyWriter writer) {
Class<?> clazz = writer.getType().getRawClass();
return Number.class.isAssignableFrom(clazz);
}
/**
* 是否是boolean
*/
private boolean isBooleanType(BeanPropertyWriter writer) {
Class<?> clazz = writer.getType().getRawClass();
return clazz.equals(Boolean.class);
}
}
JacksonHttpMessageConverter() {
getObjectMapper().setSerializerFactory(getObjectMapper().getSerializerFactory().withSerializerModifier(new MyBeanSerializerModifier()));
}
}
common/src/main/java/com/jln/common/config/JsonConfig.java 0 → 100644
package com.jln.common.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import java.io.File;
import java.util.List;
/**
* @author 86180
* @version : JsonConfig, v 0.1 2020/3/3 11:27
*/
public class JsonConfig extends WebMvcConfigurationSupport {
private static final boolean isWindows = System.getProperty("os.name").toLowerCase().contains("win");
@Override
protected void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
super.configureMessageConverters(converters);
converters.add(new JacksonHttpMessageConverter());
}
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
registry.addResourceHandler("/file/**").addResourceLocations("classpath:/file/");
if(isWindows){
registry.addResourceHandler("/file/**").addResourceLocations("classpath:/file/");
}else{
File f = new File(this.getClass().getResource("").getPath());
String path=f.toString();
path=path.substring(0,path.lastIndexOf("."));
path=path.substring(0,path.lastIndexOf("/"));
path=path.substring(0,path.lastIndexOf("."));
path=path.substring(0,path.lastIndexOf("/"));
String judge="target";
// int index = path.indexOf("target");
// path=path.substring(0,index+judge.length());
registry.addResourceHandler("/file/**").addResourceLocations(path+"/file/");
}
}
}
common/src/main/java/com/jln/common/config/MapperFactoryBean.java 0 → 100644
package com.jln.common.config;
import ma.glasnost.orika.CustomConverter;
import ma.glasnost.orika.Mapper;
import ma.glasnost.orika.MapperFactory;
import ma.glasnost.orika.impl.DefaultMapperFactory;
import ma.glasnost.orika.metadata.ClassMapBuilder;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
/**
* @author 86180
* @version : MapperFactoryBean, v 0.1 2020/2/19 13:18
*/
public class MapperFactoryBean implements FactoryBean<MapperFactory>, ApplicationContextAware {
ApplicationContext applicationContext;
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public MapperFactory getObject() throws Exception {
DefaultMapperFactory build = new DefaultMapperFactory.Builder().build();
for (CustomConverter converter : applicationContext.getBeansOfType(CustomConverter.class).values()) {
build.getConverterFactory().registerConverter(converter);
}
for (Mapper<?, ?> mapper : applicationContext.getBeansOfType(Mapper.class).values()) {
build.registerMapper(mapper);
}
for (ClassMapBuilder<?, ?> mapper : applicationContext.getBeansOfType(ClassMapBuilder.class).values()) {
build.registerClassMap(mapper);
}
return build;
}
@Override
public Class<?> getObjectType() {
return MapperFactory.class;
}
@Override
public boolean isSingleton() {
return true;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
}
\ No newline at end of file
common/src/main/java/com/jln/common/config/StringRedisSerializer.java 0 → 100644
package com.jln.common.config;
import com.alibaba.fastjson.JSON;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.util.Assert;
import java.nio.charset.Charset;
/**
* @ClassName:
* @Description:
* @Author:三刀 Date:2020/9/25 15:32
* Version:1.0
**/
public class StringRedisSerializer implements RedisSerializer<Object> {
private final Charset charset;
private final String target = "\"";
private final String replacement = "";
public StringRedisSerializer() {
this(Charset.forName("UTF8"));
}
public StringRedisSerializer(Charset charset) {
Assert.notNull(charset, "Charset must not be null!");
this.charset = charset;
}
@Override
public String deserialize(byte[] bytes) {
return (bytes == null ? null : new String(bytes, charset));
}
@Override
public byte[] serialize(Object object) {
String string = JSON.toJSONString(object);
if (string == null) {
return null;
}
string = string.replace(target, replacement);
return string.getBytes(charset);
}
}
common/src/main/java/com/jln/common/config/WebDataConvertConfig.java 0 → 100644
package com.jln.common.config;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.util.List;
/**
* @ClassName: 解决long精度丢失问题
* @Description:
* @Author:三刀 Date:2020/9/23 13:50
* Version:1.0
**/
@EnableWebMvc
@Configuration
public class WebDataConvertConfig implements WebMvcConfigurer {
@Autowired
private ObjectMapper objectMapper;
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
MappingJackson2HttpMessageConverter jackson2HttpMessageConverter = new MappingJackson2HttpMessageConverter();
/**
* 序列换成json时,将所有的long变成string
* 因为js中得数字类型不能包含所有的java long值
*/
SimpleModule simpleModule = new SimpleModule();
simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
simpleModule.addSerializer(Long.TYPE, ToStringSerializer.instance);
objectMapper.registerModule(simpleModule);
jackson2HttpMessageConverter.setObjectMapper(objectMapper);
converters.add(jackson2HttpMessageConverter);
}
}
\ No newline at end of file
common/src/main/java/com/jln/common/constant/ApiConst.java 0 → 100644
package com.jln.common.constant;
/**
* @ClassName: 静态变量维护
* @Description:
* @Author:三刀 Date:2020/1/9 14:24
* Version:1.0
**/
public class ApiConst {
//中间件API地址
// private static final String HEAD="http://115.29.202.246:8089/api";
// private static final String HEAD="http://172.16.12.11:8089/api";
private static final String HEAD = "http://127.0.0.1:8089/api";
/**
* Token 的名称
*/
public static final String TOKEN_NAME = "api_key";
/**
* Token 内容的前缀
*/
public static final String TOKEN_VAL = "";
//获取token接口
public static final String GET_TOKEN = HEAD + "/identity/getToken";
/**
* 注册标识
*/
public static final String IDENTITY_INSERT = HEAD + "/identity/save";
/**
* 注册批量标识
*/
public static final String IDENTITY_INSERT_BATCH = HEAD + "/identity/saveBatch";
/**
* 标识修改
*/
public static final String IDENTITY_UPDATE = HEAD + "/identity/update";
/**
* 标识批量更新
*/
public static final String IDENTITY_UPDATE_BATCH = HEAD + "/identity/updateBatch";
/**
* 标识删除
*/
public static final String IDENTITY_DELETE = HEAD + "/identity/delete";
/**
* 保存数据模板
*/
public static final String SAVE_TEMPLATE = HEAD + "/identityTemplate/save";
/**
* 查询数据模板接口
*/
public static final String GET_TEMPLATE = HEAD + "/identityTemplate/select";
/**
* 删除数据模板接口
*/
public static final String DEL_TEMPLATE = HEAD + "/identityTemplate/delete";
/**
* 获取编码的地址
*/
public static final String GET_CODE = "http://39.99.231.15:11004/api/sm/codeTable/getCodeing";
}
common/src/main/java/com/jln/common/constant/LocalDateTimeConst.java 0 → 100644
package com.jln.common.constant;
/**
* 关于时间的常量
*/
public class LocalDateTimeConst {
public static final String DATE_YYYYMM_PATTERN = "yyyyMM";
public static final String DATE_YEAR_MONTH_PATTERN = "yyyy-MM";
public static final String DATE_YEAR_PATTERN = "yyyy";
/**
* 默认日期格式 "yyyy-MM-dd"
*/
public static final String DATE_PATTERN = "yyyy-MM-dd";
/**
* 默认时间格式 "HH:mm:ss"
*/
public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";
/**
* 默认日期时间格式 yyyy-MM-dd HH:mm:ss
*/
public static final String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
public static final String DATE_SHORTTIME_PATTERN = "yyyy-MM-dd HH:mm";
public static final String DATE_PATTERN_2 = "yyyy/MM/dd";
public static final String DATE_POINT_PATTERN = "yyyy.MM.dd";
public static final String DATE_POINT2_PATTERN = "yyyy.MM";
public static final String DATE_YYYYMMDDHHmm = "yyyy年MM月dd日 HH:mm";
public static final String DATE_mdHHmmss = "MM-dd HH:mm:ss";
}
common/src/main/java/com/jln/common/constant/TokenCacheConst.java 0 → 100644
package com.jln.common.constant;
/**
* @ClassName:
* @Description:
* @Author:三刀 Date:2020/9/25 14:17
* Version:1.0
**/
public class TokenCacheConst {
/**
* Redis缓存用户信息的key前缀
*/
public static final String TOKEN_USER_INFO = "SYS::user_info";
/**
* Redis缓存岗位信息的key前缀 当前用户具有哪些岗位
*/
public static final String TOKEN_POST_PREFIX = "sys_post_employee";
/**
* Redis缓存中当前岗位有哪些角色缓存前缀
*/
public static final String TOKEN_ROLE_PREFIX = "sys_role_post";
}
common/src/main/java/com/jln/common/entity/QrParameter.java 0 → 100644
package com.jln.common.entity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.validation.constraints.NotEmpty;
import java.util.List;
/**
* @ClassName: 二维码参数封装类
* @Description:
* @Author:三刀 Date:2020/2/26 13:09
* Version:1.0
**/
@ApiModel("二维码参数封装")
@Data
public class QrParameter {
@NotEmpty(message = "二维码要跳转的前端页面不能为空")
@ApiModelProperty(example = "http://127.0.0.1:8010/mes/index.html", value = "前端要跳转的页面", required = true,dataType = "string")
private String pageAddress;
@NotEmpty(message = "请求接口位置不能为空")
@ApiModelProperty(example = "http://127.0.0.1:8010/mes/getQr", value = "页面上面要请求接口位置", required = true,dataType = "string")
private String apiUrl;
@NotEmpty(message = "接口请求方式不能为空")
@ApiModelProperty(example = "POST", value = "页面上面要请求接口方式", required = true,dataType = "string")
private String requestMode;
private List<QrParameterContent> parameter; //参数集合
}
common/src/main/java/com/jln/common/entity/QrParameterContent.java 0 → 100644
package com.jln.common.entity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* @ClassName:
* @Description:
* @Author:三刀 Date:2020/2/26 13:14
* Version:1.0
**/
@ApiModel("接口参数")
@Data
public class QrParameterContent {
@ApiModelProperty(example = "oid", value = "参数名", required = true,dataType = "string")
private String key;
@ApiModelProperty(example = "58b1088e-7d3a-45c7-87f8-9bc335880173", value = "参数值", required = true,dataType = "string")
private String value;
}
common/src/main/java/com/jln/common/entity/ResponseResult.java 0 → 100644
package com.jln.common.entity;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.jln.common.enums.ResultCodeEnum;
/**
* @author 86180
* @version : Result, v 0.1 2020/1/17 11:08
*/
public class ResponseResult {
@JsonProperty("response_uuid")
private String responseUuid;
@JsonProperty("response_time")
private String responseTime;
@JsonProperty("response_attr")
private String responseAttr;
private String message;
private int code;
public String getMessage() {
return message;
}
public ResponseResult setMessage(String message) {
this.message = message;
return this;
}
public String getResponseUuid() {
return responseUuid;
}
public void setResponseUuid(String responseUuid) {
this.responseUuid = responseUuid;
}
public String getResponseTime() {
return responseTime;
}
public void setResponseTime(String responseTime) {
this.responseTime = responseTime;
}
public String getResponseAttr() {
return responseAttr;
}
public void setResponseAttr(String responseAttr) {
this.responseAttr = responseAttr;
}
public int getCode() {
return code;
}
public ResponseResult setCode(int code) {
this.code = code;
return this;
}
public ResponseResult() {
}
/**
* 成功且不带带返回信息
*
* @return
*/
public ResponseResult toSuccess(String responseUuid, String responseTime) {
this.setCode(ResultCodeEnum.OK.getCode());
this.setMessage(ResultCodeEnum.SUCCESS.getMsg());
this.setResponseUuid(responseUuid);
this.setResponseTime(responseTime);
this.setResponseAttr("");
return this;
}
/**
* 失败且带返回信息
*
* @return
*/
public ResponseResult toFailure(String responseUuid, String responseTime, String message) {
this.setCode(ResultCodeEnum.ERROR.getCode());
this.setResponseUuid(responseUuid);
this.setResponseTime(responseTime);
this.setMessage(message);
this.setResponseAttr("");
return this;
}
}
common/src/main/java/com/jln/common/entity/Result.java 0 → 100644
package com.jln.common.entity;
import com.jln.common.enums.ResultCodeEnum;
import com.jln.common.utils.JsonUtils;
/**
* @author 86180
* @version : Result, v 0.1 2020/1/17 11:08
*/
public class Result<T> {
private String msg;
private T data;
private int code;
public String getMsg() {
return msg;
}
public Result<T> setMsg(String msg) {
this.msg = msg;
return this;
}
public T getData() {
return data;
}
public Result<T> setData(T data) {
this.data = data;
return this;
}
public int getCode() {
return code;
}
public Result<T> setCode(int code) {
this.code = code;
return this;
}
public Result(T data) {
this(ResultCodeEnum.SUCCESS, data);
}
public Result() {
}
public Result(ResultCodeEnum resultCode, T data) {
this.code = resultCode.getCode();
this.msg = resultCode.getMsg();
this.data = data;
}
/**
* 失败且带返回信息
*
* @param resultCode
* @return
*/
public Result toFailure(ResultCodeEnum resultCode) {
this.setCode(resultCode.getCode());
this.setMsg(resultCode.getMsg());
this.setData((T) resultCode.getMsg());
return this;
}
/**
* 成功且带返回信息
* @param data
* @return
*/
public Result<T> toSuccess(T data){
this.setCode(ResultCodeEnum.SUCCESS.getCode());
this.setMsg(ResultCodeEnum.SUCCESS.getMsg());
this.setData(data);
return this;
}
/**
* 成功且不带带返回信息
* @return
*/
public Result<T> toSuccess(){
this.setCode(ResultCodeEnum.SUCCESS.getCode());
this.setMsg(ResultCodeEnum.SUCCESS.getMsg());
this.setData(null);
return this;
}
/**
* 成功且不带带返回信息
* @return
*/
public Result<T> toSuccess(ResultCodeEnum resultCode){
this.setCode(resultCode.getCode());
this.setMsg(resultCode.getMsg());
this.setData(null);
return this;
}
/**
* 失败且返回消息由外部指定
*
* @param
* @return
*/
public Result toFailure(String msg) {
this.setCode(-1);
this.setMsg(msg);
return this;
}
/**
* 判断请求是否成功
*
* @return
*/
public boolean confirmSuccess() {
if (this.code == 0 || this.code == 200) {
return true;
}
return false;
}
}
common/src/main/java/com/jln/common/entity/User.java 0 → 100644
package com.jln.common.entity;
import com.jln.system.web.action.sm.sm1001.entity.SysRole;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.List;
/**
* @author 86180
* @version : User, v 0.1 2020/2/15 12:06
*/
@Data
public class User {
private static final long serialVersionUID = 1L;
/**
* 员工主键和用户主键一致
*/
private Long employeeOid;
/**
* 员工编码
*/
private String codeing;
/**
* 员工工号
*/
private String jobNumber;
/**
* 员工电话号码
*/
private String phone;
/**
* 0为男，1为女
*/
private String sex;
/**
* 员工姓名
*/
private String employeeName;
/**
* 员工籍贯
*/
private String nativePlace;
/**
* 员工身份证号
*/
private String idCard;
/**
* 入职时间
*/
private LocalDateTime entryTime;
/**
* 离职时间
*/
private LocalDateTime dimissionTime;
/**
* 0为启用，1为停用
*/
private String blockUp;
/**
* 0为未删除，1为已删除
*/
private Integer del;
@ApiModelProperty(value = "用户主键")
private Long userId;
@ApiModelProperty(example = "张三",value = "用户名，登录名")
private String userName;
@ApiModelProperty(value = "员工编码，工号")
private String employeeCode;
@ApiModelProperty(value = "用户头像")
private String photo;
@ApiModelProperty(value = "用户密码策略",example = "123456")
private Long paspolFk;
@ApiModelProperty(value = "公司主键")
private Long orgOid;
@ApiModelProperty(value = "公司名称")
private String orgName;
@ApiModelProperty(value = "公司层级")
private String orgClassCode;
@ApiModelProperty(value = "部门主键")
private Long divisionOid;
@ApiModelProperty(value = "部门名称")
private String divisionName;
@ApiModelProperty(value = "部门层级")
private String divisionClassCode;
@ApiModelProperty(value = "岗位主键")
private Long postOid;
@ApiModelProperty(value = "主岗位名称")
private String postName;
@ApiModelProperty(value = "所属项目部")
private Long xmwhFk;
@ApiModelProperty(value = "角色")
private List<SysRole> sysRoles;
}
common/src/main/java/com/jln/common/entity/UserID.java 0 → 100644
package com.jln.common.entity;
import lombok.Data;
import org.springframework.stereotype.Component;
@Data
@Component
public class UserID {
private String id;
}
common/src/main/java/com/jln/common/enums/BindingModeEnum.java 0 → 100644
package com.jln.common.enums;
import com.baomidou.mybatisplus.core.enums.IEnum;
/**
* 工单产出物料绑定方式枚举维护类
*/
public enum BindingModeEnum implements IEnum<String> {
BIND_SN("SN", "序列号"),
BIND_BT("BT", "批次号");
private String value;
private String desc;
BindingModeEnum(String value, String desc) {
this.desc = desc;
this.value = value;
}
@Override
public String getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
}
common/src/main/java/com/jln/common/enums/BlockupsEnum.java 0 → 100644
package com.jln.common.enums;
import com.baomidou.mybatisplus.core.enums.IEnum;
public enum BlockupsEnum implements IEnum {
IS_YES(1, "是"),
IS_NOT(0, "否");
private Integer value;
private String desc;
BlockupsEnum(Integer value, String desc) {
this.desc = desc;
this.value = value;
}
@Override
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
}
common/src/main/java/com/jln/common/enums/BlxBlmcToCclmEnum.java 0 → 100644
package com.jln.common.enums;
public enum BlxBlmcToCclmEnum {
STATUS("设备状态", "Status"),
Alarm("是否报警", "Alarm");
private String blmc;
private String cclm;
BlxBlmcToCclmEnum(String blmc, String cclm) {
this.blmc = blmc;
this.cclm = cclm;
}
public String getBlmc() {
return blmc;
}
public void setBlmc(String blmc) {
this.blmc = blmc;
}
public String getCclm() {
return cclm;
}
public void setCclm(String cclm) {
this.cclm = cclm;
}
}
common/src/main/java/com/jln/common/enums/CodeEnum.java 0 → 100644
package com.jln.common.enums;
import com.baomidou.mybatisplus.core.enums.IEnum;
public enum CodeEnum implements IEnum<String> {
KZTBM("控制图编码", "SPC控制图编码规则不存在"),
SAMPLE_DATA("SPC样本编码", "SPC样本数据编码规则不存在"),
TEST_OBJECT("SPC样本检验对象", "SPC样本检验对象编码规则不存在");
private String value;
private String desc;
CodeEnum(String value, String desc) {
this.value = value;
this.desc = desc;
}
@Override
public String getValue() {
return this.value;
}
public static String getDesc(String value) {
CodeEnum[] values = values();
for (CodeEnum anEnum : values) {
if (anEnum.value.equals(value)) {
return anEnum.desc;
}
}
return null;
}
}
common/src/main/java/com/jln/common/enums/IsDeleteEnum.java 0 → 100644
package com.jln.common.enums;
/**
* @ClassName:
* @Description:
* @Author:三刀 Date:2020/2/11 15:43
* Version:1.0
**/
public enum IsDeleteEnum {
Delete(1, "已删除"), NotDelete(0, "未删除");
private Integer status;
private String description;
IsDeleteEnum(Integer status, String description) {
this.status = status;
this.description = description;
}
public Integer getStatus() {
return status;
}
public String getDescription() {
return description;
}
public static boolean confirmSuccessStatus(int status) {
boolean isPass = false;
for (int i = 0; i < IsDeleteEnum.values().length; i++) {
if (status == IsDeleteEnum.values()[i].getStatus()) {
isPass = true;
}
}
return isPass;
}
}
common/src/main/java/com/jln/common/enums/JudgeEnum.java 0 → 100644
package com.jln.common.enums;
import com.baomidou.mybatisplus.core.enums.IEnum;
/**
* @ClassName:
* @Description:
* @Author:三刀 Date:2020/2/11 23:23
* Version:1.0
**/
public enum JudgeEnum implements IEnum<String> {
IS_YES("1", "是", 1L),
IS_NOT("0", "否", 0L);
private String value;
private String desc;
private Long valueLong;
JudgeEnum(String value, String desc, Long valueLong) {
this.desc = desc;
this.value = value;
this.valueLong = valueLong;
}
@Override
public String getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public Long getValueLong() {
return valueLong;
}
}
common/src/main/java/com/jln/common/enums/MeanRangeTypeEnum.java 0 → 100644
package com.jln.common.enums;
import com.baomidou.mybatisplus.core.enums.IEnum;
/**
* 均值极差类型枚举
*/
public enum MeanRangeTypeEnum implements IEnum<String> {
MEAN_VALUE("A2", "均值图-控制限计算系数"),
RANGE_TYPE("D2", "极差R图-标准估计的除数"),
RANGE_UCL_TYPE("D4", "极差R图-控制限计算系数-上限"),
RANGE_LCL_TYPE("D3", "极差R图-控制限计算系数-下限"),
MEAN_VALUE_TYPE("A2", "均值图-控制限计算系数"),
STANDARD_DEVIATION_TYPE("C4", "标准差S图--标准差估计的除数"),
STANDARD_DEVIATION_UCL_TYPE("B4", "标准差S图--控制限系数"),
STANDARD_DEVIATION_LCL_TYPE("B3", "标准差S图--控制限系数"),
SINGLE_VALUE("E2", "单值移动极差计算系数-上限");
MeanRangeTypeEnum(String value, String desc) {
this.value = value;
this.desc = desc;
}
/**
* 值
*/
private String value;
/**
* 描述
*/
private String desc;
@Override
public String getValue() {
return value;
}
}
common/src/main/java/com/jln/common/enums/MqttEnum.java 0 → 100644
package com.jln.common.enums;
public enum MqttEnum {
MQTT_HOST("MQTT_HOST", "主机地址"),
MQTT_CLIENTID("MQTT_CLIENTID", "客户端ID"),
MQTT_USERNAME("MQTT_USERNAME", "用户名"),
MQTT_PASSWORD("MQTT_PASSWORD", "密码"),
MQTT_SSLROOT_CRTPATH("MQTT_SSLROOT_CRTPATH", "CRT文件路径"),
MQTT_SSLPROTOCOL("MQTT_SSLPROTOCOL", "SSLPROTOCOL"),
MQTT_TLS("TLSv1.1", "版本"),
MQTT_TOPIC("MQTT_TOPIC", "主题");
private String mqttName;
private String mqttDesc;
MqttEnum(String mqttName, String mqttDesc) {
this.mqttName = mqttName;
this.mqttDesc = mqttDesc;
}
public String getMqttName() {
return mqttName;
}
public void setMqttName(String mqttName) {
this.mqttName = mqttName;
}
public String getMqttDesc() {
return mqttDesc;
}
public void setMqttDesc(String mqttDesc) {
this.mqttDesc = mqttDesc;
}
}
common/src/main/java/com/jln/common/enums/ProcessStateColorEnum.java 0 → 100644
package com.jln.common.enums;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName:
* @Description:
* @Author:三刀 Date:2020/11/26 16:55
* Version:1.0
**/
public enum ProcessStateColorEnum implements StateColor<String>{
NOT_START_WORKING("PSK022", "I"),
NOT_UNFINISHED("PSK023", "F"),
UNFINISHED("PSK024", "C"),
SPEED("PSK025", "D");
ProcessStateColorEnum(String value, String desc) {
this.desc = desc;
this.value = value;
}
private String value;
private String desc;
@Override
public String getValue() {
return value;
}
public String getDesc() {
return desc;
}
@Override
public List<String> getValues(){
List<String> values=new ArrayList<>();
for (ProcessStateColorEnum workOderEnum : ProcessStateColorEnum.values()) {
values.add(workOderEnum.getValue());
}
return values;
}
@Override
public List<String> getDescs(){
List<String> values=new ArrayList<>();
for (ProcessStateColorEnum workOderEnum : ProcessStateColorEnum.values()) {
values.add(workOderEnum.getDesc());
}
return values;
}
}
common/src/main/java/com/jln/common/enums/PsWbStateColorEnum.java 0 → 100644
package com.jln.common.enums;
import com.baomidou.mybatisplus.core.enums.IEnum;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName:
* @Description:
* @Author:三刀 Date:2020/11/26 15:43
* Version:1.0
**/
public enum PsWbStateColorEnum implements StateColor<String> {
PS_WB_INITIAL_KEY("PSK005", "I"),
PS_WB_LEVELS_KEY("PSK006", "R"),
PS_WB_SUSPEND_KEY("PSK007", "S"),
PS_WB_ACCOMPLISH_KEY("PSK008", "C");
PsWbStateColorEnum(String value, String desc) {
this.desc = desc;
this.value = value;
}
private String value;
private String desc;
@Override
public String getValue() {
return value;
}
public String getDesc() {
return desc;
}
@Override
public List<String> getValues(){
List<String> values=new ArrayList<>();
for (PsWbStateColorEnum workOderEnum : PsWbStateColorEnum.values()) {
values.add(workOderEnum.getValue());
}
return values;
}
@Override
public List<String> getDescs(){
List<String> values=new ArrayList<>();
for (PsWbStateColorEnum workOderEnum : PsWbStateColorEnum.values()) {
values.add(workOderEnum.getDesc());
}
return values;
}
}
common/src/main/java/com/jln/common/enums/QcSpcMonitoringTypeEnum.java 0 → 100644
package com.jln.common.enums;
import com.baomidou.mybatisplus.core.enums.IEnum;
/**
* @ClassName:
* @Description:
* @Author:三刀 Date:2020/9/10 17:08
* Version:1.0
**/
public enum QcSpcMonitoringTypeEnum implements IEnum<String> {
MEAN_VALUE("M", "均值情况"),
RANGE("L", "极差情况"),
OYHER_CONDITIONS("Q", "其他情况，P、C、U图");
private String value;
private String desc;
QcSpcMonitoringTypeEnum(String value, String desc) {
this.value = value;
this.desc = desc;
}
;
@Override
public String getValue() {
return this.value;
}
}
common/src/main/java/com/jln/common/enums/ResultCodeEnum.java 0 → 100644
package com.jln.common.enums;
/**
* @author 86180
* @version : ResultCode, v 0.1 2020/1/17 11:16
*/
public enum ResultCodeEnum {
/**
* 1** 信息，服务器收到请求，需要请求者继续执行操作
* 2** 成功，操作被成功接收并处理
* 3** 重定向，需要进一步的操作以完成请求
* 4** 客户端错误，请求包含语法错误或无法完成请求
* 5** 服务器错误，服务器在处理请求的过程中发生了错误
*/
OK(0,"ok"),
NO(1,"no"),
ERROR(-1,"exception"),
FILE_REPETITION(10002, "字段名重复"),
EULES_EXCEPITION(10004, "系统参数有误"),
CODE_EXCEPTION(10001, "编码不符合规范"),
SUCCESS(200, "success"),//成功
FAILUTE(400, "error"),//失败
UNAUTHORIZED(401, "验证失败"),//验证失败
NOT_FOUND(404, "找不到"),//找不到
NULL_POINTER_EXCEPTION(100001, "空指针引用异常"),
CLASS_CAST_EXCEPTION(100002, "类型强制转换异常"),
ILLEAGAL_ARGUMENT_EXCEPTION(100003, "传递非法参数异常"),
ARITHMETIC_EXCEPTION(100004, "算术运算异常"),
ARRAY_STORE_EXCEPTION(100005, "向数组中存放与声明类型不兼容对象异常"),
INDEX_OUT_OF_BOUNDS_EXCEPTION(100006, "下标越界异常"),
NEGATIVE_ARRAY_SIZE_EXCEPTION(100007, "创建一个大小为负数的数组错误异常"),
NUMBER_FORMAT_EXCEPTION(100008, "数字格式异常"),
SECURITY_EXCEPTION(100009, "安全异常"),
UNSUPPORTED_OPERATION_EXCEPTION(100010, "不支持的操作异常"),
LOOK_UP_TO(100011, "查无数据"),
Expire_TOKEN(102006, "密钥失效"),
CREATE_HASVALUE(101001, "已存在的名称，请重新输入后提交"),
DELETE_EXCEPTION(101002, "删除失败，查无此记录"),
UPDATE_EXCEPTION(101003, "更新异常，请根据提示确认后提交"),
CREARE_FAILURE(101004, "插入失败"),
MISS_PARAM(102001, "缺少必要参数，请检查输入数据"),
Valid_PARAM(102002, "参数验证失败，请检查输入数据"),
/**
* 参数解析
*/
Fail_PARAM(102003, "参数解析失败，请检查输入数据"),
Not_SUPPORTED(102004, "不支持"),
Not_TOKEN(102005, "密钥为空"),
/**
* 附件上传失败
*/
File_Failure(102006, "附件上传失败"),
File_DelFailure(102007, "附件删除失败"),
Not_Data(102008, "没有获取到数据"),
SQL_Error(102009, "SQL执行错误，请检查输入数据"),
MISS_Fail(102010, "错误的请求上传接口，请检查是否输入文件"),
Error_Fail(102011, "发生了预期之外的错误"),
Long_Miss(102012, "Long类型不能为空，或者传入值不对"),
/**
* 没有数据
*/
KBERROR1000(1000,"请传入物料编码"),
IPC_Fail_Check(102013, "传入的任务已存在开工任务！"),
IPC_Fail_Check2(102015, "只能暂停已开工的数据！"),
START_SUCCESS(102014, "执行成功！"),
/**
* BM
*/
BM0001(102016, "获取失败"),
BM0003(102018, "保存失败"),
BM0004(102019, "删除失败"),
BM0007(102022, "删除失败"),
BM0005(0, "删除成功"),
BM0006(102020, "项目编码重复"),
BM0008(102023, "编码重复"),
BM0010(102025, "编码重复"),
BM0009(102024, "请输入英文字母"),
BM0011(102026, "该节点或该节点以下的节点被其他模块调用，删除失败"),
BM0012(102027, "当前节点已被其他模块调用，修改其上级节点失败"),
BM0013(102028, "当前设备已被调用，删除失败"),
BM0002(102017, "字典编码重复");
private int code;
private String msg;
ResultCodeEnum(int code, String msg) {
this.code = code;
this.msg = msg;
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
\ No newline at end of file
common/src/main/java/com/jln/common/enums/SpcAbnormalTypeEnum.java 0 → 100644
package com.jln.common.enums;
import com.baomidou.mybatisplus.core.enums.IEnum;
import com.jln.common.utils.StringUtils;
/**
* @ClassName:
* @Description:
* @Author:三刀 Date:2020/9/1 10:58
* Version:1.0
**/
public enum SpcAbnormalTypeEnum implements IEnum<String> {
ABNORMAL_BOUNDARY("1", "点出界--大于上限值或者小于下限值"),
COMPANY_COMMANDER("2", "链长大于九---点的值同时九点出现在中心值的左侧或者右侧"),
INCREASING_AND_DECREASING("3", "连续六点及以上递增或者递减");
SpcAbnormalTypeEnum(String value, String desc) {
this.value = value;
this.desc = desc;
}
private String value;
private String desc;
@Override
public String getValue() {
return value;
}
/**
* 通过value取枚举
*
* @param value
* @return
*/
public static SpcAbnormalTypeEnum getTypeByValue(String value) {
if (StringUtils.isNull(value)) {
return null;
}
for (SpcAbnormalTypeEnum enums : SpcAbnormalTypeEnum.values()) {
if (enums.getValue().equals(value)) {
return enums;
}
}
return null;
}
}
common/src/main/java/com/jln/common/enums/SpcGraphTypeEnum.java 0 → 100644
package com.jln.common.enums;
import com.baomidou.mybatisplus.core.enums.IEnum;
/**
* @ClassName: SPC-图类型的枚举维护
* @Description:
* @Author:三刀 Date:2020/9/4 11:50
* Version:1.0
**/
public enum SpcGraphTypeEnum implements IEnum<String> {
THE_MEAN_POOR("11", "均值极差图"),
MEAN_STANDARD_DEVIATION("12", "均值标准差图"),
SINGLE_VALUE_MOVING_RANGE("13", "单值移动极差图"),
REGRESSION_CONTROL_CHART("14", "回归控制图"),
P_CHART("21", "P图"),
C_CHART("31", "C图"),
U_CHART("31", "U图");
private String value;
private String desc;
/**
* 构造方法
*
* @param value 值
* @param desc 描述
*/
SpcGraphTypeEnum(String value, String desc) {
this.value = value;
this.desc = desc;
}
@Override
public String getValue() {
return this.value;
}
}
common/src/main/java/com/jln/common/enums/SpcTypeEnum.java 0 → 100644
package com.jln.common.enums;
import com.baomidou.mybatisplus.core.enums.IEnum;
/**
* @ClassName: SPC 样本类型枚举维护
* @Description:
* @Author:三刀 Date:2020/8/25 15:20
* Version:1.0
**/
public enum SpcTypeEnum implements IEnum<String> {
IS_COUNT("1", "计数"),
IS_MEASURE("2", "计量"),
IS_ARGUMENT("3", "计点");
SpcTypeEnum(String value, String desc) {
this.desc = desc;
this.value = value;
}
private String value;
private String desc;
@Override
public String getValue() {
return value;
}
}
common/src/main/java/com/jln/common/enums/StateColor.java 0 → 100644
package com.jln.common.enums;
import java.io.Serializable;
import java.util.List;
/**
* @ClassName:
* @Description:
* @Author:三刀 Date:2020/11/26 15:53
* Version:1.0
**/
public interface StateColor<T extends Serializable> {
/**
* 获取value值
* @return
*/
T getValue();
/**
* 获取所有value值
* @return
*/
List<T> getValues();
/**
* 获取所有的描述值
* @return
*/
List<String> getDescs();
}
common/src/main/java/com/jln/common/enums/StateEnum.java 0 → 100644
package com.jln.common.enums;
import com.baomidou.mybatisplus.core.enums.IEnum;
/**
* @ClassName: 系统中常见状态维护枚举类
* @Description: 状态：i|初始、f|确认、c|完成
* @Author:三刀 Date:2020/2/15 17:25
* Version:1.0
**/
public enum StateEnum implements IEnum<String> {
INITAL("I", "初始"),
CONFIRM("F", "确认"),
COMPLETE("C", "完成");
private String value;
private String desc;
StateEnum(String value, String desc) {
this.desc = desc;
this.value = value;
}
@Override
public String getValue() {
return this.value;
}
}
common/src/main/java/com/jln/common/enums/WoStateColorEnum.java 0 → 100644
package com.jln.common.enums;
import java.util.ArrayList;
import java.util.List;
public enum WoStateColorEnum implements StateColor<String> {
WO_INITIAL_KEY("PPK002", "I"),
WO_AFFIRM_KEY("PPK003", "F"),
WO_LEVELS_KEY("PPK004", "R"),
WO_SUSPEND_KEY("PPK005", "S"),
WO_ACCOMPLISH_KEY("PPK006", "C");
WoStateColorEnum(String value, String desc) {
this.desc = desc;
this.value = value;
}
private String value;
private String desc;
@Override
public String getValue() {
return value;
}
public String getDesc() {
return desc;
}
@Override
public List<String> getValues(){
List<String> values=new ArrayList<>();
for (WoStateColorEnum workOderEnum : WoStateColorEnum.values()) {
values.add(workOderEnum.getValue());
}
return values;
}
@Override
public List<String> getDescs(){
List<String> values=new ArrayList<>();
for (WoStateColorEnum workOderEnum : WoStateColorEnum.values()) {
values.add(workOderEnum.getDesc());
}
return values;
}
}
common/src/main/java/com/jln/common/enums/WorkOderEnum.java 0 → 100644
package com.jln.common.enums;
import com.baomidou.mybatisplus.core.enums.IEnum;
/**
* @ClassName:
* @Description:
* @Author:三刀 Date:2020/2/20 14:00
* Version:1.0
**/
public enum WorkOderEnum implements IEnum<String> {
INITAL("I", "初始"),
CONFIRM("F", "确认"),
COMPLETE("C", "完成"),
ISSUED("R", "下达"),
PAUSE("S", "暂停");
private String value;
private String desc;
WorkOderEnum(String value, String desc) {
this.desc = desc;
this.value = value;
}
@Override
public String getValue() {
return this.value;
}
}
common/src/main/java/com/jln/common/exception/CustomException.java 0 → 100644
package com.jln.common.exception;
import com.jln.common.enums.ResultCodeEnum;
/**
* @author 86180
* @version : CustomException, v 0.1 2020/1/17 11:59
*/
/*
* message
*异常的描述信息，也就是在打印栈追踪信息时异常类名后面紧跟着的描述字符串
*cause
*导致此异常发生的父异常，即追踪信息里的caused by
*enableSuppress
*关于异常挂起的参数，这里我们永远设为false即可
*writableStackTrace
*表示是否生成栈追踪信息，只要将此参数设为false, 则在构造异常对象时就不会调用fillInStackTrace()
* 生成”轻量级”异常，对性能的耗费从大到小依次为：输出到日志、获取异常堆栈、创建并 catch 异常
* */
public class CustomException extends RuntimeException{
private int code;
private String msg;
public CustomException(ResultCodeEnum resultCode) {
super(resultCode.getMsg(),null,false,false);
this.code = resultCode.getCode();
this.msg = resultCode.getMsg();
}
public CustomException(int code, String msg) {
super(msg,null,false,false);
this.code = code;
this.msg = msg;
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
common/src/main/java/com/jln/common/exception/GlobalExceptionHandler.java 0 → 100644
package com.jln.common.exception;
import com.jln.common.entity.Result;
import com.jln.common.enums.ResultCodeEnum;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.validation.BindException;
import org.springframework.validation.ObjectError;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.multipart.support.MissingServletRequestPartException;
import org.springframework.web.servlet.NoHandlerFoundException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import javax.validation.ValidationException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
@RestControllerAdvice(basePackages = "com.jln.system.web.action.sybg.controller")
public class GlobalExceptionHandler {
private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
/**
* 未知运行异常Exception
*/
@ExceptionHandler(Exception.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
public Result<Object> ExceptionHandler(Exception e) {
logger.error("未知异常："+e.getMessage());
return new Result<>(ResultCodeEnum.FAILUTE, e.getMessage());
}
/**
* 方法参数错误异常
*
* @param e
* @return
*/
@ExceptionHandler(MethodArgumentNotValidException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
public Result<Object> MethodArgumentNotValidExceptionHandler(MethodArgumentNotValidException e) {
logger.error("方法参数错误异常："+e.getMessage());
List<String> list = new ArrayList<>(); // 从异常对象中拿到ObjectError对象
if (!e.getBindingResult().getAllErrors().isEmpty()) {
for (ObjectError error : e.getBindingResult().getAllErrors()) {
list.add(error.getDefaultMessage().toString());
}
}
// 然后提取错误提示信息进行返回
return new Result<>(ResultCodeEnum.FAILUTE, list);
}
}
common/src/main/java/com/jln/common/exception/GlobalSyzkExceptionHandler.java 0 → 100644
package com.jln.common.exception;
import com.alibaba.fastjson.JSONObject;
import com.jln.common.entity.ResponseResult;
import com.jln.common.utils.DateUtils;
import com.jln.common.utils.HttpHelper;
import com.jln.common.utils.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
* 三一中控接口统一异常处理
*/
@RestControllerAdvice(basePackages = "com.jln.system.web.action.syzk.controller")
public class GlobalSyzkExceptionHandler {
private static final Logger logger = LoggerFactory.getLogger(GlobalSyzkExceptionHandler.class);
/**
* 未知运行异常Exception
*/
@ExceptionHandler({Exception.class})
@ResponseStatus(HttpStatus.BAD_REQUEST)
public ResponseResult ExceptionHandler(Exception e, HttpServletRequest request) {
logger.error("未知异常：" + e.getMessage());
try {
String bodyString = HttpHelper.getBodyString(request);
JSONObject jsonObject = JSONObject.parseObject(bodyString);
if (null != jsonObject) {
return new ResponseResult().toFailure(jsonObject.getString("request_uuid"), DateUtils.getDateTime(), e.getMessage());
}
} catch (IOException exception) {
logger.error("获取参数request_uuid异常：" + exception.getMessage());
}
return new ResponseResult().toFailure("", DateUtils.getDateTime(), e.getMessage());
}
/**
* 方法参数错误异常
*
* @param e
* @return
*/
@ExceptionHandler(MethodArgumentNotValidException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
public ResponseResult MethodArgumentNotValidExceptionHandler(MethodArgumentNotValidException e, HttpServletRequest request) {
logger.error("方法参数错误异常：" + e.getMessage());
List<String> list = new ArrayList<>();
// 从异常对象中拿到ObjectError对象
if (!e.getBindingResult().getAllErrors().isEmpty()) {
for (ObjectError error : e.getBindingResult().getAllErrors()) {
list.add(error.getDefaultMessage().toString());
}
}
try {
String bodyString = HttpHelper.getBodyString(request);
JSONObject jsonObject = JSONObject.parseObject(bodyString);
if (null != jsonObject) {
return new ResponseResult().toFailure(jsonObject.getString("request_uuid"), DateUtils.getDateTime(), StringUtils.join(list, ","));
}
} catch (IOException exception) {
logger.error("获取参数request_uuid异常：" + exception.getMessage());
}
return new ResponseResult().toFailure("", DateUtils.getDateTime(), StringUtils.join(list, ","));
}
}
common/src/main/java/com/jln/common/interceptor/AuthenticationInterceptor.java 0 → 100644
package com.jln.common.interceptor;
import org.springframework.web.servlet.HandlerInterceptor;
/**
* @author 86180
* @version : AuthenticationInterceptor, v 0.1 2020/1/15 9:52
* @Description: 当前拦截集只是验证用户是否登录未做额外权限操作，备注：token前端传递的名字从配置文件中获取
*/
//@Component
public class AuthenticationInterceptor implements HandlerInterceptor {
/*
private static final Logger log = LoggerFactory.getLogger(AuthenticationInterceptor.class);
@Autowired
private JwtUtils jwtUtil;
public static final String USER_KEY = "Oid";
@Autowired
private UserID userID;
*//**
* 拦截器判断token是否存在,切入点@UserLoginToken
* @param httpServletRequest
* @param httpServletResponse
* @param object
* @return
* @throws Exception
*//*
@Override
public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object object) throws Exception {
String token = httpServletRequest.getHeader("api_key");
String url = httpServletRequest.getRequestURL().toString();
Object pathMapping = httpServletRequest.getAttribute("org.springframework.web.servlet.HandlerMapping.pathWithinHandlerMapping");
if(String.valueOf(pathMapping)!=null && String.valueOf(pathMapping).contains("static/")){
return true;
}
log.info(url);
if(url.contains("/v2/api-docs")||url.contains("swagger")||url.contains(("/file/imges")))
{
return true;
}
if(!(object instanceof HandlerMethod)){
return true;
}
HandlerMethod handlerMethod=(HandlerMethod)object;
Method method=handlerMethod.getMethod();
// 判断方法是否存在忽略token注解，
// 存在：验证token
// 不存在：返回true
if(!method.isAnnotationPresent(IgnoreUserLoginToken.class))
{
if(token == null){
throw new CustomException(-1,"用户信息不存在");
}
Claims claimByToken = jwtUtil.getClaimByToken(token);
if(claimByToken == null || jwtUtil.isTokenExpired(claimByToken.getExpiration())){
throw new CustomException(ResultCodeEnum.Expire_TOKEN);
}
String subject = claimByToken.getSubject();
httpServletRequest.setAttribute(JwtUtils.USER_KEY, subject);
return true;
}
return true;
}
@Override
public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
}
@Override
public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
}*/
}
common/src/main/java/com/jln/common/interceptor/LoginUserHandlerMethodArgumentResolver.java 0 → 100644
package com.jln.common.interceptor;
import com.jln.common.RedisUtil.RedisUtil;
import com.jln.common.annotation.LoginUser;
import com.jln.common.entity.User;
import com.jln.common.utils.JwtUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.MethodParameter;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;
//@Component
public class LoginUserHandlerMethodArgumentResolver implements HandlerMethodArgumentResolver {
@Autowired
private RedisUtil redisUtil;
@Autowired
private JwtUtils jwtUtils;
@Override
public boolean supportsParameter(MethodParameter parameter) {
// TODO Auto-generated method stub
return parameter.getParameterType().isAssignableFrom(User.class) && parameter.hasParameterAnnotation(LoginUser.class);
}
@Override
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
// TODO Auto-generated method stub
/*Object sysUseroid = webRequest.getHeader("api_key");
*//**1. 判断用户信息是否存在，不存在则将远程用户数据更新到本地
* 2. 判断远程用户信息是否更改，更改则将远程用户信息更新到本地(先不做考虑)
* *//*
if(sysUseroid == null){
throw new CustomException(-1,"用户信息不存在");
}
Claims claimByToken = jwtUtils.getClaimByToken(sysUseroid.toString());
if(claimByToken == null || jwtUtils.isTokenExpired(claimByToken.getExpiration())){
throw new CustomException(ResultCodeEnum.Expire_TOKEN);
}
String subject = claimByToken.getSubject();
*//**1. 判断用户信息是否存在，不存在则将远程用户数据更新到本地
* 2. 判断远程用户信息是否更改，更改则将远程用户信息更新到本地(先不做考虑)
* *//*
Object o = redisUtil.get(TokenCacheConst.TOKEN_USER_INFO + "::" + subject);
if(EmptyUtil.isEmpty(o)){
return createDeflt();
}
User user = new User();
user.setEmployeeOid( Long.valueOf(subject));
UserInfo userInfo = JacksonUtil.toBean(JacksonUtil.toString(o), UserInfo.class);
BeanUtils.copyProperties(userInfo,user);
//重新生成用户数据
user.setEmployeeName(userInfo.getEmployeeName());
user.setSysRoles(userInfo.getSysRoles());
return user;*/
return null;
}
}
common/src/main/java/com/jln/common/interceptor/MyResponseBodyAdvice.java 0 → 100644
package com.jln.common.interceptor;
import com.alibaba.fastjson.JSON;
import com.jln.common.entity.ResponseResult;
import com.jln.common.entity.Result;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
/**
* @author 86180
* @version : MyResponseBodyAdvice, v 0.1 2020/1/31 10:03
*/
@RestControllerAdvice
public class MyResponseBodyAdvice implements ResponseBodyAdvice {
@Override
public boolean supports(MethodParameter returnType, Class converterType) {
return true;
}
@Override
public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
// 不处理swagger返回json格式
String url = request.getURI().toString();
if(url.contains("/v2/api-docs") || url.contains("/swagger-resources") || url.contains("/wf/modeleditor") || url.contains("/wf/procservice") || url.contains("proctrackimgs"))
{
return body;
}
if(body.equals(""))
{
return new Result().toSuccess();
}
if (body instanceof Result) {
return body;
}
if (body instanceof String) {
return JSON.toJSONString(new Result().toSuccess(body));
}
if (body instanceof ResponseResult) {
return body;
}
return new Result().toSuccess(body);
}
}
common/src/main/java/com/jln/common/request/HttpServletRequestReplacedFilter.java 0 → 100644
package com.jln.common.request;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
public class HttpServletRequestReplacedFilter implements Filter {
@Override
public void destroy() {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
ServletRequest requestWrapper = null;
if(request instanceof HttpServletRequest) {
requestWrapper = new RequestReaderHttpServletRequestWrapper((HttpServletRequest) request);
}
//获取请求中的流如何，将取出来的字符串，再次转换成流，然后把它放入到新request对象中。
// 在chain.doFiler方法中传递新的request对象
if(requestWrapper == null) {
chain.doFilter(request, response);
} else {
chain.doFilter(requestWrapper, response);
}
}
@Override
public void init(FilterConfig arg0) throws ServletException {
}
}
common/src/main/java/com/jln/common/request/RequestReaderHttpServletRequestWrapper.java 0 → 100644
package com.jln.common.request;
import com.jln.common.utils.HttpHelper;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
public class RequestReaderHttpServletRequestWrapper extends HttpServletRequestWrapper{
private final byte[] body;
public RequestReaderHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
super(request);
body = HttpHelper.getBodyString(request).getBytes(Charset.forName("UTF-8"));
}
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(getInputStream()));
}
@Override
public ServletInputStream getInputStream() throws IOException {
final ByteArrayInputStream bais = new ByteArrayInputStream(body);
return new ServletInputStream() {
@Override
public int read() throws IOException {
return bais.read();
}
@Override
public boolean isFinished() {
return false;
}
@Override
public boolean isReady() {
return false;
}
@Override
public void setReadListener(ReadListener readListener) {
}
};
}
}
common/src/main/java/com/jln/common/utils/BaseUtil.java 0 → 100644
package com.jln.common.utils;
import com.jln.common.constant.LocalDateTimeConst;
import lombok.extern.slf4j.Slf4j;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.UUID;
/**
* @ClassName: 统用工具类
* @Description:
* @Author:三刀 Date:2020/2/4 14:56
* Version:1.0
**/
@Slf4j
public class BaseUtil {
public Long getLongId(){
SnowflakeIdWorker snowflakeIdWorker = new SnowflakeIdWorker(0,0);
return snowflakeIdWorker.nextId();
}
/**
* 获取32位UUID
* @return
*/
public static String getUuidRp() {
String uuid = UUID.randomUUID().toString().replaceAll("-","");
return uuid;
}
/**
* 获取36位UUID
* @return
*/
public static String getUUID(){
return UUID.randomUUID().toString();
}
public static String LocalDateToString() {
LocalDate date = LocalDate.now();
DateTimeFormatter fmt = DateTimeFormatter.ofPattern(LocalDateTimeConst.DATE_PATTERN);
return date.format(fmt);
}
public String getPath()
{
String path = this.getClass().getProtectionDomain().getCodeSource().getLocation().getPath();
if(System.getProperty("os.name").contains("dows"))
{
path = path.substring(1,path.lastIndexOf("."));
log.error(path);
}
if(path.contains("jar"))
{
log.error("jar"+path);
path = path.substring(0,path.lastIndexOf("."));
return path.substring(0,path.lastIndexOf("/"));
}
String replace = path.replace("target/classes/", "");
replace= replace.substring(0,replace.lastIndexOf("."));
log.error("replace"+replace);
return replace.substring(0,replace.lastIndexOf("/"));
}
public static int objecttoint(BigDecimal o){
// BigDecimal num = new BigDecimal(o);
int num = o.intValue();
System.out.println(num);
return num;
}
}
common/src/main/java/com/jln/common/utils/DetermineType.java 0 → 100644
package com.jln.common.utils;
import java.lang.reflect.Type;
/**
* @ClassName: 判断当前对象是否是指定类型
* @Description:
* @Author:三刀 Date:2020/6/28 13:30
* Version:1.0
**/
public class DetermineType {
public<T> boolean function(Object obj, Class<T> calzz) {
if (obj == null) {
return false;
}
try {
T t = (T) obj;
return true;
} catch (ClassCastException e) {
return false;
}
}
public static boolean function(Object obj, String className) {
if (obj == null) {
return false;
}
try {
Class<?> aClass = Class.forName(className);
if(obj.getClass()==aClass){
return true;
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
return false;
}
return false;
}
}
common/src/main/java/com/jln/common/utils/EmptyUtil.java 0 → 100644
package com.jln.common.utils;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.util.Collection;
/**
* @ClassName:
* @Description:
* @Author:三刀 Date:2019/12/23 15:24
* Version:1.0
**/
public class EmptyUtil {
/**
* 判断字符串是否为空
* PS:
* 为空的条件：
* 1. String对象为空
* 2. 没有任何字符的字符串
*
* @param str 需要判断的字符串
* @return 为空(true), 非空(false)
*/
public static boolean isEmpty(String str) {
return null == str || "".equals(str);
}
/**
* 判断字符串是否为空
* PS:
* 为空的条件：
* 1. String对象为空
* 2. 没有任何字符的字符串
*
* @param str 需要判断的字符串
* @param isTrimmed 判断前是否去掉字符串前后的空格：是(true), 否(false)
* @return 为空(true), 非空(false)
*/
public static boolean isEmpty(String str, boolean isTrimmed) {
return isTrimmed ? null == str || "".equals(str.trim()) : null == str || "".equals(str);
}
/**
* 判断对象是否为空
*
* @param obj 需要进行判断的对象
* @return 为空(true), 不为空(false)
*/
public static boolean isEmpty(Object obj) {
if(null==obj){
return true;
}
Class clazz = (Class)obj.getClass(); // 得到类对象
Field fields[] = clazz.getDeclaredFields(); // 得到所有属性
boolean flag = true; //定义返回结果，默认为true
for(Field field : fields){
field.setAccessible(true);
Object fieldValue = null;
try {
fieldValue = field.get(obj); //得到属性值
Type fieldType =field.getGenericType();//得到属性类型
String fieldName = field.getName(); // 得到属性名
System.out.println("属性类型："+fieldType+",属性名："+fieldName+",属性值："+fieldValue);
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
if(fieldValue != null&&!"".equals(fieldValue)){ //只要有一个属性值不为null 就返回false 表示对象不为null
flag = false;
break;
}
}
return flag;
}
/**
* 判断集合是否为空
* PS：
* 集合为空的条件：
* 1. 集合对象为null
* 2. 集合中没有元素
*
* @param collection 需要进行判断的集合
* @return 为空(true), 不为空(false)
*/
public static boolean isEmpty(Collection<?> collection) {
return null == collection || collection.size() == 0;
}
/**
* 判断对象数组是否为空
* PS：
* 对象数组为空的条件：
* 1. 对象数组为null
* 2. 对象数组中没有元素
*
* @param array 需要进行判断的对象数组
* @return 为空(true), 不为空(false)
*/
public static boolean isEmpty(Object[] array) {
return null == array || array.length == 0;
}
/**
* 判断数组是否为空
* PS：
* 数组为空的条件：
* 1. 数组为null
* 2. 数组中没有元素
*
* @param array 需要进行判断的数组
* @return 为空(true), 不为空(false)
*/
public static boolean isEmpty(long[] array) {
return array == null || array.length == 0;
}
/**
* 判断数组是否为空
* PS：
* 数组为空的条件：
* 1. 数组为null
* 2. 数组中没有元素
*
* @param array 需要进行判断的数组
* @return 为空(true), 不为空(false)
*/
public static boolean isEmpty(int[] array) {
return array == null || array.length == 0;
}
/**
* 判断数组是否为空
* PS：
* 数组为空的条件：
* 1. 数组为null
* 2. 数组中没有元素
*
* @param array 需要进行判断的数组
* @return 为空(true), 不为空(false)
*/
public static boolean isEmpty(short[] array) {
return array == null || array.length == 0;
}
/**
* 判断数组是否为空
* PS：
* 数组为空的条件：
* 1. 数组为null
* 2. 数组中没有元素
*
* @param array 需要进行判断的数组
* @return 为空(true), 不为空(false)
*/
public static boolean isEmpty(char[] array) {
return array == null || array.length == 0;
}
/**
* 判断数组是否为空
* PS：
* 数组为空的条件：
* 1. 数组为null
* 2. 数组中没有元素
*
* @param array 需要进行判断的数组
* @return 为空(true), 不为空(false)
*/
public static boolean isEmpty(byte[] array) {
return array == null || array.length == 0;
}
/**
* 判断数组是否为空
* PS：
* 数组为空的条件：
* 1. 数组为null
* 2. 数组中没有元素
*
* @param array 需要进行判断的数组
* @return 为空(true), 不为空(false)
*/
public static boolean isEmpty(double[] array) {
return array == null || array.length == 0;
}
/**
* 判断数组是否为空
* PS：
* 数组为空的条件：
* 1. 数组为null
* 2. 数组中没有元素
*
* @param array 需要进行判断的数组
* @return 为空(true), 不为空(false)
*/
public static boolean isEmpty(float[] array) {
return array == null || array.length == 0;
}
/**
* 判断数组是否为空
* PS：
* 数组为空的条件：
* 1. 数组为null
* 2. 数组中没有元素
*
* @param array 需要进行判断的数组
* @return 为空(true), 不为空(false)
*/
public static boolean isEmpty(boolean[] array) {
return array == null || array.length == 0;
}
public static boolean isEmpty(Long obj) {
return null==obj;
}
}
common/src/main/java/com/jln/common/utils/FileUtil.java 0 → 100644
package com.jln.common.utils;
import org.springframework.util.ResourceUtils;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
/**
* 上传文件的工具类
*/
public class FileUtil {
private String imgUrL; //服务器储存上传图片地址的前缀
private String getPath;
private String path; //存放的路径,不带具体项目名称
private String QRNAME; //生成二维码文件名
public FileUtil(){}
public FileUtil(HttpServletRequest request, String imgUrL) {
this.QRNAME=BaseUtil.getUuidRp()+".png";
try {
File fileURL=new File(getJarRootPath(),imgUrL);
this.path = fileURL.getAbsolutePath()+File.separator;
} catch (FileNotFoundException e) {
e.printStackTrace();
}
this.imgUrL=imgUrL;
this.getPath=request.getScheme()+"://"+request.getServerName()+":"
+request.getServerPort() + request.getContextPath();
}
/**
* 截取文件类型后缀如:jpg，png
* @return
*/
private String IsFile(MultipartFile file){
String oriName=null;
if(!file.isEmpty()){
oriName = file.getOriginalFilename();
//获取出文件的后缀
int index=oriName.lastIndexOf(".");
oriName=oriName.substring(index);
}
return oriName;
}
/**
* 保存文件工具类，返回文件网络地址
* @return
*/
public String uploadFile(MultipartFile file){
String ImgNmae=BaseUtil.getUUID();
String paths=path+ ImgNmae+IsFile(file);
// System.out.println(paths);
// String updateURL=getPath+imgUrL+"/"+ImgNmae+IsFile(file);
String updateURL=imgUrL+"/"+ImgNmae+IsFile(file);
// String updateURL=paths;
try {
file.transferTo(new File(paths));
return updateURL;
} catch (IOException e) {
e.printStackTrace();
//如果文件夹不存在,则创建一个文件夹
File file2=new File(path);
file2.mkdirs();
try {
file.transferTo(new File(paths));
return updateURL;
} catch (IOException e1) {
e1.printStackTrace();
}
}
return null;
}
/**
* 批量上传文件
*/
public List<String> uploadFile(MultipartFile[] files){
List<String> ImgUrls=new ArrayList<>();
for (MultipartFile file : files) {
String file1 = uploadFile(file);
ImgUrls.add(file1);
}
return ImgUrls;
}
/**
* 删除文件,
* @param URL
* @return
*/
public Boolean deletFile(String URL){
URL = replacementPath(URL);
boolean delete = false;
File file=new File(URL);
if(file.exists()){
delete = file.delete();
}
return delete;
}
/**
* 修改图片的方法
* @param updateUrl 数据库中路径
* @param file 文件对象
* @return 返回替换结果
*/
public void updateFile(String updateUrl, MultipartFile file) throws IOException {
String s = replacementPath(updateUrl); //将路径替换成当前项目的物理路径
file.transferTo(new File(s));
}
/**
* 将数据库中的路径替换成实际项目中的路径
* @return
*/
public String replacementPath(String dataURL){
int index = dataURL.lastIndexOf("/");
if(-1==index){
index=dataURL.lastIndexOf("\\");
}
return path+dataURL.substring(++index);
}
/**
* 处理路径的方法
* @return
* @throws FileNotFoundException
*/
public String getJarRootPath() throws FileNotFoundException {
String path = ResourceUtils.getURL("classpath:").getPath();
File rootFile = new File(path);
if(!rootFile.exists()) {
rootFile = new File("");
}
return rootFile.getAbsolutePath();
}
/**
* 判断后缀是否一致,如果一致就执行替换方法
* @param updateUrl
* @param file
* @return
*/
public Boolean juitSuffix(String updateUrl, MultipartFile file){
String Suffix1 = IsFile(file);
int index1 = updateUrl.lastIndexOf(".");
updateUrl=updateUrl.substring(index1);
return Suffix1.equals(updateUrl);
}
/**
* 获取二维码对应在项目里面的路径
* @return
*/
public String getPath(){
//创建当前文件
String fileURL=this.path+QRNAME;
File file = new File(path);
file.mkdirs();
return fileURL;
}
/**
* 获取项目路径
* @return
*/
public String getGetPath(){
return this.getPath+imgUrL+"/"+QRNAME;
}
/**
* 复制单个文件
* @param srcFileName 待复制的文件名
* @param descFileName 目标文件名
* @param coverlay 如果目标文件已存在，是否覆盖
* @return 如果复制成功，则返回true，否则返回false
*/
public boolean copyFile(String srcFileName,
String descFileName, boolean coverlay) {
File srcFile = new File(srcFileName);
// 判断源文件是否存在
if (!srcFile.exists()) {
return false;
}
// 判断源文件是否是合法的文件
else if (!srcFile.isFile()) {
return false;
}
File descFile = new File(descFileName);
// 判断目标文件是否存在
if (descFile.exists()) {
// 如果目标文件存在，并且允许覆盖
if (coverlay) {
if (!deletFile(descFileName)) {
return false;
}
} else {
return false;
}
} else {
if (!descFile.getParentFile().exists()) {
// 如果目标文件所在的目录不存在，则创建目录
// 创建目标文件所在的目录
if (!descFile.getParentFile().mkdirs()) {
return false;
}
}
}
// 准备复制文件
// 读取的位数
int readByte = 0;
InputStream ins = null;
OutputStream outs = null;
try {
// 打开源文件
ins = new FileInputStream(srcFile);
// 打开目标文件的输出流
outs = new FileOutputStream(descFile);
byte[] buf = new byte[1024];
// 一次读取1024个字节，当readByte为-1时表示文件已经读取完毕
while ((readByte = ins.read(buf)) != -1) {
// 将读取的字节流写入到输出流
outs.write(buf, 0, readByte);
}
return true;
} catch (Exception e) {
return false;
} finally {
// 关闭输入输出流，首先关闭输出流，然后再关闭输入流
if (outs != null) {
try {
outs.close();
} catch (IOException oute) {
oute.printStackTrace();
}
}
if (ins != null) {
try {
ins.close();
} catch (IOException ine) {
ine.printStackTrace();
}
}
}
}
}
common/src/main/java/com/jln/common/utils/GetCode.java 0 → 100644
package com.jln.common.utils;
import com.alibaba.fastjson.JSON;
import com.jln.common.constant.ApiConst;
import com.jln.common.entity.Result;
import com.jln.common.enums.CodeEnum;
import com.jln.common.enums.ResultCodeEnum;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
/**
* 请求成功：返回编码值
* 请求失败：返回-1
* 需要自行判断是否返回成功
*/
public class GetCode {
private static final String KEY = "codeType";
/**
* 调用系统管理接口生成编码
* @return
*/
public static Result<String> getCode(String value){
ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest httpServletRequest = requestAttributes.getRequest();
Map<String, String> map = new HashMap<>(1);
map.put(KEY, value);
String s = HttpClientUtil.doGet(ApiConst.GET_CODE,
map, httpServletRequest.getHeader("api_key"));
Result result = JSON.parseObject(s, Result.class);
if(!result.confirmSuccess()){
return new Result<>().toFailure(ResultCodeEnum.FAILUTE).setMsg(CodeEnum.getDesc(value));
}
return result;
}
}
common/src/main/java/com/jln/common/utils/HttpClient.java 0 → 100644
package com.jln.common.utils;
import org.springframework.http.*;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;
/**
* @author 86180
* @version : HttpClient, v 0.1 2020/3/2 14:14
*/
public class HttpClient {
/**
* 向目的URL发送post请求
* @param url 目的url
* @param params 发送的参数
* @return AdToutiaoJsonTokenData
*/
public static String sendPostRequest(String url, MultiValueMap<String, String> params){
RestTemplate client = new RestTemplate();
//新建Http头，add方法可以添加参数
HttpHeaders headers = new HttpHeaders();
//设置请求发送方式
HttpMethod method = HttpMethod.POST;
// 以表单的方式提交
headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
//将请求头部和参数合成一个请求
HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<>(params, headers);
//执行HTTP请求，将返回的结构使用String 类格式化（可设置为对应返回值格式的类）
ResponseEntity<String> response = client.exchange(url, method, requestEntity,String .class);
return response.getBody();
}
/**
* 向目的URL发送get请求
* @param url 目的url
* @param params 发送的参数
* @param headers 发送的http头，可在外部设置好参数后传入
* @return String
*/
public static String sendGetRequest(String url, MultiValueMap<String, String> params,HttpHeaders headers){
RestTemplate client = new RestTemplate();
HttpMethod method = HttpMethod.GET;
// 以表单的方式提交
headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
//将请求头部和参数合成一个请求
HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<>(params, headers);
//执行HTTP请求，将返回的结构使用String 类格式化
ResponseEntity<String> response = client.exchange(url, method, requestEntity, String.class);
return response.getBody();
}
}
common/src/main/java/com/jln/common/utils/HttpDeleteWithBody.java 0 → 100644
package com.jln.common.utils;
import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
import java.net.URI;
/**
* @ClassName:
* @Description:
* @Author:三刀 Date:2020/1/12 14:15
* Version:1.0
**/
public class HttpDeleteWithBody extends HttpEntityEnclosingRequestBase {
public static final String METHOD_NAME = "DELETE";
public String getMethod() {
return METHOD_NAME;
}
public HttpDeleteWithBody(final String uri) {
super();
setURI(URI.create(uri));
}
public HttpDeleteWithBody(final URI uri) {
super();
setURI(uri);
}
public HttpDeleteWithBody() {
super();
}
}
common/src/main/java/com/jln/common/utils/HttpHelper.java 0 → 100644
package com.jln.common.utils;
import com.alibaba.fastjson.JSONObject;
import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
/**
* 获取接口请求参数值
*/
public class HttpHelper {
public static String getBodyString(HttpServletRequest request) throws IOException {
StringBuilder sb = new StringBuilder();
InputStream inputStream = null;
BufferedReader reader = null;
try {
inputStream = request.getInputStream();
reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
String line = "";
while ((line = reader.readLine()) != null) {
sb.append(line);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return sb.toString();
}
}
common/src/main/java/com/jln/common/utils/HumpUtils.java 0 → 100644
package com.jln.common.utils;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @ClassName:
* @Description:
* @Author:三刀 Date:2020/11/23 19:42
* Version:1.0
**/
public class HumpUtils {
private static Pattern humpPattern = Pattern.compile("[A-Z]");
/** 驼峰转下划线,效率比上面高 */
public static String humpToLine(String str) {
Matcher matcher = humpPattern.matcher(str);
StringBuffer sb = new StringBuffer();
while (matcher.find()) {
matcher.appendReplacement(sb, "_" + matcher.group(0).toLowerCase());
}
matcher.appendTail(sb);
return sb.toString();
}
}
common/src/main/java/com/jln/common/utils/IdGenerator.java 0 → 100644
/*
* Copyright (C), 2018-2018, 深圳点积科技有限公司
* FileName: IdGenerator
* Author: yugo
* Date: 2018/4/27 20:04
* Since: 1.0.0
*/
package com.jln.common.utils;
import lombok.extern.slf4j.Slf4j;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.nio.BufferUnderflowException;
import java.nio.ByteBuffer;
import java.security.SecureRandom;
import java.util.Enumeration;
/**
* id生成器
*
* @author yugo
* @since 1.0.0
* 2018/4/27
*/
@Slf4j
@SuppressWarnings("all")
public enum IdGenerator {
INSTANCE;
/**
* 开始时间截 (2017-01-01)
*/
private final long twepoch = 1609430400L;
private static final int LOW_ORDER_THREE_BYTES = 0x00ffffff;
/**
* 机器ID所占的位数
*/
private final long workerIdBits = 3L;
/**
* 进程标识ID所占的位数
*/
private final long processIdBits = 5L;
/**
* 序列在ID中占的位数
*/
private final long sequenceBits = 5L;
/**
* 机器ID向左移11位 (5+5)
*/
private final long workerIdShift = sequenceBits + processIdBits;
/**
* 进程标识ID向左移5位
*/
private final long processIdShift = sequenceBits;
/**
* 时间截向左移14位(3+5+5)
*/
private final long timestampLeftShift = sequenceBits + workerIdBits + processIdBits;
/**
* 生成序列的掩码，这里为32 (0b111111111111=0xfff=32)
*/
private final long sequenceMask = -1L ^ (-1L << sequenceBits);
/**
* 工作机器ID(0~7)
*/
private static final long WORKER_ID;
/**
* 线程ID(0~31)
*/
private static final long PROCESS_ID;
/**
* 毫秒内序列(0~255)
*/
private long sequence = 0L;
/**
* 上次生成ID的时间截
*/
private long lastTimestamp = -1L;
static {
try {
/*
* 这种计算方式是粗糙的，最好是能根据idc编号和机器编号 代替目前的IP和进程号方案取模运算，但是设定idc编号和机器号需要运维支持
* 目前为了完全不依赖运维，所以采用网卡和进程的方案，还有一点，此方案强依赖系统时间，所以系统时间需一致
*/
WORKER_ID = createIpIdentifier() % 8;
PROCESS_ID = createProcessIdentifier() % 32;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static IdGenerator getInstance() {
return INSTANCE;
}
/**
* 计算线程号
*
* @return long
* @author yugo
* 2018/4/28 09:55
* @since 1.0.0
*/
private static long createProcessIdentifier() {
long processId;
try {
String processName = java.lang.management.ManagementFactory.getRuntimeMXBean()
.getName();
if (processName.contains("@")) {
processId = Long.parseLong(processName.substring(0, processName.indexOf('@')));
} else {
processId = java.lang.management.ManagementFactory.getRuntimeMXBean().getName()
.hashCode();
}
} catch (Throwable t) {
processId = new SecureRandom().nextLong();
log.warn("Failed to get process identifier from JMX, using random number instead", t);
}
return processId;
}
/**
* 计算机网卡
*
* @return long
* @author yugo
* 2018/4/28 09:56
* @since 1.0.0
*/
@Deprecated
private static long createMachineIdentifier() {
long machinePiece;
try {
StringBuilder sb = new StringBuilder();
Enumeration<NetworkInterface> e = NetworkInterface.getNetworkInterfaces();
while (e.hasMoreElements()) {
NetworkInterface ni = e.nextElement();
sb.append(ni.toString());
byte[] mac = ni.getHardwareAddress();
if (mac != null) {
ByteBuffer bb = ByteBuffer.wrap(mac);
try {
sb.append(bb.getChar());
sb.append(bb.getChar());
sb.append(bb.getChar());
} catch (BufferUnderflowException shortHardwareAddressException) { // NOPMD
// mac with less than 6 bytes. continue
}
}
}
machinePiece = sb.toString().hashCode();
} catch (Throwable t) {
// exception sometimes happens with IBM JVM, use random
machinePiece = (new SecureRandom().nextLong());
log.warn(
"Failed to get machine identifier from network interface,using random number instead ",
t);
}
machinePiece = machinePiece & LOW_ORDER_THREE_BYTES;
return machinePiece;
}
/**
* 计算机器ip
*
* @return long
* @author yugo
* 2018/4/28 09:56
* @since 1.0.0
*/
private static long createIpIdentifier() {
long result = 0;
try {
InetAddress address = InetAddress.getLocalHost();
String hostAddress = address.getHostAddress();
String[] ipAddressInArray = hostAddress.split("\\.");
for (int i = 3; i >= 0; i--) {
long ip = Long.parseLong(ipAddressInArray[3 - i]);
result |= ip << (i * 8);
}
} catch (Throwable t) {
result = (new SecureRandom().nextLong());
log.warn(
"Failed to get machine identifier from network interface, using random number instead",
t);
}
return result;
}
/**
* 获得下一个ID
*
* @return long
* @author yugo
* 2018/4/28 09:56
* @since 1.0.0
*/
public synchronized Long nextId() {
long timestamp = timeGen();
// 如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
if (timestamp < lastTimestamp) {
throw new RuntimeException(String.format(
"Clock moved backwards. Refusing to generate id for %d milliseconds",
lastTimestamp - timestamp));
}
// 如果是同一时间生成的，则进行毫秒内序列
if (lastTimestamp == timestamp) {
sequence = (sequence + 1) & sequenceMask;
// 毫秒内序列溢出
if (sequence == 0) {
// 阻塞到下一个毫秒,获得新的时间戳
timestamp = tilNextMillis(lastTimestamp);
}
}
// 时间戳改变，毫秒内序列重置
else {
sequence = 0L;
}
// 上次生成ID的时间截
lastTimestamp = timestamp;
// 移位并通过或运算拼到一起组成64位的ID
Long id = ((timestamp - twepoch) << timestampLeftShift)
| (WORKER_ID << workerIdShift)
| (PROCESS_ID << processIdShift)
| sequence;
if (id < 0) {
throw new RuntimeException(
String.format("Id generate error for %d milliseconds", lastTimestamp - timestamp));
}
return id;
}
/**
* 阻塞到下一个毫秒，直到获得新的时间戳
*
* @param lastTimestamp 上次的时间戳
* @return long
* @author yugo
* 2018/4/28 09:57
* @since 1.0.0
*/
protected long tilNextMillis(long lastTimestamp) {
long timestamp = timeGen();
while (timestamp <= lastTimestamp) {
timestamp = timeGen();
}
return timestamp;
}
/**
* 返回以毫秒为单位的当前时间
*
* @return long
* @author yugo
* 2018/4/28 09:57
* @since 1.0.0
*/
protected long timeGen() {
return System.currentTimeMillis();
}
}
common/src/main/java/com/jln/common/utils/IpUtils.java 0 → 100644
package com.jln.common.utils;
import javax.servlet.http.HttpServletRequest;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
* @author 86180
* @version : IpUtils, v 0.1 2020/1/14 18:09
*/
public class IpUtils {
public static String getIpAddr(HttpServletRequest request)
{
if (request == null)
{
return "unknown";
}
String ip = request.getHeader("x-forwarded-for");
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
{
ip = request.getHeader("Proxy-Client-IP");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
{
ip = request.getHeader("X-Forwarded-For");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
{
ip = request.getHeader("WL-Proxy-Client-IP");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
{
ip = request.getHeader("X-Real-IP");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
{
ip = request.getRemoteAddr();
}
return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
}
public static boolean Ip(String ip)
{
byte[] addr = textToNumericFormatV4(ip);
return Ip(addr) || "127.0.0.1".equals(ip);
}
private static boolean Ip(byte[] addr)
{
if (StringUtils.isNull(addr) || addr.length < 2)
{
return true;
}
final byte b0 = addr[0];
final byte b1 = addr[1];
// 10.x.x.x/8
final byte SECTION_1 = 0x0A;
// 172.16.x.x/12
final byte SECTION_2 = (byte) 0xAC;
final byte SECTION_3 = (byte) 0x10;
final byte SECTION_4 = (byte) 0x1F;
// 192.168.x.x/16
final byte SECTION_5 = (byte) 0xC0;
final byte SECTION_6 = (byte) 0xA8;
switch (b0)
{
case SECTION_1:
return true;
case SECTION_2:
if (b1 >= SECTION_3 && b1 <= SECTION_4)
{
return true;
}
case SECTION_5:
switch (b1)
{
case SECTION_6:
return true;
}
default:
return false;
}
}
/**
* 将IPv4地址转换成字节
*
* @param text IPv4地址
* @return byte 字节
*/
public static byte[] textToNumericFormatV4(String text)
{
if (text.length() == 0)
{
return null;
}
byte[] bytes = new byte[4];
String[] elements = text.split("\\.", -1);
try
{
long l;
int i;
switch (elements.length)
{
case 1:
l = Long.parseLong(elements[0]);
if ((l < 0L) || (l > 4294967295L))
return null;
bytes[0] = (byte) (int) (l >> 24 & 0xFF);
bytes[1] = (byte) (int) ((l & 0xFFFFFF) >> 16 & 0xFF);
bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
bytes[3] = (byte) (int) (l & 0xFF);
break;
case 2:
l = Integer.parseInt(elements[0]);
if ((l < 0L) || (l > 255L))
return null;
bytes[0] = (byte) (int) (l & 0xFF);
l = Integer.parseInt(elements[1]);
if ((l < 0L) || (l > 16777215L))
return null;
bytes[1] = (byte) (int) (l >> 16 & 0xFF);
bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
bytes[3] = (byte) (int) (l & 0xFF);
break;
case 3:
for (i = 0; i < 2; ++i)
{
l = Integer.parseInt(elements[i]);
if ((l < 0L) || (l > 255L))
return null;
bytes[i] = (byte) (int) (l & 0xFF);
}
l = Integer.parseInt(elements[2]);
if ((l < 0L) || (l > 65535L))
return null;
bytes[2] = (byte) (int) (l >> 8 & 0xFF);
bytes[3] = (byte) (int) (l & 0xFF);
break;
case 4:
for (i = 0; i < 4; ++i)
{
l = Integer.parseInt(elements[i]);
if ((l < 0L) || (l > 255L))
return null;
bytes[i] = (byte) (int) (l & 0xFF);
}
break;
default:
return null;
}
}
catch (NumberFormatException e)
{
return null;
}
return bytes;
}
public static String getHostIp()
{
try
{
return InetAddress.getLocalHost().getHostAddress();
}
catch (UnknownHostException e)
{
}
return "127.0.0.1";
}
public static String getHostName()
{
try
{
return InetAddress.getLocalHost().getHostName();
}
catch (UnknownHostException e)
{
}
return "未知";
}
}
common/src/main/java/com/jln/common/utils/JacksonUtil.java 0 → 100644
package com.jln.common.utils;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.codehaus.commons.nullanalysis.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.util.List;
import java.util.Map;
/**
* @ClassName: Jackson 序列化反序列化对象，数组，map工具类
* @Description:
* @Author:三刀 Date:2020/8/14 15:43
* Version:1.0
**/
public class JacksonUtil {
public static final ObjectMapper mapper = new ObjectMapper();
private static final Logger logger = LoggerFactory.getLogger(JacksonUtil.class);
/**
* 对象转json
* @param obj 这里支持 对象，集合 map 类型都可以
* @return
*/
@Nullable
public static String toString(Object obj) {
if (obj == null) {
return null;
}
if (obj.getClass() == String.class) {
return (String) obj;
}
try {
return mapper.writeValueAsString(obj);
} catch (JsonProcessingException e) {
logger.error("json序列化出错：" + obj, e);
return null;
}
}
/**
* json 序列化成对像，只支持序列化回对象不支持数组
* @param json josn 字符串
* @param tClass 对象的类型
* @param <T> 泛型
* @return
*/
@Nullable
public static <T> T toBean(String json, Class<T> tClass) {
try {
return mapper.readValue(json, tClass);
} catch (IOException e) {
logger.error("json解析出错：" + json, e);
return null;
}
}
/**
* json数组转集合 不支持转对象
* @param json json数组
* @param eClass 数组里面的对象
* @param <E> 泛型
* @return
*/
@Nullable
public static <E> List<E> toList(String json, Class<E> eClass) {
try {
return mapper.readValue(json, mapper.getTypeFactory().constructCollectionType(List.class, eClass));
} catch (IOException e) {
logger.error("json解析出错：" + json, e);
return null;
}
}
/**
* json 对象转map
* @param json json 对象转map
* @param kClass 键类型
* @param vClass 值类型
* @param <K>
* @param <V>
* @return
*/
@Nullable
public static <K, V> Map<K, V> toMap(String json, Class<K> kClass, Class<V> vClass) {
try {
return mapper.readValue(json, mapper.getTypeFactory().constructMapType(Map.class, kClass, vClass));
} catch (IOException e) {
logger.error("json解析出错：" + json, e);
return null;
}
}
@Nullable
public static <T> T nativeRead(String json, TypeReference<T> type) {
try {
return mapper.readValue(json, type);
} catch (IOException e) {
logger.error("json解析出错：" + json, e);
return null;
}
}
}
common/src/main/java/com/jln/common/utils/JsonUtils.java 0 → 100644
package com.jln.common.utils;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
/**
* @ClassName: 将实体类在控制台上打印成JSON格式工具类
* @Description:
* @Author:三刀 Date:2020/1/9 9:58
* Version:1.0
**/
public class JsonUtils {
public static String toJson(Object obj) {
Gson gson = new GsonBuilder()
.setPrettyPrinting()
.create();
return gson.toJson(obj);
}
}
common/src/main/java/com/jln/common/utils/JwtUtils.java 0 → 100644
package com.jln.common.utils;
/**
* @ClassName:
* @Description:
* @Author:三刀 Date:2020/9/16 11:28
* Version:1.0
**/
//@ConfigurationProperties(prefix = "renren.jwt")
//@Component
public class JwtUtils {
/* private Logger logger = LoggerFactory.getLogger(getClass());
*//**
* Token过期时间保存枚举
*//*
public final static String USER_KEY="Oid";
private String secret;
private long expire;
private String header;
*//**
* 功能描述 : 加密用户id生成token
* @param: key 字符串 用户id
* @return: java.lang.String
*//*
*//**
* 生成jwt token
*//*
public String generateToken(Long userId) {
Date nowDate = new Date();
//过期时间
Date expireDate = new Date(nowDate.getTime() + expire * 1000);
return Jwts.builder()
.setHeaderParam("typ", "JWT")
.setSubject(userId+"")
.setIssuedAt(nowDate)
.setExpiration(expireDate)
.signWith(SignatureAlgorithm.HS512, secret)
.compact();
}
public Claims getClaimByToken(String token) {
try {
return Jwts.parser()
.setSigningKey(secret)
.parseClaimsJws(token)
.getBody();
}catch (Exception e){
logger.debug("validate is token error ", e);
return null;
}
}
*//**
* token是否过期
* @return true：过期
*//*
public boolean isTokenExpired(Date expiration) {
return expiration.before(new Date());
}
public String getSecret() {
return secret;
}
public void setSecret(String secret) {
this.secret = secret;
}
public long getExpire() {
return expire;
}
public void setExpire(long expire) {
this.expire = expire;
}
public String getHeader() {
return header;
}
public void setHeader(String header) {
this.header = header;
}*/
}
common/src/main/java/com/jln/common/utils/MD5Tool.java 0 → 100644
package com.jln.common.utils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.security.Key;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Base64;
@PropertySource("classpath:common.properties")
@Component
public class MD5Tool {
//向量(同时拥有向量和密匙才能解密)，此向量必须是8byte，多少都报错
private final byte[] DESIV = new byte[] { 0x22, 0x54, 0x36, 110, 0x40, (byte) 0xac, (byte) 0xad, (byte) 0xdf };// 向量
private AlgorithmParameterSpec iv = null;// 加密算法的参数接口
private Key key = null;
private String charset = "utf-8";
public String getSecret() {
return Secret;
}
public void setSecret(String secret) throws Exception {
Secret = secret;
DESKeySpec keySpec = new DESKeySpec(secret.getBytes(this.charset));// 设置密钥参数
iv = new IvParameterSpec(DESIV);// 设置向量
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");// 获得密钥工厂
key = keyFactory.generateSecret(keySpec);// 得到密钥对象
}
@Value("${md5.secret}")
private String Secret;
/**
* 功能描述 :生成密钥
* @param: deSkey 自定义密钥
* @param: charset 编码
* @throws :
*/
public void setkey(String deSkey, String charset) throws Exception {
if (StringUtils.isNotBlank(charset)) {
this.charset = charset;
}
}
// /**
// * 构造函数
// * @param deSkey
// * @param charset
// * @throws Exception
// */
// public MD5Tool(String deSkey, String charset) throws Exception {
// if (StringUtils.isNotBlank(charset)) {
// this.charset = charset;
// }
// DESKeySpec keySpec = new DESKeySpec(deSkey.getBytes(this.charset));// 设置密钥参数
// iv = new IvParameterSpec(DESIV);// 设置向量
// SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");// 获得密钥工厂
// key = keyFactory.generateSecret(keySpec);// 得到密钥对象
// }
// public static void main(String[] args) {
// try {
// String value = "123456";
// String key = "gidea2019";// 自定义密钥,个数不能太短，太短报错，过长，它默认只取前N位（N的具体值，大家另行查找资料）
// MD5Tool mt= new MD5Tool(key, "utf-8");
// System.out.println("加密前的字符：" + value);
// System.out.println("加密后的字符：" + mt.encode(value));
// System.out.println("解密后的字符：" + mt.decode(mt.encode(value)));
// System.out.println("字符串的MD5值："+getMD5Value(value));
// } catch (Exception e) {
// e.printStackTrace();
// }
// }
/**
* 加密
* @param data
* @return
* @throws Exception
*/
public String encode(String data) throws Exception {
Cipher enCipher = Cipher.getInstance("DES/CBC/PKCS5Padding");// 得到加密对象Cipher
enCipher.init(Cipher.ENCRYPT_MODE, key, iv);// 设置工作模式为加密模式，给出密钥和向量
byte[] pasByte = enCipher.doFinal(data.getBytes(this.charset));
Base64.Encoder encoder = Base64.getEncoder();
return encoder.encodeToString(pasByte);
}
/**
* 解密
* @param data
* @return
* @throws Exception
*/
public String decode(String data) throws Exception {
Cipher deCipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
deCipher.init(Cipher.DECRYPT_MODE, key, iv);
Base64.Decoder decoder = Base64.getDecoder();
//此处注意doFinal()的参数的位数必须是8的倍数，否则会报错（通过encode加密的字符串读出来都是8的倍数位，但写入文件再读出来，就可能因为读取的方式的问题，导致最后此处的doFinal()的参数的位数不是8的倍数）
//此处必须用base64Decoder，若用data。getBytes()则获取的字符串的byte数组的个数极可能不是8的倍数，而且不与上面的BASE64Encoder对应（即使解密不报错也不会得到正确结果）
byte[] pasByte = deCipher.doFinal(decoder.decode(data));
return new String(pasByte, this.charset);
}
/**
* 获取MD5的值，可用于对比校验
* @param sourceStr
* @return
*/
private static String getMD5Value(String sourceStr) {
String result = "";
try {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(sourceStr.getBytes());
byte b[] = md.digest();
int i;
StringBuffer buf = new StringBuffer("");
for (int offset = 0; offset < b.length; offset++) {
i = b[offset];
if (i < 0)
i += 256;
if (i < 16)
buf.append("0");
buf.append(Integer.toHexString(i));
}
result = buf.toString();
} catch (NoSuchAlgorithmException e) {
}
return result;
}
}
common/src/main/java/com/jln/common/utils/PageParameter.java 0 → 100644
package com.jln.common.utils;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
/**
* @ClassName: 分页参数
* @Description:
* @Author:三刀 Date:2020/1/14 10:34
* Version:1.0
**/
@Data
public class PageParameter<T> implements Serializable {
@ApiModelProperty(value = "当前页", example = "1")
private Integer pageNum=1; //当前页
@ApiModelProperty(value = "每页显示几条", example = "10")
private Integer pageSize=10; //每页显示几条
private T data; //查询条件
public Integer getPageNum() {
return pageNum;
}
public void setPageNum(Integer pageNum) {
this.pageNum = pageNum;
}
public Integer getPageSize() {
return pageSize;
}
public void setPageSize(Integer pageSize) {
this.pageSize = pageSize;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
common/src/main/java/com/jln/common/utils/PropertiesLoader.java 0 → 100644
package com.jln.common.utils;
/*
@author 86180
* @version : PropertiesLoader, v 0.1 2019/12/10 17:34
*/
import org.apache.commons.io.IOUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;
import java.util.Properties;
public class PropertiesLoader {
private static Logger logger = LoggerFactory.getLogger(PropertiesLoader.class);
private static ResourceLoader resourceLoader = new DefaultResourceLoader();
private final Properties properties;
public PropertiesLoader(String... resourcesPaths) {
this.properties = this.loadProperties(resourcesPaths);
}
public Properties getProperties() {
return this.properties;
}
private String getValue(String key) {
String systemProperty = System.getProperty(key);
if (systemProperty != null) {
return systemProperty;
} else {
return this.properties.containsKey(key) ? this.properties.getProperty(key) : "";
}
}
public String getProperty(String key) {
String value = this.getValue(key);
if (value == null) {
throw new NoSuchElementException();
} else {
return value;
}
}
public String getProperty(String key, String defaultValue) {
String value = this.getValue(key);
return value != null ? value : defaultValue;
}
public Integer getInteger(String key) {
String value = this.getValue(key);
if (value == null) {
throw new NoSuchElementException();
} else {
return Integer.valueOf(value);
}
}
public Integer getInteger(String key, Integer defaultValue) {
String value = this.getValue(key);
return value != null ? Integer.valueOf(value) : defaultValue;
}
public Double getDouble(String key) {
String value = this.getValue(key);
if (value == null) {
throw new NoSuchElementException();
} else {
return Double.valueOf(value);
}
}
public Double getDouble(String key, Integer defaultValue) {
String value = this.getValue(key);
return value != null ? Double.valueOf(value) : (double)defaultValue;
}
public Boolean getBoolean(String key) {
String value = this.getValue(key);
if (value == null) {
throw new NoSuchElementException();
} else {
return Boolean.valueOf(value);
}
}
public Boolean getBoolean(String key, boolean defaultValue) {
String value = this.getValue(key);
return value != null ? Boolean.valueOf(value) : defaultValue;
}
private Properties loadProperties(String... resourcesPaths) {
Properties props = new Properties();
String[] var3 = resourcesPaths;
int var4 = resourcesPaths.length;
for(int var5 = 0; var5 < var4; ++var5) {
String location = var3[var5];
System.out.println(location);
InputStream is = null;
try {
Resource resource = resourceLoader.getResource(location);
is = resource.getInputStream();
props.load(is);
} catch (IOException var12) {
logger.info("Could not load properties from path:" + location + ", " + var12.getMessage());
} finally {
IOUtils.closeQuietly(is);
}
}
return props;
}
}
common/src/main/java/com/jln/common/utils/PropertiesUtil.java 0 → 100644
package com.jln.common.utils;
import com.google.common.collect.Maps;
import java.util.Map;
/**
* @author 86180
* @version : PropertiesUtil, v 0.1 2020/1/31 10:52
*/
public class PropertiesUtil {
private static Map<String, String> map = Maps.newHashMap();
private static PropertiesLoader loader = new PropertiesLoader(new String[]{"application-utils.properties"});
public static String getConfig(String key) {
String value = map.get(key);
if (value == null) {
value = loader.getProperty(key);
map.put(key, value != null ? value : "");
}
return value;
}
public static Boolean isDebug() {
String debug = getConfig("web.debug");
return "true".equals(debug);
}
}
common/src/main/java/com/jln/common/utils/RegularUtil.java 0 → 100644
package com.jln.common.utils;
import org.springframework.stereotype.Component;
/**
* @ClassName: 正则表达式工具类
* @Description:
* @Author: liyunlong
* @Date: 2020/11/12 15:21
* @version: 1.0
*/
@Component
public class RegularUtil {
/* POSTCODE("^[0-9]{6}$","邮编正则"),
FAX("^(?:\\d{3,4}-)?\\d{7,8}(?:-\\d{1,6})?$", "传真正则"),
PHONE_NUMBER("^([1]\\d{10}|([\\(（]?0[0-9]{2,3}[）\\)]?[-]?)?([2-9][0-9]{6,7})+(\\-[0-9]{1,4})?)$", "电话号码正则表达式"),
TFN("[0-9A-HJ-NPQRTUWXY]{2}\\d{6}[0-9A-HJ-NPQRTUWXY]{10}", "税收正则表达式"),
Bank_Account("^([1-9]{1})(\\d{14}|\\d{18})$", "银行账号正则表达式"),
;*/
private static String POSTCODE="^[0-9]{6}$";
private static String FAX="^(?:\\d{3,4}-)?\\d{7,8}(?:-\\d{1,6})?$";
private static String PHONE_NUMBER="^([1]\\d{10}|([\\(（]?0[0-9]{2,3}[）\\)]?[-]?)?([2-9][0-9]{6,7})+(\\-[0-9]{1,4})?)$";
private static String TFN="^[0-9A-HJ-NPQRTUWXY]{2}\\d{6}[0-9A-HJ-NPQRTUWXY]{10}";
private static String Bank_Account="^([1-9]{1})(\\d{14}|\\d{18})$";
public static String POSTCODE(){
return POSTCODE;
}
public static String FAX() {
return FAX;
}
public static String PHONE_NUMBER(){
return PHONE_NUMBER;
}
public static String TFN(){
return TFN;
}
public static String Bank_Account(){
return Bank_Account;
}
}
common/src/main/java/com/jln/common/utils/SnowflakeIdUtils.java 0 → 100644
package com.jln.common.utils;
/**
* @ClassName: 雪花算法生成ID
* @Description:
* @Author:三刀 Date:2020/9/15 15:05
* Version:1.0
**/
public class SnowflakeIdUtils {
public static Long generate(){
String classname = new Exception().getStackTrace()[1].getClassName();
//SnowflakeIdWorker worker = new SnowflakeIdWorker(12, 230L);
return UniqueIdGenerator.getInstance().genUniqueId(classname);
}
}
common/src/main/java/com/jln/common/utils/SnowflakeIdWorker.java 0 → 100644
package com.jln.common.utils;
/**
* Twitter_Snowflake<br>
* SnowFlake的结构如下(每部分用-分开):<br>
* 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 <br>
* 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0<br>
* 41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截)
* 得到的值），这里的的开始时间截，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下下面程序IdWorker类的startTime属性）。41位的时间截，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69<br>
* 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId<br>
* 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号<br>
* 加起来刚好64位，为一个Long型。<br>
* SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。
*/
public class SnowflakeIdWorker {
// ==============================Fields===========================================
/** 开始时间截 (2015-01-01) */
private final long twepoch = 1420041600000L;
/** 机器id所占的位数 */
private final long workerIdBits = 5L;
/** 数据标识id所占的位数 */
private final long datacenterIdBits = 5L;
/** 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */
private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
/** 支持的最大数据标识id，结果是31 */
private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
/** 序列在id中占的位数 */
private final long sequenceBits = 12L;
/** 机器ID向左移12位 */
private final long workerIdShift = sequenceBits;
/** 数据标识id向左移17位(12+5) */
private final long datacenterIdShift = sequenceBits + workerIdBits;
/** 时间截向左移22位(5+5+12) */
private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
/** 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095) */
private final long sequenceMask = -1L ^ (-1L << sequenceBits);
/** 工作机器ID(0~31) */
private long workerId;
/** 数据中心ID(0~31) */
private long datacenterId;
/** 毫秒内序列(0~4095) */
private long sequence = 0L;
/** 上次生成ID的时间截 */
private long lastTimestamp = -1L;
//==============================Constructors=====================================
/**
* 构造函数
* @param workerId 工作ID (0~31)
* @param datacenterId 数据中心ID (0~31)
*/
public SnowflakeIdWorker(long workerId, long datacenterId) {
if (workerId > maxWorkerId || workerId < 0) {
throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
}
if (datacenterId > maxDatacenterId || datacenterId < 0) {
throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
}
this.workerId = workerId;
this.datacenterId = datacenterId;
}
// ==============================Methods==========================================
/**
* 获得下一个ID (该方法是线程安全的)
* @return SnowflakeId
*/
public synchronized long nextId() {
long timestamp = timeGen();
//如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
if (timestamp < lastTimestamp) {
throw new RuntimeException(
String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
}
//如果是同一时间生成的，则进行毫秒内序列
if (lastTimestamp == timestamp) {
sequence = (sequence + 1) & sequenceMask;
//毫秒内序列溢出
if (sequence == 0) {
//阻塞到下一个毫秒,获得新的时间戳
timestamp = tilNextMillis(lastTimestamp);
}
}
//时间戳改变，毫秒内序列重置
else {
sequence = 0L;
}
//上次生成ID的时间截
lastTimestamp = timestamp;
//移位并通过或运算拼到一起组成64位的ID
return ((timestamp - twepoch) << timestampLeftShift) //
| (datacenterId << datacenterIdShift) //
| (workerId << workerIdShift) //
| sequence;
}
/**
* 阻塞到下一个毫秒，直到获得新的时间戳
* @param lastTimestamp 上次生成ID的时间截
* @return 当前时间戳
*/
protected long tilNextMillis(long lastTimestamp) {
long timestamp = timeGen();
while (timestamp <= lastTimestamp) {
timestamp = timeGen();
}
return timestamp;
}
/**
* 返回以毫秒为单位的当前时间
* @return 当前时间(毫秒)
*/
protected long timeGen() {
return System.currentTimeMillis();
}
public static Long getSnowflakeId(){
SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
return idWorker.nextId();
}
}
\ No newline at end of file
mqttservice/src/main/java/com/jln/system/web/action/mqtt/Base64decrypt.java 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
pom.xml 0 → 100644
差异被折叠。 点击展开。
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论