软件世界网 购物 网址 三丰软件 | 小说 美女秀 图库大全 游戏 笑话 | 下载 开发知识库 新闻 开发 图片素材
多播视频美女直播
↓电视,电影,美女直播,迅雷资源↓
TxT小说阅读器
↓语音阅读,小说下载,古典文学↓
一键清除垃圾
↓轻轻一点,清除系统垃圾↓
图片批量下载器
↓批量下载图片,美女图库↓
移动开发 架构设计 编程语言 Web前端 互联网
开发杂谈 系统运维 研发管理 数据库 云计算 Android开发资料
  软件世界网 -> 互联网 -> spring3注解详解 -> 正文阅读

[互联网]spring3注解详解


<context:component-scan>标签将自动开启“注解实现Bean依赖注入”支持。标签来表示需要要自动注册Bean定义,而通过base-package属性指定扫描的类路径位置。 
<aop:aspectj-autoproxy/>用于开启Spring对@AspectJ风格切面的支持。 

Xml代码  [img]http://chouyi.iteye.com/images/icon_star.png
  1. <beans xmlns="http://www.springframework.org/schema/beans"  
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3.     xmlns:aop="http://www.springframework.org/schema/aop"  
  4.     xmlns:context="http://www.springframework.org/schema/context"  
  5.     xsi:schemaLocation="  
  6.        http://www.springframework.org/schema/beans  
  7.        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  8.        http://www.springframework.org/schema/aop  
  9.        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
  10.        http://www.springframework.org/schema/context  
  11.        http://www.springframework.org/schema/context/spring-context-3.0.xsd"  
  12.     default-lazy-init="true">  
  13.       
  14.     <context:annotation-config />  
  15.     <context:component-scan base-package="com.chou.spring.bean"/>  
  16.     <aop:aspectj-autoproxy proxy-target-class="true" />  
  17.   
  18.     <bean id="myBeanAA" class="com.chou.spring.bean.MyBeanA" />  
  19. </beans>  

Java代码  [img]http://chouyi.iteye.com/images/icon_star.png
  1. //main方法  
  2. ApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext-an.xml");  
  3. MyBeanB b = cxt.getBean("myBeanB",MyBeanB.class);  
  4. b.domain();  

Spring自带的@Component注解及扩展@Repository、@Service、@Controller 
[img]http://dl.iteye.com/upload/attachment/0073/3957/43860681-69ad-38a1-98cf-b10ae0e03508.jpg 
@ManagedBean注解及自定义扩展:@ManagedBean注解,需要在应用服务器环境使用(如Jboss),自定义扩展部分是为了配合Spring自带的模式注解扩展自定义的,并不包含在Java EE 6规范中,在Java EE 6中相应的服务层、DAO层功能由EJB来完成。 
[img]http://dl.iteye.com/upload/attachment/0073/3959/19323756-f26b-305d-b9e3-441fd8577297.jpg 
@Named注解及自定义扩展,允许放置在类型、字段、方法参数上: 
[img]http://dl.iteye.com/upload/attachment/0073/3961/ecbc105e-bef0-3f21-948c-8d1d1f95cb45.jpg 
@ManagedBean和@Named用法可以参考博客:http://jinnianshilongnian.iteye.com/blog/1461055 
常用的Bean的配置元数据@Lazy,@DependsOn,@Scope,@Qualifier,@Primary 
常用依赖注入注解@Autowired:自动装配,@Value:注入SpEL表达式,@Qualifier:限定描述符,@Resource:自动装配,@PostConstructPreDestroy:通过注解指定初始化和销毁方法定义;
 
Java代码  [img]http://chouyi.iteye.com/images/icon_star.png
  1. @Repository  
  2. public class MyBeanB implements MyBean{  
  3.     protected static final Log logger = LogFactory.getLog(MyBeanB.class);  
  4.       
  5.     @PostConstruct   
  6.     public void MyInit(){  
  7.         logger.info("[INFO]...MyBeanB is initing..."null);  
  8.     }  
  9.       
  10.     @PreDestroy   
  11.     public void Mydestory() {  
  12.         logger.info("[INFO]...MyBeanB is destorying..."null);  
  13.     }  
  14.       
  15.     /** 
  16.      * @Autowired 默认byType进行自动装配,可以用于构造器、字段、方法注入 
  17.      * 且必须有一个Bean候选者注入,如果允许出现0个Bean候选者需要设置属性“required=false”, 
  18.      * “required”属性含义和@Required一样,只是@Required只适用于基于XML配置的setter注入方式。 
  19.      *  
  20.      * @Resource 默认如果name和type属性都不指定,将先byName自动装配,找不到再byType 
  21.      * 如果配置了name属性,使用byName进行自动装配,而使用type时则使用byType进行装配 
  22.      * 如果同时指定name和type,则从容器中找唯一匹配的bean装配,找不到抛出异常 
  23.      *  
  24.      * @Resource 注解应该只用于setter方法注入和字段属性注入,不能提供如@Autowired多参数方法注入; 
  25.      * @Resource 首先将从JNDI环境中查找资源,如果没找到默认再到Spring容器中查找, 
  26.      * 因此如果JNDI环境中有和Spring容器同名的资源时需要注意。 
  27.      */  
  28.     //@Resource //注意这里是javax.annotation.Resource  
  29.     private MyBeanA bean;  
  30.       
  31.     @Autowired(required = true)  
  32.     public void setBean(@Qualifier("myBeanAA") MyBeanA myBean) {  
  33.         //@Qualifier用于按类型自动装配时有多个同类型的bean时,规定选择某一个名称的bean  
  34.         this.bean = myBean;  
  35.     }  
  36.       
  37.     public void domain(){  
  38.         System.out.println("MyBeanB is executing...");  
  39.         bean.domain();  
  40.         bean.sayAround("haha");  
  41.         //throw new RuntimeException("This is a RuntimeException");  
  42.     }  
  43.       
  44. }  

Java代码  [img]http://chouyi.iteye.com/images/icon_star.png
  1. @Component("myBeanA")//初始化bean的名字默认是类名第一个字母小写  
  2. //@Controller 表示层  
  3. //@Service //业务逻辑层  
  4. //@Repository //数据访问层  
  5.   
  6. //@Lazy(false) //延迟初始化  
  7. //@DependsOn("myBeanB") ////定义Bean初始化及销毁时的顺序  
  8. //@Scope("prototype") //默认单例singleton  
  9. //@Primary //自动装配时当出现多个Bean候选者时,将作为首选者  
  10. public class MyBeanA{  
  11.     protected static final Log logger = LogFactory.getLog(MyBeanA.class);  
  12.       
  13.     @PostConstruct  
  14.     public void MyInit(){//bean初始化之前调用的方法,等同于xml配置的init-method  
  15.         logger.info("[INFO]...MyBeanA is initing..."null);  
  16.     }  
  17.       
  18.     @PreDestroy  
  19.     public void Mydestory() {//bean销毁之前调用的方法,等同于xml配置的destroy-method  
  20.         logger.info("[INFO]...MyBeanA is destorying..."null);  
  21.     }  
  22.       
  23.     //@Value用于注入SpEL表达式,可以放置在字段方法或参数上  
  24.     @Value(value = "#{'Hello Spring!!!'[0]}")  
  25.     private String myName;  
  26.       
  27.     @Value("#{100}")  
  28.     private Long myAge;  
  29.       
  30.     private Map<String, String> resultMap;  
  31.       
  32.     @Value("abc")  
  33.     private String arg1;  
  34.       
  35.     @Value("101")  
  36.     private Long arg2;  
  37.       
  38.     @Value("#{1==1 ? true : false}")  
  39.     private Boolean b1;  
  40.       
  41.     @Value("#{'no'}")  
  42.     private Boolean b2;  
  43.       
  44.     @Value("#{'on'}")  
  45.     private Boolean b3;  
  46.       
  47.     @Value("#{@systemProperties}")  
  48.     private Properties pros;  
  49.       
  50.     @Value("#{ new double[]{100,44,3.1415,0.4432} }")  
  51.     private Double[] nums;  
  52.       
  53.     public void domain() {  
  54.         System.out.println("MyBeanA is executing...");  
  55.         for (int i = 0; i < nums.length; i++) {  
  56.             System.out.println(nums[i]);  
  57.         }  
  58.         System.out.println(pros.getProperty("os.name"));  
  59.         //System.out.println(System.getProperties());  
  60.         System.out.println(b1);  
  61.         System.out.println(b2);  
  62.         System.out.println(b3);  
  63.         System.out.println(arg1);  
  64.         System.out.println(arg2);  
  65.         System.out.println(myName);  
  66.         System.out.println(myAge);  
  67.         if (resultMap != null) {  
  68.             System.out.println(resultMap.values());  
  69.         }  
  70.     }  
  71.     public void sayAround(String param) {    
  72.           System.out.println("around param:" + param);    
  73.     }  
  74.   
  75.     //依赖检查必须是set方法上,并通过xml文件的property属性注入  
  76.     //@Required 表示一定要有property属性注入,很少用到  
  77.     public void setResultMap(Map<String, String> resultMap) {  
  78.         this.resultMap = resultMap;  
  79.     }  
  80.       
  81. }  

@AspectJ风格的切面可以通过@Compenent注解标识其为Spring管理Bean,而@Aspect注解不能被Spring自动识别并注册为Bean,必须通过@Component注解来完成,示例如下: 
Spring使用的AOP注解分为三个层次:
1、@Aspect放在类头上,把这个类作为一个切面,但是这个类一定要显式的注册在Spring容器中。
2、 @Pointcut放在方法头上,定义一个可被别的方法引用的切入点表达式。
3、5种通知。
3.1、@Before,前置通知,放在方法头上。
3.2、@After,后置【finally】通知,放在方法头上。
3.3、@AfterReturning,后置【try】通知,放在方法头上,使用returning来引用方法返回值。
3.4、@AfterThrowing,后置【catch】通知,放在方法头上,使用throwing来引用抛出的异常。
3.5、@Around,环绕通知,放在方法头上,这个方法要决定真实的方法是否执行,而且必须有返回值。
[img]http://sishuok.com/forum/upload/2012/2/23/9d3908721f863fadfe203953dfb98e9a__9.jpg
Java代码  [img]http://chouyi.iteye.com/images/icon_star.png
  1. @Aspect  
  2. @Component  
  3. public class Interceptor {  
  4.       
  5.     @Pointcut("execution ( public * com.chou.spring.bean..*.domain(..))")  
  6.     public void myPointcut() {}   
  7.       
  8.     @Before("myPointcut()")  
  9.     public void beforeDomain() {  
  10.         System.out.println("This is beforeDomain....");  
  11.     }  
  12.       
  13.     @AfterReturning("execution ( public * com.chou.spring.bean.MyBeanA.domain(..))")  
  14.     public void afterReturning() {  
  15.         System.out.println("This is afterReturning....");  
  16.     }  
  17.       
  18.     @AfterThrowing("myPointcut()")  
  19.     public void afterThrowing() {  
  20.         System.out.println("This is afterThrowing....");  
  21.     }  
  22.       
  23.     @After("myPointcut()")  
  24.     public void afterDomain() {  
  25.         System.out.println("This is afterDomain....");  
  26.     }  
  27.       
  28.     @Around("execution(* com.chou.spring.bean..*.sayAround(..))")  
  29.     public Object around(ProceedingJoinPoint pjp) throws Throwable {    
  30.         System.out.println("===========around before advice");    
  31.         Object retVal = pjp.proceed(new Object[] {"【环绕通知】"});    
  32.         System.out.println("===========around after advice");    
  33.         return retVal;    
  34.     }  
  35. }  

细粒度控制Bean定义扫描 
在XML配置中完全消除了Bean定义,而是只有一个<context:component-scan>标签来支持注解Bean定义扫描。 
前边的示例完全采用默认扫描设置,如果我们有几个组件不想被扫描并自动注册、我们想更改默认的Bean标识符生成策略该如何做呢?接下来让我们看一下如何细粒度的控制Bean定义扫描,具体定义如下:
 
Xml代码  [img]http://chouyi.iteye.com/images/icon_star.png
  1. <context:component-scan  
  2.         base-package=""  
  3.         resource-pattern="**/*.class"  
  4.         name-generator="org.springframework.context.annotation.AnnotationBeanNameGenerator"  
  5.         use-default-filters="true"  
  6.         annotation-config="true">  
  7.         <context:include-filter type="aspectj" expression=""/>  
  8.         <context:exclude-filter type="regex" expression=""/>  
  9. </context:component-scan>     


  • base-package:表示扫描注解类的开始位置,即将在指定的包中扫描,其他包中的注解类将不被扫描,默认将扫描所有类路径;
  • resource-pattern:表示扫描注解类的后缀匹配模式,即“base-package+resource-pattern”将组成匹配模式用于匹配类路径中的组件,默认后缀为“**/*.class”,即指定包下的所有以.class结尾的类文件;
  • name-generator:默认情况下的Bean标识符生成策略,默认是AnnotationBeanNameGenerator,其将生成以小写开头的类名(不包括包名);可以自定义自己的标识符生成策略;
  • use-default-filters:默认为true表示扫描@Component、@ManagedBean、@Named注解的类,如果改为false默认将不扫描这些默认的注解来定义Bean,即这些注解类不能被扫描到,即不能通过这些注解进行Bean定义;
  • annotation-config:表示是否自动支持注解实现Bean依赖注入,默认支持,如果设置为false,将关闭支持注解的依赖注入,需要通过<context:annotation-config/>开启。

默认情况下将自动扫描@Component、@ManagedBean、@Named注解的类并将其注册为Spring管理Bean,可以通过在<context:component-scan>标签中指定自定义过滤器将扫描到匹配条件的类注册为Spring管理Bean,过滤器用里面的<context:include-filter />标签来定义: 
Xml代码  [img]http://chouyi.iteye.com/images/icon_star.png
  1. <context:include-filter type="aspectj" expression=""/>  
  2. <context:exclude-filter type="regex" expression=""/>  

  • <context:include-filter>:表示扫描到的类将被注册为Spring管理Bean;
  • <context:exclude-filter>:表示扫描到的类将不被注册为Spring管理Bean,它比<context:include-filter>具有更高优先级;
  • type:表示过滤器类型,目前支持注解类型、类类型、正则表达式、aspectj表达式过滤器,当然也可以自定义自己的过滤器,实现org.springframework.core.type.filter.TypeFilter即可;
  • expression:表示过滤器表达式。

一般情况下没必要进行自定义过滤,如果需要请参考博客: 
http://jinnianshilongnian.iteye.com/blog/1461055 
基于Java类定义Bean配置元数据 
基于Java类定义Bean配置元数据,其实就是通过Java类定义Spring配置元数据,且直接消除XML配置文件。 
基于Java类定义Bean配置元数据中的@Configuration注解的类等价于XML配置文件,@Bean注解的方法等价于XML配置文件中的Bean定义。 
基于Java类定义Bean配置元数据需要通过AnnotationConfigApplicationContext加载配置类及初始化容器,类似于XML配置文件需要使用ClassPathXmlApplicationContext加载配置文件及初始化容器。
这种用法是Spring3.X的新特性,但是用起来还是没有注解或者XML形式的直观,不建议使用,而且在WEB应用中还需要特别去修改web.xml文件。具体用法请参考博客: 
http://jinnianshilongnian.iteye.com/blog/1463704 

......显示全文...
    点击查看全文


上一篇文章      下一篇文章      查看所有文章
2016-04-01 16:55:16  
互联网 最新文章
C++11并发API总结
16.收款(AcceptingMoney)
数据链路层综述
IP协议及IP数据报解析
《浅谈HTTP协议》
计算机网络基础
LoadRunner和RPT之间关于手动关联和参数化的
HTTPS中的对称密钥加密,公开密钥加密,数字
上班需要打卡吗?(开通微信公众号--乘着风
ofbizjmsactivemq
360图书馆 软件开发资料 文字转语音 购物精选 软件下载 美食菜谱 新闻资讯 电影视频 小游戏 Chinese Culture
生肖星座 三丰软件 视频 开发 Android开发 站长 古典小说 网文精选 搜图网 美图 中国文化英文版 多播 租车 短信
2017-7-24 10:30:36
多播视频美女直播
↓电视,电影,美女直播,迅雷资源↓
TxT小说阅读器
↓语音阅读,小说下载,古典文学↓
一键清除垃圾
↓轻轻一点,清除系统垃圾↓
图片批量下载器
↓批量下载图片,美女图库↓
  网站联系: qq:121756557 email:121756557@qq.com  软件世界网 --