Spring注解@Component、@Repository、@Service、@Controller @Resource、@Autowired、@Qualifier 解析

我们在使用spring的时候经常会用到这些注解，那么这些注解到底有什么区别呢。我们先来看代码

同样分三层来看：

Action 层：

package com.ulewo.ioc;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class IocAction {
    @Autowired
    private IocService service;
    
    public void add(){
        service.add();
    }
}


service层：（service就直接定义类了，没有定义接口，定义接口也是一样的）

package com.ulewo.ioc;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

@Service
public class IocService {
    @Resource
    private IIocDao iocDao;
    public void add(){
        iocDao.add();
    }
}


Dao层

先定义一个接口

package com.ulewo.ioc;

public interface IIocDao {
    public void add();
}


然后实现类：

package com.ulewo.ioc;

import org.springframework.stereotype.Repository;

@Repository
public class IocDao implements IIocDao{
    public void add(){
        System.out.println("调用了dao");
    }
}


然后spring的配置，这个配置就很简单了，因为是基于注解的，我们不需要再xml中来定义很多

applicationContext.xml

 
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:jee="http://www.springframework.org/schema/jee"
   xmlns:tx="http://www.springframework.org/schema/tx"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xmlns:task="http://www.springframework.org/schema/task"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
                       http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
                       http://www.springframework.org/schema/tx
                       http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
                       http://www.springframework.org/schema/jee
                       http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
                       http://www.springframework.org/schema/context
                       http://www.springframework.org/schema/context/spring-context-3.2.xsd
                       http://www.springframework.org/schema/aop
                       http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
                       http://www.springframework.org/schema/task
                       http://www.springframework.org/schema/task/spring-task-3.2.xsd">
   
    
     


让spring自动扫描包就行了。

然后是我们的测试类：

IocTest:

package com.ulewo.ioc;

import junit.framework.TestCase;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class IocTest extends TestCase{
    
    public void testIoc(){
        BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
        IocAction action = factory.getBean("iocAction", IocAction.class);
        action.add();
    }
}

运行后，我们会发现 控制台打印：调用了dao


@Component、@Repository、@Service、@Controller @Resource、@Autowired、@Qualifier

这几个基本都用到了 除了 @Component  @Qualifier


我们观察会发现@Repository、@Service、@Controller 这几个是一个类型，其实@Component 跟他们也是一个类型的

Spring 2.5 中除了提供 @Component注释外，还定义了几个拥有特殊语义的注释，它们分别是：@Repository、@Service和 @Controller 其实这三个跟@Component 功能是等效的


@Service用于标注业务层组件（我们通常定义的service层就用这个）

@Controller用于标注控制层组件（如struts中的action）

@Repository用于标注数据访问组件，即DAO组件

@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。


这几个注解是当你需要定义某个类为一个bean，则在这个类的类名前一行使用@Service("XXX"),就相当于讲这个类定义为一个bean，bean名称为XXX; 这几个是基于类的，我们可以定义名称，也可以不定义，不定义会默认以类名为bean的名称（类首字母小写）。


然后我们在看后面的几个注解

@Resource、@Autowired、@Qualifier

当需要在某个类中定义一个属性，并且该属性是一个已存在的bean，要为该属性赋值我们就用着三个。我们看上面的代码可以看到这三个都是定义在一个属性上的，比如

@Resource
private IIocDao iocDao;

@Autowired
private IocService service;

那这几个到底有什么区别呢？

我们先看@Resource，它是javax.annotation.Resource; 这个包中，也就是说是javaEE中的，并不是spring中的

而且@Resource("xxx") 是可以定义bean名称的，就是说我这个属性要用那个bean来赋值。


@Autowired，它是org.springframework.beans.factory.annotation.Autowired 是这个包中，它是spring的包。

而且它没有@Autowired("xxx"),那我要为这个bean定义名称怎么办这个时候可以用@Qualifier("xxx") 这个也是spring中的。这个xxx定义bean名称有什么用呢？我们回头看下刚才的代码。

在IIocDao 这个接口中，我们定义的实现类IocDao 只有一个，好那么我们再定义一个实现类：

package com.ulewo.ioc;

import org.springframework.stereotype.Repository;

@Repository
public class IocDao2 implements IIocDao{
    public void add(){
        System.out.println("调用了dao2");
    }
}

其他不变，我们再运行：testIoc(),控制台打印出 调用了dao，所以在service层中

@Resource
private IIocDao iocDao;

这个iocDao 注入的是IocDao 这个实现。奇怪了，它怎么知道我要调用哪个实现呢？

好我们修改一下，把 private IIocDao iocDao;改一下，改成 private IIocDao iocDaox 把属性名改一下，再运行，会报错：

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [com.ulewo.ioc.IIocDao] is defined: expected single matching bean but found 2: iocDao,iocDao2

错误很明显啊，有两个bean iocDao和iocDao2,但是我们的是iocDaox所以找不到了。所以可以看出来在用 @Repository注解来生成bean的时候，如果没有定义名称那么就会根据类名来生成。所以我们要调用第二个实现的时候可以 定义为private IIocDao iocDao2 。我们再运行：调用了dao2，所以可以根据属性名来区分，到底注入那个bean。但是有的人说，我不想定义bean名称跟类实现一样，我要定义其他的，那怎么玩呢，方法有2种：


第一种：我们在生成bean的时候就给bean定义个名称

@Repository("myIocDao")
public class IocDao implements IIocDao{
    public void add(){
        System.out.println("调用了dao");
    }
}

当然@Service是一样的,这样就把这个实现定义为myIocDao了，而不是默认的类名 iocDao。

那么我们在使用这个bean的时候就要这么定义了：

@Resource
private IIocDao myIocDao;

运行 输出：调用了dao

如果你这里不是用的 myIocDao,你又多加了一个x，成了myIocDaox，你运行会是这样的：

 org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [com.ulewo.ioc.IIocDao] is defined: expected single matching bean but found 2: myIocDao,iocDao2

所以，要自定义bean的名称可以在类注解的时候指定。


第二种：在注入bean的时候指定名称：

先看@Resource

我们这么定义下：

@Resource(name="iocDao")
private IIocDao xx;

注意：

@Repository
public class IocDao implements IIocDao{
    public void add(){
        System.out.println("调用了dao");
    }
}

这里还是用会默认的，也就是这个实现对应的是 iocDao这bean。如果你要为这个类指定别名bean，@Repository("myIocDao"),那@Resource(name="myIocDao") 就要这么写了。就是这里的name要跟实现类对应的bean名称保持一致。private IIocDao xx; 这个属性名就随便写了。

运行：调用了dao

如果用Autowired就要这么写了

@Autowired
@Qualifier("iocDao")
private IIocDao xx;

因为Autowired 不能像Resource 那样带个参数指定一个name，就要用Qualifier来指定了。


而且还可以这么用

@Resource
@Qualifier("iocDao")
private IIocDao xx;

等同于

@Resource(name="iocDao")
private IIocDao xx;


记住一点：@Resource的作用相当于@Autowired，只不过@Autowired按byType自动注入，如果发现找到多个bean，则，又按照byName方式比对，如果还有多个，则报出异常 而@Resource默认按 byName自动注入罢了。其实spring注解，最常用的还是根据名称，根据类型啊，构造方法啊，用的非常少。所以在多个实现的时候我们定义好bean的名称就行，就不会错乱。


说了这么多，不知道对着几个注解是不是了解多一点了呢，貌似这些注解 没有根本上的区别，就看你习惯怎么用了。拿代码多跑几次，然后根据自己的想法改改，你就明白这几个注解的用处啦。


==========

spring注解注入:详解
spring从2.5版本开始支持注解注入，注解注入可以省去很多的xml配置工作。由于注解是写入java代码中的，所以注解注入会失去一定的灵活性，我们要根据需要来选择是否启用注解注入。

我们首先看一个注解注入的实际例子，然后再详细介绍context:component-scan的使用。

如果你已经在用spring mvc的注解配置，那么你一定已经在使用注解注入了，本文不会涉及到spring mvc，我们用一个简单的例子来说明问题。

本例中我们会定义如下类：

    PersonService类，给上层提供Person相关操作
    PersonDao类，给PersonService类提供DAO方法
    Person类，定义Person相关属性，是一个POJO
    App类，入口类，调用注解注入的PersonService类

PersonService类实现如下：

package cn.outofmemory.spring;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class PersonService {

    @Autowired
    private PersonDao personDao;
    
    public Person getPerson(int id) {
        return personDao.selectPersonById(id);
    }
}

在Service类上使用了@Service注解修饰，在它的私有字段PersonDao上面有@Autowired注解修饰。@Service告诉spring容器，这是一个Service类，默认情况会自动加载它到spring容器里。而@Autowired注解告诉spring，这个字段是需要自动注入的。

PersonDao类：

package cn.outofmemory.spring;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;

@Scope("singleton")
@Repository
public class PersonDao {

    public Person selectPersonById(int id) {
        Person p = new Person();
        p.setId(id);
        p.setName("Person name");
        return p;
    }
}

在PersonDao类上面有两个注解，分别为@Scope和@Repository，前者指定此spring bean的scope是单例，你也可以根据需要将此bean指定为prototype，@Repository注解指定此类是一个容器类，是DA层类的实现。这个类我们只是简单的定义了一个selectPersonById方法，该方法的实现也是一个假的实现，只是声明了一个Person的新实例，然后设置了属性，返回他，在实际应用中DA层的类肯定是要从数据库或者其他存储中取数据的。

Person类：

package cn.outofmemory.spring;

public class Person {
    private int id;
    private String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

Person类是一个POJO。

App类：

package cn.outofmemory.spring;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * Hello spring! from outofmemory.cn
 *
 */
public class App
{
    public static void main( String[] args )
    {
        ApplicationContext appContext = new ClassPathXmlApplicationContext("/spring.xml");
        PersonService service = appContext.getBean(PersonService.class);
        Person p = service.getPerson(1);
        System.out.println(p.getName());
    }
}

在App类的main方法中，我们初始化了ApplicationContext，然后从中得到我们注解注入的PersonService类，然后调用此对象的getPerson方法，并输出返回结果的name属性。

注解注入也必须在spring的配置文件中做配置，我们看下spring.xml文件的内容：


       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.0.xsd">
   
       
    


这个配置文件中必须声明xmlns:context 这个xml命名空间，在schemaLocation中需要指定schema：

           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.0.xsd

这个文件中beans根节点下只有一个context:component-scan节点，此节点有两个属性base-package属性告诉spring要扫描的包，use-default-filters="false"表示不要使用默认的过滤器，此处的默认过滤器，会扫描包含Service,Component,Repository,Controller注解修饰的类，而此处我们处于示例的目的，故意将use-default-filters属性设置成了false。

context:component-scan节点允许有两个子节点和。filter标签的type和表达式说明如下：
Filter Type     Examples Expression     Description
annotation     org.example.SomeAnnotation     符合SomeAnnoation的target class
assignable     org.example.SomeClass     指定class或interface的全名
aspectj     org.example..*Service+     AspectJ語法
regex     org\.example\.Default.*     Regelar Expression
custom     org.example.MyTypeFilter     Spring3新增自訂Type，實作org.springframework.core.type.TypeFilter

在我们的示例中，将filter的type设置成了正则表达式，regex，注意在正则里面.表示所有字符，而\.才表示真正的.字符。我们的正则表示以Dao或者Service结束的类。

我们也可以使用annotaion来限定，如下：


       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.0.xsd">
   
       
       
    


 这里我们指定的include-filter的type是annotation，expression则是注解类的全名。

另外context:conponent-scan节点还有可以用来指定要排除的类，其用法和include-filter一致。

最后我们要看下输出的结果了，运行App类，输出：

2014-5-18 21:14:18 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1cac6db: startup date [Sun May 18 21:14:18 CST 2014]; root of context hierarchy
2014-5-18 21:14:18 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [spring.xml]
2014-5-18 21:14:18 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@1fcf790: defining beans [personDao,personService,org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor]; root of factory hierarchy
Person name

前几行都是spring输出的一些调试信息，最后一行是我们自己程序的输出。