JavaWeb框架 - Spring注解部分：

Spring注解部分：

1. IOC部分的详解：

   • @ComponentScan() 注解：

     • @ComponentScan value:指定要扫描的包

     • excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件

     • includeFilters = Filter[] ：指定扫描的时候只需要包含哪些组件

     • 高级使用特性：Filter的使用：使用自定义的TypeFilter 按照一定的类型 进行注解的扫描

       @ComponentScan(value = "com.spring", excludeFilters = {
               @ComponentScan.Filter(type = FilterType.CUSTOM ,classes = {MyTypeFilter.class})
       })
       

       public enum FilterType {
       	ANNOTATION,//默认的就是使用注解的类型进行过滤
       	ASSIGNABLE_TYPE,// 按照给定的类型；
       	ASPECTJ,// 使用ASPECTJ表达式
       	REGEX,	//使用正则指定
       	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")){// 只有类名包含er的才进行扫描
       			return true;
       		}
       		return false;
       	}
       }
       

   • @Scope() 注解的使用：

     • scope：详解：

       • prototype：多实例的：ioc容器启动 并不会去调用方法创建对象放在容器中而是每次获取的时候才会调用方法创建对象；@Scope("prototype") 和 在xml中的bean标签中的scope属性是一致的<bean id="person" class="com.spring.entities.Person" scope="prototype" lazy-init="true">
       • singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中在容器创建的过程中就会进行bean的实例化 以后每次获取就是直接从容器（map.get()）中拿
       • request：同一次请求创建一个实例
       • session：同一个session创建一个实例

     • 懒加载： 懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；

       • 单实例bean：默认在容器启动的时候创建对象

   • 指定bean的初始化方法 和 销毁方法的方式：方法中不能有参数 但是可以抛出异常

     • 在xml配置文件中指定bean标签的 <bean id="person" class="com.spring.entities.Person" init-method="" destroy-method="">

     • 第二种方式就是 在@bean 注解中指定 init method 和 destroy method

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

     • 第三种方法使用@PostConstruct @PreDestroy注解

       @PostConstruct //方法中不能有参数 但是能有异常
       public void init() throws RuntimeException{
           System.out.println("car init....");
       }
       @PreDestroy
       public void destroy(){
           System.out.println("car destroy ....");
       }
       

     • 第四种方式： 实现InitializingBean 接口 进行初始化方法实现 afterPropertiesSet() 实现销毁方法的接口就是disposablebean接口 实现destroy()方法

       public class Cat implements InitializingBean, DisposableBean {
           public Cat(){
               System.out.println("new cat");
           }
           @Override
           public void destroy() throws Exception {
               System.out.println(" cat dead.... DisposableBean");
           }
           @Override
           public void afterPropertiesSet() throws Exception {
               System.out.println("cat born... afterPropertiesSet");
           }
       }
       

   • Spring 中工厂类的使用：implements FactoryBean<T>

     public class MyFactoryBean implements FactoryBean<Color> {
         // 创建实例
         @Override
         public Color getObject() throws Exception {
             return new Color();
         }
         // 返回的是bean的class
         @Override
         public Class<?> getObjectType() {
             return Color.class;
         }
         // 要是返回的是true表示的是单例
         @Override
         public boolean isSingleton() {
             return true;
         }
     }
     

     • 需要注意的一点：

        // 使用这样的方式创建出来的其实是color类型的不是工厂 所以传入的类型也是 color类型不是 工厂类型
       Object myFactoryBean = annoBeans.getBean("factoryBean");
       Object myRealFactoryBean = annoBeans.getBean("&factoryBean");//这样才能获取到工厂的实例
       

   • BeanPostProcessor的使用： implements BeanPostProcessor

     @Component// 使用的时候需要也是一个组件需要加入到容器中
     public class MyBeanPostProcessor implements BeanPostProcessor {
         // 初始化之前的后置处理
         @Override
         public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
             System.out.println(beanName+"postProcessBeforeInitialization--->"+bean);
             return bean;
         }
         // 初始化之后的后置处理
         @Override
         public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
             System.out.println(beanName+"postProcessAfterInitialization--->"+bean);
             return bean;
         }
     }
     

     • bean的生命周期：
       

   • 属性注入相关的注解：

     • @value：

       @Value("张三")	//1、基本数值
       private String name;
       @Value("#{20-2}") //2、可以写SpEL； #{}
       private Integer age;
       @Value("${person.nickName}") 	//3、可以写${}；取出配置文件【properties】中的值（在运行环境变量里面的值）
       private String nickName;  
       

   • 自动注入相关的注解：

     • @Autowired：自动注入：默认优先按照类型去容器中找对应的组件:applicationContext.getBean(XXXclass);找到就赋值 如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找

     • @Qualifier()：使用@Qualifier指定需要装配的组件的id，而不是使用属性名自动装配默认一定要将属性赋值好，没有就会报错可以使用@Autowired(required=false);

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

     • @Resource:可以和@Autowired一样实现自动装配功能；默认是按照组件名称进行装配的(相当于 Autowired + Qualifier)没有能支持@Primary功能没有支持@Autowired（reqiured=false）;

     • @Inject:需要导入javax.inject的包，和Autowired的功能一样。、没有required=false的功能 @Autowired:Spring定义的； @Resource、@Inject都是java规范