pengjunjie/JeecgBoot
1
0
Fork 1
mirror of https://github.com/jeecgboot/JeecgBoot.git synced 2025-12-26 16:26:41 +08:00
Code Issues Packages Projects Releases Wiki Activity

后台目录结构大调整，让结构更清晰

Browse Source
This commit is contained in:
zhangdaiscott
2022-08-12 14:14:11 +08:00
parent d135f32b7b
commit ea0f9ed10d
1486 changed files with 94 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

362
jeecg-server-cloud/jeecg-cloud-gateway/src/main/java/org/jeecg/loader/DynamicRouteLoader.java Normal file
View File

@ -0,0 +1,362 @@
package org.jeecg.loader;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.config.listener.Listener;
import com.alibaba.nacos.api.exception.NacosException;
import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.jeecg.common.base.BaseMap;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.config.GatewayRoutersConfig;
import org.jeecg.config.RouterDataType;
import org.jeecg.loader.repository.DynamicRouteService;
import org.jeecg.loader.repository.MyInMemoryRouteDefinitionRepository;
import org.jeecg.loader.vo.MyRouteDefinition;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
import org.springframework.cloud.gateway.filter.FilterDefinition;
import org.springframework.cloud.gateway.handler.predicate.PredicateDefinition;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.context.annotation.DependsOn;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;
/**
* 动态路由加载器
*
* @author : zyf
* @date :2020-11-10
*/
@Slf4j
@Component
@RefreshScope
@DependsOn({"gatewayRoutersConfig"})
public class DynamicRouteLoader implements ApplicationEventPublisherAware {
public static final long DEFAULT_TIMEOUT = 30000;
@Autowired
private GatewayRoutersConfig gatewayRoutersConfig;
private MyInMemoryRouteDefinitionRepository repository;
private ApplicationEventPublisher publisher;
private DynamicRouteService dynamicRouteService;
private ConfigService configService;
private RedisUtil redisUtil;
/**
* 需要拼接key的路由条件
*/
private static String[] GEN_KEY_ROUTERS = new String[]{"Path", "Host", "Method", "After", "Before", "Between", "RemoteAddr"};
public DynamicRouteLoader(MyInMemoryRouteDefinitionRepository repository, DynamicRouteService dynamicRouteService, RedisUtil redisUtil) {
this.repository = repository;
this.dynamicRouteService = dynamicRouteService;
this.redisUtil = redisUtil;
}
// @PostConstruct
// public void init() {
// init(null);
// }
public void init(BaseMap baseMap) {
log.info("初始化路由模式，dataType："+ gatewayRoutersConfig.getDataType());
if (RouterDataType.nacos.toString().endsWith(gatewayRoutersConfig.getDataType())) {
loadRoutesByNacos();
}
//从数据库加载路由
if (RouterDataType.database.toString().endsWith(gatewayRoutersConfig.getDataType())) {
loadRoutesByRedis(baseMap);
}
}
/**
* 刷新路由
*
* @return
*/
public Mono<Void> refresh(BaseMap baseMap) {
log.info("初始化路由模式，dataType："+ gatewayRoutersConfig.getDataType());
if (!RouterDataType.yml.toString().endsWith(gatewayRoutersConfig.getDataType())) {
this.init(baseMap);
}
return Mono.empty();
}
/**
* 从nacos中读取路由配置
*
* @return
*/
private void loadRoutesByNacos() {
List<RouteDefinition> routes = Lists.newArrayList();
configService = createConfigService();
if (configService == null) {
log.warn("initConfigService fail");
}
try {
String configInfo = configService.getConfig(gatewayRoutersConfig.getDataId(), gatewayRoutersConfig.getRouteGroup(), DEFAULT_TIMEOUT);
if (StringUtils.isNotBlank(configInfo)) {
log.info("获取网关当前配置:\r\n{}", configInfo);
routes = JSON.parseArray(configInfo, RouteDefinition.class);
}
} catch (NacosException e) {
log.error("初始化网关路由时发生错误", e);
e.printStackTrace();
}
for (RouteDefinition definition : routes) {
log.info("update route : {}", definition.toString());
dynamicRouteService.add(definition);
}
this.publisher.publishEvent(new RefreshRoutesEvent(this));
dynamicRouteByNacosListener(gatewayRoutersConfig.getDataId(), gatewayRoutersConfig.getRouteGroup());
}
/**
* 从redis中读取路由配置
*
* @return
*/
private void loadRoutesByRedis(BaseMap baseMap) {
List<MyRouteDefinition> routes = Lists.newArrayList();
configService = createConfigService();
if (configService == null) {
log.warn("initConfigService fail");
}
Object configInfo = redisUtil.get(CacheConstant.GATEWAY_ROUTES);
if (ObjectUtil.isNotEmpty(configInfo)) {
log.debug("获取网关当前配置:\r\n{}", configInfo);
JSONArray array = JSON.parseArray(configInfo.toString());
try {
routes = getRoutesByJson(array);
} catch (URISyntaxException e) {
e.printStackTrace();
}
}
for (MyRouteDefinition definition : routes) {
log.debug("update route : {}", definition.toString());
Integer status=definition.getStatus();
if(status.equals(0)){
dynamicRouteService.delete(definition.getId());
}else{
dynamicRouteService.add(definition);
}
}
if(ObjectUtils.isNotEmpty(baseMap)){
String delRouterId = baseMap.get("delRouterId");
if (ObjectUtils.isNotEmpty(delRouterId)) {
dynamicRouteService.delete(delRouterId);
}
}
this.publisher.publishEvent(new RefreshRoutesEvent(this));
}
/**
* redis中的信息需要处理下 转成RouteDefinition对象
* - id: login
* uri: lb://cloud-jeecg-system
* predicates:
* - Path=/jeecg-boot/sys/**,
*
* @param array
* @return
*/
public static List<MyRouteDefinition> getRoutesByJson(JSONArray array) throws URISyntaxException {
List<MyRouteDefinition> ls = new ArrayList<>();
for (int i = 0; i < array.size(); i++) {
JSONObject obj = array.getJSONObject(i);
MyRouteDefinition route = new MyRouteDefinition();
route.setId(obj.getString("routerId"));
route.setStatus(obj.getInteger("status"));
Object uri = obj.get("uri");
if (uri == null) {
route.setUri(new URI("lb://" + obj.getString("name")));
} else {
route.setUri(new URI(obj.getString("uri")));
}
Object predicates = obj.get("predicates");
if (predicates != null) {
JSONArray list = JSON.parseArray(predicates.toString());
List<PredicateDefinition> predicateDefinitionList = new ArrayList<>();
for (Object map : list) {
JSONObject json = (JSONObject) map;
PredicateDefinition predicateDefinition = new PredicateDefinition();
//update-begin-author:zyf date:20220419 for:【VUEN-762】路由条件添加异常问题,原因是部分路由条件参数需要设置固定key
String name=json.getString("name");
predicateDefinition.setName(name);
//路由条件是否拼接Key
if(ArrayUtil.contains(GEN_KEY_ROUTERS,name)) {
JSONArray jsonArray = json.getJSONArray("args");
for (int j = 0; j < jsonArray.size(); j++) {
predicateDefinition.addArg("_genkey" + j, jsonArray.get(j).toString());
}
}else{
JSONObject jsonObject = json.getJSONObject("args");
if(ObjectUtil.isNotEmpty(jsonObject)){
for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
Object valueObj=entry.getValue();
if(ObjectUtil.isNotEmpty(valueObj)) {
predicateDefinition.addArg(entry.getKey(), valueObj.toString());
}
}
}
}
//update-end-author:zyf date:20220419 for:【VUEN-762】路由条件添加异常问题,原因是部分路由条件参数需要设置固定key
predicateDefinitionList.add(predicateDefinition);
}
route.setPredicates(predicateDefinitionList);
}
Object filters = obj.get("filters");
if (filters != null) {
JSONArray list = JSON.parseArray(filters.toString());
List<FilterDefinition> filterDefinitionList = new ArrayList<>();
if (ObjectUtil.isNotEmpty(list)) {
for (Object map : list) {
JSONObject json = (JSONObject) map;
JSONArray jsonArray = json.getJSONArray("args");
String name = json.getString("name");
FilterDefinition filterDefinition = new FilterDefinition();
for (Object o : jsonArray) {
JSONObject params = (JSONObject) o;
filterDefinition.addArg(params.getString("key"), params.get("value").toString());
}
filterDefinition.setName(name);
filterDefinitionList.add(filterDefinition);
}
route.setFilters(filterDefinitionList);
}
}
ls.add(route);
}
return ls;
}
// private void loadRoutesByDataBase() {
// List<GatewayRouteVo> routeList = jdbcTemplate.query(SELECT_ROUTES, new RowMapper<GatewayRouteVo>() {
// @Override
// public GatewayRouteVo mapRow(ResultSet rs, int i) throws SQLException {
// GatewayRouteVo result = new GatewayRouteVo();
// result.setId(rs.getString("id"));
// result.setName(rs.getString("name"));
// result.setUri(rs.getString("uri"));
// result.setStatus(rs.getInt("status"));
// result.setRetryable(rs.getInt("retryable"));
// result.setPredicates(rs.getString("predicates"));
// result.setStripPrefix(rs.getInt("strip_prefix"));
// result.setPersist(rs.getInt("persist"));
// return result;
// }
// });
// if (ObjectUtil.isNotEmpty(routeList)) {
// // 加载路由
// routeList.forEach(route -> {
// RouteDefinition definition = new RouteDefinition();
// List<PredicateDefinition> predicatesList = Lists.newArrayList();
// List<FilterDefinition> filtersList = Lists.newArrayList();
// definition.setId(route.getId());
// String predicates = route.getPredicates();
// String filters = route.getFilters();
// if (StringUtils.isNotEmpty(predicates)) {
// predicatesList = JSON.parseArray(predicates, PredicateDefinition.class);
// definition.setPredicates(predicatesList);
// }
// if (StringUtils.isNotEmpty(filters)) {
// filtersList = JSON.parseArray(filters, FilterDefinition.class);
// definition.setFilters(filtersList);
// }
// URI uri = UriComponentsBuilder.fromUriString(route.getUri()).build().toUri();
// definition.setUri(uri);
// this.repository.save(Mono.just(definition)).subscribe();
// });
// log.info("加载路由:{}==============", routeList.size());
// Mono.empty();
// }
// }
/**
* 监听Nacos下发的动态路由配置
*
* @param dataId
* @param group
*/
public void dynamicRouteByNacosListener(String dataId, String group) {
try {
configService.addListener(dataId, group, new Listener() {
@Override
public void receiveConfigInfo(String configInfo) {
log.info("进行网关更新:\n\r{}", configInfo);
List<MyRouteDefinition> definitionList = JSON.parseArray(configInfo, MyRouteDefinition.class);
for (MyRouteDefinition definition : definitionList) {
log.info("update route : {}", definition.toString());
dynamicRouteService.update(definition);
}
}
@Override
public Executor getExecutor() {
log.info("getExecutor\n\r");
return null;
}
});
} catch (Exception e) {
log.error("从nacos接收动态路由配置出错!!!", e);
}
}
/**
* 创建ConfigService
*
* @return
*/
private ConfigService createConfigService() {
try {
Properties properties = new Properties();
properties.setProperty("serverAddr", gatewayRoutersConfig.getServerAddr());
if(StringUtils.isNotBlank(gatewayRoutersConfig.getNamespace())){
properties.setProperty("namespace", gatewayRoutersConfig.getNamespace());
}
if(StringUtils.isNotBlank( gatewayRoutersConfig.getUsername())){
properties.setProperty("username", gatewayRoutersConfig.getUsername());
}
if(StringUtils.isNotBlank(gatewayRoutersConfig.getPassword())){
properties.setProperty("password", gatewayRoutersConfig.getPassword());
}
return configService = NacosFactory.createConfigService(properties);
} catch (Exception e) {
log.error("创建ConfigService异常", e);
return null;
}
}
@Override
public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
this.publisher = applicationEventPublisher;
}
}

89
jeecg-server-cloud/jeecg-cloud-gateway/src/main/java/org/jeecg/loader/repository/DynamicRouteService.java Normal file
View File

@ -0,0 +1,89 @@
package org.jeecg.loader.repository;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.loader.repository.MyInMemoryRouteDefinitionRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Mono;
/**
* 动态更新路由网关service
* 1）实现一个Spring提供的事件推送接口ApplicationEventPublisherAware
* 2）提供动态路由的基础方法，可通过获取bean操作该类的方法。该类提供新增路由、更新路由、删除路由，然后实现发布的功能。
*
* @author zyf
*/
@Slf4j
@Service
public class DynamicRouteService implements ApplicationEventPublisherAware {
@Autowired
private MyInMemoryRouteDefinitionRepository repository;
/**
* 发布事件
*/
private ApplicationEventPublisher publisher;
@Override
public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
this.publisher = applicationEventPublisher;
}
/**
* 删除路由
*
* @param id
* @return
*/
public synchronized void delete(String id) {
try {
repository.delete(Mono.just(id)).subscribe();
this.publisher.publishEvent(new RefreshRoutesEvent(this));
}catch (Exception e){
log.warn(e.getMessage(),e);
}
}
/**
* 更新路由
*
* @param definition
* @return
*/
public synchronized String update(RouteDefinition definition) {
try {
log.info("gateway update route {}", definition);
} catch (Exception e) {
return "update fail,not find route routeId: " + definition.getId();
}
try {
repository.save(Mono.just(definition)).subscribe();
this.publisher.publishEvent(new RefreshRoutesEvent(this));
return "success";
} catch (Exception e) {
return "update route fail";
}
}
/**
* 增加路由
*
* @param definition
* @return
*/
public synchronized String add(RouteDefinition definition) {
log.info("gateway add route {}", definition);
try {
repository.save(Mono.just(definition)).subscribe();
} catch (Exception e) {
log.warn(e.getMessage(),e);
}
return "success";
}
}

68
jeecg-server-cloud/jeecg-cloud-gateway/src/main/java/org/jeecg/loader/repository/MyInMemoryRouteDefinitionRepository.java Normal file
View File

@ -0,0 +1,68 @@
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.jeecg.loader.repository;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.function.Function;
import java.util.function.Supplier;
import ch.qos.logback.classic.Logger;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.RouteDefinitionRepository;
import org.springframework.cloud.gateway.support.NotFoundException;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
/**
* @author qinfeng
*/
@Slf4j
@Component
public class MyInMemoryRouteDefinitionRepository implements RouteDefinitionRepository {
private final Map<String, RouteDefinition> routes = Collections.synchronizedMap(new LinkedHashMap());
public MyInMemoryRouteDefinitionRepository() {
}
@Override
public Mono<Void> save(Mono<RouteDefinition> route) {
return route.flatMap((r) -> {
if (ObjectUtils.isEmpty(r.getId())) {
return Mono.error(new IllegalArgumentException("id may not be empty"));
} else {
this.routes.put(r.getId(), r);
return Mono.empty();
}
});
}
@Override
public Mono<Void> delete(Mono<String> routeId) {
return routeId.flatMap((id) -> {
if (this.routes.containsKey(id)) {
this.routes.remove(id);
return Mono.empty();
} else {
log.warn("RouteDefinition not found: " + routeId);
return Mono.empty();
// return Mono.defer(() -> {
// return Mono.error(new NotFoundException("RouteDefinition not found: " + routeId));
// });
}
});
}
@Override
public Flux<RouteDefinition> getRouteDefinitions() {
Map<String, RouteDefinition> routesSafeCopy = new LinkedHashMap(this.routes);
return Flux.fromIterable(routesSafeCopy.values());
}
}

21
jeecg-server-cloud/jeecg-cloud-gateway/src/main/java/org/jeecg/loader/vo/GatewayRouteVo.java Normal file
View File

@ -0,0 +1,21 @@
package org.jeecg.loader.vo;
import lombok.Data;
/**
* 路由参数模型
* @author zyf
* @date: 2022/4/21 10:55
*/
@Data
public class GatewayRouteVo {
private String id;
private String name;
private String uri;
private String predicates;
private String filters;
private Integer stripPrefix;
private Integer retryable;
private Integer persist;
private Integer status;
}

22
jeecg-server-cloud/jeecg-cloud-gateway/src/main/java/org/jeecg/loader/vo/MyRouteDefinition.java Normal file
View File

@ -0,0 +1,22 @@
package org.jeecg.loader.vo;
import org.springframework.cloud.gateway.route.RouteDefinition;
/**
* 自定义RouteDefinition
* @author zyf
*/
public class MyRouteDefinition extends RouteDefinition {
/**
* 路由状态
*/
private Integer status;
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
}