简单服务接口访问时权限以及缓存HashMap实现

实现拦截器：

 package com.zqc.share.framework.interceptor;

 import javax.annotation.Resource;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import org.springframework.web.servlet.HandlerInterceptor;
 import org.springframework.web.servlet.ModelAndView;

 import com.zqc.share.framework.security.RequestContextValidate;

 public class TokenValidateInterceptor implements HandlerInterceptor {

     @Resource(name="requestContextValidate")
     RequestContextValidate requestContextValidate;

     @Override
     public void afterCompletion(HttpServletRequest arg0,
             HttpServletResponse arg1, Object arg2, Exception arg3)
             throws Exception {
         // TODO Auto-generated method stub

     }

     @Override
     public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1,
             Object arg2, ModelAndView arg3) throws Exception {

     }

     @Override
     public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse,
             Object arg2) throws Exception {
         // TODO Auto-generated method stub
         String str = (String)httpServletRequest.getParameter("p");
         if(requestContextValidate.validate(str))return true;
         else
            return false;
     }

 }

Validate实现：

 package com.zqc.share.framework.security;

 import javax.annotation.Resource;

 import org.springframework.stereotype.Service;

 import com.zqc.share.dao.service.ServiceDao;
 import com.zqc.share.framework.cache.CacheManager;
 import com.zqc.share.framework.model.ServiceAccountItemCache;
 import com.zqc.share.model.service.ServiceAccountItem;

 @Service
 public class RequestContextValidate {

     @Resource(name="serviceDao")
     ServiceDao serviceDao;

     @Resource(name="cacheManager")
     CacheManager cacheManager;

     public boolean validate(String str){
         String[] strs = str.split("\\|");
         String keystr = strs[0];
         String token = strs[1];
         ServiceAccountItemCache serviceAccountItemCache;

         serviceAccountItemCache = cacheManager.serviceAccountMap.get(keystr);

         if(serviceAccountItemCache == null){
             ServiceAccountItem serviceAccountItem = serviceDao.getAccountItem(keystr);
             if(serviceAccountItem == null)return false;
             if(token.equals(serviceAccountItem.getToken())){
                 cacheManager.insert(keystr,serviceAccountItem);
                 System.out.println("第一次访问");
                 return true;
             }
             else
                return false;
         }
         else {
             cacheManager.update(keystr);
             System.out.println("已经访问过");
             return true;
         }

     }

 }

其中CacheManager用于管理cache

 package com.zqc.share.framework.cache;

 import java.util.Date;
 import java.util.HashMap;

 import org.springframework.stereotype.Service;

 import com.zqc.share.framework.model.ServiceAccountItemCache;
 import com.zqc.share.model.service.ServiceAccountItem;

 @Service
 public class CacheManager {

     public HashMap<String,ServiceAccountItemCache> serviceAccountMap = new HashMap<String,ServiceAccountItemCache>();

     public void insert(String keystr,ServiceAccountItem serviceAccountItem){
         ServiceAccountItemCache serviceAccountItemCache = new ServiceAccountItemCache();
         serviceAccountItemCache.setServiceAccountItem(serviceAccountItem);
         serviceAccountItemCache.setCreatetime(new Date());
         serviceAccountMap.put(keystr,serviceAccountItemCache);
     }

     public void update(String keystr){
         ServiceAccountItemCache serviceAccountItemCache = serviceAccountMap.get(keystr);
         serviceAccountItemCache.setCreatetime(new Date());
     }

 }

ServiceAccountItemCache用于缓存ServiceAccountItem,以下是model:

 package com.zqc.share.framework.model;

 import java.util.Date;

 import com.zqc.share.model.service.ServiceAccountItem;

 public class ServiceAccountItemCache {

     private ServiceAccountItem serviceAccountItem;
     private Date createtime;
     private int lifetime;

     public ServiceAccountItem getServiceAccountItem() {
         return serviceAccountItem;
     }
     public void setServiceAccountItem(ServiceAccountItem serviceAccountItem) {
         this.serviceAccountItem = serviceAccountItem;
     }
     public Date getCreatetime() {
         return createtime;
     }
     public void setCreatetime(Date createtime) {
         this.createtime = createtime;
     }
     public int getLifetime() {
         return lifetime;
     }
     public void setLifetime(int lifetime) {
         this.lifetime = lifetime;
     }
 }

 package com.zqc.share.model.service;

 public class ServiceAccountItem {

     private int id;
     private String keystr;
     private String token;

     public String getKeystr() {
         return keystr;
     }
     public void setKeystr(String keystr) {
         this.keystr = keystr;
     }
     public int getId() {
         return id;
     }
     public void setId(int id) {
         this.id = id;
     }

     public String getToken() {
         return token;
     }
     public void setToken(String token) {
         this.token = token;
     }

 }

以下是加密解密工具类，根据情况自行决定加密位置：

 package com.zqc.share.framework.security;

 import java.io.UnsupportedEncodingException;
 import java.security.InvalidKeyException;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;

 import javax.crypto.BadPaddingException;
 import javax.crypto.Cipher;
 import javax.crypto.IllegalBlockSizeException;
 import javax.crypto.KeyGenerator;
 import javax.crypto.NoSuchPaddingException;
 import javax.crypto.SecretKey;
 import javax.crypto.spec.SecretKeySpec;

 public class AESManager {

     public static String password = "our project is share";

     /**
      * 加密
      *
      * @param content 需要加密的内容
      * @param password  加密密码
      * @return
      */
     public static byte[] encrypt(String content, String password) {
             try {
                     KeyGenerator kgen = KeyGenerator.getInstance("AES");
                     kgen.init(128, new SecureRandom(password.getBytes()));
                     SecretKey secretKey = kgen.generateKey();
                     byte[] enCodeFormat = secretKey.getEncoded();
                     SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
                     Cipher cipher = Cipher.getInstance("AES");// 创建密码器
                     byte[] byteContent = content.getBytes("utf-8");
                     cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化
                     byte[] result = cipher.doFinal(byteContent);
                     return result; // 加密
             } catch (NoSuchAlgorithmException e) {
                     e.printStackTrace();
             } catch (NoSuchPaddingException e) {
                     e.printStackTrace();
             } catch (InvalidKeyException e) {
                     e.printStackTrace();
             } catch (UnsupportedEncodingException e) {
                     e.printStackTrace();
             } catch (IllegalBlockSizeException e) {
                     e.printStackTrace();
             } catch (BadPaddingException e) {
                     e.printStackTrace();
             }
             return null;
     }  

     /**解密
      * @param content  待解密内容
      * @param password 解密密钥
      * @return
      */
     public static byte[] decrypt(byte[] content, String password) {
             try {
                      KeyGenerator kgen = KeyGenerator.getInstance("AES");
                      kgen.init(128, new SecureRandom(password.getBytes()));
                      SecretKey secretKey = kgen.generateKey();
                      byte[] enCodeFormat = secretKey.getEncoded();
                      SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
                      Cipher cipher = Cipher.getInstance("AES");// 创建密码器
                     cipher.init(Cipher.DECRYPT_MODE, key);// 初始化
                     byte[] result = cipher.doFinal(content);
                     return result; // 加密
             } catch (NoSuchAlgorithmException e) {
                     e.printStackTrace();
             } catch (NoSuchPaddingException e) {
                     e.printStackTrace();
             } catch (InvalidKeyException e) {
                     e.printStackTrace();
             } catch (IllegalBlockSizeException e) {
                     e.printStackTrace();
             } catch (BadPaddingException e) {
                     e.printStackTrace();
             }
             return null;
     }  

     /**将二进制转换成16进制
      * @param buf
      * @return
      */
     public static String parseByte2HexStr(byte buf[]) {
             StringBuffer sb = new StringBuffer();
             for (int i = 0; i < buf.length; i++) {
                     String hex = Integer.toHexString(buf[i] & 0xFF);
                     if (hex.length() == 1) {
                             hex = '0' + hex;
                     }
                     sb.append(hex.toUpperCase());
             }
             return sb.toString();
     }  

     /**将16进制转换为二进制
      * @param hexStr
      * @return
      */
     public static byte[] parseHexStr2Byte(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;
     }  

 }