Spring @autowired

使用autowired 可以大量减少配置文件,只需要在Bean前面加上@SpringBean/@Component/@Service之类的annotation, 注入的时候Spring就会自动去照响应implementation.

这样引发的争论是每个service只有一个implementation了,如果有多个的话就要指定,这样跟new就没有什么区别了,一样的hard code。

实际上可以通过@Qulifier来解决:

If you have a hard requirement for autowiring by type. Then you can specify like this,

<bean id="PersonBean1" class="com.mkyong.common.Person">
        <property name="name" value="mkyong1" />
        <property name="address" value="address 1" />
        <property name="age" value="28" />
    </bean>

    <bean id="PersonBean2" class="com.mkyong.common.Person">
        <property name="name" value="mkyong2" />
        <property name="address" value="address 2" />
        <property name="age" value="28" />
    </bean>

and you can specify the bean in your class like,

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

public class Customer 
{
    @Autowired
    @Qualifier("PersonBean1")
    private Person person;
    private int type;
    private String action;
    //getter and setter methods
}

 

 

转载一下(http://blog.csdn.net/chjttony/article/details/6026079):

1.在java开发领域,Spring相对于EJB来说是一种轻量级的,非侵入性的Java开发框架,曾经有两本很畅销的书《Expert one-on-one J2EE Design and Development》和《Expert one-on-one J2EE development without EJB》是java高手进阶必看的宝典,Spring就是从这两本书的理论发展起来的。

Spring主要核心是:

(1).控制反转(IOC):以前传统的java开发模式中,当需要一个对象时我们,我们会自己使用new或者getInstance等直接或者间接调用构造方法创建一个对象,而在Spring开发模式中,Spring容器使用了工厂模式为我们创建了所需要的对象,我们使用时不需要自己去创建,直接调用Spring为我们提供的对象即可,这就是控制反转的思想。实例化一个java对象有三种方式:使用类构造器,使用静态工厂方法,使用实例工厂方法,当使用spring时我们就不需要关心通过何种方式实例化一个对象,spring通过控制反转机制自动为我们实例化一个对象。

(2).依赖注入(DI):Spring使用java Bean对象的Set方法或者带参数的构造方法为我们在创建所需对象时将其属性自动设置所需要的值的过程就是依赖注入的基本思想。

(3).面向切面编程(AOP):在面向对象编程(OOP)思想中,我们将事物纵向抽象成一个个的对象。而在面向切面编程中,我们将一个个对象某些类似的方面横向抽象成一个切面,对这个切面进行一些如权限验证,事物管理,记录日志等公用操作处理的过程就是面向切面编程的思想。

2.在Spring中,所有管理的对象都是Java Bean对象,而BeanFactory和ApplicationContext就是spring框架的两个IOC容器,现在一般使用ApplicationnContext,其不但包含了BeanFactory的作用,同时还进行更多的扩展。

实例化Spring IOC容器的简单方法:

(1).方法1:

  1. //如果只有一个spring配置文件也可以直接传递一个string参数,不需要使用数组
  2. ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{“spring配置文件路径”});

(2).方法2:

  1. Resource res = new FileSystemResource(“spring配置文件”);
  2. BeanFactory factory = new XMLBeanFactory(res);

2. Spring多个配置文件组合方法:

很多时候,由于Spring需要管理和配置的东西比较多,如果都放在一个配置文件中,配置文件会变的比较大,同时不方便与维护,一般好的做法是按照功能模块将Spring配置文件分开,例如:DAO层配置到一个spring-dao.xml配置文件中,Service层配置到spring-service.xml文件中,Struts的action配置到spring-action.xml文件中,然后通过下面两种办法将这些分散的配置文件组合起来:

(1).方法1:在一个作为Spring总配置文件中的<bean>元素定义之前,通过<import>元素将要引入的spring其他配置文件引入,例如:

  1. <beans>
  2.        <import resource=”spring-dao.xml”/>
  3.        <import resource=”spring-service.xml”/>
  4.        <import resource=”spring-action.xml”/>
  5.        ……
  6.        <bean>
  7.        </bean>
  8.        ……
  9. </beans>

(2).方法2:

a.对于JavaSE的工程,当使用下面方法获取ApplicationContext对象时将所有的spring配置文件通过数组传递进去,也可以使用通配符如spring-*.xml方式。

  1. ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{“spring配置文件路径”});

b.对于JavaEE工程,在web.xml文件中指定spring配置文件时可以指定多个,中间有逗号“,”分隔,也可以使用通配符方式。

3. spring配置文件bean的配置规则:

(1).一个Bean可以通过一个id属性惟一指定和引用,如果spring配置文件中有两个以上相同的id时,spring会报错id冲突。

(2).一个Bean也可以通过一个name属性来引用和指定,如果spring配置文件中有两个以上相同name的Bean,则spring通过name引用时,运行时后面的会自动覆盖前面相同name的bean引用,而不会报错。

4.spring依赖注入3种方式:

对于spring配置一个bean时,如果需要给该bean提供一些初始化参数,则需要通过依赖注入方式,所谓的依赖注入就是通过spring将bean所需要的一些参数传递到bean实例对象的过程,spring的依赖注入有3种方式:

(1).使用构造器注入:

  1. <bean id=”……” class=”……”>
  2.        <constructor-arg>构造函数需要的参数1</constructor-arg>
  3.        <constructor-arg>构造函数需要的参数2</constructor-arg>
  4.        ……
  5. </bean>

使用构造器注入方式时:spring在实例化该Bean时会调用配置参数符合的构造方法。

(2).使用属性的setter注入:

  1. <bean id=”……” class=”……”>
  2.        <property name=”属性1” value=”……”/>
  3.        <property name=”属性2” value=”……”/>
  4.        ……
  5. </bean>

使用属性的setter注入方式时,所注入的属性必须提供setter和getter方法,spring在实例化时会自动调用无参数的构造方法或者静态工厂方法,实例化之后自动调用属性的set方法将值设置进去。

(3).使用Field字段注入方式,该方式是spring2.5以后提供的基于java 注解(annotation)方式的注入,就是在java中的字段上或者setter方法上通过使用注解方式进行spring的依赖注入。

例如:

a.字段注入:

  1. @Resource
  2. private  UserDao dao;

b. 属性注入:

  1. @Resource
  2. public void setUserDao(UserDao dao){
  3.        this.dao = dao;
  4. }

5.spring通过注入方式注入依赖bean的方法:

Spring中为一个bean注入其依赖的另一个bean时,通过使用ref来注入另一个bean,简单例子如下:

如果bean2中通过bean1属性引用了bean1则通过下面方式注入:

  1. <beans>
  2.        <bean id=”bean1” class=”……”>
  3.               <property name=”属性1” value=”……”/>
  4.               ……
  5.        </bean>
  6. <bean id=”bean2” class=”……”>
  7.               <property name=”bean1” ref=”bean1”/>
  8.               ……
  9.        </bean>
  10. </beans>

6.spring的集合注入:

当需要给Bean的集合引用注入值时,spring也提供了相应的方法:

(1).Set集合注入:

  1. <bean id=”……” class=”……”>
  2. <set>
  3.               <value>value1</value>
  4.               <value>value2</value>
  5.               ……
  6.        </set>
  7. </bean>

(2).List集合注入:

  1. <bean id=”……” class=”……”>
  2. <list>
  3.               <value>value1</value>
  4.               <value>value2</value>
  5.               ……
  6.        </list>
  7. </bean>

(3).Map集合注入:

  1. <bean id=”……” class=”……”>
  2. <map>
  3.               <entry key=”key1” value=”value1”>
  4.               <entry key=”key2” value=”value2”>
  5.               ……
  6.        </map>
  7. </bean>

(4).Properties注入:

  1. <bean id=”……” class=”……”>
  2. <props>
  3.               <prop key=”key1”>value1</prop>
  4.               <prop key=”key2”>value2</prop>
  5.               ……
  6.        </props>
  7. </bean>

注意:Spring会自动将其数据类型转换,支持泛型。
8. Java注解(Annotation)简单介绍:

Java注解(Annotation)是通过在java源文件上添加标记字段,然后通过反射的反射在编译或者运行时获取这些标记字段以及其标记目标,然后进行相应处理的方法,曾经风靡一时的XDoclet就是最早的java注解的工作原理说明。使用注解可以进行某些配置,大大减少xml配置文件的书写麻烦,但是也有人认为注解方式不方便理解和维护,因此对于注解VS XML配置文件一直争论不断,个人感觉没有好坏之分,合适就是最好的。

(1).JDK内置注解:

JDK内置了3个注解:

a.       @Override:声明某个方法被重写。

b.       @Deprectated:声明某个方法过时,不推荐使用。

c.       @SuppressWarning({“unchecked”,…….}):告诉编译器对于那些警告信息忽略。

(2).自定义java注解:

Java注解就是一种特殊的接口,自定java注解非常方便,简单例子如下:

  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Target(ElementType.CLASS)
  3. public @interface TestAnnotation{
  4. String value() default “”;
  5. }

(3).若要想自定义的注解可以被继承,则需要在自定义注解类上加上“@Inherited”注解。

注意和说明:

a.  java的注解实际上是自动继承了java.lang.annotation.Annotation接口,因此在自定义注解时不能继承其他的注解或者接口。

b.  Retention:告诉编译器如何处理注解,即注解运行在什么时刻。

RetentionPolicy是个枚举类型,有以下三种状态值:

1).SOURCE:该注解存储在源文件中,编译过后即废弃。

2).CLASS:该注解存储在class文件中,是其缺省的值。

3).RUNTIME:该注解存储在class文件中,并且有Java虚拟机读入解析,该类型非常重要,可以使用反射机制获取注解相关信息,可以进行程序分析处理。

c. @Target:指定注解的目标使用对象。

ElementType也是个枚举类型,有以下几种状态值:

1).TYPE:该注解适用于class,interface,enum等类级别的目标对象。

2).FIELD:该注解适用于类中字段级别的目标对象。

3).METHOD:该注解适用于类中方法级别的目标对象。

4).PARAMETER:该注解适用于方法参数级别的目标对象。

5).CONSTRUCTOR:该注解适用于类构造方法。

6).LOCAL_VARIABLE:该注解适用于局部变量。

7).ANNOTATION_TYPE:该注解适用于annotation对象。

8).PACKAGE:该注解适用于package对象。

d.注解里面只能声明属性,不能声明方法,声明属性的方式比较特殊:

语法格式为:数据类型 属性() default 默认值(默认值是可选的); 如:String value();

使用时,“注解对象(属性=属性值)”为注解指定属性值,通过“注解对象.属性;”就可以得到注解属性的值。

e.注解的解析:使用java反射机制获得注解的目标对象就可以得到注解对象,如:

通过反射得到了注解目标的Field对象field,则通过“field.getAnnotation(注解类.class);”就可以得到注解对象。

9.       基于注解的Spring配置准备条件:

从Spring2.5以后,Spring开始全面支持注解方式配置,所以可以不用写xml配置文件,一样可以使用spring。

(1).使用spring注解方式,必须加入spring注解方式所依赖的jar包:common-annotation.jar。

(2).使用注解方式时,必须在spring配置文件的schema中添加注解的命名空间如下:

(3).在spring配置文件中注册注解处理器:

在spring配置文件中<.bean>元素之前添加:

  1. <context:annotation-config>

10.   基于注解的spring配置:

Spring2.5中使用四个注解按功能来进行对bean的配置:

(1).@Component:泛指组件,对于一般不好归类的java Bean使用。

(2).@Service:用于标注配置业务层(service层)组件。

(3).@Controller:用于标注配置控制层的组件(如Struts中的action)。

(4).@Repository:用于标注配置数据访问层组件,即一般的DAO层Bean对象。

注意:对于使用spring注解方式配置的bean对象,bean引用时默认名称为被注解名称的首字母小写形式,也可以指定名称,如:@Service(“userDao“)。

11.   Spring的自动装配:

自动装配的是指不用手动显式配置java Bean之间依赖关系,而是让spring依据某种规则自动将合适的对象注入到目标对象的过程。Spring中常用@Autowire和@Resource来进行自动装配

(1).@Autowire:默认是按照对象的数据类型进行自动装配的,如

  1. @Autowire
  2. private UserDao userDao;

spring框架在运行时会自动将类型为UserDao的对象注入进来。

(2).@Resource:默认是按照名称或者Id进行自动装配的,只有当找不到匹配的名称或者Id时才按类型进行装配,如:

  1. @Resource(name=”userDao”)
  2. private UsreDao userDao;

spring框架在运行时会将配置名称或者id为“userDao”的对象注入进来。

注意:@Autowire和@Resource都既可以写在字段上,也可以写在set方法上。

12.   Spring的自动扫描:

Spring自动扫描机制是指,我们使用基于注解的spring配置方式后,spring的配置文件中只需要注册注解处理器,不用显式地配置Bean,当spring在运行时会自动扫描根据给定的条件下类路径中的所有bean,根据注解将它们注入和装配起来并进行初始化的过程。

自动扫描很简单,只需要在spring的配置文件中添加如:

  1. <context:component-scan base-package=“要自动扫描的包名“>

Spring在运行时就可以对指定的包中所有添加了Spring注解的bean自动扫描,注入,装配和初始化。

注意:基于注解的spring配置,自动装配和自动扫描是紧密联系在一起协同工作的,都需要引入context的命名空间。

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s