项目精妙（一）--拦截器

目录

一个简单的登录拦截，怎么把缓存和自定义的注解合并在一起

首先定义一个 注解

注解：就是给方法或者变量加上可以便于统一管理的属性值，

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Authorize {
    String type() default ""; 
    String value() default ""; 
    boolean disable() default false;
}

在controller中使用

就是在方法上加上注解

 @RequestMapping(value = "/get",method = RequestMethod.GET)
    @ResponseBody
    @Authorize(disable = true)
    public Object get(){
    }

拦截器

属于springMVC的拦截器，这样可以控制到 按钮级别的权限细粒度

  public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response, Object handler) throws Exception { 
     //直接将注解类 获取出来，进行判断是否需要判断权限                        
            Authorize authPrivileges = ((HandlerMethod) handler).getMethodAnnotation(Authorize.class);  
            if (authPrivileges != null && authPrivileges.disable())
                return true;
                然后根据 request中的 token 到缓存中获取信息，没有获取到 则 return false ，获取到了就给 登陆者缓存续期

                }

缓存的设计

1. 首先是适配的类 接口就是抽象方法的集合

public interface CacheAdapter { 
    Boolean exists(String type, Object key); 
    void set(String type, Object key, Object value); 
    void set(String type, Object key, Object value, int seconds); 
    <T> T get(String type, Object key, Type clsType); 
    Integer getInteger(String type, Object key); 
    BigDecimal getBigDecimal(String type, Object key);
       void clean(); 
    void remove(String type, Object key);
    }

1. 实现这个适配器的实现类
   * 由于是使用的redis，所以我先 给redis写一个抽象类（包含的是需要一些默认的实现的方法，或者是需要一直会变动的方法，捕捉子类的通用特性）

public abstract class RedisBase {
    public abstract void set(byte[] key, byte[] value);

    public abstract void set(byte[] key, byte[] value, int seconds);

    public abstract byte[] get(byte[] key);

    public abstract Boolean exists(byte[] key);

    public abstract void remove(byte[] key);

    public abstract void clean();
}

*具体的实现类

public class RedisCache implements CacheAdapter {

    protected RedisBase redis = null;

    public RedisCache() { 
    } 
    public RedisCache(Class type) {
        try {
            redis = (RedisBase) type.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    @Override
    public Boolean exists(String type, Object key) {
        byte[] _key = getHash(type, key);
        return redis.exists(_key);
    }

    @Override
    public void set(String type, Object key, Object value) {
        byte[] _key = getHash(type, key);
        String _val;

        try {
            _val = JSONUtil.stringify(value);
            redis.set(_key, _val.getBytes());
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void set(String type, Object key, Object value, int seconds) {
        byte[] _key = getHash(type, key);
        String _val;

        try {
            _val = JSONUtil.stringify(value);
            redis.set(_key, _val.getBytes(), seconds);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }

    @Override
    public <T> T get(String type, Object key, Type clsType) {
        byte[] _key = getHash(type, key);
        String _val; 
        byte[] bytes = redis.get(_key); 
        T result = null; 
        if (bytes != null) {
            _val = new String(bytes);
            try {
                result = JSONUtil.parse(_val, clsType);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return result;
    }

    @Override
    public Integer getInteger(String type, Object key) {
        return get(type, key, Integer.class);
    }

    @Override
    public void clean() {
        redis.clean();
    }

    @Override
    public void remove(String type, Object key) {
        byte[] _key = getHash(type, key);
        redis.remove(_key);
    }

    private byte[] getHash(String type, Object key) {
        return (type.toUpperCase().hashCode() + "-" + key.hashCode()).getBytes();
    }
}

1. sdf
2. asdf
3. asdf
4. asdf
5. asdf
6. 8.