Spring注解，记录一下，方便回顾

Spring注解

一、扫描注解与自定义扫描规则

@ComponentScan扫描注解

自定义扫描规则：

ComponentScan包含的属性有value

excludeFilters：不包含什么注解

includeFilters：包含什么注解

两个的参数都是@Filter注解数组。

如：@ComponentScan(value="com.spring02.demo1",excludeFilters={@Filter(type=FilterType.ANNOTATION,value={Service.class})})

上面这段注解，描述了扫描的范围不包括Service注解。

二、组件注册，自定义TypeFilter指定过滤规则

定义：创建一个类实现TypeFilter接口。

其中match方法：

public boolean match(MetadataReader arg0, MetadataReaderFactory arg1) throws IOException {
		
		//获取注解
		AnnotationMetadata annotationMetadata = arg0.getAnnotationMetadata();
		
		//获取类名
		ClassMetadata classMetadata = arg0.getClassMetadata();
		
		//获取资源
		Resource resource = arg0.getResource();
		System.out.println(annotationMetadata.getClassName() + "--" + classMetadata.getClassName());
		if(classMetadata.getClassName().contains("Pro")){
			return true;
		}
		return false;
	}

自定义过滤规则的使用：

@Filter(type=FilterType.CUSTOM,value={MyFilter.class})

三、Scope-设置组件的作用域

Singleton

Prototype

Session

Request

等

四、懒加载

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

懒加载：容器启动不创建对象，第一次获取的时候创建Bean.

@Lazy

五、组件注册@Conditional 按条件注册Bean

@Conditional的参数为Conditional数组，创建Conditional类，要实现Condition接口

实现Condition接口有一个matches方法，该方法有两个参数：ConditionContext（获取condition上下文信息） AnnotatedTypeMeta（注解信息）

getBeanFactory：获取到IOC使用的BeanFactory

getClassLoader：获得类加载器

getEnvironment：获取当前系统环境信息

getRegistry：获取Bean定义的注册类

public class LinuxConditional implements Condition{
	@Override
	public boolean matches(ConditionContext conditioncontext, AnnotatedTypeMetadata annotatedtypemetadata) {
		//获取beanFactory工厂
		ConfigurableListableBeanFactory beanFactory = conditioncontext.getBeanFactory();
		//获取类加载器
		ClassLoader classLoader = conditioncontext.getClassLoader();
		//获取系统配置相关信息
		Environment environment = conditioncontext.getEnvironment();
		//获取注册Bean的类，该类可以删除bean、注册bean、查询注册的bean等操作
		BeanDefinitionRegistry registry = conditioncontext.getRegistry();
		//获取资源加载器
		ResourceLoader resourceLoader = conditioncontext.getResourceLoader();
		if(environment.getProperty("os.name").toLowerCase().contains("linux")){
			return true;
		}
		return false;
	}
}

WindowsConditional类似，只是将linux改为windows
调用方式

        @Conditional(value={WindowsConditional.class})
	@Bean(name="zhangsanForWindos")
	public UserBean userBeanForWindows(){
		return new UserBean("zhangsanForWindos", "23");
	}
	
	@Conditional(value={LinuxConditional.class})
	@Bean(name="zhangsanForLinux")
	public UserBean userBeanForLinux(){
		return new UserBean("zhangsanForLinux", "23");
	}

小提示：-Dos.name=linux 运行环境设置为linux运行环境

Conditional可以放在方法上，也可以放在类上。

六、import，给容器快速导入一个组件

给容器中注册组件：

1、通过@Service、@Controller、@Repository、@Component注解注入（局限于自己写的类）

2、通过@Bean注解加入第三方包的组件

3、@Import快速的给容器中导入组件。

import导入组件在4.2.1之前只能导入配置类（有Configrution等）

import注解（XML配置文件上的import标签）只能写在配置类上，

@Configuration
@Import(ColorBean.class)
public class ConditionalDemoConfig {}

public class ColorBean {}

七、Profile的使用。

为不同环境下的不同配置提供了支持，如数据库配置等。

源码如下：

        @Bean
	@Profile("dev")
	public DemoBean DevDemoBean(){
		return new DemoBean("dev");
	}
	
	@Bean
	@Profile("prod")
	public DemoBean ProdDemoBean(){
		return new DemoBean("prod");
	}

       //main方法
       AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
	//获取环境变量并设置Profile的值
	context.getEnvironment().setActiveProfiles("prod");
	//后置注册配置文件类
	context.register(ProfileConfig.class);
	//刷新容器
	context.refresh();
	//打印容器内的组件
	BeanUtil.printBean(context);
	context.close();

八、Bean的生命周期

Bean的创建——初始化——销毁的过程，在spring中容器管理bean的生命周期，但是我们可以自定义bean的初始化和销毁方法。多实例Bean在获取对象后进行初始化，并不自动销毁，需要手动调销毁方法；单实例Bean的生命周期是被容器管理的，在容器关闭的时候销毁。

1、通过注解配置指定初始化与销毁方法。在Bean对应的初始化、销毁方法上用@PostConstruct和@PreDestroy注解标注（JSR250注解）

2、通过@Bean注解中的initMethod 和destoryMethod方法

3、通过让Bean实现initializingBean和DisposableBean接口实现

@Repository
public class BeanDemo2 implements InitializingBean,DisposableBean {
	private String context;
	//销毁方法
	@Override
	public void destroy() throws Exception {
		System.out.println("BeanDemo2 destroy..");
	}
	//在设置属性之后执行的方法
	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("BeanDemo2 afterPropertiesSet..");
	}
	....
}

BeanPostProcessor：bean的后置处理器，在bean初始化之前进行一些处理工作。

postProcessBeforeInitialization：在bean初始化之前

postProcessAfterInitialization：在bean初始化完成后

完成后将 BeanPostProcessor加载到Bean容器中。

init与 postProcessBeforeInitialization、postProcessAfterInitialization的执行顺序

先执行postProcessBeforeInitialization再执行init 最后执行postProcessAfterInitialization，见源码

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged(new PrivilegedAction<Object>() {
				@Override
				public Object run() {
					invokeAwareMethods(beanName, bean);
					return null;
				}
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}


		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);//1
		}


		try {
			invokeInitMethods(beanName, wrappedBean, mbd);//2
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}


		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);//3
		}
		return wrappedBean;
	}

九、spring的事件机制，Application Event

很好的支持了bean与bean之间的通信，比如这个bean做完了，希望另外的bean能知道并进行相应的处理，这里就是观察者模式，目标发生改变通知订阅他的所有订阅者。最明显的例子就是行人与交通信号灯，信号灯发生改变，行人接收到信号并做出相应的动作。

spring的事件机制三要素：

1.自定义事件。继承ApplicationEvent类

2.自定义事件监听器，实现ApplicationListener接口，接口泛型指定要监听的事件（ApplicationEvent），可以有多个，并添加到容器中

3.使用容器发布事件（通过ApplicationContext.publshe()方法发布消息），并添加到容器中

DemoEvent.class

public class DemoEvent extends ApplicationEvent{
	private String msg;
	public DemoEvent(Object source,String msg) {
		super(source);
		this.msg = msg;
	}
	public String getMsg() {
		return msg;
	}
	public void setMsg(String msg) {
		this.msg = msg;
	}
}

DemoListener.class监听者

@Component
public class DemoListener implements ApplicationListener<DemoEvent>{
	@Override
	public void onApplicationEvent(DemoEvent event) {
		String msg = event.getMsg();
		System.out.println("我（demolistener）接收到了(demopublisher)发布的消息："+msg);
	}
}

DemoPulisher.class发布者，可通过Annocation发布，也可通过实现ApplicationEcentPublisherAware接口实现。

@Component
public class DemoPulisher {
//	public class DemoPulisher implements ApplicationEventPublisherAware {


	//通过applicationContext发布消息
	@Autowired
	private ApplicationContext applicationContext;
	
	public void publisher(String msg){
		//调用applicationCOntext的pubishEvent方法发布消息。
		applicationContext.publishEvent(new DemoEvent(this, msg));
		
	}
//	private ApplicationEventPublisher applicationEventPublisher;
//
//	@Override
//	public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
//		this.applicationEventPublisher = applicationEventPublisher;
//	}
//	
//	public void publisher(String msg){
//		applicationEventPublisher.publishEvent(new DemoEvent(this, msg));
//	}
}

接下来定义配置文件，然后从容器中获取发布者调用发布方法发布相应的消息。