spring 注解

gavinlau

浏览: 297622 次
性别:
来自: 上海

最近访客更多访客>>

icedcoco

stanley_llin

yonghong

bichonghai_1111

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

Spring Bean AOP XML 配置管理

annotations spring hibernatre

2009-07-16 22:14

@Autowired
1、Spring 通过一个 BeanPostProcessor 对 @Autowired 进行解析，所以要让 @Autowired 起作用必须事先在 Spring 容器中声明 AutowiredAnnotationBeanPostProcessor Bean。

Java代码

<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>

<!-- 该 BeanPostProcessor 将自动起作用，对标注 @Autowired 的 Bean 进行自动注入 -->
<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>

或者使用隐式注册（隐式注册 post-processors 包括了 AutowiredAnnotationBeanPostProcessor，CommonAnnotationBeanPostProcessor，PersistenceAnnotationBeanPostProcessor，RequiredAnnotationBeanPostProcessor。）

Java代码

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:annotation-config/>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"        
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-2.5.xsd
http://www.springframework.org/schema/context            
http://www.springframework.org/schema/context/spring-context-2.5.xsd">

<context:annotation-config/> 
</beans>

2、@Autowired默认按照类型匹配的方式进行注入
3、@Autowired注解可以用于成员变量、setter方法、构造器函数等
4、使用@Autowired注解须有且仅有一个与之匹配的Bean，当找不到匹配的 Bean 或者存在多个匹配的Bean时，Spring 容器将抛出异常
5、Spring 允许我们通过 @Qualifier 注释指定注入 Bean 的名称。@Autowired 和 @Qualifier 结合使用时，自动注入的策略就从 byType 转变成 byName 了。

Java代码

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

public class MovieRecommender {

@Autowired
@Qualifier("mainCatalog")
private MovieCatalog movieCatalog;
    
    private CustomerPreferenceDao customerPreferenceDao;

    @Autowired
    public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) {
        this.customerPreferenceDao = customerPreferenceDao;
    }

    // ...
}

@Resource
1、@Resource 的作用相当于 @Autowired，只不过 @Autowired 按 byType 自动注入，@Resource 默认按 byName 自动注入罢了。
2、要让 JSR-250 的注释生效，除了在 Bean 类中标注这些注释外，还需要在 Spring 容器中注册一个负责处理这些注释的 BeanPostProcessor

Java代码

<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/>

<bean  class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/>

3、@Resource 有两个属性是比较重要的，分别是 name 和 type，Spring 将 @Resource 注释的 name 属性解析为 Bean 的名字，而 type 属性则解析为 Bean 的类型。所以如果使用 name 属性，则使用 byName 的自动注入策略，而使用 type 属性时则使用 byType 自动注入策略。如果既不指定 name 也不指定 type 属性，这时将通过反射机制使用 byName 自动注入策略。

Java代码

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

public class SimpleMovieLister {

    private MovieFinder movieFinder;

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

@PostConstruct 和 @PreDestroy
标注了 @PostConstruct 注释的方法将在类实例化后调用，而标注了 @PreDestroy 的方法将在类销毁之前调用。

Java代码

public class CachingMovieLister {
@PostConstruct
public void populateMovieCache() {
// populates the movie cache upon initialization...
}
@PreDestroy
public void clearMovieCache() {
// clears the movie cache upon destruction...
}
}

public class CachingMovieLister {

    @PostConstruct
    public void populateMovieCache() {
        // populates the movie cache upon initialization...
    }
    
    @PreDestroy
    public void clearMovieCache() {
        // clears the movie cache upon destruction...
    }
}

@Component
1、使用@Component注解可以直接定义Bean，而无需在xml定义。但是若两种定义同时存在，xml中的定义会覆盖类中注解的Bean定义。
2、@Component 有一个可选的入参，用于指定 Bean 的名称。

Java代码

@Component
public class ActionMovieCatalog implements MovieCatalog {
// ...
}

@Component
public class ActionMovieCatalog implements MovieCatalog {
    // ...
}

3、<context:component-scan/> 允许定义过滤器将基包下的某些类纳入或排除。Spring 支持以下 4 种类型的过滤方式：

过滤器类型	表达式范例
annotation	org.example.SomeAnnotation
assignable	org.example.SomeClass
regex	org\.example\.Default.*
aspectj	org.example..*Service+

下面这个XML配置会忽略所有的@Repository注解并用“stub”储存库代替。

Java代码

<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>

<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>

4、默认情况下通过 @Component 定义的 Bean 都是 singleton 的，如果需要使用其它作用范围的 Bean，可以通过 @Scope 注释来达到目标

Java代码

@Scope("prototype")
@Repository
public class MovieFinderImpl implements MovieFinder {
// ...
}

@Scope("prototype")
@Repository
public class MovieFinderImpl implements MovieFinder {
    // ...
}

5、Spring 2.5引入了更多典型化注解(stereotype annotations)： @Component、@Service和 @Controller。 @Component是所有受Spring管理组件的通用形式；而@Repository、@Service和 @Controller则是@Component的细化，用来表示更具体的用例(例如，分别对应了持久化层、服务层和表现层)

Java代码

@Service
public class SimpleMovieLister {
private MovieFinder movieFinder;
@Autowired
public SimpleMovieLister(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
}
@Repository
public class JpaMovieFinder implements MovieFinder {
// implementation elided for clarity
}

@Service
public class SimpleMovieLister {

    private MovieFinder movieFinder;

    @Autowired
    public SimpleMovieLister(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }
}

@Repository
public class JpaMovieFinder implements MovieFinder {
    // implementation elided for clarity
}

6、要检测这些类并注册相应的bean，需要在XML中包含以下元素，其中'basePackage'是两个类的公共父包 (或者可以用逗号分隔的列表来分别指定包含各个类的包)。

Java代码

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:component-scan base-package="org.example"/>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd">
               
     <context:component-scan base-package="org.example"/>
     
</beans>

此外，在使用组件扫描元素时，AutowiredAnnotationBeanPostProcessor 和CommonAnnotationBeanPostProcessor会隐式地被包括进来。也就是说，连个组件都会被自动检测并织入 - 所有这一切都不需要在XML中提供任何bean配置元数据。

=====================================================================

spring mvc :http://www.ibm.com/developerworks/cn/java/j-lo-spring25-mvc/

Spring注解：

1. @Autowired注解

     @Autowired可以对成员变量、方法和构造函数进行标注，来完成自动装配的工作。@Autowired的标注位置不同，它们都会在Spring在初始化这个bean时，自动装配这个属性。要使@Autowired能够工作，还需要在配置文件中加入以下           Java代码 <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />

               <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />

2. @Qualifier

    @Autowired是根据类型进行自动装配的。例如，如果当Spring上下文中存在不止一个UserDao类型的bean时，就会抛出BeanCreationException异常；如果Spring上下文中不存在UserDao类型的bean，也会抛出BeanCreationException异常。我们可以使用@Qualifier配合@Autowired来解决这些问题。如下：

   1). 可能存在多个UserDao实例



@Autowired

public void setUserDao(@Qualifier("userDao") UserDao userDao) {

    this.userDao = userDao;

}

@Autowired

public void setUserDao(@Qualifier("userDao") UserDao userDao) {

this.userDao = userDao;

}



   这样，Spring会找到id为userDao的bean进行装配。

   2). 可能不存在UserDao实例



@Autowired(required = false)

public void setUserDao(UserDao userDao) {

    this.userDao = userDao;

}

@Autowired(required = false)

public void setUserDao(UserDao userDao) {

this.userDao = userDao;

}

3. @Resource

   JSR-250标准注解，推荐使用它来代替Spring专有的@Autowired注解。@Resource的作用相当于@Autowired，只不过@Autowired按byType自动注入，而@Resource默认按byName自动注入罢了。@Resource有两个属性是比较重要的，分别是name和type，Spring将 @Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。

    @Resource装配顺序

       如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常

       如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常

       如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常

       如果既没有指定name，又没有指定type，则自动按照byName方式进行装配（见2）；如果没有匹配，则回退为一个原始类型（UserDao）进行匹配，如果匹配则自动装配；

4. @PostConstruct（JSR-250）

    在方法上加上注解@PostConstruct，这个方法就会在Bean初始化之后被Spring容器执行（注：Bean初始化包括，实例化Bean，并装配Bean的属性（依赖注入））。

它的一个典型的应用场景是，当你需要往Bean里注入一个其父类中定义的属性，而你又无法复写父类的属性或属性的setter方法时，如：



public class UserDaoImpl extends HibernateDaoSupport implements UserDao {

    private SessionFactory mySessionFacotry;

    @Resource

    public void setMySessionFacotry(SessionFactory sessionFacotry) {

        this.mySessionFacotry = sessionFacotry;

     }

    @PostConstruct

    public void injectSessionFactory() {

        super.setSessionFactory(mySessionFacotry);

     }



}

    这里通过@PostConstruct，为UserDaoImpl的父类里定义的一个sessionFactory私有属性，注入了我们自己定义的 sessionFactory（父类的setSessionFactory方法为final，不可复写），之后我们就可以通过调用 super.getSessionFactory()来访问该属性了。

5. @PreDestroy（JSR-250）

    在方法上加上注解@PreDestroy，这个方法就会在Bean初始化之后被Spring容器执行。其用法同@PostConstruct。和@PostConstruct 区别在于：@PostConstruct注释的方法将在类实例化后调用，而标注了 @PreDestroy 的方法将在类销毁之前调用。

6. @Component（不推荐使用）

    只需要在对应的类上加上一个@Component注解，就将该类定义为一个Bean了。Spring还提供了更加细化的注解形式：@Repository、@Service、@Controller，它们分别对应存储层Bean，业务层Bean，和展示层Bean。目前版本（2.5）中，这些注解与@Component的语义是一样的，完全通用，在Spring以后的版本中可能会给它们追加更多的语义。所以，我们推荐使用@Repository、@Service、@Controller来替代@Component。

7.@Scope

    在使用XML定义Bean时，我们可能还需要通过bean的scope属性来定义一个Bean的作用范围，我们同样可以通过@Scope注解来完成这项工作：



@Scope("session")

@Component()

public class UserSessionBean implements Serializable{

。。。。。。。。。。。。

}

二。配置

1. 使用<context:annotation-config />简化配置

      Spring2.1添加了一个新的context的Schema命名空间，该命名空间对注释驱动、属性文件引入、加载期织入等功能提供了便捷的配置。我们知道注释本身是不会做任何事情的，它仅提供元数据信息。要使元数据信息真正起作用，必须让负责处理这些元数据的处理器工作起来。

    AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor就是处理这些注释元数据的处理器。但是直接在Spring配置文件中定义这些Bean显得比较笨拙。Spring为我们提供了一种方便的注册这些BeanPostProcessor的方式，这就是<context:annotation-config />。<context:annotation-config />将隐式地向Spring容器注册 AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、 PersistenceAnnotationBeanPostProcessor以及 RequiredAnnotationBeanPostProcessor这4个BeanPostProcessor。

2. 使用<context:component-scan />让Bean定义注解工作起来

    <context:component-scan />的base-package属性指定了需要扫描的类包，类包及其递归子包中所有的类都会被处理。

   注意： <context:component-scan />配置项不但启用了对类包进行扫描以实施注释驱动Bean定义的功能，同时还启用了注释驱动自动注入的功能（即还隐式地在内部注册了 AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor），因此当使用<context:component-scan />后，就可以将<context:annotation-config />移除了。

3.<tx:annotation-driven/>

   <context:annotation-config />是不支持spring的@Transcation和EJB的Spring's @Transactional or EJB3's @TransactionAttribute annotation。用此配置可以达到目的。

======================================================================

研究了很久新出的 Spring 2.5, 总算大致明白了如何用标注定义 Bean, 但是如何定义和注入类型为 java.lang.String 的 bean 仍然未解决, 希望得到高人帮助.

　　总的来看 Java EE 5 的标注开发方式开来是得到了大家的认可了.

　　@Service 相当于定义 bean, 自动根据 bean 的类名生成一个首字母小写的 bean

　　@Autowired 则是自动注入依赖的类, 它会在类路径中找成员对应的类/接口的实现类, 如果找到多个, 需要用 @Qualifier("chineseMan") 来指定对应的 bean 的 ID.

　　一定程度上大大简化了代码的编写, 例如一对一的 bean 映射现在完全不需要写任何额外的 bean 定义了.

　　下面是代码的运行结果:

man.sayHello()=抽你丫的
SimpleMan said: Hi
org.example.EnglishMan@12bcd4b said: Fuck you!

　　代码:

　　beans.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"
　　　 xmlns:context="http://www.springframework.org/schema/context"
　　　 xsi:schemaLocation="http://www.springframework.org/schema/beans
　　　　　 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
　　　　　 http://www.springframework.org/schema/context
　　　　　 http://www.springframework.org/schema/context/spring-context-2.5.xsd">
　　 <context:annotation-config/>
　　 <context:component-scan base-package="org.example"/>
</beans>

　　测试类:

import org.example.IMan;
import org.example.SimpleMan;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTest {
　　public static void main(String[] args) {
　　　　ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
　　　　SimpleMan dao = (SimpleMan) ctx.getBean("simpleMan");
　　　　System.out.println(dao.hello());
　　　　IMan man = (IMan) ctx.getBean("usMan");
　　　　System.out.println(man.sayHello());
　　}
}

　　自动探测和注入bean的类:

package org.example;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
public class SimpleMan {
　　// 自动注入名称为 Man 的 Bean
　　@Autowired(required = false)
　　@Qualifier("chineseMan")
　　//@Qualifier("usMan")
　　private IMan man;　　
　　/**
　　 * @return the man
　　 */
　　public IMan getMan() {
　　　　return man;
　　}
　　/**
　　 * @param man the man to set
　　 */
　　public void setMan(IMan man) {
　　　　this.man = man;
　　}
　　public String hello() {
　　　　System.out.println("man.sayHello()=" + man.sayHello());
　　　　return "SimpleMan said: Hi";
　　}
}
　　
一个接口和两个实现类:
package org.example;
/**
* 抽象的人接口.
* @author BeanSoft
* @version 1.0
*/
public interface IMan {
　　/**
　　 * 打招呼的抽象定义.
　　 * @return 招呼的内容字符串
　　 */
　　public String sayHello();
}
　　
package org.example;
import org.springframework.stereotype.Service;
/**
* 中国人的实现.
* @author BeanSoft
*/
@Service
public class ChineseMan implements IMan {
　　public String sayHello() {
　　　　return "抽你丫的";
　　}
}
package org.example;
import org.springframework.stereotype.Service;
/**
* @author BeanSoft
* 美国大兵
*/
@Service("usMan")
// 这里定义了一个 id 为 usMan 的 Bean, 标注里面的属性是 bean 的 id
public class EnglishMan implements IMan {
　　public String sayHello() {
　　　　return this + " said: Fuck you!";
　　}
}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/nini1109/archive/2009/06/17/4277588.aspx

======================================================================

<context:component-scan base-package="com.easyjob.cnhuike" use-default-filters="false" >
<context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
<context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/>
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<context:component-scan base-package="com.easyjob.cnhuike" use-default-filters="false" >
		<context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
		<context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/>
		<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	</context:component-scan>

Java代码