Spring中的各項注解的用法

本篇內容介紹了“Spring中的各項注解的用法”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

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); }

“Spring中的各項注解的用法”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！