spring（5）注解

1.官方文档https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#beans-required-annotation

2.ioc

@Configuration：//配置，可以使用AnnotationConfigApplicationContext加载

@Import({Student.class,MyImportSelector.class,MyImportBeanDefinitionRegistrar.class})//全类名，MyImportSelector需要实现ImportSelector接口，MyImportBeanDefinitionRegistrar需要实现ImportBeanDefinitionRegistrar接口

@Value("李四") //指定值，可以用在set方法，参数，属性上，支持spel表达式

@Bean(value="p1",destroyMethod = "destroy",initMethod = "init")/*注解具有返回值的方法，注入bean容器，destroy在销毁bean之前，init在赋值之前，多实例不会加入bean容器管理，所以不会调用detroy方法*/

@PostConstruct//bean赋值完成之后

@PreDestroy//容器销毁bean之前

@Autowired：自动注入，具有参数require，可以放在参数，方法，属性，构造器上

@Resource与@Autowired用法类似，不支持@Primary的功能

@injection与@Autowired一样，但是少了require属性，需要导入jar

@Primary//默认是自动动装配的首选bean，与@Autowired配合使用

@Scope：singleton为默认值，表示单实例，还有request，session，prototype

@Lookup：//在单实例bean依赖多实例bean时使用，一般与@Scope配合使用

@PropertySource({"classpath:"})//导入多个资源文件，保存在环境变量中

@Conditional(WindowCondition.class)//需要实现Condition接口，满足条件的才注册bean，spring底层大量使用该注解，使用在方法上，表示当前方法需要满足条件，注解在类上，表示所有的都需要满足该条件

@Lazy //延迟加载，第一次调用时加载

@Qualifier("p")//指定注入bean的名称

@component，@service，@repository，@controller

@Profile("test")/*默认值defalut，表示被ioc注入，其他值在没有被激活的情况下，不能注入bean，用于数据源的切换等

注入方式：添加运行参数Dspring.profiles.active=test，或者按如下方式激活（按test方式激活）

 @org.junit.Test
    public void  testProfile(){
        acac = new AnnotationConfigApplicationContext();
        acac.getEnvironment().setActiveProfiles("test");
        acac.register(MainConfig.class);
        acac.refresh();
        String[] names = acac.getBeanDefinitionNames();
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }
    }

@ComponentScans（)： ComponentScan[] value();

@ComponentScan(value = "cn.springannocation.bean",includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, value = {Component.class})}, useDefaultFilters = false)

/*属性：useDefaultFilters：在includeFilters是需要使用，因为是默认加载； includeFilters/ excludeFilters*/

/*FilterType的枚举值有：ANNOTATION:注解；ASSIGNABLE_TYPE：类型；ASPECTJ：切面表达式（很少用）；REGEX：正则；CUSTOM：自定义（需要实现TypeFilter接口）*/

备注:

1)MyImportSelector实现ImportSelector接口，使用@Import({MyImportSelector.class})

public class MyImportSelector  implements ImportSelector {
    //AnnotationMetadata：当前标注@Import的所有注解信息
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        String []  strs={"cn.springannocation.bean.Cat"};//全类名的方式
        return   strs;//不能返回null，否则会出异常，将strs中的内容注入到bean容器
    }
}

2）MyImportBeanDefinitionRegistrar实现ImportBeanDefinitionRegistrar接口，使用@Import({MyImportBeanDefinitionRegistrar.class})

public class MyImportBeanDefinitionRegistrar  implements ImportBeanDefinitionRegistrar {
    /*importingClassMetadata：当前标注@Import的所有注解信息
     BeanDefinitionRegistry:使用registerBeanDefinition方法手动加载*/
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //RootBeanDefinition是BeanDefinition子类
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Person.class);
        //Person注册到BeanDefinitionRegistry中，手动注册bean
        registry.registerBeanDefinition("name", rootBeanDefinition);
    }
}

3）bean工厂

public class MyFactoryBean implements FactoryBean<Cat> {
        @Override//获取bean
        public Cat getObject() throws Exception {
            return new Cat();
        }

    @Override//获取bean的类型
    public Class<?> getObjectType() {
        return Cat.class;
    }

    @Override//是否是单例
    public boolean isSingleton() {
        return true;
    }
}

    @Bean("myFactoryBean")
    public MyFactoryBean getMyFactoryBean() {
        return new MyFactoryBean();
    }

@Test
    public void testFactoryBean(){
        Object bean = acac.getBean("myFactoryBean");  
        System.out.println(bean.getClass());/输出为class cn.springannocation.bean.Cat,会使用MyFactoryBean中的方法，在id前添加&表示返回的是工厂对象自身，生产对象*/
}

4）InitializingBean与DisposableBean//针对该bean

@Component("mad")
public class MyInitializingBeanAndDisposableBean implements InitializingBean , DisposableBean {
   @Value("bb")
    String  name;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override//赋值完成之后,@PostConstruct类似
    public void afterPropertiesSet() throws Exception {
        setName("aaa");
        System.out.println("afterPropertiesSet...");
    }

    @Override//容器销毁bean之前，@PreDestroy类似，在多实例中bean容器不会管理，所以不会调用destroy方法
    public void destroy() throws Exception {
        System.out.println("destroySet...");
    }

    @Override
    public String toString() {
        return "MyInitializingBeanAndDisposableBean{" +
                "name='" + name + '\'' +
                '}';
    }
}

6）WindowCondition实现Condition接口

public class WindowCondition implements Condition {
    /**
     * ConditionContext： 上下文信息
     * AnnotatedTypeMetadata：注释信息
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();//获取bean工厂
        ClassLoader classLoader = context.getClassLoader();//获取类加载器
        Environment environment = context.getEnvironment();//获取上下文环境
        BeanDefinitionRegistry registry = context.getRegistry();//获取bean的注册信息
        registry.containsBeanDefinition("p");//容器中是否含有p
        if(environment.getProperty("os.name").contains("Windows")){
            System.out.println(environment.getProperty("os.name"));
            return  true;
        }
        return false;
    }
}

7）FilterType.CUSTOM需要实现TypeFilter接口

/*自定义类型过滤器*/
public class MyTypeFilter implements TypeFilter {
    /*是一个一个来扫描添加的
    * 返回值为true，那么就会添加到AnnotationConfigApplicationContext容器类
    *metadataReader ：当前正在扫描的类的信息，包含注解信息，类信息，资源信息等
    *MetadataReaderFactory：可以获取其他任何类的信息
    * */
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        System.out.println(metadataReader.getAnnotationMetadata());//注解信息
        System.out.println(metadataReader.getClassMetadata());//类信息，例如类名含有xxx的加入容器等
        System.out.println(metadataReader.getResource());//路径等信息
        return false;
    }
}

8）xxxaware接口都有相应的xxxawreprocessor接口，每个xxxaware接口都有一个需要实现的方法

BeanClassLoaderAware bean加载器接口

ApplicationContextAware 注入对象

BeanNameAware bean的名称

BeanFactoryAware bean工厂

EmbeddedValueResolverAware 解析spel表达式等

3.aop

@EnableAspectJAutoProxy//开启切面aop

@Enablexxx都是切面的配置

@Aspect//表示当前类为一个切面类，基本都与@Component一起使用

@before，@after，@Pointcut，@Around ，@AfterThrowing， @AfterRunning

execution表达式语法：

execution （“modifiers-pattern ret-type-pattern declaring-type-pattern？name-pattern（param-pattern）throw-pattern”）

说明：execution：匹配执方法的连接点

modifiers-pattern 权限修饰符支持通配* 可省略

ret-type-pattern 返回值类型支持通配*

declaring-type-pattern指定方法所属的类支持通配* 可省略

name-pattern方法名支持通配

param-pattern ..代表两个任意的参数假如是*则是代表一个任意类型的参数

throw-pattern 声明抛出异常支持通配可省略

@Before("execution(* spring2.*.*(int, int))")第一个*表示返回类型第二个*表示类名第三个表示方法

备注：

1）AspectJAutoProxyRegistrar

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar //public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar

public void registerBeanDefinitions(
      AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry)//自定义导入组件

4）事务

@EnableTransactionManagement：开启事务

@Transactional //默认值transactionManager， propagation，isolation，readOnly，rollbackFor，noRollbackFor，timeout（spring中有说明）

4.servlet

1）web每次运行的时候都会扫描meta-inf下的javax.servlet.ServletContainerInitializer文件

实例：如下javax.servlet.ServletContainerInitializer文件

内容cn.springannocation.service.MyServletContainerInitializer

//在servlet8.2.4中看到在在meta-inf建立services下建立一个javax.servlet.ServletContainerInitializer文件，
// 在文件内写全路径，默认servlet运行时会自动加载
//满足@HandlesTypes的类型的子类，实现类的类型（不包含自身），放入Set<Class<?>> c中
@HandlesTypes(value = {})
public class MyServletContainerInitializer  implements ServletContainerInitializer {
    @Override
    //启动是就会运行onStartup方法
    //必须在项目启动的时候添加
    public void onStartup(Set<Class<?>> c, ServletContext sc) throws ServletException {
        FilterRegistration.Dynamic userFilter = sc.addFilter("userFilter", new UserFilter());
        userFilter.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST),true,"/*");
        //可以注册servlet  listen  filter
    }
}

5.springmvc注解

@EnableWebMvc // <mvc:annotation-driven/>，且开启定制功能

WebMvcConfigurer接口的实现类WebMvcConfigurerAdapter

方法

addFormatters 注册类型转换器

addInterceptors 注册拦截器

configureViewResolvers 视图解析器

configureDefaultServletHandling 静态资源的处理等

6.web3.0异步请求处理

在web3.0以前，从require获取线程，到response释放线程是一个线程//可能造成线程线程不能释放导致线程不足。

@WebServlet(value = "async", asyncSupported = true)// asyncSupported = true支持异步

@WebServlet(value = "async",asyncSupported = true)//asyncSupported = true开启异步
public class AsyncServlet extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        AsyncContext startAsync = req.startAsync();
        startAsync.start(new Runnable() {
            @Override
            public void run() {
                AsyncContext asyncContext = req.getAsyncContext();
//                asyncContext.addListener();添加监听
//                asyncContext.setTimeout();连接时间
                ServletResponse response = asyncContext.getResponse();
                try {
                    response.getWriter().print("hellowrold");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

springmvc的异步

@RequestMapping("/async")
    //当返回值为Callable的时候springmvc会自动的开启一个异步的处理
    //Callable返回的结果，springmvc将再次放入容器，恢复之前的处理，所以会使用两次拦截器
   //有主线程池和异步线程池
    public Callable<String>  async(){
        Callable<String>  callable = new Callable(){
            @Override
            public Object call() throws Exception {

                return "async";
            }
        };
        return callable;
    }

test

    @RequestMapping("/deferredResult")
    public DeferredResult<String> deferredResult(){
        DeferredResult<String> result = new DeferredResult<>((long)2000,"sss");
        MyQueue.save(result);
        return result;//deferredResult.setResult(oder);触发以后，才能得到真正的返回
    }

    @RequestMapping("/create")
    public String create(){
        //UUID是16字节128位长的数字，它是在一定的范围内（从特定的名字空间到全球）唯一的机器生成的标识符
        //为了保证UUID的唯一性，规范定义了包括网卡MAC地址、时间戳、名字空间（Namespace）、随机或伪随机数、
        // 时序等元素，以及从这些元素生成UUID的算法。UUID的复杂特性在保证了其唯一性的同时，意味着只能由计算机生成
        String  oder= UUID.randomUUID().toString();
        DeferredResult deferredResult = MyQueue.poll();
        deferredResult.setResult(oder);//这里触发以后，  上述的return result才立即真正的返回;
        return "success";
    }

public class MyQueue  {
      private   static ConcurrentLinkedQueue<DeferredResult>  queue=new
              ConcurrentLinkedQueue<>();//基于分片机制管理锁，效率较LinkedQueue高
      public static void save (DeferredResult  deferredResult){
          queue.add(deferredResult);
      }

      public  static DeferredResult   poll(){
          DeferredResult deferredResult = queue.poll();
          return deferredResult;
      }
}

spring（5）注解

推荐阅读