菜单

spring框架

2018年11月16日 - Java

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