chore(v0.11): 全路径纳入版本库与走查整改

- .gitignore：显式放行全部 maven-*、scripts、dev-support、frontend、反1、artifacts、历史导出目录 - 新增跟踪：device-manager/device-sdk/legacy-public、davinci-manager、cwos-*、cwos-resource 等源码与附属资源 - davinci FileStorageManagerImpl：Feign Response 关闭、绝对 URL 拉流 SSRF 校验（协议/主机/解析地址） - davinci OuterCallFeignClient：补充契约说明 - cwos-common-aks AksConstant：final 类 + 私有构造防误实例化 - device-manager DeviceConstant：沿用 DEFAULT_APPLICATIONID 拼写修正 Made-with: Cursor
2026-06-10 00:40:30 +08:00 · 2026-04-24 23:54:05 +08:00
parent de6245a492
commit 0a34c76a82
3193 changed files with 227337 additions and 1 deletions
@@ -0,0 +1,18 @@
+package cn.cloudwalk.cloud.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface CloudwalkParamsValidate {
+  int[] argsIndexs() default {0};
+  
+  Class<?>[] groups() default {javax.validation.groups.Default.class};
+}
+
+
@@ -0,0 +1,20 @@
+package cn.cloudwalk.cloud.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface CloudwalkTrace {
+  String module() default "";
+  
+  String operation() default "";
+  
+  boolean code() default false;
+}
+
+
@@ -0,0 +1,14 @@
+package cn.cloudwalk.cloud.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface DataFieldEncrypt {}
+
+
@@ -0,0 +1,14 @@
+package cn.cloudwalk.cloud.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface DataObjectEncrypt {}
+
+
@@ -0,0 +1,17 @@
+package cn.cloudwalk.cloud.annotation;
+
+import cn.cloudwalk.cloud.sensitive.I8ndescribedSerialize;
+import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.FIELD, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@JsonSerialize(using = I8ndescribedSerialize.class)
+@JacksonAnnotationsInside
+public @interface I8ndescribed {}
+
+
@@ -0,0 +1,26 @@
+package cn.cloudwalk.cloud.annotation;
+
+import cn.cloudwalk.cloud.enums.SensitiveType;
+import cn.cloudwalk.cloud.sensitive.SensitiveInfoSerialize;
+import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.FIELD, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@JsonSerialize(using = SensitiveInfoSerialize.class)
+@JacksonAnnotationsInside
+public @interface SensitiveField {
+  SensitiveType type() default SensitiveType.NULL;
+  
+  int prefix() default 4;
+  
+  int suffix() default 3;
+  
+  int split() default 3;
+}
+
+
@@ -0,0 +1,140 @@
+package cn.cloudwalk.cloud.context;
+
+import cn.cloudwalk.cloud.session.company.CompanyContext;
+import cn.cloudwalk.cloud.session.extend.ExtendContext;
+import cn.cloudwalk.cloud.session.note.NotesContext;
+import cn.cloudwalk.cloud.session.user.UserContext;
+import java.io.Serializable;
+import java.util.Date;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public final class CloudwalkCallContext
+implements Serializable
+{
+private static final long serialVersionUID = -6192221637110412715L;
+private String applicationId;
+private String serviceCode;
+private String deviceId;
+private String logId;
+private Date callTime;
+private UserContext user;
+private ExtendContext ext;
+private NotesContext notes;
+private CompanyContext company;
+
+public String getApplicationId() {
+/*  68 */     return this.applicationId;
+}
+
+public void setApplicationId(String applicationId) {
+/*  72 */     this.applicationId = applicationId;
+}
+
+public String getDeviceId() {
+/*  76 */     return this.deviceId;
+}
+
+public void setDeviceId(String deviceId) {
+/*  80 */     this.deviceId = deviceId;
+}
+
+public String getLogId() {
+/*  84 */     return this.logId;
+}
+
+public void setLogId(String logId) {
+/*  88 */     this.logId = logId;
+}
+
+public Date getCallTime() {
+/*  92 */     return this.callTime;
+}
+
+public void setCallTime(Date callTime) {
+/*  96 */     this.callTime = callTime;
+}
+
+public UserContext getUser() {
+return this.user;
+}
+
+public void setUser(UserContext user) {
+this.user = user;
+}
+
+public CompanyContext getCompany() {
+return this.company;
+}
+
+public void setCompany(CompanyContext company) {
+this.company = company;
+}
+
+public ExtendContext getExt() {
+return this.ext;
+}
+
+public void setExt(ExtendContext ext) {
+this.ext = ext;
+}
+
+public NotesContext getNotes() {
+return this.notes;
+}
+
+public void setNotes(NotesContext notes) {
+this.notes = notes;
+}
+
+public String getServiceCode() {
+return this.serviceCode;
+}
+
+public void setServiceCode(String serviceCode) {
+this.serviceCode = serviceCode;
+}
+}
+
+
@@ -0,0 +1,46 @@
+package cn.cloudwalk.cloud.context;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public final class CloudwalkCallContextBuilder
+{
+public static CloudwalkCallContext buildContext(CloudwalkSessionContextHolder sessionContextHolder) {
+CloudwalkSessionObject session = sessionContextHolder.getSession();
+CloudwalkCallContext context = new CloudwalkCallContext();
+
+context.setUser(session.getUser());
+context.setCompany(session.getCompany());
+context.setExt(session.getExt());
+context.setNotes(session.getNotes());
+
+context.setCallTime(session.getCallTime());
+context.setApplicationId(session.getApplicationId());
+context.setServiceCode(session.getServiceCode());
+
+return context;
+}
+
+
+
+
+
+public static void cleanContext(CloudwalkSessionContextHolder sessionContextHolder) {
+sessionContextHolder.clearSession();
+}
+}
+
+
@@ -0,0 +1,45 @@
+package cn.cloudwalk.cloud.context;
+
+
+
+
+
+
+
+
+
+
+
+
+
+public final class CloudwalkSessionContextHolder
+{
+private static ThreadLocal<CloudwalkSessionObject> SESSION_OBJECT = new ThreadLocal<>();
+
+
+
+
+
+
+public CloudwalkSessionObject getSession() {
+return SESSION_OBJECT.get();
+}
+
+
+
+
+
+
+public void putSession(CloudwalkSessionObject cloudWalkSessionObject) {
+SESSION_OBJECT.set(cloudWalkSessionObject);
+}
+
+
+
+
+public void clearSession() {
+SESSION_OBJECT.remove();
+}
+}
+
+
@@ -0,0 +1,179 @@
+package cn.cloudwalk.cloud.context;
+
+import cn.cloudwalk.cloud.session.company.CompanyContext;
+import cn.cloudwalk.cloud.session.extend.ExtendContext;
+import cn.cloudwalk.cloud.session.note.ErrorContext;
+import cn.cloudwalk.cloud.session.note.NotesContext;
+import cn.cloudwalk.cloud.session.user.UserContext;
+import cn.cloudwalk.cloud.utils.CloudwalkDateUtils;
+import java.io.Serializable;
+import java.util.Date;
+import org.springframework.util.Assert;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public final class CloudwalkSessionObject
+implements Serializable
+{
+private static final long serialVersionUID = -5960069764782340892L;
+public static final String CLOUDWALK_SESSION_OBJECT_KEY = "cloudSessionObject";
+private String applicationId;
+private String serviceCode;
+private Date callTime;
+private UserContext user;
+private CompanyContext company;
+private ExtendContext ext;
+private NotesContext notes;
+
+public CloudwalkSessionObject() {
+/*  71 */     this.notes = (NotesContext)new ErrorContext();
+}
+
+
+
+
+
+
+
+public CloudwalkSessionObject(String[] values) {
+/*  81 */     Assert.notNull(values, "values is not null");
+/*  82 */     if (values.length != 4) {
+/*  83 */       throw new IllegalArgumentException("values is not vaild");
+}
+
+/*  86 */     this.user = new UserContext();
+/*  87 */     this.company = new CompanyContext();
+/*  88 */     this.notes = (NotesContext)new ErrorContext();
+
+/*  90 */     this.user.setCaller(values[0]);
+/*  91 */     this.user.setCallerName(values[2]);
+/*  92 */     this.company.setCompanyId(values[1]);
+
+/*  94 */     setApplicationId(values[3]);
+/*  95 */     setCallTime(CloudwalkDateUtils.getCurrentDate());
+}
+
+
+
+
+
+
+
+
+
+
+
+public CloudwalkSessionObject(String userId, String serviceCode, String businessId, String corpCode, String username) {
+this.user = new UserContext();
+this.company = new CompanyContext();
+this.notes = (NotesContext)new ErrorContext();
+
+this.user.setCaller(userId);
+this.user.setCallerName(username);
+this.company.setCompanyId(businessId);
+this.company.setCorpCode(corpCode);
+
+setServiceCode(serviceCode);
+setCallTime(CloudwalkDateUtils.getCurrentDate());
+}
+
+public String getApplicationId() {
+return this.applicationId;
+}
+
+public void setApplicationId(String applicationId) {
+this.applicationId = applicationId;
+}
+
+public Date getCallTime() {
+return this.callTime;
+}
+
+public void setCallTime(Date callTime) {
+this.callTime = callTime;
+}
+
+public UserContext getUser() {
+return this.user;
+}
+
+public void setUser(UserContext user) {
+this.user = user;
+}
+
+public CompanyContext getCompany() {
+return this.company;
+}
+
+public void setCompany(CompanyContext company) {
+this.company = company;
+}
+
+public ExtendContext getExt() {
+return this.ext;
+}
+
+public void setExt(ExtendContext ext) {
+this.ext = ext;
+}
+
+public NotesContext getNotes() {
+return this.notes;
+}
+
+public void setNotes(NotesContext notes) {
+this.notes = notes;
+}
+
+public String getServiceCode() {
+return this.serviceCode;
+}
+
+public void setServiceCode(String serviceCode) {
+this.serviceCode = serviceCode;
+}
+}
+
+
@@ -0,0 +1,55 @@
+package cn.cloudwalk.cloud.entity;
+
+import java.io.Serializable;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class CloudwalkBaseIdentify
+implements Serializable
+{
+private static final long serialVersionUID = -2923446725609856732L;
+private String id;
+private String createUserId;
+private String lastUpdateUserId;
+
+public String getId() {
+return this.id;
+}
+
+public String getCreateUserId() {
+return this.createUserId;
+}
+
+public String getLastUpdateUserId() {
+return this.lastUpdateUserId;
+}
+
+public void setId(String id) {
+this.id = id;
+}
+
+public void setCreateUserId(String createUserId) {
+this.createUserId = createUserId;
+}
+
+public void setLastUpdateUserId(String lastUpdateUserId) {
+this.lastUpdateUserId = lastUpdateUserId;
+}
+}
+
+
@@ -0,0 +1,68 @@
+package cn.cloudwalk.cloud.entity;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class CloudwalkBasePeriod
+extends CloudwalkBaseIdentify
+{
+private static final long serialVersionUID = 4257604668089816087L;
+private Long createBeginTime;
+private Long createEndTime;
+private Long lastUpdateBeginTime;
+private Long lastUpdateEndTime;
+
+public Long getCreateBeginTime() {
+return this.createBeginTime;
+}
+
+public Long getCreateEndTime() {
+return this.createEndTime;
+}
+
+public Long getLastUpdateBeginTime() {
+return this.lastUpdateBeginTime;
+}
+
+public Long getLastUpdateEndTime() {
+return this.lastUpdateEndTime;
+}
+
+public void setCreateBeginTime(Long createBeginTime) {
+this.createBeginTime = createBeginTime;
+}
+
+public void setCreateEndTime(Long createEndTime) {
+this.createEndTime = createEndTime;
+}
+
+public void setLastUpdateBeginTime(Long lastUpdateBeginTime) {
+this.lastUpdateBeginTime = lastUpdateBeginTime;
+}
+
+public void setLastUpdateEndTime(Long lastUpdateEndTime) {
+this.lastUpdateEndTime = lastUpdateEndTime;
+}
+}
+
+
@@ -0,0 +1,44 @@
+package cn.cloudwalk.cloud.entity;
+
+import cn.cloudwalk.cloud.enums.SortEnum;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class CloudwalkBaseSort
+extends CloudwalkBasePeriod
+{
+private static final long serialVersionUID = 2250338703453500458L;
+private String sortField;
+private SortEnum sortValue;
+
+public String getSortField() {
+return this.sortField;
+}
+
+public void setSortField(String sortField) {
+this.sortField = sortField;
+}
+
+public SortEnum getSortValue() {
+return (this.sortValue == null) ? SortEnum.AES : this.sortValue;
+}
+
+public void setSortValue(SortEnum sortValue) {
+this.sortValue = sortValue;
+}
+}
+
+
@@ -0,0 +1,42 @@
+package cn.cloudwalk.cloud.entity;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class CloudwalkBaseTimes
+extends CloudwalkBaseIdentify
+{
+private static final long serialVersionUID = -1915432938815132522L;
+private Long createTime;
+private Long lastUpdateTime;
+
+public Long getCreateTime() {
+return this.createTime;
+}
+
+public Long getLastUpdateTime() {
+return this.lastUpdateTime;
+}
+
+public void setCreateTime(Long createTime) {
+this.createTime = createTime;
+}
+
+public void setLastUpdateTime(Long lastUpdateTime) {
+this.lastUpdateTime = lastUpdateTime;
+}
+}
+
+
@@ -0,0 +1,34 @@
+package cn.cloudwalk.cloud.enums;
+
+
+
+
+
+
+
+
+
+
+
+
+public enum DataFieldEncryptType
+{
+SM4,
+
+
+
+
+AES,
+
+
+
+
+DES,
+
+
+
+
+JAS;
+}
+
+
@@ -0,0 +1,54 @@
+package cn.cloudwalk.cloud.enums;
+
+
+
+
+
+
+
+
+
+
+
+
+public enum SensitiveType
+{
+CHINESE_NAME,
+
+
+
+
+ID_CARD,
+
+
+
+
+FIXED_PHONE,
+
+
+
+
+MOBILE_PHONE,
+
+
+
+
+EMAIL,
+
+
+
+
+BANK_CARD,
+
+
+
+
+CNAPS_CODE,
+
+
+
+
+NULL;
+}
+
+
@@ -0,0 +1,19 @@
+package cn.cloudwalk.cloud.enums;
+
+
+
+
+
+
+
+
+
+
+
+
+public enum SortEnum
+{
+AES, DES;
+}
+
+
@@ -0,0 +1,40 @@
+package cn.cloudwalk.cloud.exception;
+
+
+
+
+
+
+
+
+
+
+
+public class DataAccessException
+extends Exception
+{
+private static final long serialVersionUID = -1219262335729891920L;
+
+public DataAccessException(String message) {
+super(message);
+}
+
+
+
+
+
+public DataAccessException(Throwable cause) {
+super(cause);
+}
+
+
+
+
+
+
+public DataAccessException(String message, Throwable cause) {
+super(message, cause);
+}
+}
+
+
@@ -0,0 +1,64 @@
+package cn.cloudwalk.cloud.exception;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class ServiceException
+extends Exception
+{
+private static final long serialVersionUID = -1219262335729891920L;
+private String code;
+
+public ServiceException(String message) {
+super(message);
+}
+
+
+
+
+
+public ServiceException(Throwable cause) {
+super(cause);
+}
+
+
+
+
+
+
+public ServiceException(String code, String message) {
+this(message);
+this.code = code;
+}
+
+
+
+
+
+
+public ServiceException(String message, Throwable cause) {
+super(message, cause);
+}
+
+public String getCode() {
+return this.code;
+}
+
+public void setCode(String code) {
+this.code = code;
+}
+}
+
+
@@ -0,0 +1,47 @@
+package cn.cloudwalk.cloud.page;
+
+import cn.cloudwalk.cloud.entity.CloudwalkBasePeriod;
+
+
+
+
+
+
+
+
+
+
+
+
+public class CloudwalkBasePageForm
+extends CloudwalkBasePeriod
+{
+private static final long serialVersionUID = -4212911809130413023L;
+private int rowsOfPage = 10;
+
+
+
+
+private int currentPage = 1;
+
+public int getCurrentPage() {
+return this.currentPage;
+}
+
+public void setCurrentPage(int currentPage) {
+if (currentPage >= 1) {
+this.currentPage = currentPage;
+}
+}
+
+public int getRowsOfPage() {
+return this.rowsOfPage;
+}
+
+public void setRowsOfPage(int rowsOfPage) {
+if (rowsOfPage >= 1)
+this.rowsOfPage = rowsOfPage; 
+}
+}
+
+
@@ -0,0 +1,131 @@
+package cn.cloudwalk.cloud.page;
+
+import java.io.Serializable;
+import java.util.Collection;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class CloudwalkPageAble<T>
+implements Serializable
+{
+private static final long serialVersionUID = -3628865867907230918L;
+private long pageSize;
+private long currentPage;
+private long totalPages;
+private long totalRows;
+private long minRowNumber;
+private long maxRowNumber;
+private Collection<T> datas;
+
+public CloudwalkPageAble() {}
+
+public CloudwalkPageAble(Collection<T> list, CloudwalkPageInfo page, long totalCount) {
+/*  67 */     if (totalCount < 0L || page == null || page.getPageSize() <= 0 || page.getCurrentPage() < 0) {
+/*  68 */       throw new IllegalArgumentException("totalCount must more than 0");
+}
+
+/*  71 */     this.datas = list;
+/*  72 */     this.totalRows = totalCount;
+
+/*  74 */     this.pageSize = page.getPageSize();
+/*  75 */     this.currentPage = page.getCurrentPage();
+
+/*  77 */     if (totalCount == 0L) {
+/*  78 */       this.totalPages = 0L;
+}
+/*  80 */     else if (totalCount % page.getPageSize() > 0L) {
+/*  81 */       this.totalPages = totalCount / page.getPageSize() + 1L;
+} else {
+/*  83 */       this.totalPages = totalCount / page.getPageSize();
+} 
+
+
+
+/*  88 */     if (this.totalRows == 0L) {
+/*  89 */       this.minRowNumber = 0L;
+} else {
+/*  91 */       this.minRowNumber = (this.currentPage - 1L) * page.getPageSize() + 1L;
+} 
+
+
+/*  95 */     if (this.currentPage * page.getPageSize() > this.totalRows) {
+/*  96 */       this.maxRowNumber = this.totalRows;
+} else {
+/*  98 */       this.maxRowNumber = this.currentPage * page.getPageSize();
+} 
+}
+
+public long getCurrentPage() {
+return this.currentPage;
+}
+
+public long getTotalPages() {
+return this.totalPages;
+}
+
+public long getTotalRows() {
+return this.totalRows;
+}
+
+public Collection<T> getDatas() {
+return this.datas;
+}
+
+public long getMinRowNumber() {
+return this.minRowNumber;
+}
+
+public long getMaxRowNumber() {
+return this.maxRowNumber;
+}
+
+public long getPageSize() {
+return this.pageSize;
+}
+}
+
+
@@ -0,0 +1,62 @@
+package cn.cloudwalk.cloud.page;
+
+import java.io.Serializable;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class CloudwalkPageDTO<T>
+implements Serializable
+{
+private static final long serialVersionUID = -1351931333484421041L;
+private CloudwalkPageInfo page;
+private T dto;
+
+public CloudwalkPageDTO() {}
+
+public CloudwalkPageDTO(CloudwalkPageInfo page, T dto) {
+this.page = page;
+this.dto = dto;
+}
+
+public CloudwalkPageInfo getPage() {
+return this.page;
+}
+
+public void setPage(CloudwalkPageInfo page) {
+this.page = page;
+}
+
+public T getDto() {
+return this.dto;
+}
+
+public void setDto(T dto) {
+this.dto = dto;
+}
+
+
+public String toString() {
+return "CloudwalkPageDTO [page=" + this.page + ", dto=" + this.dto + "]";
+}
+}
+
+
@@ -0,0 +1,76 @@
+package cn.cloudwalk.cloud.page;
+
+import java.io.Serializable;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class CloudwalkPageInfo
+implements Serializable
+{
+private static final long serialVersionUID = -9065614200385450712L;
+private int pageSize;
+private int currentPage;
+
+public CloudwalkPageInfo(int currentPage, int pageSize) {
+if (currentPage < 1 || pageSize < 1) {
+throw new IllegalArgumentException("currentPage and pageSize must more than 0.");
+}
+
+this.currentPage = currentPage;
+this.pageSize = pageSize;
+}
+
+
+
+
+public CloudwalkPageInfo() {
+this.currentPage = 1;
+this.pageSize = 20;
+}
+
+
+
+
+
+public int getPageStart() {
+if (this.currentPage < 1) {
+this.currentPage = 1;
+}
+
+return (this.currentPage - 1) * this.pageSize;
+}
+
+
+
+
+
+public int getPageSize() {
+return this.pageSize;
+}
+
+
+
+
+
+public int getCurrentPage() {
+return this.currentPage;
+}
+}
+
+
@@ -0,0 +1,125 @@
+package cn.cloudwalk.cloud.result;
+
+import java.io.Serializable;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class CloudwalkResult<T>
+implements Serializable
+{
+private static final long serialVersionUID = 9191892693219217387L;
+public static final String RESP_CODE_SUCCESS = "00000000";
+public static final String RESP_MESG_SUCCESS = "success";
+private String code;
+private boolean success;
+private String message;
+private T data;
+
+public String getCode() {
+/*  47 */     return this.code;
+}
+
+public void setCode(String code) {
+/*  51 */     this.code = code;
+}
+
+public String getMessage() {
+/*  55 */     return this.message;
+}
+
+public void setMessage(String message) {
+/*  59 */     this.message = message;
+}
+
+public T getData() {
+/*  63 */     return this.data;
+}
+
+public void setData(T data) {
+/*  67 */     this.data = data;
+}
+
+public boolean isSuccess() {
+/*  71 */     return this.success;
+}
+
+public void setSuccess(boolean success) {
+/*  75 */     this.success = success;
+}
+
+
+
+
+
+
+public static <T> CloudwalkResult<T> success(T data) {
+/*  84 */     CloudwalkResult<T> result = new CloudwalkResult<>();
+/*  85 */     result.setCode("00000000");
+/*  86 */     result.setMessage("success");
+/*  87 */     result.setSuccess(true);
+/*  88 */     result.setData(data);
+/*  89 */     return result;
+}
+
+
+
+
+
+
+
+public static <T> CloudwalkResult<T> fail(String code, String message, T data) {
+/*  99 */     CloudwalkResult<T> result = new CloudwalkResult<>();
+result.setCode(code);
+result.setData(data);
+result.setMessage(message);
+result.setSuccess(false);
+return result;
+}
+
+
+
+
+
+
+
+
+public static <T> CloudwalkResult<T> fail(String code, String message) {
+CloudwalkResult<T> result = new CloudwalkResult<>();
+result.setCode(code);
+result.setMessage(message);
+result.setSuccess(false);
+result.setData(null);
+
+return result;
+}
+}
+
+
@@ -0,0 +1,165 @@
+package cn.cloudwalk.cloud.security;
+
+import java.nio.charset.Charset;
+import java.util.Arrays;
+import javax.crypto.Cipher;
+import javax.crypto.spec.SecretKeySpec;
+import org.apache.commons.codec.binary.Base64;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class AESUtils
+{
+private static final String KEY_ALGORITHM = "AES";
+/*  30 */   private static final Charset CHARSET = Charset.forName("UTF-8");
+
+
+
+
+
+
+private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";
+
+
+
+
+
+
+
+public static String encrypt(String content, String password) throws Exception {
+/*  46 */     Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
+/*  47 */     cipher.init(1, getSecretKey(password));
+
+/*  49 */     byte[] byteContent = content.getBytes(CHARSET);
+/*  50 */     byte[] result = cipher.doFinal(byteContent);
+
+/*  52 */     return HexUtils.bytesToHex(result);
+}
+
+
+
+
+
+
+
+
+
+public static String encryptBase64(String content, String password) throws Exception {
+/*  64 */     Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
+/*  65 */     cipher.init(1, getSecretKey(password));
+
+/*  67 */     byte[] byteContent = content.getBytes(CHARSET);
+/*  68 */     byte[] result = cipher.doFinal(byteContent);
+
+/*  70 */     return Base64.encodeBase64String(result);
+}
+
+
+
+
+
+
+
+
+
+
+public static String decrypt(String content, String password) throws Exception {
+/*  83 */     Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
+/*  84 */     cipher.init(2, getSecretKey(password));
+/*  85 */     byte[] result = cipher.doFinal(HexUtils.hexStringToByte(content));
+
+/*  87 */     return new String(result, CHARSET);
+}
+
+
+
+
+
+
+
+
+
+
+public static String decryptBase64(String content, String password) throws Exception {
+Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
+cipher.init(2, getSecretKey(password));
+byte[] result = cipher.doFinal(Base64.decodeBase64(content));
+
+return new String(result, CHARSET);
+}
+
+
+
+
+
+
+
+public static byte[] getEncCode(byte[] bytes, String password) throws Exception {
+Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
+cipher.init(1, getSecretKey(password));
+byte[] result = cipher.doFinal(bytes);
+
+return result;
+}
+
+
+
+
+
+
+
+
+
+public static byte[] getDecCode(byte[] bytes, String password) throws Exception {
+Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
+cipher.init(2, getSecretKey(password));
+byte[] result = cipher.doFinal(bytes);
+
+return result;
+}
+
+
+
+
+
+
+
+private static SecretKeySpec getSecretKey(String password) {
+try {
+return new SecretKeySpec(password.getBytes(CHARSET), "AES");
+} catch (Exception e) {
+throw new IllegalArgumentException("encode init error");
+} 
+}
+
+
+public static void main(String[] args) throws Exception {
+byte[] bytes1 = { 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4 };
+System.out.println("原数组长度：-----" + bytes1.length);
+byte[] bytes = getEncCode(bytes1, "123asdasdasdas21");
+System.out.println("加密后长度：-----" + bytes.length);
+System.out.println(Arrays.toString(bytes));
+
+byte[] bytes2 = getDecCode(bytes, "123asdasdasdas21");
+System.out.println("还原数组长度：-----" + bytes2.length);
+System.out.println(Arrays.toString(bytes2));
+}
+}
+
+
@@ -0,0 +1,158 @@
+package cn.cloudwalk.cloud.security;
+
+import java.nio.charset.Charset;
+import java.security.SecureRandom;
+import javax.crypto.Cipher;
+import javax.crypto.SecretKey;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.spec.DESKeySpec;
+import org.apache.commons.codec.binary.Base64;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class DESUtils
+{
+private static final String DES = "DES";
+/*  31 */   private static final Charset CHARSET = Charset.forName("UTF-8");
+
+
+
+
+
+
+
+
+
+public static String encrypt(String data, String key) throws Exception {
+/*  42 */     return HexUtils.bytesToHex(encrypt(data.getBytes(CHARSET), key.getBytes(CHARSET)));
+}
+
+
+
+
+
+
+
+
+
+public static byte[] encrypt(byte[] data, String key) throws Exception {
+/*  54 */     return encrypt(data, key.getBytes(CHARSET));
+}
+
+
+
+
+
+
+
+
+
+public static String encryptBase64(String data, String key) throws Exception {
+/*  66 */     return Base64.encodeBase64String(encrypt(data.getBytes(CHARSET), key.getBytes(CHARSET)));
+}
+
+
+
+
+
+
+
+
+
+public static String decrypt(String data, String key) throws Exception {
+/*  78 */     return new String(decrypt(HexUtils.hexStringToByte(data), key.getBytes(CHARSET)), CHARSET);
+}
+
+
+
+
+
+
+
+
+
+public static byte[] decrypt(byte[] data, String key) throws Exception {
+/*  90 */     return decrypt(data, key.getBytes(CHARSET));
+}
+
+
+
+
+
+
+
+
+
+public static String decryptBase64(String data, String key) throws Exception {
+return new String(decrypt(Base64.decodeBase64(data), key.getBytes(CHARSET)), CHARSET);
+}
+
+
+
+
+
+
+
+
+
+
+public static byte[] encrypt(byte[] data, byte[] key) throws Exception {
+SecureRandom sr = new SecureRandom();
+SecretKey securekey = getSecretKey(key);
+
+
+Cipher cipher = Cipher.getInstance("DES");
+cipher.init(1, securekey, sr);
+
+return cipher.doFinal(data);
+}
+
+
+
+
+
+
+
+
+
+
+public static byte[] decrypt(byte[] data, byte[] key) throws Exception {
+SecureRandom sr = new SecureRandom();
+SecretKey securekey = getSecretKey(key);
+
+
+Cipher cipher = Cipher.getInstance("DES");
+cipher.init(2, securekey, sr);
+
+return cipher.doFinal(data);
+}
+
+
+
+
+
+
+
+
+private static SecretKey getSecretKey(byte[] key) throws Exception {
+SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
+return keyFactory.generateSecret(new DESKeySpec(key));
+}
+}
+
+
@@ -0,0 +1,58 @@
+package cn.cloudwalk.cloud.security;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class HexUtils
+{
+public static String bytesToHex(byte[] src) {
+StringBuilder sb = new StringBuilder();
+for (int i = 0; i < src.length; i++) {
+String hex = Integer.toHexString(src[i] & 0xFF);
+if (hex.length() == 1) {
+hex = '0' + hex;
+}
+
+sb.append(hex.toUpperCase());
+} 
+
+return sb.toString();
+}
+
+
+
+
+
+
+
+
+public static byte[] hexStringToByte(String hexStr) {
+if (hexStr.length() < 1) {
+return null;
+}
+
+byte[] result = new byte[hexStr.length() / 2];
+for (int i = 0; i < hexStr.length() / 2; i++) {
+int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
+int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
+result[i] = (byte)(high * 16 + low);
+} 
+
+return result;
+}
+}
+
+
@@ -0,0 +1,239 @@
+package cn.cloudwalk.cloud.security;
+
+import java.security.Key;
+import java.security.KeyFactory;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.security.Signature;
+import java.security.interfaces.RSAPrivateKey;
+import java.security.interfaces.RSAPublicKey;
+import java.security.spec.PKCS8EncodedKeySpec;
+import java.security.spec.X509EncodedKeySpec;
+import java.util.HashMap;
+import java.util.Map;
+import javax.crypto.Cipher;
+import org.apache.commons.codec.binary.Base64;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class RSAUtils
+{
+private static final int KEY_SIZE = 1024;
+public static final String KEY_RSA = "RSA";
+public static final String KEY_RSA_PUBLICKEY = "RSAPublicKey";
+public static final String KEY_RSA_PRIVATEKEY = "RSAPrivateKey";
+private static final String KEY_RSA_SIGNATURE = "MD5withRSA";
+
+public static Map<String, Object> initKey() throws NoSuchAlgorithmException {
+/*  66 */     KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
+/*  67 */     keyPairGenerator.initialize(1024);
+/*  68 */     KeyPair keyPair = keyPairGenerator.generateKeyPair();
+
+
+/*  71 */     RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic();
+/*  72 */     RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();
+
+
+/*  75 */     Map<String, Object> map = new HashMap<>();
+/*  76 */     map.put("RSAPublicKey", publicKey);
+/*  77 */     map.put("RSAPrivateKey", privateKey);
+
+/*  79 */     return map;
+}
+
+
+
+
+
+
+public static byte[] getPublicKey(Map<String, Object> map) {
+/*  88 */     return ((Key)map.get("RSAPublicKey")).getEncoded();
+}
+
+
+
+
+
+
+public static byte[] getPrivateKey(Map<String, Object> map) {
+/*  97 */     return ((Key)map.get("RSAPrivateKey")).getEncoded();
+}
+
+
+
+
+
+
+
+
+public static byte[] encryptByPublic(byte[] data, byte[] keyBytes) throws Exception {
+X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
+
+
+KeyFactory factory = KeyFactory.getInstance("RSA");
+PublicKey publicKey = factory.generatePublic(keySpec);
+
+
+Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
+cipher.init(1, publicKey);
+
+return cipher.doFinal(data);
+}
+
+
+
+
+
+
+
+
+
+
+public static byte[] decryptByPrivate(byte[] data, byte[] keyBytes) throws Exception {
+PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
+KeyFactory factory = KeyFactory.getInstance("RSA");
+PrivateKey privateKey = factory.generatePrivate(keySpec);
+
+
+Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
+cipher.init(2, privateKey);
+
+return cipher.doFinal(data);
+}
+
+
+
+
+
+
+
+
+
+public static byte[] encryptByPrivate(byte[] data, byte[] keyBytes) throws Exception {
+PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
+KeyFactory factory = KeyFactory.getInstance("RSA");
+PrivateKey privateKey = factory.generatePrivate(keySpec);
+
+
+Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
+cipher.init(1, privateKey);
+
+return cipher.doFinal(data);
+}
+
+
+
+
+
+
+
+
+public static byte[] decryptByPublic(byte[] data, byte[] keyBytes) throws Exception {
+X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
+
+
+KeyFactory factory = KeyFactory.getInstance("RSA");
+PublicKey publicKey = factory.generatePublic(keySpec);
+
+
+Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
+cipher.init(2, publicKey);
+
+return cipher.doFinal(data);
+}
+
+
+
+
+
+
+
+
+public static String sign(byte[] data, byte[] privateKey) throws Exception {
+PKCS8EncodedKeySpec pkcs = new PKCS8EncodedKeySpec(privateKey);
+
+
+KeyFactory factory = KeyFactory.getInstance("RSA");
+PrivateKey key = factory.generatePrivate(pkcs);
+
+
+Signature signature = Signature.getInstance("MD5withRSA");
+signature.initSign(key);
+signature.update(data);
+
+return Base64.encodeBase64String(signature.sign());
+}
+
+
+
+
+
+
+
+
+
+public static boolean verify(byte[] data, byte[] publicKey, String sign) throws Exception {
+X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
+
+
+KeyFactory factory = KeyFactory.getInstance("RSA");
+PublicKey key = factory.generatePublic(keySpec);
+
+
+Signature signature = Signature.getInstance("MD5withRSA");
+signature.initVerify(key);
+signature.update(data);
+
+return signature.verify(Base64.decodeBase64(sign));
+}
+
+public static void main(String[] args) throws Exception {
+Map<String, Object> map = initKey();
+
+String str = "这是一段测试报文";
+byte[] ret = encryptByPublic(str.getBytes("utf-8"), getPublicKey(map));
+System.out.println(Base64.encodeBase64String(ret));
+
+System.out.println(new String(decryptByPrivate(ret, getPrivateKey(map)), "utf-8"));
+}
+}
+
+
@@ -0,0 +1,392 @@
+package cn.cloudwalk.cloud.security;
+
+import java.io.UnsupportedEncodingException;
+import java.util.Arrays;
+import org.apache.commons.codec.binary.Base64;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class SM4Utils
+{
+private static final String ENCODE = "UTF-8";
+private static final int ENCRYPT = 1;
+private static final int DECRYPT = 0;
+public static final int ROUND = 32;
+private static final int BLOCK = 16;
+/*  46 */   private static byte[] Sbox = new byte[] { -42, -112, -23, -2, -52, -31, 61, -73, 22, -74, 20, -62, 40, -5, 44, 5, 43, 103, -102, 118, 42, -66, 4, -61, -86, 68, 19, 38, 73, -122, 6, -103, -100, 66, 80, -12, -111, -17, -104, 122, 51, 84, 11, 67, -19, -49, -84, 98, -28, -77, 28, -87, -55, 8, -24, -107, Byte.MIN_VALUE, -33, -108, -6, 117, -113, 63, -90, 71, 7, -89, -4, -13, 115, 23, -70, -125, 89, 60, 25, -26, -123, 79, -88, 104, 107, -127, -78, 113, 100, -38, -117, -8, -21, 15, 75, 112, 86, -99, 53, 30, 36, 14, 94, 99, 88, -47, -94, 37, 34, 124, 59, 1, 33, 120, -121, -44, 0, 70, 87, -97, -45, 39, 82, 76, 54, 2, -25, -96, -60, -56, -98, -22, -65, -118, -46, 64, -57, 56, -75, -93, -9, -14, -50, -7, 97, 21, -95, -32, -82, 93, -92, -101, 52, 26, 85, -83, -109, 50, 48, -11, -116, -79, -29, 29, -10, -30, 46, -126, 102, -54, 96, -64, 41, 35, -85, 13, 83, 78, 111, -43, -37, 55, 69, -34, -3, -114, 47, 3, -1, 106, 114, 109, 108, 91, 81, -115, 27, -81, -110, -69, -35, -68, Byte.MAX_VALUE, 17, -39, 92, 65, 31, 16, 90, -40, 10, -63, 49, -120, -91, -51, 123, -67, 45, 116, -48, 18, -72, -27, -76, -80, -119, 105, -105, 74, 12, -106, 119, 126, 101, -71, -15, 9, -59, 110, -58, -124, 24, -16, 125, -20, 58, -36, 77, 32, 121, -18, 95, 62, -41, -53, 57, 72 };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*  71 */   private static int[] CK = new int[] { 462357, 472066609, 943670861, 1415275113, 1886879365, -1936483679, -1464879427, -993275175, -521670923, -66909679, 404694573, 876298825, 1347903077, 1819507329, -2003855715, -1532251463, -1060647211, -589042959, -117504499, 337322537, 808926789, 1280531041, 1752135293, -2071227751, -1599623499, -1128019247, -656414995, -184876535, 269950501, 741554753, 1213159005, 1684763257 };
+
+
+
+
+private static int rotl(int x, int y) {
+/*  77 */     return x << y | x >>> 32 - y;
+}
+
+private static int byteSub(int a) {
+/*  81 */     return (Sbox[a >>> 24 & 0xFF] & 0xFF) << 24 | (Sbox[a >>> 16 & 0xFF] & 0xFF) << 16 | (Sbox[a >>> 8 & 0xFF] & 0xFF) << 8 | Sbox[a & 0xFF] & 0xFF;
+}
+
+
+private static int left1(int b) {
+/*  86 */     return b ^ rotl(b, 2) ^ rotl(b, 10) ^ rotl(b, 18) ^ rotl(b, 24);
+}
+
+private static int left2(int b) {
+/*  90 */     return b ^ rotl(b, 13) ^ rotl(b, 23);
+}
+
+
+private static void sms4Crypt(byte[] input, byte[] output, int[] rk) {
+/*  95 */     if (input == null) {
+return;
+}
+
+
+int[] x = new int[4];
+int[] tmp = new int[4];
+for (int i = 0; i < 4; i++) {
+tmp[0] = input[0 + 4 * i] & 0xFF;
+tmp[1] = input[1 + 4 * i] & 0xFF;
+tmp[2] = input[2 + 4 * i] & 0xFF;
+tmp[3] = input[3 + 4 * i] & 0xFF;
+x[i] = tmp[0] << 24 | tmp[1] << 16 | tmp[2] << 8 | tmp[3];
+} 
+for (int r = 0; r < 32; r += 4) {
+int mid = x[1] ^ x[2] ^ x[3] ^ rk[r + 0];
+mid = byteSub(mid);
+x[0] = x[0] ^ left1(mid);
+
+mid = x[2] ^ x[3] ^ x[0] ^ rk[r + 1];
+mid = byteSub(mid);
+x[1] = x[1] ^ left1(mid);
+
+mid = x[3] ^ x[0] ^ x[1] ^ rk[r + 2];
+mid = byteSub(mid);
+x[2] = x[2] ^ left1(mid);
+
+mid = x[0] ^ x[1] ^ x[2] ^ rk[r + 3];
+mid = byteSub(mid);
+x[3] = x[3] ^ left1(mid);
+} 
+
+
+for (int j = 0; j < 16; j += 4) {
+output[j] = (byte)(x[3 - j / 4] >>> 24 & 0xFF);
+output[j + 1] = (byte)(x[3 - j / 4] >>> 16 & 0xFF);
+output[j + 2] = (byte)(x[3 - j / 4] >>> 8 & 0xFF);
+output[j + 3] = (byte)(x[3 - j / 4] & 0xFF);
+} 
+}
+
+
+private static void sms4KeyExt(byte[] key, int[] rk, int cryptFlag) {
+int[] x = new int[4];
+int[] tmp = new int[4];
+for (int i = 0; i < 4; i++) {
+tmp[0] = key[0 + 4 * i] & 0xFF;
+tmp[1] = key[1 + 4 * i] & 0xFF;
+tmp[2] = key[2 + 4 * i] & 0xFF;
+tmp[3] = key[3 + 4 * i] & 0xFF;
+x[i] = tmp[0] << 24 | tmp[1] << 16 | tmp[2] << 8 | tmp[3];
+} 
+x[0] = x[0] ^ 0xA3B1BAC6;
+x[1] = x[1] ^ 0x56AA3350;
+x[2] = x[2] ^ 0x677D9197;
+x[3] = x[3] ^ 0xB27022DC; int r;
+for (r = 0; r < 32; r += 4) {
+int mid = x[1] ^ x[2] ^ x[3] ^ CK[r + 0];
+mid = byteSub(mid);
+x[0] = x[0] ^ left2(mid); rk[r + 0] = x[0] ^ left2(mid);
+
+mid = x[2] ^ x[3] ^ x[0] ^ CK[r + 1];
+mid = byteSub(mid);
+x[1] = x[1] ^ left2(mid); rk[r + 1] = x[1] ^ left2(mid);
+
+mid = x[3] ^ x[0] ^ x[1] ^ CK[r + 2];
+mid = byteSub(mid);
+x[2] = x[2] ^ left2(mid); rk[r + 2] = x[2] ^ left2(mid);
+
+mid = x[0] ^ x[1] ^ x[2] ^ CK[r + 3];
+mid = byteSub(mid);
+x[3] = x[3] ^ left2(mid); rk[r + 3] = x[3] ^ left2(mid);
+} 
+
+
+if (cryptFlag == 0) {
+for (r = 0; r < 16; r++) {
+int mid = rk[r];
+rk[r] = rk[31 - r];
+rk[31 - r] = mid;
+} 
+}
+}
+
+private static int sms4(byte[] in, int inLen, byte[] key, byte[] out, int cryptFlag) {
+int point = 0;
+int[] roundKey = new int[32];
+
+sms4KeyExt(key, roundKey, cryptFlag);
+byte[] input = null;
+byte[] output = new byte[16];
+
+while (inLen >= 16) {
+input = Arrays.copyOfRange(in, point, point + 16);
+sms4Crypt(input, output, roundKey);
+System.arraycopy(output, 0, out, point, 16);
+inLen -= 16;
+point += 16;
+} 
+
+return 0;
+}
+
+
+
+
+
+
+
+
+
+public static String encodeSMS4(String plaintext, String key) throws UnsupportedEncodingException {
+for (int i = (plaintext.getBytes("UTF-8")).length % 16; i < 16; i++) {
+plaintext = plaintext + Character.MIN_VALUE;
+}
+
+byte[] keyHex = key.getBytes("UTF-8");
+return Base64.encodeBase64String(encodeSMS4(plaintext.getBytes("UTF-8"), keyHex));
+}
+
+
+
+
+
+
+
+
+
+public static byte[] encodeSMS4(String plaintext, byte[] key) throws UnsupportedEncodingException {
+if (plaintext == null || plaintext.equals("")) {
+return null;
+}
+
+for (int i = (plaintext.getBytes("UTF-8")).length % 16; i < 16; i++) {
+plaintext = plaintext + Character.MIN_VALUE;
+}
+
+return encodeSMS4(plaintext.getBytes("UTF-8"), key);
+}
+
+
+
+
+
+
+
+
+
+public static byte[] encodeSMS4(byte[] data, String key) throws UnsupportedEncodingException {
+byte[] keyHex = key.getBytes("UTF-8");
+return encodeSMS4(data, keyHex);
+}
+
+
+
+
+
+
+
+
+public static byte[] encodeSMS4(byte[] plaintext, byte[] key) {
+byte[] ciphertext = new byte[plaintext.length];
+
+int k = 0;
+int plainLen = plaintext.length;
+while (k + 16 <= plainLen) {
+byte[] cellPlain = new byte[16];
+for (int i = 0; i < 16; i++) {
+cellPlain[i] = plaintext[k + i];
+}
+
+byte[] cellCipher = encode16(cellPlain, key);
+for (int j = 0; j < cellCipher.length; j++) {
+ciphertext[k + j] = cellCipher[j];
+}
+
+k += 16;
+} 
+
+return ciphertext;
+}
+
+
+
+
+
+
+
+
+
+
+public static String decodeSMS4(String cipherString, String key) throws UnsupportedEncodingException {
+byte[] ciphertext = Base64.decodeBase64(cipherString);
+byte[] keyHex = key.getBytes("UTF-8");
+
+return decodeSMS4toString(ciphertext, keyHex);
+}
+
+
+
+
+
+
+
+
+
+
+public static byte[] decodeSMS4(byte[] data, String key) throws UnsupportedEncodingException {
+byte[] keyHex = key.getBytes("UTF-8");
+
+return decodeSMS4(data, keyHex);
+}
+
+
+
+
+
+
+
+
+
+public static byte[] decodeSMS4(byte[] ciphertext, byte[] key) {
+if (ciphertext == null) {
+return null;
+}
+
+byte[] plaintext = new byte[ciphertext.length];
+
+int k = 0;
+int cipherLen = ciphertext.length;
+while (k + 16 <= cipherLen) {
+byte[] cellCipher = new byte[16];
+for (int i = 0; i < 16; i++) {
+cellCipher[i] = ciphertext[k + i];
+}
+
+byte[] cellPlain = decode16(cellCipher, key);
+for (int j = 0; j < cellPlain.length; j++) {
+plaintext[k + j] = cellPlain[j];
+}
+
+k += 16;
+} 
+
+return plaintext;
+}
+
+
+
+
+
+
+
+
+public static String decodeSMS4toString(byte[] ciphertext, byte[] key) {
+byte[] plaintext = decodeSMS4(ciphertext, key);
+if (plaintext == null) {
+return "";
+}
+
+return (new String(plaintext)).replaceAll("\000", "");
+}
+
+
+
+
+
+
+
+
+private static byte[] encode16(byte[] plaintext, byte[] key) {
+byte[] cipher = new byte[16];
+sms4(plaintext, 16, key, cipher, 1);
+
+return cipher;
+}
+
+
+
+
+
+
+
+
+private static byte[] decode16(byte[] ciphertext, byte[] key) {
+byte[] plain = new byte[16];
+sms4(ciphertext, 16, key, plain, 0);
+
+return plain;
+}
+
+public static void main(String[] args) throws Exception {
+System.out.println(encodeSMS4("1aaaa", "465535453546785465342345"));
+System.out.println(decodeSMS4(encodeSMS4("1aaaa", "465535453546785465342345"), "465535453546785465342345"));
+}
+}
+
+
@@ -0,0 +1,30 @@
+package cn.cloudwalk.cloud.sensitive;
+
+import cn.cloudwalk.cloud.enums.SensitiveType;
+
+
+
+
+
+
+
+
+
+
+public abstract class AbstractSensitiveHandler
+implements SensitiveHandler
+{
+public String sensitive(String text, SensitiveType type) {
+if (type.equals(strategy())) {
+return sensitive(text);
+}
+
+return null;
+}
+
+public abstract SensitiveType strategy();
+
+public abstract String sensitive(String paramString);
+}
+
+
@@ -0,0 +1,56 @@
+package cn.cloudwalk.cloud.sensitive;
+
+import cn.cloudwalk.cloud.enums.SensitiveType;
+import cn.cloudwalk.cloud.sensitive.handler.BankCardSensitiveHandler;
+import cn.cloudwalk.cloud.sensitive.handler.ChineseNameSensitiveHandler;
+import cn.cloudwalk.cloud.sensitive.handler.CnapsCodeSensitiveHandler;
+import cn.cloudwalk.cloud.sensitive.handler.EmailSensitiveHandler;
+import cn.cloudwalk.cloud.sensitive.handler.FixedPhoneSensitiveHandler;
+import cn.cloudwalk.cloud.sensitive.handler.IdCardSensitiveHandler;
+import cn.cloudwalk.cloud.sensitive.handler.MobilePhoneSensitiveHandler;
+import java.util.ArrayList;
+import java.util.List;
+
+
+
+
+
+
+
+
+
+
+
+
+public class CompositeSensitiveHandler
+implements SensitiveHandler
+{
+private static List<SensitiveHandler> SENSITIVE_HANDLER_LIST = new ArrayList<>();
+
+
+
+
+static {
+SENSITIVE_HANDLER_LIST.add(new IdCardSensitiveHandler());
+SENSITIVE_HANDLER_LIST.add(new EmailSensitiveHandler());
+SENSITIVE_HANDLER_LIST.add(new BankCardSensitiveHandler());
+SENSITIVE_HANDLER_LIST.add(new CnapsCodeSensitiveHandler());
+SENSITIVE_HANDLER_LIST.add(new FixedPhoneSensitiveHandler());
+SENSITIVE_HANDLER_LIST.add(new ChineseNameSensitiveHandler());
+SENSITIVE_HANDLER_LIST.add(new MobilePhoneSensitiveHandler());
+}
+
+
+public String sensitive(String text, SensitiveType type) {
+for (SensitiveHandler handler : SENSITIVE_HANDLER_LIST) {
+String result = handler.sensitive(text, type);
+if (result != null) {
+return result;
+}
+} 
+
+return text;
+}
+}
+
+
@@ -0,0 +1,82 @@
+package cn.cloudwalk.cloud.sensitive;
+
+import cn.cloudwalk.cloud.annotation.I8ndescribed;
+import cn.cloudwalk.cloud.utils.ApplicationContextUtils;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.BeanProperty;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonSerializer;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.ser.ContextualSerializer;
+import java.io.IOException;
+import java.util.Objects;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class I8ndescribedSerialize
+extends JsonSerializer<String>
+implements ContextualSerializer
+{
+private I8ndescribed i8ndescribed;
+
+public I8ndescribedSerialize() {}
+
+public I8ndescribedSerialize(I8ndescribed i8ndescribed) {
+this.i8ndescribed = i8ndescribed;
+}
+
+
+
+
+public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) throws JsonMappingException {
+if (property != null) {
+if (Objects.equals(property.getType().getRawClass(), String.class)) {
+
+I8ndescribed cloudwalkI8N = (I8ndescribed)property.getAnnotation(I8ndescribed.class);
+if (cloudwalkI8N == null) {
+cloudwalkI8N = (I8ndescribed)property.getContextAnnotation(I8ndescribed.class);
+}
+
+if (cloudwalkI8N != null) {
+return new I8ndescribedSerialize(cloudwalkI8N);
+}
+} 
+
+return prov.findValueSerializer(property.getType(), property);
+} 
+
+return prov.findNullValueSerializer(property);
+}
+
+
+
+public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException, JsonProcessingException {
+if (this.i8ndescribed == null) {
+gen.writeString(value);
+} else {
+gen.writeString(ApplicationContextUtils.getMessage(value));
+} 
+}
+}
+
+
@@ -0,0 +1,9 @@
+package cn.cloudwalk.cloud.sensitive;
+
+import cn.cloudwalk.cloud.enums.SensitiveType;
+
+public interface SensitiveHandler {
+  String sensitive(String paramString, SensitiveType paramSensitiveType);
+}
+
+
@@ -0,0 +1,128 @@
+package cn.cloudwalk.cloud.sensitive;
+
+import cn.cloudwalk.cloud.annotation.SensitiveField;
+import cn.cloudwalk.cloud.enums.SensitiveType;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.BeanProperty;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonSerializer;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.ser.ContextualSerializer;
+import java.io.IOException;
+import java.util.Objects;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class SensitiveInfoSerialize
+extends JsonSerializer<String>
+implements ContextualSerializer
+{
+/*  34 */   private static final Logger logger = LoggerFactory.getLogger(SensitiveInfoSerialize.class);
+
+
+
+
+/*  39 */   private static CompositeSensitiveHandler handler = new CompositeSensitiveHandler();
+
+
+
+
+private SensitiveField sensitiveField;
+
+
+
+
+
+public SensitiveInfoSerialize() {}
+
+
+
+
+
+public SensitiveInfoSerialize(SensitiveField sensitiveField) {
+/*  57 */     this.sensitiveField = sensitiveField;
+}
+
+
+
+
+public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) throws JsonMappingException {
+/*  64 */     if (property != null) {
+
+
+/*  67 */       if (Objects.equals(property.getType().getRawClass(), String.class)) {
+
+
+/*  70 */         SensitiveField sensitiveField = (SensitiveField)property.getAnnotation(SensitiveField.class);
+/*  71 */         if (sensitiveField == null) {
+/*  72 */           sensitiveField = (SensitiveField)property.getContextAnnotation(SensitiveField.class);
+}
+
+
+/*  76 */         if (sensitiveField != null) {
+/*  77 */           return new SensitiveInfoSerialize(sensitiveField);
+}
+}
+else {
+
+/*  82 */         logger.debug("未对字段进行序列化，因为数据类型非String");
+} 
+
+/*  85 */       return prov.findValueSerializer(property.getType(), property);
+} 
+
+/*  88 */     return prov.findNullValueSerializer(property);
+}
+
+
+
+
+public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException, JsonProcessingException {
+/*  95 */     SensitiveType type = this.sensitiveField.type();
+/*  96 */     if (!SensitiveType.NULL.equals(type)) {
+/*  97 */       String ret = handler.sensitive(value, type);
+/*  98 */       gen.writeString(ret);
+} else {
+gen.writeString(split(value));
+} 
+}
+
+
+
+
+
+
+
+private String split(String text) {
+if (StringUtils.isBlank(text)) {
+return "";
+}
+
+int length = text.length();
+if (this.sensitiveField.prefix() + this.sensitiveField.suffix() >= length) {
+return text;
+}
+
+String left = StringUtils.left(text, this.sensitiveField.prefix());
+String right = StringUtils.right(text, this.sensitiveField.suffix());
+
+length = this.sensitiveField.suffix() + this.sensitiveField.split();
+return left.concat(StringUtils.leftPad(right, length, '*'));
+}
+}
+
+
@@ -0,0 +1,45 @@
+package cn.cloudwalk.cloud.sensitive.configuration;
+
+import cn.cloudwalk.cloud.sensitive.introspector.DisableI8ndescribedIntrospector;
+import com.fasterxml.jackson.databind.AnnotationIntrospector;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+@Configuration
+@EnableConfigurationProperties({I8ndescribedProperties.class})
+@ConditionalOnProperty(name = {"disable"}, havingValue = "true", matchIfMissing = false, prefix = "cloudwalk.i8ndescribed")
+public class I8ndescribedConfiguration
+{
+@Autowired
+private ObjectMapper objectMapper;
+
+@Bean
+public DisableI8ndescribedIntrospector disableI8ndescribedIntrospector() {
+DisableI8ndescribedIntrospector intrspector = new DisableI8ndescribedIntrospector();
+this.objectMapper.setAnnotationIntrospector((AnnotationIntrospector)intrspector);
+
+return intrspector;
+}
+}
+
+
@@ -0,0 +1,45 @@
+package cn.cloudwalk.cloud.sensitive.configuration;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+@ConfigurationProperties(prefix = "cloudwalk.sensitive")
+public class I8ndescribedProperties
+{
+public static final String I8NDESCRIBED_PREFIX = "cloudwalk.i8ndescribed";
+public static final String I8NDESCRIBED_DISABLE_VALUE = "true";
+public static final String I8NDESCRIBED_KEY = "disable";
+private String disable = "true";
+
+public String getDisable() {
+return this.disable;
+}
+
+public void setDisable(String disable) {
+this.disable = disable;
+}
+}
+
+
@@ -0,0 +1,44 @@
+package cn.cloudwalk.cloud.sensitive.configuration;
+
+import cn.cloudwalk.cloud.sensitive.introspector.DisableSensitiveInfoIntrospector;
+import com.fasterxml.jackson.databind.AnnotationIntrospector;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+@Configuration
+@EnableConfigurationProperties({SensitiveInfoProperties.class})
+@ConditionalOnProperty(name = {"disable"}, havingValue = "true", matchIfMissing = false, prefix = "cloudwalk.sensitive")
+public class SensitiveInfoConfiguration
+{
+@Autowired
+private ObjectMapper objectMapper;
+
+@Bean
+public DisableSensitiveInfoIntrospector disableSensitiveInfoIntrospector() {
+DisableSensitiveInfoIntrospector intrspector = new DisableSensitiveInfoIntrospector();
+this.objectMapper.setAnnotationIntrospector((AnnotationIntrospector)intrspector);
+
+return intrspector;
+}
+}
+
+
@@ -0,0 +1,44 @@
+package cn.cloudwalk.cloud.sensitive.configuration;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+@ConfigurationProperties(prefix = "cloudwalk.sensitive")
+public class SensitiveInfoProperties
+{
+public static final String FIELD_SENSITIVE_PREFIX = "cloudwalk.sensitive";
+public static final String FIELD_SENSITIVE_DISABLE_VALUE = "true";
+public static final String FIELD_SENSITIVE_KEY = "disable";
+private String disable = "true";
+
+public String getDisable() {
+return this.disable;
+}
+
+public void setDisable(String disable) {
+this.disable = disable;
+}
+}
+
+
@@ -0,0 +1,40 @@
+package cn.cloudwalk.cloud.sensitive.handler;
+
+import cn.cloudwalk.cloud.enums.SensitiveType;
+import cn.cloudwalk.cloud.sensitive.AbstractSensitiveHandler;
+import org.apache.commons.lang3.StringUtils;
+
+
+
+
+
+
+
+
+
+
+public class BankCardSensitiveHandler
+extends AbstractSensitiveHandler
+{
+public SensitiveType strategy() {
+return SensitiveType.BANK_CARD;
+}
+
+
+public String sensitive(String text) {
+if (StringUtils.isBlank(text)) {
+return "";
+}
+
+int length = StringUtils.length(text);
+if (length < 10) {
+return text;
+}
+String left = StringUtils.left(text, 6);
+String right = StringUtils.right(text, 4);
+
+return left.concat(StringUtils.removeStart(StringUtils.leftPad(right, length, '*'), "******"));
+}
+}
+
+
@@ -0,0 +1,36 @@
+package cn.cloudwalk.cloud.sensitive.handler;
+
+import cn.cloudwalk.cloud.enums.SensitiveType;
+import cn.cloudwalk.cloud.sensitive.AbstractSensitiveHandler;
+import org.apache.commons.lang3.StringUtils;
+
+
+
+
+
+
+
+
+
+
+public class ChineseNameSensitiveHandler
+extends AbstractSensitiveHandler
+{
+public SensitiveType strategy() {
+return SensitiveType.CHINESE_NAME;
+}
+
+
+public String sensitive(String text) {
+if (StringUtils.isBlank(text)) {
+return "";
+}
+
+int length = StringUtils.length(text);
+String w = StringUtils.left(text, 1);
+
+return StringUtils.rightPad(w, (length > 4) ? 4 : length, '*');
+}
+}
+
+
@@ -0,0 +1,38 @@
+package cn.cloudwalk.cloud.sensitive.handler;
+
+import cn.cloudwalk.cloud.enums.SensitiveType;
+import cn.cloudwalk.cloud.sensitive.AbstractSensitiveHandler;
+import org.apache.commons.lang3.StringUtils;
+
+
+
+
+
+
+
+
+
+
+public class CnapsCodeSensitiveHandler
+extends AbstractSensitiveHandler
+{
+public SensitiveType strategy() {
+return SensitiveType.CNAPS_CODE;
+}
+
+
+public String sensitive(String text) {
+if (StringUtils.isBlank(text)) {
+return "";
+}
+
+int length = StringUtils.length(text);
+if (length < 2) {
+return text;
+}
+String left = StringUtils.left(text, 2);
+return StringUtils.rightPad(left, length, '*');
+}
+}
+
+
@@ -0,0 +1,38 @@
+package cn.cloudwalk.cloud.sensitive.handler;
+
+import cn.cloudwalk.cloud.enums.SensitiveType;
+import cn.cloudwalk.cloud.sensitive.AbstractSensitiveHandler;
+import org.apache.commons.lang3.StringUtils;
+
+
+
+
+
+
+
+
+
+
+public class EmailSensitiveHandler
+extends AbstractSensitiveHandler
+{
+public SensitiveType strategy() {
+return SensitiveType.EMAIL;
+}
+
+
+public String sensitive(String text) {
+if (StringUtils.isBlank(text)) {
+return "";
+}
+
+int index = StringUtils.indexOf(text, 64);
+if (index <= 1) {
+return text;
+}
+return StringUtils.rightPad(StringUtils.left(text, 1), index, '*')
+.concat(StringUtils.mid(text, index, StringUtils.length(text)));
+}
+}
+
+
@@ -0,0 +1,38 @@
+package cn.cloudwalk.cloud.sensitive.handler;
+
+import cn.cloudwalk.cloud.enums.SensitiveType;
+import cn.cloudwalk.cloud.sensitive.AbstractSensitiveHandler;
+import org.apache.commons.lang3.StringUtils;
+
+
+
+
+
+
+
+
+
+
+public class FixedPhoneSensitiveHandler
+extends AbstractSensitiveHandler
+{
+public SensitiveType strategy() {
+return SensitiveType.FIXED_PHONE;
+}
+
+
+public String sensitive(String text) {
+if (StringUtils.isBlank(text)) {
+return "";
+}
+
+int length = StringUtils.length(text);
+if (length <= 4) {
+return text;
+}
+String last = StringUtils.right(text, 4);
+return StringUtils.leftPad(last, length, '*');
+}
+}
+
+
@@ -0,0 +1,56 @@
+package cn.cloudwalk.cloud.sensitive.handler;
+
+import cn.cloudwalk.cloud.enums.SensitiveType;
+import cn.cloudwalk.cloud.sensitive.AbstractSensitiveHandler;
+import org.apache.commons.lang3.StringUtils;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class IdCardSensitiveHandler
+extends AbstractSensitiveHandler
+{
+private static final int ID_CARD_LENGTH = 8;
+private static final int PRE_CHAR_LENGTH = 3;
+private static final int LST_CHAR_LENGTH = 4;
+
+public SensitiveType strategy() {
+return SensitiveType.ID_CARD;
+}
+
+
+
+public String sensitive(String text) {
+if (StringUtils.isBlank(text)) {
+return "";
+}
+
+int length = StringUtils.length(text);
+if (length < 8) {
+return text;
+}
+String pre = StringUtils.left(text, 3);
+String num = StringUtils.right(text, 4);
+
+return pre.concat(StringUtils.leftPad(num, 8, '*'));
+}
+}
+
+
@@ -0,0 +1,40 @@
+package cn.cloudwalk.cloud.sensitive.handler;
+
+import cn.cloudwalk.cloud.enums.SensitiveType;
+import cn.cloudwalk.cloud.sensitive.AbstractSensitiveHandler;
+import org.apache.commons.lang3.StringUtils;
+
+
+
+
+
+
+
+
+
+
+public class MobilePhoneSensitiveHandler
+extends AbstractSensitiveHandler
+{
+public SensitiveType strategy() {
+return SensitiveType.MOBILE_PHONE;
+}
+
+
+public String sensitive(String text) {
+if (StringUtils.isBlank(text)) {
+return "";
+}
+
+int length = StringUtils.length(text);
+if (length < 7) {
+return text;
+}
+String left = StringUtils.left(text, 3);
+String right = StringUtils.right(text, 4);
+
+return left.concat(StringUtils.leftPad(right, 8, '*'));
+}
+}
+
+
@@ -0,0 +1,30 @@
+package cn.cloudwalk.cloud.sensitive.introspector;
+
+import cn.cloudwalk.cloud.annotation.I8ndescribed;
+import com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector;
+import java.lang.annotation.Annotation;
+
+
+
+
+
+
+
+
+
+
+
+public class DisableI8ndescribedIntrospector
+extends JacksonAnnotationIntrospector
+{
+private static final long serialVersionUID = 5915688650237481024L;
+
+public boolean isAnnotationBundle(Annotation ann) {
+if (ann.annotationType().equals(I8ndescribed.class)) {
+return false;
+}
+return super.isAnnotationBundle(ann);
+}
+}
+
+
@@ -0,0 +1,30 @@
+package cn.cloudwalk.cloud.sensitive.introspector;
+
+import cn.cloudwalk.cloud.annotation.SensitiveField;
+import com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector;
+import java.lang.annotation.Annotation;
+
+
+
+
+
+
+
+
+
+
+
+public class DisableSensitiveInfoIntrospector
+extends JacksonAnnotationIntrospector
+{
+private static final long serialVersionUID = 5915688650237481024L;
+
+public boolean isAnnotationBundle(Annotation ann) {
+if (ann.annotationType().equals(SensitiveField.class)) {
+return false;
+}
+return super.isAnnotationBundle(ann);
+}
+}
+
+
@@ -0,0 +1,22 @@
+package cn.cloudwalk.cloud.serial;
+
+import java.util.UUID;
+
+
+
+
+
+
+
+
+
+
+public class UUIDGeneralSerial
+implements UUIDSerial
+{
+public String uuid() {
+return UUID.randomUUID().toString().replace("-", "");
+}
+}
+
+
@@ -0,0 +1,7 @@
+package cn.cloudwalk.cloud.serial;
+
+public interface UUIDSerial {
+  String uuid();
+}
+
+
@@ -0,0 +1,85 @@
+package cn.cloudwalk.cloud.session.company;
+
+import java.io.Serializable;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class CompanyContext
+implements Serializable
+{
+private static final long serialVersionUID = 7852895769123192530L;
+private String companyId;
+private String corpCode;
+private String companyName;
+
+public String getCompanyId() {
+return this.companyId;
+}
+
+
+
+
+
+
+public void setCompanyId(String companyId) {
+this.companyId = companyId;
+}
+
+
+
+
+
+
+public String getCompanyName() {
+return this.companyName;
+}
+
+
+
+
+
+
+public void setCompanyName(String companyName) {
+this.companyName = companyName;
+}
+
+
+
+
+
+
+public String getCorpCode() {
+return this.corpCode;
+}
+
+
+
+
+
+
+public void setCorpCode(String corpCode) {
+this.corpCode = corpCode;
+}
+}
+
+
@@ -0,0 +1,29 @@
+package cn.cloudwalk.cloud.session.extend;
+
+
+
+
+
+
+
+
+
+
+
+
+public class DefaultExtendContext<T>
+implements ExtendContext
+{
+private static final long serialVersionUID = -4446456929803517034L;
+private T value;
+
+public T getValue() {
+return this.value;
+}
+
+public void setValue(T value) {
+this.value = value;
+}
+}
+
+
@@ -0,0 +1,7 @@
+package cn.cloudwalk.cloud.session.extend;
+
+import java.io.Serializable;
+
+public interface ExtendContext extends Serializable {}
+
+
@@ -0,0 +1,29 @@
+package cn.cloudwalk.cloud.session.note;
+
+
+
+
+
+
+
+
+
+
+
+public class ErrorContext
+implements NotesContext
+{
+private static final long serialVersionUID = -4931497254293052617L;
+private String message;
+
+public void setMessage(String message) {
+this.message = message;
+}
+
+
+public String getMessage() {
+return this.message;
+}
+}
+
+
@@ -0,0 +1,9 @@
+package cn.cloudwalk.cloud.session.note;
+
+import java.io.Serializable;
+
+public interface NotesContext extends Serializable {
+  String getMessage();
+}
+
+
@@ -0,0 +1,66 @@
+package cn.cloudwalk.cloud.session.user;
+
+import java.io.Serializable;
+import java.util.Set;
+import javax.validation.constraints.NotNull;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class UserContext
+implements Serializable
+{
+private static final long serialVersionUID = 1937298343860044405L;
+@NotNull(message = "10000013")
+private String caller;
+private String callerName;
+private Set<String> roles;
+
+public String getCaller() {
+return this.caller;
+}
+
+public void setCaller(String caller) {
+this.caller = caller;
+}
+
+public String getCallerName() {
+return this.callerName;
+}
+
+public void setCallerName(String callerName) {
+this.callerName = callerName;
+}
+
+public Set<String> getRoles() {
+return this.roles;
+}
+
+public void setRoles(Set<String> roles) {
+this.roles = roles;
+}
+}
+
+
@@ -0,0 +1,73 @@
+package cn.cloudwalk.cloud.utils;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeansException;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.context.i18n.LocaleContextHolder;
+import org.springframework.stereotype.Component;
+
+
+
+
+
+
+
+
+
+
+
+
+@Component
+public class ApplicationContextUtils
+implements ApplicationContextAware
+{
+private static final Logger logger = LoggerFactory.getLogger(ApplicationContextUtils.class);
+
+
+
+private static ApplicationContext context;
+
+
+
+public void setApplicationContext(ApplicationContext context) throws BeansException {
+ApplicationContextUtils.context = context;
+}
+
+
+
+
+
+public static ApplicationContext getContext() {
+return context;
+}
+
+
+
+
+
+
+
+
+public static String getMessage(String code) {
+try {
+return context.getMessage(code, null, LocaleContextHolder.getLocale());
+} catch (Exception e) {
+logger.error("Try to resolve the message falid");
+
+
+return code;
+} 
+}
+
+public static <T> T getBean(String name) {
+return (T)context.getBean(name);
+}
+
+public static <T> T getBean(Class<T> requiredType) {
+return (T)context.getBean(requiredType);
+}
+}
+
+
@@ -0,0 +1,118 @@
+package cn.cloudwalk.cloud.utils;
+
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.entity.CloudwalkBaseTimes;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import org.springframework.beans.BeanUtils;
+import org.springframework.util.CollectionUtils;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class BeanCopyUtils
+{
+public static <T> T copyProperties(Object source, Class<T> targetClazz) {
+/*  34 */     T target = null;
+try {
+/*  36 */       target = targetClazz.newInstance();
+/*  37 */       BeanUtils.copyProperties(source, target);
+/*  38 */     } catch (Exception e) {
+/*  39 */       throw new RuntimeException(e);
+} 
+
+/*  42 */     return target;
+}
+
+
+
+
+
+
+
+public static <T> T copyProperties(Object source, T target) {
+/*  52 */     BeanUtils.copyProperties(source, target);
+/*  53 */     return target;
+}
+
+
+
+
+
+
+
+
+
+public static <T> T copyProperties(Object source, CloudwalkCallContext context, T target) {
+/*  65 */     BeanUtils.copyProperties(source, target);
+/*  66 */     if (CloudwalkBaseTimes.class.isAssignableFrom(target.getClass())) {
+/*  67 */       copyProperties((CloudwalkBaseTimes)target, context);
+}
+
+/*  70 */     return target;
+}
+
+
+
+
+
+
+public static void copyProperties(CloudwalkBaseTimes dto, CloudwalkCallContext context) {
+/*  79 */     if (context == null || dto == null) {
+return;
+}
+
+/*  83 */     dto.setCreateTime(Long.valueOf(context.getCallTime().getTime()));
+/*  84 */     dto.setCreateUserId(context.getUser().getCaller());
+
+/*  86 */     dto.setLastUpdateTime(Long.valueOf(context.getCallTime().getTime()));
+/*  87 */     dto.setLastUpdateUserId(context.getUser().getCaller());
+}
+
+
+
+
+
+
+
+
+public static <V, E> List<E> copy(Collection<V> list, Class<E> clazz) {
+/*  98 */     List<E> result = new ArrayList<>(12);
+
+if (!CollectionUtils.isEmpty(list)) {
+for (V source : list) {
+E target = null;
+try {
+target = clazz.newInstance();
+BeanUtils.copyProperties(source, target);
+} catch (Exception e) {
+throw new RuntimeException(e);
+} 
+
+result.add(target);
+} 
+}
+
+return result;
+}
+}
+
+
@@ -0,0 +1,117 @@
+package cn.cloudwalk.cloud.utils;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.UUID;
+import org.joda.time.DateTime;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class CloudwalkDateUtils
+{
+/*  26 */   private static final Logger LOG = LoggerFactory.getLogger(CloudwalkDateUtils.class);
+
+
+
+
+
+private static final String YYYYMMDD = "yyyyMMdd";
+
+
+
+
+private static final String YYYY_MM_DD = "yyyy-MM-dd";
+
+
+
+
+private static final String HH_MM_SS = "HHmmss";
+
+
+
+
+
+public static Date getCurrentDate() {
+/*  49 */     return new Date(System.currentTimeMillis());
+}
+
+
+
+
+
+
+
+
+public static String formatDate(Date date, String pattern) {
+/*  60 */     SimpleDateFormat sdf = new SimpleDateFormat(pattern);
+/*  61 */     return sdf.format(date);
+}
+
+
+
+
+
+
+
+
+public static Date toDate(String str, String pattern) {
+/*  72 */     SimpleDateFormat sdf = new SimpleDateFormat(pattern);
+try {
+/*  74 */       return sdf.parse(str);
+/*  75 */     } catch (ParseException e) {
+/*  76 */       LOG.error("日期格式转换失败,原因:", e);
+/*  77 */       return null;
+} 
+}
+
+
+
+
+
+
+public static String getDate8YMD() {
+/*  87 */     return (new DateTime()).toString("yyyyMMdd");
+}
+
+
+
+
+
+public static String getTime8() {
+/*  95 */     return (new DateTime()).toString("HHmmss");
+}
+
+
+
+
+
+
+public static String getDate10YMD() {
+return (new DateTime()).toString("yyyy-MM-dd");
+}
+
+
+
+
+
+
+public static String getUUID() {
+return UUID.randomUUID().toString().replace("-", "");
+}
+}
+
+
@@ -0,0 +1,70 @@
+package cn.cloudwalk.cloud.utils;
+
+import java.util.List;
+import org.apache.commons.lang3.StringUtils;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public class CloudwalkListUtils
+{
+private static final String COMMA = ",";
+private static final String SINGLE_QUOTES = "'";
+
+public static <T> String join(List<T> list) {
+return join(list, ",");
+}
+
+
+
+
+
+
+
+public static <T> String join(List<T> list, String separator) {
+return join(list, "'", separator);
+}
+
+
+
+
+
+
+
+
+public static <T> String join(List<T> list, String chr, String separator) {
+StringBuilder ret = new StringBuilder();
+if (list != null && list.size() > 0) {
+for (T t : list) {
+if (StringUtils.isNoneEmpty(new CharSequence[] { ret })) {
+ret.append(separator);
+}
+
+ret.append(chr).append(t).append(chr);
+} 
+}
+
+return ret.toString();
+}
+}
+
+
@@ -0,0 +1,257 @@
+package cn.cloudwalk.cloud.utils;
+
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.net.SocketException;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Set;
+
+
+
+
+
+
+
+
+
+
+
+
+public class NetworkUtils
+{
+public enum Filter
+{
+/*  25 */     ALL,
+
+
+
+
+/*  30 */     UP,
+
+
+
+
+/*  35 */     VIRTUAL,
+
+
+
+
+/*  40 */     LOOPBACK,
+
+
+
+
+/*  45 */     PHYICAL_ONLY;
+
+public boolean apply(NetworkInterface input) {
+/*  48 */       if (null == input) {
+/*  49 */         return false;
+}
+try {
+byte[] hardwareAddress;
+/*  53 */         switch (this) {
+case UP:
+/*  55 */             return input.isUp();
+case VIRTUAL:
+/*  57 */             return input.isVirtual();
+case LOOPBACK:
+/*  59 */             return input.isLoopback();
+case PHYICAL_ONLY:
+/*  61 */             hardwareAddress = input.getHardwareAddress();
+/*  62 */             return (null != hardwareAddress && hardwareAddress.length > 0 && 
+
+/*  64 */               !input.isVirtual() && 
+/*  65 */               !NetworkUtils.isVMMac(hardwareAddress));
+} 
+
+/*  68 */         return true;
+}
+/*  70 */       catch (SocketException e) {
+/*  71 */         throw new RuntimeException(e);
+} 
+}
+}
+
+
+
+
+
+
+@SafeVarargs
+public static Set<NetworkInterface> getNICs(Filter... filters) {
+/*  83 */     if (null == filters) {
+/*  84 */       filters = new Filter[] { Filter.ALL };
+}
+
+/*  87 */     Set<NetworkInterface> ret = new HashSet<>();
+/*  88 */     Enumeration<NetworkInterface> networks = null;
+try {
+/*  90 */       networks = NetworkInterface.getNetworkInterfaces();
+/*  91 */     } catch (SocketException e) {
+/*  92 */       throw new RuntimeException(e);
+} 
+
+/*  95 */     while (networks.hasMoreElements()) {
+/*  96 */       boolean match = false;
+/*  97 */       NetworkInterface temp = networks.nextElement();
+/*  98 */       for (Filter v : filters) {
+/*  99 */         if (v.apply(temp))
+{
+
+match = true;
+}
+} 
+if (match) {
+ret.add(temp);
+}
+} 
+
+return ret;
+}
+
+public static Set<NetworkInterface> getPhysicalNICs() {
+return getNICs(new Filter[] { Filter.PHYICAL_ONLY, Filter.UP });
+}
+
+
+
+
+
+
+
+
+
+public static final String format(byte[] source, String separator, Radix radix) {
+if (null == source) {
+return "";
+}
+
+if (null == separator) {
+separator = "";
+}
+
+StringBuilder buf = new StringBuilder();
+for (byte b : source) {
+buf.append(separator).append(apply(Byte.valueOf(b), radix));
+}
+
+return (buf.length() > 0) ? buf.substring(separator.length()) : "";
+}
+
+private static String apply(Byte input, Radix radix) {
+return String.copyValueOf(new char[] {
+Character.forDigit((input.byteValue() & 0xF0) >> 4, radix.value), 
+Character.forDigit(input.byteValue() & 0xF, radix.value)
+});
+}
+
+
+
+
+
+public static final String formatMac(byte[] source, String separator) {
+return format(source, separator, Radix.HEX);
+}
+
+
+
+
+
+public static final String formatIp(byte[] source) {
+return format(source, ".", Radix.DEC);
+}
+
+
+
+
+
+
+
+
+public static byte[] getMacAddress(InetAddress address) {
+try {
+NetworkInterface nic = NetworkInterface.getByInetAddress(address);
+return (null == nic) ? null : nic.getHardwareAddress();
+} catch (SocketException e) {
+throw new RuntimeException(e);
+} 
+}
+
+
+
+
+
+
+public static String getMacAddress(NetworkInterface nic, String separator) {
+try {
+return format(nic.getHardwareAddress(), separator, Radix.HEX);
+} catch (SocketException e) {
+throw new RuntimeException(e);
+} 
+}
+
+
+
+
+
+
+
+public static String getMacAddress(InetAddress address, String separator) {
+return format(getMacAddress(address), separator, Radix.HEX);
+}
+
+private static byte[][] invalidMacs = new byte[][] { { 0, 5, 105 }, { 0, 28, 20 }, { 0, 12, 41 }, { 0, 80, 86 }, { 8, 0, 39 }, { 10, 0, 39 }, { 0, 3, -1 }, { 0, 21, 93 } };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+private static boolean isVMMac(byte[] mac) {
+if (null == mac) {
+return false;
+}
+
+for (byte[] invalid : invalidMacs) {
+if (invalid[0] == mac[0] && invalid[1] == mac[1] && invalid[2] == mac[2]) {
+return true;
+}
+} 
+
+return false;
+}
+
+
+
+public enum Radix
+{
+BIN(2),
+
+
+
+
+DEC(10),
+
+
+
+
+HEX(16);
+
+final int value;
+
+Radix(int radix) {
+this.value = radix;
+}
+}
+}
+
+