4、相关工具类的编写

缺乏、安全感 2022-05-14 13:29 180阅读 0赞

![这里写图片描述][70]

`Const` ：

package com.mmall.common;
    
    public class Const { 
        public static final String CURRENT_USER="currentUser";
    
        public static final String EMAIL="email";
    
        public static final String USERNAME="username";
    
        public interface Role{ 
            int ROLE_CUSTOMER=0; //普通用户
    
            int ROLE_ADMIN=1; //管理员
    
        }
    }

`ResponseCode` ：

package com.mmall.common;
    
    public enum ResponseCode {
    
        SUCCSEE(0,"SUCCESS"),
        ERROR(1,"ERROR"),
        NEED_LOGIN(10,"NEED_LOGIN"),
        ILLEGAL_ARGUMENT(2,"ILLEGAL_ARGUMENT");
    
        private final  int code;
        private final String desc;
    
        ResponseCode(int code,String desc){
            this.code=code;
            this.desc=desc;
        }
    
        public  int getCode(){
            return code;
        }
    
        public String getDesc(){
            return desc;
        }
    }

`ServerResponse` ：

package com.mmall.common;
    
    import org.codehaus.jackson.annotate.JsonIgnore;
    import org.codehaus.jackson.map.annotate.JsonSerialize;
    
    import java.io.Serializable;
    
    @JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
    //保证序列化Json的时候，如果是null的对象，key也会消失
    public class ServerResponse<T> implements Serializable {
    
        private int status;
        private String msg;
        private T data;
    
        private ServerResponse(int status){
            this.status=status;
        }
        private ServerResponse(int status, String msg){
            this.status=status;
            this.msg=msg;
        }
        private ServerResponse(int status, T data){
            this.status=status;
            this.data=data;
        }
        private ServerResponse(int status, String msg, T data){
            this.status=status;
            this.msg=msg;
            this.data=data;
        }
    
        @JsonIgnore
     //使之不再Json序列化的结果当中
        public boolean isSussecc(){
            return this.status==ResponseCode.SUCCSEE.getCode();
        }
    
        public int getStatus(){
            return status;
        }
    
        public T getData(){
            return data;
        }
    
        public String getMsg(){
            return msg;
        }
    
    
        public static <T> ServerResponse<T> createBySuccess(){
            return new ServerResponse<T>(ResponseCode.SUCCSEE.getCode());
        }
    
        public static <T> ServerResponse<T> createBySuccessMessage(String msg){
            return new ServerResponse<T>(ResponseCode.SUCCSEE.getCode(),msg);
        }
    
        public static <T> ServerResponse<T> createBySuccess(T data){
            return new ServerResponse<T>(ResponseCode.SUCCSEE.getCode(),data);
        }
    
        public static <T> ServerResponse<T> createBySuccessMessage(String msg,T data){
            return new ServerResponse<T>(ResponseCode.SUCCSEE.getCode(),msg,data);
        }
    
        public static <T> ServerResponse<T> createByError(){
            return new ServerResponse<T>(ResponseCode.ERROR.getCode(),ResponseCode.ERROR.getDesc());
        }
    
        public static <T> ServerResponse<T> createByErrorMessage(String errorMessage){
            return new ServerResponse<T>(ResponseCode.ERROR.getCode(),errorMessage);
        }
    
        public static <T> ServerResponse<T> createByErrorCodeMessage(String errorMessage){
            return new ServerResponse<T>(ResponseCode.ERROR.getCode(),errorMessage);
        }
    }

`TokenCache` ：

package com.mmall.common;
    
    import com.google.common.cache.CacheBuilder;
    import com.google.common.cache.CacheLoader;
    import com.google.common.cache.LoadingCache;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.util.concurrent.TimeUnit;
    
    public class TokenCache { 
    
        public static Logger logger= LoggerFactory.getLogger(TokenCache.class);
    
        private static LoadingCache<String,String> localCache= CacheBuilder.newBuilder()
                .initialCapacity(1000)
                .maximumSize(10000)
                .expireAfterAccess(12, TimeUnit.HOURS).build(new CacheLoader<String, String>() {
            //默认的数据加载实现，当调用get取值的时候，如果key没有对应的值，就调用这个方法进行加载
            @Override
            public String load(String s) throws Exception {
                return "null";
            }
        });
    
    
        public static void setKey(String key,String value){
            localCache.put(key,value);
        }
    
    
        public static String getKey(String key){
            String value=null;
    
            try{
                value=localCache.get(key);
                if("null".equals(value)){
                    return null;
                }
    
                return value;
    
            }catch (Exception e){
                    logger.error("localCache get error",e);
            }
            return  null;
        }
    
    }

[70]: /images/20220514/00dbde03c3f042c6ad388a03d633e0e6.png