java后端处理高并发

一个登陆页面可能会被很多账户同时登陆或者注册，那么我们就好处理这些并发，否则降低程序的使用率，甚至程序奔溃，下面一段代码处理程序的高并发效果不错。

		    		/**
		    *@author xiaoxie
		    *@date create 2019/9/17
		    *@return
		     * 处理高并发
		    */
		    public class RequestHolder {

		    //    线程处理
		        private static final ThreadLocal<SysUser> userHolder = new ThreadLocal<SysUser>();

		    //    登录
		        private static final ThreadLocal<HttpServletRequest> requestHolder = new ThreadLocal<HttpServletRequest>();

		    //    设置登陆用户
		        public static void add(SysUser sysUser){
		            userHolder.set(sysUser);
		        }

		        public static void add(HttpServletRequest request) {
		            requestHolder.set(request);
		        }

		    //    处理当前用户
		        public static SysUser getCurrentUser() {
		            return userHolder.get();
		        }

		    //    处理当前登录
		        public static HttpServletRequest getCurrentRequest() {
		            return requestHolder.get();
		        }

		    //    消亡
		        public static void remove(){
		            userHolder.remove();
		            requestHolder.remove();
		        }
		    }

注意：SysUser是自己定义的model，根据自己的需要设置。

在登陆或者注册完成之后就要消亡，否则会产生数据的溢出。

	    	/**
	    *@author xiaoxie
	    *@date CREATE 2019/9/6  UPDATE 2019/9/12
	    *@return 请求前后监听
	    */
	    @Slf4j
	    public class HttpInterceptor extends HandlerInterceptorAdapter {

	        private static final String START_TIME = "requestStartTime";

	        @Override
	        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
	            String url = request.getRequestURI().toString();
	            Map parameterMap = request.getParameterMap();
	            log.info("request start. url:{}, params:{}", url, JsonMapper.obj2String(parameterMap));
	            long start = System.currentTimeMillis();
	            request.setAttribute(START_TIME, start);
	            return true;
	        }

	        @Override
	        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
	    //        String url = request.getRequestURI().toString();
	    //        long start = (Long) request.getAttribute(START_TIME);
	    //        long end = System.currentTimeMillis();
	    //        log.info("request finished. url:{}, cost:{}", url, end - start);
	            removeThreadLocalInfo();
	        }

	        @Override
	        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
	            String url = request.getRequestURI().toString();
	            long start = (Long) request.getAttribute(START_TIME);
	            long end = System.currentTimeMillis();
	            log.info("request completed. url:{}, cost:{}", url, end - start);

	            removeThreadLocalInfo();
	        }

	        public void removeThreadLocalInfo() {
	            RequestHolder.remove();
	        }

通过过滤器进行实现

	    /**
	    *@author xiaoxie
	    *@date  create 2019/9/17
	    *@return
	     *
	     * 登陆过滤
	    */
	    @Slf4j
	    public class LoginFilter implements Filter {
	        @Override
	        public void init(FilterConfig filterConfig) throws ServletException {

	        }

	        @Override
	        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
	            HttpServletRequest req = (HttpServletRequest) servletRequest;
	            HttpServletResponse resp = (HttpServletResponse) servletResponse;

	            SysUser sysUser = (SysUser) req.getSession().getAttribute("user");

	            if (sysUser == null){
	                String path = "/signin.jsp";
	                resp.sendRedirect(path);
	                return;
	            }

	    //        处理高并发
	            RequestHolder.add(sysUser);
	            RequestHolder.add(req);
	            filterChain.doFilter(servletRequest,servletResponse);
	            return;
	        }

	        @Override
	        public void destroy() {

	        }
	    }

简单的高并发就处理好了。