Spring注解篇

2018-06-18 00:48:08来源：未知阅读 ()

本文章所涉及的内容均为网上摘要，只做学习所用。

Spring 基于注解的配置
　　@Required 注解应用于bean属性的setter方法。表明受到影响的bean在配置时必须放到xml配置文件中，否则容器会抛出一个BeanInitialzationException异常。

　　@Autowired 注解对在哪里和如何完成自动连接提供了更多的细微的控制。
　　　　Setter方法中的@Autowired
　　　　可以在setter方法上添加@Autowired 来除去元素，当spring 遇到一个setter方法中使用的@Autowired注解，它会在方法中试图执行byType自动连接
　　　　属性中的@Autowired
　　　　可以在属性中使用@Autowired 注解来除去setter方法，当时使用为自动连接属性传递的时候，Spring会将这些传递过来的值或者引用自动分配给那些属性。
　　　　构造函数中的@Autowired
　　　　可以在构造函数中使用@Autowired，说明当创建bean时，即使在xml文件中没有使用元素配置bean，构造函数也会被自动连接。
　　@Autowired的（required=false）选项
　　　　默认情况下，@Autowired注解意味着依赖是必须的，他类似于@Required注解，然而你可以使用@Autowired的（required=false）选项关闭默认行为。即使不为
　　　　该属性传递任何参数，亦可以运行，且不会报出异常。

　　@Qualifier 注解
　　　　当你创建具有多个相同类型的bean时，并且想要用一个属性只为他们其中的一个进行装配，这个情况下，可以使用@Qualifier注解和@Autowired注解来通过指定哪
　　　　一个真正的bean将会被装配来消除混乱。
　　　　　public class Student {
            private Integer age;
            private String name;
            public void setAge(Integer age) {
                this.age = age;
            }   
            public Integer getAge() {
            return age;
            }
            public void setName(String name) {
                this.name = name;
            }      
            public String getName() {
            return name;
            }
        }

        public class Profile {
            @Autowired
            @Qualifier("student1")
            private Student student;
            public Profile(){
                System.out.println("Inside Profile constructor." );
            }
            public void printAge() {
                System.out.println("Age : " + student.getAge() );
            }
            public void printName() {
                System.out.println("Name : " + student.getName() );
            }
        }
    　　　　　<bean id="profile" class="com.tutorialspoint.Profile">
            </bean>

            
            <bean id="student1" class="com.tutorialspoint.Student">
                <property name="name"  value="name1" />
                <property name="age"  value="11"/>
            </bean>

 
            <bean id="student2" class="com.tutorialspoint.Student">
                <property name="name"  value="name2" />
                <property name="age"  value="2"/>
            </bean>
　　　　　　以上的代码用于解释Qualifier 注解的作用。

　　JSR-250注解

　　　　　　@PostConstruct 和 @PreDestroy 注解
　　　　　　可以使用 @PostConstruct 注解作为初始化回调函数的一个替代，@PreDestroy 注解作为销毁回调函数的一个替代
 1 　　　　　　　public class HelloWorld {
 2                 private String message;
 3                 public void setMessage(String message){
 4                     this.message  = message;
 5                 }
 6                 public String getMessage(){
 7                     System.out.println("Your Message : " + message);
 8                     return message;
 9                 }
10                 @PostConstruct
11                 public void init(){
12                     System.out.println("Bean is going through init.");
13                 }
14                 @PreDestroy
15                 public void destroy(){
16                     System.out.println("Bean will destroy now.");
17                 }
18             }
　　　　

　　　　@Resource 注解
　　　　　　可以在字段中或者 setter 方法中使用 @Resource 注释，它和在 Java EE 5 中的运作是一样的。
　　　　　　依赖注入时查找bean的规则
　　　　　　1.既不指定name属性，也不指定type属性，则自动按byName方式进行查找。如果没有找到符合的bean，则回退为一个原始类型进行进行查找，如果找到就注入。
　　　　　　spring会去找bean元素里name属性值和变量名一致的bean，而不是找id属性与变量名一致的，找不到会报错
　　　　　　2.只是指定了@Resource注解的name，则按name后的名字去bean元素里查找有与之相等的name属性的bean。
　　　　　　3. 只指定@Resource注解的type属性，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常
　　　　　4. 既指定了@Resource的name属性又指定了type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常

　　基于java的配置

　　　　　@Configuration 和 @Bean 注解

　　　　　　　　带有@Configuration 的注解类表示这个类可以使用IoC容器作为bean定义的来源。 @Bean 注解告诉Spring，一个带有@Bean 的注解方法将返回一个对象，该对

　　　　　　　　　　象应该被注册为在Spring应用程序上下文中的bean。

　　　　　　　
        @Configuration
        public class HelloWorldConfig {
            @Bean 
            public HelloWorld helloWorld(){
                return new HelloWorld();
            }
        }
        
        public class Main {
            public static void main(String[] args) {
                ApplicationContext ctx = 
                new AnnotationConfigApplicationContext(HelloWorldConfig.class);

                HelloWorld helloWorld = ctx.getBean(HelloWorld.class);

                helloWorld.setMessage("Hello World!");
                helloWorld.getMessage();
            }    
        }
　　　　　注入 Bean 的依赖性

　　　　　　当@Bean 依赖对方时，表达这种依赖性非常简单，只要有一个bean方法调用另一个。
　　　　　　@Configuration
　　　　　　public class AppConfig {
　　　　　　　　@Bean
　　　　　　　　public Foo foo() {
　　　　　　　　　　return new Foo(bar());
　　　　　　　　　}
　　　　　　　　@Bean
　　　　　　　　public Bar bar() {
　　　　　　　　　　return new Bar();
　　　　　　　　}
　　　　　　}
　　　　　　@Import注解

　　　　　　　　注解允许从另一个配置类中加载@Bean定义。类似于下方代码所示：
　　　　　@Configuration
        public class ConfigA {
            @Bean
            public A a() {
                return new A(); 
            }
        }    
        
        @Configuration
        @Import(ConfigA.class)
        public class ConfigB {
            @Bean
            public B a() {
                return new A(); 
            }
        }
　　　　　　现在，当实例化上下文时，不需要同时制定ConfigA.class和ConfigB.class，只有ConfigB.class需要提供
        public static void main(String[] args) {
            ApplicationContext ctx = 
            new AnnotationConfigApplicationContext(ConfigB.class);
            A a = ctx.getBean(A.class);
            B b = ctx.getBean(B.class);
        }
　　　　生命周期回调

　　　　　　@Bean 注解支持指定任意的初始化和销毁的回调方法，就像在 bean 元素中 Spring 的 XML 的初始化方法和销毁方法的属性

　　　　
        public class Foo {
            public void init() {
                // initialization logic
            }
            public void cleanup() {
                // destruction logic
            }
        }

        @Configuration
        public class AppConfig {
            @Bean(initMethod = "init", destroyMethod = "cleanup" )
            public Foo foo() {
                return new Foo();
            }
        }
　　　　　　指定 Bean 的范围：

　　　　　　默认范围是单实例，但是可以重写带有@Scope注解的该方法。
        @Configuration
        public class AppConfig {
            @Bean
            @Scope("prototype")
            public Foo foo() {
                return new Foo();
            }
        }