Spring annotation2

Spring2

1 spring的IOC container（2）

1.3 spring Annotations

前提在一個applicatcontext中打開註解掃描器配置：

<context:annotation-config/>

Note
<context:annotation-config/> only looks for annotations on beans in the same application
context in which it is defined. This means that, if you put <context:annotation-config/>in a WebApplicationContext for a DispatcherServlet, it only checks for @Autowired
beans in your controllers, and not your services. See Section 17.2, 「The DispatcherServlet」 for
more information.
在哪一個容器中打開就掃描相應的註解！

@Required ：The @Required annotation applies to bean property setter methods, as in the following

@Autowired：

單個方法參數注入
@Autowired
public void setMovieCatalogs(Map<String, MovieCatalog> movieCatalogs) {
    this.movieCatalogs = movieCatalogs;
}
多個方法參數注入
@Autowired
public void setMovieCatalogs(Map<String, MovieCatalog> movieCatalogs) {
this.movieCatalogs = movieCatalogs;

}

若是你在一個類的多個構造器使用這個註解，spring只能搜尋參數最多的一個使用，故官方作法只標註一個構造去就好

爲一個接口類注入實例
@Autowired
private ApplicationContext context;

@Autowired, @Inject, @Resource, and @Value annotations are handled by a Spring BeanPostProcessor implementations which in turn means that you cannot apply these annotations within your own BeanPostProcessor or BeanFactoryPostProcessor types (if any). These types must be wired up explicitly via XML or using a Spring @Bean method.

@Qualifier : 當你用@Autowired去注入一個實例的時候每每會篩選出好多的備選對象，這時候spring提供溫馨的服務，配置這個註解，作更精確的篩選（從備選中篩選出id爲制定的對象）！

public class MovieRecommender {
    @Autowired
    @Qualifier("main")，
    private MovieCatalog movieCatalog;
// ...
}

public class MovieRecommender {
private MovieCatalog movieCatalog;
private CustomerPreferenceDao customerPreferenceDao;
    @Autowired
    public void prepare(@Qualifier("main")MovieCatalog movieCatalog,
    CustomerPreferenceDao customerPreferenceDao) {
    this.movieCatalog = movieCatalog;
    this.customerPreferenceDao = customerPreferenceDao;
    }
// ...
}

當你用bean 定義的name進行注入的時候及不能用@Autowired了，改換@Resource，還有注入Map Collection類型的時候也不能用@Autowired

@Autowired applies to fields, constructors, and multi-argument methods, allowing for narrowing through qualifier annotations at the parameter level

@Resource is supported only for fields and bean property setter methods with a single argument.

自定義

@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface Genre {
    String value();
}


public class MovieRecommender {
    @Autowired
    @Genre("Action")
    private MovieCatalog actionCatalog;
    private MovieCatalog comedyCatalog;
    @Autowired
    public void setComedyCatalog(@Genre("Comedy") MovieCatalog comedyCatalog) {
        this.comedyCatalog = comedyCatalog;
    }
// ...
}

@Resource : 經過bean註冊的name查找引用實例

public class SimpleMovieLister {
    private MovieFinder movieFinder;
    @Resource(name="myMovieFinder")
    public void setMovieFinder(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }
}

不指定name就是給根據set方法後面去取

public class SimpleMovieLister {
    private MovieFinder movieFinder;
    @Resource
    public void setMovieFinder(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }
}

這個等價於 @Resource(name="movieFinder")

The name provided with the annotation is resolved as a bean name by the ApplicationContext of which the CommonAnnotationBeanPostProcessor is aware.

不顯示指定名稱處理工程跟@Autowired同樣了，按照類型找出匹配的對象

@Configuration, @Bean, @Import, and @DependsOn 這些java的註解也能夠使用了！

Spring stereotype annotations

@Component, @Service, and @Controller  @Repository

<context:component-scan>開啓後。不必使用<context:annotation-config>這個了 ，他包括了後者的註解

AutowiredAnnotationBeanPostProcessor
and
CommonAnnotationBeanPostProcessor are both included implicitly when you use the component-
scan element. That means that the two components are autodetected and wired together - all without
any bean configuration metadata provided in XML.

Using filters to customize scanning

@Configuration
@ComponentScan(basePackages = "org.example",
includeFilters = @Filter(type = FilterType.REGEX, pattern = ".*Stub.*Repository"),
excludeFilters = @Filter(Repository.class))
public class AppConfig {
...
}

或者
<beans>
<context:component-scan base-package="org.example">
<context:include-filter type="regex"
expression=".*Stub.*Repository"/>
<context:exclude-filter type="annotation"
expression="org.springframework.stereotype.Repository"/>
</context:component-scan>
</beans>

Defining bean metadata within components

@Component
public class FactoryMethodComponent {
@Bean
@Qualifier("public")
public TestBean publicInstance() {
    return new TestBean("publicInstance");
}
public void doWork() {
// Component method implementation omitted
}
}

Using JSR 330 Standard Annotations

標準註解

Dependency Injection with @Inject and @Named Instead of @Autowired, @javax.inject.Inject may be used as follows:

import javax.inject.Inject;
public class SimpleMovieLister {
private MovieFinder movieFinder;
@Inject
public void setMovieFinder(MovieFinder movieFinder) {
    this.movieFinder = movieFinder;
}
// ...
}

As with @Autowired, it is possible to use @Inject at the class-level, field-level, method-level and
constructor-argument level. If you would like to use a qualified name for the dependency that should be
injected, you should use the @Named annotation as follows:

import javax.inject.Inject;
import javax.inject.Named;
public class SimpleMovieLister {
private MovieFinder movieFinder;
@Inject
public void setMovieFinder(@Named("main") MovieFinder movieFinder) {
    this.movieFinder = movieFinder;
}
// ...
}

@Named: a standard equivalent to the @Component annotation

instead of @Component, @javax.inject.Named may be used as follows:

import javax.inject.Inject;
import javax.inject.Named;
@Named("movieListener")
public class SimpleMovieLister {
private MovieFinder movieFinder;
@Inject
public void setMovieFinder(MovieFinder movieFinder) {
    this.movieFinder = movieFinder;
}
// ...
}