spring框架

spring知识的加固整治
AOP和ioc概念,以及询问及了怎么而采取spring框架的目的,作用:变换资源得到的大方向。更像是依需所请。
布置bean的艺术:利用XML的艺术,基于注解的不二法门简单种。
1通过全类名反射的方法,2经过工厂实例的法子,3
通过还底层的Beanfactory的办法
凭借注入DI的主意来三三两两种: 属性注入:property 和构造器注入:
constructor-args。
流入的细节:字面值等得以经VALUE的价签来注入,特殊字符的![CDATA[]]的道。通过ref得办法来指定对另Bean的援
也可以${xxx}来引用。
级联属性:即cars.price修改其价值。
集合属性:list和map list用ref组子标签,map用entry来部署其性。
管集合bean都拿出来分离又一个独门的区域?新的命名空间util 如util:list
id=“cars“其他的便是ref其他的car了
还有通过p命名空间来还利于之定义其属性值,还有autowired byname bytype。
bean之间的延续关系:parent=”“
bean的作用域:scope设置为单例和原型。
SpEL语言更加动态的来赋值。
静态工厂方法与实例工厂方法来配置bean的实例,和factorybean配置方式之间的涉嫌
未做明白。
应用外部属性文件:context:properties 未打明白。记。

IOC

扬言一个简易的bean

首先单例子:
率先设置一个接口Perofrmance表示参赛者。

package com.moonlit.myspring;
public interface Performer {    
      void perform() throws PerformanceException;
}

创建一个Juggler(杂技师)类继承Performer表示参赛者是杂技师。

package com.moonlit.myspring;
public class Juggler implements Performer {    
private int beanBags = 3;    
public Juggler() {
    }    
    public Juggler(int beanBags) {        
    this.beanBags = beanBags;
    }    
    public void perform() throws PerformanceException {
        System.out.println("JUGGLING " + beanBags + " BEANBAGS");
    }
}

每当spring-idol.xml配置文件中定义一个名叫吧duke的bean,他本着应Juggler类(把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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">    
  <bean id="duke" class="com.moonlit.myspring.Juggler" />    
</beans>

测试代码:

package com.moonlit.practice;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.moonlit.myspring.PerformanceException;
import com.moonlit.myspring.Performer;
public class FirstBean {    
public static void main(String[] args) throws PerformanceException {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-idol.xml");
        Performer performer = (Performer) context.getBean("duke");
        performer.perform();
    }
}

运转结果如下:

JUGGLING 3 BEANBAGS

接头:首先定义了一个接口Performer,然后形容了一个类Juggler继承自Peformer,Juggler有一个民用成员变量beanBags,他的默认值是3,然后Juggler实现了Performer的perform方法,方法的出口带有beanBags的数据。
下一场在测试的次序中,通过ApplicationContext类型对象加载了spring-idol.xml文件之始末,而以xml文件中定义了名吧”duke”的bean,然后刚好就是用到了。
然后bean返回的是一个Juggler,所以将

Performer performer = (Performer) context.getBean("duke");

改成

Juggler performer = (Juggler) context.getBean("duke");

呢是足以的,但是以这边想看的效果是经application
context返回的是休是一个Juggler,因为经过输出的结果虽可以知晓了,所以这边用(Performer),对面临输出的法力亮bean对应之Performer真的是一个Juggler,这即是透过xml定义一个bean并由此application
context获得是bean对象的整过程。

构造器注入

事先讲到的称为吧”duke”的bean有一个个体成员变量beanBags代表这个杂技师bean的一次性能够抛弃来之不过多之数码,Juggler有一个构造函数,构造函数的首先单参数(这里只出一个参数)beanBags是一个整型的价,用于传递给Juggler的民用成员变量beanBags。
构造器注入的方是:在bean中上加一个constructor-arg(如果构造函数的参数有点儿独,那即便加加点儿个constructor-arg)。
在spring-idol.xml中修改bean “duke”如下:

<bean id="duke" class="com.moonlit.myspring.Juggler" >
    <constructor-arg name="beanBags" value="15" />  
  </bean>

重新运行FirstBean程序,输出如下:

JUGGLING 15 BEANBAGS

好看看通过构造器诸如已经将duke的beanBags改以15。
构造函数中之参数可能无是一个基础项目的变量,而恐怕是一个变量,这个时要将constructor-arg的value改成ref即可,ref对应的价需要被声称如一个bean元素。
动一个晤歌唱的杂技师PoeticJuggler类来演示,PoeticJuggler继承自Juggler,它具有一个Poem类型的私房成员变量poem,代表他要读的诗词。
Poem类:

package com.moonlit.myspring;
public interface Poem 
{    
  void recite();
}

概念一首名吧Sonnet29的近乎用于表示称也同样篇sonnet29底诗篇:http://shakespeare-online.com/sonnets/29.html
Sonnet29实现了Poem接口。

package com.moonlit.myspring;
public class Sonnet29 implements Poem {    
private static String[] LINES = {
            "When, in disgrace with fortune and men's eyes,",
            "I all alone beweep my outcast state,",
            "And trouble deaf heaven with my bootless cries,",
            "And look upon myself, and curse my fate,",
            "Wishing me like to one more rich in hope,",
            "Featur'd like him, like him with friends possess'd,",
            "Desiring this man's art and that man's scope,",
            "With what I most enjoy contented least;",
            "Yet in these thoughts myself almost despising,",
            "Haply I think on thee, and then my state,",
            "Like to the lark at break of day arising",
            "From sullen earth, sings hymns at heaven's gate;",
            "For thy sweet love remember'd such wealth brings",
            "That then I scorn to change my state with kings.",
    };    

    public Sonnet29() {
    }   

     public void recite() {        
     for (String line : LINES) 
            System.out.println(line);
    }
}

发生矣Poem和他的一个实现类Sonnet29事后,开始来形容PoeticJuggler,他累自Juggler并且发生一个Poem类型私有成员变量poem。

package com.moonlit.myspring;
public class PoeticJuggler extends Juggler {    
private Poem poem;    
public PoeticJuggler(Poem poem) {        
super();        
this.poem = poem;
    }    
    public PoeticJuggler(int beanBags, Poem poem) {        
    super(beanBags);        
    this.poem = poem;
    }    
    public void perform() throws PerformanceException {        
    super.perform();
        System.out.println("While reciting...");
        poem.recite();
    }
}

并且,需要在xml文件被声称Sonnet29暨PoeticJuggler类对应之bean。

<bean id="sonnet29" class="com.moonlit.myspring.Sonnet29" />
  <bean id="poeticDuke" class="com.moonlit.myspring.PoeticJuggler">
    <constructor-arg value="16" />
    <constructor-arg ref="sonnet29" />    
  </bean>

可观看,”poeticDuke”使用了少单constructor-arg来声称参数,第一只参数使用value,第二只参数使用ref,Sonnet29路的bean–“connet29″。
采用测试程序查看效果:

package com.moonlit.practice;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.moonlit.myspring.PerformanceException;
import com.moonlit.myspring.Performer;

public class FirstBean {
    public static void main(String[] args) throws PerformanceException {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                "spring-idol.xml");
        Performer performer = (Performer) context.getBean("duke");
        performer.perform();
    }
}

次第输出如下:

JUGGLING 16 BEANBAGS
While reciting...
When, in disgrace with fortune and men's eyes,
I all alone beweep my outcast state,
And trouble deaf heaven with my bootless cries,
And look upon myself, and curse my fate,
Wishing me like to one more rich in hope,
Featur'd like him, like him with friends possess'd,
Desiring this man's art and that man's scope,
With what I most enjoy contented least;
Yet in these thoughts myself almost despising,
Haply I think on thee, and then my state,
Like to the lark at break of day arising
From sullen earth, sings hymns at heaven's gate;
For thy sweet love remember'd such wealth brings
That then I scorn to change my state with kings.

接头:可以通过构造器注入来模拟构造函数传入的参数,通过constructor-arg
value=”XX”传递一个为主型的参数XX,通过constructor-arg
ref=”XX”传递一个bean。

流入各种bean属性

此处透过一个MoonlightPoet类来演示了注入Bean属性property的功效。

package com.moonlit.myspring;

import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Properties;

public class MoonlightPoet {
    private String name;
    private int age;
    private Poem poem;
    private List<String> list;
    private Map<String, String> map;

    public void perform() {
        System.out.println("name : " + name);
        System.out.println("age : " + age);
        poem.recite();
        for (String val : list) 
            System.out.println("in list : " + val);
        for (Entry<String, String> entry : map.entrySet())
            System.out.println("in map : " + entry.getKey() + " -- " + entry.getValue());
    }
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                "spring-idol.xml");
        MoonlightPoet moonlightPoet = (MoonlightPoet) context.getBean("moonlightPoet");
        moonlightPoet.perform();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Poem getPoem() {
        return poem;
    }
    public void setPoem(Poem poem) {
        this.poem = poem;
    }
    public List<String> getList() {
        return list;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public Map<String, String> getMap() {
        return map;
    }
    public void setMap(Map<String, String> map) {
        this.map = map;
    }

}

该bean在xml文件中定义如下:

<bean id="moonlightPoet" class="com.moonlit.myspring.MoonlightPoet">
    <property name="name" value="moonlit" />
    <property name="age" value="22" />
    <property name="poem" ref="sonnet29" />
    <property name="list">
      <list>
        <value>hello</value>
        <value>world</value>
        <!-- if bean, use <ref bean="XX"> -->
      </list>
    </property>
    <property name="map">
      <map>
        <entry key="key1" value="value1" />
        <entry key="key2" value="value2" />
        <entry key="key3" value="value3" />
      </map>
    </property>
</bean>

输出结果:

name : moonlit
age : 22
When, in disgrace with fortune and men's eyes,
I all alone beweep my outcast state,
And trouble deaf heaven with my bootless cries,
And look upon myself, and curse my fate,
Wishing me like to one more rich in hope,
Featur'd like him, like him with friends possess'd,
Desiring this man's art and that man's scope,
With what I most enjoy contented least;
Yet in these thoughts myself almost despising,
Haply I think on thee, and then my state,
Like to the lark at break of day arising
From sullen earth, sings hymns at heaven's gate;
For thy sweet love remember'd such wealth brings
That then I scorn to change my state with kings.
in list : hello
in list : world
in map : key1 -- value1
in map : key2 -- value2
in map : key3 -- value3

理解:
流入简单值:
<property name=”XX” value=”YY” />
个中XX是变量名,YY是价值。
援其他Bean:
<property name=”XX” ref=”YY”>
其间XX是变量名,YY是援引的bean的id。

装配List:
<property name=”XX”>
<value>YY</value>
或者
<ref bean=”ZZ”>
</property>
里面XX是变量名,YY是价值,ZZ是引用的bean。
装配Map:
<map>
<entry key=”XX” value=”YY” />
或者
<entry key=”XX” value-ref=”YY” />
或者
<entry key-ref=”XX” value=”YY” />
或者
<entry key-ref=”XX” value-ref=”YY” />
</map>
盖map的key和value可以对应一个基础项目的价,也得以对应一个bean,所以key,value对应值,key-ref,value-ref对应bean。

采取Spring的命名空间p装配属性
可以在beans中添加

xmlns:p="http:www.springframework.org/schema/beans"

来使用p:作为<bean>元素所有属性的前缀来装配Bean的性质。用法如下:

<bean id="kenny" class="XX"
    p:song = "Jingle Bells"
    p:instrument-ref = "saxphone" />

-ref后缀作为一个标识来告诉Spring应该装配一个援而无是配面值。

活动装配bean属性

Spring提供了季栽档次的活动装配策略:

byName –
把同Bean的特性具有同等名字(或者ID)的别Bean自动装配到Bean的应和属性被。

byType –
把与Bean的性具有相同类别的外Bean自动装配到Bean的相应属性被。

constructor –
把与Bean的构造器入参具有相同档次的其他Bean自动装配到Bean的对应属性被。

autodetect –
首先采取costructor进行自动装配。如果失败,再尝试利用byType进行活动装配。
此间因为关羽和青龙偃月刀为条例: 首先定义一个械接口Weapon:

package com.moonlit.myspring;

public interface Weapon {    
    public void attack();
}

然后定义一个Weapon接口的贯彻Falchion类:

package com.moonlit.myspring;

public class Falchion implements Weapon {    
public void attack() {
        System.out.println("falcon is attacking!");
    }
}

概念一个敢接口Hero:

package com.moonlit.myspring;

public interface Hero {    
    public void perform();
}

然后定义一个Hero接口的实现Guanyu类(代表关羽):

package com.moonlit.myspring;

public class GuanYu implements Hero {    

    private Weapon weapon;    
    public void perform() {
        System.out.println("GuanYu pick up his weapon.");
        weapon.attack();
    }    
    public Weapon getWeapon() {        

        return weapon;
    }    

    public void setWeapon(Weapon weapon) {        

        this.weapon = weapon;
    }
}

以无干自动装配的情状下,想如果由此Spring的DI将Fachion类对象注入及Guanyu类的weapon属性中,可以新建一个xml文件(这里取名为spring-idol.xml)并以其中填写:
spring-idol.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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

  <bean id="falchion" class="com.moonlit.myspring.Falchion" />
  <bean id="guanyu" class="com.moonlit.myspring.GuanYu">
    <property name="weapon" ref="falchion" />
  </bean>
    </beans>

中最关键的情节就是少数只bean的宣示部分:

<bean id="falchion" class="com.moonlit.myspring.Falchion" />
  <bean id="guanyu" class="com.moonlit.myspring.GuanYu">
    <property name="weapon" ref="falchion" />
  </bean>

首先单bean标签定义了一个Falchion类型的bean,第二只bean标签中将第一独bean作为weapon的值装配到了weapon属性中。
然后可以形容一个测试程序来查阅效果:

package com.moonlit.practice;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.moonlit.myspring.Hero;

public class AutowirePractice {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-idol.xml");
        Hero guanyu = (Hero) context.getBean("guanyu");
        guanyu.perform();
    }
}

出口结果如下:

GuanYu pick up his weapon.
falcon is attacking!

及目前为止还尚无干到自动装配的始末,接下去开始讲述活动装配的情节。

byName自动装配

反spring-idol.xml中bean声明内容的花样如下:

  <bean id="weapon" class="com.moonlit.myspring.Falchion" />
  <bean id="guanyu" class="com.moonlit.myspring.GuanYu" autowire="byName" />

取平等的结果。

拿Falchion类的id去矣一个以及Guanyu类的性weapon一样的名字,并且在guanyu
bean中补充加了autowire=”byName”用于指明装配类型是byName自动装配。这个时刻guanyu
bean就是以上下文中摸索名也weapon的bean装配到他好的weapon属性中。

byType自动装配

变动spring-idol.xml中bean声明内容的样式如下:

  <bean id="falchion" class="com.moonlit.myspring.Falchion" />
  <bean id="guanyu" class="com.moonlit.myspring.GuanYu" autowire="byType" />

取平等的结果。

此处曾不用关注Falchion类对应之bean的id是呀了,因为既定义guanyu
bean的autowire属性为”byType”。这个时节guanyu
bean会在上下文中找寻与weapon具有同等类别的接近对应之bean。
盖Guanyu类的weapon实现Weapon借口,整个上下文中即只有一个Weapon接口的落实Falchion类,所以以”byType”类型就检测到了falchion
bean并将那个注入及了guanyu bean的weapon属性中。
然而也会见并发同样种植状况就算是检测的早晚或会见产出多独一样type的bean,这个时刻便未了解要配那个了。比如,在新建一个实现Weapon接口的方天画戟类HalBerd:

package com.moonlit.myspring;

public class Halberd implements Weapon {    

    public void attack() {
        System.out.println("halberd is attacking!!!");
    }
}

并且在xml文件被扬言一个初的halberd bean:

<bean id="halberd" class="com.moonlit.myspring.Halberd" />

在这种情景下就算会出错,因为起零星只bean满足byType的结果。

这上来半点栽解决办法:
率先种办法是拿里面一个bean的primary属性设为false,比如:将方天画戟falchion
bean的primary属性设为true,以防冠以用方天画戟(很好奇吕布死了然后,赤兔马由关羽了,方天画戟去哪里了):

  <bean id="falchion" class="com.moonlit.myspring.Falchion"  />
  <bean id="halberd" class="com.moonlit.myspring.Halberd" primary="true" />
  <bean id="guanyu" class="com.moonlit.myspring.GuanYu" autowire="byType" />

出口结果如下:

GuanYu pick up his weapon.
halberd is attacking!!!

由出口结果吃好观看,关羽没有用青龙偃月刀,而是采用方天画戟进行攻击了。

primary的默认属性是false。
次种办法是安中一个bean的autowire-candidate属性为false,比如:将方天画戟的autowire-candidate属性设为false:

  <bean id="falchion" class="com.moonlit.myspring.Falchion"  />
  <bean id="halberd" class="com.moonlit.myspring.Halberd" primary="true" autowire-candidate="false" />
  <bean id="guanyu" class="com.moonlit.myspring.GuanYu" autowire="byType" />

这上测试程序的出口如下:

GuanYu pick up his weapon.
falcon is attacking!

足见到这个时刻关羽又重拾了青龙偃月刀。可以看出,当halberd
bean的autowire-candidate属性设为false时,他拿无见面作活动装配的竞选bean之一,这个时候虽然halberd的primary属性为true,但是halberd
bean没有涉足活动装配的竞选,所以自动装配到了falchion。

这种感觉就象是:“隔壁村李小花觊觎曾久,但是一个而改成海贼王的先生,于是驳回了它们……最终她出嫁为了隔壁老王,过上了福之活着”。

采取注解装配bean

使用@Autowired注解

由Spring2.5开端,最有意思之同种植装配Spring
Bean的方法是用注解自动装配Bean的习性。
Spring默认禁用注解装配,最简单易行的启用方式是下Spring的context命名空间布置中之<context:annotation-config>元素,如下所示:

<?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-3.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.0.xsd">

  <context:annotation-config />

  <!-- bean declarations here -->
    </beans>

承上一致节省的例证,在xml文件中定义两只bean:falchion bean和guanyu
bean,为了实现@Autowired自动装配,在GuanYu类似中之setWeapon()方法前补加了@Autowired注解,如下:
GuanYu.java:

package com.moonlit.myspring;
import org.springframework.beans.factory.annotation.Autowired;
public class GuanYu implements Hero {    

    private Weapon weapon;    
    public void perform() {
        System.out.println("Guan Yu pick up his weapon.");
        weapon.attack();
    }    
    public Weapon getWeapon() {        

        return weapon;
    }
    @Autowired    
    public void setWeapon(Weapon weapon) {        

        this.weapon = weapon;
    }
}

透过根据注解的方式,可以免用当xml文件中也guanyu
bean添加autowire属性了。
spring-idol内部的代码:

<context:annotation-config />

  <bean id="falchion" class="com.moonlit.myspring.Falchion"  />
  <bean id="guanyu" class="com.moonlit.myspring.GuanYu" />

不仅可以动用@Autowired注解标注setter方法,还可标注得活动装配bean引用的管一计,比如,给GuanYu类的setWeapon方法改名为pickupWeapon,如下:

package com.moonlit.myspring;
import org.springframework.beans.factory.annotation.Autowired;

public class GuanYu implements Hero {    

    private Weapon weapon;    
    public void perform() {
        System.out.println("Guan Yu pick up his weapon.");
        weapon.attack();
    }    
    public Weapon getWeapon() {        

        return weapon;
    }
    @Autowired    
    public void pickupWeapon(Weapon weapon) {        

        this.weapon = weapon;
    }
}

再也运行测试程序AutowirePractice,输出的结果是如出一辙的,因为尽管没有了setWeapon方法,但是透过@Autowired注解通过pickupWeapon方法将falchion
bean传递给了guanyu bean。
@Autowired注解甚至足以标注构造器,这样的话甚至并set方法还可以不写了:

package com.moonlit.myspring;
import org.springframework.beans.factory.annotation.Autowired;
public class GuanYu implements Hero {
    @Autowired    
    private Weapon weapon;    
    public void perform() {
        System.out.println("Guan Yu pick up his weapon.");
        weapon.attack();
    }
}

@Autowired注解存在个别栽限制:
1.尚无匹配Bean
2.匹配多独Bean

而是还产生解决办法。
但是挑选的自发性装配
默认情况下,@Autowired属性具有强契约特征,其所标明的性能或参数必须是不过配的。如果无Bean可以配到@Autowired所标注的性质或参数中,自动装配就会见砸(抛出令人讨厌的NoSuchBeanDefinitionException)。
性能不自然不要是配,null值也是得领之。在这种现象下,可以透过安装@Autowired的required属性为false来布局活动装配式可选的。例如:

@Autowired(required=false)
private Weapon weapon;

范围歧义性的依赖
发出或在多只bean满足装配条件,比如,这里,falchion bean和halberd
bean都满足装配到guanyu
bean的weapon属性中之基准。此时使只是用@Autowired注解的话语就是见面发生问题,才@Autowired注解下上加@Qualifier注解如下:

    @Autowired
    @Qualifier("falchion")    
    private Weapon weapon;

就会将falchion bean装入到weapon中。
如若齐所示,@Qualifier注解将尝试注入ID为falchion的Bean。
除开通过Bean的ID来限制,也得让Bean添加一个qualifier属性,通过之qualifier属性来博取限定,如:
给halberd bean添加一个qualifier,值吗”weaponOfGuanYu”:

<bean id="halberd" class="com.moonlit.myspring.Halberd">
    <qualifier value="weaponOfGuanYu" />
  </bean>

接下来对GuanYu类weapon类的注释如下:

    @Autowired
    @Qualifier("weaponOfGuanYu")    
    private Weapon weapon;

输出如下:

Guan Yu pick up his weapon.
halberd is attacking!!!

可以看,@qualifier降低了@Autowired的相当范围,最终筛选获得了halberd
bean装入weapon属性。
此地的<qualifier>元素限定了方天画戟(halberd)Bean是关羽使用的器械(weaponOgGuanYu)。除了可以于XML中指定qualifier,还得动用Qualifier类来标注Halberd类:

package com.moonlit.myspring;

import org.springframework.beans.factory.annotation.Qualifier;

@Qualifier("weaponOfGuanYu")
public class Halberd implements Weapon {    
public void attack() {
        System.out.println("halberd is attacking!!!");
    }
}

程序运行将沾平等之结果。
即便<context:annotation-config>有助于完全铲除Spring配置文件中之要素,但是还是勿可知一心排除,仍然要运用<bean>元素显示定义Bean。因此<context:component-scan>元素出现了,它除了完成<context:annotation-config>一样的做事,还同意Spring自动检测Bean和定义Bean。这即表示非采用<bean>元素,Spring应用被的大部(或者持有)Bean都能自行实现定义及配。

自动检测

以安排Spring自动检测,需要以<context:component-scan>元素来顶替<context:annotation-config>元素:

<?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.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.moonlit.myspring">
    </context:component-scan>

</beans>

<context:component-scan>元素会扫描指定的管以及拥有子包,并物色出会自行注册也Spring
Bean的类似。base-package属性标示了<context:component-scan>元素所扫描的保险。

否自动检测标注Bean

默认情况下,<context:component-scan>查找使用构造型(stereotype)注解所标明的类似,这些特殊的注释如下:

类型 说明
@component 通用的构造型注解,标示该类为Spring 组件。
@Controller 标识将该类定义为Spring MVC controller。
@Repository 标识将该类定义也数仓库(例如:Dao层)。
@Service 标识将该类定义也劳动(例如:Service层)。

 @component("guanyu")

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图