proj_name
stringclasses 131
values | relative_path
stringlengths 30
228
| class_name
stringlengths 1
68
| func_name
stringlengths 1
48
| masked_class
stringlengths 78
9.82k
| func_body
stringlengths 46
9.61k
| len_input
int64 29
2.01k
| len_output
int64 14
1.94k
| total
int64 55
2.05k
| relevant_context
stringlengths 0
38.4k
|
|---|---|---|---|---|---|---|---|---|---|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/util/CommonLoginUtil.java
|
CommonLoginUtil
|
getUserId
|
class CommonLoginUtil {
/**
* 根据token获取用户ID
*
* @param token
* @return
* @
*/
public static Long getUserId(String token) {<FILL_FUNCTION_BODY>}
/**
* 获取用户ID
*
* @return
* @
*/
public static Long getUserId() {
String token = TokenUtil.getToken();
return getUserId(token);
}
/**
* 获取登录用户ID字符串
*
* @return
* @
*/
public static String getUserIdString() {
Long userId = getUserId();
if (userId == null) {
return null;
}
return userId.toString();
}
/**
* 根据系统类型获取用户ID
*
* @param systemType
* @return
* @
*/
public static Long getUserId(SystemType systemType) {
try {
if (SystemType.ADMIN == systemType) {
return LoginUtil.getUserId();
} else if (SystemType.APP == systemType) {
return AppLoginUtil.getUserId();
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
|
if (StringUtils.isBlank(token)) {
return null;
}
SystemType systemType = SystemTypeUtil.getSystemTypeByToken(token);
return getUserId(systemType);
| 345
| 54
| 399
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/util/LoginUtil.java
|
LoginUtil
|
getLoginVo
|
class LoginUtil {
private static LoginRedisService loginRedisService;
public LoginUtil(LoginRedisService loginRedisService) {
LoginUtil.loginRedisService = loginRedisService;
}
/**
* 根据token从redis中获取登录用户信息
*
* @param token
* @return
* @
*/
public static LoginVo getLoginVo(String token) {<FILL_FUNCTION_BODY>}
/**
* 从当前线程中获取登录用户信息
*
* @return
*/
public static LoginVo getLoginVo() {
return LoginCache.get();
}
/**
* 获取登录信息
*
* @return
*/
public static List<String> getPermissions() {
LoginVo loginVo = getLoginVo();
if (loginVo != null) {
return loginVo.getPermissions();
}
return null;
}
/**
* 获取登录用户ID
*
* @return
*/
public static Long getUserId() {
LoginVo loginVo = getLoginVo();
if (loginVo != null) {
Long userId = loginVo.getUserId();
return userId;
}
return null;
}
/**
* 获取登录用户ID字符串
*
* @return
* @
*/
public static String getUserIdString() {
Long userId = getUserId();
if (userId == null) {
return null;
}
return userId.toString();
}
/**
* 获取登录用户名
*
* @return
*/
public static String getUsername() {
LoginVo loginVo = getLoginVo();
if (loginVo != null) {
return loginVo.getUsername();
}
return null;
}
/**
* 获取登录角色ID
*
* @return
*/
public static Long getRoleId() {
LoginVo loginVo = getLoginVo();
if (loginVo != null) {
return loginVo.getRoleId();
}
return null;
}
/**
* 判断是否是管理员
*
* @return
* @
*/
public static boolean isAdmin() {
LoginVo loginVo = getLoginVo();
if (loginVo != null) {
return loginVo.isAdmin();
}
return false;
}
/**
* 判断不是管理员
*
* @return
* @
*/
public static boolean isNotAdmin() {
return !isAdmin();
}
/**
* 检查是否是管理员
*/
public static void checkAdmin() {
boolean admin = isAdmin();
if (!admin) {
throw new BusinessException("不是管理员，无权限");
}
}
}
|
if (StringUtils.isBlank(token)) {
return null;
}
LoginVo loginVo = loginRedisService.getLoginVo(token);
return loginVo;
| 790
| 53
| 843
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/auth/util/TokenUtil.java
|
TokenUtil
|
getToken
|
class TokenUtil {
/**
* 生成Admin后台Token
*
* @param userId
* @return
* @throws Exception
*/
public static String generateAdminToken(Long userId) {
String userMd5 = DigestUtils.md5Hex(userId.toString());
String adminToken = LoginConstant.ADMIN_TOKEN_PREFIX + userMd5 + "." + UUIDUtil.getUuid();
return adminToken;
}
/**
* 生成用户端Token
*
* @param userId
* @return
* @throws Exception
*/
public static String generateAppToken(Long userId) {
String userMd5 = DigestUtils.md5Hex(userId.toString());
String appToken = LoginConstant.APP_TOKEN_PREFIX + userMd5 + "." + UUIDUtil.getUuid();
return appToken;
}
/**
* 获取短的ID
*
* @param userId
* @return
* @throws Exception
*/
public static String getShortId(Long userId) {
// 将数字转换成数字加字母变为更短的字符串
// 36 表示基数(10 位数字 + 26 个字符)
String string = Long.toString(userId, 36);
return string;
}
/**
* 解析短的ID
*
* @param shorUserId
* @return
* @throws Exception
*/
public static Long parseShortId(String shorUserId) {
long userId = Long.parseLong(shorUserId, 36);
return userId;
}
/**
* 获取token
*
* @return
*/
public static String getToken() {
// 从当前线程获取
return TokenCache.get();
}
/**
* 从请求头或者请求参数中获取token
*
* @param request
* @return
*/
public static String getToken(HttpServletRequest request) {<FILL_FUNCTION_BODY>}
/**
* 从Cookie中获取token
*
* @param request
* @return
*/
public static String getTokenByCookie(HttpServletRequest request, SystemType systemType) {
Cookie[] cookies = request.getCookies();
if (ArrayUtils.isEmpty(cookies)) {
return null;
}
if (SystemType.ADMIN == systemType) {
// 管理系统token的cookie可以通过接口文档传递或者浏览器页面传递
return CookieUtil.getCookieValueByName(cookies, LoginConstant.ADMIN_COOKIE_TOKEN_NAME);
} else if (SystemType.APP == systemType) {
// 判断是否是接口文档请求，是则从cookie中获取，否则不获取，app接口只能通过接口文档传递token的cookie
if (HttpServletRequestUtil.isDocRequest()) {
return CookieUtil.getCookieValueByName(cookies, LoginConstant.APP_COOKIE_TOKEN_NAME);
}
return null;
} else {
String cookieValue = CookieUtil.getCookieValueByName(cookies, LoginConstant.ADMIN_COOKIE_TOKEN_NAME);
if (StringUtils.isBlank(cookieValue)) {
if (HttpServletRequestUtil.isDocRequest()) {
cookieValue = CookieUtil.getCookieValueByName(cookies, LoginConstant.APP_COOKIE_TOKEN_NAME);
}
}
return cookieValue;
}
}
/**
* 校验是否是admin的token
*
* @param token
* @throws Exception
*/
public static void checkAdminToken(String token) {
SystemType systemType = SystemTypeUtil.getSystemTypeByToken(token);
if (SystemType.ADMIN != systemType) {
throw new LoginTokenException("非管理后台token");
}
}
/**
* 校验是否是app的token
*
* @param token
* @throws Exception
*/
public static void checkAppToken(String token) {
SystemType systemType = SystemTypeUtil.getSystemTypeByToken(token);
if (SystemType.APP != systemType) {
throw new LoginTokenException("非移动端token");
}
}
}
|
if (request == null) {
throw new IllegalArgumentException("request不能为空");
}
// 从请求头中获取token
String token = request.getHeader(LoginConstant.TOKEN_NAME);
if (StringUtils.isBlank(token)) {
// 从请求参数中获取token
token = request.getParameter(LoginConstant.TOKEN_NAME);
}
String servletPath = request.getServletPath();
SystemType systemType = SystemTypeUtil.getSystemTypeByPath(servletPath);
if (StringUtils.isBlank(token)) {
// 从cookie中获取token
token = getTokenByCookie(request, systemType);
if (StringUtils.isNotBlank(token) && !token.startsWith(LoginConstant.TOKEN_PREFIX)) {
token = null;
}
}
if (StringUtils.isBlank(token)) {
return null;
}
// 校验token
if (!token.startsWith(LoginConstant.TOKEN_PREFIX)) {
log.error("token错误:" + token);
throw new LoginTokenException("token错误");
}
if (SystemType.ADMIN == systemType) {
checkAdminToken(token);
} else if (SystemType.APP == systemType) {
checkAppToken(token);
}
return token;
| 1,146
| 348
| 1,494
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/common/service/impl/UploadServiceImpl.java
|
UploadServiceImpl
|
upload
|
class UploadServiceImpl implements UploadService {
@Autowired
private FileProperties fileProperties;
@Autowired
private LocalFileProperties localFileProperties;
@Autowired
private SysFileService sysFileService;
@Override
public UploadVo upload(String type, MultipartFile multipartFile) throws Exception {<FILL_FUNCTION_BODY>}
private Integer getFileTypeByContentType(String contentType) {
if (StringUtils.isBlank(contentType)) {
return SysFileType.FILE.getCode();
}
if (contentType.startsWith(UploadConstant.IMAGE_TYPE)) {
return SysFileType.IMAGE.getCode();
} else if (contentType.startsWith(UploadConstant.AUDIO_TYPE) || contentType.startsWith(UploadConstant.VIDEO_TYPE)) {
return SysFileType.VIDEO.getCode();
} else if (contentType.startsWith(UploadConstant.XLS_TYPE) ||
contentType.startsWith(UploadConstant.XLSX_TYPE) ||
contentType.startsWith(UploadConstant.DOC_TYPE) ||
contentType.startsWith(UploadConstant.PPT_TYPE) ||
contentType.startsWith(UploadConstant.PDF_TYPE) ||
contentType.startsWith(UploadConstant.OFFICE_TYPE)
) {
return SysFileType.OFFICE.getCode();
} else {
return SysFileType.FILE.getCode();
}
}
@Override
public List<UploadVo> uploadBatch(String type, List<MultipartFile> multipartFiles) throws Exception {
log.info("批量文件上传结束");
List<UploadVo> uploadVos = new ArrayList<>();
for (MultipartFile multipartFile : multipartFiles) {
UploadVo upload = upload(type, multipartFile);
uploadVos.add(upload);
}
log.info("批量文件上传结束");
return uploadVos;
}
private void checkUploadType(String type, BigDecimal sizeMb, String extension) throws Exception {
UploadType uploadType = UploadType.get(type);
System.out.println("uploadType = " + uploadType);
if (UploadType.ANY == uploadType) {
return;
}
Integer maxSizeMb = uploadType.getMaxSizeMb();
List<String> extensions = uploadType.getExtensions();
if (sizeMb.doubleValue() > maxSizeMb) {
throw new UploadException("超过文件大小限制，请上传" + maxSizeMb + "MB以内的文件");
}
extension = extension.toLowerCase();
if (!extensions.contains(extension)) {
throw new UploadException("文件格式错误，请上传" + extensions.toString() + "格式的文件");
}
}
}
|
log.info("文件上传开始");
if (StringUtils.isBlank(type)) {
type = UploadType.ANY.getType();
}
String originalFilename = multipartFile.getOriginalFilename();
log.info("originalFilename:" + originalFilename);
String contentType = multipartFile.getContentType();
log.info("contentType:" + contentType);
long size = multipartFile.getSize();
log.info("size:" + size);
double mb = size * 1.00 / 1024 / 1024;
BigDecimal sizeMb = NumberUtil.round(mb, 2);
log.info("sizeMb:" + sizeMb);
// 获取文件后缀
String extension = FilenameUtils.getExtension(originalFilename);
// 校验业务类型
checkUploadType(type, sizeMb, extension);
// 上传目录名称：年月
String uploadDirName = DateUtil.format(new Date(), DatePattern.SIMPLE_MONTH_PATTERN);
// 文件名称：年月日时分秒+15位唯一ID
String formatDate = DateUtil.format(new Date(), DatePattern.PURE_DATETIME_PATTERN);
String newFileName = formatDate + IdWorker.getId() + "." + extension;
log.info("newFileName:" + newFileName);
String url;
File uploadFile = null;
FileServerType fileServerType = fileProperties.getFileServerType();
if (FileServerType.OSS == fileServerType) {
// 阿里云OSS文件上传
InputStream inputStream = multipartFile.getInputStream();
url = OssApi.upload(inputStream, uploadDirName, newFileName);
} else {
// 本地文件上传路径
String uploadPath = localFileProperties.getUploadPath();
File uploadRootDir = new File(uploadPath);
// 上传目录不存在，则直接创建
if (!uploadRootDir.exists()) {
uploadRootDir.mkdirs();
}
File uploadDir = new File(uploadRootDir, uploadDirName);
if (!uploadDir.exists()) {
uploadDir.mkdirs();
}
// 上传文件到本地目录
uploadFile = new File(uploadDir, newFileName);
log.info("uploadFile:" + uploadFile);
multipartFile.transferTo(uploadFile);
// 返回本地文件访问路径
url = localFileProperties.getAccessUrl() + "/" + uploadDirName + "/" + newFileName;
log.info("url:" + url);
}
// 保存文件记录
SysFile sysFile = new SysFile();
sysFile.setTraceId(TraceIdUtil.getTraceId());
sysFile.setServerType(fileServerType.getCode());
sysFile.setUploadType(type);
sysFile.setDirName(uploadDirName);
sysFile.setOriginalFileName(originalFilename);
sysFile.setFileName(newFileName);
sysFile.setContentType(contentType);
sysFile.setExtension(extension);
sysFile.setSize(size);
sysFile.setSizeMb(sizeMb);
sysFile.setUrl(url);
// 系统类型
SystemType systemType = SystemTypeUtil.getSystemTypeByToken();
if (systemType != null) {
sysFile.setSystemType(systemType.getCode());
sysFile.setUserId(CommonLoginUtil.getUserId(systemType));
}
// 文件物理路径，本地文件服务时才有
if (uploadFile != null) {
sysFile.setFilePath(uploadFile.getPath());
}
// 文件类型
Integer fileType = getFileTypeByContentType(contentType);
sysFile.setFileType(fileType);
// 请求IP和区域信息
String requestIp = IpUtil.getRequestIp();
String ipAreaDesc = IpRegionUtil.getIpAreaDesc(requestIp);
sysFile.setIp(requestIp);
sysFile.setIpArea(ipAreaDesc);
// 保存文件记录
sysFileService.save(sysFile);
UploadVo uploadVo = new UploadVo();
uploadVo.setId(sysFile.getId());
uploadVo.setOriginalFilename(originalFilename);
uploadVo.setFilename(newFileName);
uploadVo.setUrl(url);
uploadVo.setSize(size);
uploadVo.setSizeMb(sizeMb);
log.info("文件上传结束");
return uploadVo;
| 738
| 1,191
| 1,929
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/config/CorsConfig.java
|
CorsConfig
|
corsFilter
|
class CorsConfig {
/**
* CORS跨域设置
*
* @return
*/
@Bean
public CorsFilter corsFilter() {<FILL_FUNCTION_BODY>}
}
|
CorsConfiguration corsConfiguration = new CorsConfiguration();
// 允许访问的源
corsConfiguration.addAllowedOriginPattern("*");
// 允许访问的请求头
corsConfiguration.addAllowedHeader("*");
// 允许访问的请求方式
corsConfiguration.setAllowedMethods(Arrays.asList("OPTION", "GET", "POST"));
// 是否允许发送cookie
corsConfiguration.setAllowCredentials(true);
// 允许响应的头
corsConfiguration.addExposedHeader("*");
UrlBasedCorsConfigurationSource configurationSource = new UrlBasedCorsConfigurationSource();
configurationSource.registerCorsConfiguration("/**", corsConfiguration);
return new CorsFilter(configurationSource);
| 59
| 192
| 251
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/config/JacksonConfig.java
|
JacksonConfig
|
jackson2ObjectMapperBuilderCustomizer
|
class JacksonConfig {
@Value("${xss.enable}")
private boolean enableXss;
@Bean
public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {<FILL_FUNCTION_BODY>}
}
|
return builder -> {
builder.locale(Locale.CHINA);
builder.timeZone(TimeZone.getTimeZone(ZoneId.systemDefault()));
builder.simpleDateFormat(DatePattern.NORM_DATETIME_PATTERN);
// 反序列化(处理请求参数)
// 去掉请求参数中字符串左右两边的空格
builder.deserializerByType(String.class, JacksonStringDeserializer.INSTANCE);
builder.deserializerByType(Date.class, JacksonDateDeserializer.INSTANCE);
// 序列化(处理响应结果)
// 避免long类型精度丢失，将long类型序列化成字符串
builder.serializerByType(Long.class, ToStringSerializer.instance);
// 去掉响应结果中字符串左右两边的空格
builder.serializerByType(String.class, JacksonStringSerializer.INSTANCE);
// XSS序列化
if (enableXss) {
builder.serializerByType(String.class, new XssJacksonSerializer());
builder.deserializerByType(String.class, new XssJacksonDeserializer());
}
};
| 67
| 302
| 369
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/config/MybatisPlusConfig.java
|
MybatisPlusConfig
|
merchantLineHandler
|
class MybatisPlusConfig {
@Autowired
private MerchantLineProperties merchantLineProperties;
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
// 数据范围权限
interceptor.addInnerInterceptor(new DataPermissionInterceptor(new DataScopeHandler()));
// 多商户插件，默认关闭，如有需要，放开注释即可
// interceptor.addInnerInterceptor(new MerchantLineInnerInterceptor(merchantLineHandler()));
// 攻击 SQL 阻断解析器,防止全表更新与删除
interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
return interceptor;
}
/**
* 配置多商户插件
* 如果不需要删除即可
*
* @return
*/
@Bean
public MerchantLineHandler merchantLineHandler() {<FILL_FUNCTION_BODY>}
}
|
log.info("merchantLineProperties:" + merchantLineProperties);
return new MerchantLineHandler() {
@Override
public Expression getMerchantId() {
// TODO 可以在LoginUtil中添加获取商户ID的方法
// LoginUtil.getMerchantId();
return new LongValue(1);
}
@Override
public String getMerchantIdColumn() {
return merchantLineProperties.getMerchantIdColumn();
}
@Override
public boolean ignoreTable(String tableName) {
List<String> includeTables = merchantLineProperties.getIncludeTables();
// 判断如果包含指定的表，则不忽略，否则忽略
if (CollectionUtils.isNotEmpty(includeTables)) {
if (includeTables.contains(tableName)) {
return false;
}
}
return true;
}
/**
* 判断系统类型和系统角色，是否忽略添加商户ID
* 添加商户ID的情况
* 1：是管理后台的请求
* 2：非管理员
* 除此之外，都忽略
*
* @return
*/
@Override
public boolean ignoreMerchantId() {
try {
if (SystemTypeUtil.isAdminSystem() && LoginUtil.isNotAdmin()) {
return false;
}
} catch (Exception e) {
e.printStackTrace();
}
return true;
}
};
| 270
| 373
| 643
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/config/OpenApiConfig.java
|
OpenApiConfig
|
projectApi
|
class OpenApiConfig {
private static final String TOKEN_NAME = LoginConstant.TOKEN_NAME;
private static String AUTH_PACKAGE = "io.geekidea.boot.auth";
private static String SYSTEM_PACKAGE = "io.geekidea.boot.system";
private static String USER_PACKAGE = "io.geekidea.boot.user";
private static String COMMON_PACKAGE = "io.geekidea.boot.common";
private static String GENERATOR_PACKAGE = "io.geekidea.boot.generator";
@Autowired
private OpenApiProperties openApiProperties;
/**
* token请求头参数
*/
private Parameter tokenParameter = new HeaderParameter().name(TOKEN_NAME).required(false).schema(new StringSchema()._default("").name(TOKEN_NAME));
@Bean
public OpenAPI openApi() {
return new OpenAPI()
.info(new Info()
.title(openApiProperties.getTitle())
.description(openApiProperties.getDescription())
.termsOfService(openApiProperties.getTermsOfService())
.contact(new Contact().name(openApiProperties.getContactName()).url(openApiProperties.getContactUrl()).email(openApiProperties.getContactEmail()))
.version(openApiProperties.getVersion()))
.externalDocs(new ExternalDocumentation().description(openApiProperties.getExternalDescription()).url(openApiProperties.getExternalUrl()));
}
@Bean
public GroupedOpenApi authApi() {
String[] packagedToMatch = {AUTH_PACKAGE};
return api("2.登录授权接口文档", packagedToMatch);
}
@Bean
public GroupedOpenApi adminApi() {
String[] packagedToMatch = {SYSTEM_PACKAGE};
return api("3.系统管理接口文档", packagedToMatch);
}
@Bean
public GroupedOpenApi userApi() {
String[] packagedToMatch = {USER_PACKAGE};
return api("4.App用户模块接口文档", packagedToMatch);
}
@Bean
public GroupedOpenApi commonApi() {
String[] packagedToMatch = {COMMON_PACKAGE};
return api("5.公共服务接口文档", packagedToMatch);
}
@Bean
public GroupedOpenApi generatorApi() {
String[] packagedToMatch = {GENERATOR_PACKAGE};
return api("6.生成代码接口文档", packagedToMatch);
}
/**
* 除了上面的接口之外，其它的接口都在项目接口文档中
* 请根据实际情况进行自定义
*
* @return
*/
@Bean
public GroupedOpenApi projectApi() {<FILL_FUNCTION_BODY>}
/**
* 配置接口
*
* @param group
* @param packagedToMatch
* @return
*/
private GroupedOpenApi api(String group, String[] packagedToMatch) {
return GroupedOpenApi.builder()
.group(group)
.addOperationCustomizer(getOperationCustomizer())
.pathsToMatch("/**")
.packagesToScan(packagedToMatch).build();
}
/**
* 配置自定义请求头
*
* @return
*/
public OperationCustomizer getOperationCustomizer() {
return (operation, handlerMethod) -> {
operation.addParametersItem(tokenParameter);
return operation;
};
}
}
|
return GroupedOpenApi.builder()
.group("1.项目接口文档")
.addOperationCustomizer(getOperationCustomizer())
.pathsToMatch("/**")
.packagesToExclude(AUTH_PACKAGE, SYSTEM_PACKAGE, USER_PACKAGE, COMMON_PACKAGE, GENERATOR_PACKAGE)
.build();
| 922
| 98
| 1,020
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/config/RedisConfig.java
|
RedisConfig
|
redisTemplate
|
class RedisConfig {
@Value("${redis.projectPrefix}")
private String projectPrefix;
@Bean
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {<FILL_FUNCTION_BODY>}
}
|
RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory);
// 自定义的string序列化器和fastjson序列化器
CustomStringRedisSerializer customStringRedisSerializer = new CustomStringRedisSerializer(projectPrefix);
// jackson 序列化器
GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
// kv 序列化
redisTemplate.setKeySerializer(customStringRedisSerializer);
redisTemplate.setValueSerializer(jsonRedisSerializer);
// hash 序列化
redisTemplate.setHashKeySerializer(customStringRedisSerializer);
redisTemplate.setHashValueSerializer(jsonRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
| 73
| 216
| 289
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/config/WebMvcConfig.java
|
WebMvcConfig
|
traceIdLogFilter
|
class WebMvcConfig implements WebMvcConfigurer {
@Autowired
private LoginProperties loginProperties;
@Autowired
private LoginAdminProperties loginAdminProperties;
@Autowired
private LoginAppProperties loginAppProperties;
@Autowired
private LoginCommonProperties loginCommonProperties;
@Autowired
private LocalFileProperties localFileProperties;
@Autowired
private XssProperties xssProperties;
@Autowired
private NotAuthProperties notAuthProperties;
@Bean
public ExcludePathInterceptor excludePathInterceptor() {
return new ExcludePathInterceptor();
}
@Bean
public NotAuthInterceptor notAuthInterceptor() {
return new NotAuthInterceptor();
}
@Bean
public TokenInterceptor tokenInterceptor() {
return new TokenInterceptor();
}
@Bean
public LoginInterceptor loginInterceptor() {
return new LoginInterceptor();
}
@Bean
public AppLoginInterceptor loginAppInterceptor() {
return new AppLoginInterceptor();
}
@Bean
public CommonLoginInterceptor loginCommonInterceptor() {
return new CommonLoginInterceptor();
}
@Bean
public RefreshTokenInterceptor refreshTokenInterceptor() {
return new RefreshTokenInterceptor();
}
@Bean
public PageHelperClearInterceptor pageHelperClearInterceptor() {
return new PageHelperClearInterceptor();
}
@Bean
public FilterRegistrationBean traceIdLogFilter() {<FILL_FUNCTION_BODY>}
@Bean
public FilterRegistrationBean jsonRequestBodyFilter() {
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
JsonRequestBodyFilter jsonRequestBodyFilter = new JsonRequestBodyFilter();
filterRegistrationBean.setFilter(jsonRequestBodyFilter);
List<String> urls = new ArrayList<>();
urls.add("/*");
filterRegistrationBean.setUrlPatterns(urls);
return filterRegistrationBean;
}
/**
* XssFilter配置
*
* @return
*/
@Bean
public FilterRegistrationBean xssFilter() {
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
filterRegistrationBean.setFilter(new XssFilter());
filterRegistrationBean.setEnabled(xssProperties.isEnable());
filterRegistrationBean.addUrlPatterns(xssProperties.getUrlPatterns());
filterRegistrationBean.setOrder(xssProperties.getOrder());
filterRegistrationBean.setAsyncSupported(xssProperties.isAsync());
return filterRegistrationBean;
}
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
// 上传文件访问路径
String accessPath = localFileProperties.getAccessPath();
// 上传文件保存路径
String uploadPath = localFileProperties.getUploadPath();
if (StringUtils.isNotBlank(accessPath) && StringUtils.isNotBlank(uploadPath)) {
// 虚拟目录文件映射
registry.addResourceHandler(accessPath)
.addResourceLocations("file:" + uploadPath);
}
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
// 加入的顺序就是拦截器执行的顺序
registry.addInterceptor(excludePathInterceptor());
// 没有权限的拦截器，直接返回无权限
boolean enableNotAuth = notAuthProperties.isEnable();
if (enableNotAuth) {
List<String> includePaths = notAuthProperties.getIncludePaths();
registry.addInterceptor(notAuthInterceptor()).addPathPatterns(includePaths);
}
// token拦截器
registry.addInterceptor(tokenInterceptor()).excludePathPatterns("/admin/login", "/app/login");
// 管理后台登录拦截器配置
boolean enableAdminInterceptor = loginAdminProperties.isEnable();
if (enableAdminInterceptor) {
List<String> excludePaths = loginProperties.getExcludePaths();
List<String> adminExcludePaths = loginAdminProperties.getExcludePaths();
adminExcludePaths.addAll(excludePaths);
registry.addInterceptor(loginInterceptor())
.addPathPatterns(loginAdminProperties.getIncludePaths())
.excludePathPatterns(adminExcludePaths);
}
// 移动端端登录拦截器配置
boolean enableAppInterceptor = loginAppProperties.isEnable();
if (enableAppInterceptor) {
List<String> appIncludePaths = loginAppProperties.getIncludePaths();
List<String> excludePaths = loginAppProperties.getExcludePaths();
registry.addInterceptor(loginAppInterceptor()).addPathPatterns(appIncludePaths).excludePathPatterns(excludePaths);
}
// 刷新token拦截器
registry.addInterceptor(refreshTokenInterceptor());
// 系统公共请求拦截器，子拦截/common/开头的请求
boolean enableCommonInterceptor = loginCommonProperties.isEnable();
if (enableCommonInterceptor) {
registry.addInterceptor(loginCommonInterceptor()).addPathPatterns(loginCommonProperties.getIncludePaths());
}
// 分页缓存清除拦截器
registry.addInterceptor(pageHelperClearInterceptor());
}
}
|
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
TraceIdLogFilter traceIdLogFilter = new TraceIdLogFilter();
filterRegistrationBean.setFilter(traceIdLogFilter);
filterRegistrationBean.setUrlPatterns(Arrays.asList("/*"));
return filterRegistrationBean;
| 1,438
| 82
| 1,520
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/config/properties/LocalFileProperties.java
|
LocalFileProperties
|
setUploadPath
|
class LocalFileProperties {
/**
* 上传文件访问路径
*/
private String accessPath;
/**
* 上传文件保存路径
*/
private String uploadPath;
/**
* 上传文件访问URL前缀
*/
private String accessUrl;
public void setUploadPath(String uploadPath) {<FILL_FUNCTION_BODY>}
}
|
if (StringUtils.isBlank(uploadPath)) {
// 默认为当前项目路径下的upload目录
String userDir = CommonConstant.USER_DIR;
uploadPath = userDir + File.separator + CommonConstant.UPLOAD + File.separator;
} else {
// 如果不是以/或\\结尾，则根据系统环境加上对应的斜杠结尾
if (!(uploadPath.endsWith(CommonConstant.SLASH) || uploadPath.endsWith(CommonConstant.DOUBLE_BACKSLASH))) {
uploadPath = uploadPath + File.separator;
}
}
this.uploadPath = uploadPath;
| 112
| 165
| 277
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/config/properties/LoginAdminProperties.java
|
LoginAdminProperties
|
getTokenExpireMinutes
|
class LoginAdminProperties {
/**
* 是否启用登录校验
*/
private boolean enable;
/**
* 是否单次登录
* true: 用户最后一次登录有效，之前的登录会话下线
* false: 用户可多次登录，多次登录的会话都生效
*/
private boolean singleLogin;
/**
* token过期分钟数
*/
private Integer tokenExpireMinutes;
/**
* 方法是否鉴权
*/
private boolean loginPermission;
/**
* 包含的路径
*/
private List<String> includePaths;
/**
* 排除的路径
*/
private List<String> excludePaths;
public void setExcludePaths(List<String> excludePaths) {
this.excludePaths = YamlUtil.parseListArray(excludePaths);
}
public void setIncludePaths(List<String> includePaths) {
this.includePaths = YamlUtil.parseListArray(includePaths);
}
public Integer getTokenExpireMinutes() {<FILL_FUNCTION_BODY>}
}
|
if (tokenExpireMinutes == null) {
this.tokenExpireMinutes = LoginConstant.ADMIN_TOKEN_EXPIRE_MINUTES;
}
return tokenExpireMinutes;
| 311
| 56
| 367
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/config/properties/LoginAppProperties.java
|
LoginAppProperties
|
getTokenExpireDays
|
class LoginAppProperties {
/**
* 是否启用登录校验
*/
private boolean enable;
/**
* 默认拦截包含路径开头的所有请求(/app/**)，在不需要验证登录的controller方法加上@IgnoreLogin，表示此方法不需要登录就能调用
* 默认不拦截包含路径开头的所有请求(/app/**)，在需要登录的controller方法上加上注解@Login，表示此方法必须登录才能调用
*/
private LoginInterceptStrategy loginInterceptStrategy;
/**
* 是否单次登录
* true: 用户最后一次登录有效，之前的登录会话下线
* false: 用户可多次登录，多次登录的会话都生效
*/
private boolean singleLogin;
/**
* token过期天数
*/
private Integer tokenExpireDays;
/**
* 方法是否鉴权
*/
private boolean loginPermission;
/**
* 包含的路径
*/
private List<String> includePaths;
/**
* 排除的路径
*/
private List<String> excludePaths;
/**
* 需要登录校验的请求路径，与@Login效果一样
*/
private List<String> checkLoginPaths;
/**
* 忽略登录校验的请求路径，与@IgnoreLogin效果一样
*/
private List<String> ignoreLoginPaths;
public void setExcludePaths(List<String> excludePaths) {
this.excludePaths = YamlUtil.parseListArray(excludePaths);
}
public Integer getTokenExpireDays() {<FILL_FUNCTION_BODY>}
public void setCheckLoginPaths(List<String> checkLoginPaths) {
this.checkLoginPaths = YamlUtil.parseListArray(checkLoginPaths);
}
public void setIgnoreLoginPaths(List<String> ignoreLoginPaths) {
this.ignoreLoginPaths = YamlUtil.parseListArray(ignoreLoginPaths);
}
}
|
if (tokenExpireDays == null) {
this.tokenExpireDays = LoginConstant.APP_TOKEN_EXPIRE_DAYS;
}
return tokenExpireDays;
| 546
| 54
| 600
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/exception/GlobalExceptionHandler.java
|
GlobalExceptionHandler
|
handle
|
class GlobalExceptionHandler {
/**
* 全局异常处理
*
* @param exception
* @return
*/
public static ApiResult handle(Throwable exception) {<FILL_FUNCTION_BODY>}
/**
* 全局异常处理
*
* @param exception
* @return
*/
@ExceptionHandler(value = Exception.class)
@ResponseStatus(HttpStatus.OK)
public ApiResult exceptionHandle(Exception exception) {
log.error("exception:", exception);
return handle(exception);
}
}
|
if (exception instanceof LoginException) {
return ApiResult.fail(ApiCode.TOKEN_EXCEPTION, exception.getMessage());
} else if (exception instanceof NotAuthException) {
return ApiResult.fail(exception.getMessage());
} else if (exception instanceof BusinessException) {
return ApiResult.fail(exception.getMessage());
} else if (exception instanceof MethodArgumentNotValidException) {
MethodArgumentNotValidException ex = (MethodArgumentNotValidException) exception;
BindingResult bindingResult = ex.getBindingResult();
List<FieldError> fieldErrors = bindingResult.getFieldErrors();
FieldError fieldError = fieldErrors.get(0);
String errorMessage = fieldError.getDefaultMessage();
log.error("参数校验错误" + "：" + errorMessage);
return ApiResult.fail(errorMessage);
} else if (exception instanceof HttpMessageNotReadableException) {
return ApiResult.fail("请求参数解析异常");
} else if (exception instanceof MethodArgumentTypeMismatchException) {
return ApiResult.fail("请求参数数据类型错误");
} else if (exception instanceof DuplicateKeyException) {
return ApiResult.fail("数据违反唯一约束");
} else if (exception instanceof DataIntegrityViolationException) {
return ApiResult.fail("数据完整性异常");
} else if (exception instanceof HttpRequestMethodNotSupportedException) {
return ApiResult.fail(exception.getMessage());
}
return ApiResult.fail();
| 149
| 378
| 527
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/filter/JsonHttpServletRequestWrapper.java
|
JsonHttpServletRequestWrapper
|
getInputStream
|
class JsonHttpServletRequestWrapper extends HttpServletRequestWrapper {
private byte[] body;
public JsonHttpServletRequestWrapper(HttpServletRequest request) {
super(request);
//保存一份InputStream，将其转换为字节数组
try {
body = StreamUtils.copyToByteArray(request.getInputStream());
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 转换成String
*
* @return
*/
public String getBodyString() {
String bodyString = new String(body, StandardCharsets.UTF_8);
return bodyString;
}
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(getInputStream()));
}
/**
* 把保存好的InputStream，传下去
*
* @return
* @throws IOException
*/
@Override
public ServletInputStream getInputStream() throws IOException {<FILL_FUNCTION_BODY>}
}
|
final ByteArrayInputStream bais = new ByteArrayInputStream(body);
return new ServletInputStream() {
@Override
public int read() throws IOException {
return bais.read();
}
@Override
public boolean isFinished() {
return false;
}
@Override
public boolean isReady() {
return false;
}
@Override
public void setReadListener(ReadListener listener) {
}
};
| 261
| 120
| 381
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/filter/JsonRequestBodyFilter.java
|
JsonRequestBodyFilter
|
doFilter
|
class JsonRequestBodyFilter implements Filter {
private static final String APPLICATION_JSON = "application/json";
private static final String METHOD_POST = "POST";
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {<FILL_FUNCTION_BODY>}
}
|
JsonHttpServletRequestWrapper requestWrapper = null;
try {
if (request instanceof HttpServletRequest) {
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
String method = httpServletRequest.getMethod();
String contentType = httpServletRequest.getContentType();
if (METHOD_POST.equalsIgnoreCase(method) && StringUtils.isNotBlank(contentType)) {
contentType = contentType.toLowerCase();
if (contentType.startsWith(APPLICATION_JSON)) {
requestWrapper = new JsonHttpServletRequestWrapper((HttpServletRequest) request);
String bodyString = requestWrapper.getBodyString();
requestWrapper.setAttribute(CommonConstant.REQUEST_PARAM_BODY_STRING, bodyString);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
if (requestWrapper == null) {
chain.doFilter(request, response);
} else {
chain.doFilter(requestWrapper, response);
}
| 88
| 254
| 342
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/filter/TraceIdLogFilter.java
|
TraceIdLogFilter
|
doFilter
|
class TraceIdLogFilter implements Filter {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {<FILL_FUNCTION_BODY>}
}
|
try {
HttpServletRequest request = (HttpServletRequest) servletRequest;
// 设置日志链路ID
String traceId = IdWorker.getIdStr();
// 设置请求IP
String ip = IpUtil.getRequestIp(request);
try {
MDC.put(CommonConstant.TRACE_ID, traceId);
MDC.put(CommonConstant.IP, ip);
} catch (IllegalArgumentException e) {
e.printStackTrace();
}
// 执行
filterChain.doFilter(servletRequest, servletResponse);
} catch (Exception e) {
throw e;
} finally {
// 移除日志链路ID
try {
MDC.remove(CommonConstant.TRACE_ID);
} catch (IllegalArgumentException e) {
e.printStackTrace();
}
}
| 60
| 222
| 282
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/interceptor/BaseExcludeMethodInterceptor.java
|
BaseExcludeMethodInterceptor
|
preHandle
|
class BaseExcludeMethodInterceptor extends BaseMethodInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {<FILL_FUNCTION_BODY>}
}
|
if (handler instanceof HandlerMethod) {
HandlerMethod handlerMethod = (HandlerMethod) handler;
// 如果是排除路径，则跳过处理
Boolean isExcludePath = (Boolean) request.getAttribute(CommonConstant.REQUEST_PARAM_EXCLUDE_PATH);
if (isExcludePath != null && isExcludePath) {
return true;
}
return preHandleMethod(request, response, handlerMethod);
}
return true;
| 59
| 120
| 179
|
<methods>public non-sealed void <init>() ,public boolean preHandle(HttpServletRequest, HttpServletResponse, java.lang.Object) throws java.lang.Exception<variables>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/interceptor/BaseMethodInterceptor.java
|
BaseMethodInterceptor
|
isIgnoreLoginPath
|
class BaseMethodInterceptor implements HandlerInterceptor {
/**
* 只处理方法的控制器
*
* @param request
* @param response
* @param handlerMethod
* @return
* @throws Exception
*/
protected abstract boolean preHandleMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
if (handler instanceof HandlerMethod) {
HandlerMethod handlerMethod = (HandlerMethod) handler;
return preHandleMethod(request, response, handlerMethod);
}
return true;
}
/**
* 判断方法上和类上是否存在@Login注解
*
* @param handlerMethod
* @return
*/
protected boolean existsLoginAnnotation(HandlerMethod handlerMethod) {
// 从方法上获取登录注解
Login login = handlerMethod.getMethodAnnotation(Login.class);
if (login != null) {
return true;
}
// 从类上获取登录注解
login = handlerMethod.getMethod().getDeclaringClass().getAnnotation(Login.class);
if (login != null) {
return true;
}
return false;
}
/**
* 判断方法上和类上是否存在@IgnoreLogin注解
*
* @param handlerMethod
* @return
*/
protected boolean existsIgnoreLoginAnnotation(HandlerMethod handlerMethod) {
IgnoreLogin ignoreLogin = handlerMethod.getMethodAnnotation(IgnoreLogin.class);
if (ignoreLogin != null) {
return true;
}
ignoreLogin = handlerMethod.getMethod().getDeclaringClass().getAnnotation(IgnoreLogin.class);
if (ignoreLogin != null) {
return true;
}
return false;
}
/**
* 获取方法上和类上的@AppUserRole注解
*
* @param handlerMethod
* @return
*/
protected AppUserRole getAppUserRoleAnnotation(HandlerMethod handlerMethod) {
AppUserRole appUserRole = handlerMethod.getMethodAnnotation(AppUserRole.class);
if (appUserRole != null) {
return appUserRole;
}
appUserRole = handlerMethod.getMethod().getDeclaringClass().getAnnotation(AppUserRole.class);
if (appUserRole != null) {
return appUserRole;
}
return null;
}
/**
* 判断当前请求的路径，是否是不需要的路径
*
* @param request
* @param ignoreLoginPaths
* @return
*/
protected boolean isIgnoreLoginPath(HttpServletRequest request, List<String> ignoreLoginPaths) {<FILL_FUNCTION_BODY>}
/**
* 判断当前请求的路径，是否是需要登录的路径
*
* @param request
* @param loginPaths
* @return
*/
protected boolean isCheckLoginPath(HttpServletRequest request, List<String> loginPaths) {
String servletPath = request.getServletPath();
if (CollectionUtils.isNotEmpty(loginPaths)) {
for (String loginPath : loginPaths) {
AntPathMatcher antPathMatcher = new AntPathMatcher();
boolean match = antPathMatcher.match(loginPath, servletPath);
if (match) {
return true;
}
}
}
return false;
}
}
|
String servletPath = request.getServletPath();
if (CollectionUtils.isNotEmpty(ignoreLoginPaths)) {
for (String ignoreLoginPath : ignoreLoginPaths) {
AntPathMatcher antPathMatcher = new AntPathMatcher();
boolean match = antPathMatcher.match(ignoreLoginPath, servletPath);
if (match) {
return true;
}
}
}
return false;
| 893
| 111
| 1,004
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/interceptor/PageHelperClearInterceptor.java
|
PageHelperClearInterceptor
|
preHandleMethod
|
class PageHelperClearInterceptor extends BaseMethodInterceptor {
@Override
protected boolean preHandleMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {<FILL_FUNCTION_BODY>}
}
|
try {
PageHelper.clearPage();
} catch (Exception e) {
e.printStackTrace();
}
return true;
| 62
| 40
| 102
|
<methods>public non-sealed void <init>() ,public boolean preHandle(HttpServletRequest, HttpServletResponse, java.lang.Object) throws java.lang.Exception<variables>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/jackson/deserializer/JacksonDateDeserializer.java
|
JacksonDateDeserializer
|
deserialize
|
class JacksonDateDeserializer extends JsonDeserializer<Date> {
public static final JacksonDateDeserializer INSTANCE = new JacksonDateDeserializer();
/**
* 日期格式数组
*/
private static final String[] DATE_PATTERNS = {
"yyyy-MM-dd HH:mm:ss",
"yyyy-MM-dd",
};
@Override
public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JacksonException {<FILL_FUNCTION_BODY>}
}
|
String dateString = jsonParser.getText();
if (dateString == null) {
return null;
}
dateString = dateString.trim();
if (StringUtils.isBlank(dateString)) {
return null;
}
Date date = null;
boolean flag = false;
for (int i = 0; i < DATE_PATTERNS.length; i++) {
try {
String datePattern = DATE_PATTERNS[i];
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(datePattern);
date = simpleDateFormat.parse(dateString);
flag = true;
break;
} catch (ParseException e) {
}
}
if (flag) {
return date;
} else {
throw new IllegalArgumentException("不能解析的日期:" + dateString);
}
| 148
| 218
| 366
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/jackson/deserializer/JacksonStringDeserializer.java
|
JacksonStringDeserializer
|
deserialize
|
class JacksonStringDeserializer extends JsonDeserializer<String> {
public static final JacksonStringDeserializer INSTANCE = new JacksonStringDeserializer();
@Override
public String deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JacksonException {<FILL_FUNCTION_BODY>}
}
|
String value = jsonParser.getValueAsString();
if (value != null) {
// 去除字符串空格
value = value.trim();
}
return value;
| 85
| 52
| 137
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/jackson/serializer/JacksonStringSerializer.java
|
JacksonStringSerializer
|
serialize
|
class JacksonStringSerializer extends JsonSerializer<String> {
public static final JacksonStringSerializer INSTANCE = new JacksonStringSerializer();
@Override
public void serialize(String string, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {<FILL_FUNCTION_BODY>}
}
|
if (string != null) {
// 去除字符串空格
string = string.trim();
}
jsonGenerator.writeString(string);
| 74
| 45
| 119
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/mybatis/config/BootMetaObjectHandler.java
|
BootMetaObjectHandler
|
updateFill
|
class BootMetaObjectHandler implements MetaObjectHandler {
@Override
public void insertFill(MetaObject metaObject) {
log.info("start insert fill ....");
// 创建人
try {
this.strictInsertFill(metaObject, "createId", Long.class, CommonLoginUtil.getUserId());
} catch (Exception e) {
}
// 创建时间
this.strictInsertFill(metaObject, "createTime", Date.class, new Date());
}
@Override
public void updateFill(MetaObject metaObject) {<FILL_FUNCTION_BODY>}
}
|
log.info("start update fill ....");
// 修改人
try {
this.strictUpdateFill(metaObject, "updateId", Long.class, CommonLoginUtil.getUserId());
} catch (Exception e) {
}
// 修改时间
this.strictUpdateFill(metaObject, "updateTime", Date.class, new Date());
| 154
| 94
| 248
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/mybatis/plugins/handler/DataScopeHandler.java
|
DataScopeHandler
|
getSqlSegment
|
class DataScopeHandler implements DataPermissionHandler {
private static final String _COUNT = "_COUNT";
@Override
public Expression getSqlSegment(Expression where, String mappedStatementId) {<FILL_FUNCTION_BODY>}
/**
* 获取目标方法
*
* @param clazz
* @param methodName
* @return
* @throws Exception
*/
private Method getTargetMethod(Class<?> clazz, String methodName) throws Exception {
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
if (method.getName().equals(methodName)) {
return method;
}
}
return null;
}
}
|
try {
Class<?> clazz = Class.forName(mappedStatementId.substring(0, mappedStatementId.lastIndexOf(StringPool.DOT)));
String methodName = mappedStatementId.substring(mappedStatementId.lastIndexOf(StringPool.DOT) + 1);
if (methodName.endsWith(_COUNT)) {
// 如果是分页获取数量方法，则截取原方法名称
methodName = methodName.substring(0, methodName.lastIndexOf("_"));
}
// 获取目标方法
Method method = getTargetMethod(clazz, methodName);
// 不是自定义方法，跳过
if (method == null) {
return where;
}
// 获取方法数据范围注解
DataScope dataScope = method.getAnnotation(DataScope.class);
// 如果没有指定数据范围注解，则跳过
if (dataScope == null) {
return where;
}
// 用户表别名
String userAlias = dataScope.userAlias();
// 用户列名称
String userIdColumn = dataScope.userIdColumn();
// 用户列完整名称
String userColumnName = userIdColumn;
if (StringUtils.isNotBlank(userAlias)) {
userColumnName = userAlias + "." + userIdColumn;
}
String dataScopeSql = null;
// 获取系统类型
SystemType systemType = SystemTypeUtil.getSystemTypeByToken();
if (SystemType.ADMIN == systemType) {
// 管理后台数据权限处理
// 管理员跳过
if (LoginUtil.isAdmin()) {
return where;
}
// 获取当前登录用户ID
Long userId = LoginUtil.getUserId();
// 增加数据范围sql
dataScopeSql = userColumnName + " = " + userId;
// TODO 如果是商城，则判断商家表别名和列名称，如果有部门数据权限，则判断部门表和列别名
// ...
} else if (SystemType.APP == systemType) {
// APP移动端数据权限处理
// 获取当前登录用户ID
Long userId = AppLoginUtil.getUserId();
// 增加数据范围sql
dataScopeSql = userColumnName + " = " + userId;
}
if (StringUtils.isBlank(dataScopeSql)) {
return where;
}
Expression appendExpression = CCJSqlParserUtil.parseCondExpression(dataScopeSql);
if (where == null) {
return appendExpression;
}
return new AndExpression(where, appendExpression);
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("");
}
| 182
| 699
| 881
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/page/BasePageQuery.java
|
BasePageQuery
|
getPageSize
|
class BasePageQuery extends BaseOrderQuery {
private static final long serialVersionUID = -6831815750258997473L;
@Schema(description = "页码,默认为1", example = "1")
private Integer pageIndex = CommonConstant.DEFAULT_PAGE_INDEX;
@Schema(description = "页大小,默认为10", example = "10")
private Integer pageSize = CommonConstant.DEFAULT_PAGE_SIZE;
@Schema(description = "关键字搜索")
private String keyword;
public Integer getPageIndex() {
if (pageIndex == null || pageIndex <= 0) {
pageIndex = CommonConstant.DEFAULT_PAGE_INDEX;
}
return pageIndex;
}
public Integer getPageSize() {<FILL_FUNCTION_BODY>}
}
|
if (pageSize == null || pageSize <= 0) {
pageSize = CommonConstant.DEFAULT_PAGE_SIZE;
}
return pageSize;
| 216
| 42
| 258
|
<methods>public non-sealed void <init>() <variables>private java.lang.Boolean orderByAsc,private java.lang.String orderByColumn,private static final long serialVersionUID
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/page/OrderByItem.java
|
OrderByItem
|
desc
|
class OrderByItem {
private static final String DESC = "desc";
@Schema(description = "排序列名称")
private String column;
@Schema(description = "排序方式 true：升序，false：降序")
private boolean asc = true;
public static String orderBy(String column, Boolean asc) {
if (asc == null) {
asc = true;
}
if (asc) {
return asc(column);
} else {
return desc(column);
}
}
public static String asc(String column) {
if (StringUtils.isBlank(column)) {
return null;
}
return column;
}
public static String desc(String column) {<FILL_FUNCTION_BODY>}
public static String orderBy(String orderBy) {
if (StringUtils.isBlank(orderBy)) {
return null;
}
return orderBy;
}
}
|
if (StringUtils.isBlank(column)) {
return null;
}
return column + " " + DESC;
| 253
| 36
| 289
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/redis/CustomStringRedisSerializer.java
|
CustomStringRedisSerializer
|
serialize
|
class CustomStringRedisSerializer extends StringRedisSerializer {
private String redisKeyPrefix;
public CustomStringRedisSerializer(String redisKeyPrefix) {
this.redisKeyPrefix = redisKeyPrefix;
log.info("redisKeyPrefix:" + redisKeyPrefix);
}
@Override
public byte[] serialize(String string) {<FILL_FUNCTION_BODY>}
@Override
public String deserialize(byte[] bytes) {
String string = super.deserialize(bytes);
if (StringUtils.isNotBlank(redisKeyPrefix) && string != null && !string.startsWith(redisKeyPrefix)) {
string = redisKeyPrefix + "." + string;
}
return string;
}
}
|
if (StringUtils.isNotBlank(redisKeyPrefix) && string != null && !string.startsWith(redisKeyPrefix)) {
string = redisKeyPrefix + "." + string;
}
return super.serialize(string);
| 197
| 66
| 263
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/response/ApiResult.java
|
ApiResult
|
result
|
class ApiResult<T> implements Serializable {
private static final long serialVersionUID = 7594052194764993562L;
@Schema(description = "响应编码 200：成功，500：失败")
private int code;
@Schema(description = "响应结果 true：成功，false：失败")
private boolean success;
@Schema(description = "响应消息")
private String msg;
@Schema(description = "响应结果数据")
private T data;
@Schema(description = "响应时间")
@JSONField(format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date time;
@Schema(description = "日志链路ID")
private String traceId;
public static ApiResult success() {
return success(null);
}
public static ApiResult success(Object data) {
return result(ApiCode.SUCCESS, data);
}
public static ApiResult fail() {
return fail(ApiCode.FAIL);
}
public static ApiResult fail(String message) {
return fail(ApiCode.FAIL, message);
}
public static ApiResult fail(ApiCode apiCode) {
return fail(apiCode, null);
}
public static ApiResult fail(ApiCode apiCode, String message) {
if (ApiCode.SUCCESS == apiCode) {
throw new RuntimeException("失败结果状态码不能为" + ApiCode.SUCCESS.getCode());
}
return result(apiCode, message, null);
}
public static ApiResult result(boolean flag) {
if (flag) {
return success();
}
return fail();
}
public static ApiResult result(ApiCode apiCode) {
return result(apiCode, null);
}
public static ApiResult result(ApiCode apiCode, Object data) {
return result(apiCode, null, data);
}
public static ApiResult result(ApiCode apiCode, String message, Object data) {<FILL_FUNCTION_BODY>}
}
|
if (apiCode == null) {
throw new RuntimeException("结果状态码不能为空");
}
boolean success = false;
int code = apiCode.getCode();
if (ApiCode.SUCCESS.getCode() == code) {
success = true;
}
String outMessage;
if (StringUtils.isBlank(message)) {
outMessage = apiCode.getMsg();
} else {
outMessage = message;
}
String traceId = MDC.get(CommonConstant.TRACE_ID);
return ApiResult.builder()
.code(code)
.msg(outMessage)
.data(data)
.success(success)
.time(new Date())
.traceId(traceId)
.build();
| 581
| 200
| 781
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/runner/YitIdRunner.java
|
YitIdRunner
|
run
|
class YitIdRunner implements ApplicationRunner {
@Value("${workerId:0}")
private short workerId;
@Override
public void run(ApplicationArguments args) throws Exception {<FILL_FUNCTION_BODY>}
}
|
IdGeneratorOptions options = new IdGeneratorOptions(workerId);
YitIdHelper.setIdGenerator(options);
log.info("YitId配置初始化完成，workerId：" + workerId);
| 64
| 55
| 119
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/xss/XssFilter.java
|
XssFilter
|
doFilter
|
class XssFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
log.info("XssFilter init");
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {<FILL_FUNCTION_BODY>}
@Override
public void destroy() {
log.info("XssFilter destroy");
}
}
|
HttpServletRequest request = (HttpServletRequest) servletRequest;
XssHttpServletRequestWrapper xssHttpServletRequestWrapper = new XssHttpServletRequestWrapper(request);
filterChain.doFilter(xssHttpServletRequestWrapper, servletResponse);
| 119
| 63
| 182
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/framework/xss/XssHttpServletRequestWrapper.java
|
XssHttpServletRequestWrapper
|
getParameterValues
|
class XssHttpServletRequestWrapper extends HttpServletRequestWrapper {
public XssHttpServletRequestWrapper(HttpServletRequest request) {
super(request);
}
@Override
public String getQueryString() {
return StringEscapeUtils.escapeHtml4(super.getQueryString());
}
@Override
public String getParameter(String name) {
return StringEscapeUtils.escapeHtml4(super.getParameter(name));
}
@Override
public String[] getParameterValues(String name) {<FILL_FUNCTION_BODY>}
}
|
String[] values = super.getParameterValues(name);
if (ArrayUtils.isEmpty(values)) {
return values;
}
int length = values.length;
String[] escapeValues = new String[length];
for (int i = 0; i < length; i++) {
escapeValues[i] = StringEscapeUtils.escapeHtml4(values[i]);
}
return escapeValues;
| 146
| 105
| 251
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/generator/controller/GeneratorController.java
|
GeneratorController
|
downloadCode
|
class GeneratorController {
@Autowired
private GeneratorService generatorService;
@Autowired
private GeneratorTableService generatorTableService;
/**
* 获取数据库表
*
* @param query
* @return
* @throws Exception
*/
@PostMapping("/getDbTablePage")
@Operation(summary = "获取数据库表")
@Permission("generator:db-table:page")
public ApiResult<GeneratorTableDbVo> getDbTablePage(@Valid @RequestBody GeneratorTableQuery query) {
Paging<GeneratorTableDbVo> paging = generatorTableService.getDbTablePage(query);
return ApiResult.success(paging);
}
/**
* 获取生成代码表详情
*
* @param tableName
* @return
* @throws Exception
*/
@PostMapping("/getGeneratorTable/{tableName}")
@Operation(summary = "生成代码表详情")
@Permission("generator:table:info")
public ApiResult<GeneratorTable> getGeneratorTable(@PathVariable String tableName) {
GeneratorTable generatorTable = generatorTableService.getGeneratorTableInfo(tableName);
return ApiResult.success(generatorTable);
}
/**
* 修改生成代码表
*
* @param dto
* @return
* @throws Exception
*/
@Log(value = "修改生成代码表", type = SysLogType.UPDATE)
@PostMapping("/updateGeneratorTable")
@Operation(summary = "修改生成代码表")
@Permission("generator:table:update")
public ApiResult updateGeneratorTable(@Valid @RequestBody GeneratorTableDto dto) {
boolean flag = generatorTableService.updateGeneratorTable(dto);
return ApiResult.result(flag);
}
/**
* 预览代码
*
* @param tableName
* @return
* @throws Exception
*/
@PostMapping("/previewCode/{tableName}")
@Operation(summary = "预览代码")
@Permission("generator:preview-code")
public ApiResult<GeneratorCodeVo> previewCode(@PathVariable String tableName) {
List<GeneratorCodeVo> list = generatorService.previewCode(tableName);
return ApiResult.success(list);
}
/**
* 生成代码
*
* @param dto
* @return
* @throws Exception
*/
@PostMapping("/generatorCode")
@Operation(summary = "生成代码")
@Permission("generator:generator-code")
public ApiResult<GeneratorCodeVo> generatorCode(@Valid @RequestBody GeneratorCodeDto dto) throws Exception {
log.info("生成代码开始：" + dto);
List<String> tableNames = dto.getTableNames();
generatorService.generatorCode(tableNames);
log.info("生成代码结束：" + dto);
return ApiResult.success();
}
/**
* 下载代码
*
* @param dto
* @return
* @throws Exception
*/
@PostMapping("/downloadCode")
@Operation(summary = "下载代码")
@Permission("generator:download-code")
public void downloadCode(@Valid @RequestBody GeneratorCodeDto dto, HttpServletResponse response) throws Exception {<FILL_FUNCTION_BODY>}
}
|
log.info("下载代码开始：" + dto);
List<String> tableNames = dto.getTableNames();
Map<String, List<GeneratorCodeVo>> map = generatorService.downloadCode(tableNames);
if (MapUtils.isNotEmpty(map)) {
// zip下载
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
ZipOutputStream zipOutputStream = new ZipOutputStream(outputStream);
for (Map.Entry<String, List<GeneratorCodeVo>> entry : map.entrySet()) {
List<GeneratorCodeVo> codeVos = entry.getValue();
if (CollectionUtils.isNotEmpty(codeVos)) {
for (GeneratorCodeVo codeVo : codeVos) {
String fileName = codeVo.getFileName();
String zipFilePath = codeVo.getZipFilePath();
String fileContent = codeVo.getFileContent();
log.info("generatorFileName：" + fileName);
log.info("generatorZipFilePath：" + zipFilePath);
// 添加到zip
zipOutputStream.putNextEntry(new ZipEntry(zipFilePath));
IOUtils.write(fileContent, zipOutputStream, CharsetUtil.CHARSET_UTF_8);
zipOutputStream.flush();
zipOutputStream.closeEntry();
}
}
}
IOUtils.closeQuietly(zipOutputStream);
byte[] bytes = outputStream.toByteArray();
String zipFileName;
if (tableNames.size() > 1) {
zipFileName = "spring-boot-plus-code.zip";
} else {
zipFileName = tableNames.get(0) + "-code.zip";
}
log.info("downloadZipFileName = " + zipFileName);
response.reset();
response.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=" + zipFileName);
response.addHeader(HttpHeaders.CONTENT_LENGTH, String.valueOf(bytes.length));
response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE + "; charset=UTF-8");
IOUtils.write(bytes, response.getOutputStream());
log.info("downloadZipFile完成");
}
log.info("下载代码结束：" + dto);
| 889
| 577
| 1,466
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/generator/service/impl/GeneratorColumnServiceImpl.java
|
GeneratorColumnServiceImpl
|
addGeneratorColumn
|
class GeneratorColumnServiceImpl extends ServiceImpl<GeneratorColumnMapper, GeneratorColumn> implements GeneratorColumnService {
@Autowired
private GeneratorColumnMapper generatorColumnMapper;
@Transactional(rollbackFor = Exception.class)
@Override
public boolean addGeneratorColumn(String tableName, Boolean validateField) {<FILL_FUNCTION_BODY>}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean updateGeneratorColumn(GeneratorColumnDto dto) {
Long id = dto.getId();
GeneratorColumn generatorColumn = getById(id);
if (generatorColumn == null) {
throw new BusinessException("生成代码列不存在");
}
BeanUtils.copyProperties(dto, generatorColumn);
return updateById(generatorColumn);
}
@Override
public List<GeneratorColumnDbVo> getDbColumnListByTableName(String tableName) {
return generatorColumnMapper.getDbColumnListByTableName(tableName);
}
@Override
public List<GeneratorColumn> getGeneratorColumnList(String tableName) {
return generatorColumnMapper.getGeneratorColumnList(tableName);
}
}
|
List<GeneratorColumnDbVo> columnDbVos = getDbColumnListByTableName(tableName);
if (CollectionUtils.isEmpty(columnDbVos)) {
throw new BusinessException("没有列信息");
}
List<GeneratorColumn> columns = GeneratorUtil.getGeneratorColumns(tableName, columnDbVos, validateField);
return saveBatch(columns);
| 298
| 94
| 392
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/generator/service/impl/GeneratorServiceImpl.java
|
GeneratorServiceImpl
|
downloadCode
|
class GeneratorServiceImpl implements GeneratorService {
@Autowired
private GeneratorTableService generatorTableService;
@Override
public List<GeneratorCodeVo> previewCode(String tableName) {
GeneratorTable generatorTable = generatorTableService.getGeneratorTableInfo(tableName);
return GeneratorUtil.generatorCodeData(tableName, generatorTable);
}
@Override
public void generatorCode(List<String> tableNames) throws Exception {
for (String tableName : tableNames) {
GeneratorTable generatorTable = generatorTableService.getGeneratorTableInfo(tableName);
GeneratorUtil.generatorCode(tableName, generatorTable);
}
}
@Override
public Map<String, List<GeneratorCodeVo>> downloadCode(List<String> tableNames) {<FILL_FUNCTION_BODY>}
}
|
Map<String, List<GeneratorCodeVo>> map = new LinkedHashMap<>();
for (String tableName : tableNames) {
GeneratorTable generatorTable = generatorTableService.getGeneratorTableInfo(tableName);
List<GeneratorCodeVo> generatorCodeVos = GeneratorUtil.generatorCodeData(tableName, generatorTable);
map.put(tableName, generatorCodeVos);
}
return map;
| 212
| 106
| 318
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/generator/service/impl/GeneratorTableServiceImpl.java
|
GeneratorTableServiceImpl
|
getGeneratorTableInfo
|
class GeneratorTableServiceImpl extends ServiceImpl<GeneratorTableMapper, GeneratorTable> implements GeneratorTableService {
@Autowired
private GeneratorTableMapper generatorTableMapper;
@Autowired
private GeneratorColumnService generatorColumnService;
@Autowired
private GeneratorProperties generatorProperties;
@Transactional(rollbackFor = Exception.class)
@Override
public boolean addGeneratorTable(String tableName) {
GeneratorTableDbVo generatorTableDbVo = generatorTableMapper.getDbTableByTableName(tableName);
if (generatorTableDbVo == null) {
throw new BusinessException("表不存在或不允许操作");
}
GeneratorTable generatorTable = new GeneratorTable();
// 设置表基础信息
GeneratorUtil.setGeneratorTable(generatorProperties, tableName, generatorTableDbVo, generatorTable);
return save(generatorTable);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean updateGeneratorTable(GeneratorTableDto dto) {
Long id = dto.getId();
GeneratorTable generatorTable = getById(id);
if (generatorTable == null) {
throw new BusinessException("生成代码表不存在");
}
BeanUtils.copyProperties(dto, generatorTable);
boolean flag = updateById(generatorTable);
// 修改列
List<GeneratorColumnDto> columns = dto.getColumns();
if (CollectionUtils.isNotEmpty(columns)) {
for (GeneratorColumnDto column : columns) {
generatorColumnService.updateGeneratorColumn(column);
}
}
return flag;
}
@Transactional(rollbackFor = Exception.class)
@Override
public GeneratorTable getGeneratorTableInfo(String tableName) {<FILL_FUNCTION_BODY>}
@Override
public Paging<GeneratorTableDbVo> getDbTablePage(GeneratorTableQuery query) {
PagingUtil.handlePage(query);
List<GeneratorTableDbVo> list = generatorTableMapper.getDbTablePage(query);
if (CollectionUtils.isNotEmpty(list)) {
List<String> tablePrefixes = generatorProperties.getTablePrefixes();
for (GeneratorTableDbVo vo : list) {
String tableName = vo.getTableName();
String className = vo.getClassName();
if (StringUtils.isBlank(className)) {
// 生成类名称
String tableClassName = GeneratorUtil.getTableClassName(tableName, tablePrefixes);
vo.setClassName(tableClassName);
}
}
}
Paging<GeneratorTableDbVo> paging = new Paging<>(list);
return paging;
}
}
|
GeneratorTable table = generatorTableMapper.getGeneratorTableByTableName(tableName);
List<GeneratorColumn> columns;
if (table == null) {
// 添加生成的表
boolean addTableResult = addGeneratorTable(tableName);
if (!addTableResult) {
throw new BusinessException("添加生成表数据异常");
}
table = generatorTableMapper.getGeneratorTableByTableName(tableName);
Boolean validateField = table.getValidateField();
// 添加生成的列
generatorColumnService.addGeneratorColumn(tableName, validateField);
}
// 读取数据库表的列信息
columns = generatorColumnService.getGeneratorColumnList(tableName);
// 设置表的列信息
GeneratorUtil.setTableColumnInfo(table, columns);
return table;
| 692
| 205
| 897
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/generator/util/VelocityUtil.java
|
VelocityUtil
|
writer
|
class VelocityUtil {
private static Properties properties;
static {
properties = new Properties();
properties.setProperty("resource.loader.file.class", ClasspathResourceLoader.class.getName());
properties.setProperty("resource.loader.file.unicode", "true");
properties.setProperty(Velocity.FILE_RESOURCE_LOADER_PATH, "");
properties.setProperty(Velocity.ENCODING_DEFAULT, GeneratorConstant.UTF8);
properties.setProperty(Velocity.INPUT_ENCODING, GeneratorConstant.UTF8);
}
/**
* 渲染模板数据输出到StringWrite中
*
* @param templatePath
* @param dataMap
* @return
* @throws Exception
*/
public static String writer(String templatePath, Map<String, Object> dataMap) {<FILL_FUNCTION_BODY>}
}
|
VelocityEngine velocityEngine = new VelocityEngine(properties);
StringWriter writer = new StringWriter();
Template template = velocityEngine.getTemplate(templatePath, ConstVal.UTF8);
template.merge(new VelocityContext(dataMap), writer);
String content = writer.toString();
IOUtils.closeQuietly(writer);
return content;
| 235
| 90
| 325
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/system/controller/ServerInfoController.java
|
ServerInfoController
|
getServerInfo
|
class ServerInfoController {
@Autowired
private Environment environment;
/**
* 获取服务信息详情
*
* @return
* @throws Exception
*/
@PostMapping("/getServerInfo")
@Operation(summary = "服务信息详情")
@Permission("server:info")
public ApiResult<ServerInfo> getServerInfo() {<FILL_FUNCTION_BODY>}
}
|
ServerInfo serverInfo = ServerInfoUtil.getServerInfo();
// 获取项目信息
// 项目名称
String name = environment.getProperty("spring.application.name");
// 端口号
String port = environment.getProperty("server.port");
// 上下文路径
String contextPath = environment.getProperty("server.servlet.context-path");
// 激活的环境
String active = environment.getProperty("spring.profiles.active");
// 当前项目路径
String userDir = SystemUtil.get("user.dir");
ProjectInfo projectInfo = new ProjectInfo();
projectInfo.setName(name);
projectInfo.setPort(port);
projectInfo.setContextPath(contextPath);
projectInfo.setActive(active);
projectInfo.setUserDir(userDir);
serverInfo.setProjectInfo(projectInfo);
log.info("serverInfo:" + serverInfo);
return ApiResult.success(serverInfo);
| 112
| 247
| 359
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/system/controller/SysUserController.java
|
SysUserController
|
getProfile
|
class SysUserController {
@Autowired
private SysUserService sysUserService;
/**
* 添加系统用户
*
* @param dto
* @return
* @throws Exception
*/
@PostMapping("/addSysUser")
@Operation(summary = "添加系统用户")
@Permission("sys:user:add")
public ApiResult addSysUser(@Valid @RequestBody SysUserDto dto) {
boolean flag = sysUserService.addSysUser(dto);
return ApiResult.result(flag);
}
/**
* 修改系统用户
*
* @param dto
* @return
* @throws Exception
*/
@PostMapping("/updateSysUser")
@Operation(summary = "修改系统用户")
@Permission("sys:user:update")
public ApiResult updateSysUser(@Valid @RequestBody SysUserDto dto) {
boolean flag = sysUserService.updateSysUser(dto);
return ApiResult.result(flag);
}
/**
* 删除系统用户
*
* @param id
* @return
* @throws Exception
*/
@PostMapping("/deleteSysUser/{id}")
@Operation(summary = "删除系统用户")
@Permission("sys:user:delete")
public ApiResult deleteSysUser(@PathVariable Long id) {
boolean flag = sysUserService.deleteSysUser(id);
return ApiResult.result(flag);
}
/**
* 获取系统用户详情
*
* @param id
* @return
* @throws Exception
*/
@PostMapping("/getSysUser/{id}")
@Operation(summary = "系统用户详情")
@Permission("sys:user:info")
public ApiResult<SysUserVo> getSysUser(@PathVariable Long id) {
SysUserVo sysUserVo = sysUserService.getSysUserById(id);
return ApiResult.success(sysUserVo);
}
/**
* 系统用户分页列表
*
* @param query
* @return
* @throws Exception
*/
@PostMapping("/getSysUserPage")
@Operation(summary = "系统用户分页列表")
@Permission("sys:user:page")
public ApiResult<SysUserVo> getSysUserPage(@Valid @RequestBody SysUserQuery query) {
Paging<SysUserVo> paging = sysUserService.getSysUserPage(query);
return ApiResult.success(paging);
}
/**
* 重置系统用户密码
*
* @param sysUserResetPasswordDto
* @return
* @throws Exception
*/
@PostMapping("/resetSysUserPassword")
@Operation(summary = "重置系统用户密码")
@Permission("sys:user:reset-password")
public ApiResult resetSysUserPassword(@Valid @RequestBody SysUserResetPasswordDto sysUserResetPasswordDto) {
boolean flag = sysUserService.resetSysUserPassword(sysUserResetPasswordDto);
return ApiResult.result(flag);
}
/**
* 获取个人信息
*
* @return
* @throws Exception
*/
@PostMapping("/getProfile")
@Operation(summary = "获取个人信息")
public ApiResult<SysUserVo> getProfile() {<FILL_FUNCTION_BODY>}
/**
* 修改个人信息
*
* @param sysUserUpdateProfileDto
* @return
* @throws Exception
*/
@PostMapping("/updateProfile")
@Operation(summary = "修改个人信息")
public ApiResult updateProfile(@Valid @RequestBody SysUserUpdateProfileDto sysUserUpdateProfileDto) {
boolean flag = sysUserService.updateProfile(sysUserUpdateProfileDto);
return ApiResult.result(flag);
}
/**
* 修改用户密码
*
* @param sysUserUpdatePasswordDto
* @return
* @throws Exception
*/
@PostMapping("/updatePassword")
@Operation(summary = "修改用户密码")
public ApiResult updatePassword(@Valid @RequestBody SysUserUpdatePasswordDto sysUserUpdatePasswordDto) {
boolean flag = sysUserService.updatePassword(sysUserUpdatePasswordDto);
return ApiResult.result(flag);
}
/**
* 导入Excel用户数据
*
* @param multipartFile
* @return
* @throws Exception
*/
@PostMapping("/importExcel")
@Operation(summary = "导入Excel用户数据")
public ApiResult importExcel(MultipartFile multipartFile) throws Exception {
boolean flag = sysUserService.importExcel(multipartFile);
return ApiResult.result(flag);
}
}
|
Long userId = LoginUtil.getUserId();
if (userId == null) {
throw new BusinessException("用户ID为空");
}
SysUserVo sysUserVo = sysUserService.getSysUserById(userId);
return ApiResult.success(sysUserVo);
| 1,273
| 80
| 1,353
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/system/service/impl/SysConfigServiceImpl.java
|
SysConfigServiceImpl
|
updateSysConfig
|
class SysConfigServiceImpl extends ServiceImpl<SysConfigMapper, SysConfig> implements SysConfigService {
@Autowired
private SysConfigMapper sysConfigMapper;
@Transactional(rollbackFor = Exception.class)
@Override
public boolean addSysConfig(SysConfigDto dto) {
checkConfigKeyExists(dto.getConfigKey());
SysConfig sysConfig = new SysConfig();
BeanUtils.copyProperties(dto, sysConfig);
return save(sysConfig);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean updateSysConfig(SysConfigDto dto) {<FILL_FUNCTION_BODY>}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean deleteSysConfig(Long id) {
return removeById(id);
}
@Override
public SysConfigVo getSysConfigById(Long id) {
return sysConfigMapper.getSysConfigById(id);
}
@Override
public Paging<SysConfigVo> getSysConfigPage(SysConfigQuery query) {
OrderMapping orderMapping = new OrderMapping();
orderMapping.put("createTime", "create_time");
PagingUtil.handlePage(query, orderMapping, OrderByItem.desc("id"));
List<SysConfigVo> list = sysConfigMapper.getSysConfigPage(query);
Paging<SysConfigVo> paging = new Paging<>(list);
return paging;
}
@Override
public void checkConfigKeyExists(String configKey) {
LambdaQueryWrapper<SysConfig> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(SysConfig::getConfigKey, configKey);
long count = count(wrapper);
if (count > 0) {
throw new BusinessException(configKey + "配置key已经存在");
}
}
}
|
Long id = dto.getId();
SysConfig sysConfig = getById(id);
if (sysConfig == null) {
throw new BusinessException("系统配置不存在");
}
BeanUtils.copyProperties(dto, sysConfig);
return updateById(sysConfig);
| 498
| 75
| 573
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/system/service/impl/SysDictServiceImpl.java
|
SysDictServiceImpl
|
updateSysDict
|
class SysDictServiceImpl extends ServiceImpl<SysDictMapper, SysDict> implements SysDictService {
@Autowired
private SysDictMapper sysDictMapper;
@Transactional(rollbackFor = Exception.class)
@Override
public boolean addSysDict(SysDictDto dto) {
SysDict sysDict = new SysDict();
BeanUtils.copyProperties(dto, sysDict);
return save(sysDict);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean updateSysDict(SysDictDto dto) {<FILL_FUNCTION_BODY>}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean deleteSysDict(Long id) {
return removeById(id);
}
@Override
public SysDictVo getSysDictById(Long id) {
return sysDictMapper.getSysDictById(id);
}
@Override
public Paging<SysDictVo> getSysDictPage(SysDictQuery query) {
PagingUtil.handlePage(query, OrderByItem.orderBy("status desc,sort,id"));
List<SysDictVo> list = sysDictMapper.getSysDictPage(query);
Paging<SysDictVo> paging = new Paging<>(list);
return paging;
}
@Override
public Map<String, List<AppSysDictVo>> getAppSysDictList(SysDictAppQuery query) {
List<AppSysDictVo> list = sysDictMapper.getAppSysDictList(query);
if (CollectionUtils.isNotEmpty(list)) {
Map<String, List<AppSysDictVo>> map = list.stream().collect(Collectors.groupingBy(AppSysDictVo::getDictCode));
return map;
}
return null;
}
@Override
public List<SysDict> getSysDictList(String dictCode) {
LambdaQueryWrapper<SysDict> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(SysDict::getDictCode, dictCode);
wrapper.eq(SysDict::getStatus, true);
wrapper.orderByAsc(SysDict::getSort);
return list(wrapper);
}
@Override
public SysDict getSysDictByValue(String dictCode, Serializable value) {
LambdaQueryWrapper<SysDict> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(SysDict::getDictCode, dictCode);
wrapper.eq(SysDict::getValue, value);
wrapper.eq(SysDict::getStatus, true);
return getOne(wrapper);
}
@Override
public String getSysDictLabelByValue(String dictCode, Serializable value) {
SysDict sysDict = getSysDictByValue(dictCode, value);
if (sysDict != null) {
return sysDict.getLabel();
}
return null;
}
}
|
Long id = dto.getId();
SysDict sysDict = getById(id);
if (sysDict == null) {
throw new BusinessException("字典数据不存在");
}
BeanUtils.copyProperties(dto, sysDict);
return updateById(sysDict);
| 838
| 81
| 919
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/system/service/impl/SysDictTypeServiceImpl.java
|
SysDictTypeServiceImpl
|
deleteSysDictType
|
class SysDictTypeServiceImpl extends ServiceImpl<SysDictTypeMapper, SysDictType> implements SysDictTypeService {
@Autowired
private SysDictTypeMapper sysDictTypeMapper;
@Transactional(rollbackFor = Exception.class)
@Override
public boolean addSysDictType(SysDictTypeDto dto) {
checkCodeExists(dto.getCode());
SysDictType sysDictType = new SysDictType();
BeanUtils.copyProperties(dto, sysDictType);
return save(sysDictType);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean updateSysDictType(SysDictTypeDto dto) {
Long id = dto.getId();
SysDictType sysDictType = getById(id);
if (sysDictType == null) {
throw new BusinessException("字典类型不存在");
}
sysDictType.setIsSystem(dto.getIsSystem());
sysDictType.setName(dto.getName());
sysDictType.setRemark(dto.getRemark());
return updateById(sysDictType);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean deleteSysDictType(Long id) {<FILL_FUNCTION_BODY>}
@Override
public SysDictTypeVo getSysDictTypeById(Long id) {
return sysDictTypeMapper.getSysDictTypeById(id);
}
@Override
public List<SysDictTypeVo> getSysDictTypeList(SysDictTypeQuery query) {
List<SysDictTypeVo> list = sysDictTypeMapper.getSysDictTypeList(query);
return list;
}
@Override
public void checkCodeExists(String code) {
LambdaQueryWrapper<SysDictType> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(SysDictType::getCode, code);
long count = count(wrapper);
if (count > 0) {
throw new BusinessException(code + "类型编码已经存在");
}
}
}
|
SysDictType sysDictType = getById(id);
if (sysDictType == null) {
throw new BusinessException("系统字典类型不存在");
}
Boolean isSystem = sysDictType.getIsSystem();
if (isSystem) {
throw new BusinessException("系统类型不能删除");
}
return removeById(id);
| 586
| 96
| 682
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/system/service/impl/SysFileServiceImpl.java
|
SysFileServiceImpl
|
updateSysFile
|
class SysFileServiceImpl extends ServiceImpl<SysFileMapper, SysFile> implements SysFileService {
@Autowired
private SysFileMapper sysFileMapper;
@Transactional(rollbackFor = Exception.class)
@Override
public boolean updateSysFile(SysFileDto dto) {<FILL_FUNCTION_BODY>}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean deleteSysFile(Long id) {
return removeById(id);
}
@Override
public SysFileVo getSysFileById(Long id) {
return sysFileMapper.getSysFileById(id);
}
@Override
public Paging<SysFileVo> getSysFilePage(SysFileQuery query) {
OrderMapping orderMapping = new OrderMapping();
orderMapping.put("createTime", "create_time");
PagingUtil.handlePage(query, orderMapping, OrderByItem.desc("id"));
List<SysFileVo> list = sysFileMapper.getSysFilePage(query);
Paging<SysFileVo> paging = new Paging<>(list);
return paging;
}
}
|
Long id = dto.getId();
SysFile sysFile = getById(id);
if (sysFile == null) {
throw new BusinessException("系统文件不存在");
}
BeanUtils.copyProperties(dto, sysFile);
return updateById(sysFile);
| 312
| 75
| 387
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/system/service/impl/SysLogServiceImpl.java
|
SysLogServiceImpl
|
getSysLogPage
|
class SysLogServiceImpl extends ServiceImpl<SysLogMapper, SysLog> implements SysLogService {
@Autowired
private SysLogMapper sysLogMapper;
@Override
public SysLogVo getSysLogById(Long id) {
return sysLogMapper.getSysLogById(id);
}
@Override
public Paging<SysLogVo> getSysLogPage(SysLogQuery query) {<FILL_FUNCTION_BODY>}
}
|
OrderMapping orderMapping = new OrderMapping();
orderMapping.put("createTime", "create_time");
PagingUtil.handlePage(query, orderMapping, OrderByItem.desc("id"));
List<SysLogVo> list = sysLogMapper.getSysLogPage(query);
Paging<SysLogVo> paging = new Paging<>(list);
return paging;
| 130
| 102
| 232
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/system/service/impl/SysMenuServiceImpl.java
|
SysMenuServiceImpl
|
recursionSysNavMenuTreeList
|
class SysMenuServiceImpl extends ServiceImpl<SysMenuMapper, SysMenu> implements SysMenuService {
@Autowired
private SysMenuMapper sysMenuMapper;
@Autowired
private SysRoleMenuService sysRoleMenuService;
@Transactional(rollbackFor = Exception.class)
@Override
public boolean addSysMenu(SysMenuDto dto) {
SysMenu sysMenu = new SysMenu();
BeanUtils.copyProperties(dto, sysMenu);
Long parentId = dto.getParentId();
if (parentId == null) {
sysMenu.setParentId(SystemConstant.ROOT_MENU_ID);
}
return save(sysMenu);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean updateSysMenu(SysMenuDto dto) {
Long id = dto.getId();
SysMenu sysMenu = getById(id);
if (sysMenu == null) {
throw new BusinessException("系统菜单不存在");
}
BeanUtils.copyProperties(dto, sysMenu);
return updateById(sysMenu);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean deleteSysMenu(Long id) {
// 获取菜单
SysMenu sysMenu = getById(id);
if (sysMenu == null) {
throw new BusinessException("菜单数据不存在");
}
// 所有关联菜单ID集合
List<Long> deleteMenuIds = new ArrayList<>();
deleteMenuIds.add(id);
Integer type = sysMenu.getType();
SysMenuType sysMenuType = SysMenuType.get(type);
if (SysMenuType.DIR == sysMenuType) {
// 如果是目录，则先查询所有的子菜单ID，再根据子菜单ID查询所有的权限菜单ID
List<Long> menuIds = sysMenuMapper.getChildrenMenuIds(Arrays.asList(id));
deleteMenuIds.addAll(menuIds);
if (CollectionUtils.isNotEmpty(menuIds)) {
List<Long> permissionMenuIds = sysMenuMapper.getChildrenMenuIds(menuIds);
deleteMenuIds.addAll(permissionMenuIds);
}
} else if (SysMenuType.MENU == sysMenuType) {
// 如果是菜单，则查询所有的权限子菜单
List<Long> menuIds = sysMenuMapper.getChildrenMenuIds(Arrays.asList(id));
if (CollectionUtils.isNotEmpty(menuIds)) {
deleteMenuIds.addAll(menuIds);
}
}
// 删除角色菜单关系表中的相关菜单关联
sysRoleMenuService.deleteSysRoleMenuByMenuIds(deleteMenuIds);
// 删除所有关联菜单
return removeByIds(deleteMenuIds);
}
@Override
public SysMenuVo getSysMenuById(Long id) {
return sysMenuMapper.getSysMenuById(id);
}
@Override
public List<SysMenuTreeVo> getAllSysMenuTreeList(SysMenuQuery query) {
List<SysMenuTreeVo> list = sysMenuMapper.getSysMenuTreeList(query);
if (CollectionUtils.isEmpty(list)) {
return null;
}
// 如果搜索条件有值，则直接返回普通列表
boolean flag = ObjectValueUtil.isHaveValue(query);
if (flag) {
return list;
}
// 递归返回树形列表
return recursionSysMenuTreeList(0L, list);
}
@Override
public List<SysMenuTreeVo> getSysMenuTreeList() {
SysMenuQuery query = new SysMenuQuery();
query.setStatus(true);
List<SysMenuTreeVo> list = sysMenuMapper.getSysMenuTreeList(query);
if (CollectionUtils.isEmpty(list)) {
return null;
}
// 递归返回树形列表
return recursionSysMenuTreeList(0L, list);
}
@Override
public List<SysNavMenuTreeVo> getNavMenuTreeList() {
Long userId = LoginUtil.getUserId();
// 如果是管理员，则查询所有可用菜单，否则获取当前用户所有可用的菜单
boolean isAdmin = LoginUtil.isAdmin();
List<SysNavMenuTreeVo> list;
if (isAdmin) {
list = sysMenuMapper.getNavMenuTreeAllList();
} else {
list = sysMenuMapper.getNavMenuTreeList(userId);
}
// 递归返回树形列表
return recursionSysNavMenuTreeList(0L, list);
}
@Override
public List<Long> getMenuIdsByRoleId(Long roleId) {
return sysMenuMapper.getMenuIdsByRoleId(roleId);
}
/**
* 递归设置树形菜单
*
* @param parentId
* @param list
* @return
*/
private List<SysMenuTreeVo> recursionSysMenuTreeList(Long parentId, List<SysMenuTreeVo> list) {
return list.stream()
.filter(vo -> vo.getParentId().equals(parentId))
.map(item -> {
item.setChildren(recursionSysMenuTreeList(item.getId(), list));
return item;
})
.collect(Collectors.toList());
}
/**
* 递归设置树形导航菜单
*
* @param parentId
* @param list
* @return
*/
private List<SysNavMenuTreeVo> recursionSysNavMenuTreeList(Long parentId, List<SysNavMenuTreeVo> list) {<FILL_FUNCTION_BODY>}
}
|
return list.stream()
.filter(vo -> vo.getParentId().equals(parentId))
.map(item -> {
item.setChildren(recursionSysNavMenuTreeList(item.getId(), list));
return item;
})
.collect(Collectors.toList());
| 1,526
| 80
| 1,606
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/system/service/impl/SysRoleServiceImpl.java
|
SysRoleServiceImpl
|
checkCodeExists
|
class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> implements SysRoleService {
@Autowired
private SysRoleMapper sysRoleMapper;
@Autowired
private SysRoleMenuService sysRoleMenuService;
@Autowired
private SysMenuService sysMenuService;
@Autowired
private SysUserMapper sysUserMapper;
@Transactional(rollbackFor = Exception.class)
@Override
public boolean addSysRole(SysRoleDto dto) {
checkCodeExists(dto.getCode());
SysRole sysRole = new SysRole();
BeanUtils.copyProperties(dto, sysRole);
return save(sysRole);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean updateSysRole(SysRoleDto dto) {
Long id = dto.getId();
SysRole sysRole = getById(id);
if (sysRole == null) {
throw new BusinessException("系统角色不存在");
}
sysRole.setName(dto.getName());
sysRole.setIsSystem(dto.getIsSystem());
sysRole.setRemark(dto.getRemark());
return updateById(sysRole);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean deleteSysRole(Long id) {
// 判断角色下是否存在用户，如果存在，则不能删除
Integer count = sysUserMapper.getCountByRoleId(id);
if (count > 0) {
throw new BusinessException("该角色下还存在用户，不可删除");
}
return removeById(id);
}
@Override
public SysRoleVo getSysRoleById(Long id) {
return sysRoleMapper.getSysRoleById(id);
}
@Override
public Paging<SysRoleVo> getSysRolePage(SysRoleQuery query) {
OrderMapping orderMapping = new OrderMapping();
orderMapping.put("createTime", "create_time");
PagingUtil.handlePage(query, orderMapping, OrderByItem.desc("id"));
List<SysRoleVo> list = sysRoleMapper.getSysRolePage(query);
Paging<SysRoleVo> paging = new Paging<>(list);
return paging;
}
@Override
public List<SysRole> getSysRoleAllList() {
LambdaQueryWrapper<SysRole> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.orderByAsc(SysRole::getId);
return list(lambdaQueryWrapper);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean setRoleMenus(RoleMenusDto roleMenusDto) {
Long roleId = roleMenusDto.getRoleId();
List<Long> menuIds = roleMenusDto.getMenuIds();
SysRole sysRole = getById(roleId);
if (sysRole == null) {
throw new BusinessException("角色不存在");
}
// 先删除角色权限关系
sysRoleMenuService.deleteSysRoleMenuByRoleId(roleId);
List<SysRoleMenu> sysRoleMenus = new ArrayList<>();
// 保存角色权限关系
for (Long menuId : menuIds) {
SysRoleMenu sysRoleMenu = new SysRoleMenu();
sysRoleMenu.setRoleId(roleId);
sysRoleMenu.setMenuId(menuId);
sysRoleMenu.setChoice(true);
sysRoleMenus.add(sysRoleMenu);
}
// 补全上级菜单父ID
Set<Long> completionMenuIds = completionMenuParentIds(menuIds);
if (CollectionUtils.isNotEmpty(completionMenuIds)) {
for (Long completionMenuId : completionMenuIds) {
SysRoleMenu sysRoleMenu = new SysRoleMenu();
sysRoleMenu.setRoleId(roleId);
sysRoleMenu.setMenuId(completionMenuId);
sysRoleMenu.setChoice(false);
sysRoleMenus.add(sysRoleMenu);
}
}
boolean flag = sysRoleMenuService.saveBatch(sysRoleMenus);
if (!flag) {
throw new BusinessException("设置角色权限异常");
}
return true;
}
@Override
public void checkCodeExists(String code) {<FILL_FUNCTION_BODY>}
/**
* 补全菜单父ID
*
* @param choiceMenuIds
* @return
*/
private Set<Long> completionMenuParentIds(List<Long> choiceMenuIds) {
// 获取所有菜单
List<SysMenu> menus = sysMenuService.list();
if (CollectionUtils.isEmpty(menus)) {
return null;
}
Map<Long, SysMenu> menuMap = menus.stream().collect(Collectors.toMap(SysMenu::getId, SysMenu -> SysMenu));
// 获取选择的菜单对象集合
List<SysMenu> choiceMenus = new ArrayList<>();
for (Long choiceMenuId : choiceMenuIds) {
SysMenu sysMenu = menuMap.get(choiceMenuId);
if (sysMenu != null) {
choiceMenus.add(sysMenu);
}
}
// 递归获取上级ID直到parentId为0截止
if (CollectionUtils.isEmpty(choiceMenus)) {
return null;
}
Set<Long> menuIdSet = new HashSet<>();
for (SysMenu choiceMenu : choiceMenus) {
recursionCompletionMenu(choiceMenuIds, menuIdSet, menuMap, choiceMenu);
}
return menuIdSet;
}
/**
* 递归补全菜单ID集合
*
* @param choiceMenuIds
* @param menuIdSet
* @param menuMap
* @param choiceMenu
*/
private void recursionCompletionMenu(List<Long> choiceMenuIds, Set<Long> menuIdSet, Map<Long, SysMenu> menuMap, SysMenu choiceMenu) {
Long parentId = choiceMenu.getParentId();
// 判断是否存在此父ID，不存在则添加
if (!choiceMenuIds.contains(parentId) && !menuIdSet.contains(parentId)) {
if (parentId != 0) {
menuIdSet.add(parentId);
SysMenu parentMenu = menuMap.get(parentId);
recursionCompletionMenu(choiceMenuIds, menuIdSet, menuMap, parentMenu);
}
}
}
}
|
LambdaQueryWrapper<SysRole> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(SysRole::getCode, code);
long count = count(wrapper);
if (count > 0) {
throw new BusinessException(code + "角色编码已经存在");
}
| 1,707
| 75
| 1,782
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/system/service/impl/SysUserServiceImpl.java
|
SysUserServiceImpl
|
getSysUserPage
|
class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> implements SysUserService {
@Autowired
private SysUserMapper sysUserMapper;
@Autowired
private LoginRedisService LoginRedisService;
@Transactional(rollbackFor = Exception.class)
@Override
public boolean addSysUser(SysUserDto dto) {
checkUsernameExists(dto.getUsername());
SysUser sysUser = new SysUser();
BeanUtils.copyProperties(dto, sysUser);
// 密码加盐
String salt = RandomStringUtils.randomNumeric(6);
sysUser.setSalt(salt);
String password = PasswordUtil.encrypt(sysUser.getPassword(), salt);
sysUser.setPassword(password);
// 保存用户
return save(sysUser);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean updateSysUser(SysUserDto dto) {
Long id = dto.getId();
SysUser sysUser = getById(id);
if (sysUser == null) {
throw new BusinessException("系统用户不存在");
}
BeanUtils.copyProperties(dto, sysUser);
return updateById(sysUser);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean deleteSysUser(Long id) {
// 删除用户
return removeById(id);
}
@Override
public SysUserVo getSysUserById(Long id) {
return sysUserMapper.getSysUserById(id);
}
@Override
public Paging<SysUserVo> getSysUserPage(SysUserQuery query) {<FILL_FUNCTION_BODY>}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean resetSysUserPassword(SysUserResetPasswordDto sysUserResetPasswordDto) {
Long userId = sysUserResetPasswordDto.getUserId();
log.info("管理员重置用户密码：" + userId);
SysUser sysUser = getById(userId);
if (sysUser == null) {
throw new BusinessException("系统用户不存在");
}
String password = sysUserResetPasswordDto.getPassword();
return handleUpdatePassword(userId, password);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean updateProfile(SysUserUpdateProfileDto sysUserUpdateProfileDto) {
Long id = LoginUtil.getUserId();
SysUser sysUser = getById(id);
if (sysUser == null) {
throw new BusinessException("用户信息不存在");
}
LambdaUpdateWrapper<SysUser> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.set(SysUser::getNickname, sysUserUpdateProfileDto.getNickname());
lambdaUpdateWrapper.set(SysUser::getPhone, sysUserUpdateProfileDto.getPhone());
lambdaUpdateWrapper.set(SysUser::getEmail, sysUserUpdateProfileDto.getEmail());
lambdaUpdateWrapper.set(SysUser::getHead, sysUserUpdateProfileDto.getHead());
lambdaUpdateWrapper.eq(SysUser::getId, id);
boolean flag = update(lambdaUpdateWrapper);
return flag;
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean updatePassword(SysUserUpdatePasswordDto sysUserUpdatePasswordDto) {
Long id = LoginUtil.getUserId();
SysUser sysUser = getById(id);
if (sysUser == null) {
throw new BusinessException("用户信息不存在");
}
// 验证旧密码
String dbPassword = sysUser.getPassword();
String dbSalt = sysUser.getSalt();
String oldPassword = sysUserUpdatePasswordDto.getOldPassword();
String encryptOldPassword = PasswordUtil.encrypt(oldPassword, dbSalt);
if (!dbPassword.equals(encryptOldPassword)) {
throw new BusinessException("旧密码错误");
}
// 验证两次密码是否一致
String password = sysUserUpdatePasswordDto.getPassword();
String confirmPassword = sysUserUpdatePasswordDto.getConfirmPassword();
if (!password.equals(confirmPassword)) {
throw new BusinessException("两次输入的密码不一致");
}
// 新密码不能与旧密码一致
String newPassword = PasswordUtil.encrypt(password, dbSalt);
if (dbPassword.equals(newPassword)) {
throw new BusinessException("新密码不能与旧密码一致");
}
return handleUpdatePassword(id, password);
}
@Override
public void checkUsernameExists(String username) {
LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(SysUser::getUsername, username);
long count = count(wrapper);
if (count > 0) {
throw new BusinessException(username + "用户名已经存在");
}
}
@Override
public boolean importExcel(MultipartFile multipartFile) throws Exception {
String originalFilename = multipartFile.getOriginalFilename();
log.info("导入的Excel文件名称：" + originalFilename);
String extension = FilenameUtils.getExtension(originalFilename).toLowerCase();
if (!(extension.endsWith(CommonConstant.XLS) || extension.endsWith(CommonConstant.XLSX))) {
throw new BusinessException("只能导入xls或xlsx格式的Excel文件");
}
InputStream inputStream = multipartFile.getInputStream();
EasyExcel.read(inputStream, SysUserExcelDto.class, new PageReadListener<SysUserExcelDto>(dataList -> {
for (SysUserExcelDto demoData : dataList) {
log.info("读取到一条数据{}", JSON.toJSONString(demoData));
}
}, 10)).sheet().doRead();
return false;
}
/**
* 修改密码并删除该用户当前的登录信息
*
* @param id
* @param password
* @return
* @throws Exception
*/
private boolean handleUpdatePassword(Long id, String password) {
// 生产新的盐值
String newSalt = UUIDUtil.getUuid();
String newPassword = PasswordUtil.encrypt(password, newSalt);
// 修改密码
LambdaUpdateWrapper<SysUser> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.set(SysUser::getPassword, newPassword);
lambdaUpdateWrapper.set(SysUser::getSalt, newSalt);
lambdaUpdateWrapper.set(SysUser::getUpdateTime, new Date());
lambdaUpdateWrapper.eq(SysUser::getId, id);
// 清除当前用户登录信息
LoginRedisService.deleteLoginInfoByToken(TokenUtil.getToken());
return update(lambdaUpdateWrapper);
}
}
|
OrderMapping orderMapping = new OrderMapping();
orderMapping.put("createTime", "create_time");
PagingUtil.handlePage(query, orderMapping, OrderByItem.desc("id"));
List<SysUserVo> list = sysUserMapper.getSysUserPage(query);
Paging<SysUserVo> paging = new Paging<>(list);
return paging;
| 1,837
| 102
| 1,939
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/user/service/impl/UserRoleServiceImpl.java
|
UserRoleServiceImpl
|
addUserRole
|
class UserRoleServiceImpl extends ServiceImpl<UserRoleMapper, UserRole> implements UserRoleService {
@Autowired
private UserRoleMapper userRoleMapper;
@Transactional(rollbackFor = Exception.class)
@Override
public boolean addUserRole(UserRoleDto dto) {<FILL_FUNCTION_BODY>}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean updateUserRole(UserRoleDto dto) {
Long id = dto.getId();
UserRole userRole = getById(id);
if (userRole == null) {
throw new BusinessException("用户角色不存在");
}
BeanUtils.copyProperties(dto, userRole);
return updateById(userRole);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean deleteUserRole(Long id) {
return removeById(id);
}
@Override
public UserRoleVo getUserRoleById(Long id) {
return userRoleMapper.getUserRoleById(id);
}
@Override
public Paging<UserRoleVo> getUserRolePage(UserRoleQuery query) {
OrderMapping orderMapping = new OrderMapping();
orderMapping.put("createTime", "create_time");
PagingUtil.handlePage(query, orderMapping, OrderByItem.desc("id"));
List<UserRoleVo> list = userRoleMapper.getUserRolePage(query);
Paging<UserRoleVo> paging = new Paging<>(list);
return paging;
}
}
|
UserRole userRole = new UserRole();
BeanUtils.copyProperties(dto, userRole);
return save(userRole);
| 404
| 37
| 441
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/user/service/impl/UserServiceImpl.java
|
UserServiceImpl
|
updateUser
|
class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
@Autowired
private UserMapper userMapper;
@Override
public User getUserByOpenid(String openid) {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getOpenid, openid);
return getOne(wrapper);
}
@Override
public User getUserByUsername(String username) {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getUsername, username);
return getOne(wrapper);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean addUser(UserDto userDto) {
User user = new User();
BeanUtils.copyProperties(userDto, user);
return save(user);
}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean updateUser(UserDto userDto) {<FILL_FUNCTION_BODY>}
@Transactional(rollbackFor = Exception.class)
@Override
public boolean deleteUser(Long id) {
return removeById(id);
}
@Override
public UserVo getUserById(Long id) {
return userMapper.getUserById(id);
}
@Override
public Paging<UserVo> getUserPage(UserQuery query) {
OrderMapping orderMapping = new OrderMapping();
orderMapping.put("createTime", "create_time");
PagingUtil.handlePage(query, orderMapping, OrderByItem.desc("id"));
List<UserVo> list = userMapper.getUserPage(query);
Paging<UserVo> paging = new Paging<>(list);
return paging;
}
@Override
public AppUserVo getProfile() {
Long userId = AppLoginUtil.getUserId();
return userMapper.getAppUserById(userId);
}
@Override
public boolean updateHead(AppUserHeadDto dto) {
Long userId = AppLoginUtil.getUserId();
LambdaUpdateWrapper<User> wrapper = new LambdaUpdateWrapper<>();
wrapper.set(User::getHead, dto.getHead());
wrapper.eq(User::getId, userId);
return update(new User(), wrapper);
}
@Override
public boolean updateNickname(AppUserNicknameDto dto) {
Long userId = AppLoginUtil.getUserId();
LambdaUpdateWrapper<User> wrapper = new LambdaUpdateWrapper<>();
wrapper.set(User::getNickname, dto.getNickname());
wrapper.eq(User::getId, userId);
return update(new User(), wrapper);
}
}
|
Long id = userDto.getId();
User user = getById(id);
if (user == null) {
throw new BusinessException("用户信息不存在");
}
BeanUtils.copyProperties(userDto, user);
return updateById(user);
| 716
| 71
| 787
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/util/CookieUtil.java
|
CookieUtil
|
deleteCookie
|
class CookieUtil {
/**
* 输出token到cookie
*
* @param name
* @param value
* @param request
* @param response
*/
public static void addCookie(String name, String value, HttpServletRequest request, HttpServletResponse response) {
Cookie cookie = new Cookie(name, value);
cookie.setPath(request.getContextPath());
response.addCookie(cookie);
}
/**
* 删除cookie
*
* @param name
* @param request
* @param response
*/
public static void deleteCookie(String name, HttpServletRequest request, HttpServletResponse response) {<FILL_FUNCTION_BODY>}
/**
* 通过cookieName从请求中获取cookieValue
*
* @param request
* @param cookieName
* @return
* @throws Exception
*/
public static String getCookieValueByName(HttpServletRequest request, String cookieName) {
Cookie[] cookies = request.getCookies();
return getCookieValueByName(cookies, cookieName);
}
/**
* 通过cookie名称获取cookie值
*
* @param cookies
* @param cookieName
* @return
* @throws Exception
*/
public static String getCookieValueByName(Cookie[] cookies, String cookieName) {
for (Cookie cookie : cookies) {
String name = cookie.getName();
if (name.equals(cookieName)) {
String value = cookie.getValue();
return value;
}
}
return null;
}
}
|
Cookie cookie = new Cookie(name, null);
cookie.setMaxAge(0);
cookie.setPath(request.getContextPath());
response.addCookie(cookie);
| 423
| 52
| 475
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/util/DataRangeUtil.java
|
DataRangeUtil
|
handleCommonLogin
|
class DataRangeUtil {
/**
* 设置Admin登录用户信息到查询参数中
*
* @param dataRangeQuery
*/
public static void handleAdminLogin(DataRangeQuery dataRangeQuery) {
LoginVo loginVo = LoginUtil.getLoginVo();
if (loginVo != null) {
Long userId = loginVo.getUserId();
dataRangeQuery.setLoginCommonUserId(userId);
dataRangeQuery.setLoginAdmin(loginVo.isAdmin());
dataRangeQuery.setLoginUserId(userId);
dataRangeQuery.setLoginRoleId(loginVo.getRoleId());
dataRangeQuery.setLoginRoleCode(loginVo.getRoleCode());
}
}
/**
* 设置App登录用户信息到查询参数中
*
* @param dataRangeQuery
*/
public static void handleAppLogin(DataRangeQuery dataRangeQuery) {
AppLoginVo appLoginVo = AppLoginUtil.getLoginVo();
if (appLoginVo != null) {
Long userId = appLoginVo.getUserId();
dataRangeQuery.setLoginCommonUserId(userId);
dataRangeQuery.setLoginAppUserId(userId);
dataRangeQuery.setLoginAppUserRoleId(appLoginVo.getUserRoleId());
dataRangeQuery.setLoginAppUserRoleCode(appLoginVo.getUserRoleCode());
}
}
/**
* 设置登录用户信息到查询参数中
*
* @param dataRangeQuery
*/
public static void handleCommonLogin(DataRangeQuery dataRangeQuery) {<FILL_FUNCTION_BODY>}
}
|
// 判断token是那个端
SystemType systemType = SystemTypeUtil.getSystemTypeByToken();
if (SystemType.ADMIN == systemType) {
LoginVo loginVo = LoginUtil.getLoginVo();
if (loginVo != null) {
dataRangeQuery.setLoginCommonUserId(loginVo.getUserId());
}
} else if (SystemType.APP == systemType) {
AppLoginVo appLoginVo = AppLoginUtil.getLoginVo();
if (appLoginVo != null) {
dataRangeQuery.setLoginCommonUserId(appLoginVo.getUserId());
}
}
| 433
| 170
| 603
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/util/DateDiffUtil.java
|
DateDiffUtil
|
getDiffDaySecond
|
class DateDiffUtil {
/**
* 计算相差的时间天到秒
* xx天xx小时xx分钟xx秒
*
* @param diffTime
* @return
*/
public static String getDiffDaySecond(long diffTime) {<FILL_FUNCTION_BODY>}
}
|
// 计算相差的秒数
long diff = diffTime / 1000;
// 计算天
long day = diff / (24 * 60 * 60);
// 计算小时数
long hour = diff / (60 * 60);
// 计算分钟数
long minute = (diff % (60 * 60)) / 60;
// 计算秒数
long second = diff % 60;
String desc = day + "天" + hour + "小时" + minute + "分钟" + second + "秒";
return desc;
| 80
| 153
| 233
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/util/ExcelExportUtil.java
|
ExcelExportUtil
|
export
|
class ExcelExportUtil {
private static final String CONTENT_TYPE = "application/vnd.ms-excel";
private static final String CONTENT_DISPOSITION = "Content-disposition";
private static final String CHARACTER_ENCODING = "UTF-8";
private static final String EXCEL_SUFFIX = ".xlsx";
public static void export(List<?> list, Class<?> headClass, HttpServletResponse response) {
export(list, headClass, null, null, response);
}
public static void export(List<?> list, Class<?> headClass, String exportFileName, HttpServletResponse response) {
export(list, headClass, exportFileName, null, response);
}
public static void export(List<?> list, Class<?> headClass, String exportFileName, String sheetName, HttpServletResponse response) {<FILL_FUNCTION_BODY>}
}
|
response.setContentType(CONTENT_TYPE);
response.setCharacterEncoding(CHARACTER_ENCODING);
ExcelWriter excelWriter = null;
try {
WriteCellStyle headWriteCellStyle = new WriteCellStyle();
headWriteCellStyle.setFillForegroundColor(IndexedColors.WHITE.getIndex());
WriteCellStyle contentWriteCellStyle = new WriteCellStyle();
//设置内容水平居中
contentWriteCellStyle.setHorizontalAlignment(HorizontalAlignment.CENTER);
HorizontalCellStyleStrategy horizontalCellStyleStrategy = new HorizontalCellStyleStrategy(headWriteCellStyle, contentWriteCellStyle);
if (StringUtils.isBlank(exportFileName)) {
String currentTime = new SimpleDateFormat("yyyyMMddHHmmssS").format(new Date());
String random = RandomStringUtils.randomNumeric(6);
exportFileName = currentTime + random;
}
exportFileName = URLEncoder.encode(exportFileName, CHARACTER_ENCODING);
response.setHeader(CONTENT_DISPOSITION, "attachment;filename=" + exportFileName + EXCEL_SUFFIX);
excelWriter = EasyExcel.write(response.getOutputStream())
.registerWriteHandler(horizontalCellStyleStrategy)
.registerConverter(new LongStringConverter())
.build();
WriteSheet mainSheet = EasyExcel.writerSheet(0, sheetName).head(headClass).build();
excelWriter.write(list, mainSheet);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (excelWriter != null) {
excelWriter.finish();
}
}
| 233
| 420
| 653
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/util/HttpServletRequestUtil.java
|
HttpServletRequestUtil
|
isDocRequest
|
class HttpServletRequestUtil {
/**
* 获取HttpServletRequest对象
*
* @return
*/
public static HttpServletRequest getRequest() {
return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
}
/**
* 判断是否是Knife4j或是Swagger接口文档访问的请求
*
* @return
*/
public static boolean isDocRequest() {
return isDocRequest(getRequest());
}
/**
* 判断是否是Knife4j或是Swagger接口文档访问的请求
*
* @param request
* @return
*/
public static boolean isDocRequest(HttpServletRequest request) {<FILL_FUNCTION_BODY>}
}
|
String requestOrigion = request.getHeader(RequestHeadConstant.REQUEST_ORIGION);
String referer = request.getHeader(RequestHeadConstant.REFERER);
boolean docRequest = false;
if (CommonConstant.KNIFE4J.equals(requestOrigion)) {
docRequest = true;
} else if (StringUtils.isNotBlank(referer) && referer.contains(CommonConstant.SWAGGER_UI_PATH)) {
docRequest = true;
}
return docRequest;
| 197
| 131
| 328
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/util/HttpServletResponseUtil.java
|
HttpServletResponseUtil
|
printJson
|
class HttpServletResponseUtil {
private static String UTF8 = "UTF-8";
private static String CONTENT_TYPE = "application/json";
private HttpServletResponseUtil() {
throw new AssertionError();
}
public static void printFailJsonMessage(HttpServletResponse response, String errorMessage) {
ApiResult apiResult = ApiResult.fail(errorMessage);
printJson(response, apiResult);
}
public static void printJson(HttpServletResponse response, Object object) {<FILL_FUNCTION_BODY>}
public static void print(HttpServletResponse response, String string) {
response.setCharacterEncoding(UTF8);
response.setContentType(CONTENT_TYPE);
PrintWriter printWriter = null;
try {
printWriter = response.getWriter();
printWriter.write(string);
printWriter.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (printWriter != null) {
printWriter.close();
}
}
}
}
|
response.setCharacterEncoding(UTF8);
response.setContentType(CONTENT_TYPE);
PrintWriter printWriter = null;
try {
printWriter = response.getWriter();
printWriter.write(JSON.toJSONString(object));
printWriter.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (printWriter != null) {
printWriter.close();
}
}
| 272
| 118
| 390
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/util/IpRegionUtil.java
|
IpRegionUtil
|
destroy
|
class IpRegionUtil {
private static final String CHINA = "中国";
private static final String PROVINCE = "省";
private static final String CITY = "市";
private static final String INTRANET = "内网IP";
private static Searcher searcher;
/**
* 程序启动时，将ip2region.xdb一次性加载到内存中
* 并发场景下可安全使用
*/
@PostConstruct
private static void init() {
InputStream inputStream = null;
try {
inputStream = new ClassPathResource("/ip2region.xdb").getInputStream();
byte[] buff = FileCopyUtils.copyToByteArray(inputStream);
searcher = Searcher.newWithBuffer(buff);
log.info("加载ip2region.xdb成功");
} catch (IOException e) {
log.error("加载ip2region.xdb异常");
e.printStackTrace();
} finally {
try {
if (inputStream != null) {
inputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 根据IP获取区域信息
*
* @param ip
* @return
*/
public static IpRegion getIpRegion(String ip) {
try {
String region = searcher.search(ip);
if (StringUtils.isBlank(region)) {
return null;
}
String[] array = region.split("\\|");
String country = array[0];
String province = null;
String city = null;
String isp = null;
String areaDesc;
if (CHINA.equals(country)) {
province = array[2];
city = array[3];
isp = array[4];
if (province.endsWith(PROVINCE)) {
province = province.substring(0, province.length() - 1);
}
if (city.endsWith(CITY)) {
city = city.substring(0, city.length() - 1);
}
if (province.equals(city)) {
areaDesc = province;
} else {
areaDesc = province + " " + city;
}
} else if (region.contains(INTRANET)) {
areaDesc = INTRANET;
} else {
province = array[2];
isp = array[4];
if (StringUtils.isBlank(province)) {
areaDesc = country;
} else {
areaDesc = country + " " + province;
}
}
IpRegion ipRegion = new IpRegion();
ipRegion.setCountry(country);
ipRegion.setProvince(province);
ipRegion.setCity(city);
ipRegion.setAreaDesc(areaDesc);
ipRegion.setIsp(isp);
return ipRegion;
} catch (Exception e) {
log.error("解析IP归属地信息异常：" + ip);
e.printStackTrace();
}
return null;
}
/**
* 通过IP获取区域描述
*
* @param ip
* @return
*/
public static String getIpAreaDesc(String ip) {
IpRegion ipRegion = getIpRegion(ip);
if (ipRegion != null) {
return ipRegion.getAreaDesc();
}
return null;
}
@PreDestroy
public static void destroy() {<FILL_FUNCTION_BODY>}
}
|
try {
if (searcher != null) {
searcher.close();
}
} catch (IOException e) {
e.printStackTrace();
}
| 924
| 48
| 972
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/util/IpUtil.java
|
IpUtil
|
getLocalhostIpList
|
class IpUtil {
private static final String UNKNOWN = "unknown";
private static final String IPV6_LOCAL = "0:0:0:0:0:0:0:1";
private static final String COMMA = ",";
private static final String FE = "fe";
private static final String[] IP_HEADS = new String[]{"x-forwarded-for", "X-Forwarded-For", "X-Real-IP", "Proxy-Client-IP", "WL-Proxy-Client-IP"};
/**
* 获取请求用户的IP地址
*
* @return
*/
public static String getRequestIp() {
HttpServletRequest request = HttpServletRequestUtil.getRequest();
String ip = getRequestIp(request);
if (ip.indexOf(COMMA) != -1) {
String[] strings = ip.split(COMMA);
ip = strings[0];
}
return ip;
}
/**
* 获取请求用户的IP地址
*
* @param request
* @return
*/
public static String getRequestIp(HttpServletRequest request) {
String ip = null;
for (String ipHead : IP_HEADS) {
ip = request.getHeader(ipHead);
if (StringUtils.isNotBlank(ip) && !UNKNOWN.equalsIgnoreCase(ip)) {
break;
}
}
if (StringUtils.isBlank(ip) || UNKNOWN.equalsIgnoreCase(ip)) {
ip = request.getRemoteAddr();
}
if (IPV6_LOCAL.equals(ip)) {
ip = getLocalhostIp();
}
return ip;
}
public static String getLocalhostIp() {
try {
return InetAddress.getLocalHost().getHostAddress();
} catch (UnknownHostException e) {
e.printStackTrace();
}
return null;
}
public static List<String> getLocalhostIpList() {<FILL_FUNCTION_BODY>}
/**
* 是否是有效的网络
*
* @param networkInterface
* @return
*/
private static boolean isValidateNetworkInterface(NetworkInterface networkInterface) {
try {
return !networkInterface.isLoopback() && !networkInterface.isPointToPoint() && networkInterface.isUp() && !networkInterface.isVirtual();
} catch (SocketException e) {
e.printStackTrace();
}
return false;
}
/**
* 是否是有效的IP
*
* @param inetAddress
* @return
*/
private static boolean isValidateAddress(InetAddress inetAddress) {
try {
String hostAddress = inetAddress.getHostAddress();
// 排除IPV6地址
if (hostAddress.startsWith(FE)) {
return false;
}
if (!isValidIpV4(hostAddress)) {
return false;
}
} catch (Exception e) {
e.printStackTrace();
}
return true;
}
/**
* 校验是否是有效的IPV4
*
* @param ipAddress
* @return
*/
public static boolean isValidIpV4(String ipAddress) {
return Pattern.matches("^([1-9]|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])(\\.(\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])){3}$", ipAddress);
}
}
|
List<String> list = new ArrayList<>();
try {
Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
if (ObjectUtils.isEmpty(networkInterfaces)) {
return null;
}
while (networkInterfaces.hasMoreElements()) {
NetworkInterface networkInterface = networkInterfaces.nextElement();
if (!isValidateNetworkInterface(networkInterface)) {
continue;
}
Enumeration<InetAddress> inetAddresses = networkInterface.getInetAddresses();
while (inetAddresses.hasMoreElements()) {
InetAddress inetAddress = inetAddresses.nextElement();
if (!isValidateAddress(inetAddress)) {
continue;
}
list.add(inetAddress.getHostAddress());
}
}
} catch (SocketException e) {
e.printStackTrace();
}
return list;
| 940
| 226
| 1,166
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/util/ObjectValueUtil.java
|
ObjectValueUtil
|
isHaveValue
|
class ObjectValueUtil {
private static String SERIAL_VERSION_UID = "serialVersionUID";
/**
* 对象的属性是否没有值
*
* @param object
* @return
*/
public static boolean isNotHaveValue(Object object) {
return !isHaveValue(object);
}
/**
* 对象的属性是否有值
*
* @param object
* @return
*/
public static boolean isHaveValue(Object object) {<FILL_FUNCTION_BODY>}
}
|
if (object == null) {
return false;
}
Class<?> clazz = object.getClass();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
String name = field.getName();
if (SERIAL_VERSION_UID.equals(name)) {
continue;
}
try {
Object value = field.get(object);
Class<?> type = field.getType();
if (type == String.class) {
String string = (String) value;
if (StringUtils.isNotBlank(string)) {
return true;
}
} else {
if (value != null) {
return true;
}
}
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
return false;
| 143
| 229
| 372
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/util/PagingUtil.java
|
PagingUtil
|
handlePage
|
class PagingUtil {
/**
* 处理分页
*
* @param basePageQuery
*/
public static void handlePage(BasePageQuery basePageQuery) {
handlePage(basePageQuery, null);
}
/**
* 处理分页
*
* @param basePageQuery
* @param defaultOrderBy
*/
public static void handlePage(BasePageQuery basePageQuery, String defaultOrderBy) {
handlePage(basePageQuery, null, defaultOrderBy);
}
public static void handlePage(BasePageQuery basePageQuery, OrderMapping orderMapping, String defaultOrderBy) {<FILL_FUNCTION_BODY>}
}
|
String orderBy = defaultOrderBy;
Integer pageIndex = CommonConstant.DEFAULT_PAGE_INDEX;
Integer pageSize = CommonConstant.DEFAULT_PAGE_SIZE;
if (basePageQuery != null) {
pageIndex = basePageQuery.getPageIndex();
pageSize = basePageQuery.getPageSize();
// 判断参数中是否有排序
String orderByColumn = basePageQuery.getOrderByColumn();
if (StringUtils.isNotBlank(orderByColumn)) {
// 获取列映射
if (orderMapping != null && orderMapping.size() > 0) {
String dbColumn = orderMapping.get(orderByColumn);
// 如果没找到对应的数据库映射列，则使用当前参数列名称
if (StringUtils.isNotBlank(dbColumn)) {
orderByColumn = dbColumn;
}
}
Boolean orderByAsc = basePageQuery.getOrderByAsc();
String paramOrderBy = OrderByItem.orderBy(orderByColumn, orderByAsc);
if (StringUtils.isNotBlank(paramOrderBy)) {
orderBy = paramOrderBy;
}
}
}
// 分页
PageHelper.startPage(pageIndex, pageSize, orderBy);
| 176
| 322
| 498
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/util/PasswordUtil.java
|
PasswordUtil
|
encrypt
|
class PasswordUtil {
private static int MD5_PWD_LENGTH = 32;
public static String encrypt(String password, String salt) {<FILL_FUNCTION_BODY>}
}
|
if (StringUtils.isBlank(password)) {
throw new IllegalArgumentException("密码不能为空");
}
if (StringUtils.isBlank(salt)) {
salt = "";
}
// 如果密码长度不是32为，则进行md5加密
if (password.length() != MD5_PWD_LENGTH) {
password = DigestUtils.md5Hex(password);
}
// 将md5加密后的结果+盐，再进行sha256加密
String encryptPassword = DigestUtils.sha256Hex(password + salt);
return encryptPassword;
| 55
| 165
| 220
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/util/SystemTypeUtil.java
|
SystemTypeUtil
|
getSystemTypeByPath
|
class SystemTypeUtil {
/**
* 获取系统类型枚举
*
* @param request
* @return
* @throws Exception
*/
public static SystemType getSystemTypeByPath(HttpServletRequest request) {
String servletPath = request.getServletPath();
return getSystemTypeByPath(servletPath);
}
/**
* 根据请求路径获取系统类型枚举
*
* @param servletPath
* @return
* @throws Exception
*/
public static SystemType getSystemTypeByPath(String servletPath) {<FILL_FUNCTION_BODY>}
/**
* 判断token是那个端
*
* @param token
* @return
* @throws Exception
*/
public static SystemType getSystemTypeByToken(String token) {
if (StringUtils.isBlank(token)) {
return null;
}
if (token.startsWith(LoginConstant.ADMIN_TOKEN_PREFIX)) {
return SystemType.ADMIN;
} else if (token.startsWith(LoginConstant.APP_TOKEN_PREFIX)) {
return SystemType.APP;
}
return null;
}
/**
* 判断token是那个端
*
* @return
* @throws Exception
*/
public static SystemType getSystemTypeByToken() {
String token = TokenUtil.getToken();
return getSystemTypeByToken(token);
}
/**
* 判断token是那个端
*
* @return
* @throws Exception
*/
public static Integer getSystemTypeCodeByToken() {
SystemType systemType = getSystemTypeByToken();
if (systemType != null) {
return systemType.getCode();
}
return null;
}
/**
* 判断是否是管理后台系统
*
* @return
* @throws Exception
*/
public static boolean isAdminSystem() {
SystemType systemType = getSystemTypeByToken();
if (SystemType.ADMIN == systemType) {
return true;
}
return false;
}
/**
* 判断是否是APP移动端系统
*
* @return
* @throws Exception
*/
public static boolean isAppSystem() {
SystemType systemType = getSystemTypeByToken();
if (SystemType.APP == systemType) {
return true;
}
return false;
}
}
|
if (StringUtils.isBlank(servletPath)) {
return null;
}
if (servletPath.startsWith(LoginConstant.ADMIN_URL_PREFIX)) {
return SystemType.ADMIN;
} else if (servletPath.startsWith(LoginConstant.APP_URL_PREFIX)) {
return SystemType.APP;
}
return null;
| 642
| 101
| 743
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/util/YamlUtil.java
|
YamlUtil
|
parseListArray
|
class YamlUtil {
/**
* 解析配置文件总的list行数据为数组
*
* @param list
* @return
*/
public static List<String> parseListArray(List<String> list) {<FILL_FUNCTION_BODY>}
}
|
if (CollectionUtils.isEmpty(list)) {
return null;
}
List<String> parseList = new ArrayList<>();
for (String string : list) {
if (StringUtils.isBlank(string)) {
continue;
}
if (string.contains(CommonConstant.COMMA)) {
String[] array = string.split(CommonConstant.COMMA);
parseList.addAll(Arrays.asList(array));
} else {
parseList.add(string);
}
}
return parseList;
| 77
| 140
| 217
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/util/api/OssApi.java
|
OssApi
|
initOssClient
|
class OssApi {
private static OssProperties ossProperties;
private static OSS ossClient;
public OssApi(OssProperties ossProperties) {
OssApi.ossProperties = ossProperties;
}
@PostConstruct
public void initOssClient() {<FILL_FUNCTION_BODY>}
public static String upload(InputStream inputStream, String dirName, String fileName) {
try {
String rootDir = ossProperties.getRootDir();
String fileKey = "";
if (StringUtils.isNotBlank(rootDir)) {
fileKey = rootDir + "/";
}
fileKey = fileKey + dirName + "/" + fileName;
log.info("OSS上传文件fileKey：" + fileKey);
PutObjectRequest putObjectRequest = new PutObjectRequest(ossProperties.getBucketName(), fileKey, inputStream);
PutObjectResult result = ossClient.putObject(putObjectRequest);
log.info("OSS上传文件结果：" + JSON.toJSONString(result));
String accessUrl = ossProperties.getAccessDomain();
String url = accessUrl + "/" + fileKey;
// 返回访问路径
log.info("OSS上传文件成功，fileKey：{}，url：{}", fileKey, url);
return url;
} catch (OSSException oe) {
log.error("OSS上传文件异常，错误消息：{}，错误码：{}，请求ID：{}，主机ID：{}", oe.getErrorMessage(), oe.getErrorCode(), oe.getRequestId(), oe.getHostId());
throw new BusinessException("OSS上传文件异常");
} catch (ClientException ce) {
log.error("OSS客户端异常：" + ce.getMessage());
throw new BusinessException("OSS连接异常");
} catch (Exception e) {
throw e;
}
}
@PreDestroy
public void destroy() {
try {
if (ossClient != null) {
ossClient.shutdown();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
|
try {
DefaultCredentialProvider credentialsProvider = CredentialsProviderFactory.newDefaultCredentialProvider(ossProperties.getAccessKeyId(), ossProperties.getAccessKeySecret());
// 创建OSSClient实例
ossClient = new OSSClientBuilder().build(ossProperties.getEndpoint(), credentialsProvider);
log.info("OSS实例初始化成功：" + JSON.toJSONString(ossProperties));
} catch (Exception e) {
log.error("OSS实例初始化异常：" + JSON.toJSONString(ossProperties));
e.printStackTrace();
}
| 563
| 152
| 715
|
<no_super_class>
|
geekidea_spring-boot-plus
|
spring-boot-plus/src/main/java/io/geekidea/boot/util/api/WxMpApi.java
|
WxMpApi
|
getOpenid
|
class WxMpApi {
private static WxMpProperties wxMpProperties;
public WxMpApi(WxMpProperties wxMpProperties) {
log.info("wxMpProperties:" + wxMpProperties);
WxMpApi.wxMpProperties = wxMpProperties;
}
/**
* 微信小程序登录
*
* @param code
* @return
* @throws Exception
*/
public static String getOpenid(String code) {<FILL_FUNCTION_BODY>}
}
|
log.info("微信小程序code：" + code);
String url = "https://api.weixin.qq.com/sns/jscode2session";
Map<String, Object> paramMap = new HashMap<>();
paramMap.put("appid", wxMpProperties.getAppid());
paramMap.put("secret", wxMpProperties.getSecret());
paramMap.put("js_code", code);
paramMap.put("grant_type", "authorization_code");
String result = HttpUtil.get(url, paramMap);
log.info("微信小程序登录结果：" + result);
JSONObject jsonObject = JSONObject.parseObject(result);
String openid = jsonObject.getString("openid");
log.info("微信小程序登录openid：" + openid);
String errcode = jsonObject.getString("errcode");
String errmsg = jsonObject.getString("errmsg");
if (StringUtils.isBlank(openid)) {
log.error("微信小程序登录失败,errcode:{},errmsg", errcode, errmsg);
throw new BusinessException("微信小程序登录失败");
}
return openid;
| 146
| 304
| 450
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-autoconfig/src/main/java/org/springframework/cloud/kubernetes/client/KubernetesClientAutoConfiguration.java
|
KubernetesClientAutoConfiguration
|
apiClient
|
class KubernetesClientAutoConfiguration {
/**
* this bean will be based on
* {@link org.springframework.cloud.kubernetes.commons.discovery.KubernetesDiscoveryProperties}
* in the next major release.
*/
@Deprecated(forRemoval = true)
@Bean
@ConditionalOnMissingBean
public ApiClient apiClient(Environment environment) {<FILL_FUNCTION_BODY>}
@Bean
@ConditionalOnMissingBean
public CoreV1Api coreApi(ApiClient apiClient) {
return new CoreV1Api(apiClient);
}
@Bean
@ConditionalOnMissingBean
public KubernetesNamespaceProvider kubernetesNamespaceProvider(Environment environment) {
return new KubernetesNamespaceProvider(environment);
}
@Bean
@ConditionalOnMissingBean
public KubernetesClientPodUtils kubernetesPodUtils(CoreV1Api client,
KubernetesNamespaceProvider kubernetesNamespaceProvider) {
return new KubernetesClientPodUtils(client, kubernetesNamespaceProvider.getNamespace(), true);
}
}
|
ApiClient apiClient = kubernetesApiClient();
// it's too early to inject KubernetesClientProperties here, all its properties
// are missing. For the time being work-around with reading from the environment.
apiClient.setUserAgent(environment.getProperty("spring.cloud.kubernetes.client.user-agent",
KubernetesClientProperties.DEFAULT_USER_AGENT));
return apiClient;
| 262
| 107
| 369
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-autoconfig/src/main/java/org/springframework/cloud/kubernetes/client/KubernetesClientHealthIndicator.java
|
KubernetesClientHealthIndicator
|
getDetails
|
class KubernetesClientHealthIndicator extends AbstractKubernetesHealthIndicator {
private final PodUtils<V1Pod> utils;
public KubernetesClientHealthIndicator(PodUtils<V1Pod> utils) {
this.utils = utils;
}
@Override
protected Map<String, Object> getDetails() {<FILL_FUNCTION_BODY>}
}
|
V1Pod current = utils.currentPod().get();
if (current != null) {
Map<String, Object> details = CollectionUtils.newHashMap(8);
details.put(INSIDE, true);
V1ObjectMeta meta = current.getMetadata();
details.put(NAMESPACE, meta.getNamespace());
details.put(POD_NAME, meta.getName());
details.put(LABELS, meta.getLabels());
V1PodStatus status = current.getStatus();
details.put(POD_IP, status.getPodIP());
details.put(HOST_IP, status.getHostIP());
V1PodSpec spec = current.getSpec();
details.put(SERVICE_ACCOUNT, spec.getServiceAccountName());
details.put(NODE_NAME, spec.getNodeName());
return details;
}
else {
return Collections.singletonMap(INSIDE, false);
}
| 100
| 261
| 361
|
<methods>public non-sealed void <init>() <variables>public static final java.lang.String HOST_IP,public static final java.lang.String INSIDE,public static final java.lang.String LABELS,public static final java.lang.String NAMESPACE,public static final java.lang.String NODE_NAME,public static final java.lang.String POD_IP,public static final java.lang.String POD_NAME,public static final java.lang.String SERVICE_ACCOUNT
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-autoconfig/src/main/java/org/springframework/cloud/kubernetes/client/KubernetesClientInfoContributor.java
|
KubernetesClientInfoContributor
|
getDetails
|
class KubernetesClientInfoContributor extends AbstractKubernetesInfoContributor {
private final PodUtils<V1Pod> utils;
public KubernetesClientInfoContributor(PodUtils<V1Pod> utils) {
this.utils = utils;
}
@Override
public Map<String, Object> getDetails() {<FILL_FUNCTION_BODY>}
}
|
V1Pod current = utils.currentPod().get();
if (current != null) {
Map<String, Object> details = CollectionUtils.newHashMap(7);
details.put(INSIDE, true);
V1ObjectMeta meta = current.getMetadata();
details.put(NAMESPACE, meta.getNamespace());
details.put(POD_NAME, meta.getName());
V1PodSpec spec = current.getSpec();
details.put(SERVICE_ACCOUNT, spec.getServiceAccountName());
details.put(NODE_NAME, spec.getNodeName());
V1PodStatus status = current.getStatus();
details.put(POD_IP, status.getPodIP());
details.put(HOST_IP, status.getHostIP());
return details;
}
return Collections.singletonMap(INSIDE, false);
| 99
| 236
| 335
|
<methods>public non-sealed void <init>() ,public void contribute(org.springframework.boot.actuate.info.Info.Builder) ,public abstract Map<java.lang.String,java.lang.Object> getDetails() <variables>public static final java.lang.String HOST_IP,public static final java.lang.String INSIDE,public static final java.lang.String KUBERNETES,public static final java.lang.String LABELS,private static final org.apache.commons.logging.Log LOG,public static final java.lang.String NAMESPACE,public static final java.lang.String NODE_NAME,public static final java.lang.String POD_IP,public static final java.lang.String POD_NAME,public static final java.lang.String SERVICE_ACCOUNT
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-autoconfig/src/main/java/org/springframework/cloud/kubernetes/client/KubernetesClientPodUtils.java
|
KubernetesClientPodUtils
|
internalGetPod
|
class KubernetesClientPodUtils implements PodUtils<V1Pod> {
/**
* Hostname environment variable name.
*/
public static final String HOSTNAME = "HOSTNAME";
/**
* KUBERNETES_SERVICE_HOST environment variable name.
*/
public static final String KUBERNETES_SERVICE_HOST = "KUBERNETES_SERVICE_HOST";
private static final Log LOG = LogFactory.getLog(KubernetesClientPodUtils.class);
private final CoreV1Api client;
private final String hostName;
private final Supplier<V1Pod> current;
private final String namespace;
private final String serviceHost;
private final boolean failFast;
@Deprecated(forRemoval = true)
public KubernetesClientPodUtils(CoreV1Api client, String namespace) {
if (client == null) {
throw new IllegalArgumentException("Must provide an instance of KubernetesClient");
}
this.client = client;
this.hostName = EnvReader.getEnv(HOSTNAME);
this.serviceHost = EnvReader.getEnv(KUBERNETES_SERVICE_HOST);
this.current = LazilyInstantiate.using(this::internalGetPod);
this.namespace = namespace;
this.failFast = false;
}
// mainly needed for the health and info contributors, so that they report DOWN
// correctly
public KubernetesClientPodUtils(CoreV1Api client, String namespace, boolean failFast) {
if (client == null) {
throw new IllegalArgumentException("Must provide an instance of KubernetesClient");
}
this.client = client;
this.hostName = EnvReader.getEnv(HOSTNAME);
this.serviceHost = EnvReader.getEnv(KUBERNETES_SERVICE_HOST);
this.current = LazilyInstantiate.using(this::internalGetPod);
this.namespace = namespace;
this.failFast = failFast;
}
@Override
public Supplier<V1Pod> currentPod() {
return current;
}
@Override
public boolean isInsideKubernetes() {
return currentPod().get() != null;
}
private V1Pod internalGetPod() {<FILL_FUNCTION_BODY>}
private boolean isServiceHostEnvVarPresent() {
return StringUtils.hasLength(serviceHost);
}
private boolean isHostNameEnvVarPresent() {
return StringUtils.hasLength(hostName);
}
private boolean isServiceAccountFound() {
boolean serviceAccountPathPresent = Paths.get(Config.SERVICEACCOUNT_TOKEN_PATH).toFile().exists();
if (!serviceAccountPathPresent) {
// https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/
LOG.warn("serviceaccount path not present, did you disable it via 'automountServiceAccountToken : false'?"
+ " Major functionalities will not work without that property being set");
}
return serviceAccountPathPresent && Paths.get(Config.SERVICEACCOUNT_CA_PATH).toFile().exists();
}
}
|
try {
if (isServiceHostEnvVarPresent() && isHostNameEnvVarPresent() && isServiceAccountFound()) {
LOG.debug("reading pod in namespace : " + namespace);
// The hostname of your pod is typically also its name.
return client.readNamespacedPod(hostName, namespace, null);
}
}
catch (Throwable t) {
if (failFast) {
if (t instanceof ApiException apiException) {
LOG.error("error reading pod : " + apiException.getResponseBody());
}
throw new RuntimeException(t);
}
if (t instanceof ApiException apiException) {
LOG.warn("error reading pod, with error : " + apiException.getResponseBody());
}
LOG.warn("Failed to get pod with name:[" + hostName + "]. You should look into this if things aren't"
+ " working as you expect. Are you missing serviceaccount permissions?", t);
}
return null;
| 789
| 254
| 1,043
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-autoconfig/src/main/java/org/springframework/cloud/kubernetes/client/KubernetesClientUtils.java
|
KubernetesClientUtils
|
kubernetesApiClient
|
class KubernetesClientUtils {
private static final Log LOG = LogFactory.getLog(KubernetesClientUtils.class);
private KubernetesClientUtils() {
}
public static ApiClient createApiClientForInformerClient() {
ApiClient apiClient = kubernetesApiClient();
apiClient.setReadTimeout(0);
return apiClient;
}
public static ApiClient kubernetesApiClient() {<FILL_FUNCTION_BODY>}
/**
* this method does the namespace resolution for both config map and secrets
* implementations. It tries these places to find the namespace:
*
* <pre>
* 1. from a normalized source (which can be null)
* 2. from a property 'spring.cloud.kubernetes.client.namespace', if such is present
* 3. from a String residing in a file denoted by `spring.cloud.kubernetes.client.serviceAccountNamespacePath`
* property, if such is present
* 4. from a String residing in `/var/run/secrets/kubernetes.io/serviceaccount/namespace` file,
* if such is present (kubernetes default path)
* </pre>
*
* If any of the above fail, we throw a NamespaceResolutionFailedException.
* @param namespace normalized namespace
* @param configurationTarget Config Map/Secret
* @param provider the provider which computes the namespace
* @return application namespace
* @throws NamespaceResolutionFailedException when namespace could not be resolved
*/
public static String getApplicationNamespace(String namespace, String configurationTarget,
KubernetesNamespaceProvider provider) {
if (StringUtils.hasText(namespace)) {
LOG.debug(configurationTarget + " namespace : " + namespace);
return namespace;
}
if (provider != null) {
String providerNamespace = provider.getNamespace();
if (StringUtils.hasText(providerNamespace)) {
LOG.debug(configurationTarget + " namespace from provider : " + namespace);
return providerNamespace;
}
}
throw new NamespaceResolutionFailedException("unresolved namespace");
}
}
|
try {
// Assume we are running in a cluster
ApiClient apiClient = ClientBuilder.cluster().build();
LOG.info("Created API client in the cluster.");
return apiClient;
}
catch (Exception e) {
if (e instanceof IllegalStateException illegalStateException
&& illegalStateException.getCause() instanceof NumberFormatException) {
LOG.info("Could not create the Kubernetes ApiClient in a cluster environment, because connection port "
+ "was not provided.");
}
else {
LOG.info("Could not create the Kubernetes ApiClient in a cluster environment, because : ", e);
}
LOG.info("""
Trying to use a "standard" configuration to create the Kubernetes ApiClient""");
try {
ApiClient apiClient = ClientBuilder.defaultClient();
LOG.info("Created standard API client. Unless $KUBECONFIG or $HOME/.kube/config is defined, "
+ "this client will try to connect to localhost:8080");
return apiClient;
}
catch (Exception e1) {
LOG.warn("Could not create a Kubernetes ApiClient from either a cluster or standard environment. "
+ "Will return one that always connects to localhost:8080", e1);
return new ClientBuilder().build();
}
}
| 540
| 344
| 884
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-autoconfig/src/main/java/org/springframework/cloud/kubernetes/client/profile/KubernetesClientProfileEnvironmentPostProcessor.java
|
KubernetesClientProfileEnvironmentPostProcessor
|
isInsideKubernetes
|
class KubernetesClientProfileEnvironmentPostProcessor extends AbstractKubernetesProfileEnvironmentPostProcessor {
@Override
protected boolean isInsideKubernetes(Environment environment) {<FILL_FUNCTION_BODY>}
}
|
CoreV1Api api = new CoreV1Api();
KubernetesClientPodUtils utils = new KubernetesClientPodUtils(api, environment.getProperty(NAMESPACE_PROPERTY),
false);
return environment.containsProperty(ENV_SERVICE_HOST) || utils.isInsideKubernetes();
| 54
| 86
| 140
|
<methods>public non-sealed void <init>() ,public int getOrder() ,public void postProcessEnvironment(org.springframework.core.env.ConfigurableEnvironment, org.springframework.boot.SpringApplication) <variables>public static final java.lang.String KUBERNETES_PROFILE,private static final org.springframework.boot.logging.DeferredLog LOG,private static final java.lang.String NAMESPACE_PATH_PROPERTY,protected static final java.lang.String NAMESPACE_PROPERTY,private static final int ORDER,private static final java.lang.String PROPERTY_SOURCE_NAME
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-config/src/main/java/org/springframework/cloud/kubernetes/client/config/KubernetesClientConfigDataLocationResolver.java
|
KubernetesClientConfigDataLocationResolver
|
registerBeans
|
class KubernetesClientConfigDataLocationResolver extends KubernetesConfigDataLocationResolver {
public KubernetesClientConfigDataLocationResolver(DeferredLogFactory factory) {
super(factory);
}
@Override
protected void registerBeans(ConfigDataLocationResolverContext resolverContext, ConfigDataLocation location,
Profiles profiles, KubernetesConfigDataLocationResolver.PropertyHolder propertyHolder,
KubernetesNamespaceProvider namespaceProvider) {<FILL_FUNCTION_BODY>}
private CoreV1Api registerClientAndCoreV1Api(ConfigurableBootstrapContext bootstrapContext,
KubernetesClientProperties kubernetesClientProperties) {
ApiClient apiClient = kubernetesApiClient();
apiClient.setUserAgent(kubernetesClientProperties.userAgent());
registerSingle(bootstrapContext, ApiClient.class, apiClient, "configDataApiClient");
CoreV1Api coreV1Api = new CoreV1Api(apiClient);
bootstrapContext.registerIfAbsent(CoreV1Api.class, BootstrapRegistry.InstanceSupplier.of(coreV1Api));
return coreV1Api;
}
protected KubernetesNamespaceProvider kubernetesNamespaceProvider(Environment environment) {
return new KubernetesNamespaceProvider(environment);
}
}
|
KubernetesClientProperties kubernetesClientProperties = propertyHolder.kubernetesClientProperties();
ConfigMapConfigProperties configMapProperties = propertyHolder.configMapConfigProperties();
SecretsConfigProperties secretsProperties = propertyHolder.secretsProperties();
ConfigurableBootstrapContext bootstrapContext = resolverContext.getBootstrapContext();
CoreV1Api coreV1Api = registerClientAndCoreV1Api(bootstrapContext, kubernetesClientProperties);
if (configMapProperties != null && configMapProperties.enabled()) {
ConfigMapPropertySourceLocator configMapPropertySourceLocator = new KubernetesClientConfigMapPropertySourceLocator(
coreV1Api, configMapProperties, namespaceProvider);
if (isRetryEnabledForConfigMap(configMapProperties)) {
configMapPropertySourceLocator = new ConfigDataRetryableConfigMapPropertySourceLocator(
configMapPropertySourceLocator, configMapProperties, new KubernetesClientConfigMapsCache());
}
registerSingle(bootstrapContext, ConfigMapPropertySourceLocator.class, configMapPropertySourceLocator,
"configDataConfigMapPropertySourceLocator");
}
if (secretsProperties != null && secretsProperties.enabled()) {
SecretsPropertySourceLocator secretsPropertySourceLocator = new KubernetesClientSecretsPropertySourceLocator(
coreV1Api, namespaceProvider, secretsProperties);
if (isRetryEnabledForSecrets(secretsProperties)) {
secretsPropertySourceLocator = new ConfigDataRetryableSecretsPropertySourceLocator(
secretsPropertySourceLocator, secretsProperties, new KubernetesClientSecretsCache());
}
registerSingle(bootstrapContext, SecretsPropertySourceLocator.class, secretsPropertySourceLocator,
"configDataSecretsPropertySourceLocator");
}
| 315
| 452
| 767
|
<methods>public void <init>(org.springframework.boot.logging.DeferredLogFactory) ,public final int getOrder() ,public final boolean isResolvable(org.springframework.boot.context.config.ConfigDataLocationResolverContext, org.springframework.boot.context.config.ConfigDataLocation) ,public final List<org.springframework.cloud.kubernetes.commons.config.KubernetesConfigDataResource> resolve(org.springframework.boot.context.config.ConfigDataLocationResolverContext, org.springframework.boot.context.config.ConfigDataLocation) throws org.springframework.boot.context.config.ConfigDataLocationNotFoundException, org.springframework.boot.context.config.ConfigDataResourceNotFoundException,public final List<org.springframework.cloud.kubernetes.commons.config.KubernetesConfigDataResource> resolveProfileSpecific(org.springframework.boot.context.config.ConfigDataLocationResolverContext, org.springframework.boot.context.config.ConfigDataLocation, org.springframework.boot.context.config.Profiles) throws org.springframework.boot.context.config.ConfigDataLocationNotFoundException<variables>private static final boolean RETRY_IS_PRESENT,private final non-sealed org.apache.commons.logging.Log log
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-config/src/main/java/org/springframework/cloud/kubernetes/client/config/KubernetesClientConfigMapPropertySource.java
|
KubernetesClientConfigMapPropertySource
|
getSourceData
|
class KubernetesClientConfigMapPropertySource extends SourceDataEntriesProcessor {
private static final EnumMap<NormalizedSourceType, KubernetesClientContextToSourceData> STRATEGIES = new EnumMap<>(
NormalizedSourceType.class);
static {
STRATEGIES.put(NormalizedSourceType.NAMED_CONFIG_MAP, namedConfigMap());
STRATEGIES.put(NormalizedSourceType.LABELED_CONFIG_MAP, labeledConfigMap());
}
public KubernetesClientConfigMapPropertySource(KubernetesClientConfigContext context) {
super(getSourceData(context));
}
private static SourceData getSourceData(KubernetesClientConfigContext context) {<FILL_FUNCTION_BODY>}
private static KubernetesClientContextToSourceData namedConfigMap() {
return new NamedConfigMapContextToSourceDataProvider().get();
}
private static KubernetesClientContextToSourceData labeledConfigMap() {
return new LabeledConfigMapContextToSourceDataProvider().get();
}
}
|
NormalizedSourceType type = context.normalizedSource().type();
return Optional.ofNullable(STRATEGIES.get(type)).map(x -> x.apply(context))
.orElseThrow(() -> new IllegalArgumentException("no strategy found for : " + type));
| 261
| 71
| 332
|
<methods>public void <init>(SourceData) ,public static Map<java.lang.String,java.lang.Object> processAllEntries(Map<java.lang.String,java.lang.String>, org.springframework.core.env.Environment) ,public static Map<java.lang.String,java.lang.Object> processAllEntries(Map<java.lang.String,java.lang.String>, org.springframework.core.env.Environment, boolean) <variables>private static Predicate<java.lang.String> ENDS_IN_EXTENSION,private static final org.apache.commons.logging.Log LOG
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-config/src/main/java/org/springframework/cloud/kubernetes/client/config/KubernetesClientConfigMapPropertySourceLocator.java
|
KubernetesClientConfigMapPropertySourceLocator
|
getMapPropertySource
|
class KubernetesClientConfigMapPropertySourceLocator extends ConfigMapPropertySourceLocator {
private final CoreV1Api coreV1Api;
private final KubernetesNamespaceProvider kubernetesNamespaceProvider;
public KubernetesClientConfigMapPropertySourceLocator(CoreV1Api coreV1Api, ConfigMapConfigProperties properties,
KubernetesNamespaceProvider kubernetesNamespaceProvider) {
super(properties, new KubernetesClientConfigMapsCache());
this.coreV1Api = coreV1Api;
this.kubernetesNamespaceProvider = kubernetesNamespaceProvider;
}
@Override
protected MapPropertySource getMapPropertySource(NormalizedSource source, ConfigurableEnvironment environment) {<FILL_FUNCTION_BODY>}
}
|
String normalizedNamespace = source.namespace().orElse(null);
String namespace = getApplicationNamespace(normalizedNamespace, source.target(), kubernetesNamespaceProvider);
KubernetesClientConfigContext context = new KubernetesClientConfigContext(coreV1Api, source, namespace,
environment);
return new KubernetesClientConfigMapPropertySource(context);
| 182
| 92
| 274
|
<methods>public void <init>(ConfigMapConfigProperties) ,public void <init>(ConfigMapConfigProperties, org.springframework.cloud.kubernetes.commons.config.ConfigMapCache) ,public PropertySource<?> locate(org.springframework.core.env.Environment) ,public Collection<PropertySource<?>> locateCollection(org.springframework.core.env.Environment) <variables>private static final org.apache.commons.logging.Log LOG,private final non-sealed org.springframework.cloud.kubernetes.commons.config.ConfigMapCache cache,protected final non-sealed ConfigMapConfigProperties properties
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-config/src/main/java/org/springframework/cloud/kubernetes/client/config/KubernetesClientConfigMapsCache.java
|
KubernetesClientConfigMapsCache
|
byNamespace
|
class KubernetesClientConfigMapsCache implements ConfigMapCache {
private static final LogAccessor LOG = new LogAccessor(LogFactory.getLog(KubernetesClientConfigMapsCache.class));
/**
* at the moment our loading of config maps is using a single thread, but might change
* in the future, thus a thread safe structure.
*/
private static final ConcurrentHashMap<String, List<StrippedSourceContainer>> CACHE = new ConcurrentHashMap<>();
@Override
public void discardAll() {
CACHE.clear();
}
static List<StrippedSourceContainer> byNamespace(CoreV1Api coreV1Api, String namespace) {<FILL_FUNCTION_BODY>}
private static List<StrippedSourceContainer> strippedConfigMaps(List<V1ConfigMap> configMaps) {
return configMaps.stream().map(configMap -> new StrippedSourceContainer(configMap.getMetadata().getLabels(),
configMap.getMetadata().getName(), configMap.getData())).collect(Collectors.toList());
}
}
|
boolean[] b = new boolean[1];
List<StrippedSourceContainer> result = CACHE.computeIfAbsent(namespace, x -> {
try {
b[0] = true;
return strippedConfigMaps(coreV1Api.listNamespacedConfigMap(namespace, null, null, null, null, null,
null, null, null, null, null, null).getItems());
}
catch (ApiException apiException) {
throw new RuntimeException(apiException.getResponseBody(), apiException);
}
});
if (b[0]) {
LOG.debug(() -> "Loaded all config maps in namespace '" + namespace + "'");
}
else {
LOG.debug(() -> "Loaded (from cache) all config maps in namespace '" + namespace + "'");
}
return result;
| 272
| 223
| 495
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-config/src/main/java/org/springframework/cloud/kubernetes/client/config/KubernetesClientConfigUtils.java
|
KubernetesClientConfigUtils
|
strippedSecrets
|
class KubernetesClientConfigUtils {
private static final Log LOG = LogFactory.getLog(KubernetesClientConfigUtils.class);
// k8s-native client already returns data from secrets as being decoded
// this flags makes sure we use it everywhere
private static final boolean DECODE = Boolean.FALSE;
private KubernetesClientConfigUtils() {
}
/**
* finds namespaces to be used for the event based reloading.
*/
public static Set<String> namespaces(KubernetesNamespaceProvider provider, ConfigReloadProperties properties,
String target) {
Set<String> namespaces = properties.namespaces();
if (namespaces.isEmpty()) {
namespaces = Set.of(getApplicationNamespace(null, target, provider));
}
LOG.debug("informer namespaces : " + namespaces);
return namespaces;
}
/**
* <pre>
* 1. read all secrets in the provided namespace
* 2. from the above, filter the ones that we care about (filter by labels)
* 3. with secret names from (2), find out if there are any profile based secrets (if profiles is not empty)
* 4. concat (2) and (3) and these are the secrets we are interested in
* 5. see if any of the secrets from (4) has a single yaml/properties file
* 6. gather all the names of the secrets (from 4) + data they hold
* </pre>
*/
static MultipleSourcesContainer secretsDataByLabels(CoreV1Api coreV1Api, String namespace,
Map<String, String> labels, Environment environment, Set<String> profiles) {
List<StrippedSourceContainer> strippedSecrets = strippedSecrets(coreV1Api, namespace);
if (strippedSecrets.isEmpty()) {
return MultipleSourcesContainer.empty();
}
return ConfigUtils.processLabeledData(strippedSecrets, environment, labels, namespace, profiles, DECODE);
}
/**
* <pre>
* 1. read all config maps in the provided namespace
* 2. from the above, filter the ones that we care about (filter by labels)
* 3. with config maps names from (2), find out if there are any profile based ones (if profiles is not empty)
* 4. concat (2) and (3) and these are the config maps we are interested in
* 5. see if any from (4) has a single yaml/properties file
* 6. gather all the names of the config maps (from 4) + data they hold
* </pre>
*/
static MultipleSourcesContainer configMapsDataByLabels(CoreV1Api coreV1Api, String namespace,
Map<String, String> labels, Environment environment, Set<String> profiles) {
List<StrippedSourceContainer> strippedConfigMaps = strippedConfigMaps(coreV1Api, namespace);
if (strippedConfigMaps.isEmpty()) {
return MultipleSourcesContainer.empty();
}
return ConfigUtils.processLabeledData(strippedConfigMaps, environment, labels, namespace, profiles, DECODE);
}
/**
* <pre>
* 1. read all secrets in the provided namespace
* 2. from the above, filter the ones that we care about (by name)
* 3. see if any of the secrets has a single yaml/properties file
* 4. gather all the names of the secrets + decoded data they hold
* </pre>
*/
static MultipleSourcesContainer secretsDataByName(CoreV1Api coreV1Api, String namespace,
LinkedHashSet<String> sourceNames, Environment environment, boolean includeDefaultProfileData) {
List<StrippedSourceContainer> strippedSecrets = strippedSecrets(coreV1Api, namespace);
if (strippedSecrets.isEmpty()) {
return MultipleSourcesContainer.empty();
}
return ConfigUtils.processNamedData(strippedSecrets, environment, sourceNames, namespace, DECODE,
includeDefaultProfileData);
}
/**
* <pre>
* 1. read all config maps in the provided namespace
* 2. from the above, filter the ones that we care about (by name)
* 3. see if any of the config maps has a single yaml/properties file
* 4. gather all the names of the config maps + data they hold
* </pre>
*/
static MultipleSourcesContainer configMapsDataByName(CoreV1Api coreV1Api, String namespace,
LinkedHashSet<String> sourceNames, Environment environment, boolean includeDefaultProfileData) {
List<StrippedSourceContainer> strippedConfigMaps = strippedConfigMaps(coreV1Api, namespace);
if (strippedConfigMaps.isEmpty()) {
return MultipleSourcesContainer.empty();
}
return ConfigUtils.processNamedData(strippedConfigMaps, environment, sourceNames, namespace, DECODE,
includeDefaultProfileData);
}
private static List<StrippedSourceContainer> strippedConfigMaps(CoreV1Api coreV1Api, String namespace) {
List<StrippedSourceContainer> strippedConfigMaps = KubernetesClientConfigMapsCache.byNamespace(coreV1Api,
namespace);
if (strippedConfigMaps.isEmpty()) {
LOG.debug("No configmaps in namespace '" + namespace + "'");
}
return strippedConfigMaps;
}
private static List<StrippedSourceContainer> strippedSecrets(CoreV1Api coreV1Api, String namespace) {<FILL_FUNCTION_BODY>}
}
|
List<StrippedSourceContainer> strippedSecrets = KubernetesClientSecretsCache.byNamespace(coreV1Api, namespace);
if (strippedSecrets.isEmpty()) {
LOG.debug("No configmaps in namespace '" + namespace + "'");
}
return strippedSecrets;
| 1,407
| 78
| 1,485
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-config/src/main/java/org/springframework/cloud/kubernetes/client/config/KubernetesClientSecretsCache.java
|
KubernetesClientSecretsCache
|
byNamespace
|
class KubernetesClientSecretsCache implements SecretsCache {
private static final LogAccessor LOG = new LogAccessor(LogFactory.getLog(KubernetesClientConfigMapsCache.class));
/**
* at the moment our loading of config maps is using a single thread, but might change
* in the future, thus a thread safe structure.
*/
private static final ConcurrentHashMap<String, List<StrippedSourceContainer>> CACHE = new ConcurrentHashMap<>();
@Override
public void discardAll() {
CACHE.clear();
}
static List<StrippedSourceContainer> byNamespace(CoreV1Api coreV1Api, String namespace) {<FILL_FUNCTION_BODY>}
private static List<StrippedSourceContainer> strippedSecrets(List<V1Secret> secrets) {
return secrets.stream().map(secret -> new StrippedSourceContainer(secret.getMetadata().getLabels(),
secret.getMetadata().getName(), transform(secret.getData()))).collect(Collectors.toList());
}
private static Map<String, String> transform(Map<String, byte[]> in) {
return ObjectUtils.isEmpty(in) ? Map.of()
: in.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new String(en.getValue())));
}
}
|
boolean[] b = new boolean[1];
List<StrippedSourceContainer> result = CACHE.computeIfAbsent(namespace, x -> {
try {
b[0] = true;
return strippedSecrets(coreV1Api.listNamespacedSecret(namespace, null, null, null, null, null, null,
null, null, null, null, null).getItems());
}
catch (ApiException apiException) {
throw new RuntimeException(apiException.getResponseBody(), apiException);
}
});
if (b[0]) {
LOG.debug(() -> "Loaded all secrets in namespace '" + namespace + "'");
}
else {
LOG.debug(() -> "Loaded (from cache) all secrets in namespace '" + namespace + "'");
}
return result;
| 339
| 219
| 558
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-config/src/main/java/org/springframework/cloud/kubernetes/client/config/KubernetesClientSecretsPropertySource.java
|
KubernetesClientSecretsPropertySource
|
getSourceData
|
class KubernetesClientSecretsPropertySource extends SecretsPropertySource {
@Deprecated(forRemoval = true)
public KubernetesClientSecretsPropertySource(SourceData sourceData) {
super(sourceData);
}
private static final EnumMap<NormalizedSourceType, KubernetesClientContextToSourceData> STRATEGIES = new EnumMap<>(
NormalizedSourceType.class);
static {
STRATEGIES.put(NormalizedSourceType.NAMED_SECRET, namedSecret());
STRATEGIES.put(NormalizedSourceType.LABELED_SECRET, labeledSecret());
}
public KubernetesClientSecretsPropertySource(KubernetesClientConfigContext context) {
super(getSourceData(context));
}
private static SourceData getSourceData(KubernetesClientConfigContext context) {<FILL_FUNCTION_BODY>}
private static KubernetesClientContextToSourceData namedSecret() {
return new NamedSecretContextToSourceDataProvider().get();
}
private static KubernetesClientContextToSourceData labeledSecret() {
return new LabeledSecretContextToSourceDataProvider().get();
}
}
|
NormalizedSourceType type = context.normalizedSource().type();
return Optional.ofNullable(STRATEGIES.get(type)).map(x -> x.apply(context))
.orElseThrow(() -> new IllegalArgumentException("no strategy found for : " + type));
| 293
| 71
| 364
|
<methods>public void <init>(SourceData) ,public java.lang.String toString() <variables>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-config/src/main/java/org/springframework/cloud/kubernetes/client/config/KubernetesClientSecretsPropertySourceLocator.java
|
KubernetesClientSecretsPropertySourceLocator
|
getPropertySource
|
class KubernetesClientSecretsPropertySourceLocator extends SecretsPropertySourceLocator {
private final CoreV1Api coreV1Api;
private final KubernetesNamespaceProvider kubernetesNamespaceProvider;
public KubernetesClientSecretsPropertySourceLocator(CoreV1Api coreV1Api,
KubernetesNamespaceProvider kubernetesNamespaceProvider, SecretsConfigProperties secretsConfigProperties) {
super(secretsConfigProperties, new KubernetesClientSecretsCache());
this.coreV1Api = coreV1Api;
this.kubernetesNamespaceProvider = kubernetesNamespaceProvider;
}
@Override
protected SecretsPropertySource getPropertySource(ConfigurableEnvironment environment, NormalizedSource source) {<FILL_FUNCTION_BODY>}
}
|
String normalizedNamespace = source.namespace().orElse(null);
String namespace = getApplicationNamespace(normalizedNamespace, source.target(), kubernetesNamespaceProvider);
KubernetesClientConfigContext context = new KubernetesClientConfigContext(coreV1Api, source, namespace,
environment);
return new KubernetesClientSecretsPropertySource(context);
| 187
| 93
| 280
|
<methods>public void <init>(SecretsConfigProperties) ,public void <init>(SecretsConfigProperties, org.springframework.cloud.kubernetes.commons.config.SecretsCache) ,public PropertySource<?> locate(org.springframework.core.env.Environment) ,public Collection<PropertySource<?>> locateCollection(org.springframework.core.env.Environment) <variables>private static final org.apache.commons.logging.Log LOG,private final non-sealed org.springframework.cloud.kubernetes.commons.config.SecretsCache cache,protected final non-sealed SecretsConfigProperties properties
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-config/src/main/java/org/springframework/cloud/kubernetes/client/config/LabeledConfigMapContextToSourceDataProvider.java
|
LabeledConfigMapContextToSourceDataProvider
|
get
|
class LabeledConfigMapContextToSourceDataProvider implements Supplier<KubernetesClientContextToSourceData> {
LabeledConfigMapContextToSourceDataProvider() {
}
/*
* Computes a ContextSourceData (think content) for configmap(s) based on some labels.
* There could be many sources that are read based on incoming labels, for which we
* will be computing a single Map<String, Object> in the end.
*
* If there is no config maps found for the provided labels, we will return an "empty"
* SourceData. Its name is going to be the concatenated labels mapped to an empty Map.
*
* If we find config maps(s) for the provided labels, its name is going to be the
* concatenated names mapped to the data they hold as a Map.
*/
@Override
public KubernetesClientContextToSourceData get() {<FILL_FUNCTION_BODY>}
}
|
return context -> {
LabeledConfigMapNormalizedSource source = (LabeledConfigMapNormalizedSource) context.normalizedSource();
return new LabeledSourceData() {
@Override
public MultipleSourcesContainer dataSupplier(Map<String, String> labels, Set<String> profiles) {
return KubernetesClientConfigUtils.configMapsDataByLabels(context.client(), context.namespace(),
labels, context.environment(), profiles);
}
}.compute(source.labels(), source.prefix(), source.target(), source.profileSpecificSources(),
source.failFast(), context.namespace(), context.environment().getActiveProfiles());
};
| 228
| 173
| 401
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-config/src/main/java/org/springframework/cloud/kubernetes/client/config/LabeledSecretContextToSourceDataProvider.java
|
LabeledSecretContextToSourceDataProvider
|
get
|
class LabeledSecretContextToSourceDataProvider implements Supplier<KubernetesClientContextToSourceData> {
LabeledSecretContextToSourceDataProvider() {
}
/*
* Computes a ContextSourceData (think content) for secret(s) based on some labels.
* There could be many secrets that are read based on incoming labels, for which we
* will be computing a single Map<String, Object> in the end.
*
* If there is no secret found for the provided labels, we will return an "empty"
* SourceData. Its name is going to be the concatenated labels mapped to an empty Map.
*
* If we find secret(s) for the provided labels, its name is going to be the
* concatenated secret names mapped to the data they hold as a Map.
*/
@Override
public KubernetesClientContextToSourceData get() {<FILL_FUNCTION_BODY>}
}
|
return context -> {
LabeledSecretNormalizedSource source = (LabeledSecretNormalizedSource) context.normalizedSource();
return new LabeledSourceData() {
@Override
public MultipleSourcesContainer dataSupplier(Map<String, String> labels, Set<String> profiles) {
return KubernetesClientConfigUtils.secretsDataByLabels(context.client(), context.namespace(),
labels, context.environment(), profiles);
}
}.compute(source.labels(), source.prefix(), source.target(), source.profileSpecificSources(),
source.failFast(), context.namespace(), context.environment().getActiveProfiles());
};
| 225
| 169
| 394
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-config/src/main/java/org/springframework/cloud/kubernetes/client/config/NamedConfigMapContextToSourceDataProvider.java
|
NamedConfigMapContextToSourceDataProvider
|
get
|
class NamedConfigMapContextToSourceDataProvider implements Supplier<KubernetesClientContextToSourceData> {
NamedConfigMapContextToSourceDataProvider() {
}
@Override
public KubernetesClientContextToSourceData get() {<FILL_FUNCTION_BODY>}
}
|
return context -> {
NamedConfigMapNormalizedSource source = (NamedConfigMapNormalizedSource) context.normalizedSource();
return new NamedSourceData() {
@Override
protected String generateSourceName(String target, String sourceName, String namespace,
String[] activeProfiles) {
if (source.appendProfileToName()) {
return ConfigUtils.sourceName(target, sourceName, namespace, activeProfiles);
}
return super.generateSourceName(target, sourceName, namespace, activeProfiles);
}
@Override
public MultipleSourcesContainer dataSupplier(LinkedHashSet<String> sourceNames) {
return KubernetesClientConfigUtils.configMapsDataByName(context.client(), context.namespace(),
sourceNames, context.environment(), context.includeDefaultProfileData());
}
}.compute(source.name().orElseThrow(), source.prefix(), source.target(), source.profileSpecificSources(),
source.failFast(), context.namespace(), context.environment().getActiveProfiles());
};
| 72
| 267
| 339
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-config/src/main/java/org/springframework/cloud/kubernetes/client/config/NamedSecretContextToSourceDataProvider.java
|
NamedSecretContextToSourceDataProvider
|
get
|
class NamedSecretContextToSourceDataProvider implements Supplier<KubernetesClientContextToSourceData> {
NamedSecretContextToSourceDataProvider() {
}
@Override
public KubernetesClientContextToSourceData get() {<FILL_FUNCTION_BODY>}
}
|
return context -> {
NamedSecretNormalizedSource source = (NamedSecretNormalizedSource) context.normalizedSource();
return new NamedSourceData() {
@Override
protected String generateSourceName(String target, String sourceName, String namespace,
String[] activeProfiles) {
if (source.appendProfileToName()) {
return ConfigUtils.sourceName(target, sourceName, namespace, activeProfiles);
}
return super.generateSourceName(target, sourceName, namespace, activeProfiles);
}
@Override
public MultipleSourcesContainer dataSupplier(LinkedHashSet<String> sourceNames) {
return KubernetesClientConfigUtils.secretsDataByName(context.client(), context.namespace(),
sourceNames, context.environment(), context.includeDefaultProfileData());
}
}.compute(source.name().orElseThrow(), source.prefix(), source.target(), source.profileSpecificSources(),
source.failFast(), context.namespace(), context.environment().getActiveProfiles());
};
| 70
| 263
| 333
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-config/src/main/java/org/springframework/cloud/kubernetes/client/config/reload/KubernetesClientEventBasedConfigMapChangeDetector.java
|
KubernetesClientEventBasedConfigMapChangeDetector
|
onDelete
|
class KubernetesClientEventBasedConfigMapChangeDetector extends ConfigurationChangeDetector {
private static final LogAccessor LOG = new LogAccessor(
LogFactory.getLog(KubernetesClientEventBasedConfigMapChangeDetector.class));
private final CoreV1Api coreV1Api;
private final KubernetesClientConfigMapPropertySourceLocator propertySourceLocator;
private final ApiClient apiClient;
private final List<SharedIndexInformer<V1ConfigMap>> informers = new ArrayList<>();
private final List<SharedInformerFactory> factories = new ArrayList<>();
private final Set<String> namespaces;
private final boolean enableReloadFiltering;
private final ResourceEventHandler<V1ConfigMap> handler = new ResourceEventHandler<>() {
@Override
public void onAdd(V1ConfigMap configMap) {
LOG.debug(() -> "ConfigMap " + configMap.getMetadata().getName() + " was added in namespace "
+ configMap.getMetadata().getNamespace());
onEvent(configMap);
}
@Override
public void onUpdate(V1ConfigMap oldConfigMap, V1ConfigMap newConfigMap) {
LOG.debug(() -> "ConfigMap " + newConfigMap.getMetadata().getName() + " was updated in namespace "
+ newConfigMap.getMetadata().getNamespace());
if (Objects.equals(oldConfigMap.getData(), newConfigMap.getData())) {
LOG.debug(() -> "data in configmap has not changed, will not reload");
}
else {
onEvent(newConfigMap);
}
}
@Override
public void onDelete(V1ConfigMap configMap, boolean deletedFinalStateUnknown) {<FILL_FUNCTION_BODY>}
};
public KubernetesClientEventBasedConfigMapChangeDetector(CoreV1Api coreV1Api, ConfigurableEnvironment environment,
ConfigReloadProperties properties, ConfigurationUpdateStrategy strategy,
KubernetesClientConfigMapPropertySourceLocator propertySourceLocator,
KubernetesNamespaceProvider kubernetesNamespaceProvider) {
super(environment, properties, strategy);
this.propertySourceLocator = propertySourceLocator;
this.coreV1Api = coreV1Api;
this.apiClient = createApiClientForInformerClient();
this.enableReloadFiltering = properties.enableReloadFiltering();
namespaces = namespaces(kubernetesNamespaceProvider, properties, "configmap");
}
@PostConstruct
void inform() {
LOG.info(() -> "Kubernetes event-based configMap change detector activated");
namespaces.forEach(namespace -> {
SharedIndexInformer<V1ConfigMap> informer;
String[] filter = new String[1];
if (enableReloadFiltering) {
filter[0] = ConfigReloadProperties.RELOAD_LABEL_FILTER + "=true";
}
SharedInformerFactory factory = new SharedInformerFactory(apiClient);
factories.add(factory);
informer = factory
.sharedIndexInformerFor(
(CallGeneratorParams params) -> coreV1Api.listNamespacedConfigMapCall(namespace, null, null,
null, null, filter[0], null, params.resourceVersion, null, null,
params.timeoutSeconds, params.watch, null),
V1ConfigMap.class, V1ConfigMapList.class);
LOG.debug(() -> "added configmap informer for namespace : " + namespace + " with filter : " + filter[0]);
informer.addEventHandler(handler);
informers.add(informer);
factory.startAllRegisteredInformers();
});
}
@PreDestroy
void shutdown() {
informers.forEach(SharedIndexInformer::stop);
factories.forEach(SharedInformerFactory::stopAllRegisteredInformers);
}
protected void onEvent(KubernetesObject configMap) {
boolean reload = ConfigReloadUtil.reload("config-map", configMap.toString(), propertySourceLocator, environment,
KubernetesClientConfigMapPropertySource.class);
if (reload) {
reloadProperties();
}
}
}
|
LOG.debug(() -> "ConfigMap " + configMap.getMetadata().getName() + " was deleted in namespace "
+ configMap.getMetadata().getNamespace());
onEvent(configMap);
| 1,063
| 53
| 1,116
|
<methods>public void <init>(org.springframework.core.env.ConfigurableEnvironment, ConfigReloadProperties, ConfigurationUpdateStrategy) ,public void reloadProperties() <variables>private static final org.springframework.core.log.LogAccessor LOG,protected org.springframework.core.env.ConfigurableEnvironment environment,protected ConfigReloadProperties properties,protected ConfigurationUpdateStrategy strategy
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-config/src/main/java/org/springframework/cloud/kubernetes/client/config/reload/KubernetesClientEventBasedSecretsChangeDetector.java
|
KubernetesClientEventBasedSecretsChangeDetector
|
onDelete
|
class KubernetesClientEventBasedSecretsChangeDetector extends ConfigurationChangeDetector {
private static final LogAccessor LOG = new LogAccessor(
LogFactory.getLog(KubernetesClientEventBasedSecretsChangeDetector.class));
private final CoreV1Api coreV1Api;
private final KubernetesClientSecretsPropertySourceLocator propertySourceLocator;
private final ApiClient apiClient;
private final List<SharedIndexInformer<V1Secret>> informers = new ArrayList<>();
private final List<SharedInformerFactory> factories = new ArrayList<>();
private final Set<String> namespaces;
private final boolean enableReloadFiltering;
private final ResourceEventHandler<V1Secret> handler = new ResourceEventHandler<>() {
@Override
public void onAdd(V1Secret secret) {
LOG.debug(() -> "Secret " + secret.getMetadata().getName() + " was added in namespace "
+ secret.getMetadata().getNamespace());
onEvent(secret);
}
@Override
public void onUpdate(V1Secret oldSecret, V1Secret newSecret) {
LOG.debug(() -> "Secret " + newSecret.getMetadata().getName() + " was updated in namespace "
+ newSecret.getMetadata().getNamespace());
if (KubernetesClientEventBasedSecretsChangeDetector.equals(oldSecret.getData(), newSecret.getData())) {
LOG.debug(() -> "data in secret has not changed, will not reload");
}
else {
onEvent(newSecret);
}
}
@Override
public void onDelete(V1Secret secret, boolean deletedFinalStateUnknown) {<FILL_FUNCTION_BODY>}
};
public KubernetesClientEventBasedSecretsChangeDetector(CoreV1Api coreV1Api, ConfigurableEnvironment environment,
ConfigReloadProperties properties, ConfigurationUpdateStrategy strategy,
KubernetesClientSecretsPropertySourceLocator propertySourceLocator,
KubernetesNamespaceProvider kubernetesNamespaceProvider) {
super(environment, properties, strategy);
this.propertySourceLocator = propertySourceLocator;
this.coreV1Api = coreV1Api;
this.apiClient = createApiClientForInformerClient();
this.enableReloadFiltering = properties.enableReloadFiltering();
namespaces = namespaces(kubernetesNamespaceProvider, properties, "secret");
}
@PostConstruct
void inform() {
LOG.info(() -> "Kubernetes event-based secrets change detector activated");
namespaces.forEach(namespace -> {
SharedIndexInformer<V1Secret> informer;
String[] filter = new String[1];
if (enableReloadFiltering) {
filter[0] = ConfigReloadProperties.RELOAD_LABEL_FILTER + "=true";
}
SharedInformerFactory factory = new SharedInformerFactory(apiClient);
factories.add(factory);
informer = factory.sharedIndexInformerFor(
(CallGeneratorParams params) -> coreV1Api.listNamespacedSecretCall(namespace, null, null, null,
null, filter[0], null, params.resourceVersion, null, null, params.timeoutSeconds,
params.watch, null),
V1Secret.class, V1SecretList.class);
LOG.debug(() -> "added secret informer for namespace : " + namespace + " with filter : " + filter[0]);
informer.addEventHandler(handler);
informers.add(informer);
factory.startAllRegisteredInformers();
});
}
@PreDestroy
void shutdown() {
informers.forEach(SharedIndexInformer::stop);
factories.forEach(SharedInformerFactory::stopAllRegisteredInformers);
}
protected void onEvent(KubernetesObject secret) {
boolean reload = ConfigReloadUtil.reload("secrets", secret.toString(), propertySourceLocator, environment,
KubernetesClientSecretsPropertySource.class);
if (reload) {
reloadProperties();
}
}
static boolean equals(Map<String, byte[]> left, Map<String, byte[]> right) {
Map<String, byte[]> innerLeft = Optional.ofNullable(left).orElse(Map.of());
Map<String, byte[]> innerRight = Optional.ofNullable(right).orElse(Map.of());
if (innerLeft.size() != innerRight.size()) {
return false;
}
for (Map.Entry<String, byte[]> entry : innerLeft.entrySet()) {
String key = entry.getKey();
byte[] value = entry.getValue();
if (!Arrays.equals(value, innerRight.get(key))) {
return false;
}
}
return true;
}
}
|
LOG.debug(() -> "Secret " + secret.getMetadata().getName() + " was deleted in namespace "
+ secret.getMetadata().getNamespace());
onEvent(secret);
| 1,230
| 49
| 1,279
|
<methods>public void <init>(org.springframework.core.env.ConfigurableEnvironment, ConfigReloadProperties, ConfigurationUpdateStrategy) ,public void reloadProperties() <variables>private static final org.springframework.core.log.LogAccessor LOG,protected org.springframework.core.env.ConfigurableEnvironment environment,protected ConfigReloadProperties properties,protected ConfigurationUpdateStrategy strategy
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-discovery/src/main/java/org/springframework/cloud/kubernetes/client/discovery/ConditionalOnSelectiveNamespacesMissing.java
|
ConditionalOnSelectiveNamespacesMissing
|
matches
|
class ConditionalOnSelectiveNamespacesMissing implements ConfigurationCondition {
private static final LogAccessor LOG = new LogAccessor(
LogFactory.getLog(ConditionalOnSelectiveNamespacesMissing.class));
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {<FILL_FUNCTION_BODY>}
@Override
public ConfigurationPhase getConfigurationPhase() {
return ConfigurationPhase.REGISTER_BEAN;
}
}
|
Set<String> selectiveNamespaces = Binder.get(context.getEnvironment())
.bind("spring.cloud.kubernetes.discovery.namespaces", Bindable.setOf(String.class)).orElse(Set.of());
boolean selectiveNamespacesMissing = selectiveNamespaces.isEmpty();
if (selectiveNamespacesMissing) {
LOG.debug(() -> "selective namespaces not present");
}
else {
LOG.debug(() -> "found selective namespaces : " + selectiveNamespaces.stream().sorted().toList());
}
return selectiveNamespacesMissing;
| 116
| 159
| 275
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-discovery/src/main/java/org/springframework/cloud/kubernetes/client/discovery/ConditionalOnSelectiveNamespacesPresent.java
|
ConditionalOnSelectiveNamespacesPresent
|
matches
|
class ConditionalOnSelectiveNamespacesPresent implements ConfigurationCondition {
private static final LogAccessor LOG = new LogAccessor(
LogFactory.getLog(ConditionalOnSelectiveNamespacesPresent.class));
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {<FILL_FUNCTION_BODY>}
@Override
public ConfigurationCondition.ConfigurationPhase getConfigurationPhase() {
return ConfigurationPhase.REGISTER_BEAN;
}
}
|
Set<String> selectiveNamespaces = Binder.get(context.getEnvironment())
.bind("spring.cloud.kubernetes.discovery.namespaces", Bindable.setOf(String.class)).orElse(Set.of());
boolean selectiveNamespacesPresent = !selectiveNamespaces.isEmpty();
if (selectiveNamespacesPresent) {
LOG.debug(() -> "found selective namespaces : " + selectiveNamespaces.stream().sorted().toList());
}
else {
LOG.debug(() -> "selective namespaces not present");
}
return selectiveNamespacesPresent;
| 119
| 160
| 279
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-discovery/src/main/java/org/springframework/cloud/kubernetes/client/discovery/K8sPodLabelsAndAnnotationsSupplier.java
|
K8sPodLabelsAndAnnotationsSupplier
|
apply
|
class K8sPodLabelsAndAnnotationsSupplier implements Function<String, PodLabelsAndAnnotations> {
private static final LogAccessor LOG = new LogAccessor(LogFactory.getLog(K8sPodLabelsAndAnnotationsSupplier.class));
private final CoreV1Api coreV1Api;
private final String namespace;
private K8sPodLabelsAndAnnotationsSupplier(CoreV1Api coreV1Api, String namespace) {
this.coreV1Api = coreV1Api;
this.namespace = namespace;
}
/**
* to be used when .spec.type of the Service is != 'ExternalName'.
*/
static K8sPodLabelsAndAnnotationsSupplier nonExternalName(CoreV1Api coreV1Api, String namespace) {
return new K8sPodLabelsAndAnnotationsSupplier(coreV1Api, namespace);
}
/**
* to be used when .spec.type of the Service is == 'ExternalName'.
*/
static K8sPodLabelsAndAnnotationsSupplier externalName() {
return new K8sPodLabelsAndAnnotationsSupplier(null, null);
}
@Override
public PodLabelsAndAnnotations apply(String podName) {<FILL_FUNCTION_BODY>}
}
|
V1ObjectMeta objectMeta;
try {
objectMeta = Optional.ofNullable(coreV1Api.readNamespacedPod(podName, namespace, null).getMetadata())
.orElse(new V1ObjectMetaBuilder().withLabels(Map.of()).withAnnotations(Map.of()).build());
}
catch (ApiException e) {
LOG.warn(e, "Could not get pod metadata");
objectMeta = new V1ObjectMetaBuilder().withLabels(Map.of()).withAnnotations(Map.of()).build();
}
return new PodLabelsAndAnnotations(Optional.ofNullable(objectMeta.getLabels()).orElse(Map.of()),
Optional.ofNullable(objectMeta.getAnnotations()).orElse(Map.of()));
| 316
| 202
| 518
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-discovery/src/main/java/org/springframework/cloud/kubernetes/client/discovery/KubernetesClientConfigServerBootstrapper.java
|
KubernetesClientConfigServerBootstrapper
|
initialize
|
class KubernetesClientConfigServerBootstrapper extends KubernetesConfigServerBootstrapper {
private static final Log LOG = LogFactory.getLog(KubernetesClientConfigServerBootstrapper.class);
@Override
public void initialize(BootstrapRegistry registry) {<FILL_FUNCTION_BODY>}
private String getInformerNamespace(KubernetesNamespaceProvider kubernetesNamespaceProvider,
KubernetesDiscoveryProperties discoveryProperties) {
return discoveryProperties.allNamespaces() ? Namespaces.NAMESPACE_ALL
: kubernetesNamespaceProvider.getNamespace() == null ? Namespaces.NAMESPACE_DEFAULT
: kubernetesNamespaceProvider.getNamespace();
}
private Environment getNamespaceEnvironment(
ConfigServerConfigDataLocationResolver.PropertyResolver propertyResolver) {
return new AbstractEnvironment() {
@Override
public String getProperty(String key) {
return propertyResolver.get(key, String.class, super.getProperty(key));
}
};
}
}
|
if (hasConfigServerInstanceProvider()) {
return;
}
registry.registerIfAbsent(KubernetesDiscoveryProperties.class, context -> {
if (!getDiscoveryEnabled(context)) {
return null;
}
return createKubernetesDiscoveryProperties(context);
});
registry.registerIfAbsent(KubernetesClientProperties.class, context -> {
if (!getDiscoveryEnabled(context)) {
return null;
}
return createKubernetesClientProperties(context);
});
registry.registerIfAbsent(ConfigServerInstanceProvider.Function.class, context -> {
if (!getDiscoveryEnabled(context)) {
return (id) -> Collections.emptyList();
}
if (context.isRegistered(KubernetesInformerDiscoveryClient.class)) {
KubernetesInformerDiscoveryClient client = context.get(KubernetesInformerDiscoveryClient.class);
return client::getInstances;
}
else {
PropertyResolver propertyResolver = getPropertyResolver(context);
ApiClient defaultApiClient = kubernetesApiClient();
defaultApiClient.setUserAgent(propertyResolver.get("spring.cloud.kubernetes.client.user-agent",
String.class, KubernetesClientProperties.DEFAULT_USER_AGENT));
KubernetesClientAutoConfiguration clientAutoConfiguration = new KubernetesClientAutoConfiguration();
ApiClient apiClient = context.getOrElseSupply(ApiClient.class, () -> defaultApiClient);
KubernetesNamespaceProvider kubernetesNamespaceProvider = clientAutoConfiguration
.kubernetesNamespaceProvider(getNamespaceEnvironment(propertyResolver));
KubernetesDiscoveryProperties discoveryProperties = context.get(KubernetesDiscoveryProperties.class);
String namespace = getInformerNamespace(kubernetesNamespaceProvider, discoveryProperties);
SharedInformerFactory sharedInformerFactory = new SharedInformerFactory(apiClient);
GenericKubernetesApi<V1Service, V1ServiceList> servicesApi = new GenericKubernetesApi<>(V1Service.class,
V1ServiceList.class, "", "v1", "services", apiClient);
SharedIndexInformer<V1Service> serviceSharedIndexInformer = sharedInformerFactory
.sharedIndexInformerFor(servicesApi, V1Service.class, 0L, namespace);
Lister<V1Service> serviceLister = new Lister<>(serviceSharedIndexInformer.getIndexer());
GenericKubernetesApi<V1Endpoints, V1EndpointsList> endpointsApi = new GenericKubernetesApi<>(
V1Endpoints.class, V1EndpointsList.class, "", "v1", "endpoints", apiClient);
SharedIndexInformer<V1Endpoints> endpointsSharedIndexInformer = sharedInformerFactory
.sharedIndexInformerFor(endpointsApi, V1Endpoints.class, 0L, namespace);
Lister<V1Endpoints> endpointsLister = new Lister<>(endpointsSharedIndexInformer.getIndexer());
KubernetesInformerDiscoveryClient discoveryClient = new KubernetesInformerDiscoveryClient(
sharedInformerFactory, serviceLister, endpointsLister, serviceSharedIndexInformer,
endpointsSharedIndexInformer, discoveryProperties);
try {
discoveryClient.afterPropertiesSet();
return discoveryClient::getInstances;
}
catch (Exception e) {
LOG.warn("Error initiating informer discovery client", e);
return (serviceId) -> Collections.emptyList();
}
finally {
sharedInformerFactory.stopAllRegisteredInformers();
}
}
});
| 246
| 929
| 1,175
|
<methods>public non-sealed void <init>() ,public static KubernetesClientProperties createKubernetesClientProperties(org.springframework.boot.context.properties.bind.Binder, org.springframework.boot.context.properties.bind.BindHandler) ,public static KubernetesClientProperties createKubernetesClientProperties(org.springframework.boot.BootstrapContext) ,public static KubernetesDiscoveryProperties createKubernetesDiscoveryProperties(org.springframework.boot.context.properties.bind.Binder, org.springframework.boot.context.properties.bind.BindHandler) ,public static KubernetesDiscoveryProperties createKubernetesDiscoveryProperties(org.springframework.boot.BootstrapContext) ,public static java.lang.Boolean getDiscoveryEnabled(org.springframework.boot.context.properties.bind.Binder, org.springframework.boot.context.properties.bind.BindHandler) ,public static java.lang.Boolean getDiscoveryEnabled(org.springframework.boot.BootstrapContext) ,public static boolean hasConfigServerInstanceProvider() <variables>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-discovery/src/main/java/org/springframework/cloud/kubernetes/client/discovery/KubernetesClientInformerAutoConfiguration.java
|
KubernetesClientInformerAutoConfiguration
|
kubernetesClientNamespace
|
class KubernetesClientInformerAutoConfiguration {
private static final LogAccessor LOG = new LogAccessor(
LogFactory.getLog(KubernetesClientInformerAutoConfiguration.class));
@Bean
@ConditionalOnMissingBean
public SharedInformerFactory sharedInformerFactory(ApiClient client) {
LOG.debug(() -> "registering sharedInformerFactory for non-selective namespaces");
return new SharedInformerFactory(client);
}
@Bean
public String kubernetesClientNamespace(KubernetesDiscoveryProperties properties,
KubernetesNamespaceProvider provider) {<FILL_FUNCTION_BODY>}
@Bean
@ConditionalOnMissingBean(value = V1Service.class, parameterizedContainer = SharedIndexInformer.class)
public SharedIndexInformer<V1Service> servicesSharedIndexInformer(SharedInformerFactory sharedInformerFactory,
ApiClient apiClient, String kubernetesClientNamespace) {
GenericKubernetesApi<V1Service, V1ServiceList> servicesApi = new GenericKubernetesApi<>(V1Service.class,
V1ServiceList.class, "", "v1", "services", apiClient);
return sharedInformerFactory.sharedIndexInformerFor(servicesApi, V1Service.class, 0L,
kubernetesClientNamespace);
}
@Bean
@ConditionalOnMissingBean(value = V1Endpoints.class, parameterizedContainer = SharedIndexInformer.class)
public SharedIndexInformer<V1Endpoints> endpointsSharedIndexInformer(SharedInformerFactory sharedInformerFactory,
ApiClient apiClient, String kubernetesClientNamespace) {
GenericKubernetesApi<V1Endpoints, V1EndpointsList> servicesApi = new GenericKubernetesApi<>(V1Endpoints.class,
V1EndpointsList.class, "", "v1", "endpoints", apiClient);
return sharedInformerFactory.sharedIndexInformerFor(servicesApi, V1Endpoints.class, 0L,
kubernetesClientNamespace);
}
@Bean
@ConditionalOnMissingBean(value = V1Service.class, parameterizedContainer = Lister.class)
public Lister<V1Service> servicesLister(SharedIndexInformer<V1Service> servicesSharedIndexInformer,
String kubernetesClientNamespace) {
return new Lister<>(servicesSharedIndexInformer.getIndexer(), kubernetesClientNamespace);
}
@Bean
@ConditionalOnMissingBean(value = V1Endpoints.class, parameterizedContainer = Lister.class)
public Lister<V1Endpoints> endpointsLister(SharedIndexInformer<V1Endpoints> endpointsSharedIndexInformer,
String kubernetesClientNamespace) {
return new Lister<>(endpointsSharedIndexInformer.getIndexer(), kubernetesClientNamespace);
}
}
|
String namespace;
if (properties.allNamespaces()) {
namespace = NAMESPACE_ALL;
LOG.debug(() -> "serviceSharedInformer will use all-namespaces");
}
else {
try {
namespace = getApplicationNamespace(null, "kubernetes client discovery", provider);
}
catch (NamespaceResolutionFailedException ex) {
LOG.warn(() -> "failed to resolve namespace, defaulting to :" + NAMESPACE_DEFAULT
+ ". This will fail in a future release.");
namespace = NAMESPACE_DEFAULT;
}
LOG.debug("serviceSharedInformer will use namespace : " + namespace);
}
return namespace;
| 704
| 182
| 886
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-discovery/src/main/java/org/springframework/cloud/kubernetes/client/discovery/KubernetesClientInformerSelectiveNamespacesAutoConfiguration.java
|
KubernetesClientInformerSelectiveNamespacesAutoConfiguration
|
sharedInformerFactories
|
class KubernetesClientInformerSelectiveNamespacesAutoConfiguration {
private static final LogAccessor LOG = new LogAccessor(
LogFactory.getLog(KubernetesClientInformerSelectiveNamespacesAutoConfiguration.class));
// we rely on the order of namespaces to enable listers, as such provide a bean of
// namespaces as a list, instead of the incoming Set.
@Bean
public List<String> selectiveNamespaces(KubernetesDiscoveryProperties properties) {
List<String> selectiveNamespaces = properties.namespaces().stream().sorted().toList();
LOG.debug(() -> "using selective namespaces : " + selectiveNamespaces);
return selectiveNamespaces;
}
@Bean
@ConditionalOnMissingBean(value = SharedInformerFactory.class, parameterizedContainer = List.class)
public List<SharedInformerFactory> sharedInformerFactories(ApiClient apiClient, List<String> selectiveNamespaces) {<FILL_FUNCTION_BODY>}
@Bean
@ConditionalOnMissingBean(value = V1Service.class,
parameterizedContainer = { List.class, SharedIndexInformer.class })
public List<SharedIndexInformer<V1Service>> serviceSharedIndexInformers(
List<SharedInformerFactory> sharedInformerFactories, List<String> selectiveNamespaces,
ApiClient apiClient) {
int howManyNamespaces = selectiveNamespaces.size();
List<SharedIndexInformer<V1Service>> serviceSharedIndexedInformers = new ArrayList<>(howManyNamespaces);
for (int i = 0; i < howManyNamespaces; ++i) {
GenericKubernetesApi<V1Service, V1ServiceList> servicesApi = new GenericKubernetesApi<>(V1Service.class,
V1ServiceList.class, "", "v1", "services", apiClient);
SharedIndexInformer<V1Service> sharedIndexInformer = sharedInformerFactories.get(i)
.sharedIndexInformerFor(servicesApi, V1Service.class, 0L, selectiveNamespaces.get(i));
serviceSharedIndexedInformers.add(sharedIndexInformer);
}
return serviceSharedIndexedInformers;
}
@Bean
@ConditionalOnMissingBean(value = V1Service.class, parameterizedContainer = { List.class, Lister.class })
public List<Lister<V1Service>> serviceListers(List<String> selectiveNamespaces,
List<SharedIndexInformer<V1Service>> serviceSharedIndexInformers) {
int howManyNamespaces = selectiveNamespaces.size();
List<Lister<V1Service>> serviceListers = new ArrayList<>(howManyNamespaces);
for (int i = 0; i < howManyNamespaces; ++i) {
String namespace = selectiveNamespaces.get(i);
Lister<V1Service> lister = new Lister<>(serviceSharedIndexInformers.get(i).getIndexer(), namespace);
LOG.debug(() -> "registering lister (for services) in namespace : " + namespace);
serviceListers.add(lister);
}
return serviceListers;
}
@Bean
@ConditionalOnMissingBean(value = V1Endpoints.class,
parameterizedContainer = { List.class, SharedIndexInformer.class })
public List<SharedIndexInformer<V1Endpoints>> endpointsSharedIndexInformers(
List<SharedInformerFactory> sharedInformerFactories, List<String> selectiveNamespaces,
ApiClient apiClient) {
int howManyNamespaces = selectiveNamespaces.size();
List<SharedIndexInformer<V1Endpoints>> endpointsSharedIndexedInformers = new ArrayList<>(howManyNamespaces);
for (int i = 0; i < howManyNamespaces; ++i) {
GenericKubernetesApi<V1Endpoints, V1EndpointsList> endpointsApi = new GenericKubernetesApi<>(
V1Endpoints.class, V1EndpointsList.class, "", "v1", "endpoints", apiClient);
SharedIndexInformer<V1Endpoints> sharedIndexInformer = sharedInformerFactories.get(i)
.sharedIndexInformerFor(endpointsApi, V1Endpoints.class, 0L, selectiveNamespaces.get(i));
endpointsSharedIndexedInformers.add(sharedIndexInformer);
}
return endpointsSharedIndexedInformers;
}
@Bean
@ConditionalOnMissingBean(value = V1Endpoints.class, parameterizedContainer = { List.class, Lister.class })
public List<Lister<V1Endpoints>> endpointsListers(List<String> selectiveNamespaces,
List<SharedIndexInformer<V1Endpoints>> serviceSharedIndexInformers) {
int howManyNamespaces = selectiveNamespaces.size();
List<Lister<V1Endpoints>> endpointsListers = new ArrayList<>(howManyNamespaces);
for (int i = 0; i < howManyNamespaces; ++i) {
String namespace = selectiveNamespaces.get(i);
Lister<V1Endpoints> lister = new Lister<>(serviceSharedIndexInformers.get(i).getIndexer());
LOG.debug(() -> "registering lister (for endpoints) in namespace : " + namespace);
endpointsListers.add(lister);
}
return endpointsListers;
}
}
|
int howManyNamespaces = selectiveNamespaces.size();
List<SharedInformerFactory> sharedInformerFactories = new ArrayList<>(howManyNamespaces);
for (int i = 0; i < howManyNamespaces; ++i) {
sharedInformerFactories.add(new SharedInformerFactory(apiClient));
}
return sharedInformerFactories;
| 1,372
| 97
| 1,469
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-discovery/src/main/java/org/springframework/cloud/kubernetes/client/discovery/KubernetesDiscoveryClientUtils.java
|
KubernetesDiscoveryClientUtils
|
filter
|
class KubernetesDiscoveryClientUtils {
private static final LogAccessor LOG = new LogAccessor(LogFactory.getLog(KubernetesDiscoveryClientUtils.class));
private static final SpelExpressionParser PARSER = new SpelExpressionParser();
private static final SimpleEvaluationContext EVALUATION_CONTEXT = SimpleEvaluationContext.forReadOnlyDataBinding()
.withInstanceMethods().build();
private KubernetesDiscoveryClientUtils() {
}
static boolean matchesServiceLabels(V1Service service, KubernetesDiscoveryProperties properties) {
Map<String, String> propertiesServiceLabels = properties.serviceLabels();
Map<String, String> serviceLabels = Optional.ofNullable(service.getMetadata()).map(V1ObjectMeta::getLabels)
.orElse(Map.of());
if (propertiesServiceLabels.isEmpty()) {
LOG.debug(() -> "service labels from properties are empty, service with name : '"
+ service.getMetadata().getName() + "' will match");
return true;
}
if (serviceLabels.isEmpty()) {
LOG.debug(() -> "service with name : '" + service.getMetadata().getName() + "' does not have labels");
return false;
}
LOG.debug(() -> "Service labels from properties : " + propertiesServiceLabels);
LOG.debug(() -> "Service labels from service : " + serviceLabels);
return serviceLabels.entrySet().containsAll(propertiesServiceLabels.entrySet());
}
static Predicate<V1Service> filter(KubernetesDiscoveryProperties properties) {<FILL_FUNCTION_BODY>}
static void postConstruct(List<SharedInformerFactory> sharedInformerFactories,
KubernetesDiscoveryProperties properties, Supplier<Boolean> informersReadyFunc,
List<Lister<V1Service>> serviceListers) {
sharedInformerFactories.forEach(SharedInformerFactory::startAllRegisteredInformers);
if (!Wait.poll(Duration.ofSeconds(1), Duration.ofSeconds(properties.cacheLoadingTimeoutSeconds()), () -> {
LOG.info(() -> "Waiting for the cache of informers to be fully loaded..");
return informersReadyFunc.get();
})) {
if (properties.waitCacheReady()) {
throw new IllegalStateException(
"Timeout waiting for informers cache to be ready, is the kubernetes service up?");
}
else {
LOG.warn(() -> "Timeout waiting for informers cache to be ready, "
+ "ignoring the failure because waitForInformerCacheReady property is false");
}
}
else {
LOG.info(() -> "Cache fully loaded (total " + serviceListers.stream().mapToLong(x -> x.list().size()).sum()
+ " services), discovery client is now available");
}
}
static ServiceMetadata serviceMetadata(V1Service service) {
V1ObjectMeta metadata = service.getMetadata();
V1ServiceSpec serviceSpec = service.getSpec();
return new ServiceMetadata(metadata.getName(), metadata.getNamespace(), serviceSpec.getType(),
metadata.getLabels(), metadata.getAnnotations());
}
/**
* a service is allowed to have a single port defined without a name.
*/
static Map<String, Integer> endpointSubsetsPortData(List<V1EndpointSubset> endpointSubsets) {
return endpointSubsets.stream()
.flatMap(endpointSubset -> Optional.ofNullable(endpointSubset.getPorts()).orElse(List.of()).stream())
.collect(Collectors.toMap(
endpointPort -> hasText(endpointPort.getName()) ? endpointPort.getName() : UNSET_PORT_NAME,
CoreV1EndpointPort::getPort));
}
static List<V1EndpointAddress> addresses(V1EndpointSubset endpointSubset,
KubernetesDiscoveryProperties properties) {
List<V1EndpointAddress> addresses = Optional.ofNullable(endpointSubset.getAddresses()).map(ArrayList::new)
.orElse(new ArrayList<>());
if (properties.includeNotReadyAddresses()) {
List<V1EndpointAddress> notReadyAddresses = endpointSubset.getNotReadyAddresses();
if (CollectionUtils.isEmpty(notReadyAddresses)) {
return addresses;
}
addresses.addAll(notReadyAddresses);
}
return addresses;
}
}
|
String spelExpression = properties.filter();
Predicate<V1Service> predicate;
if (spelExpression == null || spelExpression.isEmpty()) {
LOG.debug(() -> "filter not defined, returning always true predicate");
predicate = service -> true;
}
else {
Expression filterExpr = PARSER.parseExpression(spelExpression);
predicate = service -> {
Boolean include = filterExpr.getValue(EVALUATION_CONTEXT, service, Boolean.class);
return Optional.ofNullable(include).orElse(false);
};
LOG.debug(() -> "returning predicate based on filter expression: " + spelExpression);
}
return predicate;
| 1,128
| 183
| 1,311
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-discovery/src/main/java/org/springframework/cloud/kubernetes/client/discovery/KubernetesInformerAutoConfiguration.java
|
KubernetesInformerAutoConfiguration
|
namespace
|
class KubernetesInformerAutoConfiguration {
private static final LogAccessor LOG = new LogAccessor(
LogFactory.getLog(KubernetesInformerAutoConfiguration.class));
@Bean
@ConditionalOnMissingBean
public SharedInformerFactory sharedInformerFactory(ApiClient client) {
return new SharedInformerFactory(client);
}
@Bean
@ConditionalOnMissingBean(value = V1Service.class, parameterizedContainer = SharedIndexInformer.class)
public SharedIndexInformer<V1Service> servicesSharedIndexInformer(SharedInformerFactory sharedInformerFactory,
ApiClient apiClient, KubernetesNamespaceProvider kubernetesNamespaceProvider,
KubernetesDiscoveryProperties discoveryProperties) {
GenericKubernetesApi<V1Service, V1ServiceList> servicesApi = new GenericKubernetesApi<>(V1Service.class,
V1ServiceList.class, "", "v1", "services", apiClient);
return sharedInformerFactory.sharedIndexInformerFor(servicesApi, V1Service.class, 0L,
namespace(discoveryProperties, kubernetesNamespaceProvider));
}
@Bean
@ConditionalOnMissingBean(value = V1Endpoints.class, parameterizedContainer = SharedIndexInformer.class)
public SharedIndexInformer<V1Endpoints> endpointsSharedIndexInformer(SharedInformerFactory sharedInformerFactory,
ApiClient apiClient, KubernetesNamespaceProvider kubernetesNamespaceProvider,
KubernetesDiscoveryProperties discoveryProperties) {
GenericKubernetesApi<V1Endpoints, V1EndpointsList> servicesApi = new GenericKubernetesApi<>(V1Endpoints.class,
V1EndpointsList.class, "", "v1", "endpoints", apiClient);
return sharedInformerFactory.sharedIndexInformerFor(servicesApi, V1Endpoints.class, 0L,
namespace(discoveryProperties, kubernetesNamespaceProvider));
}
@Bean
@ConditionalOnMissingBean(value = V1Service.class, parameterizedContainer = Lister.class)
public Lister<V1Service> servicesLister(SharedIndexInformer<V1Service> servicesSharedIndexInformer) {
return new Lister<>(servicesSharedIndexInformer.getIndexer());
}
@Bean
@ConditionalOnMissingBean(value = V1Endpoints.class, parameterizedContainer = Lister.class)
public Lister<V1Endpoints> endpointsLister(SharedIndexInformer<V1Endpoints> endpointsSharedIndexInformer) {
return new Lister<>(endpointsSharedIndexInformer.getIndexer());
}
private String namespace(KubernetesDiscoveryProperties discoveryProperties,
KubernetesNamespaceProvider kubernetesNamespaceProvider) {<FILL_FUNCTION_BODY>}
}
|
String namespace;
if (discoveryProperties.allNamespaces()) {
namespace = NAMESPACE_ALL;
}
else if (kubernetesNamespaceProvider.getNamespace() == null) {
namespace = NAMESPACE_DEFAULT;
}
else {
namespace = kubernetesNamespaceProvider.getNamespace();
}
LOG.debug(() -> "serviceSharedInformer will use namespace : " + namespace);
return namespace;
| 690
| 118
| 808
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-discovery/src/main/java/org/springframework/cloud/kubernetes/client/discovery/KubernetesInformerDiscoveryClientAutoConfiguration.java
|
KubernetesInformerDiscoveryClientAutoConfiguration
|
indicatorInitializer
|
class KubernetesInformerDiscoveryClientAutoConfiguration {
private static final LogAccessor LOG = new LogAccessor(
LogFactory.getLog(KubernetesInformerDiscoveryClientAutoConfiguration.class));
@Deprecated(forRemoval = true)
public KubernetesInformerDiscoveryClient kubernetesInformerDiscoveryClient(
KubernetesNamespaceProvider kubernetesNamespaceProvider, SharedInformerFactory sharedInformerFactory,
Lister<V1Service> serviceLister, Lister<V1Endpoints> endpointsLister,
SharedInformer<V1Service> serviceInformer, SharedInformer<V1Endpoints> endpointsInformer,
KubernetesDiscoveryProperties properties) {
return new KubernetesInformerDiscoveryClient(kubernetesNamespaceProvider.getNamespace(), sharedInformerFactory,
serviceLister, endpointsLister, serviceInformer, endpointsInformer, properties);
}
/**
* Creation of this bean triggers publishing an InstanceRegisteredEvent. In turn,
* there is the CommonsClientAutoConfiguration::DiscoveryClientHealthIndicator, that
* implements 'ApplicationListener' that will catch this event. It also registers a
* bean of type DiscoveryClientHealthIndicator via ObjectProvider.
*/
@Bean
@ConditionalOnSpringCloudKubernetesBlockingDiscoveryHealthInitializer
public KubernetesDiscoveryClientHealthIndicatorInitializer indicatorInitializer(
ApplicationEventPublisher applicationEventPublisher, PodUtils<?> podUtils) {<FILL_FUNCTION_BODY>}
@Bean
@ConditionalOnMissingBean
@Conditional(ConditionalOnSelectiveNamespacesMissing.class)
KubernetesInformerDiscoveryClient kubernetesClientInformerDiscoveryClient(
SharedInformerFactory sharedInformerFactory, Lister<V1Service> serviceLister,
Lister<V1Endpoints> endpointsLister, SharedInformer<V1Service> serviceInformer,
SharedInformer<V1Endpoints> endpointsInformer, KubernetesDiscoveryProperties properties) {
return new KubernetesInformerDiscoveryClient(sharedInformerFactory, serviceLister, endpointsLister,
serviceInformer, endpointsInformer, properties);
}
@Bean
@ConditionalOnMissingBean
@Conditional(ConditionalOnSelectiveNamespacesPresent.class)
KubernetesInformerDiscoveryClient selectiveNamespacesKubernetesInformerDiscoveryClient(
List<SharedInformerFactory> sharedInformerFactories, List<Lister<V1Service>> serviceListers,
List<Lister<V1Endpoints>> endpointsListers, List<SharedInformer<V1Service>> serviceInformers,
List<SharedInformer<V1Endpoints>> endpointsInformers, KubernetesDiscoveryProperties properties) {
return new KubernetesInformerDiscoveryClient(sharedInformerFactories, serviceListers, endpointsListers,
serviceInformers, endpointsInformers, properties);
}
}
|
LOG.debug(() -> "Will publish InstanceRegisteredEvent from blocking implementation");
return new KubernetesDiscoveryClientHealthIndicatorInitializer(podUtils, applicationEventPublisher);
| 737
| 49
| 786
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-discovery/src/main/java/org/springframework/cloud/kubernetes/client/discovery/catalog/KubernetesCatalogWatch.java
|
KubernetesCatalogWatch
|
stateGenerator
|
class KubernetesCatalogWatch implements ApplicationEventPublisherAware {
private static final LogAccessor LOG = new LogAccessor(LogFactory.getLog(KubernetesCatalogWatch.class));
private final KubernetesCatalogWatchContext context;
private Function<KubernetesCatalogWatchContext, List<EndpointNameAndNamespace>> stateGenerator;
private volatile List<EndpointNameAndNamespace> catalogEndpointsState = null;
private ApplicationEventPublisher publisher;
KubernetesCatalogWatch(CoreV1Api coreV1Api, ApiClient apiClient, KubernetesDiscoveryProperties properties,
KubernetesNamespaceProvider namespaceProvider) {
context = new KubernetesCatalogWatchContext(coreV1Api, apiClient, properties, namespaceProvider);
}
@Override
public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
this.publisher = publisher;
}
@Scheduled(fixedDelayString = "${" + CATALOG_WATCH_PROPERTY_WITH_DEFAULT_VALUE + "}")
void catalogServicesWatch() {
try {
List<EndpointNameAndNamespace> currentState = stateGenerator.apply(context);
if (!currentState.equals(catalogEndpointsState)) {
LOG.debug(() -> "Received endpoints update from kubernetesClient: " + currentState);
publisher.publishEvent(new HeartbeatEvent(this, currentState));
}
catalogEndpointsState = currentState;
}
catch (Exception e) {
LOG.error(e, () -> "Error watching Kubernetes Services");
}
}
@PostConstruct
void postConstruct() {
stateGenerator = stateGenerator();
}
Function<KubernetesCatalogWatchContext, List<EndpointNameAndNamespace>> stateGenerator() {<FILL_FUNCTION_BODY>}
}
|
Function<KubernetesCatalogWatchContext, List<EndpointNameAndNamespace>> localStateGenerator;
if (context.properties().useEndpointSlices()) {
// this emulates : 'kubectl api-resources | grep -i EndpointSlice'
ApiClient apiClient = context.apiClient();
CustomObjectsApi customObjectsApi = new CustomObjectsApi(apiClient);
try {
List<V1APIResource> resources = customObjectsApi.getAPIResources(DISCOVERY_GROUP, DISCOVERY_VERSION)
.getResources();
boolean found = resources.stream().map(V1APIResource::getKind).anyMatch(ENDPOINT_SLICE::equals);
if (!found) {
throw new IllegalArgumentException("EndpointSlices are not supported on the cluster");
}
else {
localStateGenerator = new KubernetesEndpointSlicesCatalogWatch();
}
}
catch (ApiException e) {
throw new RuntimeException(e);
}
}
else {
localStateGenerator = new KubernetesEndpointsCatalogWatch();
}
LOG.debug(() -> "stateGenerator is of type: " + localStateGenerator.getClass().getSimpleName());
return localStateGenerator;
| 459
| 323
| 782
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-discovery/src/main/java/org/springframework/cloud/kubernetes/client/discovery/catalog/KubernetesEndpointSlicesCatalogWatch.java
|
KubernetesEndpointSlicesCatalogWatch
|
apply
|
class KubernetesEndpointSlicesCatalogWatch
implements Function<KubernetesCatalogWatchContext, List<EndpointNameAndNamespace>> {
private static final LogAccessor LOG = new LogAccessor(
LogFactory.getLog(KubernetesEndpointSlicesCatalogWatch.class));
@Override
public List<EndpointNameAndNamespace> apply(KubernetesCatalogWatchContext context) {<FILL_FUNCTION_BODY>}
private List<V1EndpointSlice> endpointSlices(DiscoveryV1Api api, Map<String, String> labels) {
try {
return api.listEndpointSliceForAllNamespaces(null, null, null, labelSelector(labels), null, null, null,
null, null, null, null).getItems();
}
catch (ApiException e) {
LOG.warn(e, () -> "can not list endpoint slices in all namespaces");
return Collections.emptyList();
}
}
private List<V1EndpointSlice> namespacedEndpointSlices(DiscoveryV1Api api, String namespace,
Map<String, String> labels) {
try {
return api.listNamespacedEndpointSlice(namespace, null, null, null, null, labelSelector(labels), null, null,
null, null, null, null).getItems();
}
catch (ApiException e) {
LOG.warn(e, () -> "can not list endpoint slices in namespace " + namespace);
return Collections.emptyList();
}
}
}
|
List<V1EndpointSlice> endpointSlices;
DiscoveryV1Api api = new DiscoveryV1Api(context.apiClient());
if (context.properties().allNamespaces()) {
LOG.debug(() -> "discovering endpoint slices in all namespaces");
endpointSlices = endpointSlices(api, context.properties().serviceLabels());
}
else if (!context.properties().namespaces().isEmpty()) {
LOG.debug(() -> "discovering endpoint slices in " + context.properties().namespaces());
List<V1EndpointSlice> inner = new ArrayList<>(context.properties().namespaces().size());
context.properties().namespaces().forEach(namespace -> inner
.addAll(namespacedEndpointSlices(api, namespace, context.properties().serviceLabels())));
endpointSlices = inner;
}
else {
String namespace = KubernetesClientUtils.getApplicationNamespace(null, "catalog-watch",
context.namespaceProvider());
LOG.debug(() -> "discovering endpoint slices in namespace : " + namespace);
endpointSlices = namespacedEndpointSlices(api, namespace, context.properties().serviceLabels());
}
Stream<V1ObjectReference> references = endpointSlices.stream().map(V1EndpointSlice::getEndpoints)
.flatMap(List::stream).map(V1Endpoint::getTargetRef);
return KubernetesCatalogWatchContext.state(references);
| 387
| 385
| 772
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-discovery/src/main/java/org/springframework/cloud/kubernetes/client/discovery/catalog/KubernetesEndpointsCatalogWatch.java
|
KubernetesEndpointsCatalogWatch
|
endpoints
|
class KubernetesEndpointsCatalogWatch
implements Function<KubernetesCatalogWatchContext, List<EndpointNameAndNamespace>> {
private static final LogAccessor LOG = new LogAccessor(LogFactory.getLog(KubernetesEndpointsCatalogWatch.class));
@Override
public List<EndpointNameAndNamespace> apply(KubernetesCatalogWatchContext context) {
List<V1Endpoints> endpoints;
CoreV1Api coreV1Api = context.coreV1Api();
if (context.properties().allNamespaces()) {
LOG.debug(() -> "discovering endpoints in all namespaces");
endpoints = endpoints(coreV1Api, context.properties().serviceLabels());
}
else if (!context.properties().namespaces().isEmpty()) {
LOG.debug(() -> "discovering endpoints in " + context.properties().namespaces());
List<V1Endpoints> inner = new ArrayList<>(context.properties().namespaces().size());
context.properties().namespaces().forEach(namespace -> inner
.addAll(namespacedEndpoints(coreV1Api, namespace, context.properties().serviceLabels())));
endpoints = inner;
}
else {
String namespace = KubernetesClientUtils.getApplicationNamespace(null, "catalog-watch",
context.namespaceProvider());
LOG.debug(() -> "discovering endpoints in namespace : " + namespace);
endpoints = namespacedEndpoints(coreV1Api, namespace, context.properties().serviceLabels());
}
/**
* <pre>
* - An "V1Endpoints" holds a List of V1EndpointSubset.
* - A single V1EndpointSubset holds a List of V1EndpointAddress
*
* - (The union of all V1EndpointSubsets is the Set of all V1Endpoints)
* - Set of V1Endpoints is the cartesian product of :
* V1EndpointSubset::getAddresses and V1EndpointSubset::getPorts (each is a List)
* </pre>
*/
Stream<V1ObjectReference> references = endpoints.stream().map(V1Endpoints::getSubsets).filter(Objects::nonNull)
.flatMap(List::stream).map(V1EndpointSubset::getAddresses).filter(Objects::nonNull)
.flatMap(List::stream).map(V1EndpointAddress::getTargetRef);
return KubernetesCatalogWatchContext.state(references);
}
private List<V1Endpoints> endpoints(CoreV1Api client, Map<String, String> labels) {<FILL_FUNCTION_BODY>}
private List<V1Endpoints> namespacedEndpoints(CoreV1Api client, String namespace, Map<String, String> labels) {
try {
return client.listNamespacedEndpoints(namespace, null, null, null, null, labelSelector(labels), null, null,
null, null, null, null).getItems();
}
catch (ApiException e) {
LOG.warn(e, () -> "can not list endpoints in namespace " + namespace);
return Collections.emptyList();
}
}
}
|
try {
return client.listEndpointsForAllNamespaces(null, null, null, labelSelector(labels), null, null, null, null,
null, null, null).getItems();
}
catch (ApiException e) {
LOG.warn(e, () -> "can not list endpoints in all namespaces");
return Collections.emptyList();
}
| 807
| 100
| 907
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-discovery/src/main/java/org/springframework/cloud/kubernetes/client/discovery/reactive/KubernetesInformerReactiveDiscoveryClient.java
|
KubernetesInformerReactiveDiscoveryClient
|
getInstances
|
class KubernetesInformerReactiveDiscoveryClient implements ReactiveDiscoveryClient {
private final KubernetesInformerDiscoveryClient kubernetesDiscoveryClient;
@Deprecated(forRemoval = true)
public KubernetesInformerReactiveDiscoveryClient(KubernetesNamespaceProvider kubernetesNamespaceProvider,
SharedInformerFactory sharedInformerFactory, Lister<V1Service> serviceLister,
Lister<V1Endpoints> endpointsLister, SharedInformer<V1Service> serviceInformer,
SharedInformer<V1Endpoints> endpointsInformer, KubernetesDiscoveryProperties properties) {
this.kubernetesDiscoveryClient = new KubernetesInformerDiscoveryClient(
kubernetesNamespaceProvider.getNamespace(), sharedInformerFactory, serviceLister, endpointsLister,
serviceInformer, endpointsInformer, properties);
}
// this is either kubernetesClientInformerDiscoveryClient
// or selectiveNamespacesKubernetesClientInformerDiscoveryClient
KubernetesInformerReactiveDiscoveryClient(KubernetesInformerDiscoveryClient kubernetesDiscoveryClient) {
this.kubernetesDiscoveryClient = kubernetesDiscoveryClient;
}
@Override
public String description() {
return "Kubernetes Reactive Discovery Client";
}
@Override
public Flux<ServiceInstance> getInstances(String serviceId) {<FILL_FUNCTION_BODY>}
@Override
public Flux<String> getServices() {
return Flux.defer(() -> Flux.fromIterable(kubernetesDiscoveryClient.getServices()))
.subscribeOn(Schedulers.boundedElastic());
}
}
|
Objects.requireNonNull(serviceId, "serviceId must be provided");
return Flux.defer(() -> Flux.fromIterable(kubernetesDiscoveryClient.getInstances(serviceId)))
.subscribeOn(Schedulers.boundedElastic());
| 415
| 68
| 483
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-discovery/src/main/java/org/springframework/cloud/kubernetes/client/discovery/reactive/KubernetesInformerReactiveDiscoveryClientAutoConfiguration.java
|
KubernetesInformerReactiveDiscoveryClientAutoConfiguration
|
kubernetesReactiveDiscoveryClient
|
class KubernetesInformerReactiveDiscoveryClientAutoConfiguration {
private static final LogAccessor LOG = new LogAccessor(
LogFactory.getLog(KubernetesInformerReactiveDiscoveryClientAutoConfiguration.class));
@Deprecated(forRemoval = true)
public ReactiveDiscoveryClientHealthIndicator kubernetesReactiveDiscoveryClientHealthIndicator(
KubernetesInformerReactiveDiscoveryClient client, DiscoveryClientHealthIndicatorProperties properties,
KubernetesClientPodUtils podUtils) {
ReactiveDiscoveryClientHealthIndicator healthIndicator = new ReactiveDiscoveryClientHealthIndicator(client,
properties);
InstanceRegisteredEvent<RegisteredEventSource> event = new InstanceRegisteredEvent<>(
new RegisteredEventSource("kubernetes", podUtils.isInsideKubernetes(), podUtils.currentPod().get()),
null);
healthIndicator.onApplicationEvent(event);
return healthIndicator;
}
@Deprecated(forRemoval = true)
public KubernetesInformerReactiveDiscoveryClient kubernetesReactiveDiscoveryClient(
KubernetesNamespaceProvider kubernetesNamespaceProvider, SharedInformerFactory sharedInformerFactory,
Lister<V1Service> serviceLister, Lister<V1Endpoints> endpointsLister,
SharedInformer<V1Service> serviceInformer, SharedInformer<V1Endpoints> endpointsInformer,
KubernetesDiscoveryProperties properties) {<FILL_FUNCTION_BODY>}
/**
* Post an event so that health indicator is initialized.
*/
@Bean
@ConditionalOnSpringCloudKubernetesReactiveDiscoveryHealthInitializer
KubernetesDiscoveryClientHealthIndicatorInitializer reactiveIndicatorInitializer(
ApplicationEventPublisher applicationEventPublisher, PodUtils<?> podUtils) {
LOG.debug(() -> "Will publish InstanceRegisteredEvent from reactive implementation");
return new KubernetesDiscoveryClientHealthIndicatorInitializer(podUtils, applicationEventPublisher);
}
/**
* unlike the blocking implementation, we need to register the health indicator.
*/
@Bean
@ConditionalOnSpringCloudKubernetesReactiveDiscoveryHealthInitializer
ReactiveDiscoveryClientHealthIndicator kubernetesReactiveDiscoveryClientHealthIndicator(
KubernetesInformerReactiveDiscoveryClient client, DiscoveryClientHealthIndicatorProperties properties) {
return new ReactiveDiscoveryClientHealthIndicator(client, properties);
}
@Bean
@ConditionalOnMissingBean
KubernetesInformerReactiveDiscoveryClient kubernetesClientReactiveDiscoveryClient(
KubernetesInformerDiscoveryClient kubernetesClientInformerDiscoveryClient) {
return new KubernetesInformerReactiveDiscoveryClient(kubernetesClientInformerDiscoveryClient);
}
@Bean
@ConditionalOnMissingBean
@Conditional(ConditionalOnSelectiveNamespacesMissing.class)
KubernetesInformerDiscoveryClient kubernetesClientInformerDiscoveryClient(
SharedInformerFactory sharedInformerFactory, Lister<V1Service> serviceLister,
Lister<V1Endpoints> endpointsLister, SharedInformer<V1Service> serviceInformer,
SharedInformer<V1Endpoints> endpointsInformer, KubernetesDiscoveryProperties properties) {
return new KubernetesInformerDiscoveryClient(sharedInformerFactory, serviceLister, endpointsLister,
serviceInformer, endpointsInformer, properties);
}
@Bean
@ConditionalOnMissingBean
@Conditional(ConditionalOnSelectiveNamespacesPresent.class)
KubernetesInformerDiscoveryClient selectiveNamespacesKubernetesClientInformerDiscoveryClient(
List<SharedInformerFactory> sharedInformerFactories, List<Lister<V1Service>> serviceListers,
List<Lister<V1Endpoints>> endpointsListers, List<SharedInformer<V1Service>> serviceInformers,
List<SharedInformer<V1Endpoints>> endpointsInformers, KubernetesDiscoveryProperties properties) {
return new KubernetesInformerDiscoveryClient(sharedInformerFactories, serviceListers, endpointsListers,
serviceInformers, endpointsInformers, properties);
}
}
|
return new KubernetesInformerReactiveDiscoveryClient(kubernetesNamespaceProvider, sharedInformerFactory,
serviceLister, endpointsLister, serviceInformer, endpointsInformer, properties);
| 1,070
| 52
| 1,122
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-loadbalancer/src/main/java/org/springframework/cloud/kubernetes/client/loadbalancer/KubernetesClientServiceInstanceMapper.java
|
KubernetesClientServiceInstanceMapper
|
logWarning
|
class KubernetesClientServiceInstanceMapper implements KubernetesServiceInstanceMapper<V1Service> {
private static final LogAccessor LOG = new LogAccessor(
LogFactory.getLog(KubernetesClientServiceInstanceMapper.class));
/**
* empty on purpose, load balancer implementation does not need them.
*/
private static final Map<String, Integer> PORTS_DATA = Map.of();
private final KubernetesLoadBalancerProperties properties;
private final KubernetesDiscoveryProperties discoveryProperties;
private final ServicePortSecureResolver resolver;
public KubernetesClientServiceInstanceMapper(KubernetesLoadBalancerProperties properties,
KubernetesDiscoveryProperties discoveryProperties) {
this.properties = properties;
this.discoveryProperties = discoveryProperties;
resolver = new ServicePortSecureResolver(discoveryProperties);
}
@Override
public KubernetesServiceInstance map(V1Service service) {
V1ObjectMeta metadata = service.getMetadata();
List<V1ServicePort> ports = ofNullable(service.getSpec()).map(V1ServiceSpec::getPorts).orElse(List.of());
V1ServicePort port;
if (ports.isEmpty()) {
LOG.warn(() -> "service : " + metadata.getName() + " does not have any ServicePort(s),"
+ " will not consider it for load balancing");
return null;
}
if (ports.size() == 1) {
LOG.debug(() -> "single ServicePort found, will use it as-is " + "(without checking " + PORT_NAME_PROPERTY
+ ")");
port = ports.get(0);
}
else {
String portNameFromProperties = properties.getPortName();
if (StringUtils.hasText(portNameFromProperties)) {
Optional<V1ServicePort> optionalPort = ports.stream()
.filter(x -> Objects.equals(x.getName(), portNameFromProperties)).findAny();
if (optionalPort.isPresent()) {
LOG.debug(() -> "found port name that matches : " + portNameFromProperties);
port = optionalPort.get();
}
else {
logWarning(portNameFromProperties);
port = ports.get(0);
}
}
else {
LOG.warn(() -> PORT_NAME_PROPERTY + " is not set");
LOG.warn(() -> NON_DETERMINISTIC_PORT_MESSAGE);
port = ports.get(0);
}
}
String host = KubernetesServiceInstanceMapper.createHost(service.getMetadata().getName(),
service.getMetadata().getNamespace(), properties.getClusterDomain());
boolean secure = secure(port, service);
return new DefaultKubernetesServiceInstance(metadata.getUid(), metadata.getName(), host, port.getPort(),
serviceMetadata(service), secure);
}
private Map<String, String> serviceMetadata(V1Service service) {
V1ObjectMeta metadata = service.getMetadata();
V1ServiceSpec serviceSpec = service.getSpec();
ServiceMetadata serviceMetadata = new ServiceMetadata(metadata.getName(), metadata.getNamespace(),
serviceSpec.getType(), metadata.getLabels(), metadata.getAnnotations());
return DiscoveryClientUtils.serviceInstanceMetadata(PORTS_DATA, serviceMetadata, discoveryProperties);
}
private boolean secure(V1ServicePort port, V1Service service) {
V1ObjectMeta metadata = service.getMetadata();
ServicePortNameAndNumber portNameAndNumber = new ServicePortNameAndNumber(port.getPort(), port.getName());
Input input = new Input(portNameAndNumber, metadata.getName(), metadata.getLabels(), metadata.getAnnotations());
return resolver.resolve(input);
}
private void logWarning(String portNameFromProperties) {<FILL_FUNCTION_BODY>}
}
|
LOG.warn(() -> "Did not find a port name that is equal to the value " + portNameFromProperties);
LOG.warn(() -> NON_DETERMINISTIC_PORT_MESSAGE);
| 985
| 57
| 1,042
|
<no_super_class>
|
spring-cloud_spring-cloud-kubernetes
|
spring-cloud-kubernetes/spring-cloud-kubernetes-client-loadbalancer/src/main/java/org/springframework/cloud/kubernetes/client/loadbalancer/KubernetesClientServicesListSupplier.java
|
KubernetesClientServicesListSupplier
|
services
|
class KubernetesClientServicesListSupplier extends KubernetesServicesListSupplier<V1Service> {
private static final LogAccessor LOG = new LogAccessor(
LogFactory.getLog(KubernetesClientServicesListSupplier.class));
private final CoreV1Api coreV1Api;
private final KubernetesNamespaceProvider kubernetesNamespaceProvider;
public KubernetesClientServicesListSupplier(Environment environment,
KubernetesServiceInstanceMapper<V1Service> mapper, KubernetesDiscoveryProperties discoveryProperties,
CoreV1Api coreV1Api, KubernetesNamespaceProvider kubernetesNamespaceProvider) {
super(environment, mapper, discoveryProperties);
this.coreV1Api = coreV1Api;
this.kubernetesNamespaceProvider = kubernetesNamespaceProvider;
}
@Override
public Flux<List<ServiceInstance>> get() {
List<ServiceInstance> result = new ArrayList<>();
String serviceName = getServiceId();
LOG.debug(() -> "serviceID : " + serviceName);
if (discoveryProperties.allNamespaces()) {
LOG.debug(() -> "discovering services in all namespaces");
List<V1Service> services = services(null, serviceName);
services.forEach(service -> addMappedService(mapper, result, service));
}
else if (!discoveryProperties.namespaces().isEmpty()) {
List<String> selectiveNamespaces = discoveryProperties.namespaces().stream().sorted().toList();
LOG.debug(() -> "discovering services in selective namespaces : " + selectiveNamespaces);
selectiveNamespaces.forEach(selectiveNamespace -> {
List<V1Service> services = services(selectiveNamespace, serviceName);
services.forEach(service -> addMappedService(mapper, result, service));
});
}
else {
String namespace = getApplicationNamespace(null, "loadbalancer-service", kubernetesNamespaceProvider);
LOG.debug(() -> "discovering services in namespace : " + namespace);
List<V1Service> services = services(namespace, serviceName);
services.forEach(service -> addMappedService(mapper, result, service));
}
LOG.debug(() -> "found services : " + result);
return Flux.defer(() -> Flux.just(result));
}
private void addMappedService(KubernetesServiceInstanceMapper<V1Service> mapper, List<ServiceInstance> services,
V1Service service) {
services.add(mapper.map(service));
}
private List<V1Service> services(String namespace, String serviceName) {<FILL_FUNCTION_BODY>}
}
|
if (namespace == null) {
try {
return coreV1Api.listServiceForAllNamespaces(null, null, "metadata.name=" + serviceName, null, null,
null, null, null, null, null, null).getItems();
}
catch (ApiException apiException) {
LOG.warn(apiException, "Error retrieving services (in all namespaces) with name " + serviceName);
return List.of();
}
}
else {
try {
// there is going to be a single service here, if found
return coreV1Api.listNamespacedService(namespace, null, null, null, "metadata.name=" + serviceName,
null, null, null, null, null, null, null).getItems();
}
catch (ApiException apiException) {
LOG.warn(apiException,
"Error retrieving service with name " + serviceName + " in namespace : " + namespace);
return List.of();
}
}
| 683
| 258
| 941
|
<methods>public void <init>(org.springframework.core.env.Environment, KubernetesServiceInstanceMapper<io.kubernetes.client.openapi.models.V1Service>, KubernetesDiscoveryProperties) ,public abstract Flux<List<org.springframework.cloud.client.ServiceInstance>> get() ,public java.lang.String getServiceId() <variables>protected final non-sealed KubernetesDiscoveryProperties discoveryProperties,protected final non-sealed org.springframework.core.env.Environment environment,protected final non-sealed KubernetesServiceInstanceMapper<io.kubernetes.client.openapi.models.V1Service> mapper
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.