软件世界网 购物 网址 三丰软件 | 小说 美女秀 图库大全 游戏 笑话 | 下载 开发知识库 新闻 开发 图片素材
多播视频美女直播
↓电视,电影,美女直播,迅雷资源↓
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 股票 租车
生肖星座 三丰软件 视频 开发 短信 中国文化 网文精选 搜图网 美图 阅读网 多播 租车 短信 看图 日历 万年历 2018年1日历
2018-1-17 14:41:43
多播视频美女直播
↓电视,电影,美女直播,迅雷资源↓
TxT小说阅读器
↓语音阅读,小说下载,古典文学↓
一键清除垃圾
↓轻轻一点,清除系统垃圾↓
图片批量下载器
↓批量下载图片,美女图库↓
  网站联系: qq:121756557 email:121756557@qq.com  软件世界网 --