澳门新葡亰娱乐网站-www.142net-欢迎您

澳门新葡亰娱乐网站是因为你还没有找到一条正确的致富之路,www.142net是将所有的游戏都汇集在一起的官方平台,因为澳门新葡亰娱乐网站这个网站当中有着大量的游戏攻略,托IP定位技术,传达终端直接到达的精准传播方式。

IoC中逐条注明的知情和接纳,Spring常用评释

来源:http://www.bhtsgq.com 作者:计算机知识 人气:110 发布时间:2019-05-30
摘要:初稿链接:壹.      2.  前言 IoC其实有二种艺术,1种是DI,而另1种是DL,即DependencyLookup(注重查找),前者是现阶段软件实体被动接受其借助的任何零件被IOc容器注入,而后者是近些日子

初稿链接:壹.       2. 

前言

IoC其实有二种艺术,1种是DI,而另1种是DL,即Dependency Lookup(注重查找),前者是现阶段软件实体被动接受其借助的任何零件被IOc容器注入,而后者是近些日子软件实体主动去某些服务登记地搜寻其借助的那1个服务。

葡京网上开户 1

小编们常见涉及的Spring IoC实际上是值Spring框架提供的IoC容器完毕(IoC Container),而使用Spring IoC容器的非凡代码片段是

1  ApplicationContext ac = new ClassPathXmlApplicationContext("test.xml");
2         User user = (User) ac.getBean("testBean");
3         System.out.println(user.getUserName() "----------" user.getEmail());

概述

Spring二.五 引进了讲授。
于是乎,2个难点发生了:选择注明格局注入 JavaBean 是否迟早完爆 xml方式?
不至于。正所谓,各执己见各执一词。任何事物都有其优缺点,看你哪些采用。来看望申明的利害:
优点:大大收缩了配备,并且能够使配置更是精细——类,方法,字段都能够用证明去标识。
缺点:使用申明,不可幸免发生了侵入式编制程序,也发出了一些标题。

  • 你要求将注脚插手你的源码并编写翻译它;
  • 表明往往非常粗放,不易管理控制。

注:spring 中,先进行申明注入,然后才是xml注入,因而只要流入的靶子1致,后者会覆盖前者。

Spring常用申明 使用阐明来组织IoC容器的措施,springioc

利用表明来组织IoC容器

用评释来向Spring容器注册Bean。供给在applicationContext.xml中注册<context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。

如:在base-package指爱他美(Nutrilon)个包

<context:component-scan base-package="cn.gacl.java"/>

标记cn.gacl.java包及其子包中,即使有个别类的头上带有一定的讲明【@Component/@Repository/@Service/@Controller】,就能将这一个指标作为Bean注册进Spring容器。也能够在<context:component-scan base-package=” ”/>中内定四个包,如:

<context:component-scan base-package="cn.gacl.dao.impl,cn.gacl.service.impl,cn.gacl.action"/>

多少个包逗号隔开分离。

1、@Component

@Component

是具有受Spring 管理组件的通用格局,@Component申明能够放在类的头上,@Component不推荐使用。

2、@Controller

@Controller对应表现层的Bean,也正是Action,比如:

 @Controller
 @Scope("prototype")
 public class UserAction extends BaseAction<User>{
 ……
 }

应用@Controller表明标记UserAction之后,就象征要把UserAction交给Spring容器管理,在Spring容器中会存在一个名称为"userAction"的action,这么些名字是基于UserAction类名来取的。注意:要是@Controller不钦命其value【@Controller】,则暗许的bean名称为那么些类的类名首字母小写,纵然钦赐value【@Controller(value="UserAction")】也许【@Controller("UserAction")】,则动用value作为bean的名字。

那边的UserAction还使用了@Scope注脚,@Scope("prototype")表示将Action的限定注脚为原型,能够利用容器的scope="prototype"来担保每贰个请求有2个独门的Action来拍卖,制止struts中Action的线程安全主题素材。spring 暗中同意scope 是单例情势(scope="singleton"),那样只会创设贰个Action对象,每趟访问都以同1Action对象,数据不安全,struts二是讲求每一回次访问都对应差别的Action,scope="prototype" 能够确定保证当有请求的时候都创设三个Action对象

3、@ Service

@Service对应的是事情层Bean,例如:

@Service("userService")
 public class UserServiceImpl implements UserService {
 ………
 }

葡京网上开户,@Service("userService")注解是告诉Spring,当Spring要创建User瑟维斯Impl的的实例时,bean的名字务必叫做"userService",那样当Action须求动用UserServiceImpl的的实例时,就足以由Spring创制好的"userService",然后注入给Action:在Action只需求声爱他美(Aptamil)(Nutrilon)个名字叫“userService”的变量来取出由Spring注入的"userService"就能够,具体代码如下:

 // 注入userService
 @Resource(name = "userService")
 private UserService userService;

1、把在Spring的xml文件中计划bean改为Spring的笺注来安排bean

古板的Spring做法是使用.xml文件来对bean举办注入或然是陈设aop、事物,这么做有八个缺陷:
一、如若具备的剧情都安顿在.xml文件中,那么.xml文件将会至极特大;尽管按需求分开.xml文件,那么.xml文件又会相当的多。综上说述那将形成配置文件的可读性与可维护性别变化得比比较低。
贰、在支付中在.java文件和.xml文件之间穿梭切换,是1件劳心的事,同期这种观念上的不连贯也会减低开拓的功效。
为了化解那五个难题,Spring引进了疏解,通过"@XXX"的法子,让注明与Java Bean紧凑结合,既大大裁减了配备文件的容量,又增添了Java Bean的可读性与内聚性。

不使用表明:

先看二个不行使声明的Spring示例,在那么些示例的根底上,改成申明版本的,那样也能观望使用与不使用申明之间的界别,先定义三个老虎:

 1 package com.spring.model;
 2 
 3 public class Tiger {
 4     
 5     private String tigerName="TigerKing";
 6     
 7     public String toString(){
 8         return "TigerName:" tigerName;
 9     }
10 }

再定义贰个猴子:

 1 package com.spring.model;
 2 
 3 public class Monkey {
 4     
 5     private String monkeyName = "MonkeyKing";
 6     
 7     public String toString(){
 8         return "MonkeyName:"   monkeyName;
 9     }
10 
11 }

概念1个动物园:

 1 package com.spring.model;
 2 
 3 public class Zoo {
 4     private Tiger tiger;
 5     private Monkey monkey;
 6     
 7     public Tiger getTiger() {
 8         return tiger;
 9     }
10     public void setTiger(Tiger tiger) {
11         this.tiger = tiger;
12     }
13     public Monkey getMonkey() {
14         return monkey;
15     }
16     public void setMonkey(Monkey monkey) {
17         this.monkey = monkey;
18     }
19     
20     public String toString(){
21         return tiger   "n"   monkey;
22     }
23     
24 }

spring的安顿文件这么写:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans
 3     xmlns="http://www.springframework.org/schema/beans"
 4     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5     xmlns:p="http://www.springframework.org/schema/p"
 6     xmlns:context="http://www.springframework.org/schema/context"
 7     xsi:schemaLocation="http://www.springframework.org/schema/beans
 8     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 9     http://www.springframework.org/schema/context
10     http://www.springframework.org/schema/context/spring-context-3.0.xsd
11     ">
12     
13      <bean id="zoo" class="com.spring.model.Zoo" >
14         <property name="tiger" ref="tiger" />
15         <property name="monkey" ref="monkey" />
16     </bean>
17     
18     <bean id="tiger" class="com.spring.model.Tiger" />
19     <bean id="monkey" class="com.spring.model.Monkey" />
20 
21 </beans>

测试方法:

 1 public class TestAnnotation {
 2     /**
 3      * 不使用注解
 4      */
 5     @Test
 6     public void test(){
 7         //读取配置文件
 8         ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext2.xml");
 9         Zoo zoo=(Zoo) ctx.getBean("zoo");
10         System.out.println(zoo.toString());
11     }
12 }

IoC中逐条注明的知情和接纳,Spring常用评释。都很熟练,权当复习壹遍了。

1、@Autowired

@Autowired以偏概全,就是电动装配,其作用是为着裁撤代码Java代码里面包车型客车getter/setter与bean属性中的property。当然,getter看个人须要,如若个人属性要求对外提供的话,应当予以保留。

@Autowired暗许按类型相配的方法,在容器查找相称的Bean,当有且仅有二个一双两好的Bean时,Spring将其注入@Autowired标明的变量中。

之所以,引进@Autowired注明,先看一下spring配置文件怎么写:

 1  <?xml version="1.0" encoding="UTF-8"?>
 2  <beans
 3      xmlns="http://www.springframework.org/schema/beans"
 4      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5      xmlns:p="http://www.springframework.org/schema/p"
 6      xmlns:context="http://www.springframework.org/schema/context"
 7      xsi:schemaLocation="http://www.springframework.org/schema/beans
 8      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 9      http://www.springframework.org/schema/context
10      http://www.springframework.org/schema/context/spring-context-3.0.xsd
11      ">
12      
13      <context:component-scan base-package="com.spring" />
14      
15      <bean id="zoo" class="com.spring.model.Zoo" />
16      <bean id="tiger" class="com.spring.model.Tiger" />
17      <bean id="monkey" class="com.spring.model.Monkey" />
18  
19  </beans>

瞩目第一3行,使用必须告诉spring一下自己要利用注明了,告诉的主意有繁多,<context:component-scan base-package="xxx" />是一种最简便的,spring会自动扫描xxx路线下的讲解。

看看第一五行,原本zoo里面应当注入两性格情tiger、monkey,以后不要求注入了。再看下,Zoo.java也很便宜,把getter/setter都得以去掉:

 1 package com.spring.model;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 
 5 public class Zoo {
 6     
 7     @Autowired
 8     private Tiger tiger;
 9     
10     @Autowired
11     private Monkey monkey;
12     
13     public String toString(){
14         return tiger   "n"   monkey;
15     }
16     
17 }

此地@Autowired注脚的乐趣正是,当Spring开掘@Autowired注明时,将活动在代码上下文中找到和其合作(暗许是种类相称)的Bean,并自行注入到对应的地方去。

有三个细节性的标题是,要是bean里面有多个property,Zoo.java里面又去掉了品质的getter/setter并动用@Autowired表明标明那多少个属性那会怎么?答案是Spring会根据xml优先的标准去Zoo.java中寻觅那两本特性的getter/setter,导致的结果就是初阶化bean报错。 

OK,固然此时自家把.xml文件的16行、一柒行两行给去掉,再运转,会抛出非常:

葡京网上开户 2葡京网上开户 3

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'zoo': Injection of autowired dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire field: private com.spring.model.Tiger com.spring.model.Zoo.tiger; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No matching bean of type [com.spring.model.Tiger] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:285)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1074)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:517)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:456)
    at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:291)
    at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:222)
    at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:288)
    at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:190)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:580)
    at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:895)
    at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:425)
    at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:139)
    at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:83)
    at com.spring.test.TestAnnotation.test(TestAnnotation.java:16)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
    at java.lang.reflect.Method.invoke(Method.java:597)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:45)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:42)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:263)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:68)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:47)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:231)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:60)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:229)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:50)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:222)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:300)
    at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:45)
    at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:460)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:673)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:386)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:196)
Caused by: org.springframework.beans.factory.BeanCreationException: Could not autowire field: private com.spring.model.Tiger com.spring.model.Zoo.tiger; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No matching bean of type [com.spring.model.Tiger] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:502)
    at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:84)
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:282)
    ... 36 more
Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No matching bean of type [com.spring.model.Tiger] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoSuchBeanDefinitionException(DefaultListableBeanFactory.java:920)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:789)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:703)
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:474)
    ... 38 more

View Code

因为,@Autowired表明要去寻找的是1个Bean,Tiger和Monkey的Bean定义都给去掉了,自然就不是1个Bean了,Spring容器找不到也很好精通。那么,倘若属性找不到本人不想让Spring容器抛出非常,而就是显得null,能够呢?能够的,其实特别信息里面也付出了提醒了,便是将@Autowired注解的required属性设置为false就可以:

 1 package com.spring.model;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 
 5 public class Zoo {
 6     
 7     @Autowired(required=false)
 8     private Tiger tiger;
 9     
10     @Autowired(required=false)
11     private Monkey monkey;
12     
13     public String toString(){
14         return tiger   "n"   monkey;
15     }
16     
17 }

那时候,找不到tiger、monkey多个特性,Spring容器不再抛出卓殊而是感觉那四个属性为null。

二、Qualifier(钦定注入Bean的名称)

即使容器中有一个以上相配的Bean,则足以通过@Qualifier注解限定Bean的称呼,看上面包车型客车例证:

概念一个Car接口:

1 package com.spring.service;
2 
3 public interface ICar {
4     
5     public String getCarName();
6 }

多个落实类BMWCar和奔驰Car:

 1 package com.spring.service.impl;
 2 
 3 import com.spring.service.ICar;
 4 
 5 public class BMWCar implements ICar{
 6     
 7     public String getCarName(){
 8         return "BMW car";
 9     }
10 }

 1 package com.spring.service.impl;
 2 
 3 import com.spring.service.ICar;
 4 
 5 public class BenzCar implements ICar{
 6     
 7     public String getCarName(){
 8         return "Benz car";
 9     }
10 }

再写一个CarFactory,引用car(这里先不用@Qualifier注脚):

 1 package com.spring.model;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 
 5 import com.spring.service.ICar;
 6 
 7 public class CarFactory {
 8     
 9     @Autowired
10     private ICar car;
11     
12     public String toString(){
13         return car.getCarName();
14     }
15     
16 }

安顿文件:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans
 3     xmlns="http://www.springframework.org/schema/beans"
 4     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5     xmlns:p="http://www.springframework.org/schema/p"
 6     xmlns:context="http://www.springframework.org/schema/context"
 7     xsi:schemaLocation="http://www.springframework.org/schema/beans
 8     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 9     http://www.springframework.org/schema/context
10     http://www.springframework.org/schema/context/spring-context-3.0.xsd
11     ">
12     
13     <context:component-scan base-package="com.spring" />
14     
15     <!-- Autowired注解配合Qualifier注解 -->
16     <bean id="carFactory" class="com.spring.model.CarFactory" />
17     <bean id="bmwCar" class="com.spring.service.impl.BMWCar" />
18     <bean id="benz" class="com.spring.service.impl.BenzCar" />
19     
20 </beans>

测试方法:

 1 /**
 2  * Autowired注解配合Qualifier注解
 3  */
 4 @Test
 5 public void test1(){
 6     //读取配置文件
 7     ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext2.xml");
 8     CarFactory carFactory=(CarFactory) ctx.getBean("carFactory");
 9     System.out.println(carFactory.toString());
10 }

 

运行一下,不用说,一定是报错的,Car接口有七个落实类,Spring并不知道应当引用哪个完结类。

葡京网上开户 4葡京网上开户 5

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'carFactory': Injection of autowired dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: 
Could not autowire field: private com.spring.service.ICar com.spring.model.CarFactory.car; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException:
No unique bean of type [com.spring.service.ICar] is defined: expected single matching bean but found 2: [bmwCar, benz]
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:285)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1074)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:517)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:456)
    at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:291)
    at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:222)
    at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:288)
    at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:190)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:580)
    at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:895)
    at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:425)
    at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:139)
    at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:83)
    at com.spring.test.TestAnnotation.test1(TestAnnotation.java:25)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
    at java.lang.reflect.Method.invoke(Method.java:597)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:45)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:42)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:263)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:68)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:47)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:231)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:60)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:229)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:50)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:222)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:300)
    at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:45)
    at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:460)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:673)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:386)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:196)
Caused by: org.springframework.beans.factory.BeanCreationException: Could not autowire field: private com.spring.service.ICar com.spring.model.CarFactory.car; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No unique bean of type [com.spring.service.ICar] is defined: expected single matching bean but found 2: [bmwCar, benz]
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:502)
    at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:84)
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:282)
    ... 36 more
Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No unique bean of type [com.spring.service.ICar] is defined: expected single matching bean but found 2: [bmwCar, benz]
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:796)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:703)
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:474)
    ... 38 more

View Code

出现这种情状习感到常有两种化解办法:
(1)、在安排文件中除去个中一个落到实处类,Spring会自动去base-package下搜寻Car接口的完成类,开掘Car接口唯有3个达成类,便会一向引用那个完毕类。
(2)、完毕类正是有八个该怎么做?此时能够动用@Qualifier申明来钦定Bean的称谓:

 1 package com.spring.model;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.beans.factory.annotation.Qualifier;
 5 
 6 import com.spring.service.ICar;
 7 
 8 public class CarFactory {
 9     
10     @Autowired
11     @Qualifier("bmwCar")
12     private ICar car;
13     
14     public String toString(){
15         return car.getCarName();
16     }
17     
18 }

此处会注入名称叫"bmwCar"的Bean。

3、Resource

@Resource评释与@Autowired注明功用特别相似,这么些就回顾说了,看例子:

 1 package com.spring.model;
 2 
 3 import javax.annotation.Resource;
 4 
 5 public class Zoo1 {
 6     
 7     @Resource(name="tiger")
 8     private Tiger tiger;
 9     
10     @Resource(type=Monkey.class)
11     private Monkey monkey;
12     
13     public String toString(){
14         return tiger   "n"   monkey;
15     }
16 }

这是事无巨细一些的用法,说一下@Resource的装配顺序:
(1)、@Resource后边未有别的内容,私下认可通过name属性去相称bean,找不到再按type去相配
(二)、内定了name也许type则依据钦命的体系去相称bean
(三)、钦赐了name和type则依照内定的name和type去相称bean,任何一个不匹配都将报错

然后,区分一下@Autowired和@Resource多个评释的区分:
(一)、@Autowired私下认可遵照byType方式进行bean相配,@Resource私下认可依照byName情势开始展览bean相配
(二)、@Autowired是Spring的笺注,@Resource是J二EE的注释,这一个看一下导入申明的时候那多个声明的包名就清清楚楚了
Spring属于第二方的,J二EE是Java本人的东西,因而,提出采取@Resource注明,以压缩代码和Spring之间的耦合。

4、Service

地方那些事例,还能够继续简化,因为spring的布局文件之中还大概有壹5行~①柒行多个bean,下一步的简化是把那多少个bean也给去掉,使得spring配置文件之中唯有3个机动扫描的竹签,加强Java代码的内聚性并进一步回落配置文件。

要连续简化,能够动用@Service。先看一下布局文件,当然是百分百剔除了:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans
 3     xmlns="http://www.springframework.org/schema/beans"
 4     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5     xmlns:p="http://www.springframework.org/schema/p"
 6     xmlns:context="http://www.springframework.org/schema/context"
 7     xsi:schemaLocation="http://www.springframework.org/schema/beans
 8     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 9     http://www.springframework.org/schema/context
10     http://www.springframework.org/schema/context/spring-context-3.0.xsd
11     ">
12     
13     <context:component-scan base-package="com.spring" />
14     
15 </beans>

是否深感很爽?起码笔者觉着是的。OK,上面以Zoo.java为例,其他的Monkey.java和Tiger.java都一点差距也未有:

 1 package com.spring.model;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.stereotype.Service;
 5 
 6 @Service
 7 public class Zoo {
 8     
 9     @Autowired
10     private Tiger tiger;
11     
12     @Autowired
13     private Monkey monkey;
14     
15     public String toString(){
16         return tiger   "n"   monkey;
17     }
18     
19 }

诸如此类,Zoo.java在Spring容器中设有的款式正是"zoo",即能够透过ApplicationContext的getBean("zoo")方法来获得Zoo.java。@Service表明,其实做了两件业务:
(一)、表明Zoo.java是一个bean,那点很首要,因为Zoo.java是贰个bean,别的的类才得以应用@Autowired将Zoo作为3个成员变量自动注入。
(2)、Zoo.java在bean中的id是"zoo",即类名且首字母小写。

假诺,笔者不想用这种情势如何是好,就想让Zoo.java在Spring容器中的名字叫做"Zoo",能够的:

 1 package com.spring.model;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.context.annotation.Scope;
 5 import org.springframework.stereotype.Service;
 6 
 7 @Service("Zoo")
 8 @Scope("prototype")
 9 public class Zoo {
10     
11     @Autowired
12     private Tiger tiger;
13     
14     @Autowired
15     private Monkey monkey;
16     
17     public String toString(){
18         return tiger   "n"   monkey;
19     }
20     
21 }

这么,就能够透过ApplicationContext的getBean("Zoo")方法来收获Zoo.java了。

此处本人还多加了三个@Scope表明,应该很好明白。因为Spring暗许发生的bean是单例的,就算本身不想行使单例咋做,xml文件之中能够在bean里面配备scope属性。表明也是均等,配置@Scope就能够,暗许是"singleton"即单例,"prototype"表示原型即每趟都会new一个新的出来。

————————————————————————————————————————————————————————————————————

一、任何叁个Spring框架营造的单独的Java应用,平常会设有1行就像于sc.getBean()的代码,实际上那些做的正是DL的办事,Spring Ioc所做的事务

起步注脚

Spring 暗中认可是不启用申明的。若是想采取申明,要求先在xml中运维表明。
起首方式:在xml中进入八个标签,很简短吗。

<context:annotation-config/>

注:<context:annotation-config/> 只会寻觅定义它的上下文。什么意思吧?正是说,如若您
为DispatcherServlet钦点了一个WebApplicationContext,那么它只在controller中搜索@Autowired表明,而不会检查别的的渠道。

注意:在Action证明的“userService”变量的花色必须是“UserServiceImpl”可能是其父类“UserService”,不然由于品种不等同而无法注入,由于Action中的证明的“userService”变量使用了@Resource注明去标明,并且指明了其name

"userService",那就十分告诉Spring,说自家Action要实例化3个“userService”,你Spring快点帮笔者实例化好,然后给自家,当Spring看到user瑟维斯变量上的@Resource的注释时,依据其指明的name属性能够驾驭,Action中供给利用三个UserServiceImpl的实例,此时Spring就能够把温馨创办好的名字称为"userService"的User瑟维斯Impl的实例注入给Action中的“userService”变量,辅助Action完毕user瑟维斯的实例化,那样在Action中就毫无经过“UserServiceuserService = new User瑟维斯Impl();”这种最原始的法子去实例化userService了。

比如未有Spring,那么当Action必要运用UserServiceImpl时,必须通过“UserServiceuserService = new UserServiceImpl();”主动去创设实例对象,但使用了Spring之后,Action要采用UserServiceImpl时,就不要主动去创设UserServiceImpl的实例了,创立UserServiceImpl实例已经交付Spring来做了,Spring把创设好的UserServiceImpl实例给Action,Action获得就能够直接用了。

Action由原来的积极性成立UserServiceImpl实例后就可以马上使用,形成了被动等待由Spring创立好UserServiceImpl实例之后再流入给Action,Action技艺够使用。

那表明Action对“UserServiceImpl”类的“调整权”已经被“反转”了,原本主动权在投机手上,本身要使用“UserServiceImpl”类的实例,本人主动去new3个出去马上就能够运用了,但未来和好不可能主动去new“UserServiceImpl”类的实例,new“UserServiceImpl”类的实例的权限已经被Spring拿走了,唯有Spring才具够new“UserServiceImpl”类的实例,而Action只可以等Spring创建好“UserServiceImpl”类的实例后,再“央浼”Spring把创造好的“UserServiceImpl”类的实例给她,那样她能力够选取“UserServiceImpl”,这正是Spring核情感想“调整反转”,也叫“重视注入”,“依赖注入”也很好通晓,Action须求接纳UserServiceImpl干活,那么就是对UserServiceImpl发生了依赖,Spring把Acion需求依据的User瑟维斯Impl注入(也便是“给”)给Action,那就是所谓的“重视注入”。对Action来说,Action注重什么东西,就请求Spring注入给他,对Spring来讲,Action要求怎样,Spring就主动注入给他。

4、@ Repository

@Repository对应数据访问层Bean ,举例:

@Repository(value="userDao")
public class UserDaoImpl extends BaseDaoImpl<User> {
………
}

@Repository(value="userDao")申明是报告Spring,让Spring创造贰个名字叫“userDao”的UserDaoImpl实例。

当Service须求接纳Spring创设的名字叫“userDao”的UserDaoImpl实例时,就足以选取@Resource(name = "userDao")注脚告诉Spring,Spring把创制好的userDao注入给Service就可以。

// 注入userDao,从数据库中根据用户Id取出指定用户时需要用到
@Resource(name = "userDao")
private BaseDao<User> userDao;

@Resource、@AutoWired、@Qualifier 都用于注入对象。个中@Resource可以以 name 或 type 格局注入,@AutoWired只可以以 type 格局注入,@Qualifier 只好以 name 方式注入。

但它们有1部分微薄差异:

壹、@Resource、@Qualifier暗中认可按 byName自动注入,@Autowired暗中同意按byType自动注入。

二、@Resource有两特个性是相比较首要的,分是name和type。即使选用name属性,则采纳byName的全自动注入计谋。而选用type属性时则运用byType自动注入战术。

叁、@Resources是JDK提供的注明,而@Autowired是Spring提供的笺注。

能够把 @Resource 当成 @AutoWired @Qualifier 的相当吧,哈哈。你们有的,小编都有,你们尚未的,小编也有~

@Resource、@AutoWired、@Qualifier 都用来注入对象。当中@Resource能够以 name 或 type 方式注入,@AutoWired只可以以 type 格局注入,@Qualifier 只好以 name 情势注入。

但它们有点轻微差别:

一、@Resource、@Qualifier私下认可按 byName自动注入,@Autowired暗中同意按byType自动注入。

二、@Resource有三个属性是比较重大的,分是name和type。要是应用name属性,则利用byName的机动注入计策。而选拔type属性时则选择byType自动注入攻略。

三、@Resources是JDK提供的注脚,而@Autowired是Spring提供的注解。

能够把 @Resource 当成 @AutoWired @Qualifier 的十分吧,哈哈。你们有的,作者都有,你们尚未的,作者也是有~

以上那篇Spring常用注解使用申明来协会IoC容器的方式便是小编分享给大家的全部内容了,希望能给我们二个仿照效法,也可望我们多多协理帮客之家。

使用表明来协会IoC容器的章程,springioc 使用表明来布局IoC容器 用申明来向Spring容器注册Bean。要求在applicationContext.xml中注册...

贰、使用注明来布局IoC容器

用表明来向Spring容器注册Bean。须要在applicationContext.xml中登记<context:component-scan base-package=”pagkage一[,pagkage2,…,pagkageN]”/>

如:在base-package指澳优(Ausnutria Hyproca)个包

1 <context:component-scan base-package="cn.gacl.java"/>

表明cn.gacl.java包及其子包中,若是有些类的头上带有一定的申明【@Component/@Repository/@Service/@Controller】,就能将以此指标作为Bean注册进Spring容器。也得以在<context:component-scan base-package=” ”/>中钦点五个包,如:

1 <context:component-scan base-package="cn.gacl.dao.impl,cn.gacl.service.impl,cn.gacl.action"/>

三个包逗号隔离。

1、搜集和注册

在本阶段,我们能够利用XML或Java代码的方法定义一些bean,然后经过吸取组装只怕让容器基于某个机制自动扫描的款型将那个bean定义搜聚到IoC容器中。

1)以XML格式配置

<bean id="car" class="com.slp.Car"></bean>

二)以XML Schema格局安插实行批量扫描收罗和挂号

1 <context:component-scan base-package="com.slp">

Spring注解

本文由澳门新葡亰发布于计算机知识,转载请注明出处:IoC中逐条注明的知情和接纳,Spring常用评释

关键词: spring 程序员 java-framewo

最火资讯