alsace/wu-lazy-cloud-network
1
0
Fork 0
mirror of https://gitee.com/wujiawei1207537021/wu-lazy-cloud-network.git synced 2025-06-03 03:47:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

【fix】添加虚拟路由管理

Browse Source
This commit is contained in:
wujiawei 2025-05-06 17:27:35 +08:00
parent c2c350a28a
commit 9a44a598ef
36 changed files with 3140 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/LazyNettyClientVirtualRouteApplication.java Normal file
View File

@ -0,0 +1,109 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application;
import org.wu.framework.web.response.Result;
import org.wu.framework.web.response.ResultFactory;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.client.virtual.route.LazyNettyClientVirtualRoute;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteRemoveCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteStoryCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteUpdateCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteQueryListCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteQueryOneCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.dto.LazyNettyClientVirtualRouteDTO;
import java.util.List;
import org.wu.framework.lazy.orm.database.lambda.domain.LazyPage;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyApplication
**/
public interface LazyNettyClientVirtualRouteApplication {
/**
* describe 新增客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteStoryCommand 新增客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRoute>} 客户端虚拟路由管理新增后领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyNettyClientVirtualRoute> story(LazyNettyClientVirtualRouteStoryCommand lazyNettyClientVirtualRouteStoryCommand);
/**
* describe 批量新增客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteStoryCommandList 批量新增客户端虚拟路由管理
* @return {@link Result<List<LazyNettyClientVirtualRoute>>} 客户端虚拟路由管理新增后领域对象集合
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<List<LazyNettyClientVirtualRoute>> batchStory(List<LazyNettyClientVirtualRouteStoryCommand> lazyNettyClientVirtualRouteStoryCommandList);
/**
* describe 更新客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteUpdateCommand 更新客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRoute>} 客户端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyNettyClientVirtualRoute> updateOne(LazyNettyClientVirtualRouteUpdateCommand lazyNettyClientVirtualRouteUpdateCommand);
/**
* describe 查询单个客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteQueryOneCommand 查询单个客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRouteDTO>} 客户端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyNettyClientVirtualRouteDTO> findOne(LazyNettyClientVirtualRouteQueryOneCommand lazyNettyClientVirtualRouteQueryOneCommand);
/**
* describe 查询多个客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteQueryListCommand 查询多个客户端虚拟路由管理
* @return {@link Result <List<LazyNettyClientVirtualRouteDTO>>} 客户端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result <List<LazyNettyClientVirtualRouteDTO>> findList(LazyNettyClientVirtualRouteQueryListCommand lazyNettyClientVirtualRouteQueryListCommand);
/**
* describe 分页查询多个客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteQueryListCommand 分页查询多个客户端虚拟路由管理
* @return {@link Result <LazyPage<LazyNettyClientVirtualRouteDTO>>} 分页客户端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result <LazyPage<LazyNettyClientVirtualRouteDTO>> findPage(int size,int current,LazyNettyClientVirtualRouteQueryListCommand lazyNettyClientVirtualRouteQueryListCommand);
/**
* describe 删除客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteRemoveCommand 删除客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRoute>} 客户端虚拟路由管理
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyNettyClientVirtualRoute> remove(LazyNettyClientVirtualRouteRemoveCommand lazyNettyClientVirtualRouteRemoveCommand);
}

109
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/LazyNettyServerVirtualRouteApplication.java Normal file
View File

@ -0,0 +1,109 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application;
import org.wu.framework.web.response.Result;
import org.wu.framework.web.response.ResultFactory;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.server.virtual.route.LazyNettyServerVirtualRoute;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteRemoveCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteStoryCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteUpdateCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteQueryListCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteQueryOneCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.dto.LazyNettyServerVirtualRouteDTO;
import java.util.List;
import org.wu.framework.lazy.orm.database.lambda.domain.LazyPage;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyApplication
**/
public interface LazyNettyServerVirtualRouteApplication {
/**
* describe 新增服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteStoryCommand 新增服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRoute>} 服务端虚拟路由管理新增后领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyNettyServerVirtualRoute> story(LazyNettyServerVirtualRouteStoryCommand lazyNettyServerVirtualRouteStoryCommand);
/**
* describe 批量新增服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteStoryCommandList 批量新增服务端虚拟路由管理
* @return {@link Result<List<LazyNettyServerVirtualRoute>>} 服务端虚拟路由管理新增后领域对象集合
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<List<LazyNettyServerVirtualRoute>> batchStory(List<LazyNettyServerVirtualRouteStoryCommand> lazyNettyServerVirtualRouteStoryCommandList);
/**
* describe 更新服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteUpdateCommand 更新服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRoute>} 服务端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyNettyServerVirtualRoute> updateOne(LazyNettyServerVirtualRouteUpdateCommand lazyNettyServerVirtualRouteUpdateCommand);
/**
* describe 查询单个服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteQueryOneCommand 查询单个服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRouteDTO>} 服务端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyNettyServerVirtualRouteDTO> findOne(LazyNettyServerVirtualRouteQueryOneCommand lazyNettyServerVirtualRouteQueryOneCommand);
/**
* describe 查询多个服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteQueryListCommand 查询多个服务端虚拟路由管理
* @return {@link Result <List<LazyNettyServerVirtualRouteDTO>>} 服务端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result <List<LazyNettyServerVirtualRouteDTO>> findList(LazyNettyServerVirtualRouteQueryListCommand lazyNettyServerVirtualRouteQueryListCommand);
/**
* describe 分页查询多个服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteQueryListCommand 分页查询多个服务端虚拟路由管理
* @return {@link Result <LazyPage<LazyNettyServerVirtualRouteDTO>>} 分页服务端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result <LazyPage<LazyNettyServerVirtualRouteDTO>> findPage(int size,int current,LazyNettyServerVirtualRouteQueryListCommand lazyNettyServerVirtualRouteQueryListCommand);
/**
* describe 删除服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteRemoveCommand 删除服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRoute>} 服务端虚拟路由管理
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyNettyServerVirtualRoute> remove(LazyNettyServerVirtualRouteRemoveCommand lazyNettyServerVirtualRouteRemoveCommand);
}

93
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/assembler/LazyNettyClientVirtualRouteDTOAssembler.java Normal file
View File

@ -0,0 +1,93 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.assembler;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.client.virtual.route.LazyNettyClientVirtualRoute;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteRemoveCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteStoryCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteUpdateCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteQueryListCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteQueryOneCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.dto.LazyNettyClientVirtualRouteDTO;
import org.mapstruct.factory.Mappers;
import org.mapstruct.Mapper;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyAssembler
**/
@Mapper
public interface LazyNettyClientVirtualRouteDTOAssembler {
/**
* describe MapStruct 创建的代理对象
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyClientVirtualRouteDTOAssembler INSTANCE = Mappers.getMapper(LazyNettyClientVirtualRouteDTOAssembler.class);
/**
* describe 应用层存储入参转换成 领域对象
*
* @param lazyNettyClientVirtualRouteStoryCommand 保存客户端虚拟路由管理对象
* @return {@link LazyNettyClientVirtualRoute} 客户端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyClientVirtualRoute toLazyNettyClientVirtualRoute(LazyNettyClientVirtualRouteStoryCommand lazyNettyClientVirtualRouteStoryCommand);
/**
* describe 应用层更新入参转换成 领域对象
*
* @param lazyNettyClientVirtualRouteUpdateCommand 更新客户端虚拟路由管理对象
* @return {@link LazyNettyClientVirtualRoute} 客户端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyClientVirtualRoute toLazyNettyClientVirtualRoute(LazyNettyClientVirtualRouteUpdateCommand lazyNettyClientVirtualRouteUpdateCommand);
/**
* describe 应用层查询入参转换成 领域对象
*
* @param lazyNettyClientVirtualRouteQueryOneCommand 查询单个客户端虚拟路由管理对象参数
* @return {@link LazyNettyClientVirtualRoute} 客户端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyClientVirtualRoute toLazyNettyClientVirtualRoute(LazyNettyClientVirtualRouteQueryOneCommand lazyNettyClientVirtualRouteQueryOneCommand);
/**
* describe 应用层查询入参转换成 领域对象
*
* @param lazyNettyClientVirtualRouteQueryListCommand 查询集合客户端虚拟路由管理对象参数
* @return {@link LazyNettyClientVirtualRoute} 客户端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyClientVirtualRoute toLazyNettyClientVirtualRoute(LazyNettyClientVirtualRouteQueryListCommand lazyNettyClientVirtualRouteQueryListCommand);
/**
* describe 应用层删除入参转换成 领域对象
*
* @param lazyNettyClientVirtualRouteRemoveCommand 删除客户端虚拟路由管理对象参数
* @return {@link LazyNettyClientVirtualRoute} 客户端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyClientVirtualRoute toLazyNettyClientVirtualRoute(LazyNettyClientVirtualRouteRemoveCommand lazyNettyClientVirtualRouteRemoveCommand);
/**
* describe 持久层领域对象转换成DTO对象
*
* @param lazyNettyClientVirtualRoute 客户端虚拟路由管理领域对象
* @return {@link LazyNettyClientVirtualRouteDTO} 客户端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyClientVirtualRouteDTO fromLazyNettyClientVirtualRoute(LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute);
}

93
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/assembler/LazyNettyServerVirtualRouteDTOAssembler.java Normal file
View File

@ -0,0 +1,93 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.assembler;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.server.virtual.route.LazyNettyServerVirtualRoute;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteRemoveCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteStoryCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteUpdateCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteQueryListCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteQueryOneCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.dto.LazyNettyServerVirtualRouteDTO;
import org.mapstruct.factory.Mappers;
import org.mapstruct.Mapper;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyAssembler
**/
@Mapper
public interface LazyNettyServerVirtualRouteDTOAssembler {
/**
* describe MapStruct 创建的代理对象
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyServerVirtualRouteDTOAssembler INSTANCE = Mappers.getMapper(LazyNettyServerVirtualRouteDTOAssembler.class);
/**
* describe 应用层存储入参转换成 领域对象
*
* @param lazyNettyServerVirtualRouteStoryCommand 保存服务端虚拟路由管理对象
* @return {@link LazyNettyServerVirtualRoute} 服务端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyServerVirtualRoute toLazyNettyServerVirtualRoute(LazyNettyServerVirtualRouteStoryCommand lazyNettyServerVirtualRouteStoryCommand);
/**
* describe 应用层更新入参转换成 领域对象
*
* @param lazyNettyServerVirtualRouteUpdateCommand 更新服务端虚拟路由管理对象
* @return {@link LazyNettyServerVirtualRoute} 服务端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyServerVirtualRoute toLazyNettyServerVirtualRoute(LazyNettyServerVirtualRouteUpdateCommand lazyNettyServerVirtualRouteUpdateCommand);
/**
* describe 应用层查询入参转换成 领域对象
*
* @param lazyNettyServerVirtualRouteQueryOneCommand 查询单个服务端虚拟路由管理对象参数
* @return {@link LazyNettyServerVirtualRoute} 服务端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyServerVirtualRoute toLazyNettyServerVirtualRoute(LazyNettyServerVirtualRouteQueryOneCommand lazyNettyServerVirtualRouteQueryOneCommand);
/**
* describe 应用层查询入参转换成 领域对象
*
* @param lazyNettyServerVirtualRouteQueryListCommand 查询集合服务端虚拟路由管理对象参数
* @return {@link LazyNettyServerVirtualRoute} 服务端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyServerVirtualRoute toLazyNettyServerVirtualRoute(LazyNettyServerVirtualRouteQueryListCommand lazyNettyServerVirtualRouteQueryListCommand);
/**
* describe 应用层删除入参转换成 领域对象
*
* @param lazyNettyServerVirtualRouteRemoveCommand 删除服务端虚拟路由管理对象参数
* @return {@link LazyNettyServerVirtualRoute} 服务端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyServerVirtualRoute toLazyNettyServerVirtualRoute(LazyNettyServerVirtualRouteRemoveCommand lazyNettyServerVirtualRouteRemoveCommand);
/**
* describe 持久层领域对象转换成DTO对象
*
* @param lazyNettyServerVirtualRoute 服务端虚拟路由管理领域对象
* @return {@link LazyNettyServerVirtualRouteDTO} 服务端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyServerVirtualRouteDTO fromLazyNettyServerVirtualRoute(LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute);
}

87
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/command/lazy/netty/client/virtual/route/LazyNettyClientVirtualRouteQueryListCommand.java Normal file
View File

@ -0,0 +1,87 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route;
import lombok.Data;
import lombok.experimental.Accessors;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyQueryListCommand
**/
@Data
@Accessors(chain = true)
@Schema(title = "lazy_netty_client_virtual_route_query_List_command",description = "客户端虚拟路由管理")
public class LazyNettyClientVirtualRouteQueryListCommand {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
private Long id;
/**
*
* 目标客户端ID
*/
@Schema(description ="目标客户端ID",name ="targetClientId",example = "")
private String targetClientId;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
private LocalDateTime updateTime;
/**
*
* 客户端虚拟路由IP
*/
@Schema(description ="客户端虚拟路由IP",name ="virtualIp",example = "")
private String virtualIp;
/**
*
* 客户端虚拟路由端口：默认ALL
*/
@Schema(description ="客户端虚拟路由端口：默认ALL",name ="virtualPort",example = "")
private String virtualPort;
}

87
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/command/lazy/netty/client/virtual/route/LazyNettyClientVirtualRouteQueryOneCommand.java Normal file
View File

@ -0,0 +1,87 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route;
import lombok.Data;
import lombok.experimental.Accessors;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyQueryOneCommand
**/
@Data
@Accessors(chain = true)
@Schema(title = "lazy_netty_client_virtual_route_query_one_command",description = "客户端虚拟路由管理")
public class LazyNettyClientVirtualRouteQueryOneCommand {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
private Long id;
/**
*
* 目标客户端ID
*/
@Schema(description ="目标客户端ID",name ="targetClientId",example = "")
private String targetClientId;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
private LocalDateTime updateTime;
/**
*
* 客户端虚拟路由IP
*/
@Schema(description ="客户端虚拟路由IP",name ="virtualIp",example = "")
private String virtualIp;
/**
*
* 客户端虚拟路由端口：默认ALL
*/
@Schema(description ="客户端虚拟路由端口：默认ALL",name ="virtualPort",example = "")
private String virtualPort;
}

93
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/command/lazy/netty/client/virtual/route/LazyNettyClientVirtualRouteRemoveCommand.java Normal file
View File

@ -0,0 +1,93 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route;
import lombok.Data;
import lombok.experimental.Accessors;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyRemoveCommand
**/
@Data
@Accessors(chain = true)
@Schema(title = "lazy_netty_client_virtual_route_remove_command",description = "客户端虚拟路由管理")
public class LazyNettyClientVirtualRouteRemoveCommand {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
private Long id;
/**
*
* 是否删除
*/
@Schema(description ="是否删除",name ="isDeleted",example = "")
private Boolean isDeleted;
/**
*
* 目标客户端ID
*/
@Schema(description ="目标客户端ID",name ="targetClientId",example = "")
private String targetClientId;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
private LocalDateTime updateTime;
/**
*
* 客户端虚拟路由IP
*/
@Schema(description ="客户端虚拟路由IP",name ="virtualIp",example = "")
private String virtualIp;
/**
*
* 客户端虚拟路由端口：默认ALL
*/
@Schema(description ="客户端虚拟路由端口：默认ALL",name ="virtualPort",example = "")
private String virtualPort;
}

93
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/command/lazy/netty/client/virtual/route/LazyNettyClientVirtualRouteStoryCommand.java Normal file
View File

@ -0,0 +1,93 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route;
import lombok.Data;
import lombok.experimental.Accessors;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyStoryCommand
**/
@Data
@Accessors(chain = true)
@Schema(title = "lazy_netty_client_virtual_route_story_command",description = "客户端虚拟路由管理")
public class LazyNettyClientVirtualRouteStoryCommand {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
private Long id;
/**
*
* 是否删除
*/
@Schema(description ="是否删除",name ="isDeleted",example = "")
private Boolean isDeleted;
/**
*
* 目标客户端ID
*/
@Schema(description ="目标客户端ID",name ="targetClientId",example = "")
private String targetClientId;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
private LocalDateTime updateTime;
/**
*
* 客户端虚拟路由IP
*/
@Schema(description ="客户端虚拟路由IP",name ="virtualIp",example = "")
private String virtualIp;
/**
*
* 客户端虚拟路由端口：默认ALL
*/
@Schema(description ="客户端虚拟路由端口：默认ALL",name ="virtualPort",example = "")
private String virtualPort;
}

93
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/command/lazy/netty/client/virtual/route/LazyNettyClientVirtualRouteUpdateCommand.java Normal file
View File

@ -0,0 +1,93 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route;
import lombok.Data;
import lombok.experimental.Accessors;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyUpdateCommand
**/
@Data
@Accessors(chain = true)
@Schema(title = "lazy_netty_client_virtual_route_update_command",description = "客户端虚拟路由管理")
public class LazyNettyClientVirtualRouteUpdateCommand {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
private Long id;
/**
*
* 是否删除
*/
@Schema(description ="是否删除",name ="isDeleted",example = "")
private Boolean isDeleted;
/**
*
* 目标客户端ID
*/
@Schema(description ="目标客户端ID",name ="targetClientId",example = "")
private String targetClientId;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
private LocalDateTime updateTime;
/**
*
* 客户端虚拟路由IP
*/
@Schema(description ="客户端虚拟路由IP",name ="virtualIp",example = "")
private String virtualIp;
/**
*
* 客户端虚拟路由端口：默认ALL
*/
@Schema(description ="客户端虚拟路由端口：默认ALL",name ="virtualPort",example = "")
private String virtualPort;
}

80
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/command/lazy/netty/server/virtual/route/LazyNettyServerVirtualRouteQueryListCommand.java Normal file
View File

@ -0,0 +1,80 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route;
import lombok.Data;
import lombok.experimental.Accessors;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyQueryListCommand
**/
@Data
@Accessors(chain = true)
@Schema(title = "lazy_netty_server_virtual_route_query_List_command",description = "服务端虚拟路由管理")
public class LazyNettyServerVirtualRouteQueryListCommand {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
private Long id;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
private LocalDateTime updateTime;
/**
*
* 虚拟服务端路由IP
*/
@Schema(description ="虚拟服务端路由IP",name ="virtualIp",example = "")
private String virtualIp;
/**
*
* 虚拟服务端路由端口：默认ALL
*/
@Schema(description ="虚拟服务端路由端口：默认ALL",name ="virtualPort",example = "")
private String virtualPort;
}

80
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/command/lazy/netty/server/virtual/route/LazyNettyServerVirtualRouteQueryOneCommand.java Normal file
View File

@ -0,0 +1,80 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route;
import lombok.Data;
import lombok.experimental.Accessors;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyQueryOneCommand
**/
@Data
@Accessors(chain = true)
@Schema(title = "lazy_netty_server_virtual_route_query_one_command",description = "服务端虚拟路由管理")
public class LazyNettyServerVirtualRouteQueryOneCommand {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
private Long id;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
private LocalDateTime updateTime;
/**
*
* 虚拟服务端路由IP
*/
@Schema(description ="虚拟服务端路由IP",name ="virtualIp",example = "")
private String virtualIp;
/**
*
* 虚拟服务端路由端口：默认ALL
*/
@Schema(description ="虚拟服务端路由端口：默认ALL",name ="virtualPort",example = "")
private String virtualPort;
}

86
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/command/lazy/netty/server/virtual/route/LazyNettyServerVirtualRouteRemoveCommand.java Normal file
View File

@ -0,0 +1,86 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route;
import lombok.Data;
import lombok.experimental.Accessors;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyRemoveCommand
**/
@Data
@Accessors(chain = true)
@Schema(title = "lazy_netty_server_virtual_route_remove_command",description = "服务端虚拟路由管理")
public class LazyNettyServerVirtualRouteRemoveCommand {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
private Long id;
/**
*
* 是否删除
*/
@Schema(description ="是否删除",name ="isDeleted",example = "")
private Boolean isDeleted;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
private LocalDateTime updateTime;
/**
*
* 虚拟服务端路由IP
*/
@Schema(description ="虚拟服务端路由IP",name ="virtualIp",example = "")
private String virtualIp;
/**
*
* 虚拟服务端路由端口：默认ALL
*/
@Schema(description ="虚拟服务端路由端口：默认ALL",name ="virtualPort",example = "")
private String virtualPort;
}

86
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/command/lazy/netty/server/virtual/route/LazyNettyServerVirtualRouteStoryCommand.java Normal file
View File

@ -0,0 +1,86 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route;
import lombok.Data;
import lombok.experimental.Accessors;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyStoryCommand
**/
@Data
@Accessors(chain = true)
@Schema(title = "lazy_netty_server_virtual_route_story_command",description = "服务端虚拟路由管理")
public class LazyNettyServerVirtualRouteStoryCommand {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
private Long id;
/**
*
* 是否删除
*/
@Schema(description ="是否删除",name ="isDeleted",example = "")
private Boolean isDeleted;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
private LocalDateTime updateTime;
/**
*
* 虚拟服务端路由IP
*/
@Schema(description ="虚拟服务端路由IP",name ="virtualIp",example = "")
private String virtualIp;
/**
*
* 虚拟服务端路由端口：默认ALL
*/
@Schema(description ="虚拟服务端路由端口：默认ALL",name ="virtualPort",example = "")
private String virtualPort;
}

86
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/command/lazy/netty/server/virtual/route/LazyNettyServerVirtualRouteUpdateCommand.java Normal file
View File

@ -0,0 +1,86 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route;
import lombok.Data;
import lombok.experimental.Accessors;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyUpdateCommand
**/
@Data
@Accessors(chain = true)
@Schema(title = "lazy_netty_server_virtual_route_update_command",description = "服务端虚拟路由管理")
public class LazyNettyServerVirtualRouteUpdateCommand {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
private Long id;
/**
*
* 是否删除
*/
@Schema(description ="是否删除",name ="isDeleted",example = "")
private Boolean isDeleted;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
private LocalDateTime updateTime;
/**
*
* 虚拟服务端路由IP
*/
@Schema(description ="虚拟服务端路由IP",name ="virtualIp",example = "")
private String virtualIp;
/**
*
* 虚拟服务端路由端口：默认ALL
*/
@Schema(description ="虚拟服务端路由端口：默认ALL",name ="virtualPort",example = "")
private String virtualPort;
}

93
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/dto/LazyNettyClientVirtualRouteDTO.java Normal file
View File

@ -0,0 +1,93 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.dto;
import lombok.Data;
import lombok.experimental.Accessors;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyDTO
**/
@Data
@Accessors(chain = true)
@Schema(title = "lazy_netty_client_virtual_route_command_dto",description = "客户端虚拟路由管理")
public class LazyNettyClientVirtualRouteDTO {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
private Long id;
/**
*
* 是否删除
*/
@Schema(description ="是否删除",name ="isDeleted",example = "")
private Boolean isDeleted;
/**
*
* 目标客户端ID
*/
@Schema(description ="目标客户端ID",name ="targetClientId",example = "")
private String targetClientId;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
private LocalDateTime updateTime;
/**
*
* 客户端虚拟路由IP
*/
@Schema(description ="客户端虚拟路由IP",name ="virtualIp",example = "")
private String virtualIp;
/**
*
* 客户端虚拟路由端口：默认ALL
*/
@Schema(description ="客户端虚拟路由端口：默认ALL",name ="virtualPort",example = "")
private String virtualPort;
}

86
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/dto/LazyNettyServerVirtualRouteDTO.java Normal file
View File

@ -0,0 +1,86 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.dto;
import lombok.Data;
import lombok.experimental.Accessors;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyDTO
**/
@Data
@Accessors(chain = true)
@Schema(title = "lazy_netty_server_virtual_route_command_dto",description = "服务端虚拟路由管理")
public class LazyNettyServerVirtualRouteDTO {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
private Long id;
/**
*
* 是否删除
*/
@Schema(description ="是否删除",name ="isDeleted",example = "")
private Boolean isDeleted;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
private LocalDateTime updateTime;
/**
*
* 虚拟服务端路由IP
*/
@Schema(description ="虚拟服务端路由IP",name ="virtualIp",example = "")
private String virtualIp;
/**
*
* 虚拟服务端路由端口：默认ALL
*/
@Schema(description ="虚拟服务端路由端口：默认ALL",name ="virtualPort",example = "")
private String virtualPort;
}

144
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyNettyClientVirtualRouteApplicationImpl.java Normal file
View File

@ -0,0 +1,144 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.impl;
import org.wu.framework.database.lazy.web.plus.stereotype.LazyApplication;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.LazyNettyClientVirtualRouteApplication;
import org.springframework.web.bind.annotation.*;
import org.wu.framework.web.response.Result;
import org.wu.framework.web.response.ResultFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.client.virtual.route.LazyNettyClientVirtualRoute;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteRemoveCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteStoryCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteUpdateCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteQueryListCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteQueryOneCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.assembler.LazyNettyClientVirtualRouteDTOAssembler;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.dto.LazyNettyClientVirtualRouteDTO;
import java.util.stream.Collectors;
import jakarta.annotation.Resource;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteRepository;
import java.util.List;
import org.wu.framework.lazy.orm.database.lambda.domain.LazyPage;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyApplicationImpl
**/
@LazyApplication
public class LazyNettyClientVirtualRouteApplicationImpl implements LazyNettyClientVirtualRouteApplication {
@Resource
LazyNettyClientVirtualRouteRepository lazyNettyClientVirtualRouteRepository;
/**
* describe 新增客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteStoryCommand 新增客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRoute>} 客户端虚拟路由管理新增后领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyNettyClientVirtualRoute> story(LazyNettyClientVirtualRouteStoryCommand lazyNettyClientVirtualRouteStoryCommand) {
LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute = LazyNettyClientVirtualRouteDTOAssembler.INSTANCE.toLazyNettyClientVirtualRoute(lazyNettyClientVirtualRouteStoryCommand);
return lazyNettyClientVirtualRouteRepository.story(lazyNettyClientVirtualRoute);
}
/**
* describe 批量新增客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteStoryCommandList 批量新增客户端虚拟路由管理
* @return {@link Result<List<LazyNettyClientVirtualRoute>>} 客户端虚拟路由管理新增后领域对象集合
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<List<LazyNettyClientVirtualRoute>> batchStory(List<LazyNettyClientVirtualRouteStoryCommand> lazyNettyClientVirtualRouteStoryCommandList) {
List<LazyNettyClientVirtualRoute> lazyNettyClientVirtualRouteList = lazyNettyClientVirtualRouteStoryCommandList.stream().map( LazyNettyClientVirtualRouteDTOAssembler.INSTANCE::toLazyNettyClientVirtualRoute).collect(Collectors.toList());
return lazyNettyClientVirtualRouteRepository.batchStory(lazyNettyClientVirtualRouteList);
}
/**
* describe 更新客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteUpdateCommand 更新客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRoute>} 客户端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyNettyClientVirtualRoute> updateOne(LazyNettyClientVirtualRouteUpdateCommand lazyNettyClientVirtualRouteUpdateCommand) {
LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute = LazyNettyClientVirtualRouteDTOAssembler.INSTANCE.toLazyNettyClientVirtualRoute(lazyNettyClientVirtualRouteUpdateCommand);
return lazyNettyClientVirtualRouteRepository.story(lazyNettyClientVirtualRoute);
}
/**
* describe 查询单个客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteQueryOneCommand 查询单个客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRouteDTO>} 客户端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyNettyClientVirtualRouteDTO> findOne(LazyNettyClientVirtualRouteQueryOneCommand lazyNettyClientVirtualRouteQueryOneCommand) {
LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute = LazyNettyClientVirtualRouteDTOAssembler.INSTANCE.toLazyNettyClientVirtualRoute(lazyNettyClientVirtualRouteQueryOneCommand);
return lazyNettyClientVirtualRouteRepository.findOne(lazyNettyClientVirtualRoute).convert(LazyNettyClientVirtualRouteDTOAssembler.INSTANCE::fromLazyNettyClientVirtualRoute);
}
/**
* describe 查询多个客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteQueryListCommand 查询多个客户端虚拟路由管理
* @return {@link Result<List<LazyNettyClientVirtualRouteDTO>>} 客户端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<List<LazyNettyClientVirtualRouteDTO>> findList(LazyNettyClientVirtualRouteQueryListCommand lazyNettyClientVirtualRouteQueryListCommand) {
LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute = LazyNettyClientVirtualRouteDTOAssembler.INSTANCE.toLazyNettyClientVirtualRoute(lazyNettyClientVirtualRouteQueryListCommand);
return lazyNettyClientVirtualRouteRepository.findList(lazyNettyClientVirtualRoute) .convert(lazyNettyClientVirtualRoutes -> lazyNettyClientVirtualRoutes.stream().map(LazyNettyClientVirtualRouteDTOAssembler.INSTANCE::fromLazyNettyClientVirtualRoute).collect(Collectors.toList())) ;
}
/**
* describe 分页查询多个客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteQueryListCommand 分页查询多个客户端虚拟路由管理
* @return {@link Result<LazyPage<LazyNettyClientVirtualRouteDTO>>} 分页客户端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyPage<LazyNettyClientVirtualRouteDTO>> findPage(int size,int current,LazyNettyClientVirtualRouteQueryListCommand lazyNettyClientVirtualRouteQueryListCommand) {
LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute = LazyNettyClientVirtualRouteDTOAssembler.INSTANCE.toLazyNettyClientVirtualRoute(lazyNettyClientVirtualRouteQueryListCommand);
return lazyNettyClientVirtualRouteRepository.findPage(size,current,lazyNettyClientVirtualRoute) .convert(page -> page.convert(LazyNettyClientVirtualRouteDTOAssembler.INSTANCE::fromLazyNettyClientVirtualRoute)) ;
}
/**
* describe 删除客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteRemoveCommand 删除客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRoute>} 客户端虚拟路由管理
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyNettyClientVirtualRoute> remove(LazyNettyClientVirtualRouteRemoveCommand lazyNettyClientVirtualRouteRemoveCommand) {
LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute = LazyNettyClientVirtualRouteDTOAssembler.INSTANCE.toLazyNettyClientVirtualRoute(lazyNettyClientVirtualRouteRemoveCommand);
return lazyNettyClientVirtualRouteRepository.remove(lazyNettyClientVirtualRoute);
}
}

144
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyNettyServerVirtualRouteApplicationImpl.java Normal file
View File

@ -0,0 +1,144 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.application.impl;
import org.wu.framework.database.lazy.web.plus.stereotype.LazyApplication;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.LazyNettyServerVirtualRouteApplication;
import org.springframework.web.bind.annotation.*;
import org.wu.framework.web.response.Result;
import org.wu.framework.web.response.ResultFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.server.virtual.route.LazyNettyServerVirtualRoute;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteRemoveCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteStoryCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteUpdateCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteQueryListCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteQueryOneCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.assembler.LazyNettyServerVirtualRouteDTOAssembler;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.dto.LazyNettyServerVirtualRouteDTO;
import java.util.stream.Collectors;
import jakarta.annotation.Resource;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteRepository;
import java.util.List;
import org.wu.framework.lazy.orm.database.lambda.domain.LazyPage;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyApplicationImpl
**/
@LazyApplication
public class LazyNettyServerVirtualRouteApplicationImpl implements LazyNettyServerVirtualRouteApplication {
@Resource
LazyNettyServerVirtualRouteRepository lazyNettyServerVirtualRouteRepository;
/**
* describe 新增服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteStoryCommand 新增服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRoute>} 服务端虚拟路由管理新增后领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyNettyServerVirtualRoute> story(LazyNettyServerVirtualRouteStoryCommand lazyNettyServerVirtualRouteStoryCommand) {
LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute = LazyNettyServerVirtualRouteDTOAssembler.INSTANCE.toLazyNettyServerVirtualRoute(lazyNettyServerVirtualRouteStoryCommand);
return lazyNettyServerVirtualRouteRepository.story(lazyNettyServerVirtualRoute);
}
/**
* describe 批量新增服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteStoryCommandList 批量新增服务端虚拟路由管理
* @return {@link Result<List<LazyNettyServerVirtualRoute>>} 服务端虚拟路由管理新增后领域对象集合
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<List<LazyNettyServerVirtualRoute>> batchStory(List<LazyNettyServerVirtualRouteStoryCommand> lazyNettyServerVirtualRouteStoryCommandList) {
List<LazyNettyServerVirtualRoute> lazyNettyServerVirtualRouteList = lazyNettyServerVirtualRouteStoryCommandList.stream().map( LazyNettyServerVirtualRouteDTOAssembler.INSTANCE::toLazyNettyServerVirtualRoute).collect(Collectors.toList());
return lazyNettyServerVirtualRouteRepository.batchStory(lazyNettyServerVirtualRouteList);
}
/**
* describe 更新服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteUpdateCommand 更新服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRoute>} 服务端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyNettyServerVirtualRoute> updateOne(LazyNettyServerVirtualRouteUpdateCommand lazyNettyServerVirtualRouteUpdateCommand) {
LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute = LazyNettyServerVirtualRouteDTOAssembler.INSTANCE.toLazyNettyServerVirtualRoute(lazyNettyServerVirtualRouteUpdateCommand);
return lazyNettyServerVirtualRouteRepository.story(lazyNettyServerVirtualRoute);
}
/**
* describe 查询单个服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteQueryOneCommand 查询单个服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRouteDTO>} 服务端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyNettyServerVirtualRouteDTO> findOne(LazyNettyServerVirtualRouteQueryOneCommand lazyNettyServerVirtualRouteQueryOneCommand) {
LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute = LazyNettyServerVirtualRouteDTOAssembler.INSTANCE.toLazyNettyServerVirtualRoute(lazyNettyServerVirtualRouteQueryOneCommand);
return lazyNettyServerVirtualRouteRepository.findOne(lazyNettyServerVirtualRoute).convert(LazyNettyServerVirtualRouteDTOAssembler.INSTANCE::fromLazyNettyServerVirtualRoute);
}
/**
* describe 查询多个服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteQueryListCommand 查询多个服务端虚拟路由管理
* @return {@link Result<List<LazyNettyServerVirtualRouteDTO>>} 服务端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<List<LazyNettyServerVirtualRouteDTO>> findList(LazyNettyServerVirtualRouteQueryListCommand lazyNettyServerVirtualRouteQueryListCommand) {
LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute = LazyNettyServerVirtualRouteDTOAssembler.INSTANCE.toLazyNettyServerVirtualRoute(lazyNettyServerVirtualRouteQueryListCommand);
return lazyNettyServerVirtualRouteRepository.findList(lazyNettyServerVirtualRoute) .convert(lazyNettyServerVirtualRoutes -> lazyNettyServerVirtualRoutes.stream().map(LazyNettyServerVirtualRouteDTOAssembler.INSTANCE::fromLazyNettyServerVirtualRoute).collect(Collectors.toList())) ;
}
/**
* describe 分页查询多个服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteQueryListCommand 分页查询多个服务端虚拟路由管理
* @return {@link Result<LazyPage<LazyNettyServerVirtualRouteDTO>>} 分页服务端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyPage<LazyNettyServerVirtualRouteDTO>> findPage(int size,int current,LazyNettyServerVirtualRouteQueryListCommand lazyNettyServerVirtualRouteQueryListCommand) {
LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute = LazyNettyServerVirtualRouteDTOAssembler.INSTANCE.toLazyNettyServerVirtualRoute(lazyNettyServerVirtualRouteQueryListCommand);
return lazyNettyServerVirtualRouteRepository.findPage(size,current,lazyNettyServerVirtualRoute) .convert(page -> page.convert(LazyNettyServerVirtualRouteDTOAssembler.INSTANCE::fromLazyNettyServerVirtualRoute)) ;
}
/**
* describe 删除服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteRemoveCommand 删除服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRoute>} 服务端虚拟路由管理
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyNettyServerVirtualRoute> remove(LazyNettyServerVirtualRouteRemoveCommand lazyNettyServerVirtualRouteRemoveCommand) {
LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute = LazyNettyServerVirtualRouteDTOAssembler.INSTANCE.toLazyNettyServerVirtualRoute(lazyNettyServerVirtualRouteRemoveCommand);
return lazyNettyServerVirtualRouteRepository.remove(lazyNettyServerVirtualRoute);
}
}

142
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/controller/LazyNettyClientVirtualRouteProvider.java Normal file
View File

@ -0,0 +1,142 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.controller;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import org.wu.framework.web.spring.EasyController;
import org.springframework.web.bind.annotation.*;
import org.wu.framework.web.response.Result;
import org.wu.framework.web.response.ResultFactory;
import org.springframework.beans.factory.annotation.Autowired;
import jakarta.annotation.Resource;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.client.virtual.route.LazyNettyClientVirtualRoute;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteRemoveCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteStoryCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteUpdateCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteQueryListCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteQueryOneCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.LazyNettyClientVirtualRouteApplication;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.dto.LazyNettyClientVirtualRouteDTO;
import java.util.List;
import org.wu.framework.lazy.orm.database.lambda.domain.LazyPage;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyController
**/
@Tag(name = "客户端虚拟路由管理提供者")
@EasyController("/lazy/netty/client/virtual/route")
public class LazyNettyClientVirtualRouteProvider {
@Resource
private LazyNettyClientVirtualRouteApplication lazyNettyClientVirtualRouteApplication;
/**
* describe 新增客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteStoryCommand 新增客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRoute>} 客户端虚拟路由管理新增后领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Operation(summary = "新增客户端虚拟路由管理")
@PostMapping("/story")
public Result<LazyNettyClientVirtualRoute> story(@RequestBody LazyNettyClientVirtualRouteStoryCommand lazyNettyClientVirtualRouteStoryCommand){
return lazyNettyClientVirtualRouteApplication.story(lazyNettyClientVirtualRouteStoryCommand);
}
/**
* describe 批量新增客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteStoryCommandList 批量新增客户端虚拟路由管理
* @return {@link Result<List<LazyNettyClientVirtualRoute>>} 客户端虚拟路由管理新增后领域对象集合
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Operation(summary = "批量新增客户端虚拟路由管理")
@PostMapping("/batchStory")
public Result<List<LazyNettyClientVirtualRoute>> batchStory(@RequestBody List<LazyNettyClientVirtualRouteStoryCommand> lazyNettyClientVirtualRouteStoryCommandList){
return lazyNettyClientVirtualRouteApplication.batchStory(lazyNettyClientVirtualRouteStoryCommandList);
}
/**
* describe 更新客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteUpdateCommand 更新客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRoute>} 客户端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Operation(summary = "更新客户端虚拟路由管理")
@PutMapping("/updateOne")
public Result<LazyNettyClientVirtualRoute> updateOne(@RequestBody LazyNettyClientVirtualRouteUpdateCommand lazyNettyClientVirtualRouteUpdateCommand){
return lazyNettyClientVirtualRouteApplication.updateOne(lazyNettyClientVirtualRouteUpdateCommand);
}
/**
* describe 查询单个客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteQueryOneCommand 查询单个客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRouteDTO>} 客户端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Operation(summary = "查询单个客户端虚拟路由管理")
@GetMapping("/findOne")
public Result<LazyNettyClientVirtualRouteDTO> findOne(@ModelAttribute LazyNettyClientVirtualRouteQueryOneCommand lazyNettyClientVirtualRouteQueryOneCommand){
return lazyNettyClientVirtualRouteApplication.findOne(lazyNettyClientVirtualRouteQueryOneCommand);
}
/**
* describe 查询多个客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteQueryListCommand 查询多个客户端虚拟路由管理
* @return {@link Result<List<LazyNettyClientVirtualRouteDTO>>} 客户端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Operation(summary = "查询多个客户端虚拟路由管理")
@GetMapping("/findList")
public Result<List<LazyNettyClientVirtualRouteDTO>> findList(@ModelAttribute LazyNettyClientVirtualRouteQueryListCommand lazyNettyClientVirtualRouteQueryListCommand){
return lazyNettyClientVirtualRouteApplication.findList(lazyNettyClientVirtualRouteQueryListCommand);
}
/**
* describe 分页查询多个客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteQueryListCommand 分页查询多个客户端虚拟路由管理
* @return {@link Result<LazyPage<LazyNettyClientVirtualRouteDTO>>} 分页客户端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Operation(summary = "分页查询多个客户端虚拟路由管理")
@GetMapping("/findPage")
public Result<LazyPage<LazyNettyClientVirtualRouteDTO>> findPage(@Parameter(description ="分页大小") @RequestParam(defaultValue = "10", value = "size") int size,
@Parameter(description ="当前页数") @RequestParam(defaultValue = "1", value = "current") int current,@ModelAttribute LazyNettyClientVirtualRouteQueryListCommand lazyNettyClientVirtualRouteQueryListCommand){
return lazyNettyClientVirtualRouteApplication.findPage(size,current,lazyNettyClientVirtualRouteQueryListCommand);
}
/**
* describe 删除客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteRemoveCommand 删除客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRoute>} 客户端虚拟路由管理
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Operation(summary = "删除客户端虚拟路由管理")
@DeleteMapping("/remove")
public Result<LazyNettyClientVirtualRoute> remove(@ModelAttribute LazyNettyClientVirtualRouteRemoveCommand lazyNettyClientVirtualRouteRemoveCommand){
return lazyNettyClientVirtualRouteApplication.remove(lazyNettyClientVirtualRouteRemoveCommand);
}
}

142
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/controller/LazyNettyServerVirtualRouteProvider.java Normal file
View File

@ -0,0 +1,142 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.controller;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import org.wu.framework.web.spring.EasyController;
import org.springframework.web.bind.annotation.*;
import org.wu.framework.web.response.Result;
import org.wu.framework.web.response.ResultFactory;
import org.springframework.beans.factory.annotation.Autowired;
import jakarta.annotation.Resource;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.server.virtual.route.LazyNettyServerVirtualRoute;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteRemoveCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteStoryCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteUpdateCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteQueryListCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteQueryOneCommand;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.LazyNettyServerVirtualRouteApplication;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.dto.LazyNettyServerVirtualRouteDTO;
import java.util.List;
import org.wu.framework.lazy.orm.database.lambda.domain.LazyPage;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyController
**/
@Tag(name = "服务端虚拟路由管理提供者")
@EasyController("/lazy/netty/server/virtual/route")
public class LazyNettyServerVirtualRouteProvider {
@Resource
private LazyNettyServerVirtualRouteApplication lazyNettyServerVirtualRouteApplication;
/**
* describe 新增服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteStoryCommand 新增服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRoute>} 服务端虚拟路由管理新增后领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Operation(summary = "新增服务端虚拟路由管理")
@PostMapping("/story")
public Result<LazyNettyServerVirtualRoute> story(@RequestBody LazyNettyServerVirtualRouteStoryCommand lazyNettyServerVirtualRouteStoryCommand){
return lazyNettyServerVirtualRouteApplication.story(lazyNettyServerVirtualRouteStoryCommand);
}
/**
* describe 批量新增服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteStoryCommandList 批量新增服务端虚拟路由管理
* @return {@link Result<List<LazyNettyServerVirtualRoute>>} 服务端虚拟路由管理新增后领域对象集合
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Operation(summary = "批量新增服务端虚拟路由管理")
@PostMapping("/batchStory")
public Result<List<LazyNettyServerVirtualRoute>> batchStory(@RequestBody List<LazyNettyServerVirtualRouteStoryCommand> lazyNettyServerVirtualRouteStoryCommandList){
return lazyNettyServerVirtualRouteApplication.batchStory(lazyNettyServerVirtualRouteStoryCommandList);
}
/**
* describe 更新服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteUpdateCommand 更新服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRoute>} 服务端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Operation(summary = "更新服务端虚拟路由管理")
@PutMapping("/updateOne")
public Result<LazyNettyServerVirtualRoute> updateOne(@RequestBody LazyNettyServerVirtualRouteUpdateCommand lazyNettyServerVirtualRouteUpdateCommand){
return lazyNettyServerVirtualRouteApplication.updateOne(lazyNettyServerVirtualRouteUpdateCommand);
}
/**
* describe 查询单个服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteQueryOneCommand 查询单个服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRouteDTO>} 服务端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Operation(summary = "查询单个服务端虚拟路由管理")
@GetMapping("/findOne")
public Result<LazyNettyServerVirtualRouteDTO> findOne(@ModelAttribute LazyNettyServerVirtualRouteQueryOneCommand lazyNettyServerVirtualRouteQueryOneCommand){
return lazyNettyServerVirtualRouteApplication.findOne(lazyNettyServerVirtualRouteQueryOneCommand);
}
/**
* describe 查询多个服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteQueryListCommand 查询多个服务端虚拟路由管理
* @return {@link Result<List<LazyNettyServerVirtualRouteDTO>>} 服务端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Operation(summary = "查询多个服务端虚拟路由管理")
@GetMapping("/findList")
public Result<List<LazyNettyServerVirtualRouteDTO>> findList(@ModelAttribute LazyNettyServerVirtualRouteQueryListCommand lazyNettyServerVirtualRouteQueryListCommand){
return lazyNettyServerVirtualRouteApplication.findList(lazyNettyServerVirtualRouteQueryListCommand);
}
/**
* describe 分页查询多个服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteQueryListCommand 分页查询多个服务端虚拟路由管理
* @return {@link Result<LazyPage<LazyNettyServerVirtualRouteDTO>>} 分页服务端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Operation(summary = "分页查询多个服务端虚拟路由管理")
@GetMapping("/findPage")
public Result<LazyPage<LazyNettyServerVirtualRouteDTO>> findPage(@Parameter(description ="分页大小") @RequestParam(defaultValue = "10", value = "size") int size,
@Parameter(description ="当前页数") @RequestParam(defaultValue = "1", value = "current") int current,@ModelAttribute LazyNettyServerVirtualRouteQueryListCommand lazyNettyServerVirtualRouteQueryListCommand){
return lazyNettyServerVirtualRouteApplication.findPage(size,current,lazyNettyServerVirtualRouteQueryListCommand);
}
/**
* describe 删除服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteRemoveCommand 删除服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRoute>} 服务端虚拟路由管理
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Operation(summary = "删除服务端虚拟路由管理")
@DeleteMapping("/remove")
public Result<LazyNettyServerVirtualRoute> remove(@ModelAttribute LazyNettyServerVirtualRouteRemoveCommand lazyNettyServerVirtualRouteRemoveCommand){
return lazyNettyServerVirtualRouteApplication.remove(lazyNettyServerVirtualRouteRemoveCommand);
}
}

93
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/domain/model/lazy/netty/client/virtual/route/LazyNettyClientVirtualRoute.java Normal file
View File

@ -0,0 +1,93 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.client.virtual.route;
import lombok.Data;
import lombok.experimental.Accessors;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyDomain
**/
@Data
@Accessors(chain = true)
@Schema(title = "lazy_netty_client_virtual_route",description = "客户端虚拟路由管理")
public class LazyNettyClientVirtualRoute {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
private Long id;
/**
*
* 是否删除
*/
@Schema(description ="是否删除",name ="isDeleted",example = "")
private Boolean isDeleted;
/**
*
* 目标客户端ID
*/
@Schema(description ="目标客户端ID",name ="targetClientId",example = "")
private String targetClientId;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
private LocalDateTime updateTime;
/**
*
* 客户端虚拟路由IP
*/
@Schema(description ="客户端虚拟路由IP",name ="virtualIp",example = "")
private String virtualIp;
/**
*
* 客户端虚拟路由端口：默认ALL
*/
@Schema(description ="客户端虚拟路由端口：默认ALL",name ="virtualPort",example = "")
private String virtualPort;
}

106
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/domain/model/lazy/netty/client/virtual/route/LazyNettyClientVirtualRouteRepository.java Normal file
View File

@ -0,0 +1,106 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.client.virtual.route;
import org.wu.framework.web.response.Result;
import org.wu.framework.web.response.ResultFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.client.virtual.route.LazyNettyClientVirtualRoute;
import java.util.List;
import org.wu.framework.lazy.orm.database.lambda.domain.LazyPage;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyDomainRepository
**/
public interface LazyNettyClientVirtualRouteRepository {
/**
* describe 新增客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRoute 新增客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRoute>} 客户端虚拟路由管理新增后领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyNettyClientVirtualRoute> story(LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute);
/**
* describe 批量新增客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteList 批量新增客户端虚拟路由管理
* @return {@link Result<List<LazyNettyClientVirtualRoute>>} 客户端虚拟路由管理新增后领域对象集合
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<List<LazyNettyClientVirtualRoute>> batchStory(List<LazyNettyClientVirtualRoute> lazyNettyClientVirtualRouteList);
/**
* describe 查询单个客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRoute 查询单个客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRoute>} 客户端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyNettyClientVirtualRoute> findOne(LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute);
/**
* describe 查询多个客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRoute 查询多个客户端虚拟路由管理
* @return {@link Result<List<LazyNettyClientVirtualRoute>>} 客户端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<List<LazyNettyClientVirtualRoute>> findList(LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute);
/**
* describe 分页查询多个客户端虚拟路由管理
*
* @param size 当前页数
* @param current 当前页
* @param lazyNettyClientVirtualRoute 分页查询多个客户端虚拟路由管理
* @return {@link Result<LazyPage<LazyNettyClientVirtualRoute>>} 分页客户端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyPage<LazyNettyClientVirtualRoute>> findPage(int size,int current,LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute);
/**
* describe 删除客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRoute 删除客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRoute>} 客户端虚拟路由管理
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyNettyClientVirtualRoute> remove(LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute);
/**
* describe 是否存在客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRoute 是否存在客户端虚拟路由管理
* @return {@link Result<Boolean>} 客户端虚拟路由管理是否存在
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<Boolean> exists(LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute);
}

86
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/domain/model/lazy/netty/server/virtual/route/LazyNettyServerVirtualRoute.java Normal file
View File

@ -0,0 +1,86 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.server.virtual.route;
import lombok.Data;
import lombok.experimental.Accessors;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyDomain
**/
@Data
@Accessors(chain = true)
@Schema(title = "lazy_netty_server_virtual_route",description = "服务端虚拟路由管理")
public class LazyNettyServerVirtualRoute {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
private Long id;
/**
*
* 是否删除
*/
@Schema(description ="是否删除",name ="isDeleted",example = "")
private Boolean isDeleted;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
private LocalDateTime updateTime;
/**
*
* 虚拟服务端路由IP
*/
@Schema(description ="虚拟服务端路由IP",name ="virtualIp",example = "")
private String virtualIp;
/**
*
* 虚拟服务端路由端口：默认ALL
*/
@Schema(description ="虚拟服务端路由端口：默认ALL",name ="virtualPort",example = "")
private String virtualPort;
}

106
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/domain/model/lazy/netty/server/virtual/route/LazyNettyServerVirtualRouteRepository.java Normal file
View File

@ -0,0 +1,106 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.server.virtual.route;
import org.wu.framework.web.response.Result;
import org.wu.framework.web.response.ResultFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.server.virtual.route.LazyNettyServerVirtualRoute;
import java.util.List;
import org.wu.framework.lazy.orm.database.lambda.domain.LazyPage;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyDomainRepository
**/
public interface LazyNettyServerVirtualRouteRepository {
/**
* describe 新增服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRoute 新增服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRoute>} 服务端虚拟路由管理新增后领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyNettyServerVirtualRoute> story(LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute);
/**
* describe 批量新增服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteList 批量新增服务端虚拟路由管理
* @return {@link Result<List<LazyNettyServerVirtualRoute>>} 服务端虚拟路由管理新增后领域对象集合
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<List<LazyNettyServerVirtualRoute>> batchStory(List<LazyNettyServerVirtualRoute> lazyNettyServerVirtualRouteList);
/**
* describe 查询单个服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRoute 查询单个服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRoute>} 服务端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyNettyServerVirtualRoute> findOne(LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute);
/**
* describe 查询多个服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRoute 查询多个服务端虚拟路由管理
* @return {@link Result<List<LazyNettyServerVirtualRoute>>} 服务端虚拟路由管理DTO对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<List<LazyNettyServerVirtualRoute>> findList(LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute);
/**
* describe 分页查询多个服务端虚拟路由管理
*
* @param size 当前页数
* @param current 当前页
* @param lazyNettyServerVirtualRoute 分页查询多个服务端虚拟路由管理
* @return {@link Result<LazyPage<LazyNettyServerVirtualRoute>>} 分页服务端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyPage<LazyNettyServerVirtualRoute>> findPage(int size,int current,LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute);
/**
* describe 删除服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRoute 删除服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRoute>} 服务端虚拟路由管理
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<LazyNettyServerVirtualRoute> remove(LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute);
/**
* describe 是否存在服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRoute 是否存在服务端虚拟路由管理
* @return {@link Result<Boolean>} 服务端虚拟路由管理是否存在
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
Result<Boolean> exists(LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute);
}

48
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/infrastructure/converter/LazyNettyClientVirtualRouteConverter.java Normal file
View File

@ -0,0 +1,48 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.converter;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.client.virtual.route.LazyNettyClientVirtualRoute;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.entity.LazyNettyClientVirtualRouteDO;
import org.mapstruct.factory.Mappers;
import org.mapstruct.Mapper;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyInfrastructureConverter
**/
@Mapper
public interface LazyNettyClientVirtualRouteConverter {
/**
* describe MapStruct 创建的代理对象
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyClientVirtualRouteConverter INSTANCE = Mappers.getMapper(LazyNettyClientVirtualRouteConverter.class);
/**
* describe 实体对象 转换成领域对象
*
* @param lazyNettyClientVirtualRouteDO 客户端虚拟路由管理实体对象
* @return {@link LazyNettyClientVirtualRoute} 客户端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyClientVirtualRoute toLazyNettyClientVirtualRoute(LazyNettyClientVirtualRouteDO lazyNettyClientVirtualRouteDO);
/**
* describe 领域对象 转换成实体对象
*
* @param lazyNettyClientVirtualRoute 客户端虚拟路由管理领域对象
* @return {@link LazyNettyClientVirtualRouteDO} 客户端虚拟路由管理实体对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyClientVirtualRouteDO fromLazyNettyClientVirtualRoute(LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute);
}

48
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/infrastructure/converter/LazyNettyServerVirtualRouteConverter.java Normal file
View File

@ -0,0 +1,48 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.converter;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.server.virtual.route.LazyNettyServerVirtualRoute;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.entity.LazyNettyServerVirtualRouteDO;
import org.mapstruct.factory.Mappers;
import org.mapstruct.Mapper;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyInfrastructureConverter
**/
@Mapper
public interface LazyNettyServerVirtualRouteConverter {
/**
* describe MapStruct 创建的代理对象
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyServerVirtualRouteConverter INSTANCE = Mappers.getMapper(LazyNettyServerVirtualRouteConverter.class);
/**
* describe 实体对象 转换成领域对象
*
* @param lazyNettyServerVirtualRouteDO 服务端虚拟路由管理实体对象
* @return {@link LazyNettyServerVirtualRoute} 服务端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyServerVirtualRoute toLazyNettyServerVirtualRoute(LazyNettyServerVirtualRouteDO lazyNettyServerVirtualRouteDO);
/**
* describe 领域对象 转换成实体对象
*
* @param lazyNettyServerVirtualRoute 服务端虚拟路由管理领域对象
* @return {@link LazyNettyServerVirtualRouteDO} 服务端虚拟路由管理实体对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
LazyNettyServerVirtualRouteDO fromLazyNettyServerVirtualRoute(LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute);
}

112
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/infrastructure/entity/LazyNettyClientVirtualRouteDO.java Normal file
View File

@ -0,0 +1,112 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.entity;
import lombok.Data;
import lombok.experimental.Accessors;
import org.wu.framework.lazy.orm.core.stereotype.LazyTableIndex;
import org.wu.framework.core.stereotype.LayerField;
import org.wu.framework.core.stereotype.LayerField.LayerFieldType;
import org.wu.framework.lazy.orm.core.stereotype.LazyTable;
import org.wu.framework.lazy.orm.core.stereotype.LazyTableField;
import org.wu.framework.lazy.orm.core.stereotype.*;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import org.wu.framework.lazy.orm.core.stereotype.LazyTableFieldId;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyInfrastructureEntity
**/
@Data
@Accessors(chain = true)
@LazyTable(tableName = "lazy_netty_client_virtual_route",comment = "客户端虚拟路由管理")
@Schema(title = "lazy_netty_client_virtual_route",description = "客户端虚拟路由管理")
public class LazyNettyClientVirtualRouteDO {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
@LazyTableField(name="create_time",comment="创建时间",defaultValue="CURRENT_TIMESTAMP",upsertStrategy = LazyFieldStrategy.NEVER,columnType="datetime",extra=" on update CURRENT_TIMESTAMP")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
@LazyTableField(name="describe",comment="规则描述",columnType="varchar(255)")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
@LazyTableFieldId(name = "id", comment = "主键ID")
private Long id;
/**
*
* 是否删除
*/
@Schema(description ="是否删除",name ="isDeleted",example = "")
@LazyTableField(name="is_deleted",comment="是否删除",notNull=true,defaultValue="'0'",upsertStrategy = LazyFieldStrategy.NEVER,columnType="tinyint(1)")
private Boolean isDeleted;
/**
*
* 目标客户端ID
*/
@Schema(description ="目标客户端ID",name ="targetClientId",example = "")
@LazyTableField(name="target_client_id",comment="目标客户端ID",notNull=true,columnType="varchar(255)")
private String targetClientId;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
@LazyTableField(name="target_ip",comment="目标路由IP",notNull=true,columnType="varchar(255)")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
@LazyTableField(name="target_port",comment="目标路由端口：默认ALL",notNull=true,defaultValue="'ALL'",upsertStrategy = LazyFieldStrategy.NEVER,columnType="varchar(255)")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
@LazyTableField(name="update_time",comment="更新时间",defaultValue="CURRENT_TIMESTAMP",upsertStrategy = LazyFieldStrategy.NEVER,columnType="datetime",extra=" on update CURRENT_TIMESTAMP")
private LocalDateTime updateTime;
/**
*
* 客户端虚拟路由IP
*/
@Schema(description ="客户端虚拟路由IP",name ="virtualIp",example = "")
@LazyTableField(name="virtual_ip",comment="客户端虚拟路由IP",notNull=true,columnType="varchar(255)")
private String virtualIp;
/**
*
* 客户端虚拟路由端口：默认ALL
*/
@Schema(description ="客户端虚拟路由端口：默认ALL",name ="virtualPort",example = "")
@LazyTableField(name="virtual_port",comment="客户端虚拟路由端口：默认ALL",notNull=true,defaultValue="'ALL'",upsertStrategy = LazyFieldStrategy.NEVER,columnType="varchar(255)")
private String virtualPort;
}

104
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/infrastructure/entity/LazyNettyServerVirtualRouteDO.java Normal file
View File

@ -0,0 +1,104 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.entity;
import lombok.Data;
import lombok.experimental.Accessors;
import org.wu.framework.lazy.orm.core.stereotype.LazyTableIndex;
import org.wu.framework.core.stereotype.LayerField;
import org.wu.framework.core.stereotype.LayerField.LayerFieldType;
import org.wu.framework.lazy.orm.core.stereotype.LazyTable;
import org.wu.framework.lazy.orm.core.stereotype.LazyTableField;
import org.wu.framework.lazy.orm.core.stereotype.*;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.lang.String;
import org.wu.framework.lazy.orm.core.stereotype.LazyTableFieldId;
import java.lang.Long;
import java.lang.Boolean;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyInfrastructureEntity
**/
@Data
@Accessors(chain = true)
@LazyTable(tableName = "lazy_netty_server_virtual_route",comment = "服务端虚拟路由管理")
@Schema(title = "lazy_netty_server_virtual_route",description = "服务端虚拟路由管理")
public class LazyNettyServerVirtualRouteDO {
/**
*
* 创建时间
*/
@Schema(description ="创建时间",name ="createTime",example = "")
@LazyTableField(name="create_time",comment="创建时间",defaultValue="CURRENT_TIMESTAMP",upsertStrategy = LazyFieldStrategy.NEVER,columnType="datetime",extra=" on update CURRENT_TIMESTAMP")
private LocalDateTime createTime;
/**
*
* 规则描述
*/
@Schema(description ="规则描述",name ="describe",example = "")
@LazyTableField(name="describe",comment="规则描述",columnType="varchar(255)")
private String describe;
/**
*
* 主键ID
*/
@Schema(description ="主键ID",name ="id",example = "")
@LazyTableFieldId(name = "id", comment = "主键ID")
private Long id;
/**
*
* 是否删除
*/
@Schema(description ="是否删除",name ="isDeleted",example = "")
@LazyTableField(name="is_deleted",comment="是否删除",notNull=true,defaultValue="'0'",upsertStrategy = LazyFieldStrategy.NEVER,columnType="tinyint(1)")
private Boolean isDeleted;
/**
*
* 目标路由IP
*/
@Schema(description ="目标路由IP",name ="targetIp",example = "")
@LazyTableField(name="target_ip",comment="目标路由IP",notNull=true,columnType="varchar(255)")
private String targetIp;
/**
*
* 目标路由端口：默认ALL
*/
@Schema(description ="目标路由端口：默认ALL",name ="targetPort",example = "")
@LazyTableField(name="target_port",comment="目标路由端口：默认ALL",notNull=true,defaultValue="'ALL'",upsertStrategy = LazyFieldStrategy.NEVER,columnType="varchar(255)")
private String targetPort;
/**
*
* 更新时间
*/
@Schema(description ="更新时间",name ="updateTime",example = "")
@LazyTableField(name="update_time",comment="更新时间",defaultValue="CURRENT_TIMESTAMP",upsertStrategy = LazyFieldStrategy.NEVER,columnType="datetime",extra=" on update CURRENT_TIMESTAMP")
private LocalDateTime updateTime;
/**
*
* 虚拟服务端路由IP
*/
@Schema(description ="虚拟服务端路由IP",name ="virtualIp",example = "")
@LazyTableField(name="virtual_ip",comment="虚拟服务端路由IP",notNull=true,columnType="varchar(255)")
private String virtualIp;
/**
*
* 虚拟服务端路由端口：默认ALL
*/
@Schema(description ="虚拟服务端路由端口：默认ALL",name ="virtualPort",example = "")
@LazyTableField(name="virtual_port",comment="虚拟服务端路由端口：默认ALL",notNull=true,defaultValue="'ALL'",upsertStrategy = LazyFieldStrategy.NEVER,columnType="varchar(255)")
private String virtualPort;
}

18
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/infrastructure/jpa/lazy/LazyNettyClientVirtualRouteLazyJpaRepository.java Normal file
View File

@ -0,0 +1,18 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.jpa.lazy;
import org.wu.framework.lazy.orm.database.jpa.repository.LazyJpaRepository;
import org.wu.framework.lazy.orm.database.jpa.repository.annotation.*;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.entity.LazyNettyClientVirtualRouteDO;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyInfrastructureLazyJpa
**/
@LazyRepository
public interface LazyNettyClientVirtualRouteLazyJpaRepository extends LazyJpaRepository<LazyNettyClientVirtualRouteDO,Long> {
}

18
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/infrastructure/jpa/lazy/LazyNettyServerVirtualRouteLazyJpaRepository.java Normal file
View File

@ -0,0 +1,18 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.jpa.lazy;
import org.wu.framework.lazy.orm.database.jpa.repository.LazyJpaRepository;
import org.wu.framework.lazy.orm.database.jpa.repository.annotation.*;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.entity.LazyNettyServerVirtualRouteDO;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyInfrastructureLazyJpa
**/
@LazyRepository
public interface LazyNettyServerVirtualRouteLazyJpaRepository extends LazyJpaRepository<LazyNettyServerVirtualRouteDO,Long> {
}

15
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/infrastructure/mapper/LazyNettyClientVirtualRouteMapper.java Normal file
View File

@ -0,0 +1,15 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.mapper;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyInfrastructureMapper
**/
public interface LazyNettyClientVirtualRouteMapper {
}

15
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/infrastructure/mapper/LazyNettyServerVirtualRouteMapper.java Normal file
View File

@ -0,0 +1,15 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.mapper;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyInfrastructureMapper
**/
public interface LazyNettyServerVirtualRouteMapper {
}

155
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/infrastructure/persistence/LazyNettyClientVirtualRouteRepositoryImpl.java Normal file
View File

@ -0,0 +1,155 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.persistence;
import jakarta.annotation.Resource;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.client.virtual.route.LazyNettyClientVirtualRoute;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.client.virtual.route.LazyNettyClientVirtualRouteRepository;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.converter.LazyNettyClientVirtualRouteConverter;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.entity.LazyNettyClientVirtualRouteDO;
import org.springframework.stereotype.Repository;
import org.wu.framework.lazy.orm.database.lambda.domain.LazyPage;
import org.wu.framework.lazy.orm.database.lambda.stream.lambda.LazyLambdaStream;
import org.wu.framework.lazy.orm.database.lambda.stream.wrapper.LazyUpdateSetValueWrappers;
import org.wu.framework.lazy.orm.database.lambda.stream.wrapper.LazyWrappers;
import org.wu.framework.web.response.Result;
import org.wu.framework.web.response.ResultFactory;
import java.util.List;
import java.util.stream.Collectors;
/**
* describe 客户端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyInfrastructurePersistence
**/
@Repository
public class LazyNettyClientVirtualRouteRepositoryImpl implements LazyNettyClientVirtualRouteRepository {
@Resource
LazyLambdaStream lazyLambdaStream;
/**
* describe 新增客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRoute 新增客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRoute>} 客户端虚拟路由管理新增后领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyNettyClientVirtualRoute> story(LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute) {
LazyNettyClientVirtualRouteDO lazyNettyClientVirtualRouteDO = LazyNettyClientVirtualRouteConverter.INSTANCE.fromLazyNettyClientVirtualRoute(lazyNettyClientVirtualRoute);
lazyLambdaStream.upsert(lazyNettyClientVirtualRouteDO);
return ResultFactory.successOf();
}
/**
* describe 批量新增客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRouteList 批量新增客户端虚拟路由管理
* @return {@link Result<List<LazyNettyClientVirtualRoute>>} 客户端虚拟路由管理新增后领域对象集合
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<List<LazyNettyClientVirtualRoute>> batchStory(List<LazyNettyClientVirtualRoute> lazyNettyClientVirtualRouteList) {
List<LazyNettyClientVirtualRouteDO> lazyNettyClientVirtualRouteDOList = lazyNettyClientVirtualRouteList.stream().map(LazyNettyClientVirtualRouteConverter.INSTANCE::fromLazyNettyClientVirtualRoute).collect(Collectors.toList());
lazyLambdaStream.upsert(lazyNettyClientVirtualRouteDOList);
return ResultFactory.successOf();
}
/**
* describe 查询单个客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRoute 查询单个客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRoute>} 客户端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyNettyClientVirtualRoute> findOne(LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute) {
LazyNettyClientVirtualRouteDO lazyNettyClientVirtualRouteDO = LazyNettyClientVirtualRouteConverter.INSTANCE.fromLazyNettyClientVirtualRoute(lazyNettyClientVirtualRoute);
lazyNettyClientVirtualRouteDO.setIsDeleted(false);
LazyNettyClientVirtualRoute lazyNettyClientVirtualRouteOne = lazyLambdaStream.selectOne(LazyWrappers.lambdaWrapperBean(lazyNettyClientVirtualRouteDO), LazyNettyClientVirtualRoute.class);
return ResultFactory.successOf(lazyNettyClientVirtualRouteOne);
}
/**
* describe 查询多个客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRoute 查询多个客户端虚拟路由管理
* @return {@link Result<List<LazyNettyClientVirtualRoute>>} 客户端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<List<LazyNettyClientVirtualRoute>> findList(LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute) {
LazyNettyClientVirtualRouteDO lazyNettyClientVirtualRouteDO = LazyNettyClientVirtualRouteConverter.INSTANCE.fromLazyNettyClientVirtualRoute(lazyNettyClientVirtualRoute);
lazyNettyClientVirtualRouteDO.setIsDeleted(false);
List<LazyNettyClientVirtualRoute> lazyNettyClientVirtualRouteList = lazyLambdaStream.selectList(LazyWrappers.lambdaWrapperBean(lazyNettyClientVirtualRouteDO), LazyNettyClientVirtualRoute.class);
return ResultFactory.successOf(lazyNettyClientVirtualRouteList);
}
/**
* describe 分页查询多个客户端虚拟路由管理
*
* @param size 当前页数
* @param current 当前页
* @param lazyNettyClientVirtualRoute 分页查询多个客户端虚拟路由管理
* @return {@link Result<LazyPage<LazyNettyClientVirtualRoute>>} 分页客户端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyPage<LazyNettyClientVirtualRoute>> findPage(int size, int current, LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute) {
LazyNettyClientVirtualRouteDO lazyNettyClientVirtualRouteDO = LazyNettyClientVirtualRouteConverter.INSTANCE.fromLazyNettyClientVirtualRoute(lazyNettyClientVirtualRoute);
LazyPage<LazyNettyClientVirtualRoute> lazyPage = new LazyPage<>(current, size);
LazyPage<LazyNettyClientVirtualRoute> lazyNettyClientVirtualRouteLazyPage = lazyLambdaStream.selectPage(LazyWrappers.lambdaWrapperBean(lazyNettyClientVirtualRouteDO), lazyPage, LazyNettyClientVirtualRoute.class);
return ResultFactory.successOf(lazyNettyClientVirtualRouteLazyPage);
}
/**
* describe 删除客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRoute 删除客户端虚拟路由管理
* @return {@link Result<LazyNettyClientVirtualRoute>} 客户端虚拟路由管理
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyNettyClientVirtualRoute> remove(LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute) {
LazyNettyClientVirtualRouteDO lazyNettyClientVirtualRouteDO = LazyNettyClientVirtualRouteConverter.INSTANCE.fromLazyNettyClientVirtualRoute(lazyNettyClientVirtualRoute);
lazyLambdaStream.update(LazyUpdateSetValueWrappers.<LazyNettyClientVirtualRouteDO>lambdaWrapper()
.set(LazyNettyClientVirtualRouteDO::getIsDeleted, true),
LazyWrappers
.<LazyNettyClientVirtualRouteDO>lambdaWrapper()
.eq(LazyNettyClientVirtualRouteDO::getId, lazyNettyClientVirtualRouteDO.getId())
);
return ResultFactory.successOf();
}
/**
* describe 是否存在客户端虚拟路由管理
*
* @param lazyNettyClientVirtualRoute 客户端虚拟路由管理领域对象
* @return {@link Result<Boolean>} 是否存在 true 存在，false 不存在
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<Boolean> exists(LazyNettyClientVirtualRoute lazyNettyClientVirtualRoute) {
LazyNettyClientVirtualRouteDO lazyNettyClientVirtualRouteDO = LazyNettyClientVirtualRouteConverter.INSTANCE.fromLazyNettyClientVirtualRoute(lazyNettyClientVirtualRoute);
Boolean exists = lazyLambdaStream.exists(LazyWrappers.lambdaWrapperBean(lazyNettyClientVirtualRouteDO));
return ResultFactory.successOf(exists);
}
}

155
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/infrastructure/persistence/LazyNettyServerVirtualRouteRepositoryImpl.java Normal file
View File

@ -0,0 +1,155 @@
package org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.persistence;
import jakarta.annotation.Resource;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.server.virtual.route.LazyNettyServerVirtualRoute;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.domain.model.lazy.netty.server.virtual.route.LazyNettyServerVirtualRouteRepository;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.converter.LazyNettyServerVirtualRouteConverter;
import org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.entity.LazyNettyServerVirtualRouteDO;
import org.springframework.stereotype.Repository;
import org.wu.framework.lazy.orm.database.lambda.domain.LazyPage;
import org.wu.framework.lazy.orm.database.lambda.stream.lambda.LazyLambdaStream;
import org.wu.framework.lazy.orm.database.lambda.stream.wrapper.LazyUpdateSetValueWrappers;
import org.wu.framework.lazy.orm.database.lambda.stream.wrapper.LazyWrappers;
import org.wu.framework.web.response.Result;
import org.wu.framework.web.response.ResultFactory;
import java.util.List;
import java.util.stream.Collectors;
/**
* describe 服务端虚拟路由管理
*
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
* @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyInfrastructurePersistence
**/
@Repository
public class LazyNettyServerVirtualRouteRepositoryImpl implements LazyNettyServerVirtualRouteRepository {
@Resource
LazyLambdaStream lazyLambdaStream;
/**
* describe 新增服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRoute 新增服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRoute>} 服务端虚拟路由管理新增后领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyNettyServerVirtualRoute> story(LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute) {
LazyNettyServerVirtualRouteDO lazyNettyServerVirtualRouteDO = LazyNettyServerVirtualRouteConverter.INSTANCE.fromLazyNettyServerVirtualRoute(lazyNettyServerVirtualRoute);
lazyLambdaStream.upsert(lazyNettyServerVirtualRouteDO);
return ResultFactory.successOf();
}
/**
* describe 批量新增服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRouteList 批量新增服务端虚拟路由管理
* @return {@link Result<List<LazyNettyServerVirtualRoute>>} 服务端虚拟路由管理新增后领域对象集合
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<List<LazyNettyServerVirtualRoute>> batchStory(List<LazyNettyServerVirtualRoute> lazyNettyServerVirtualRouteList) {
List<LazyNettyServerVirtualRouteDO> lazyNettyServerVirtualRouteDOList = lazyNettyServerVirtualRouteList.stream().map(LazyNettyServerVirtualRouteConverter.INSTANCE::fromLazyNettyServerVirtualRoute).collect(Collectors.toList());
lazyLambdaStream.upsert(lazyNettyServerVirtualRouteDOList);
return ResultFactory.successOf();
}
/**
* describe 查询单个服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRoute 查询单个服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRoute>} 服务端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyNettyServerVirtualRoute> findOne(LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute) {
LazyNettyServerVirtualRouteDO lazyNettyServerVirtualRouteDO = LazyNettyServerVirtualRouteConverter.INSTANCE.fromLazyNettyServerVirtualRoute(lazyNettyServerVirtualRoute);
lazyNettyServerVirtualRouteDO.setIsDeleted(false);
LazyNettyServerVirtualRoute lazyNettyServerVirtualRouteOne = lazyLambdaStream.selectOne(LazyWrappers.lambdaWrapperBean(lazyNettyServerVirtualRouteDO), LazyNettyServerVirtualRoute.class);
return ResultFactory.successOf(lazyNettyServerVirtualRouteOne);
}
/**
* describe 查询多个服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRoute 查询多个服务端虚拟路由管理
* @return {@link Result<List<LazyNettyServerVirtualRoute>>} 服务端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<List<LazyNettyServerVirtualRoute>> findList(LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute) {
LazyNettyServerVirtualRouteDO lazyNettyServerVirtualRouteDO = LazyNettyServerVirtualRouteConverter.INSTANCE.fromLazyNettyServerVirtualRoute(lazyNettyServerVirtualRoute);
lazyNettyServerVirtualRouteDO.setIsDeleted(false);
List<LazyNettyServerVirtualRoute> lazyNettyServerVirtualRouteList = lazyLambdaStream.selectList(LazyWrappers.lambdaWrapperBean(lazyNettyServerVirtualRouteDO), LazyNettyServerVirtualRoute.class);
return ResultFactory.successOf(lazyNettyServerVirtualRouteList);
}
/**
* describe 分页查询多个服务端虚拟路由管理
*
* @param size 当前页数
* @param current 当前页
* @param lazyNettyServerVirtualRoute 分页查询多个服务端虚拟路由管理
* @return {@link Result<LazyPage<LazyNettyServerVirtualRoute>>} 分页服务端虚拟路由管理领域对象
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyPage<LazyNettyServerVirtualRoute>> findPage(int size, int current, LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute) {
LazyNettyServerVirtualRouteDO lazyNettyServerVirtualRouteDO = LazyNettyServerVirtualRouteConverter.INSTANCE.fromLazyNettyServerVirtualRoute(lazyNettyServerVirtualRoute);
LazyPage<LazyNettyServerVirtualRoute> lazyPage = new LazyPage<>(current, size);
LazyPage<LazyNettyServerVirtualRoute> lazyNettyServerVirtualRouteLazyPage = lazyLambdaStream.selectPage(LazyWrappers.lambdaWrapperBean(lazyNettyServerVirtualRouteDO), lazyPage, LazyNettyServerVirtualRoute.class);
return ResultFactory.successOf(lazyNettyServerVirtualRouteLazyPage);
}
/**
* describe 删除服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRoute 删除服务端虚拟路由管理
* @return {@link Result<LazyNettyServerVirtualRoute>} 服务端虚拟路由管理
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<LazyNettyServerVirtualRoute> remove(LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute) {
LazyNettyServerVirtualRouteDO lazyNettyServerVirtualRouteDO = LazyNettyServerVirtualRouteConverter.INSTANCE.fromLazyNettyServerVirtualRoute(lazyNettyServerVirtualRoute);
lazyLambdaStream.update(LazyUpdateSetValueWrappers.<LazyNettyServerVirtualRouteDO>lambdaWrapper()
.set(LazyNettyServerVirtualRouteDO::getIsDeleted, true),
LazyWrappers
.<LazyNettyServerVirtualRouteDO>lambdaWrapper()
.eq(LazyNettyServerVirtualRouteDO::getId, lazyNettyServerVirtualRouteDO.getId())
);
return ResultFactory.successOf();
}
/**
* describe 是否存在服务端虚拟路由管理
*
* @param lazyNettyServerVirtualRoute 服务端虚拟路由管理领域对象
* @return {@link Result<Boolean>} 是否存在 true 存在，false 不存在
* @author Jia wei Wu
* @date 2025/05/06 05:00 下午
**/
@Override
public Result<Boolean> exists(LazyNettyServerVirtualRoute lazyNettyServerVirtualRoute) {
LazyNettyServerVirtualRouteDO lazyNettyServerVirtualRouteDO = LazyNettyServerVirtualRouteConverter.INSTANCE.fromLazyNettyServerVirtualRoute(lazyNettyServerVirtualRoute);
Boolean exists = lazyLambdaStream.exists(LazyWrappers.lambdaWrapperBean(lazyNettyServerVirtualRouteDO));
return ResultFactory.successOf(exists);
}
}

18
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/infrastructure/xml/LazyNettyClientVirtualRouteMapper.xml Normal file
View File

@ -0,0 +1,18 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.mapper.LazyNettyClientVirtualRouteMapper">
<resultMap id="BaseResultMap" type="org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.entity.LazyNettyClientVirtualRouteDO">
<result column="create_time" property="createTime" />
<result column="`describe`" property="describe" />
<id column="id" property="id" />
<result column="is_deleted" property="isDeleted" />
<result column="target_client_id" property="targetClientId" />
<result column="target_ip" property="targetIp" />
<result column="target_port" property="targetPort" />
<result column="update_time" property="updateTime" />
<result column="virtual_ip" property="virtualIp" />
<result column="virtual_port" property="virtualPort" />
</resultMap>
</mapper>

17
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/infrastructure/xml/LazyNettyServerVirtualRouteMapper.xml Normal file
View File

@ -0,0 +1,17 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.mapper.LazyNettyServerVirtualRouteMapper">
<resultMap id="BaseResultMap" type="org.framework.lazy.cloud.network.heartbeat.server.standalone.infrastructure.entity.LazyNettyServerVirtualRouteDO">
<result column="create_time" property="createTime" />
<result column="`describe`" property="describe" />
<id column="id" property="id" />
<result column="is_deleted" property="isDeleted" />
<result column="target_ip" property="targetIp" />
<result column="target_port" property="targetPort" />
<result column="update_time" property="updateTime" />
<result column="virtual_ip" property="virtualIp" />
<result column="virtual_port" property="virtualPort" />
</resultMap>
</mapper>