• springboot项目配置拦截器


    配置拦截器

    @Configuration
    public class InterceptorConfig implements WebMvcConfigurer {
    
        @Autowired
        private ResponseInteceptor appInteceptor;
     
        @Autowired
        private PersonInterceptorConfig personInteceptor;
        /**
         * 拦截器,在这里加拦截路径
         */
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            System.out.println("加载 InterceptorConfig...");
            // 全局拦截器
            registry.addInterceptor(appInteceptor).addPathPatterns("/**");
            //个人端登录页面拦截器,拦截特定的请求
            registry.addInterceptor(personInteceptor).addPathPatterns("/**/person/**");
            System.out.println("已开启拦截器!");
        }
    }
    

      处理拦截页面

    @Component
    public class PersonInterceptorConfig extends HandlerInterceptorAdapter {
    
    	@Resource
    	private RedisCache<Object> redisCache;
    
    	// 在控制器执行前调用
    	@Override
    	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
    			throws Exception {
    
    		// 获取当前登录账户信息
    		String struuid = null;
    		Cookie[] cookies = request.getCookies();
    		for (Cookie cookie : cookies) {
    			if (cookie.getName().equalsIgnoreCase(Constants.CookieKey)) {
    				struuid = cookie.getValue();
    			}
    		}
    
    		if (struuid == null) {
    			System.out.println("验证不通过");
    			return false;
    		}
    		String userName = redisCache.get(struuid).toString();
    		if (userName == null) {
    			System.out.println("验证不通过");
    			return false;
    		} else {
    			System.out.println("***********************************************");
    			return true;
    		}
    	}
    
    	@Override
    	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
    			ModelAndView modelAndView) throws Exception {
    		super.postHandle(request, response, handler, modelAndView);
    	}
    
    	// 在后端控制器执行后调用
    	@Override
    	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
    			throws Exception {
    		super.afterCompletion(request, response, handler, ex);
    	}
    }
    

      

    public interface Constants {
    	 //自定义cookie的key
    	 static String CookieKey="userid";
    	 static String RedisUserKey="userid";
    	}
    

      登录页面处理

    @Resource
    	private RedisCache<Object> redisCache;
    	
    	/**
    	 * 个人端登录页面
    	 * 
    	 * @param 
    	 */
    	@RequestMapping(value = "/personLoginById", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    	public JSONResponse personLoginById(@PathVariable("name") String name,@PathVariable("id") String id,
    			HttpServletRequest request,HttpServletResponse response) {
    		try {
    			// @PathVariable("code") String code,@PathVariable("phoneCode") String phoneCode,
    			String uuid = UUIDUtils.getUUID();
    			//Map<String,Object> map = new HashMap<String,Object>();
    		    Cookie cookie = new Cookie(Constants.CookieKey, uuid);
    		    response.addCookie(cookie);//返回客户端
    			redisCache.set(uuid, name);
    			return ResultUtil.success();
    		} catch (Exception e) {
    			logger.error(e.getMessage());
    			return ResultUtil.error(e.getMessage());
    		}
    	}
    
    redisCache类
    public class RedisCache<T> {
    
    	private final Logger logger = LoggerFactory.getLogger(getClass());
    	
    	@Autowired
    	private RedisTemplate<String, T> redisTemplate;
    
    	public static final String KEY_SET_PREFIX = "_set:";
    	public static final String KEY_LIST_PREFIX = "_list:";
    
    	public T get(String key) {
    		logger.debug("get key [{}]", key);
    		try {
    			if (key == null) {
    				return null;
    			}
    			else {
    				return redisTemplate.opsForValue().get(key);
    			}
    		}
    		catch (Throwable t) {
    			logger.error("get key [{}] exception!", key, t);
    			throw new CacheException(t);
    		}
    
    	}
    
    	public T set(String key, T value) {
    		logger.debug("set key [{}]", key);
    		try {
    			redisTemplate.opsForValue().set(key, value);
    			return value;
    		}
    		catch (Throwable t) {
    			logger.error("set key [{}] exception!", key, t);
    			throw new CacheException(t);
    		}
    	}
    
    	public T set(String key, T value, long timeout) {
    		logger.debug("set key [{}]", key);
    		try {
    			redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    			return value;
    		}
    		catch (Throwable t) {
    			logger.error("set key [{}] exception!", key, t);
    			throw new CacheException(t);
    		}
    	}
    
    	public void delete(String key) {
    		logger.debug("delete key [{}]", key);
    		try {
    			redisTemplate.delete(key);
    		}
    		catch (Throwable t) {
    			logger.error("delete key [{}] exception!", key, t);
    			throw new CacheException(t);
    		}
    	}
    
    	@SuppressWarnings("unchecked")
    	public void setSet(String k, T value, long time) {
    		String key = KEY_SET_PREFIX + k;
    		logger.debug("setSet key [{}]", key);
    		try {
    			SetOperations<String, T> valueOps = redisTemplate.opsForSet();
    			valueOps.add(key, value);
    			if (time > 0)
    				redisTemplate.expire(key, time, TimeUnit.SECONDS);
    		}
    		catch (Throwable t) {
    			logger.error("setSet key [{}] exception!", key, t);
    			throw new CacheException(t);
    		}
    	}
    
    	public void setSet(String k, T value) {
    		setSet(k, value, -1);
    	}
    
    	@SuppressWarnings("unchecked")
    	public void setSet(String k, Set<T> v, long time) {
    		String key = KEY_SET_PREFIX + k;
    		logger.debug("setSet key [{}]", key);
    		try {
    			SetOperations<String, T> setOps = redisTemplate.opsForSet();
    			setOps.add(key, (T[]) v.toArray());
    			if (time > 0)
    				redisTemplate.expire(key, time, TimeUnit.SECONDS);
    		}
    		catch (Throwable t) {
    			logger.error("setSet key [{}] exception!", key, t);
    			throw new CacheException(t);
    		}
    	}
    
    	public void setSet(String k, Set<T> v) {
    		setSet(k, v, -1);
    	}
    
    	public Set<T> getSet(String k) {
    		String key = KEY_SET_PREFIX + k;
    		logger.debug("getSet key [{}]", key);
    		try {
    			SetOperations<String, T> setOps = redisTemplate.opsForSet();
    			return setOps.members(key);
    		}
    		catch (Throwable t) {
    			logger.error("getSet key [{}] exception!", key, t);
    			throw new CacheException(t);
    		}
    	}
    
    	public void setList(String k, T v, long time) {
    		String key = KEY_LIST_PREFIX + k;
    		logger.debug("setList key [{}]", key);
    		try {
    			ListOperations<String, T> listOps = redisTemplate.opsForList();
    			listOps.rightPush(key, v);
    			if (time > 0)
    				redisTemplate.expire(key, time, TimeUnit.SECONDS);
    		}
    		catch (Throwable t) {
    			logger.error("setList key [{}] exception!", key, t);
    			throw new CacheException(t);
    		}
    	}
    
    	public void setList(String k, List<T> v, long time) {
    		String key = KEY_LIST_PREFIX + k;
    		logger.debug("setList key [{}]", key);
    		try {
    			ListOperations<String, T> listOps = redisTemplate.opsForList();
    			listOps.rightPushAll(key, v);
    			if (time > 0)
    				redisTemplate.expire(key, time, TimeUnit.SECONDS);
    		}
    		catch (Throwable t) {
    			logger.error("setList key [{}] exception!", key, t);
    			throw new CacheException(t);
    		}
    	}
    
    	public void setList(String k, List<T> v) {
    		setList(k, v, -1);
    	}
    
    	public List<T> getList(String k, long start, long end) {
    		String key = KEY_LIST_PREFIX + k;
    		logger.debug("setList key [{}]", key);
    		try {
    			ListOperations<String, T> listOps = redisTemplate.opsForList();
    			return listOps.range(key, start, end);
    		}
    		catch (Throwable t) {
    			logger.error("getList key [{}] exception!", key, t);
    			throw new CacheException(t);
    		}
    	}
    
    	public long getListSize(String k) {
    		String key = KEY_LIST_PREFIX + k;
    		logger.debug("setList key [{}]", key);
    		try {
    			ListOperations<String, T> listOps = redisTemplate.opsForList();
    			return listOps.size(key);
    		}
    		catch (Throwable t) {
    			logger.error("getListSize key [{}] exception!", key, t);
    			throw new CacheException(t);
    		}
    	}
    
    	public long getListSize(ListOperations<String, String> listOps, String k) {
    		String key = KEY_LIST_PREFIX + k;
    		logger.debug("getListSize key [{}]", key);
    		try {
    			return listOps.size(key);
    		}
    		catch (Throwable t) {
    			logger.error("getListSize key [{}] exception!", key, t);
    			throw new CacheException(t);
    		}
    	}
    
    	public void setMap(String key, String mapkey, T mapValue) {
    		HashOperations<String, String, T> hashOperations = redisTemplate.opsForHash();
    		hashOperations.putIfAbsent(key, mapkey, mapValue);
    	}
    
    	public void deleteMap(String key, String mapkey) {
    		HashOperations<String, String, T> hashOperations = redisTemplate.opsForHash();
    		hashOperations.delete(key, mapkey);
    	}
    
    	public T getMap(String key, String mapkey) {
    		HashOperations<String, String, T> hashOperations = redisTemplate.opsForHash();
    		return hashOperations.get(key, mapkey);
    	}
    
    	public List<T> getMapValues(String key) {
    		HashOperations<String, String, T> hashOperations = redisTemplate.opsForHash();
    		return hashOperations.values(key);
    	}
    
    	public void setRedisTemplate(RedisTemplate<String, T> redisTemplate) {
    		this.redisTemplate = redisTemplate;
    	}
    }
    

      

    如果你不知道自己要去哪里,那么去哪里都是一样
  • 相关阅读:
    调用EasyPlayer播放器报错FlvPlayer.load() has been called,pleasse call unload() first!,如何处理?
    开发webrtc P2P连接报错DOMException: Failed to execute XXXXXX排查及优化
    异地视频共享/组网工具EasyNTS如何进行穿透接口的数据迁移?
    视频监控如何实现异地共享/组网?EasyNTS解决远程难题
    每日总结
    关于RHEL7.5无法使用yum命令的解决方法
    java后端学习-第一部分java基础:面向对象编程
    每日总结
    每日总结
    每日总结
  • 原文地址:https://www.cnblogs.com/dragonKings/p/12021439.html
Copyright © 2020-2023  润新知