Initial commit: reorganized source tree

- backend/: 13 Maven modules (cw-elevator-application, cloudwalk-cloud, intelligent-cwoscomponent, ninca-crk, etc.) - frontend/: 4 Vue projects (elevator-front, cwos-portal, alarm-front, front_acs) + decompiled + scripts - scripts/: build, test-env, tools (Docker Compose, service templates, API parity) - docs/: AGENTS.md, superpowers specs, architecture docs - .gitignore: standard Java/Maven exclusions Moved from legacy maven-*/ root layout to backend/ organized structure.
2026-06-10 00:40:30 +08:00 · 2026-05-09 09:00:12 +08:00
commit 7b2bd307f1
7260 changed files with 612980 additions and 0 deletions
@@ -0,0 +1,16 @@
+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,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.PARAMETER, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface CloudwalkTrace {
+    String module() default "";
+
+    String operation() default "";
+
+    boolean code() default false;
+}
@@ -0,0 +1,13 @@
+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,13 @@
+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,16 @@
+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,24 @@
+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,93 @@
+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() {
+        return this.applicationId;
+    }
+
+    public void setApplicationId(String applicationId) {
+        this.applicationId = applicationId;
+    }
+
+    public String getDeviceId() {
+        return this.deviceId;
+    }
+
+    public void setDeviceId(String deviceId) {
+        this.deviceId = deviceId;
+    }
+
+    public String getLogId() {
+        return this.logId;
+    }
+
+    public void setLogId(String logId) {
+        this.logId = logId;
+    }
+
+    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,23 @@
+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,17 @@
+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,116 @@
+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() {
+        this.notes = (NotesContext) new ErrorContext();
+    }
+
+    public CloudwalkSessionObject(String[] values) {
+        Assert.notNull(values, "values is not null");
+        if (values.length != 4) {
+            throw new IllegalArgumentException("values is not vaild");
+        }
+
+        this.user = new UserContext();
+        this.company = new CompanyContext();
+        this.notes = (NotesContext) new ErrorContext();
+
+        this.user.setCaller(values[0]);
+        this.user.setCallerName(values[2]);
+        this.company.setCompanyId(values[1]);
+
+        setApplicationId(values[3]);
+        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,34 @@
+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,41 @@
+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,25 @@
+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,23 @@
+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,11 @@
+package cn.cloudwalk.cloud.enums;
+
+public enum DataFieldEncryptType {
+    SM4,
+
+    AES,
+
+    DES,
+
+    JAS;
+}
@@ -0,0 +1,19 @@
+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,5 @@
+package cn.cloudwalk.cloud.enums;
+
+public enum SortEnum {
+    AES, DES;
+}
@@ -0,0 +1,17 @@
+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,31 @@
+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,29 @@
+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,78 @@
+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) {
+        if (totalCount < 0L || page == null || page.getPageSize() <= 0 || page.getCurrentPage() < 0) {
+            throw new IllegalArgumentException("totalCount must more than 0");
+        }
+
+        this.datas = list;
+        this.totalRows = totalCount;
+
+        this.pageSize = page.getPageSize();
+        this.currentPage = page.getCurrentPage();
+
+        if (totalCount == 0L) {
+            this.totalPages = 0L;
+        } else if (totalCount % page.getPageSize() > 0L) {
+            this.totalPages = totalCount / page.getPageSize() + 1L;
+        } else {
+            this.totalPages = totalCount / page.getPageSize();
+        }
+
+        if (this.totalRows == 0L) {
+            this.minRowNumber = 0L;
+        } else {
+            this.minRowNumber = (this.currentPage - 1L) * page.getPageSize() + 1L;
+        }
+
+        if (this.currentPage * page.getPageSize() > this.totalRows) {
+            this.maxRowNumber = this.totalRows;
+        } else {
+            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,37 @@
+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,39 @@
+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,73 @@
+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() {
+        return this.code;
+    }
+
+    public void setCode(String code) {
+        this.code = code;
+    }
+
+    public String getMessage() {
+        return this.message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public T getData() {
+        return this.data;
+    }
+
+    public void setData(T data) {
+        this.data = data;
+    }
+
+    public boolean isSuccess() {
+        return this.success;
+    }
+
+    public void setSuccess(boolean success) {
+        this.success = success;
+    }
+
+    public static <T> CloudwalkResult<T> success(T data) {
+        CloudwalkResult<T> result = new CloudwalkResult<>();
+        result.setCode("00000000");
+        result.setMessage("success");
+        result.setSuccess(true);
+        result.setData(data);
+        return result;
+    }
+
+    public static <T> CloudwalkResult<T> fail(String code, String message, T data) {
+        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,74 @@
+package cn.cloudwalk.cloud.security;
+
+import java.nio.charset.Charset;
+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";
+    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 {
+        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
+        cipher.init(1, getSecretKey(password));
+
+        byte[] byteContent = content.getBytes(CHARSET);
+        byte[] result = cipher.doFinal(byteContent);
+
+        return HexUtils.bytesToHex(result);
+    }
+
+    public static String encryptBase64(String content, String password) throws Exception {
+        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
+        cipher.init(1, getSecretKey(password));
+
+        byte[] byteContent = content.getBytes(CHARSET);
+        byte[] result = cipher.doFinal(byteContent);
+
+        return Base64.encodeBase64String(result);
+    }
+
+    public static String decrypt(String content, String password) throws Exception {
+        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
+        cipher.init(2, getSecretKey(password));
+        byte[] result = cipher.doFinal(HexUtils.hexStringToByte(content));
+
+        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");
+        }
+    }
+
+}
@@ -0,0 +1,63 @@
+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";
+    private static final Charset CHARSET = Charset.forName("UTF-8");
+
+    public static String encrypt(String data, String key) throws Exception {
+        return HexUtils.bytesToHex(encrypt(data.getBytes(CHARSET), key.getBytes(CHARSET)));
+    }
+
+    public static byte[] encrypt(byte[] data, String key) throws Exception {
+        return encrypt(data, key.getBytes(CHARSET));
+    }
+
+    public static String encryptBase64(String data, String key) throws Exception {
+        return Base64.encodeBase64String(encrypt(data.getBytes(CHARSET), key.getBytes(CHARSET)));
+    }
+
+    public static String decrypt(String data, String key) throws Exception {
+        return new String(decrypt(HexUtils.hexStringToByte(data), key.getBytes(CHARSET)), CHARSET);
+    }
+
+    public static byte[] decrypt(byte[] data, String key) throws Exception {
+        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,32 @@
+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,121 @@
+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 {
+        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
+        keyPairGenerator.initialize(1024);
+        KeyPair keyPair = keyPairGenerator.generateKeyPair();
+
+        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
+        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
+
+        Map<String, Object> map = new HashMap<>();
+        map.put("RSAPublicKey", publicKey);
+        map.put("RSAPrivateKey", privateKey);
+
+        return map;
+    }
+
+    public static byte[] getPublicKey(Map<String, Object> map) {
+        return ((Key) map.get("RSAPublicKey")).getEncoded();
+    }
+
+    public static byte[] getPrivateKey(Map<String, Object> map) {
+        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));
+    }
+}
@@ -0,0 +1,262 @@
+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;
+    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 };
+
+    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) {
+        return x << y | x >>> 32 - y;
+    }
+
+    private static int byteSub(int a) {
+        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) {
+        return b ^ rotl(b, 2) ^ rotl(b, 10) ^ rotl(b, 18) ^ rotl(b, 24);
+    }
+
+    private static int left2(int b) {
+        return b ^ rotl(b, 13) ^ rotl(b, 23);
+    }
+
+    private static void sms4Crypt(byte[] input, byte[] output, int[] rk) {
+        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;
+    }
+}
@@ -0,0 +1,17 @@
+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,37 @@
+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,54 @@
+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,7 @@
+package cn.cloudwalk.cloud.sensitive;
+
+import cn.cloudwalk.cloud.enums.SensitiveType;
+
+public interface SensitiveHandler {
+    String sensitive(String paramString, SensitiveType paramSensitiveType);
+}
@@ -0,0 +1,84 @@
+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 {
+    private static final Logger logger = LoggerFactory.getLogger(SensitiveInfoSerialize.class);
+
+    private static CompositeSensitiveHandler handler = new CompositeSensitiveHandler();
+
+    private SensitiveField sensitiveField;
+
+    public SensitiveInfoSerialize() {
+    }
+
+    public SensitiveInfoSerialize(SensitiveField sensitiveField) {
+        this.sensitiveField = sensitiveField;
+    }
+
+    public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property)
+            throws JsonMappingException {
+        if (property != null) {
+
+            if (Objects.equals(property.getType().getRawClass(), String.class)) {
+
+                SensitiveField sensitiveField = (SensitiveField) property.getAnnotation(SensitiveField.class);
+                if (sensitiveField == null) {
+                    sensitiveField = (SensitiveField) property.getContextAnnotation(SensitiveField.class);
+                }
+
+                if (sensitiveField != null) {
+                    return new SensitiveInfoSerialize(sensitiveField);
+                }
+            } else {
+
+                logger.debug("未对字段进行序列化，因为数据类型非String");
+            }
+
+            return prov.findValueSerializer(property.getType(), property);
+        }
+
+        return prov.findNullValueSerializer(property);
+    }
+
+    public void serialize(String value, JsonGenerator gen, SerializerProvider serializers)
+            throws IOException, JsonProcessingException {
+        SensitiveType type = this.sensitiveField.type();
+        if (!SensitiveType.NULL.equals(type)) {
+            String ret = handler.sensitive(value, type);
+            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,27 @@
+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,19 @@
+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,27 @@
+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,19 @@
+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,26 @@
+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,22 @@
+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,24 @@
+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,24 @@
+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,24 @@
+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,30 @@
+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,26 @@
+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,16 @@
+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,16 @@
+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,9 @@
+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,5 @@
+package cn.cloudwalk.cloud.serial;
+
+public interface UUIDSerial {
+    String uuid();
+}
@@ -0,0 +1,34 @@
+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,14 @@
+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,6 @@
+package cn.cloudwalk.cloud.session.extend;
+
+import java.io.Serializable;
+
+public interface ExtendContext extends Serializable {
+}
@@ -0,0 +1,14 @@
+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,7 @@
+package cn.cloudwalk.cloud.session.note;
+
+import java.io.Serializable;
+
+public interface NotesContext extends Serializable {
+    String getMessage();
+}
@@ -0,0 +1,37 @@
+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,42 @@
+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,68 @@
+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) {
+        T target = null;
+        try {
+            target = targetClazz.getDeclaredConstructor().newInstance();
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+        BeanUtils.copyProperties(source, target);
+        return target;
+    }
+
+    public static <T> T copyProperties(Object source, T target) {
+        BeanUtils.copyProperties(source, target);
+        return target;
+    }
+
+    public static <T> T copyProperties(Object source, CloudwalkCallContext context, T target) {
+        BeanUtils.copyProperties(source, target);
+        if (CloudwalkBaseTimes.class.isAssignableFrom(target.getClass())) {
+            copyProperties((CloudwalkBaseTimes) target, context);
+        }
+
+        return target;
+    }
+
+    public static void copyProperties(CloudwalkBaseTimes dto, CloudwalkCallContext context) {
+        if (context == null || dto == null) {
+            return;
+        }
+
+        dto.setCreateTime(Long.valueOf(context.getCallTime().getTime()));
+        dto.setCreateUserId(context.getUser().getCaller());
+
+        dto.setLastUpdateTime(Long.valueOf(context.getCallTime().getTime()));
+        dto.setLastUpdateUserId(context.getUser().getCaller());
+    }
+
+    public static <V, E> List<E> copy(Collection<V> list, Class<E> clazz) {
+        List<E> result = new ArrayList<>(12);
+
+        if (!CollectionUtils.isEmpty(list)) {
+            for (V source : list) {
+                E target = null;
+                try {
+                    target = clazz.getDeclaredConstructor().newInstance();
+                } catch (ReflectiveOperationException e) {
+                    throw new RuntimeException(e);
+                }
+                BeanUtils.copyProperties(source, target);
+
+                result.add(target);
+            }
+        }
+
+        return result;
+    }
+}
@@ -0,0 +1,54 @@
+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 {
+    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() {
+        return new Date(System.currentTimeMillis());
+    }
+
+    public static String formatDate(Date date, String pattern) {
+        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
+        return sdf.format(date);
+    }
+
+    public static Date toDate(String str, String pattern) {
+        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
+        try {
+            return sdf.parse(str);
+        } catch (ParseException e) {
+            LOG.error("日期格式转换失败,原因:", e);
+            return null;
+        }
+    }
+
+    public static String getDate8YMD() {
+        return (new DateTime()).toString("yyyyMMdd");
+    }
+
+    public static String getTime8() {
+        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,32 @@
+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,165 @@
+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 {
+        ALL,
+
+        UP,
+
+        VIRTUAL,
+
+        LOOPBACK,
+
+        PHYICAL_ONLY;
+
+        public boolean apply(NetworkInterface input) {
+            if (null == input) {
+                return false;
+            }
+            try {
+                byte[] hardwareAddress;
+                switch (this) {
+                case UP:
+                    return input.isUp();
+                case VIRTUAL:
+                    return input.isVirtual();
+                case LOOPBACK:
+                    return input.isLoopback();
+                case PHYICAL_ONLY:
+                    hardwareAddress = input.getHardwareAddress();
+                    return (null != hardwareAddress && hardwareAddress.length > 0 &&
+
+                            !input.isVirtual() && !NetworkUtils.isVMMac(hardwareAddress));
+                }
+
+                return true;
+            } catch (SocketException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    @SafeVarargs
+    public static Set<NetworkInterface> getNICs(Filter... filters) {
+        if (null == filters) {
+            filters = new Filter[] { Filter.ALL };
+        }
+
+        Set<NetworkInterface> ret = new HashSet<>();
+        Enumeration<NetworkInterface> networks = null;
+        try {
+            networks = NetworkInterface.getNetworkInterfaces();
+        } catch (SocketException e) {
+            throw new RuntimeException(e);
+        }
+
+        while (networks.hasMoreElements()) {
+            boolean match = false;
+            NetworkInterface temp = networks.nextElement();
+            for (Filter v : filters) {
+                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;
+        }
+    }
+}