spring注解开发

容器

AnnotationConfigApplicationContext

配置类

    @Configuration  //告诉Spring这是一个配置类

包扫描

    @ComponentScans(
            value = {
                    @ComponentScan(value="com.atguigu",includeFilters = {
    /*						@Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
                            @Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),*/
                            @Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})
                    },useDefaultFilters = false)	
            }
            )

@ComponentScan value:指定要扫描的包

• excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件
• includeFilters = Filter[] ：指定扫描的时候只需要包含哪些组件
  FilterType.ANNOTATION：按照注解
  FilterType.ASSIGNABLE_TYPE：按照给定的类型
  FilterType.ASPECTJ：使用ASPECTJ表达式
  FilterType.REGEX：使用正则指定
  FilterType.CUSTOM：使用自定义规则

    public class MyTypeFilter implements TypeFilter {

	/**
	 * metadataReader：读取到的当前正在扫描的类的信息
	 * metadataReaderFactory:可以获取到其他任何类信息的
	 */
	@Override
	public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
			throws IOException {
		// TODO Auto-generated method stub
		//获取当前类注解的信息
		AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
		//获取当前正在扫描的类的类信息
		ClassMetadata classMetadata = metadataReader.getClassMetadata();
		//获取当前类资源（类的路径）
		Resource resource = metadataReader.getResource();
		
		String className = classMetadata.getClassName();
		System.out.println("--->"+className);
		if(className.contains("er")){
			return true;
		}
		return false;
	}

}

组件添加

@ComponentScan

@ComponentScan("com.atguigu.bean")

包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）[自己写的类]

• @Component
• @Service
• @Controller
• @Repository

@Bean

//给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id

    @Bean("person")
	public Person person01(){
		return new Person("lisi", 20);
	}

Bean的生命周期

bean创建—初始化----销毁的过程
容器管理bean的生命周期；
我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法

构造（对象创建）
单实例：在容器启动的时候创建对象
多实例：在每次获取的时候创建对象

销毁：
单实例：容器关闭的时候
多实例：容器不会管理这个bean；容器不会调用销毁方法；

​

• 1）、指定初始化和销毁方法：通过@Bean指定init-method和destroy-method；

        @Bean(initMethod="init",destroyMethod="detory")
        public Car car(){
            return new Car();
        }

• 2）、通过让Bean实现InitializingBean（定义初始化逻辑），DisposableBean（定义销毁逻辑）;

        @Component
        public class Cat implements InitializingBean,DisposableBean {
            public Cat(){
                System.out.println("cat constructor...");
            }
            @Override
            public void destroy() throws Exception {
                // TODO Auto-generated method stub
                System.out.println("cat...destroy...");
            }
            @Override
            public void afterPropertiesSet() throws Exception {
                // TODO Auto-generated method stub
                System.out.println("cat...afterPropertiesSet...");
            }
        }

• 3）、可以使用JSR250；
  @PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
  @PreDestroy：在容器销毁bean之前通知我们进行清理工作

        //对象创建并赋值之后调用
        @PostConstruct
        public void init(){
            System.out.println("Dog....@PostConstruct...");
        }
        //容器移除对象之前
        @PreDestroy
        public void detory(){
            System.out.println("Dog....@PreDestroy...");
        }

• 4）、BeanPostProcessor【interface】：bean的后置处理器；
  在bean初始化前后进行一些处理工作；
  BeanPostProcessor.postProcessBeforeInitialization
  初始化：
  对象创建完成，并赋值好，调用初始化方法。。。
  BeanPostProcessor.postProcessAfterInitialization
  postProcessBeforeInitialization:在初始化之前工作
  postProcessAfterInitialization:在初始化之后工作

遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization

        /**
        * 后置处理器：初始化前后进行处理工作
        * 将后置处理器加入到容器中
        * @author lfy
        */
        @Component
        public class MyBeanPostProcessor implements BeanPostProcessor {

            @Override
            public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
                // TODO Auto-generated method stub
                System.out.println("postProcessBeforeInitialization..."+beanName+"=>"+bean);
                return bean;
            }

            @Override
            public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
                // TODO Auto-generated method stub
                System.out.println("postProcessAfterInitialization..."+beanName+"=>"+bean);
                return bean;
            }

        }

    * 
    * Spring底层对 BeanPostProcessor 的使用；
    * 		bean赋值，注入其他组件，@Autowired，生命周期注解功能，@Async,xxx BeanPostProcessor;
    * 
    * @author lfy
    *
    */

@Configuration

@Conditional({Condition}) ： 按照一定的条件进行判断，满足条件给容器中注册bean

    @Conditional({LinuxCondition.class})
    //判断是否linux系统
    public class LinuxCondition implements Condition {

	/**
	 * ConditionContext：判断条件能使用的上下文（环境）
	 * AnnotatedTypeMetadata：注释信息
	 */
	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		// TODO是否linux系统
		//1、能获取到ioc使用的beanfactory
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
		//2、获取类加载器
		ClassLoader classLoader = context.getClassLoader();
		//3、获取当前环境信息
		Environment environment = context.getEnvironment();
		//4、获取到bean定义的注册类
		BeanDefinitionRegistry registry = context.getRegistry();
		
		String property = environment.getProperty("os.name");
		
		//可以判断容器中的bean注册情况，也可以给容器中注册bean
		boolean definition = registry.containsBeanDefinition("person");
		if(property.contains("linux")){
			return true;
		}
		
		return false;
	}

}

@Primary

让Spring进行自动装配的时候，默认使用首选的bean；也可以继续使用@Qualifier指定需要装配的bean的名字

@Lazy

 * 懒加载：
 * 		单实例bean：默认在容器启动的时候创建对象；
 * 		懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；

@Scope

 * @Scope:调整作用域
 * prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。
 * 					每次获取的时候才会调用方法创建对象；
 * singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。
 * 			以后每次获取就是直接从容器（map.get()）中拿，
 * request：同一次请求创建一个实例
 * session：同一个session创建一个实例

@Import

• 1）@Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名

        @Import({Color.class,Red.class,MyImportSelector.class,MyImportBeanDefinitionRegistrar.class})
        //@Import导入组件，id默认是组件的全类名

• 2）ImportSelector:返回需要导入的组件的全类名数组；

        public class MyImportSelector implements ImportSelector {
            //返回值，就是到导入到容器中的组件全类名
            //AnnotationMetadata:当前标注@Import注解的类的所有注解信息
            @Override
            public String[] selectImports(AnnotationMetadata importingClassMetadata) {
                // TODO Auto-generated method stub
                //importingClassMetadata
                //方法不要返回null值
                return new String[]{"com.atguigu.bean.Blue","com.atguigu.bean.Yellow"};
            }
        }

• 3）ImportBeanDefinitionRegistrar:手动注册bean到容器中

        public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

            /**
            * AnnotationMetadata：当前类的注解信息
            * BeanDefinitionRegistry:BeanDefinition注册类；
            * 		把所有需要添加到容器中的bean；调用
            * 		BeanDefinitionRegistry.registerBeanDefinition手工注册进来
            */
            @Override
            public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
                
                boolean definition = registry.containsBeanDefinition("com.atguigu.bean.Red");
                boolean definition2 = registry.containsBeanDefinition("com.atguigu.bean.Blue");
                if(definition && definition2){
                    //指定Bean定义信息；（Bean的类型，Bean。。。）
                    RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
                    //注册一个Bean，指定bean名
                    registry.registerBeanDefinition("rainBow", beanDefinition);
                }
            }
        }

组件赋值

@Value

• 1、基本数值
• 2、可以写SpEL； #{}
• 3、可以写${}；取出配置文件【properties】中的值（在运行环境变量里面的值）

        @Value("张三")
        private String name;
        @Value("#{20-2}")
        private Integer age;
        @Value("${person.nickName}")
        private String nickName;

@Autowired

• 1）默认优先按照类型去容器中找对应的组件:applicationContext.getBean(BookDao.class);找到就赋值
• 2）如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找 applicationContext.getBean(“bookDao”)
• 3）@Qualifier(“bookDao”)：使用@Qualifier指定需要装配的组件的id，而不是使用属性名
• 4）自动装配默认一定要将属性赋值好，没有就会报错；可以使用@Autowired(required=false);
• 5）@Primary：让Spring进行自动装配的时候，默认使用首选的bean；
  也可以继续使用@Qualifier指定需要装配的bean的名字

        @Service
        public class BookService {
            //@Qualifier("bookDao")
            //@Autowired(required=false)
            //@Resource(name="bookDao2")
            @Inject
            private BookDao bookDao;
            
            public void print(){
                System.out.println(bookDao);
            }

            @Override
            public String toString() {
                return "BookService [bookDao=" + bookDao + "]";
            }
         }

Spring还支持使用@Resource(JSR250)和@Inject(JSR330)[java规范的注解]

    @Resource:可以和@Autowired一样实现自动装配功能；默认是按照组件名称进行装配的；没有能支持@Primary功能没有支持@Autowired（reqiured=false）;
    @Inject:需要导入javax.inject的包，和Autowired的功能一样。没有required=false的功能；

@PropertySources

@PropertySource

• 使用@PropertySource读取外部配置文件中的k/v保存到运行的环境变量中;加载完外部的配置文件以后使用${}取出配置文件的值

  @PropertySource(value={"classpath:/person.properties"})
  

@Profile

@Profile：指定组件在哪个环境的情况下才能被注册到容器中，不指定，任何环境下都能注册这个组件

• 1）、加了环境标识的bean，只有这个环境被激活的时候才能注册到容器中。默认是default环境
• 2）、写在配置类上，只有是指定的环境的时候，整个配置类里面的所有配置才能开始生效
• 3）、没有标注环境标识的bean在，任何环境下都是加载的；

        @Profile("dev")
        @Bean("devDataSource")
        public DataSource dataSourceDev(@Value("${db.password}")String pwd) throws Exception{
            ComboPooledDataSource dataSource = new ComboPooledDataSource();
            dataSource.setUser(user);
            dataSource.setPassword(pwd);
            dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/ssm_crud");
            dataSource.setDriverClass(driverClass);
            return dataSource;
        }
            
//1、使用命令行动态参数: 在虚拟机参数位置加载 -Dspring.profiles.active=test
//2、代码的方式激活某种环境；

        @Test
        public void test01(){
            
            //1、创建一个applicationContext
            AnnotationConfigApplicationContext applicationContext = 
                    new AnnotationConfigApplicationContext();
            //2、设置需要激活的环境
            applicationContext.getEnvironment().setActiveProfiles("dev");
            //3、注册主配置类
            applicationContext.register(MainConfigOfProfile.class);
            //4、启动刷新容器
            applicationContext.refresh();
            
            
            String[] namesForType = applicationContext.getBeanNamesForType(DataSource.class);
            for (String string : namesForType) {
                System.out.println(string);
            }
            
            Yellow bean = applicationContext.getBean(Yellow.class);
            System.out.println(bean);
            applicationContext.close();
        }

组件注入

• @Autowired:构造器，参数，方法，属性；都是从容器中获取参数组件的值

方法参数

• [标注在方法位置]：@Bean+方法参数；参数从容器中获取;默认不写@Autowired效果是一样的；都能自动装配

构造器注入

• [标在构造器上]：如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略，参数位置的组件还是可以自动从容器中获取

ApplicationContextAware

xxxAware

自定义组件想要使用Spring容器底层的一些组件（ApplicationContext，BeanFactory，xxx）；

• 自定义组件实现xxxAware；在创建对象的时候，会调用接口规定的方法注入相关组件；Aware；
• 把Spring底层一些组件注入到自定义的Bean中；
• xxxAware：功能使用xxxProcessor；
• ApplicationContextAware==》ApplicationContextAwareProcessor；

AOP【动态代理】

• 指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；
• 1、导入aop模块；Spring AOP：(spring-aspects)
• 2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx）
• 3、定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行；
  • 通知方法：
    前置通知(@Before)：logStart：在目标方法(div)运行之前运行
    后置通知(@After)：logEnd：在目标方法(div)运行结束之后运行（无论方法正常结束还是异常结束）
    返回通知(@AfterReturning)：logReturn：在目标方法(div)正常返回之后运行
    异常通知(@AfterThrowing)：logException：在目标方法(div)出现异常以后运行
    环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）
• 4、给切面类的目标方法标注何时何地运行（通知注解）；

        /**
        * 切面类
        * @author lfy
        * 
        * @Aspect： 告诉Spring当前类是一个切面类
        *
        */
        @Aspect
        public class LogAspects {
        
        //抽取公共的切入点表达式
        //1、本类引用
        //2、其他的切面引用
        @Pointcut("execution(public int com.atguigu.aop.MathCalculator.*(..))")
        public void pointCut(){};
        
        //@Before在目标方法之前切入；切入点表达式（指定在哪个方法切入）
        @Before("pointCut()")
        public void logStart(JoinPoint joinPoint){
            Object[] args = joinPoint.getArgs();
            System.out.println(""+joinPoint.getSignature().getName()+"运行。。。@Before:参数列表是：{"+Arrays.asList(args)+"}");
        }
        
        @After("com.atguigu.aop.LogAspects.pointCut()")
        public void logEnd(JoinPoint joinPoint){
            System.out.println(""+joinPoint.getSignature().getName()+"结束。。。@After");
        }
        
        //JoinPoint一定要出现在参数表的第一位
        @AfterReturning(value="pointCut()",returning="result")
        public void logReturn(JoinPoint joinPoint,Object result){
            System.out.println(""+joinPoint.getSignature().getName()+"正常返回。。。@AfterReturning:运行结果：{"+result+"}");
        }
        
        @AfterThrowing(value="pointCut()",throwing="exception")
        public void logException(JoinPoint joinPoint,Exception exception){
            System.out.println(""+joinPoint.getSignature().getName()+"异常。。。异常信息：{"+exception+"}");
        }

    }

• 5、将切面类和业务逻辑类（目标方法所在类）都加入到容器中;
• 6、必须告诉Spring哪个类是切面类(给切面类上加一个注解：@Aspect)
• 7、给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】在Spring中很多的 @EnableXXX;

        @EnableAspectJAutoProxy
        @Configuration
        public class MainConfigOfAOP {
            
            //业务逻辑类加入容器中
            @Bean
            public MathCalculator calculator(){
                return new MathCalculator();
            }

            //切面类加入到容器中
            @Bean
            public LogAspects logAspects(){
                return new LogAspects();
            }
        }

• 三步：
  • 1）将业务逻辑组件和切面类都加入到容器中；告诉Spring哪个是切面类（@Aspect）
  • 2）在切面类上的每一个通知方法上标注通知注解，告诉Spring何时何地运行（切入点表达式@Pointcut）
  • 3）开启基于注解的aop模式；@EnableAspectJAutoProxy

AOP小结

• 1） @EnableAspectJAutoProxy 开启AOP功能
• 2） @EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareAspectJAutoProxyCreator
• 3）AnnotationAwareAspectJAutoProxyCreator是一个后置处理器；
• 4）容器的创建流程：
  • 1）registerBeanPostProcessors（）注册后置处理器；创建AnnotationAwareAspectJAutoProxyCreator对象
  • 2）finishBeanFactoryInitialization（）初始化剩下的单实例bean
    • 1）创建业务逻辑组件和切面组件
    • 2）AnnotationAwareAspectJAutoProxyCreator拦截组件的创建过程
    • 3）组件创建完之后，判断组件是否需要增强
      是：切面的通知方法，包装成增强器（Advisor）;给业务逻辑组件创建一个代理对象（cglib）；
• 5）执行目标方法：
  • 1）代理对象执行目标方法
  • 2）CglibAopProxy.intercept()；
    • 1）得到目标方法的拦截器链（增强器包装成拦截器MethodInterceptor）
    • 2）利用拦截器的链式机制，依次进入每一个拦截器进行执行；
    • 3）效果：
      • 正常执行：前置通知-》目标方法-》后置通知-》返回通知
      • 出现异常：前置通知-》目标方法-》后置通知-》异常通知

声明式事务

• 1、导入相关依赖：数据源、数据库驱动、Spring-jdbc模块
• 2、配置数据源、JdbcTemplate（Spring提供的简化数据库操作的工具）操作数据

   //数据源
   @Bean
   public DataSource dataSource() throws Exception{
   	ComboPooledDataSource dataSource = new ComboPooledDataSource();
   	dataSource.setUser("root");
   	dataSource.setPassword("123456");
   	dataSource.setDriverClass("com.mysql.jdbc.Driver");
   	dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
   	return dataSource;
   }
   //JdbcTemplate
   @Bean
   public JdbcTemplate jdbcTemplate() throws Exception{
   	//Spring对@Configuration类会特殊处理；给容器中加组件的方法，多次调用都只是从容器中找组件
   	JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource());
   	return jdbcTemplate;
   }

• 3、给方法上标注 @Transactional 表示当前方法是一个事务方法；

    @Service
    public class UserService {
        
        @Autowired
        private UserDao userDao;
        
        @Transactional
        public void insertUser(){
            userDao.insert();
            //otherDao.other();xxx
            System.out.println("插入完成...");
            int i = 10/0;
        }

    }

• 4、@EnableTransactionManagement 开启基于注解的事务管理功能；(@EnableXXX)
• 5、配置事务管理器来控制事务;

    @EnableTransactionManagement
    @ComponentScan("com.atguigu.tx")
    @Configuration
    public class TxConfig{
        
        @Bean
        public DataSource dataSource() throws Exception{
            ComboPooledDataSource dataSource = new ComboPooledDataSource();
            dataSource.setUser("root");
            dataSource.setPassword("123456");
            dataSource.setDriverClass("com.mysql.jdbc.Driver");
            dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
            return dataSource;
        }
        //JdbcTemplate
        @Bean
        public JdbcTemplate jdbcTemplate() throws Exception{
            //Spring对@Configuration类会特殊处理；给容器中加组件的方法，多次调用都只是从容器中找组件
            JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource());
            return jdbcTemplate;
        }

        //注册事务管理器在容器中
        @Bean
        public PlatformTransactionManager transactionManager() throws Exception{
            return new DataSourceTransactionManager(dataSource());
        }
    }

扩展原理

BeanFactoryPostProcessor

BeanDefinitionRegistryPostProcessor

ApplicationListener

@EventListener

Spring容器创建过程

web

spring整合springmvc原理

• 1、web容器在启动的时候，会扫描每个jar包下的META-INF/services/javax.servlet.ServletContainerInitializer
• 2、加载这个文件指定的类SpringServletContainerInitializer
• 3、spring的应用一启动会加载感兴趣的WebApplicationInitializer接口的下的所有组件；
• 4、并且为WebApplicationInitializer组件创建对象（组件不是接口，不是抽象类）
  1）、AbstractContextLoaderInitializer：创建根容器；createRootApplicationContext()；
  2）、AbstractDispatcherServletInitializer：
  创建一个web的ioc容器；createServletApplicationContext();
  创建了DispatcherServlet；createDispatcherServlet()；
  将创建的DispatcherServlet添加到ServletContext中；
  getServletMappings();
  3）、AbstractAnnotationConfigDispatcherServletInitializer：注解方式配置的DispatcherServlet初始化器
  创建根容器：createRootApplicationContext()
  getRootConfigClasses();传入一个配置类
  创建web的ioc容器： createServletApplicationContext();
  获取配置类；getServletConfigClasses();
• 总结：
  以注解方式来启动SpringMVC；继承AbstractAnnotationConfigDispatcherServletInitializer；实现抽象方法指定DispatcherServlet的配置信息；

定制SpringMVC；

• 1）@EnableWebMvc:开启SpringMVC定制配置功能；
  mvc:annotation-driven/；

• 2）配置组件（视图解析器、视图映射、静态资源映射、拦截器。。。）
  extends WebMvcConfigurerAdapter

示例

• 1）创建AbstractAnnotationConfigDispatcherServletInitializer

//web容器启动的时候创建对象；调用方法来初始化容器以前前端控制器
public class MyWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

	//获取根容器的配置类；（Spring的配置文件）   父容器；
	@Override
	protected Class<?>[] getRootConfigClasses() {
		// TODO Auto-generated method stub
		return new Class<?>[]{RootConfig.class};
	}

	//获取web容器的配置类（SpringMVC配置文件）  子容器；
	@Override
	protected Class<?>[] getServletConfigClasses() {
		// TODO Auto-generated method stub
		return new Class<?>[]{AppConfig.class};
	}

	//获取DispatcherServlet的映射信息
	//  /：拦截所有请求（包括静态资源（xx.js,xx.png）），但是不包括*.jsp；
	//  /*：拦截所有请求；连*.jsp页面都拦截；jsp页面是tomcat的jsp引擎解析的；
	@Override
	protected String[] getServletMappings() {
		// TODO Auto-generated method stub
		return new String[]{"/"};
	}

}

• 2）spring配置文件

//Spring的容器不扫描controller;父容器
@ComponentScan(value="com.atguigu",excludeFilters={
		@Filter(type=FilterType.ANNOTATION,classes={Controller.class})
})
public class RootConfig {

}

• 3）springmvc配置文件

//useDefaultFilters=false 禁用默认的过滤规则；
@ComponentScan(value="com.atguigu",includeFilters={
		@Filter(type=FilterType.ANNOTATION,classes={Controller.class})
},useDefaultFilters=false)
@EnableWebMvc
public class AppConfig  extends WebMvcConfigurerAdapter  {

	//定制
	
	//视图解析器
	@Override
	public void configureViewResolvers(ViewResolverRegistry registry) {
		// TODO Auto-generated method stub
		//默认所有的页面都从 /WEB-INF/ xxx .jsp
		//registry.jsp();
		registry.jsp("/WEB-INF/views/", ".jsp");
	}
	
	//静态资源访问
	@Override
	public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
		// TODO Auto-generated method stub
		configurer.enable();
	}
	
	//拦截器
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		// TODO Auto-generated method stub
		//super.addInterceptors(registry);
		registry.addInterceptor(new MyFirstInterceptor()).addPathPatterns("/**");
	}

}

servlet3.0

异步请求