springMVC-拦截器-后篇-时间拦截器

package com.in.interceptor;

import java.util.Calendar;

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

import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
/**
 * 重写12306的业务操作，在某个时间之间允许访问控制层的方法，其他时间都不允许
 * @author Administrator
 *
 */
public class SystemInterceptor extends HandlerInterceptorAdapter{
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        //获取当前时间
        long time=System.currentTimeMillis();
        //获取当前日历对象(存储当前时间信息)
        Calendar c=Calendar.getInstance();//起始时间
        c.set(Calendar.HOUR_OF_DAY, 15);
        c.set(Calendar.MINUTE,0);
        c.set(Calendar.SECOND, 0);
        c.set(Calendar.MILLISECOND, 0);//0毫秒
        long starTime=c.getTimeInMillis();//终止时间
        c.set(Calendar.HOUR_OF_DAY, 23);
        long endTime=c.getTimeInMillis();
        if(time<starTime||time>endTime){
            System.out.println("本时间点之内不允许访问");
            response.sendRedirect("forbit.jsp");
            return false;//表示拦截，不再去执行控制层的方法
        }
        return true;//表示放行，要执行控制层的方法
    }
}

package com.in.interceptor;

import java.lang.reflect.Method;

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

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

import com.in.annotation.TimeMonitor;

/**
 * 拦截器的编写:是实现HandlerInterceptor接口或继承HandlerInterceptorAdapter 继承适配器只需要实现一部分功能
 * 拦截器的配置 1)xml方式(spring-config.xml) 2)基于annotation方式
 */
public class TimeInterceptor implements HandlerInterceptor {

    public TimeInterceptor() {
        System.out.println("TimeInterceptor.TimeInterceptor()");
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        System.out.println("TimeInterceptor.preHandle()");
        long startTime = System.currentTimeMillis();
        HandlerMethod hMethod = (HandlerMethod) handler;
        TimeMonitor timeMonitor = hMethod.getMethodAnnotation(TimeMonitor.class);
        if (timeMonitor != null) {
            // 没有共享就没有伤害
            request.setAttribute("startTime", startTime);
        }

        return true;// false表示拦截。true表示放行
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        System.out.println("TimeInterceptor.postHandle()");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        System.out.println("TimeInterceptor.afterCompletion()");

        System.out.println(handler.getClass().getName());
        // 将handler向下转型(目的获取方法信息)
        if (handler instanceof HandlerMethod) {
            // 将handler向下转型-获取方法相关信息
            HandlerMethod hMethod = (HandlerMethod) handler;
            TimeMonitor timeMonitor = hMethod.getMethodAnnotation(TimeMonitor.class);
            if (timeMonitor != null) {
                // 没有共享就没有伤害
                long endTime = System.currentTimeMillis();
                long startTime = (Long) request.getAttribute("startTime");
                long totalTime = endTime - startTime;
                // 获取方法对象
                Method method = hMethod.getMethod();
                // 获取执行方法所在的类的信息
                String beanCls = hMethod.getBeanType().getName();
                System.out.println(beanCls + "." + method.getName() + "()" + "总时长" + totalTime);
            }

        }

    }

}

package  com.in.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)//定义注解运行时有效
@Target(ElementType.METHOD)//target用于描述注解修饰方法
public @interface TimeMonitor {

}

package com.in.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.in.annotation.TimeMonitor;



@Controller
@RequestMapping("/")

public class InterceptorController {
    @RequestMapping("doSomeThing")
    @ResponseBody
    @TimeMonitor
    public String doSomeThing() {
        System.out.println("InterceptorController.doSomeThing()");
        // 获取方法执行时长
        String result = "do some thing";
        try {
            Thread.sleep(500);
        } catch (Exception e) {
        }
        return result;
    }

    @RequestMapping("doStudyInterceptor")
    @ResponseBody
    public String doStudyInterceptor() {
        System.out.println("InterceptorController.doStudyInterceptor()");
        // 获取方法执行时长
        String result = "do study Interceptor";
        try {
            Thread.sleep(600);
        } catch (Exception e) {
        }
        return result;
    }
    @RequestMapping("doStudyMVC")
    @ResponseBody
    public String doStudyMVC(){
        System.out.println("InterceptorController.doStudyMVC()");
        String result = "do study MVC";
        try {
            Thread.sleep(700);
        } catch (Exception e) {
        }
        return result;
    }
}

/spring-mvc-v2/src/main/webapp/forbit.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>首页</title>
</head>
<body>
    本时段不允许访问
</body>
</html>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:util="http://www.springframework.org/schema/util" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xsi:schemaLocation="  
       http://www.springframework.org/schema/beans   
       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd  
       http://www.springframework.org/schema/mvc   
       http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd   
       http://www.springframework.org/schema/tx   
       http://www.springframework.org/schema/tx/spring-tx-4.3.xsd   
       http://www.springframework.org/schema/aop 
       http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
       http://www.springframework.org/schema/util 
       http://www.springframework.org/schema/util/spring-util-4.3.xsd
       http://www.springframework.org/schema/data/jpa 
       http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.3.xsd">
    <!-- 配置spring中bean对象的扫描(包括后端控制器) component-scan元素用于包以及包中的子类并且将使用了@Controller,@Service类似注解等修饰的类 
        交给Spring容器管理。 -->
    <context:component-scan base-package="com.in" />
    <!--配置和启用spring MVC默认配置(例如底层支持json) -->
    <mvc:annotation-driven />
    <!--配置springMVC视图解析器(负责视图解析操作) -->
    <bean id="viewResolver"
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀 -->
        <property name="Prefix" value="/WEB-INF/pages/"></property>
    </bean>
    <!--配置拦截器对象 -->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--要拦截的路径url -->
            <mvc:mapping path="/**" />
            <!--拦截器对象 -->
            <bean class="com.in.interceptor.SystemInterceptor" />
        </mvc:interceptor>
        <mvc:interceptor>
            <!--要拦截的路径url -->
            <mvc:mapping path="/**" />
            <!--要排除的拦截路径url -->
            <mvc:exclude-mapping path="/doStudyInterceptor.do" />
            <!--拦截器对象 -->
            <bean class="com.in.interceptor.TimeInterceptor" />
        </mvc:interceptor>
    </mvc:interceptors>
</beans>

http://localhost/spring-mvc-v2/doStudyMVC.do
控制台

本时间点之内不允许访问
  1. 多个拦截器时,其执行顺序有什么决定?(配置顺序)
  2. 拦截器对象何时创建?(启动时创建)
  3. 拦截器对象在内存中有几份?(一份)
  4. 拦截器中存在变量共享时可能会有线程安全问题吗?(有)
  5. Spring管理的Bean对象中存在变量共享时可能会有线程安全吗？（有）
  6. 多个拦截器对象如何共享数据?
    (通过request,session,ServletContext,)
  7. 拦截器对象的生命周期何时结束?(容器销毁时)
  8. 拦截器可以解决什么问题?(Controller中共性问题,例如日志处理,系统监控,...)
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

友情链接更多精彩内容