Skip to content

G
GatewaywithDynamicRoute
Commit c239a771 authored by zhang 张号彬's avatar zhang 张号彬
Browse files
Options

gateway动态路由配置

parents
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 4602 additions and 0 deletions
.gitignore 0 → 100644
View file @ c239a771
HELP.md
target/
!.mvn/wrapper/maven-wrapper.jar
!**/src/main/**
!**/src/test/**
### STS ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
### IntelliJ IDEA ###
.idea
*.iws
*.iml
*.ipr
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
build/
logs/
/target/
### VS Code ###
.vscode/
/mvnw
/mvnw.cmd
/.mvn/
/fin/src/main/resources/config/application-local.yml
/.gradle/
/gradle/
gradlew
gradlew.bat
/core/build/
/interface/build/
/ecar-ningda/build/
/ecar-ningda/logs/
/fin/logs/
/demo/logs/
logs/
*.log
README.md 0 → 100644
View file @ c239a771
This diff is collapsed.
build.gradle 0 → 100644
View file @ c239a771
group 'com.elitesland'
version '1.0-SNAPSHOT'
buildscript {
ext {
springBootVersion = '2.3.5.RELEASE'
}
repositories {
maven { url 'https://maven.aliyun.com/repository/public/' }
mavenCentral()
}
dependencies {
/* 添加插件依赖路径（通过jar方式） */
classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}" as Object)
}
}
subprojects {
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
apply plugin: 'java'
apply plugin: 'idea'
group = 'com.elitesland'
version = '1.0-SNAPSHOT'
sourceCompatibility = '11'
[compileJava, compileTestJava, javadoc]*.options*.encoding = 'UTF-8'
repositories {
maven { url 'https://maven.aliyun.com/repository/public/' }
maven {
url 'https://mvn.elitescloud.com/nexus/repository/maven-private/'
credentials {
username 'dev'
password 'BhModSEAxmz3492k'
}
}
mavenCentral()
}
ext {
set('springCloudAlibabaVersion', "2.2.4.RELEASE")
set('springCloudVersion', "Hoxton.SR9")
}
dependencyManagement {
imports {
mavenBom "com.alibaba.cloud:spring-cloud-alibaba-dependencies:${springCloudAlibabaVersion}"
mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
}
}
configurations {
compile.exclude module: 'spring-boot-starter-tomcat'
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
implementation 'org.springframework.boot:spring-boot-starter-jdbc'
implementation 'org.springframework.boot:spring-boot-starter-data-redis'
// https://mvnrepository.com/artifact/com.alibaba.cloud/spring-cloud-starter-alibaba-sentinel
implementation group: 'com.alibaba.cloud', name: 'spring-cloud-starter-alibaba-sentinel'
// https://mvnrepository.com/artifact/org.redisson/redisson
// 分布式锁
// https://mvnrepository.com/artifact/org.redisson/redisson-spring-boot-starter
implementation group: 'org.redisson', name: 'redisson-spring-boot-starter', version: '3.14.0'
implementation 'org.springframework.boot:spring-boot-starter-security'
implementation 'org.springframework.boot:spring-boot-starter-web'
testCompile 'org.springframework.boot:spring-boot-starter-test'
implementation 'org.springframework.boot:spring-boot-starter-undertow'
implementation 'org.springframework.boot:spring-boot-starter-validation'
developmentOnly 'org.springframework.boot:spring-boot-devtools'
runtimeOnly 'mysql:mysql-connector-java'
implementation 'com.zaxxer:HikariCP:3.4.5'
implementation 'org.apache.shardingsphere:sharding-jdbc-spring-boot-starter:4.1.1'
implementation 'org.apache.shardingsphere:sharding-jdbc-spring-namespace:4.1.1'
annotationProcessor 'org.springframework.boot:spring-boot-configuration-processor'
compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'
implementation 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'
testImplementation('org.springframework.boot:spring-boot-starter-test') {
exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
}
testImplementation 'io.projectreactor:reactor-test'
testImplementation 'org.springframework.security:spring-security-test'
implementation 'cn.hutool:hutool-all:5.3.7'
implementation 'org.apache.commons:commons-lang3:3.10'
implementation 'commons-codec:commons-codec:1.14'
implementation 'org.apache.commons:commons-collections4:4.4'
implementation 'org.mapstruct:mapstruct:1.4.1.Final'
annotationProcessor 'org.mapstruct:mapstruct-processor:1.4.1.Final'
implementation 'io.vavr:vavr:0.10.2'
implementation 'com.auth0:java-jwt:3.9.0'
//querydsl
implementation 'com.querydsl:querydsl-core:4.3.1'
implementation 'com.querydsl:querydsl-jpa:4.3.1'
annotationProcessor('com.querydsl:querydsl-apt:4.3.1:jpa',
'org.springframework.boot:spring-boot-starter-data-jpa')
implementation 'io.springfox:springfox-swagger2:3.0.0'
implementation 'com.github.xiaoymin:swagger-bootstrap-ui:1.9.6'
implementation 'com.alibaba:easyexcel:2.2.6'
implementation 'com.github.whvcse:easy-captcha:1.6.2'
implementation 'com.baomidou:mybatis-plus-boot-starter:3.3.2'
implementation 'eu.bitwalker:UserAgentUtils:1.21'
implementation 'io.jsonwebtoken:jjwt-api:0.11.2'
implementation 'io.jsonwebtoken:jjwt-impl:0.11.2'
implementation 'io.jsonwebtoken:jjwt-jackson:0.11.2'
implementation 'com.google.code.gson:gson:2.8.6'
implementation 'org.springframework.kafka:spring-kafka:2.6.2'
implementation 'commons-beanutils:commons-beanutils:1.9.4'
implementation 'org.apache.cxf:cxf-spring-boot-starter-jaxws:3.4.0'
implementation 'com.github.wxpay:wxpay-sdk:0.0.3'
implementation 'com.alipay.sdk:alipay-sdk-java:4.10.170.ALL'
// implementation 'com.elitesland:yst-workflow-flowable:1.1.9' //工作流
//Spring Cloud Alibaba Nacos & Dubbo
implementation 'com.alibaba.cloud:spring-cloud-starter-alibaba-nacos-config'
implementation 'com.alibaba.cloud:spring-cloud-starter-alibaba-nacos-discovery'
implementation('com.alibaba.cloud:spring-cloud-starter-dubbo'){
exclude group: 'org.springframework.cloud', module: 'spring-cloud-openfeign-core'
}
implementation 'org.apache.dubbo:dubbo-serialization-kryo:2.7.8'
implementation 'com.squareup.okhttp3:okhttp:3.4.1'
implementation 'com.squareup.okhttp:okhttp:2.7.4' //和府发票接口
implementation 'com.github.binarywang:weixin-java-cp:3.9.0' //微信接口 第三方开源工具包
implementation "log4j:log4j:1.2.17"
}
test {
useJUnitPlatform()
}
}
gradle.properties 0 → 100644
View file @ c239a771
org.gradle.jvmargs=-Xmx4096M
settings.gradle 0 → 100644
View file @ c239a771
rootProject.name = 'yst-yd-core'
include 'yst-aftersales'
include 'yst-base-auth'
include 'yst-base-gateway'
include 'yst-base-sso'
include 'yst-common'
include 'yst-core'
include 'yst-demo'
include 'yst-masterdata'
include 'yst-itm'
include 'yst-sale'
include 'yst-user'
include 'yst-inv'
include 'yst-pur'
include 'yst-pric'
include 'yst-dis'
include 'yst-crm'
yst-base-gateway/Dockerfile 0 → 100644
View file @ c239a771
FROM dperezcabrera/openjdk11-alpine
VOLUME /tmp
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
ENV ACTIVE=$ACTIVE
ENV JAVA_OPTS=$JAVA_OPTS
ENTRYPOINT [ "sh", "-c", "java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.jar --spring.profiles.active=$ACTIVE" ]
#ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar","--spring.profiles.active=$ACTIVE"]
\ No newline at end of file
yst-base-gateway/README.md 0 → 100644
View file @ c239a771
# SpringCloud GateWay 实现路由动态路由
- [ ] **需求背景**
在我们项目开发中，SpringCloud作为一款优秀的微服务架构和解决方案，使用率还是挺高的，其中使用GateWay来实现网关路由分发、负载均衡等功能，
当然还可以利用GateWay来实现限流（比如RateLimter令牌桶算法等，也可搭载Sentinel来实现更细颗粒度的限流控制）、灰度发布、请求过滤处理等
功能，由于这些不在本项目示例范围内，故不做相应的展开说明。而使用GateWay实现网关路由分发功能，一般通过两种方式来进行配置：
1. 在GateWay的配置文件中配置路由规则（这是常用的方式），如下图所示：
![配置文件配置路由规则](images/gateway静态路由规则配置方法.png)
2. 代码方式，通过代码方式在SpringContext中注入RouteLocator这个Bean，来实现路由规则的加载，如图所示：
![code方式配置路由规则](images/代码方式配置gateway路由规则.png)
但是这两种方式只是在项目启动时初始化bean时加载RouteDefinition，若路由规则发生改变时候需要重启Gateway实例后方可重新加载新配置的路由规则。
这就很难满足我们项目中的一些动态化的配置需求，尤其saas平台下多租户的应用和后端微服务实例为物理隔离的单独部署方式，灵活多变的部署方式带来网关路由
规则的多样性和动态化，因此本人做了此gateway网关动态路由规则配置的项目示例。
- [ ] **路由规则加载原理**
gateway网关程序在启动时，配置在配置文件或者代码中的路由信息会加载到内存中，路由信息被封装到RouteDefinition对象中，通过RouteDefinitionLocator接口来实现
实现类来进行控制。配置文件中的配置信息是通过PropertiesRouteDefinitionLocator来进行加载。代码中的路由配置信息则是通过RouteLocatorBuilder构建出RouteLocator
实例来加载。
RouteDefinition主要由id、uri以及断言、过滤器等信息构成。
RouteDefinitionRepository接口继承了RouteDefinitionLocator接口和RouteDefinitionWriter接口，故该接口具有RouteDefinition的查询、保存与删除等功能，默认使用InMemoryRouteDefinitionRepository类。
而ApplicationEventPublisher实现RouteDefinition信息变动的发布与更新等操作，因此要实现路由规则动态加载（即热加载），只要我们使用RouteDefinitionWriter接口来实现RouteDefinition的增删功能，并使用ApplicationEventPublisher
完成RouteDefinition信息变动的发布即可。
- [ ] **动态路由实现方法*
1.实现ApplicationEventPublisherAware接口，通过setApplicationEventPublisher方法获取ApplicationEventPublisher实例，并通过ApplicationEventPublisher
实现RouteDefinition变更的事件发布操作。
2.通过在我们自己定义的ApplicationEventPublisherAware实现类中注入RouteDefinitionWriter接口（RouteDefinitionRepository接口继承了RouteDefinitionWriter）,实现RouteDefinition的增删功能（修改功能也是通过增删功能来实现的）。
3.对于单实例网关，通过本地操作可以实现本地路由信息的动态更新，但由于我们在项目中一般会根据项目情况部署多个网关实例，因此需要多个网关实例同步刷新配置信息方可。
对此本人想了三种方案：
1）在配置文件中配置所有的网关实例部署的地址（在nacos中配置也可），然后调用每个网关实例中暴露出来的路由信息刷新接口进行相应的操作，这种方法比较笨重，淘汰。
2）通过消息队列的广播模式，每个网关实例作为消费端消费推送过来的路由信息进行本地更新操作。该方法由于需要借助第三方MQ，所以使用起来也不方便，淘汰。
3）利用nacos的监听机制，每个网关实例监听到nacos server中配置信息的变动后进行本地化路由信息的刷新，由于nacos在我们yd等项目中已经作为服务发现和配置中心，因此此方案最佳
也是本项目中所采纳的方案。
- [ ] **动态路由实现步骤（重点）**
1.路由规则动态配置架构如下：
![路由规则动态配置架构图](images/路由规则动态配置架构图.png)
2.执行过程逻辑
1）运维人员通过Nacos Server管理后台或我们自己平台管理后端（平台管理后端通过调用网关实例中RouteController暴露出来Rest API接口实现nacos server上路由动态配置信息的管理操作）来新增、修改、删除网关路由规则配置信息。
2）在gateway上注册NacosConfigLisenter监听（在自定义NacosConfigListener类getConfig方法中），监听nacos Server上网关路由配置信息的变化情况。当配置信息发生变化时，会执行本地网关实例中路由配置信息的更新
操作（在自定义NacosConfigListener类getConfig方法中调用的refreshLocalRoute方法进行操作）。
3）在refreshLocalRoute方法中进行本地路由配置信息更新前，要先从内存中将已配置的路由信息删除完毕后再进行执行新增路由配置信息的操作。并在操作完成后
将更新过的RouteDefinition的信息存入本地，以便后面出现新的更新情况下，先执行删除操作。
3.程序实现步骤：
1）引入模块如下：
![依赖类库](images/引入依赖类库.png)
2）添加配置信息：其中dataId和group信息是我们在nacos config上的配置坐标。
![添加配置信息](images/添加配置信息.png)
3）代码结构如下：
![醒目结构图](images/项目结构图.png)
4）bean包下定义了三个类，其中GatewayRouteDefinition类是程序对外暴露的数据结构，GatewayFilterDefinition是GatewayRouteDefinition中
过滤器的描述类，GatewayPredicateDefinition是GatewayRouteDefinition中断言的描述类，GatewayRouteDefinition除此外还包含id、uri、order等信息。
5）service包下有两个类：
#### DynamicRouteService
该类实现了ApplicationEventPublisherAware接口，在此类中setApplicationEventPublisher方法获得
ApplicationEventPublisher接口的实例，并通过该实例可以操作路由配置信息的事件刷新。同时DynamicRouteService还注入了RouteDefinitionWriter接口。
RouteDefinitionWriter接口被InMemoryRouteDefinitionRepository的接口类RouteDefinitionRepository所继承，因此可以在DynamicRouteService
中使用RouteDefinitionWriter接口来实现路由规则配置信息的增删等功能。
#### GatewayRoutesInNacosConfigService
该类主要封装了对Nacos Config的一些操作方法。主要提供给RouteController来进行调用，比较简单，不做过多介绍。
6） util包下的GateWayNacosUtils类主要封装了获取ConfigService实例、从nacos server中获取route规则配置信息等操作。
7）config包下的NacosConfigListener类
#### GatewayRoutesInNacosConfigService
该类实现了CommandLineRunner接口，在网关实例启动后被执行，该类中最重要的就是getConfig方法，该方法实现了网关实例启动后初始化网关路由配置信息，并注册一个
nacos监听，当nacos server上网关路由配置信息发生变更时，执行了refreshLocalRoute方法，该方法主要逻辑是首先要先删除网关实例内存中已经加载的配置信息，然后
根据nacos server同步过来变更后的路由规则信息进行本地新增操作并发布加载到gateway工作内存中。
8）controller包下的RouteController类主要封装了对nacos config server中网关路由信息的新增、查询、删除等操作的Rest API。
9）路由定义规则配置信息说明
#### yml中路由的配置信息
```spring:
cloud:
gateway:
routes:
- id: zz00001 # demo 中心路由
uri: lb://zz00001 #应用服务名称可以使用店铺编码
predicates:
- Path=/mdxt/**
- Header=orgCode,zz00001 #例如可根据店铺编码设置header 当客户端发request请求时携带orgCode=zz00001 则满足此规则，反之则不符合此路由规则
filters:
- RewritePath=/mdxt/(?<segment>.*),/$\{segment}
```
### 调用Rest API进行网关路由配置，数据结构如下
POST: /route/addOrUpdate 请求体为json格式的requestBody
```
{
"filters":[
{"args":{
"_genkey_0": "/mdxt/(?<segment>.*)",
"_genkey_1": "/${segment}"
},
"name":"RewritePath"
}],
"id":"zz00001",
"order":0,
"predicates":[
{"args":{
"_genkey_0":"/mdxt/**"
},
"name":"Path"
},{"args":{
"_genkey_0":"orgCode",
"_genkey_1": "zz00001"
},
"name":"Header"
}],
"uri":"lb://zz00001"
}
```
#### 在nacos webui中添加和管理网关配置信息
如果在nacos webui中添加网关配置信息，则需要用‘[ ]’将json数据体包起来，如下：
```
[{
"filters":[
{"args":{
"_genkey_0": "/mdxt/(?<segment>.*)",
"_genkey_1": "/${segment}"
},
"name":"RewritePath"
}],
"id":"zz00001",
"order":0,
"predicates":[
{"args":{
"_genkey_0":"/mdxt/**"
},
"name":"Path"
},{"args":{
"_genkey_0":"orgCode",
"_genkey_1": "zz00001"
},
"name":"Header"
}],
"uri":"lb://zz00001"
}]
```
### 测试demo模块中/demo/nativesql接口 通过网关访问http://localhost:9040/mdxt/demo/nativesql
![网关测试](images/postman通过gateway访问demo模块.png)
\ No newline at end of file
yst-base-gateway/build.gradle 0 → 100644
View file @ c239a771
plugins {
id 'com.palantir.docker' version '0.25.0'
}
archivesBaseName = 'yst-base-gateway'
//库存中心
group 'com.elitesland'
version '1.0-SNAPSHOT'
bootJar.enabled = true
configurations {
compile.exclude module: 'sharding-jdbc-spring-boot-starter'
compile.exclude module: 'sharding-jdbc-spring-namespace'
compile.exclude module: 'spring-boot-starter-starter'
compile.exclude module: 'spring-cloud-starter-dubbo'
compile.exclude module: 'spring-boot-starter-security'
compile.exclude module: 'redisson-spring-boot-starter'
compile.exclude module: 'spring-boot-starter-web'
compile.exclude module: 'spring-webmvc'
}
dependencies {
testCompile group: 'junit', name: 'junit', version: '4.12'
// implementation project(':yst-common')
// implementation project(':yst-core')
// https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-gateway
implementation 'com.alibaba.cloud:spring-cloud-starter-alibaba-nacos-config'
implementation group: 'org.springframework.cloud', name: 'spring-cloud-starter-gateway'
// compile group: 'org.springframework.boot', name: 'spring-boot-starter-webflux'
compile group: 'org.springframework.boot', name: 'spring-boot-starter-actuator'
// https://mvnrepository.com/artifact/com.alibaba.cloud/spring-cloud-alibaba-sentinel-gateway
// implementation group: 'com.alibaba.cloud', name: 'spring-cloud-alibaba-sentinel-gateway'
// https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-webflux
}
jar {
manifest {
attributes(
'Main-Class': 'com.elitesland.YstGatewayApplication'
)
}
}
docker {
name = "elitesland/${project.archivesBaseName}:${project.version}" //发布到harbor的镜像名称
dockerfile file("Dockerfile")
copySpec.from(jar).rename(".*", "app.jar")
buildArgs(['JAR_FILE': "app.jar"])
}
yst-base-gateway/src/main/java/com/elitesland/YstGatewayApplication.java 0 → 100644
View file @ c239a771
package com.elitesland;
import com.elitesland.router.config.NacosConfigListener;
import com.elitesland.router.service.DynamicRouteService;
import com.elitesland.router.util.GateWayNacosUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Bean;
/**
* <p>
* 功能说明
* </p >
*
* @author Roman.Zhang
* @date 2021/1/29
*/
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
@EnableDiscoveryClient
public class YstGatewayApplication {
public static void main(String[] args) throws Exception {
SpringApplication.run(YstGatewayApplication.class, args);
}
}
yst-base-gateway/src/main/java/com/elitesland/exception/config/ErrorHandlerConfiguration.java 0 → 100644
View file @ c239a771
//package com.elitesland.gateway.config;
///*
// *@Author Horbin.Zhang
// *@Date 2021-02-10 10:05
// *@Description
// */
//
//import com.elitesland.exception.GlobalExceptionHandler;
//import org.springframework.beans.factory.ObjectProvider;
//import org.springframework.boot.autoconfigure.web.ResourceProperties;
//import org.springframework.boot.autoconfigure.web.ServerProperties;
//import org.springframework.boot.context.properties.EnableConfigurationProperties;
//import org.springframework.boot.web.reactive.error.ErrorAttributes;
//import org.springframework.boot.web.reactive.error.ErrorWebExceptionHandler;
//import org.springframework.context.ApplicationContext;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.core.Ordered;
//import org.springframework.core.annotation.Order;
//import org.springframework.http.codec.ServerCodecConfigurer;
//import org.springframework.web.reactive.result.view.ViewResolver;
//
//import java.util.Collections;
//import java.util.List;
//
//@Configuration
//@EnableConfigurationProperties({ServerProperties.class, ResourceProperties.class})
//public class ErrorHandlerConfiguration {
// private final ServerProperties serverProperties;
//
// private final ApplicationContext applicationContext;
//
// private final ResourceProperties resourceProperties;
//
// private final List<ViewResolver> viewResolvers;
//
// private final ServerCodecConfigurer serverCodecConfigurer;
// public ErrorHandlerConfiguration(ServerProperties serverProperties,
// ResourceProperties resourceProperties,
// ObjectProvider<List<ViewResolver>> viewResolversProvider,
// ServerCodecConfigurer serverCodecConfigurer,
// ApplicationContext applicationContext) {
// this.serverProperties = serverProperties;
// this.applicationContext = applicationContext;
// this.resourceProperties = resourceProperties;
// this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
// this.serverCodecConfigurer = serverCodecConfigurer;
// }
// @Bean
// @Order(Ordered.HIGHEST_PRECEDENCE)
// public ErrorWebExceptionHandler errorWebExceptionHandler(ErrorAttributes errorAttributes) {
// GlobalExceptionHandler exceptionHandler = new GlobalExceptionHandler(
// errorAttributes,
// this.resourceProperties,
// this.serverProperties.getError(),
// this.applicationContext);
// exceptionHandler.setViewResolvers(this.viewResolvers);
// exceptionHandler.setMessageWriters(this.serverCodecConfigurer.getWriters());
// exceptionHandler.setMessageReaders(this.serverCodecConfigurer.getReaders());
// return exceptionHandler;
// }
//
//}
yst-base-gateway/src/main/java/com/elitesland/exception/handler/GlobalExceptionHandler.java 0 → 100644
View file @ c239a771
//package com.elitesland.exception;
//
//import java.time.LocalDateTime;
//import java.util.HashMap;
//import java.util.Map;
//
//import com.elitesland.core.base.ApiCode;
//import com.elitesland.core.base.ApiResult;
//import org.springframework.boot.autoconfigure.web.ErrorProperties;
//import org.springframework.boot.autoconfigure.web.ResourceProperties;
//import org.springframework.boot.autoconfigure.web.reactive.error.DefaultErrorWebExceptionHandler;
//import org.springframework.boot.web.reactive.error.ErrorAttributes;
//import org.springframework.context.ApplicationContext;
//import org.springframework.http.HttpStatus;
//import org.springframework.web.reactive.function.server.RequestPredicates;
//import org.springframework.web.reactive.function.server.RouterFunction;
//import org.springframework.web.reactive.function.server.RouterFunctions;
//import org.springframework.web.reactive.function.server.ServerRequest;
//import org.springframework.web.reactive.function.server.ServerResponse;
//import springfox.documentation.spring.web.scanners.ApiListingReferenceScanResult;
//
///*
// *@Author Horbin.Zhang
// *@Date 2021-02-10 9:02
// *@Description
// */
//
//public class GlobalExceptionHandler extends DefaultErrorWebExceptionHandler {
//
// public GlobalExceptionHandler(ErrorAttributes errorAttributes, ResourceProperties resourceProperties,
// ErrorProperties errorProperties, ApplicationContext applicationContext) {
// super(errorAttributes, resourceProperties, errorProperties, applicationContext);
// }
//
// /**
// * 获取异常属性
// */
// @Override
// protected Map<String, Object> getErrorAttributes(ServerRequest request, boolean includeStackTrace) {
// int code = 500;
// Throwable error = super.getError(request);
// if (error instanceof org.springframework.cloud.gateway.support.NotFoundException) {
// code = 404;
// }
// ApiResult<Object> result = ApiResult.fail(ApiCode.getApiCode(code), error.getMessage());
// return ApiResult.toMap(result);
// }
//
// /**
// * 指定响应处理方法为JSON处理的方法
// * @param errorAttributes
// */
// @Override
// protected RouterFunction<ServerResponse> getRoutingFunction(ErrorAttributes errorAttributes) {
// return RouterFunctions.route(RequestPredicates.all(), this::renderErrorResponse);
// }
//
// @Override
// protected int getHttpStatus(Map<String, Object> errorAttributes) {
// int statusCode = (int) errorAttributes.get("code");
// return statusCode;
// }
//
//}
\ No newline at end of file
yst-base-gateway/src/main/java/com/elitesland/gateway/config/CORSConfig.java 0 → 100644
View file @ c239a771
package com.elitesland.gateway.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.reactive.CorsWebFilter;
import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource;
/**
* <p>
* 功能说明
* </p >
*
* @author Roman.Zhang
* @date 2021/1/29
*/
@Configuration
public class CORSConfig {
@Bean
public CorsWebFilter corsWebFilter() {
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
CorsConfiguration corsConfiguration = new CorsConfiguration();
corsConfiguration.addAllowedHeader("*");
corsConfiguration.addAllowedMethod("*");
corsConfiguration.addAllowedOrigin("*");
corsConfiguration.setAllowCredentials(true);
source.registerCorsConfiguration("/**", corsConfiguration);
return new CorsWebFilter(source);
}
}
yst-base-gateway/src/main/java/com/elitesland/gateway/config/SentinelGatewayConfig.java 0 → 100644
View file @ c239a771
//package com.elitesland.gateway.config;
//
//import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.GatewayCallbackManager;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.web.reactive.function.server.ServerResponse;
//import reactor.core.publisher.Mono;
//
///**
// * <p>
// * 功能说明
// * </p >
// *
// * @author Roman.Zhang
// * @date 2021/1/29
// */
//@Configuration
//public class SentinelGatewayConfig {
//
// public SentinelGatewayConfig() {
// GatewayCallbackManager.setBlockHandler(((exchange, t) -> {
//// ApiResul error = R.error(BizCodeEnum.TOO_MANY_REQUESTS.getCode(), BizCodeEnum.TOO_MANY_REQUESTS.getMsg());
//// String jsonString = JSON.toJSONString(error);
// // Mono<ServerResponse> body = ServerResponse.ok().body(Mono.just(jsonString), String.class);
// return ServerResponse.ok().body(Mono.just(""), String.class);
// }));
// }
//
//}
yst-base-gateway/src/main/java/com/elitesland/router/bean/GatewayFilterDefinition.java 0 → 100644
View file @ c239a771
package com.elitesland.router.bean;
import lombok.Data;
import java.util.LinkedHashMap;
import java.util.Map;
/*
*@Author Horbin.Zhang
*@Date 2021-02-10 19:23
*@Description 网关过滤器定义类，定义路由规则
*/
@Data
public class GatewayFilterDefinition {
//Filter Name
private String name;
//对应的路由规则
private Map<String, String> args = new LinkedHashMap<>();
}
\ No newline at end of file
yst-base-gateway/src/main/java/com/elitesland/router/bean/GatewayPredicateDefinition.java 0 → 100644
View file @ c239a771
package com.elitesland.router.bean;
import lombok.Data;
import java.util.LinkedHashMap;
import java.util.Map;
/*
*@Author Horbin.Zhang
*@Date 2021-02-10 19:23
*@Description 网关断言定义类 定义网关断言规则
*/
@Data
public class GatewayPredicateDefinition {
//断言对应的Name
private String name;
//配置的断言规则
private Map<String, String> args = new LinkedHashMap<>();
}
\ No newline at end of file
yst-base-gateway/src/main/java/com/elitesland/router/bean/GatewayRouteDefinition.java 0 → 100644
View file @ c239a771
package com.elitesland.router.bean;
import lombok.Data;
import java.util.ArrayList;
/*
*@Author Horbin.Zhang
*@Date 2021-02-10 19:21
*@Description 路由定义类，封装了路由的全局Id、断言集合、过滤器集合配置、转发uri以及执行顺序等
*/
@Data
public class GatewayRouteDefinition{
//路由的Id
private String id;
//路由断言集合配置
private ArrayList<GatewayPredicateDefinition> predicates = new ArrayList<>();
//路由过滤器集合配置
private ArrayList<GatewayFilterDefinition> filters = new ArrayList<>();
//路由规则转发的目标uri
private String uri;
//路由执行的顺序
private int order = 0;
//此处省略get和set方法
}
\ No newline at end of file
yst-base-gateway/src/main/java/com/elitesland/router/config/NacosConfigListener.java 0 → 100644
View file @ c239a771
package com.elitesland.router.config;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.config.listener.Listener;
import com.elitesland.router.bean.GatewayFilterDefinition;
import com.elitesland.router.bean.GatewayPredicateDefinition;
import com.elitesland.router.bean.GatewayRouteDefinition;
import com.elitesland.router.service.DynamicRouteService;
import com.elitesland.router.util.GateWayNacosUtils;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.cloud.gateway.filter.FilterDefinition;
import org.springframework.cloud.gateway.handler.predicate.PredicateDefinition;
import org.springframework.cloud.gateway.route.InMemoryRouteDefinitionRepository;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.stereotype.Component;
import org.springframework.web.util.UriComponentsBuilder;
import reactor.core.publisher.Flux;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Executor;
/*
*@Author Horbin.Zhang
*@Date 2021-02-12 19:47
*@Description 注册nacos监听，该类实现CommandLineRunner接口
*/
@Component
public class NacosConfigListener implements CommandLineRunner {
@Autowired
private GateWayNacosUtils gateWayNacosUtils;
@Autowired
private DynamicRouteService dynamicRouteService;
@Autowired
private InMemoryRouteDefinitionRepository inMemoryRouteDefinitionRepository;
//由于可能根据需要在定时任务中引用该list，因此使用线程安全的SynchronizedListlist
public static List<GatewayRouteDefinition> list = Collections.synchronizedList(new ArrayList<>());
@Override
public void run(String... args) {
getConfig();
}
private void getConfig() {
try {
String routeDefinitions = gateWayNacosUtils.getRouteDefinitionsFromNacosServer();
ConfigService configService = gateWayNacosUtils.getNacosConfigService();
Gson gson = new Gson();
//注册nacos配置监听，当nacos配置信息发生改变时刷新本地内存中Gateway Route规则信息
refreshLocalRoute(routeDefinitions, gson,true);
String group = gateWayNacosUtils.getNacosConfigGroup();
String routeConfigDataId = gateWayNacosUtils.getNacosConfigDataIdForGateWayDefinition();
configService.addListener(routeConfigDataId, group, new Listener() {
@Override
public void receiveConfigInfo(String configInfo) {
System.out.println(configInfo+"------->");
refreshLocalRoute(configInfo, gson,false);
}
@Override
public Executor getExecutor() {
return null;
}
});
} catch (Exception e) {
getConfig();
e.printStackTrace();
}
}
/**
* 根据nacos配置信息，刷新本地Gateway RouteDefinition
*/
private void refreshLocalRoute(String initConfigInfo, Gson gson, boolean t) {
//删除内存中已存在的动态路由配置信息
if(list.size() > 0){
list.forEach(gatewayRouteDefinition -> {
dynamicRouteService.delete(gatewayRouteDefinition.getId());
});
list = Collections.synchronizedList(new ArrayList<>());
}
JsonArray jsonArray = gson.fromJson(initConfigInfo, JsonArray.class);
jsonArray.forEach(routeDefinitionAsJsonObject -> {
GatewayRouteDefinition gatewayRouteDefinition = gson.fromJson(routeDefinitionAsJsonObject, GatewayRouteDefinition.class);
RouteDefinition definition = convertRouteDefinition(gatewayRouteDefinition);
dynamicRouteService.add(definition);
list.add(gatewayRouteDefinition);
});
}
/**
* 根据前端参数封装路由对象
*/
private RouteDefinition convertRouteDefinition(GatewayRouteDefinition gwdefinition) {
RouteDefinition definition = new RouteDefinition();
definition.setId(gwdefinition.getId());
definition.setOrder(gwdefinition.getOrder());
//设置断言
ArrayList<PredicateDefinition> pdList = new ArrayList<>();
ArrayList<GatewayPredicateDefinition> gatewayPredicateDefinitionList = gwdefinition.getPredicates();
gatewayPredicateDefinitionList.forEach(gpDefinition -> {
PredicateDefinition predicate = new PredicateDefinition();
predicate.setArgs(gpDefinition.getArgs());
predicate.setName(gpDefinition.getName());
pdList.add(predicate);
});
definition.setPredicates(pdList);
//设置过滤器
ArrayList<FilterDefinition> filters = new ArrayList();
ArrayList<GatewayFilterDefinition> gatewayFilters = gwdefinition.getFilters();
gatewayFilters.forEach(filterDefinition -> {
FilterDefinition filter = new FilterDefinition();
filter.setName(filterDefinition.getName());
filter.setArgs(filterDefinition.getArgs());
filters.add(filter);
});
definition.setFilters(filters);
URI uri = null;
if (gwdefinition.getUri().startsWith("http")) {
uri = UriComponentsBuilder.fromHttpUrl(gwdefinition.getUri()).build().toUri();
} else {
uri = URI.create(gwdefinition.getUri());
}
definition.setUri(uri);
return definition;
}
}
yst-base-gateway/src/main/java/com/elitesland/router/controller/RouteController.java 0 → 100644
View file @ c239a771
package com.elitesland.router.controller;
import com.elitesland.router.bean.GatewayRouteDefinition;
import com.elitesland.router.service.DynamicRouteService;
import com.elitesland.router.service.GatewayRoutesInNacosConfigService;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.config.PropertiesRouteDefinitionLocator;
import org.springframework.cloud.gateway.route.InMemoryRouteDefinitionRepository;
import org.springframework.cloud.gateway.route.Route;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import java.util.ArrayList;
/*
*@Author Horbin.Zhang
*@Date 2021-02-10 19:17
*@Description
* http://localhost:9040/actuator/gateway/routes 通过acutator查询route配置信息
* 在生产环境中配置信息将通过redis进行查询及持久化操作
*/
@RestController
@RequestMapping("/route")
public class RouteController {
@Autowired
private GatewayRoutesInNacosConfigService gatewayRoutesInNacosConfigService;
@Autowired
PropertiesRouteDefinitionLocator PropertiesRouteDefinitionLocator;
@Autowired
private DynamicRouteService dynamicRouteService;
/**
*增加路由
*/
@PostMapping("/addOrUpdate")
public GatewayRouteDefinition addOrUpdate(@RequestBody GatewayRouteDefinition gwdefinition) {
return gatewayRoutesInNacosConfigService.addOrUpdateRouteDefinitiToNacosServer(gwdefinition);
}
/**
*删除路由
*/
@DeleteMapping("/routes/{id}")
public String delete(@PathVariable String id) {
return gatewayRoutesInNacosConfigService.deleteRouteDefinitiToNacosServer(id);
}
/**
* 获取nacos里配置的动态路由配置信息
* */
@GetMapping("/routes/all")
public Flux<ArrayList<GatewayRouteDefinition>> all() {
Gson g = new Gson();
ArrayList<GatewayRouteDefinition> list = new ArrayList<>();
JsonArray gatewayDefinitionsFromNacosServer = gatewayRoutesInNacosConfigService.getGatewayDefinitionsFromNacosServer();
gatewayDefinitionsFromNacosServer.forEach(o ->{
GatewayRouteDefinition gatewayRouteDefinition = g.fromJson(o, GatewayRouteDefinition.class);
list.add(gatewayRouteDefinition);
});
return Flux.just(list);
}
/**
* 获取本地所有的动态路由配置信息
* */
@GetMapping("/all")
public Flux<RouteDefinition> all1() {
Flux<RouteDefinition> routeDefinitions = PropertiesRouteDefinitionLocator.getRouteDefinitions();
routeDefinitions.subscribe();
return routeDefinitions;
}
}
\ No newline at end of file
yst-base-gateway/src/main/java/com/elitesland/router/service/DynamicRouteService.java 0 → 100644
View file @ c239a771
package com.elitesland.router.service;
import com.elitesland.router.util.GateWayNacosUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.RouteDefinitionWriter;
import org.springframework.cloud.gateway.support.NotFoundException;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Mono;
import java.util.ArrayList;
/*
*@Author Horbin.Zhang
*@Date 2021-02-10 19:29
*@Description 路由增改删查服务类
*/
@Service
public class DynamicRouteService implements ApplicationEventPublisherAware {
@Autowired
private GateWayNacosUtils gateWayNacosUtils;
@Autowired
private RouteDefinitionWriter routeDefinitionWriter;
private ApplicationEventPublisher publisher;
private ArrayList<String> routeIdInMemory = new ArrayList<>();
@Override
public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
this.publisher = applicationEventPublisher;
}
/**
* 增加路由
*/
public String add(RouteDefinition definition) {
routeDefinitionWriter.save(Mono.just(definition)).subscribe();
this.publisher.publishEvent(new RefreshRoutesEvent(this));
return "删除成功！";
}
/**
* 删除路由
*/
public String delete(String id) {
Mono<ResponseEntity<Object>> responseEntityMono = this.routeDefinitionWriter.delete(Mono.just(id)).then(Mono.defer(() -> {
return Mono.just(ResponseEntity.ok().build());
})).onErrorResume((t) -> {
return t instanceof NotFoundException;
}, (t) -> {
return Mono.just(ResponseEntity.notFound().build());
});
responseEntityMono.subscribe();
this.publisher.publishEvent(new RefreshRoutesEvent(this));
return "删除成功！";
}
}
\ No newline at end of file
yst-base-gateway/src/main/java/com/elitesland/router/service/GatewayRoutesInNacosConfigService.java 0 → 100644
View file @ c239a771
package com.elitesland.router.service;
import com.alibaba.nacos.api.config.ConfigService;
import com.elitesland.router.bean.GatewayRouteDefinition;
import com.elitesland.router.util.GateWayNacosUtils;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.config.PropertiesRouteDefinitionLocator;
import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
import org.springframework.cloud.gateway.route.CachingRouteDefinitionLocator;
import org.springframework.cloud.gateway.route.InMemoryRouteDefinitionRepository;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.RouteDefinitionRepository;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.stereotype.Service;
import reactor.core.Disposable;
import reactor.core.publisher.Flux;
import java.util.List;
/*
*@Author Horbin.Zhang
*@Date 2021-02-12 14:17
*@Description
*/
@Service
public class GatewayRoutesInNacosConfigService {
@Autowired
private GateWayNacosUtils gateWayNacosUtils;
@Autowired
org.springframework.cloud.gateway.config.PropertiesRouteDefinitionLocator propertiesRouteDefinitionLocator;
@Autowired
private DynamicRouteService dynamicRouteService;
RouteLocatorBuilder routeLocatorBuilder;
public GatewayRouteDefinition addOrUpdateRouteDefinitiToNacosServer(GatewayRouteDefinition gwdefinition) {
try {
//清除静态配置路由信息中存在的动态路由信息
// Flux<RouteDefinition> routeDefinitions = propertiesRouteDefinitionLocator.getRouteDefinitions();
// routeDefinitions.subscribe( routeDefinition ->{
// if (routeDefinition.getId().equalsIgnoreCase(gwdefinition.getId())) {
// System.out.println(routeDefinition.getId()+"++++++++++++++++++++++++++++++++++++++++++========");
// dynamicRouteService.delete(routeDefinition.getId());
// }
// });
Gson gson = new Gson();
String gateWayDefinitions = gateWayNacosUtils.getRouteDefinitionsFromNacosServer();
boolean flag = false;
if (null != gateWayDefinitions) {
JsonArray jsonArray = gson.fromJson(gateWayDefinitions, JsonArray.class);
JsonArray newConfig = new JsonArray();
if (jsonArray.size() > 0) {
jsonArray.forEach(routeDefinitionAsJsonObject -> {
GatewayRouteDefinition gatewayRouteDefinition = gson.fromJson(routeDefinitionAsJsonObject, GatewayRouteDefinition.class);
if (null != gatewayRouteDefinition) {
if (!gatewayRouteDefinition.getId().equalsIgnoreCase(gwdefinition.getId())) {
newConfig.add(routeDefinitionAsJsonObject);
}
}
});
}
JsonElement jsonElement = gson.toJsonTree(gwdefinition, GatewayRouteDefinition.class);
newConfig.add(jsonElement);
ConfigService configService = gateWayNacosUtils.getNacosConfigService();
String group = gateWayNacosUtils.getNacosConfigGroup();
String routeConfigDataId = gateWayNacosUtils.getNacosConfigDataIdForGateWayDefinition();
configService.publishConfig(routeConfigDataId, group, newConfig.toString(), "json");
}
} catch (Exception e) {
e.printStackTrace();
}
return gwdefinition;
}
public String deleteRouteDefinitiToNacosServer(String routeId) {
try {
Gson gson = new Gson();
String gateWayDefinitions = gateWayNacosUtils.getRouteDefinitionsFromNacosServer();
if (null != gateWayDefinitions) {
JsonArray jsonArray = gson.fromJson(gateWayDefinitions, JsonArray.class);
JsonArray newConfig = new JsonArray();
if (jsonArray.size() > 0) {
jsonArray.forEach(routeDefinitionAsJsonObject -> {
GatewayRouteDefinition gatewayRouteDefinition = gson.fromJson(routeDefinitionAsJsonObject, GatewayRouteDefinition.class);
if (null != gatewayRouteDefinition) {
if (!gatewayRouteDefinition.getId().equalsIgnoreCase(routeId)) {
newConfig.add(routeDefinitionAsJsonObject);
}
}
});
}
ConfigService configService = gateWayNacosUtils.getNacosConfigService();
String group = gateWayNacosUtils.getNacosConfigGroup();
String routeConfigDataId = gateWayNacosUtils.getNacosConfigDataIdForGateWayDefinition();
configService.publishConfig(routeConfigDataId, group, newConfig.toString(), "json");
}
return "删除成功！";
} catch (Exception e) {
e.printStackTrace();
return "删除失败！";
}
}
public JsonArray getGatewayDefinitionsFromNacosServer() {
JsonArray jsonArrayOfJsonGatewayDefinitions = null;
try {
Gson gson = new Gson();
String gateWayDefinitions = gateWayNacosUtils.getRouteDefinitionsFromNacosServer();
if (null != gateWayDefinitions) {
jsonArrayOfJsonGatewayDefinitions = gson.fromJson(gateWayDefinitions, JsonArray.class);
}
} catch (Exception e) {
e.printStackTrace();
}
return jsonArrayOfJsonGatewayDefinitions;
}
}
yst-base-gateway/src/main/java/com/elitesland/router/util/GateWayNacosUtils.java 0 → 100644
View file @ c239a771
package com.elitesland.router.util;
import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.config.ConfigService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.util.Properties;
/*
*@Author Horbin.Zhang
*@Date 2021-02-12 16:29
*@Description
*/
@Component
public class GateWayNacosUtils {
@Value("${spring.cloud.nacos.config.server-addr}")
private String serverAddr;
@Value("${gateway.nacos.routeinfo.group}")
private String group;
@Value("${gateway.nacos.routeinfo.dataid}")
private String routeConfigDataId;
public String getRouteDefinitionsFromNacosServer() throws Exception{
ConfigService configService = getNacosConfigService();
String initConfigInfo = configService.getConfig(routeConfigDataId, group, 5000);
return initConfigInfo;
}
public ConfigService getNacosConfigService() throws Exception{
Properties properties = new Properties();
properties.put("serverAddr", serverAddr);
ConfigService configService = NacosFactory.createConfigService(properties);
return configService;
}
public String getNacosConfigGroup(){
return this.group;
}
public String getNacosConfigDataIdForGateWayDefinition(){
return this.routeConfigDataId;
}
}
yst-base-gateway/src/main/resources/application-dev.yml 0 → 100644
View file @ c239a771
spring:
shardingsphere:
dataSource:
names: yst-nrp2
yst-nrp2:
type: com.zaxxer.hikari.HikariDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
jdbcUrl: jdbc:mysql://frps.elitescloud.com:25148/yst_yddb?useUnicode=true&characterEncoding=utf8&tinyInt1isBit=false&useSSL=false&serverTimezone=GMT
username: root
password: 123456
maxPoolSize: 20
# db-test1:
# type: com.zaxxer.hikari.HikariDataSource
# driver-class-name: com.mysql.cj.jdbc.Driver
# jdbcUrl: jdbc:mysql://127.0.0.1:3308/cool?useUnicode=true&characterEncoding=utf8&tinyInt1isBit=false&useSSL=false&serverTimezone=GMT
# username: root
# password: slavepwd
# maxPoolSize: 20
# db-test2:
# type: com.zaxxer.hikari.HikariDataSource
# driver-class-name: com.mysql.cj.jdbc.Driver
# jdbcUrl: jdbc:mysql://127.0.0.1:3309/cool?useUnicode=true&characterEncoding=utf8&tinyInt1isBit=false&useSSL=false&serverTimezone=GMT
# username: root
# password: slave1pwd
# maxPoolSize: 20
# sharding:
# master-slave-rules:
# ds0:
# master-data-source-name: db-test0
# slave-data-source-names: db-test1, db-test2
# load-balance-algorithm-type: ROUND_ROBIN
props:
sql:
show: true
jpa:
database: mysql
database-platform: org.hibernate.dialect.MySQL8Dialect
show-sql: true
hibernate:
ddl-auto: update
naming:
physical-strategy: org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy
open-in-view: false
cloud:
gateway:
# discovery:
# locator:
# enabled: true
routes:
# # 雅迪前端工程
# - id: yst-yd-web
# uri: http://192.168.0.210:82
# predicates:
# - Path=/yst-yd/**
#
# - id: product_route # 商品中心路由
# uri: lb://yst-itm
# predicates:
# - Path=/ystyd/itm/**
# filters:
# - RewritePath=/ystyd/(?<segment>.*),/$\{segment}
- id: user_route # 用户中心路由
uri: lb://yst-user
predicates:
- Path=/ystyd/user/**
filters:
- RewritePath=/ystyd/(?<segment>.*),/$\{segment}
# - id: zz00001 # demo 中心路由
# uri: lb://zz00001
# predicates:
# - Path=/mdxt/**
# - Header=orgCode,zz00001
# filters:
# - RewritePath=/mdxt/(?<segment>.*),/$\{segment}
nacos:
discovery:
server-addr: frps.elitescloud.com:25145
# enabled: true
# register-enabled: true
gateway:
nacos:
routeinfo:
dataid: gateway.routeinfo.json
group: DEFAULT_GROUP
# 内部端点暴露
management:
endpoints:
web:
exposure:
include: '*'
endpoint:
health:
show-details: always
# datasource:
# url: jdbc:mysql://frps.elitescloud.com:25148/jyj_fc?rewriteBatchedStatements=true&serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false&allowPublicKeyRetrieval=true&nullCatalogMeansCurrent=true
# username: root
# password: 123456
# tomcat:
# ignore-exception-on-pre-load:
jwt:
header: Authorization
# 令牌前缀
token-start-with: Bearer
# 必须使用最少88位的Base64对该令牌进行编码
base64-secret: ZmQ0ZGI5NjQ0MDQwY2I4MjMxY2Y3ZmI3MjdhN2ZmMjNhODViOTg1ZGE0NTBjMGM4NDA5NzYxMjdjOWMwYWRmZTBlZjlhNGY3ZTg4Y2U3YTE1ODVkZDU5Y2Y3OGYwZWE1NzUzNWQ2YjFjZDc0NGMxZWU2MmQ3MjY1NzJmNTE0MzI=
# 令牌过期时间 此处单位/毫秒 ，默认4小时，可在此网站生成 https://www.convertworld.com/zh-hans/time/milliseconds.html
token-validity-in-seconds: 14400000
# 在线用户key
online-key: online-token-
# 验证码
code-key: code-key-
# token 续期检查时间范围（默认30分钟，单位毫秒），在token即将过期的一段时间内用户操作了，则给用户的token续期
detect: 1800000
# 续期时间范围，默认1小时，单位毫秒
renew: 3600000
swagger:
base:
package: com.elitesland.user
contact:
email: Mir@qq.com
name: Mir
url: ''
description: ''
title: YST中台-NRP2-Demo
url: ''
version: 1.0
\ No newline at end of file
yst-base-gateway/src/main/resources/application-test.yml 0 → 100644
View file @ c239a771
spring:
cloud:
gateway:
discovery:
locator:
enabled: true
routes:
# 本地项目
- id: yst-yd-demo
uri: http://127.0.0.1:8080
predicates:
- Path=/yst-demo/**
- id: remote_route # 远程服务
uri: http://192.168.0.210:81
predicates:
- Path=/**
nacos:
discovery:
server-addr: frps.elitescloud.com:25145
enabled: false
yst-base-gateway/src/main/resources/application.yml 0 → 100644
View file @ c239a771
spring:
#profiles:
#active: ${profileActive}
application:
name: yst-gateway
server:
port: 9040
# servlet:
# context-path: ""
yst-base-gateway/src/main/resources/bootstrap.yml 0 → 100644
View file @ c239a771
spring:
cloud:
nacos:
config:
server-addr: frps.elitescloud.com:25145
yst-common/Dockerfile 0 → 100644
View file @ c239a771
FROM dperezcabrera/openjdk11-alpine
VOLUME /tmp
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
ENV ACTIVE=$ACTIVE
ENV JAVA_OPTS=$JAVA_OPTS
ENTRYPOINT [ "sh", "-c", "java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.jar --spring.profiles.active=$ACTIVE" ]
#ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar","--spring.profiles.active=$ACTIVE"]
\ No newline at end of file
yst-common/build.gradle 0 → 100644
View file @ c239a771
plugins {
id 'com.palantir.docker' version '0.25.0'
}
archivesBaseName = 'yst-common'
//所有服务公共依赖部分
group 'com.elitesland'
version '1.0-SNAPSHOT'
jar.enabled=true
bootJar.enabled=false
dependencies {
testCompile group: 'junit', name: 'junit', version: '4.12'
implementation project(':yst-core')
}
docker {
name = "elitesland/${project.archivesBaseName}:${project.version}" //发布到harbor的镜像名称
dockerfile file("Dockerfile")
copySpec.from(jar).rename(".*", "app.jar")
buildArgs(['JAR_FILE': "app.jar"])
}
\ No newline at end of file
yst-common/src/main/java/com/elitesland/common/dto/product/DemoProductDTO.java 0 → 100644
View file @ c239a771
package com.elitesland.common.dto.product;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.ToString;
import java.io.Serializable;
/**
* <p>
* 功能说明
* Demo服务调用User服务，传参类
* </p >
*
* @author Roman.Zhang
* @date 2021/1/30
*/
@Data
@ApiModel(value = "Demo服务调用Product服务传参类", description = "Demo服务调用User服务传参类")
@ToString
public class DemoProductDTO implements Serializable {
private static final long serialVersionUID = 6654517748561862106L;
@ApiModelProperty("商品名称")
private String productName;
}
yst-common/src/main/java/com/elitesland/common/dto/user/DemoUserDTO.java 0 → 100644
View file @ c239a771
package com.elitesland.common.dto.user;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
/**
* <p>
* 功能说明
* Demo服务调用User服务，传参类
* </p >
*
* @author Roman.Zhang
* @date 2021/1/30
*/
@Data
@ApiModel(value = "Demo服务调用User服务传参类", description = "Demo服务调用User服务传参类")
public class DemoUserDTO implements Serializable {
private static final long serialVersionUID = 7573919808933923530L;
@ApiModelProperty("用户名称")
private String userName;
}
yst-common/src/main/java/com/elitesland/common/rpc/demo/DemoRpcProductService.java 0 → 100644
View file @ c239a771
package com.elitesland.common.rpc.demo;
import com.elitesland.common.dto.product.DemoProductDTO;
import com.elitesland.core.base.ApiResult;
/**
* <p>
* 功能说明
* Demo服务调用Product服务
* </p >
*
* @author Roman.Zhang
* @date 2021/1/30
*/
public interface DemoRpcProductService {
/**
* demo服务调用product服务，用于演示测试
* @param demoProductDTO 商品信息
* @return
*/
ApiResult<Object> getProduct(DemoProductDTO demoProductDTO);
}
yst-common/src/main/java/com/elitesland/common/rpc/demo/DemoRpcUserService.java 0 → 100644
View file @ c239a771
package com.elitesland.common.rpc.demo;
import com.elitesland.common.dto.user.DemoUserDTO;
import com.elitesland.core.base.ApiResult;
/**
* <p>
* 功能说明
* Demo服务调用Product服务
* </p >
*
* @author Roman.Zhang
* @date 2021/1/30
*/
public interface DemoRpcUserService {
/**
* demo服务调用User服务，用于演示测试
* @param demoUserDTO 用户信息
* @return
*/
ApiResult<Object> getUser(DemoUserDTO demoUserDTO);
}
yst-common/src/main/java/com/elitesland/common/rpc/user/UserRpcDemoService.java 0 → 100644
View file @ c239a771
package com.elitesland.common.rpc.user;
/**
* <p>
* 功能说明
* demo服务调用user服务
* </p >
*
* @author Roman.Zhang
* @date 2021/1/30
*/
public interface UserRpcDemoService {
Object getDemo(String demo);
}
yst-core/Dockerfile 0 → 100644
View file @ c239a771
FROM dperezcabrera/openjdk11-alpine
VOLUME /tmp
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
ENV ACTIVE=$ACTIVE
ENV JAVA_OPTS=$JAVA_OPTS
ENTRYPOINT [ "sh", "-c", "java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.jar --spring.profiles.active=$ACTIVE" ]
#ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar","--spring.profiles.active=$ACTIVE"]
\ No newline at end of file
yst-core/build.gradle 0 → 100644
View file @ c239a771
plugins {
id 'com.palantir.docker' version '0.25.0'
}
archivesBaseName = 'yst-core'
// 用户中心
jar.enabled = true
bootJar.enabled = false
docker {
name = "elitesland/${project.archivesBaseName}:${project.version}" //发布到harbor的镜像名称
dockerfile file("Dockerfile")
copySpec.from(jar).rename(".*", "app.jar")
buildArgs(['JAR_FILE': "app.jar"])
}
\ No newline at end of file
yst-core/src/bin/restart.sh 0 → 100644
View file @ c239a771
#! /bin/shell
# Copyright 2019-2029 elitesland(https://elitesland.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#======================================================================
# 项目重启shell脚本
# 先调用shutdown.sh停服
# 然后调用startup.sh启动服务
#
# author: Mir
# date: 2020-2-18
#======================================================================
# 项目名称
APPLICATION="yst-cms-svr"
# 停服
echo stop ${APPLICATION} Application...
sh shutdown.sh
# 启动服务
echo start ${APPLICATION} Application...
sh startup.sh
\ No newline at end of file
yst-core/src/bin/shutdown.sh 0 → 100644
View file @ c239a771
#! /bin/shell
# Copyright 2019-2029 elitesland(https://elitesland.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#======================================================================
# 项目停服shell脚本
# 通过项目名称查找到PID
# 然后kill -9 pid
#
# author: Mir
# date: 2020-2-18
#======================================================================
# 项目名称
APPLICATION="yst-cms-svr"
# 项目启动jar包名称
APPLICATION_JAR="${APPLICATION}.jar"
PID=$(ps -ef | grep ${APPLICATION_JAR} | grep -v grep | awk '{ print $2 }')
if [ -z "$PID" ]
then
echo ${APPLICATION} is already stopped
else
echo kill ${PID}
kill -9 ${PID}
echo ${APPLICATION} stopped successfully
fi
\ No newline at end of file
yst-core/src/bin/startup.bat 0 → 100644
View file @ c239a771
rem Copyright 2019-2029 elitesland(https://elitesland.com)
rem
rem Licensed under the Apache License, Version 2.0 (the "License");
rem you may not use this file except in compliance with the License.
rem You may obtain a copy of the License at
rem
rem http://www.apache.org/licenses/LICENSE-2.0
rem
rem Unless required by applicable law or agreed to in writing, software
rem distributed under the License is distributed on an "AS IS" BASIS,
rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
rem See the License for the specific language governing permissions and
rem limitations under the License.
rem ======================================================================
rem windows启动脚本
rem
rem author: Mir
rem date: 2020-2-18
rem ======================================================================
rem startup jar
java -jar ../lib/yst-cms-svr.jar --spring.config.location=../config/ --elbootplus.isEnableAnsi=false
pause
\ No newline at end of file
yst-core/src/bin/startup.sh 0 → 100644
View file @ c239a771
#! /bin/shell
# Copyright 2019-2029 elitesland(https://elitesland.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#======================================================================
# 项目启动shell脚本
# config目录: 配置文件目录
# logs目录: 项目运行日志目录
# logs/spring-boot-plus_startup.log: 记录启动日志
# logs/back目录: 项目运行日志备份目录
# nohup后台运行
#
# author: Mir
# date: 2020-2-18
#======================================================================
# 项目名称
APPLICATION="yst-cms-svr"
# 项目启动jar包名称
APPLICATION_JAR="${APPLICATION}.jar"
# bin目录绝对路径
BIN_PATH=$(cd $(dirname "$0"); pwd)
# 进入bin目录
cd $(dirname "$0")
# 返回到上一级项目根目录路径
cd ..
# 打印项目根目录绝对路径
# `pwd` 执行系统命令并获得结果
BASE_PATH=$(pwd)
# 外部配置文件绝对目录,如果是目录需要/结尾，也可以直接指定文件
# 如果指定的是目录,spring则会读取目录中的所有配置文件
CONFIG_DIR=${BASE_PATH}"/config/"
# 项目日志输出绝对路径
LOG_DIR=${BASE_PATH}"/logs"
LOG_FILE="${APPLICATION}.log"
LOG_PATH="${LOG_DIR}/${LOG_FILE}"
# 日志备份目录
LOG_BACK_DIR="${LOG_DIR}/back/"
# 项目启动日志输出绝对路径
LOG_STARTUP_PATH="${LOG_DIR}/${APPLICATION}_startup.log"
# 当前时间
NOW=$(date --date='0 days ago' "+%Y-%m-%d-%H-%M-%S")
NOW_PRETTY=$(date --date='0 days ago' "+%Y-%m-%d %H:%M:%S")
# 启动日志
STARTUP_LOG="================================================ ${NOW_PRETTY} ================================================\n"
# 如果logs文件夹不存在,则创建文件夹
if [ ! -d "${LOG_DIR}" ]; then
mkdir "${LOG_DIR}"
fi
# 如果logs/back文件夹不存在,则创建文件夹
if [ ! -d "${LOG_BACK_DIR}" ]; then
mkdir "${LOG_BACK_DIR}"
fi
# 如果项目运行日志存在,则重命名备份
if [ -f "${LOG_PATH}" ]; then
mv ${LOG_PATH} "${LOG_BACK_DIR}/${APPLICATION}_back_${NOW}.log"
fi
# 创建新的项目运行日志
echo "" > ${LOG_PATH}
# 如果项目启动日志不存在,则创建,否则追加
echo ${STARTUP_LOG} >> ${LOG_STARTUP_PATH}
#==========================================================================================
# JVM Configuration
# -Xmx1g:设置JVM最大可用内存为1G。
# -Xms1g:设置JVM初始内存41。此值可以设置与-Xmx相同,以避免每次垃圾回收完成后JVM重新分配内存
# -Xmn512m:设置年轻代大小为512m。整个JVM内存大小=年轻代大小 + 年老代大小 + 持久代大小。
# 持久代一般固定大小为64m,所以增大年轻代,将会减小年老代大小。此值对系统性能影响较大,Sun官方推荐配置为整个堆的3/8
# -XX:MetaspaceSize=64m:存储class的内存大小,该值越大触发Metaspace GC的时机就越晚
# -XX:MaxMetaspaceSize=320m:限制Metaspace增长的上限，防止因为某些情况导致Metaspace无限的使用本地内存，影响到其他程序
# -XX:-OmitStackTraceInFastThrow:解决重复异常不打印堆栈信息问题
#==========================================================================================
JAVA_OPT="-server -Xms1g -Xmx1g -Xmn512m -XX:MetaspaceSize=64m -XX:MaxMetaspaceSize=256m"
JAVA_OPT="${JAVA_OPT} -XX:-OmitStackTraceInFastThrow"
#=======================================================
# 将命令启动相关日志追加到日志文件
#=======================================================
# 输出项目名称
STARTUP_LOG="${STARTUP_LOG}application name: ${APPLICATION}\n"
# 输出jar包名称
STARTUP_LOG="${STARTUP_LOG}application jar name: ${APPLICATION_JAR}\n"
# 输出项目bin路径
STARTUP_LOG="${STARTUP_LOG}application bin path: ${BIN_PATH}\n"
# 输出项目根目录
STARTUP_LOG="${STARTUP_LOG}application root path: ${BASE_PATH}\n"
# 打印日志路径
STARTUP_LOG="${STARTUP_LOG}application log path: ${LOG_PATH}\n"
# 打印JVM配置
STARTUP_LOG="${STARTUP_LOG}application JAVA_OPT : ${JAVA_OPT}\n"
# 打印启动命令
STARTUP_LOG="${STARTUP_LOG}application background startup command: nohup java ${JAVA_OPT} -jar ${BASE_PATH}/lib/${APPLICATION_JAR} --spring.config.location=${CONFIG_DIR} --logging.config=${CONFIG_DIR}logback.xml > ${LOG_PATH} 2>&1 &\n"
#======================================================================
# 执行启动命令：后台启动项目,并将日志输出到项目根目录下的logs文件夹下
#======================================================================
nohup java ${JAVA_OPT} -jar ${BASE_PATH}/lib/${APPLICATION_JAR} --spring.config.location=${CONFIG_DIR} --logging.config=${CONFIG_DIR}logback.xml > ${LOG_PATH} 2>&1 &
# 进程ID
PID=$(ps -ef | grep ${APPLICATION_JAR} | grep -v grep | awk '{ print $2 }')
STARTUP_LOG="${STARTUP_LOG}application pid: ${PID}\n"
# 启动日志追加到启动日志文件中
echo -e ${STARTUP_LOG} >> ${LOG_STARTUP_PATH}
# 打印启动日志
echo -e ${STARTUP_LOG}
# 打印项目日志
tail -f ${LOG_PATH}
yst-core/src/main/assembly/assembly.xml 0 → 100644
View file @ c239a771
<?xml version="1.0" encoding="UTF-8"?>
<!--
~ Copyright 2019-2029 elitesland(https://elitesland.com)
~
~ Licensed under the Apache License, Version 2.0 (the "License");
~ you may not use this file except in compliance with the License.
~ You may obtain a copy of the License at
~
~ http://www.apache.org/licenses/LICENSE-2.0
~
~ Unless required by applicable law or agreed to in writing, software
~ distributed under the License is distributed on an "AS IS" BASIS,
~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
~ See the License for the specific language governing permissions and
~ limitations under the License.
-->
<assembly>
<!-- 可自定义，这里指定的是项目环境 -->
<!-- spring-boot-plus-server-1.0.1-RELEASE-local.tar.gz -->
<!-- <id>${project.version}-${profileActive}</id> -->
<id>assembly</id>
<!-- 打包的类型，如果有N个，将会打N个类型的包 -->
<formats>
<format>tar.gz</format>
<!-- <format>zip</format> -->
</formats>
<includeBaseDirectory>true</includeBaseDirectory>
<fileSets>
<!--
0755->即用户具有读/写/执行权限，组用户和其它用户具有读写权限；
0644->即用户具有读写权限，组用户和其它用户具有只读权限；
-->
<!-- 将src/bin目录下的所有文件输出到打包后的bin目录中 -->
<fileSet>
<directory>${basedir}/src/bin</directory>
<outputDirectory>bin</outputDirectory>
<fileMode>0755</fileMode>
<includes>
<include>**.sh</include>
<include>**.bat</include>
</includes>
</fileSet>
<!-- 指定输出target/classes中的配置文件到config目录中 -->
<fileSet>
<directory>${basedir}/target/classes/config</directory>
<outputDirectory>config</outputDirectory>
<fileMode>0644</fileMode>
<includes>
<include>*</include>
</includes>
</fileSet>
<!-- 将项目启动jar打包到lib目录中 -->
<fileSet>
<directory>${basedir}/target</directory>
<outputDirectory>lib</outputDirectory>
<fileMode>0755</fileMode>
<includes>
<include>${project.build.finalName}.jar</include>
</includes>
</fileSet>
<!-- 指定日志目录 -->
<fileSet>
<directory>${basedir}/src/logs</directory>
<outputDirectory>logs</outputDirectory>
<fileMode>0755</fileMode>
</fileSet>
<!-- 包含根目录下的文件 -->
<fileSet>
<directory>${basedir}</directory>
<includes>
<include>NOTICE</include>
<include>LICENSE</include>
</includes>
</fileSet>
</fileSets>
</assembly>
\ No newline at end of file
yst-core/src/main/java/com/elitesland/core/base/ApiCode.java 0 → 100644
View file @ c239a771
package com.elitesland.core.base;
/**
* <p>
* REST API 响应码
* </p>
*
* @author Mir
* @date 2018-11-08
*/
public enum ApiCode {
/**
* Http response entity status code, corresponding to HTTP Status Code
*/
SUCCESS(200, "操作成功"),
UNAUTHORIZED(401, "请先登录"),
NOT_PERMISSION(403, "没有权限"),
NOT_FOUND(404, "你请求的资源不存在"),
FAIL(500, "操作失败"),
LOGIN_EXCEPTION(4000, "登录失败"),
SYSTEM_EXCEPTION(5000, "系统异常!"),
PARAMETER_EXCEPTION(5001, "请求参数校验异常"),
PARAMETER_PARSE_EXCEPTION(5002, "请求参数解析异常"),
HTTP_MEDIA_TYPE_EXCEPTION(5003, "HTTP Media 类型异常"),
SPRING_BOOT_PLUS_EXCEPTION(5100, "系统处理异常"),
BUSINESS_EXCEPTION(5101, "业务处理异常"),
DAO_EXCEPTION(5102, "数据库处理异常"),
VERIFICATION_CODE_EXCEPTION(5103, "验证码校验异常"),
AUTHENTICATION_EXCEPTION(5104, "登录授权异常"),
UNAUTHENTICATED_EXCEPTION(5105, "身份认证不正确"),
UNAUTHORIZED_EXCEPTION(5106, "没有访问权限"),
UNAUTHORIZED_ANONYMOUS(5107, "匿名用户，未授权访问"),
NO_USER_FOUND_EXCEPTION(5108, "用户信息未找到，系统异常")
;
private final int code;
private final String msg;
ApiCode(final int code, final String msg) {
this.code = code;
this.msg = msg;
}
public static ApiCode getApiCode(int code) {
ApiCode[] ecs = ApiCode.values();
for (ApiCode ec : ecs) {
if (ec.getCode() == code) {
return ec;
}
}
return SUCCESS;
}
public int getCode() {
return code;
}
public String getMsg() {
return msg;
}
}
yst-core/src/main/java/com/elitesland/core/base/ApiResult.java 0 → 100644
View file @ c239a771
package com.elitesland.core.base;
import cn.hutool.core.util.StrUtil;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.experimental.Accessors;
import lombok.val;
import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;
/**
* <p>
* REST API 返回结果
* </p>
*
* @author Mir
* @date 2018-11-08
*/
@Data
@Accessors(chain = true)
@Builder
@AllArgsConstructor
public class ApiResult<T> implements Serializable {
private static final long serialVersionUID = 7722914707623525357L;
/**
* 响应码
*/
private int code;
/**
* 响应消息
*/
private String msg;
/**
* 是否成功
*/
private boolean success;
/**
* 响应数据
*/
private T data;
/**
* 响应时间
*/
// @JSONField(format = "yyyy-MM-ddTHH:mm:ss")
// @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime time = LocalDateTime.now();
public ApiResult() {
}
public static <T> ApiResult<T> result(boolean flag) {
if (flag) {
return ok();
}
return fail();
}
public static <T> ApiResult<T> result(ApiCode apiCode) {
return result(apiCode, null);
}
public static <T> ApiResult<T> result(ApiCode apiCode, T data) {
return result(apiCode, null, data);
}
public static <T> ApiResult<T> result(ApiCode apiCode, String msg, T data) {
boolean success = false;
if (apiCode.getCode() == ApiCode.SUCCESS.getCode()) {
success = true;
}
String message = apiCode.getMsg();
if (StrUtil.isNotBlank(msg)) {
message = msg;
}
return ApiResult.<T>builder()
.code(apiCode.getCode())
.msg(message)
.data(data)
.success(success)
.time(LocalDateTime.now())
.build();
}
public static <T> ApiResult<T> ok() {
return ok(null);
}
public static <T> ApiResult<T> ok(T data) {
return result(ApiCode.SUCCESS, data);
}
public static <T> ApiResult<T> ok(T data, String msg) {
return result(ApiCode.SUCCESS, msg, data);
}
public static <T> ApiResult<Map<String, T>> okMap(String key, T value) {
Map<String, T> map = new HashMap<>(1);
map.put(key, value);
return ok(map);
}
public static Map<String, Object> toMap(ApiResult<?> result) {
val map = new HashMap<String, Object>();
map.put("code", result.code);
map.put("msg", result.msg);
map.put("data", result.data);
map.put("success", result.success);
map.put("time", result.time);
return map;
}
public static <T> ApiResult<T> fail(ApiCode apiCode) {
return result(apiCode, null);
}
public static <T> ApiResult<T> fail(String msg) {
return result(ApiCode.FAIL, msg, null);
}
public static ApiResult<Object> fail(ApiCode apiCode, String msg){
if(ApiCode.SUCCESS == apiCode){
throw new RuntimeException("失败结果状态吗不能为" + ApiCode.SUCCESS.getCode());
}
return result(apiCode, msg, null);
}
public static <T> ApiResult<T> fail(ApiCode apiCode, T data) {
if (ApiCode.SUCCESS == apiCode) {
throw new RuntimeException("失败结果状态码不能为" + ApiCode.SUCCESS.getCode());
}
return result(apiCode, data);
}
public static <T> ApiResult<Map<String, T>> fail(String key, T value) {
Map<String, T> map = new HashMap<>(1);
map.put(key, value);
return result(ApiCode.FAIL, map);
}
public static <T> ApiResult<T> fail() {
return fail(ApiCode.FAIL);
}
}
\ No newline at end of file
yst-core/src/main/java/com/elitesland/core/base/BaseModel.java 0 → 100644
View file @ c239a771
package com.elitesland.core.base;
import com.elitesland.system.annotation.Comment;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.hibernate.annotations.GenericGenerator;
import org.springframework.data.annotation.CreatedBy;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedBy;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import javax.persistence.*;
import java.time.LocalDateTime;
/**
* <pre>
* JPA数据实体类的基础类，用于唯一ID生成策略绑定
* 审计字段、版本和逻辑删除标记，
* 未来扩展租户ID信息
* </pre>
*
* @author Moz
* @date 3/17/2020
*/
@Data
@EntityListeners(AuditingEntityListener.class)
@MappedSuperclass
public class BaseModel {
@Id
@GenericGenerator(name = "el-id", strategy = "com.elitesland.core.util.IdGenerator")
@GeneratedValue(strategy = GenerationType.AUTO, generator = "el-id")
@JsonSerialize(using = ToStringSerializer.class)
@ApiModelProperty("记录唯一ID")
@Comment("记录唯一ID")
@Column()
private Long id;
@ApiModelProperty(value = "租户ID")
@Comment(value = "租户ID")
@Column()
@JsonSerialize(using = ToStringSerializer.class)
Long tenantId;
@ApiModelProperty(value = "备注")
@Comment("备注")
@Column()
private String remark;
@ApiModelProperty("记录创建者ID")
@Comment("记录创建者ID")
@Column(updatable = false)
@JsonSerialize(using = ToStringSerializer.class)
private Long createUserId = 0L;
@CreatedBy
@ApiModelProperty("记录创建者")
@Comment("记录创建者")
@Column()
private String creator;
@CreatedDate
@ApiModelProperty("记录创建时间")
@Comment("记录创建时间")
@Column(updatable = false)
private LocalDateTime createTime = LocalDateTime.now();
@ApiModelProperty("记录最后更新者ID")
@Comment("记录最后更新者ID")
@Column()
@JsonSerialize(using = ToStringSerializer.class)
private Long modifyUserId = 0L;
@LastModifiedBy
@ApiModelProperty("记录最后更新者")
@Comment("记录最后更新者")
@Column()
String updater;
@LastModifiedDate
@ApiModelProperty("记录最后更新时间")
@Comment("记录最后更新时间")
@Column()
private LocalDateTime modifyTime = LocalDateTime.now();
@ApiModelProperty(value = "逻辑删除，0：未删除，1：已删除")
@Comment("逻辑删除，0：未删除，1：已删除")
@Column()
private Integer deleteFlag;
@ApiModelProperty(value = "锁版本")
@Comment("锁版本")
@Column()
private Integer auditDataVersion;
}
yst-core/src/main/java/com/elitesland/core/base/PagingVO.java 0 → 100644
View file @ c239a771
package com.elitesland.core.base;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Builder;
import lombok.Data;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Collections;
import java.util.List;
/**
* @author Mir
* @date 2018-11-08
*/
@ApiModel("分页")
@Data
@Accessors(chain = true)
@Builder
public class PagingVO<T> implements Serializable {
private static final long serialVersionUID = -1683800405530086022L;
@ApiModelProperty("总行数")
@JsonProperty("total")
private Long total = 0L;
@ApiModelProperty("数据列表")
@JsonProperty("records")
private List<T> records = Collections.emptyList();
public PagingVO() {
}
public PagingVO(long total, List<T> records) {
this.total = total;
this.records = records;
}
public PagingVO(IPage<T> page) {
this.total = page.getTotal();
this.records = page.getRecords();
}
@Override
public String toString() {
return "Paging{" +
"total=" + total +
", records=" + records +
'}';
}
}
yst-core/src/main/java/com/elitesland/core/base/param/AbstractOrderQueryParam.java 0 → 100644
View file @ c239a771
package com.elitesland.core.base.param;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.elitesland.core.base.ApiCode;
import com.elitesland.core.exception.BusinessException;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.querydsl.core.types.Order;
import com.querydsl.core.types.OrderSpecifier;
import com.querydsl.core.types.dsl.EntityPathBase;
import com.querydsl.core.types.dsl.PathBuilder;
import com.querydsl.jpa.impl.JPAQuery;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.val;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
/**
* 可排序查询参数对象
*
* @author Mir
* @date 2019-08-04
*/
@Data
@EqualsAndHashCode(callSuper = true)
@ApiModel("可排序查询参数对象")
public abstract class AbstractOrderQueryParam extends QueryParam {
private static final long serialVersionUID = 57714391204790143L;
@ApiModelProperty(value = "排序")
private List<OrderItem> orders;
public List<OrderItem> getOrders() {
return orders;
}
public void setOrders(List<OrderItem> orders) {
this.orders = orders;
}
public void defaultOrder(OrderItem orderItem) {
this.defaultOrders(Collections.singletonList(orderItem));
}
public void defaultOrders(List<OrderItem> orderItems) {
if (CollectionUtils.isEmpty(orderItems)) {
return;
}
this.orders = orderItems;
}
@JsonIgnore
public PageRequest getPageRequest() {
val orderBys = CollectionUtils.isEmpty(orders) ? new ArrayList<Sort.Order>() :
orders.stream().map(o -> new Sort.Order(
o.isAsc() ? Sort.Direction.ASC : Sort.Direction.DESC,
o.getColumn()
)).collect(Collectors.toList());
return PageRequest.of(getCurrent(), getSize(), Sort.by(orderBys));
}
/**
* 单表查询,排序方法
* @param query
* @param entityPathBase 实体对象
*/
@JsonIgnore
public void fillOrders(JPAQuery<?> query, EntityPathBase entityPathBase) {
val pageRequest = getPageRequest();
pageRequest.getSort().forEach(s -> {
val orderbyExpr = new PathBuilder(entityPathBase.getClass(),
entityPathBase.getMetadata().getElement().toString());
query.orderBy(new OrderSpecifier(s.isAscending() ?
Order.ASC : Order.DESC, orderbyExpr.get(s.getProperty())));
});
}
/**
* 多表关联查询，排序方法。要求：排序字段格式需为 “实体对象名称.字段名称”
* @param query
*/
@JsonIgnore
public void fillOrders(JPAQuery<?> query) {
val pageRequest = getPageRequest();
pageRequest.getSort().forEach(s -> {
val sects = s.getProperty().split("\\.");
if (sects.length > 1) {
val orderbyExpr = new PathBuilder<>(Object.class, sects[0]);
query.orderBy(new OrderSpecifier(s.isAscending() ?
Order.ASC : Order.DESC, orderbyExpr.get(sects[1])));
} else {
throw new BusinessException(ApiCode.PARAMETER_PARSE_EXCEPTION, "排序字段需要指定所属hql的实体对象，对象名称.字段名称");
}
});
}
@JsonIgnore
public void setPaging(JPAQuery<?> query) {
query.offset(getCurrent() * getSize());
query.limit(getSize());
}
}
yst-core/src/main/java/com/elitesland/core/base/param/IdParam.java 0 → 100644
View file @ c239a771
package com.elitesland.core.base.param;
import io.swagger.annotations.ApiModel;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import java.io.Serializable;
/**
* @author Mir
* @date 2018-11-08
*/
@Data
@ApiModel("ID参数")
public class IdParam implements Serializable {
private static final long serialVersionUID = -5353973980674510450L;
@NotBlank(message = "ID不能为空")
private String id;
}
yst-core/src/main/java/com/elitesland/core/base/param/IdStatusParam.java 0 → 100644
View file @ c239a771
package com.elitesland.core.base.param;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
/**
* @author Mir
* @date 2018-11-08
*/
@ApiModel("主键状态VO")
public class IdStatusParam implements Serializable {
private static final long serialVersionUID = -7581307955242965701L;
@ApiModelProperty("主键ID")
private String id;
@ApiModelProperty("状态,1:启用 0:禁用")
private Integer status;
}
yst-core/src/main/java/com/elitesland/core/base/param/NameParam.java 0 → 100644
View file @ c239a771
package com.elitesland.core.base.param;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
/**
* 名称参数
*
* @author Mir
* @date 2018-11-08
*/
@ApiModel("名称参数")
public class NameParam implements Serializable {
private static final long serialVersionUID = -3710501706034574149L;
@ApiModelProperty("名称")
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "NameParam{" +
"name='" + name + '\'' +
'}';
}
}
yst-core/src/main/java/com/elitesland/core/base/param/QueryParam.java 0 → 100644
View file @ c239a771
package com.elitesland.core.base.param;
import com.elitesland.core.constant.CommonConstant;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
/**
* 查询参数
* @author Mir
* @date 2018-11-08
*/
@Data
@ApiModel("查询参数对象")
public abstract class QueryParam implements Serializable {
private static final long serialVersionUID = -3263921252635611410L;
@ApiModelProperty(value = "页码,默认为1", example = "0")
private Integer current = CommonConstant.DEFAULT_PAGE_INDEX;
@ApiModelProperty(value = "页大小,默认为10", example = "10")
private Integer size = CommonConstant.DEFAULT_PAGE_SIZE;
@ApiModelProperty(value = "搜索字符串", example = "")
private String keyword;
public Integer getCurrent() {
return current > 0 ? current - 1 : 0;
}
public Integer getSize() {
return size;
}
public String getKeyword() {
return keyword;
}
public void setKeyword(String keyword) {
this.keyword = keyword;
}
public void setCurrent(Integer current) {
if (current == null || current < 0) {
this.current = CommonConstant.DEFAULT_PAGE_INDEX;
} else {
this.current = current;
}
}
public void setSize(Integer size) {
if (size == null || size <= 0) {
this.size = CommonConstant.DEFAULT_PAGE_SIZE;
} else {
this.size = size;
}
}
}
yst-core/src/main/java/com/elitesland/core/config/HibernateConfig.java 0 → 100644
View file @ c239a771
package com.elitesland.core.config;
import com.elitesland.system.annotation.CommentIntegrator;
import org.hibernate.jpa.boot.spi.IntegratorProvider;
import org.springframework.boot.autoconfigure.orm.jpa.HibernatePropertiesCustomizer;
import org.springframework.stereotype.Component;
import java.util.Collections;
import java.util.Map;
/**
* @author Mir
* @date 2020-09-19
*/
@Component
public class HibernateConfig implements HibernatePropertiesCustomizer {
@Override
public void customize(Map<String, Object> hibernateProperties) {
hibernateProperties.put("hibernate.use_sql_comments", true);
hibernateProperties.put("hibernate.integrator_provider",
(IntegratorProvider) () -> Collections.singletonList(CommentIntegrator.INSTANCE));
}
}
yst-core/src/main/java/com/elitesland/core/config/QueryDSLConfig.java 0 → 100644
View file @ c239a771
package com.elitesland.core.config;
import com.querydsl.jpa.impl.JPAQueryFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.persistence.EntityManager;
/**
* <pre>
*
* </pre>
* @author Mir
* @date 2020-06-20
*/
@Configuration
public class QueryDSLConfig {
@Bean
public JPAQueryFactory jpaQueryFactory(EntityManager em) {
return new JPAQueryFactory(em);
}
}
yst-core/src/main/java/com/elitesland/core/config/json/LocalDateTimeSerializerConfig.java 0 → 100644
View file @ c239a771
package com.elitesland.core.config.json;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
/**
* @author Mir
*/
@Configuration
public class LocalDateTimeSerializerConfig {
@Value("${spring.jackson.date-format:yyyy-MM-dd HH:mm:ss}")
private String pattern;
private LocalDateTimeSerializer localDateTimeSerializer;
private LocalDateTimeDeserializer localDateTimeDeserializer;
@Autowired
public void setLocalDateTimeSerializer(LocalDateTimeSerializer localDateTimeSerializer) {
this.localDateTimeSerializer = localDateTimeSerializer;
}
@Autowired
public void setLocalDateTimeDeserializer(LocalDateTimeDeserializer localDateTimeDeserializer) {
this.localDateTimeDeserializer = localDateTimeDeserializer;
}
@Bean
public LocalDateTimeSerializer localDateTimeSerializer() {
return new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(pattern));
}
@Bean
public LocalDateTimeDeserializer localDateTimeDeserializer() {
return new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(pattern));
}
@Bean
public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
return jacksonObjectMapperBuilder -> {
jacksonObjectMapperBuilder.serializerByType(LocalDateTime.class, localDateTimeSerializer);
jacksonObjectMapperBuilder.deserializerByType(LocalDateTime.class, localDateTimeDeserializer);
// jacksonObjectMapperBuilder.serializerByType(Long.class, ToStringSerializer.instance);
// jacksonObjectMapperBuilder.serializerByType(Long.TYPE, ToStringSerializer.instance);
};
}
}
yst-core/src/main/java/com/elitesland/core/constant/CacheKey.java 0 → 100644
View file @ c239a771
package com.elitesland.core.constant;
public interface CacheKey {
}
yst-core/src/main/java/com/elitesland/core/constant/CommonConstant.java 0 → 100644
View file @ c239a771
package com.elitesland.core.constant;
/**
* 常量
*
* @author Mir
* @date 2018-11-08
*/
public interface CommonConstant {
/**
* 默认页码为1
*/
Integer DEFAULT_PAGE_INDEX = 0;
/**
* 默认页大小为10
*/
Integer DEFAULT_PAGE_SIZE = 10;
/**
* 登录用户
*/
String LOGIN_SYS_USER = "loginSysUser";
/**
* 登录token
*/
String JWT_DEFAULT_TOKEN_NAME = "token";
/**
* JWT用户名
*/
String JWT_USERNAME = "username";
/**
* JWT刷新新token响应状态码
*/
int JWT_REFRESH_TOKEN_CODE = 460;
/**
* JWT刷新新token响应状态码，
* Redis中不存在，但jwt未过期，不生成新的token，返回361状态码
*/
int JWT_INVALID_TOKEN_CODE = 461;
/**
* JWT Token默认密钥
*/
String JWT_DEFAULT_SECRET = "666666";
/**
* JWT 默认过期时间，3600L，单位秒
*/
Long JWT_DEFAULT_EXPIRE_SECOND = 3600L;
/**
* 初始密码
*/
String INIT_PWD = "123456";
/**
* 默认头像
*/
String DEFAULT_HEAD_URL = "";
/**
* 管理员角色名称
*/
String ADMIN_ROLE_NAME = "管理员";
String ADMIN_LOGIN = "adminLogin";
/**
* 验证码token
*/
String VERIFY_TOKEN = "verifyToken";
/**
* 图片
*/
String IMAGE = "image";
/**
* JPEG
*/
String JPEG = "JPEG";
/**
* base64前缀
*/
String BASE64_PREFIX = "data:image/png;base64,";
String AUDIT_CREATOR = "creator";
String AUDIT_CREATED = "created";
String AUDIT_UPDATER = "updater";
String AUDIT_UPDATED = "updated";
}
yst-core/src/main/java/com/elitesland/core/constant/CommonRedisKey.java 0 → 100644
View file @ c239a771
package com.elitesland.core.constant;
/**
* <p>
* redis key 常量
* </p>
*
* @author Mir
* @date 2019-05-23
**/
public interface CommonRedisKey {
/**
* 登录用户token信息key
*/
String LOGIN_TOKEN = "login:token:%s";
/**
* 登录用户信息key
*/
String LOGIN_USER = "login:user:%s";
/**
* 登录用户盐值信息key
*/
String LOGIN_SALT = "login:salt:%s";
/**
* 登录用户username token
*/
String LOGIN_USER_TOKEN = "login:user:token:%s:%s";
/**
* 验证码
*/
String VERIFY_CODE = "verify.code:%s";
}
yst-core/src/main/java/com/elitesland/core/constant/DatePattern.java 0 → 100644
View file @ c239a771
package com.elitesland.core.constant;
/**
* <p>
* 日期格式常量
* </p>
*
* @author Mir
* @date 2018-11-08
*/
public interface DatePattern {
/**
* 年-月-日
*/
String yyyy_MM_dd = "yyyy-MM-dd";
/**
* 年-月-日 时:分
*/
String yyyy_MM_dd_HH_mm = "yyyy-MM-dd HH:mm";
/**
* 年-月-日 时:分:秒
*/
String yyyy_MM_dd_HH_mm_ss = "yyyy-MM-dd HH:mm:ss";
/**
* 年-月-日 时:分:秒:毫秒
*/
String yyyy_MM_dd_HH_mm_ss_S = "yyyy-MM-dd HH:mm:ss.S";
/**
* 时:分
*/
String HH_mm = "HH:mm";
/**
* 时:分:秒
*/
String HH_mm_ss = "HH:mm:ss";
/**
* 时:分:秒:毫秒
*/
String HH_mm_ss_S = "HH:mm:ss:S";
}
yst-core/src/main/java/com/elitesland/core/constant/HttpConstant.java 0 → 100644
View file @ c239a771
package com.elitesland.core.constant;
/**
* @author Mir
* @date 2020/03/18
*/
public interface HttpConstant {
String CHARSET_ENCODING_UTF8 = "UTF-8";
String CONTENT_TYPE_JSON = "application/json";
}
yst-core/src/main/java/com/elitesland/core/exception/BadCaptchaException.java 0 → 100644
View file @ c239a771
package com.elitesland.core.exception;
import org.springframework.security.core.AuthenticationException;
/**
* <pre>
* [功能说明]
* </pre>
*
* @author Mir
* @date 2020/6/24
*/
public class BadCaptchaException extends AuthenticationException {
private static final long serialVersionUID = 8337958032785176060L;
public BadCaptchaException(String msg) {
super(msg);
}
}
yst-core/src/main/java/com/elitesland/core/exception/BadConfigurationException.java 0 → 100644
View file @ c239a771
/*
* Copyright 2019-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.elitesland.core.exception;
/**
* <pre>
* 统一关于错误配置信息 异常
* </pre>
*
* @author Mir
* @date 2020-06-20
*/
public class BadConfigurationException extends RuntimeException {
private static final long serialVersionUID = -5628549105671311130L;
/**
* Constructs a new runtime exception with {@code null} as its
* detail message. The cause is not initialized, and may subsequently be
* initialized by a call to {@link #initCause}.
*/
public BadConfigurationException() {
super();
}
/**
* Constructs a new runtime exception with the specified detail message.
* The cause is not initialized, and may subsequently be initialized by a
* call to {@link #initCause}.
*
* @param message the detail message. The detail message is saved for
* later retrieval by the {@link #getMessage()} method.
*/
public BadConfigurationException(String message) {
super(message);
}
/**
* Constructs a new runtime exception with the specified detail message and
* cause. <p>Note that the detail message associated with
* {@code cause} is <i>not</i> automatically incorporated in
* this runtime exception's detail message.
*
* @param message the detail message (which is saved for later retrieval
* by the {@link #getMessage()} method).
* @param cause the cause (which is saved for later retrieval by the
* {@link #getCause()} method). (A {@code null} value is
* permitted, and indicates that the cause is nonexistent or
* unknown.)
* @since 1.4
*/
public BadConfigurationException(String message, Throwable cause) {
super(message, cause);
}
/**
* Constructs a new runtime exception with the specified cause and a
* detail message of {@code (cause==null ? null : cause.toString())}
* (which typically contains the class and detail message of
* {@code cause}). This constructor is useful for runtime exceptions
* that are little more than wrappers for other throwables.
*
* @param cause the cause (which is saved for later retrieval by the
* {@link #getCause()} method). (A {@code null} value is
* permitted, and indicates that the cause is nonexistent or
* unknown.)
* @since 1.4
*/
public BadConfigurationException(Throwable cause) {
super(cause);
}
/**
* Constructs a new runtime exception with the specified detail
* message, cause, suppression enabled or disabled, and writable
* stack trace enabled or disabled.
*
* @param message the detail message.
* @param cause the cause. (A {@code null} value is permitted,
* and indicates that the cause is nonexistent or unknown.)
* @param enableSuppression whether or not suppression is enabled
* or disabled
* @param writableStackTrace whether or not the stack trace should
* be writable
* @since 1.7
*/
protected BadConfigurationException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
}
yst-core/src/main/java/com/elitesland/core/exception/BadJwtTokenException.java 0 → 100644
View file @ c239a771
package com.elitesland.core.exception;
import org.springframework.security.core.AuthenticationException;
/**
* <p>
* JWT Token验证失败的异常
* </p>
*
* @author Mir
* @date 2020/7/4
*/
public class BadJwtTokenException extends AuthenticationException {
private static final long serialVersionUID = 7542672984694936118L;
public BadJwtTokenException(String msg) {
super(msg);
}
}
yst-core/src/main/java/com/elitesland/core/exception/BusinessException.java 0 → 100644
View file @ c239a771
package com.elitesland.core.exception;
import com.elitesland.core.base.ApiCode;
import lombok.Getter;
import java.util.function.Supplier;
/**
* <pre>
* 业务异常
* </pre>
*
* @author Mir
* @date 2020/6/22
*/
@Getter
public class BusinessException extends RuntimeException implements Supplier<BusinessException> {
private static final long serialVersionUID = -2205002357611194846L;
private ApiCode code;
public BusinessException() {
super();
}
public BusinessException(String message) {
super(message);
}
public BusinessException(ApiCode code, String message) {
super(message);
this.code = code;
}
public BusinessException(String message, Throwable cause) {
super(message, cause);
}
public BusinessException(Throwable cause) {
super(cause);
}
public BusinessException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
@Override
public BusinessException get() {
return this;
}
}
yst-core/src/main/java/com/elitesland/core/exception/CaptchaExpiredException.java 0 → 100644
View file @ c239a771
package com.elitesland.core.exception;
import org.springframework.security.core.AuthenticationException;
/**
* <pre>
* [功能说明]
* </pre>
*
* @author Mir
* @date 2020/6/24
*/
public class CaptchaExpiredException extends AuthenticationException {
private static final long serialVersionUID = -2209433381756411634L;
public CaptchaExpiredException(String msg) {
super(msg);
}
}
yst-core/src/main/java/com/elitesland/core/exception/handler/GlobalExceptionHandler.java 0 → 100644
View file @ c239a771
package com.elitesland.core.exception.handler;
import lombok.extern.slf4j.Slf4j;
/**
* <pre>
* [功能说明]
* </pre>
*
* @author Mir
* @date 2020/6/22
*/
@Slf4j
//@ControllerAdvice
public class GlobalExceptionHandler {
// @ExceptionHandler(BadRequestException.class)
// public ApiResult<Object> handleBadRequestException(BadRequestException e) {
// log.error(ThrowableUtil.getStackTrace(e));
// return ApiResult.fail(ApiCode.VERIFICATION_CODE_EXCEPTION, ThrowableUtil.getStackTrace(e));
// }
// @ExceptionHandler(BusinessException.class)
// @ResponseBody
// public ApiResult<Object> handleBusinessException(BusinessException e) {
// log.error(ThrowableUtil.getStackTrace(e));
// return ApiResult.fail(e.getCode(), e.getMessage());
// }
// @ExceptionHandler(BadJwtTokenException.class)
// public ApiResult<Object> handleAuthenticationException(AuthenticationException e) {
// log.error(ThrowableUtil.getStackTrace(e));
// return ApiResult.fail(ApiCode.VERIFICATION_CODE_EXCEPTION, ThrowableUtil.getStackTrace(e));
// }
}
yst-core/src/main/java/com/elitesland/core/exception/rest/FilterErrorController.java 0 → 100644
View file @ c239a771
package com.elitesland.core.exception.rest;
import com.elitesland.core.base.ApiCode;
import com.elitesland.core.base.ApiResult;
import com.elitesland.core.exception.BusinessException;
import com.elitesland.core.vo.RequestBindingErrorVO;
import lombok.extern.slf4j.Slf4j;
import lombok.val;
import org.springframework.boot.autoconfigure.web.ErrorProperties;
import org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController;
import org.springframework.boot.web.error.ErrorAttributeOptions;
import org.springframework.boot.web.servlet.error.DefaultErrorAttributes;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
/**
* <pre>
* [功能说明]
* </pre>
*
* @author Mir
* @date 2020/6/24
*/
@RestController
@Slf4j
public class FilterErrorController extends BasicErrorController {
public FilterErrorController() {
super(new DefaultErrorAttributes(), new ErrorProperties());
}
@Override
@RequestMapping(produces = {MediaType.APPLICATION_JSON_VALUE})
public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
var body = getErrorAttributes(request, ErrorAttributeOptions.of(
ErrorAttributeOptions.Include.MESSAGE,
ErrorAttributeOptions.Include.BINDING_ERRORS,
ErrorAttributeOptions.Include.STACK_TRACE,
ErrorAttributeOptions.Include.EXCEPTION));
// val status = getStatus(request);
log.error(body.toString());
val r = ApiResult.fail(ApiCode.FAIL, body.get("message"));
body = ApiResult.toMap(r);
val o = request.getAttribute("org.springframework.boot.web.servlet.error.DefaultErrorAttributes.ERROR");
if (o instanceof BusinessException) {
val e = (BusinessException) o;
val result = ApiResult.fail(e.getCode() == null ? ApiCode.FAIL : e.getCode(), e.getMessage());
body = ApiResult.toMap(result);
}
/**
* 工作流异常
*/
// if(o instanceof WorkflowException)
// {
// val e = (WorkflowException) o;
// val result = ApiResult.fail( ApiCode.FAIL , e.getMessage());
// body = ApiResult.toMap(result);
// }
if (o instanceof MethodArgumentNotValidException) {
List<RequestBindingErrorVO> errors = ((MethodArgumentNotValidException) o).getBindingResult().getFieldErrors().stream()
.map(e -> {
val vo = new RequestBindingErrorVO();
vo.setField(e.getField()).setMsg(e.getDefaultMessage());
return vo;
}).collect(Collectors.toList());
val result = ApiResult.fail(ApiCode.PARAMETER_EXCEPTION, errors);
body = ApiResult.toMap(result);
}
return ResponseEntity.of(Optional.of(body));
}
@Override
public String getErrorPath() {
return "error/error";
}
}
yst-core/src/main/java/com/elitesland/core/micro/ClockPool.java 0 → 100644
View file @ c239a771
package com.elitesland.core.micro;
import java.sql.Timestamp;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
/**
* Clock Pool
* <p>
* 利用ScheduledExecutorService实现高并发场景下System.currentTimeMillis()的性能问题的优化.
*
* @author Mir
* @date 3/17/2020
*
* https://github.com/yu120/neural
*/
public enum ClockPool {
// ====
INSTANCE(1);
private final long period;
private final AtomicLong nowTime;
private boolean started = false;
private ScheduledExecutorService executorService;
ClockPool(long period) {
this.period = period;
this.nowTime = new AtomicLong(System.currentTimeMillis());
}
/**
* The initialize scheduled executor service
*/
public void initialize() {
if (started) {
return;
}
this.executorService = new ScheduledThreadPoolExecutor(1, r -> {
Thread thread = new Thread(r, "system-clock");
thread.setDaemon(true);
return thread;
});
executorService.scheduleAtFixedRate(() -> nowTime.set(System.currentTimeMillis()),
this.period, this.period, TimeUnit.MILLISECONDS);
Runtime.getRuntime().addShutdownHook(new Thread(this::destroy));
started = true;
}
/**
* The get current time milliseconds
*
* @return long time
*/
public long currentTimeMillis() {
return started ? nowTime.get() : System.currentTimeMillis();
}
/**
* The get string current time
*
* @return string time
*/
public String currentTime() {
return new Timestamp(currentTimeMillis()).toString();
}
/**
* The destroy of executor service
*/
public void destroy() {
if (executorService != null) {
executorService.shutdown();
}
}
}
yst-core/src/main/java/com/elitesland/core/micro/Snowflake.java 0 → 100644
View file @ c239a771
package com.elitesland.core.micro;
import java.net.InetAddress;
import java.util.concurrent.ThreadLocalRandom;
/**
* 基于Twitter的Snowflake算法实现分布式高效有序ID生产黑科技(sequence)——升级版Snowflake
*
* <br>
* SnowFlake的结构如下(每部分用-分开):<br>
* <br>
* 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 <br>
* <br>
* 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0<br>
* <br>
* 41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截)
* 得到的值），这里的的开始时间截，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下START_TIME属性）。
* 41位的时间截，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69<br>
* <br>
* 10位的数据机器位，可以部署在1024个节点，包括5位dataCenterId和5位workerId<br>
* <br>
* 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号<br>
* <br>
* <br>
* 加起来刚好64位，为一个Long型。<br>
* SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，
* 并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。
* <p>
* <p>
* 特性：
* 1.支持自定义允许时间回拨的范围<p>
* 2.解决跨毫秒起始值每次为0开始的情况（避免末尾必定为偶数，而不便于取余使用问题）<p>
* 3.解决高并发场景中获取时间戳性能问题<p>
* 4.支撑根据IP末尾数据作为workerId
* 5.时间回拨方案思考：1024个节点中分配10个点作为时间回拨序号（连续10次时间回拨的概率较小）
*
* @author Mir
* @date 3/17/2020
*
* https://github.com/yu120/neural
*/
public class Snowflake {
/**
* 起始时间戳
**/
private final static long START_TIME = 1519740777809L;
/**
* dataCenterId占用的位数：2
**/
private final static long DATA_CENTER_ID_BITS = 2L;
/**
* workerId占用的位数：8
**/
private final static long WORKER_ID_BITS = 8L;
/**
* 序列号占用的位数：12（表示只允许workId的范围为：0-4095）
**/
private final static long SEQUENCE_BITS = 12L;
/**
* workerId可以使用范围：0-255
**/
private final static long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS);
/**
* dataCenterId可以使用范围：0-3
**/
private final static long MAX_DATA_CENTER_ID = ~(-1L << DATA_CENTER_ID_BITS);
private final static long WORKER_ID_SHIFT = SEQUENCE_BITS;
private final static long DATA_CENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;
private final static long TIMESTAMP_LEFT_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATA_CENTER_ID_BITS;
/**
* 用mask防止溢出:位与运算保证计算的结果范围始终是 0-4095
**/
private final static long SEQUENCE_MASK = ~(-1L << SEQUENCE_BITS);
private final long workerId;
private final long dataCenterId;
private long sequence = 0L;
private long lastTimestamp = -1L;
private static byte LAST_IP = 0;
private final boolean clock;
private final long timeOffset;
private final boolean randomSequence;
private final ThreadLocalRandom tlr = ThreadLocalRandom.current();
public Snowflake(long dataCenterId) {
this(dataCenterId, 0x000000FF & getLastIPAddress(), false, 5L, false);
}
public Snowflake(long dataCenterId, boolean clock, boolean randomSequence) {
this(dataCenterId, 0x000000FF & getLastIPAddress(), clock, 5L, randomSequence);
}
/**
* 基于Snowflake创建分布式ID生成器
*
* @param dataCenterId 数据中心ID,数据范围为0~255
* @param workerId 工作机器ID,数据范围为0~3
* @param clock true表示解决高并发下获取时间戳的性能问题
* @param timeOffset 允许时间回拨的毫秒量,建议5ms
* @param randomSequence true表示使用毫秒内的随机序列(超过范围则取余)
*/
public Snowflake(long dataCenterId, long workerId, boolean clock, long timeOffset, boolean randomSequence) {
if (dataCenterId > MAX_DATA_CENTER_ID || dataCenterId < 0) {
throw new IllegalArgumentException("Data Center Id can't be greater than " +
MAX_DATA_CENTER_ID + " or less than 0");
}
if (workerId > MAX_WORKER_ID || workerId < 0) {
throw new IllegalArgumentException("Worker Id can't be greater than " +
MAX_WORKER_ID + " or less than 0");
}
this.workerId = workerId;
this.dataCenterId = dataCenterId;
this.clock = clock;
this.timeOffset = timeOffset;
this.randomSequence = randomSequence;
}
/**
* 获取ID
*
* @return long
*/
public synchronized Long nextId() {
long currentTimestamp = this.timeGen();
// 闰秒：如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过，这个时候应当抛出异常
if (currentTimestamp < lastTimestamp) {
// 校验时间偏移回拨量
long offset = lastTimestamp - currentTimestamp;
if (offset > timeOffset) {
throw new RuntimeException("Clock moved backwards, refusing to generate id for [" + offset + "ms]");
}
try {
// 时间回退timeOffset毫秒内，则允许等待2倍的偏移量后重新获取，解决小范围的时间回拨问题
this.wait(offset << 1);
} catch (Exception e) {
throw new RuntimeException(e);
}
// 再次获取
currentTimestamp = this.timeGen();
// 再次校验
if (currentTimestamp < lastTimestamp) {
throw new RuntimeException("Clock moved backwards, refusing to generate id for [" + offset + "ms]");
}
}
// 同一毫秒内序列直接自增
if (lastTimestamp == currentTimestamp) {
// randomSequence为true表示随机生成允许范围内的序列起始值并取余数,否则毫秒内起始值为0L开始自增
long tempSequence = sequence + 1;
if (randomSequence && tempSequence > SEQUENCE_MASK) {
tempSequence = tempSequence % SEQUENCE_MASK;
}
// 通过位与运算保证计算的结果范围始终是 0-4095
sequence = tempSequence & SEQUENCE_MASK;
if (sequence == 0) {
currentTimestamp = this.tilNextMillis(lastTimestamp);
}
} else {
// randomSequence为true表示随机生成允许范围内的序列起始值,否则毫秒内起始值为0L开始自增
sequence = randomSequence ? tlr.nextLong(SEQUENCE_MASK + 1) : 0L;
}
lastTimestamp = currentTimestamp;
long currentOffsetTime = currentTimestamp - START_TIME;
/*
* 1.左移运算是为了将数值移动到对应的段(41、5、5，12那段因为本来就在最右，因此不用左移)
* 2.然后对每个左移后的值(la、lb、lc、sequence)做位或运算，是为了把各个短的数据合并起来，合并成一个二进制数
* 3.最后转换成10进制，就是最终生成的id
*/
return (currentOffsetTime << TIMESTAMP_LEFT_SHIFT) |
// 数据中心位
(dataCenterId << DATA_CENTER_ID_SHIFT) |
// 工作ID位
(workerId << WORKER_ID_SHIFT) |
// 毫秒序列化位
sequence;
}
/**
* 保证返回的毫秒数在参数之后(阻塞到下一个毫秒，直到获得新的时间戳)——CAS
*
* @param lastTimestamp last timestamp
* @return next millis
*/
private long tilNextMillis(long lastTimestamp) {
long timestamp = this.timeGen();
while (timestamp <= lastTimestamp) {
// 如果发现时间回拨，则自动重新获取（可能会处于无限循环中）
timestamp = this.timeGen();
}
return timestamp;
}
/**
* 获得系统当前毫秒时间戳
*
* @return timestamp 毫秒时间戳
*/
private long timeGen() {
return clock ? ClockPool.INSTANCE.currentTimeMillis() : System.currentTimeMillis();
}
/**
* 用IP地址最后几个字节标示
* <p>
* eg:192.168.1.30->30
*
* @return last IP
*/
private static byte getLastIPAddress() {
if (LAST_IP != 0) {
return LAST_IP;
}
try {
InetAddress inetAddress = InetAddress.getLocalHost();
byte[] addressByte = inetAddress.getAddress();
LAST_IP = addressByte[addressByte.length - 1];
} catch (Exception e) {
throw new RuntimeException("Unknown Host Exception", e);
}
return LAST_IP;
}
}
yst-core/src/main/java/com/elitesland/core/util/CallBack.java 0 → 100644
View file @ c239a771
/*
* Copyright 2019-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.elitesland.core.util;
/**
* @author: liaojinlong
* @date: 2020/6/9 17:02
* @since: 1.0
* @see {@link SpringContextHolder}
* 针对某些初始化方法，在SpringContextHolder 初始化前时，<br>
* 可提交一个 提交回调任务。<br>
* 在SpringContextHolder 初始化后，进行回调使用
*/
public interface CallBack {
/**
* 回调执行方法
*/
void executor();
/**
* 本回调任务名称
* @return /
*/
default String getCallBackName() {
return Thread.currentThread().getId() + ":" + this.getClass().getName();
}
}
yst-core/src/main/java/com/elitesland/core/util/ElAdminConstant.java 0 → 100644
View file @ c239a771
/*
* Copyright 2019-2020 Zheng Jie
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.elitesland.core.util;
/**
* 常用静态常量
*
* @author Zheng Jie
* @date 2018-12-26
*/
public class ElAdminConstant {
/**
* 用于IP定位转换
*/
public static final String REGION = "内网IP|内网IP";
/**
* win 系统
*/
public static final String WIN = "win";
/**
* mac 系统
*/
public static final String MAC = "mac";
/**
* 常用接口
*/
public static class Url {
// 免费图床
public static final String SM_MS_URL = "https://sm.ms/api";
// IP归属地查询
public static final String IP_URL = "http://whois.pconline.com.cn/ipJson.jsp?ip=%s&json=true";
}
}
yst-core/src/main/java/com/elitesland/core/util/ElStringUtils.java 0 → 100644
View file @ c239a771
/*
* Copyright 2019-2020 Zheng Jie
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.elitesland.core.util;
import cn.hutool.http.HttpUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import eu.bitwalker.useragentutils.Browser;
import eu.bitwalker.useragentutils.UserAgent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Calendar;
import java.util.Date;
/**
* @author Zheng Jie
* 字符串工具类, 继承org.apache.commons.lang3.StringUtils类
*/
public class ElStringUtils extends org.apache.commons.lang3.StringUtils {
private static final Logger log = LoggerFactory.getLogger(ElStringUtils.class);
private static boolean ipLocal = false;
private static File file = null;
//TODO 需要实现IP对地域的转换功能
// private static DbConfig config;
private static final char SEPARATOR = '_';
private static final String UNKNOWN = "unknown";
static {
// SpringContextHolder.addCallBacks(() -> {
// ElStringUtils.ipLocal = SpringContextHolder.getProperties("ip.local-parsing", false, Boolean.class);
// if (ipLocal) {
// /*
// * 此文件为独享 ，不必关闭
// */
// String path = "ip2region/ip2region.db";
// String name = "ip2region.db";
// try {
// config = new DbConfig();
// file = FileUtil.inputStreamToFile(new ClassPathResource(path).getInputStream(), name);
// } catch (Exception e) {
// log.error(e.getMessage(), e);
// }
// }
// });
}
/**
* 驼峰命名法工具
*
* @return toCamelCase(" hello_world ") == "helloWorld"
* toCapitalizeCamelCase("hello_world") == "HelloWorld"
* toUnderScoreCase("helloWorld") = "hello_world"
*/
public static String toCamelCase(String s) {
if (s == null) {
return null;
}
s = s.toLowerCase();
StringBuilder sb = new StringBuilder(s.length());
boolean upperCase = false;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c == SEPARATOR) {
upperCase = true;
} else if (upperCase) {
sb.append(Character.toUpperCase(c));
upperCase = false;
} else {
sb.append(c);
}
}
return sb.toString();
}
/**
* 驼峰命名法工具
*
* @return toCamelCase(" hello_world ") == "helloWorld"
* toCapitalizeCamelCase("hello_world") == "HelloWorld"
* toUnderScoreCase("helloWorld") = "hello_world"
*/
public static String toCapitalizeCamelCase(String s) {
if (s == null) {
return null;
}
s = toCamelCase(s);
return s.substring(0, 1).toUpperCase() + s.substring(1);
}
/**
* 驼峰命名法工具
*
* @return toCamelCase(" hello_world ") == "helloWorld"
* toCapitalizeCamelCase("hello_world") == "HelloWorld"
* toUnderScoreCase("helloWorld") = "hello_world"
*/
static String toUnderScoreCase(String s) {
if (s == null) {
return null;
}
StringBuilder sb = new StringBuilder();
boolean upperCase = false;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
boolean nextUpperCase = true;
if (i < (s.length() - 1)) {
nextUpperCase = Character.isUpperCase(s.charAt(i + 1));
}
if ((i > 0) && Character.isUpperCase(c)) {
if (!upperCase || !nextUpperCase) {
sb.append(SEPARATOR);
}
upperCase = true;
} else {
upperCase = false;
}
sb.append(Character.toLowerCase(c));
}
return sb.toString();
}
/**
* 获取ip地址
*/
public static String getIp(HttpServletRequest request) {
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("WL-Proxy-Client-IP");
}
if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
ip = request.getRemoteAddr();
}
String comma = ",";
String localhost = "127.0.0.1";
if (ip.contains(comma)) {
ip = ip.split(",")[0];
}
if (localhost.equals(ip)) {
// 获取本机真正的ip地址
try {
ip = InetAddress.getLocalHost().getHostAddress();
} catch (UnknownHostException e) {
log.error(e.getMessage(), e);
}
}
return ip;
}
/**
* 根据ip获取详细地址
*/
public static String getCityInfo(String ip) {
if (ipLocal) {
return getLocalCityInfo(ip);
} else {
return ip;
//TODO: 需要优化根据各种网络环境的IP地域获取机制-2020-09-22
// return getHttpCityInfo(ip);
}
}
/**
* 根据ip获取详细地址
*/
public static String getHttpCityInfo(String ip) {
String api = String.format(ElAdminConstant.Url.IP_URL, ip);
JSONObject object = JSONUtil.parseObj(HttpUtil.get(api));
return object.get("addr", String.class);
}
/**
* 根据ip获取详细地址
*/
public static String getLocalCityInfo(String ip) {
// try {
// DataBlock dataBlock = new DbSearcher(config, file.getPath())
// .binarySearch(ip);
// String region = dataBlock.getRegion();
// String address = region.replace("0|", "");
// char symbol = '|';
// if (address.charAt(address.length() - 1) == symbol) {
// address = address.substring(0, address.length() - 1);
// }
// return address.equals(ElAdminConstant.REGION) ? "内网IP" : address;
// } catch (Exception e) {
// log.error(e.getMessage(), e);
// }
return "待实现";
}
public static String getBrowser(HttpServletRequest request) {
UserAgent userAgent = UserAgent.parseUserAgentString(request.getHeader("User-Agent"));
Browser browser = userAgent.getBrowser();
return browser.getName();
}
/**
* 获得当天是周几
*/
public static String getWeekDay() {
String[] weekDays = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
Calendar cal = Calendar.getInstance();
cal.setTime(new Date());
int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
if (w < 0) {
w = 0;
}
return weekDays[w];
}
/**
* 获取当前机器的IP
*
* @return /
*/
public static String getLocalIp() {
InetAddress addr;
try {
addr = InetAddress.getLocalHost();
} catch (UnknownHostException e) {
return "unknown";
}
byte[] ipAddr = addr.getAddress();
StringBuilder ipAddrStr = new StringBuilder();
for (int i = 0; i < ipAddr.length; i++) {
if (i > 0) {
ipAddrStr.append(".");
}
ipAddrStr.append(ipAddr[i] & 0xFF);
}
return ipAddrStr.toString();
}
}
yst-core/src/main/java/com/elitesland/core/util/EncryptUtils.java 0 → 100644
View file @ c239a771
/*
* Copyright 2019-2020 Zheng Jie
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.elitesland.core.util;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.nio.charset.StandardCharsets;
/**
* 加密
* @author Zheng Jie
* @date 2018-11-23
*/
public class EncryptUtils {
private static final String STR_PARAM = "Passw0rd";
private static Cipher cipher;
private static final IvParameterSpec IV = new IvParameterSpec(STR_PARAM.getBytes(StandardCharsets.UTF_8));
private static DESKeySpec getDesKeySpec(String source) throws Exception {
if (source == null || source.length() == 0){
return null;
}
cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
String strKey = "Passw0rd";
return new DESKeySpec(strKey.getBytes(StandardCharsets.UTF_8));
}
/**
* 对称加密
*/
public static String desEncrypt(String source) throws Exception {
DESKeySpec desKeySpec = getDesKeySpec(source);
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
cipher.init(Cipher.ENCRYPT_MODE, secretKey, IV);
return byte2hex(
cipher.doFinal(source.getBytes(StandardCharsets.UTF_8))).toUpperCase();
}
/**
* 对称解密
*/
public static String desDecrypt(String source) throws Exception {
byte[] src = hex2byte(source.getBytes(StandardCharsets.UTF_8));
DESKeySpec desKeySpec = getDesKeySpec(source);
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
cipher.init(Cipher.DECRYPT_MODE, secretKey, IV);
byte[] retByte = cipher.doFinal(src);
return new String(retByte);
}
private static String byte2hex(byte[] inStr) {
String stmp;
StringBuilder out = new StringBuilder(inStr.length * 2);
for (byte b : inStr) {
stmp = Integer.toHexString(b & 0xFF);
if (stmp.length() == 1) {
// 如果是0至F的单位字符串，则添加0
out.append("0").append(stmp);
} else {
out.append(stmp);
}
}
return out.toString();
}
private static byte[] hex2byte(byte[] b) {
int size = 2;
if ((b.length % size) != 0){
throw new IllegalArgumentException("长度不是偶数");
}
byte[] b2 = new byte[b.length / 2];
for (int n = 0; n < b.length; n += size) {
String item = new String(b, n, 2);
b2[n / 2] = (byte) Integer.parseInt(item, 16);
}
return b2;
}
}
yst-core/src/main/java/com/elitesland/core/util/HttpServletResponseUtil.java 0 → 100644
View file @ c239a771
package com.elitesland.core.util;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import lombok.val;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.time.LocalDateTime;
/**
* @author Mir
* @date 2018-11-08
*/
public final class HttpServletResponseUtil {
private static String UTF8 = "UTF-8";
private static String CONTENT_TYPE = "application/json";
private HttpServletResponseUtil() {
throw new AssertionError();
}
public static void printJSON(HttpServletResponse response, Object object) throws Exception {
val mapper = new ObjectMapper();
val javaTimeModule = new JavaTimeModule();
javaTimeModule.addSerializer(LocalDateTime.class, SpringContextHolder.getBean(LocalDateTimeSerializer.class));
javaTimeModule.addDeserializer(LocalDateTime.class, SpringContextHolder.getBean(LocalDateTimeDeserializer.class));
mapper.registerModule(javaTimeModule);
response.setCharacterEncoding(UTF8);
response.setContentType(CONTENT_TYPE);
PrintWriter printWriter = response.getWriter();
printWriter.write(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(object));
printWriter.flush();
printWriter.close();
}
}
yst-core/src/main/java/com/elitesland/core/util/IdGenerator.java 0 → 100644
View file @ c239a771
package com.elitesland.core.util;
import com.elitesland.core.micro.Snowflake;
import org.hibernate.HibernateException;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.id.IdentifierGenerator;
import java.io.Serializable;
/**
* 适用于JPA的基于Snowflake算法的ID生成器
*
* @author Moz
* @date 3/17/2020
*/
public class IdGenerator implements IdentifierGenerator {
private final Snowflake snowflake = new Snowflake(1);
@Override
public Serializable generate(SharedSessionContractImplementor sharedSessionContractImplementor, Object o) throws HibernateException {
return snowflake.nextId();
}
public Snowflake getSnowflake() {
return this.snowflake;
}
}
yst-core/src/main/java/com/elitesland/core/util/PageUtil.java 0 → 100644
View file @ c239a771
/*
* Copyright 2019-2020 Zheng Jie
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.elitesland.core.util;
import org.springframework.data.domain.Page;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* 分页工具
* @author Mir
* @date 2018-12-10
*/
public class PageUtil extends cn.hutool.core.util.PageUtil {
/**
* List 分页
*/
public static List toPage(int page, int size , List list) {
int fromIndex = page * size;
int toIndex = page * size + size;
if(fromIndex > list.size()){
return new ArrayList();
} else if(toIndex >= list.size()) {
return list.subList(fromIndex,list.size());
} else {
return list.subList(fromIndex,toIndex);
}
}
/**
* Page 数据处理，预防redis反序列化报错
*/
public static Map<String,Object> toPage(Page page) {
Map<String,Object> map = new LinkedHashMap<>(2);
map.put("content",page.getContent());
map.put("totalElements",page.getTotalElements());
return map;
}
/**
* 自定义分页
*/
public static Map<String,Object> toPage(Object object, Object totalElements) {
Map<String,Object> map = new LinkedHashMap<>(2);
map.put("content",object);
map.put("totalElements",totalElements);
return map;
}
}
yst-core/src/main/java/com/elitesland/core/util/ParameterRequestWrapper.java 0 → 100644
View file @ c239a771
package com.elitesland.core.util;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
/**
* <pre>
* 封装请求，并替换getParameter从原有的Parameter获取值，为从Attribute中获取值
* </pre>
*
* @author Mir
* @date 2020/6/16
*/
public class ParameterRequestWrapper extends HttpServletRequestWrapper {
public ParameterRequestWrapper(HttpServletRequest request) {
super(request);
}
@Override
public String getParameter(String name) {
return (String) super.getAttribute(name);
}
}
yst-core/src/main/java/com/elitesland/core/util/RequestUtil.java 0 → 100644
View file @ c239a771
package com.elitesland.core.util;
import lombok.val;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.ServletRequest;
import java.io.BufferedReader;
import java.io.IOException;
/**
* <pre>
* 将请求的body的二进制内容转为字符串
* </pre>
*
* @author Mir
* @date 2020/6/16
*/
public class RequestUtil {
private static final Logger log = LoggerFactory.getLogger(RequestUtil.class);
private RequestUtil() {
}
public static String obtainBody(ServletRequest request) {
BufferedReader br = null;
val sb = new StringBuilder();
try {
br = request.getReader();
String str;
while ((str = br.readLine()) != null) {
sb.append(str);
}
br.close();
} catch (IOException e) {
log.error("request body error");
} finally {
if (null != br) {
try {
br.close();
} catch (IOException e) {
log.error("request reader close error");
}
}
}
return sb.toString();
}
}
yst-core/src/main/java/com/elitesland/core/util/RsaUtils.java 0 → 100644
View file @ c239a771
package com.elitesland.core.util;
import org.apache.commons.codec.binary.Base64;
import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
/**
* @author https://www.cnblogs.com/nihaorz/p/10690643.html
* @description Rsa 工具类，公钥私钥生成，加解密
* @date 2020-05-18
**/
public class RsaUtils {
private static final String SRC = "123456";
public static void main(String[] args) throws Exception {
System.out.println("\n");
RsaKeyPair keyPair = generateKeyPair();
System.out.println("公钥：" + keyPair.getPublicKey());
System.out.println("私钥：" + keyPair.getPrivateKey());
System.out.println("\n");
test1(keyPair);
System.out.println("\n");
test2(keyPair);
System.out.println("\n");
}
/**
* 公钥加密私钥解密
*/
private static void test1(RsaKeyPair keyPair) throws Exception {
System.out.println("***************** 公钥加密私钥解密开始 *****************");
String text1 = encryptByPublicKey(keyPair.getPublicKey(), RsaUtils.SRC);
String text2 = decryptByPrivateKey(keyPair.getPrivateKey(), text1);
System.out.println("加密前：" + RsaUtils.SRC);
System.out.println("加密后：" + text1);
System.out.println("解密后：" + text2);
if (RsaUtils.SRC.equals(text2)) {
System.out.println("解密字符串和原始字符串一致，解密成功");
} else {
System.out.println("解密字符串和原始字符串不一致，解密失败");
}
System.out.println("***************** 公钥加密私钥解密结束 *****************");
}
/**
* 私钥加密公钥解密
* @throws Exception /
*/
private static void test2(RsaKeyPair keyPair) throws Exception {
System.out.println("***************** 私钥加密公钥解密开始 *****************");
String text1 = encryptByPrivateKey(keyPair.getPrivateKey(), RsaUtils.SRC);
String text2 = decryptByPublicKey(keyPair.getPublicKey(), text1);
System.out.println("加密前：" + RsaUtils.SRC);
System.out.println("加密后：" + text1);
System.out.println("解密后：" + text2);
if (RsaUtils.SRC.equals(text2)) {
System.out.println("解密字符串和原始字符串一致，解密成功");
} else {
System.out.println("解密字符串和原始字符串不一致，解密失败");
}
System.out.println("***************** 私钥加密公钥解密结束 *****************");
}
/**
* 公钥解密
*
* @param publicKeyText 公钥
* @param text 待解密的信息
* @return /
* @throws Exception /
*/
public static String decryptByPublicKey(String publicKeyText, String text) throws Exception {
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyText));
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, publicKey);
byte[] result = cipher.doFinal(Base64.decodeBase64(text));
return new String(result);
}
/**
* 私钥加密
*
* @param privateKeyText 私钥
* @param text 待加密的信息
* @return /
* @throws Exception /
*/
public static String encryptByPrivateKey(String privateKeyText, String text) throws Exception {
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyText));
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
byte[] result = cipher.doFinal(text.getBytes());
return Base64.encodeBase64String(result);
}
/**
* 私钥解密
*
* @param privateKeyText 私钥
* @param text 待解密的文本
* @return /
* @throws Exception /
*/
public static String decryptByPrivateKey(String privateKeyText, String text) throws Exception {
PKCS8EncodedKeySpec pkcs8EncodedKeySpec5 = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyText));
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec5);
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] result = cipher.doFinal(Base64.decodeBase64(text));
return new String(result);
}
/**
* 公钥加密
*
* @param publicKeyText 公钥
* @param text 待加密的文本
* @return /
*/
public static String encryptByPublicKey(String publicKeyText, String text) throws Exception {
X509EncodedKeySpec x509EncodedKeySpec2 = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyText));
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec2);
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] result = cipher.doFinal(text.getBytes());
return Base64.encodeBase64String(result);
}
/**
* 构建RSA密钥对
*
* @return /
* @throws NoSuchAlgorithmException /
*/
public static RsaKeyPair generateKeyPair() throws NoSuchAlgorithmException {
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(1024);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
String publicKeyString = Base64.encodeBase64String(rsaPublicKey.getEncoded());
String privateKeyString = Base64.encodeBase64String(rsaPrivateKey.getEncoded());
return new RsaKeyPair(publicKeyString, privateKeyString);
}
/**
* RSA密钥对对象
*/
public static class RsaKeyPair {
private final String publicKey;
private final String privateKey;
public RsaKeyPair(String publicKey, String privateKey) {
this.publicKey = publicKey;
this.privateKey = privateKey;
}
public String getPublicKey() {
return publicKey;
}
public String getPrivateKey() {
return privateKey;
}
}
}
yst-core/src/main/java/com/elitesland/core/util/SpringContextHolder.java 0 → 100644
View file @ c239a771
/*
* Copyright 2019-2020 Zheng Jie
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.elitesland.core.util;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.core.env.Environment;
import java.util.ArrayList;
import java.util.List;
/**
* @author Jie
* @date 2019-01-07
*/
@Slf4j
public class SpringContextHolder implements ApplicationContextAware, DisposableBean {
private static ApplicationContext applicationContext = null;
private static final List<CallBack> CALL_BACKS = new ArrayList<>();
private static boolean addCallback = true;
/**
* 针对 某些初始化方法，在SpringContextHolder 未初始化时 提交回调方法。
* 在SpringContextHolder 初始化后，进行回调使用
*
* @param callBack 回调函数
*/
public synchronized static void addCallBacks(CallBack callBack) {
if (addCallback) {
SpringContextHolder.CALL_BACKS.add(callBack);
} else {
log.warn("CallBack：{} 已无法添加！立即执行", callBack.getCallBackName());
callBack.executor();
}
}
/**
* 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
*/
@SuppressWarnings("unchecked")
public static <T> T getBean(String name) {
assertContextInjected();
return (T) applicationContext.getBean(name);
}
/**
* 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
*/
public static <T> T getBean(Class<T> requiredType) {
assertContextInjected();
return applicationContext.getBean(requiredType);
}
/**
* 获取SpringBoot 配置信息
*
* @param property 属性key
* @param defaultValue 默认值
* @param requiredType 返回类型
* @return /
*/
public static <T> T getProperties(String property, T defaultValue, Class<T> requiredType) {
T result = defaultValue;
try {
result = getBean(Environment.class).getProperty(property, requiredType);
} catch (Exception ignored) {}
return result;
}
/**
* 获取SpringBoot 配置信息
*
* @param property 属性key
* @return /
*/
public static String getProperties(String property) {
return getProperties(property, null, String.class);
}
/**
* 获取SpringBoot 配置信息
*
* @param property 属性key
* @param requiredType 返回类型
* @return /
*/
public static <T> T getProperties(String property, Class<T> requiredType) {
return getProperties(property, null, requiredType);
}
/**
* 检查ApplicationContext不为空.
*/
private static void assertContextInjected() {
if (applicationContext == null) {
throw new IllegalStateException("applicaitonContext属性未注入, 请在applicationContext" +
".xml中定义SpringContextHolder或在SpringBoot启动类中注册SpringContextHolder.");
}
}
/**
* 清除SpringContextHolder中的ApplicationContext为Null.
*/
private static void clearHolder() {
log.debug("清除SpringContextHolder中的ApplicationContext:"
+ applicationContext);
applicationContext = null;
}
@Override
public void destroy() {
SpringContextHolder.clearHolder();
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
if (SpringContextHolder.applicationContext != null) {
log.warn("SpringContextHolder中的ApplicationContext被覆盖, 原有ApplicationContext为:" + SpringContextHolder.applicationContext);
}
SpringContextHolder.applicationContext = applicationContext;
if (addCallback) {
for (CallBack callBack : SpringContextHolder.CALL_BACKS) {
callBack.executor();
}
CALL_BACKS.clear();
}
SpringContextHolder.addCallback = false;
}
}
yst-core/src/main/java/com/elitesland/core/util/ThrowableUtil.java 0 → 100644
View file @ c239a771
package com.elitesland.core.util;
import lombok.val;
import java.io.PrintWriter;
import java.io.StringWriter;
/**
* <pre>
* 整理异常中的堆栈信息，返回信息字符串
* </pre>
*
* @author Mir
* @date 2020/6/22
*/
public class ThrowableUtil {
public static String getStackTrace(Throwable e) {
val sw = new StringWriter();
try (val pw = new PrintWriter(sw)) {
e.printStackTrace(pw);
return sw.toString();
}
}
}
yst-core/src/main/java/com/elitesland/core/util/UUIDUtil.java 0 → 100644
View file @ c239a771
package com.elitesland.core.util;
import java.util.UUID;
/**
* @author Mir
* @date 2018-11-08
*/
public class UUIDUtil {
/**
* 随机生成UUID
*
* @return UUID字符串，不含连接符
*/
public static String getUUID() {
return UUID.randomUUID().toString().replaceAll("-", "");
}
}
yst-core/src/main/java/com/elitesland/core/vo/RequestBindingErrorVO.java 0 → 100644
View file @ c239a771
package com.elitesland.core.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.experimental.Accessors;
import java.io.Serializable;
/**
* <pre>
* [功能说明]
* </pre>
*
* @author Mir
* @date 2020/7/6
*/
@Data
@Accessors(chain = true)
@ApiModel("请求对象参数绑定错误")
public class RequestBindingErrorVO implements Serializable {
private static final long serialVersionUID = -4297055572902473228L;
@ApiModelProperty("错误字段")
String field;
@ApiModelProperty("错误信息")
String msg;
}
yst-core/src/main/java/com/elitesland/metadata/convert/MetaCatDefConvert.java 0 → 100644
View file @ c239a771
package com.elitesland.metadata.convert;
import com.elitesland.metadata.entity.MetaCatDefDO;
import com.elitesland.metadata.vo.MetaCatDefVO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
/**
* <pre>作用说明</pre>
*
* @author mir
* @date 11/29/2020 12:37 AM
*/
@Mapper
public interface MetaCatDefConvert {
MetaCatDefConvert INSTANCE = Mappers.getMapper(MetaCatDefConvert.class);
MetaCatDefVO doToVO(MetaCatDefDO def);
MetaCatDefDO voToDO(MetaCatDefVO def);
}
yst-core/src/main/java/com/elitesland/metadata/convert/MetaCatTableConvert.java 0 → 100644
View file @ c239a771
package com.elitesland.metadata.convert;
import com.elitesland.metadata.entity.MetaCatTableDO;
import com.elitesland.metadata.vo.MetaCatTableVO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
/**
* <pre>作用说明</pre>
*
* @author mir
* @date 11/29/2020 12:34 AM
*/
@Mapper
public interface MetaCatTableConvert {
MetaCatTableConvert INSTANCE = Mappers.getMapper(MetaCatTableConvert.class);
MetaCatTableVO doToVO(MetaCatTableDO table);
MetaCatTableDO voToDO(MetaCatTableVO table);
}
yst-core/src/main/java/com/elitesland/metadata/convert/MetaColumnConvert.java 0 → 100644
View file @ c239a771
package com.elitesland.metadata.convert;
import com.elitesland.metadata.entity.MetaColumnDO;
import com.elitesland.metadata.vo.MetaColumnVO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
/**
* <pre>作用说明</pre>
*
* @author mir
* @date 12/3/2020 7:59 PM
*/
@Mapper
public interface MetaColumnConvert {
MetaColumnConvert INSTANCE = Mappers.getMapper(MetaColumnConvert.class);
MetaColumnVO doToVO(MetaColumnDO column);
MetaColumnDO voToDO(MetaColumnVO column);
}
yst-core/src/main/java/com/elitesland/org/entity/OrgBuDO.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-core/src/main/java/com/elitesland/org/entity/OrgOuDO.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-core/src/main/java/com/elitesland/org/repo/OrgBuRepo.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-core/src/main/java/com/elitesland/org/repo/OrgOuRepo.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-core/src/main/java/com/elitesland/org/vo/EmployeeVO.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-core/src/main/java/com/elitesland/org/vo/OrgBuVO.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-core/src/main/java/com/elitesland/org/vo/OrgOuVO.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-core/src/main/java/com/elitesland/org/vo/OrgPostVO.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-core/src/main/java/com/elitesland/system/vo/SysRoleVO.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-core/src/main/java/com/elitesland/system/vo/SysUserVO.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-core/src/main/java/com/elitesland/system/vo/UserVO.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-core/src/main/java/org/hibernate/cfg/InheritanceState.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-demo/Dockerfile 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-demo/build.gradle 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-demo/src/main/java/com/elitesland/DemoApplication.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-demo/src/main/java/com/elitesland/Utils/PayDetail.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-demo/src/main/java/com/elitesland/Utils/PayInfo.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-demo/src/main/java/com/elitesland/Utils/QueueParmas.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-demo/src/main/java/com/elitesland/Utils/QueueUtils.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-demo/src/main/resources/config/application-dev.yml 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-demo/src/main/resources/config/application-prod.yml 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-demo/src/main/resources/config/application.yml 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-demo/src/main/resources/logback.xml 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-user/Dockerfile 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-user/build.gradle 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-user/src/main/java/com/elitesland/UserDemoApplication.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-user/src/main/java/com/elitesland/utils/TokenUtil.java 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-user/src/main/resources/config/application-dev.yml 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-user/src/main/resources/config/application-prod.yml 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-user/src/main/resources/config/application.yml 0 → 100644
View file @ c239a771
This diff is collapsed.
yst-user/src/main/resources/logback.xml 0 → 100644
View file @ c239a771
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment