小夥伴們在催更Spring系列，於是我寫下了這篇註解彙總！！

大家好，我是冰河~~

由於在更新其他專題的文章，Spring系列文章有很長一段時間沒有更新了，很多小夥伴都在公眾號後臺留言或者直接私信我微信催更Spring系列文章。

看來是要繼續更新Spring文章了。想來想去，寫一篇關於Spring中註解相關的文章吧，因為之前更新Spring系列的文章一直也是在更新Spring註解驅動開發。這篇文章也算是對之前文章的一個小小的總結吧，估計更新完這篇，我們會進入Spring的AOP章節的更新。

沒有看過Spring其他文章的小夥伴，可以到【冰河技術】公號的【Spring系列】專題中進行閱讀。

文章已收錄到：

https://github.com/sunshinelyz/technology-binghe

https://gitee.com/binghe001/technology-binghe

xml配置與類配置

1.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/sp
	<bean id="person" class="com.binghe.spring.Person"></bean>
</beans>

獲取Person例項如下所示。

public static void main( String[] args ){
	ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
	System.out.println(ctx.getBean("person"));
}

2.類配置

@Configuration
public class MainConfig {
    @Bean
    public Person person(){
    	return new Person();
    }
}		

這裡，有一個需要注意的地方：通過@Bean的形式是使用的話， bean的預設名稱是方法名，若@Bean(value="bean的名稱")那麼bean的名稱是指定的 。

獲取Person例項如下所示。

public static void main( String[] args ){
	AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);
	System.out.println(ctx.getBean("person"));
}

@CompentScan註解

我們可以使用@CompentScan註解來進行包掃描，如下所示。

@Configuration
@ComponentScan(basePackages = {"com.binghe.spring"})
	public class MainConfig {
}	

excludeFilters 屬性

當我們使用@CompentScan註解進行掃描時，可以使用@CompentScan註解的excludeFilters 屬性來排除某些類，如下所示。

@Configuration
@ComponentScan(basePackages = {"com.binghe.spring"},excludeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class}),
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,value = {PersonService.class})
})
public class MainConfig {
}

includeFilters屬性

當我們使用@CompentScan註解進行掃描時，可以使用@CompentScan註解的includeFilters屬性將某些類包含進來。這裡需要注意的是：需要把useDefaultFilters屬性設定為false（true表示掃描全部的）

@Configuration
@ComponentScan(basePackages = {"com.binghe.spring"},includeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class, PersonService.class})
},useDefaultFilters = false)
public class MainConfig {
}

@ComponentScan.Filter type的型別

• 註解形式的FilterType.ANNOTATION @Controller @Service @Repository @Compent
• 指定型別的 FilterType.ASSIGNABLE_TYPE @ComponentScan.Filter(type =FilterType.ASSIGNABLE_TYPE,value = {Person.class})
• aspectj型別的 FilterType.ASPECTJ(不常用)
• 正規表示式的 FilterType.REGEX(不常用)
• 自定義的 FilterType.CUSTOM

public enum FilterType {
    //註解形式 比如@Controller @Service @Repository @Compent
    ANNOTATION,
    //指定的型別
    ASSIGNABLE_TYPE,
    //aspectJ形式的
    ASPECTJ,
    //正規表示式的
    REGEX,
    //自定義的
    CUSTOM
}

FilterType.CUSTOM 自定義型別

public class CustomFilterType implements TypeFilter {
@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
    //獲取當前類的註解源資訊
    AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
    //獲取當前類的class的源資訊
    ClassMetadata classMetadata = metadataReader.getClassMetadata();
    //獲取當前類的資源資訊
    Resource resource = metadataReader.getResource();
 	return classMetadata.getClassName().contains("Service");
}
    
@ComponentScan(basePackages = {"com.binghe.spring"},includeFilters = {
@ComponentScan.Filter(type = FilterType.CUSTOM,value = CustomFilterType.class)
},useDefaultFilters = false)
public class MainConfig {
}

配置Bean的作用域物件

不指定@Scope

在不指定@Scope的情況下，所有的bean都是單例項的bean，而且是餓漢載入(容器啟動例項就建立好了)

@Bean
public Person person() {
	return new Person();
}	

@Scope為 prototype

指定@Scope為 prototype 表示為多例項的，而且還是懶漢模式載入（IOC容器啟動的時候，並不會建立物件，而是在第一次使用的時候才會建立）

@Bean
@Scope(value = "prototype")
public Person person() {
    return new Person();
}

@Scope取值

• singleton 單例項的(預設)
• prototype 多例項的
• request 同一次請求
• session 同一個會話級別

懶載入

Bean的懶載入@Lazy(主要針對單例項的bean 容器啟動的時候，不建立物件，在第一次使用的時候才會建立該物件)

@Bean
@Lazy
public Person person() {
	return new Person();
}

@Conditional條件判斷

場景，有二個元件CustomAspect 和CustomLog ，我的CustomLog元件是依賴於CustomAspect的元件
應用：自己建立一個CustomCondition的類 實現Condition介面

public class CustomCondition implements Condition {
/****
@param context
* @param metadata
* @return
*/
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //判斷容器中是否有CustomAspect的元件
        return context.getBeanFactory().containsBean("customAspect");
    }	
} 

public class MainConfig {
    @Bean
    public CustomAspect customAspect() {
        return new CustomAspect();
    } 
    @Bean
    @Conditional(value = CustomCondition.class)
    public CustomLog customLog() {
   		return new CustomLog();
    }
}

向IOC 容器新增元件

（1）通過@CompentScan +@Controller @Service @Respository @compent。適用場景: 針對我們自己寫的元件可以通過該方式來進行載入到容器中。

（2）通過@Bean的方式來匯入元件(適用於匯入第三方元件的類)

（3）通過@Import來匯入元件 （匯入元件的id為全類名路徑）

@Configuration
@Import(value = {Person.class})
public class MainConfig {
}

通過@Import 的ImportSeletor類實現元件的匯入 (匯入元件的id為全類名路徑)

public class CustomImportSelector implements ImportSelector {	
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
    	return new String[]{"com.binghe.spring"};
    }
} 
Configuration
@Import(value = {Person.class}
public class MainConfig {
}

通過@Import的 ImportBeanDefinitionRegister匯入元件 (可以指定bean的名稱)

public class DogBeanDefinitionRegister implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //建立一個bean定義物件
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Dog.class);
        //把bean定義物件匯入到容器中
        registry.registerBeanDefinition("dog",rootBeanDefinition);
    }
} 
@Configuration
@Import(value = {Person.class, Car.class, CustomImportSelector.class, DogBeanDefinitionRegister.class})
public class MainConfig {
}

通過實現FacotryBean介面來實現註冊 元件

public class CarFactoryBean implements FactoryBean<Car> {
    @Override
    public Car getObject() throws Exception {
    	return new Car();
    } 
    @Override
    public Class<?> getObjectType() {
    	return Car.class;
    } 

    @Override
    public boolean isSingleton() {
    	return true;
    }
}

Bean的初始化與銷燬

指定bean的初始化方法和bean的銷燬方法

由容器管理Bean的生命週期，我們可以通過自己指定bean的初始化方法和bean的銷燬方法

@Configuration
public class MainConfig {
    //指定了bean的生命週期的初始化方法和銷燬方法.@Bean(initMethod = "init",destroyMethod = "destroy")
    public Car car() {
    	return new Car();
    }
}

針對單例項bean的話，容器啟動的時候，bean的物件就建立了，而且容器銷燬的時候，也會呼叫Bean的銷燬方法

針對多例項bean的話,容器啟動的時候，bean是不會被建立的而是在獲取bean的時候被建立，而且bean的銷燬不受IOC容器的管理

通過 InitializingBean和DisposableBean實現

通過 InitializingBean和DisposableBean個介面實現bean的初始化以及銷燬方法

@Component
public class Person implements InitializingBean,DisposableBean {
    public Person() {
    	System.out.println("Person的構造方法");
    } 
    @Override
    public void destroy() throws Exception {
    	System.out.println("DisposableBean的destroy()方法 ");
    } 
    @Override
    public void afterPropertiesSet() throws Exception {
    	System.out.println("InitializingBean的 afterPropertiesSet方法");
    }
}

通過JSR250規範

通過JSR250規範 提供的註解@PostConstruct 和@ProDestory標註的方法

@Component
public class Book {
    public Book() {
    	System.out.println("book 的構造方法");
    } 
    @PostConstruct
    public void init() {
    	System.out.println("book 的PostConstruct標誌的方法");
    } 
    @PreDestroy
    public void destory() {
    	System.out.println("book 的PreDestory標註的方法");
    }
}

通過BeanPostProcessor實現

通過Spring的BeanPostProcessor的 bean的後置處理器會攔截所有bean建立過程

• postProcessBeforeInitialization 在init方法之前呼叫
• postProcessAfterInitialization 在init方法之後呼叫

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    	System.out.println("CustomBeanPostProcessor...postProcessBeforeInitialization:"+beanName);
   		return bean;
    } 
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("CustomBeanPostProcessor...postProcessAfterInitialization:"+beanName);
        return bean;
    }
}	

BeanPostProcessor的執行時機

populateBean(beanName, mbd, instanceWrapper)
initializeBean{
    applyBeanPostProcessorsBeforeInitialization()
    invokeInitMethods{
    isInitializingBean.afterPropertiesSet()
    自定義的init方法
}
applyBeanPostProcessorsAfterInitialization()方法
}

通過@Value +@PropertySource來給元件賦值

public class Person {
    //通過普通的方式
    @Value("獨孤")
    private String firstName;
    //spel方式來賦值
    @Value("#{28-8}")
    private Integer age;
    通過讀取外部配置檔案的值
    @Value("${person.lastName}")
    private String lastName;
} 
@Configuration
@PropertySource(value = {"classpath:person.properties"}) //指定外部檔案的位置
public class MainConfig {
    @Bean
    public Person person() {
        return new Person();
    }
}

自動裝配

@AutoWired的使用

自動注入

@Repository
public class CustomDao {
} 
@Service
public class CustomService {
    @Autowired
    private CustomDao customDao;
｝

結論:
（1）自動裝配首先時按照型別進行裝配，若在IOC容器中發現了多個相同型別的元件，那麼就按照 屬性名稱來進行裝配

@Autowired
private CustomDao customDao;

比如，我容器中有二個CustomDao型別的元件 一個叫CustomDao 一個叫CustomDao2那麼我們通過@AutoWired 來修飾的屬性名稱時CustomDao，那麼拿就載入容器的CustomDao元件，若屬性名稱為tulignDao2 那麼他就載入的時CustomDao2元件

（2）假設我們需要指定特定的元件來進行裝配，我們可以通過使用@Qualifier("CustomDao")來指定裝配的元件
或者在配置類上的@Bean加上@Primary註解

@Autowired
@Qualifier("CustomDao")
private CustomDao customDao2

（3）假設我們容器中即沒有CustomDao 和CustomDao2,那麼在裝配的時候就會丟擲異常

No qualifying bean of type 'com.binghhe.spring.dao.CustomDao' available

若我們想不拋異常 ，我們需要指定 required為false的時候可以了

@Autowired(required = false)
@Qualifier("customDao")
private CustomDao CustomDao2;

（4）@Resource(JSR250規範)
功能和@AutoWired的功能差不多一樣，但是不支援@Primary 和@Qualifier的支援

（5）@InJect（JSR330規範）
需要匯入jar包依賴，功能和支援@Primary功能 ,但是沒有Require=false的功能

<dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <version>1</version>
</dependency>

（6）使用@Autowired 可以標註在方法上

• 標註在set方法上

//@Autowired
public void setCustomLog(CustomLog customLog) {
	this.customLog = customLog;
}

• 標註在構造方法上

@Autowired
public CustomAspect(CustomLog customLog) {
	this.customLog = customLog;
}

標註在配置類上的入參中（可以不寫）

@Bean
public CustomAspect CustomAspect(@Autowired CustomLog customLog) {
    CustomAspect customAspect = new CustomAspect(customLog);
    return ustomAspect;
}

XXXAwarce介面

我們自己的元件 需要使用spring ioc的底層元件的時候,比如 ApplicationContext等我們可以通過實現XXXAware介面來實現

@Component
public class CustomCompent implements ApplicationContextAware,BeanNameAware {
    private ApplicationContext applicationContext;
    @Override
    public void setBeanName(String name) {
    	System.out.println("current bean name is :【"+name+"】");
    } 
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    	this.applicationContext = applicationContext;
    }
}

@Profile註解

通過@Profile註解 來根據環境來啟用標識不同的Bean

• @Profile標識在類上，那麼只有當前環境匹配，整個配置類才會生效
• @Profile標識在Bean上 ，那麼只有當前環境的Bean才會被啟用
• 沒有標誌為@Profile的bean 不管在什麼環境都可以被啟用

@Configuration
@PropertySource(value = {"classpath:ds.properties"})
public class MainConfig implements EmbeddedValueResolverAware {
    @Value("${ds.username}")
    private String userName;
    @Value("${ds.password}")
    private String password;
    private String jdbcUrl;
    private String classDriver;
    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        this.jdbcUrl = resolver.resolveStringValue("${ds.jdbcUrl}");
        this.classDriver = resolver.resolveStringValue("${ds.classDriver}");
    } 
    @Bean
    @Profile(value = "test")
    public DataSource testDs() {
   		return buliderDataSource(new DruidDataSource());
    }
    @Bean
    @Profile(value = "dev")
    public DataSource devDs() {
    	return buliderDataSource(new DruidDataSource());
    } 
    @Bean
    @Profile(value = "prod")
    public DataSource prodDs() {
    	return buliderDataSource(new DruidDataSource());
    } 
    private DataSource buliderDataSource(DruidDataSource dataSource) {
        dataSource.setUsername(userName);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(classDriver);
        dataSource.setUrl(jdbcUrl);
    	return dataSource;
    }
}

啟用切換環境的方法

（1）執行時jvm引數來切換

 -Dspring.profiles.active=test|dev|prod  

（2）通過程式碼的方式來啟用

public static void main(String[] args) {
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
    ctx.getEnvironment().setActiveProfiles("test","dev");
    ctx.register(MainConfig.class);
    ctx.refresh();
    printBeanName(ctx);
}

好了，今天就到這兒吧，我是冰河，大家有啥問題可以在下方留言，也可以加我微信：sun_shine_lyz，我拉你進群，一起交流技術，一起進階，一起牛逼~~