spring框架---IOC容器

IOC
声明一个bean
首先设置一个接口Performance表示表演者。

package com.moonlit.myspring;
//表演
public interface Perform {
    //方法
    public void perform();

}

  **创建一个Juggler（杂技师）的类继承Performer表示表演者是杂技师**
        package com.moonlit.myspring;
    //杂技
    public class Juggler implements Perform {
        private int bags=3;//小球的个数
    
        public Juggler(int bags){
            this.bags=bags;
        }
        
        public Juggler(){}
        
        @Override
        public void perform() {
            System.out.println("表演抛"+bags+"小球");
    
        }
    }

在spring-idaol.xml配置文件中定义了一个名为duke的bean，他对应Juggler类

<?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 class FirstBean { 
public static void main(String[] args)  { 
ApplicationContext context = new ClassPathXmlApplicationContext("spring-idol.xml"); 
Performer performer = (Performer) context.getBean("duke"); performer.perform(); 
}
 }

运行结果如下：

表演抛3个小球

理解：首先定义了一个接口Performer，然后写了一个类Juggler实现了Performer，Juggler里面有一个私有的成员变量bags，他的默认值是3，
然后Juggler实现了Performance的perform方法
方法输出带有bags的数量。
然后再测试的过程中，通过ApplicationContext 类型加载了spring-idol.xml的文件内容，而在xml中定义了名字为“duke”的bean，然后刚好就用到了。然后bean返回是一个Juggler，所以将：

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

改成

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

也是可以的，但是想看见效果可以通过ApplicationContext 返回是不是一个Juggler，因为通过输出结果就可以知道了，所以用（Performer）,输出的效果显示bean对应的Performer真的是一个Juggler，这就通过xml定义一个bean并通过applicationcontext获取得到这个bean的整个过程。

方便理解bean，我们可以把

 <bean id="duke" class="com.moonlit.myspring.Juggler" />

看成

Juggler duke=new Juggler();

每一次运行spring容器就会创建个Juggler名字为duke的对象。

构造器注入

这里通过一个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;



public class MoonlightPoem {
    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");
        MoonlightPoem moonlightPoet = (MoonlightPoem) 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="mooncake" class="com.moonlit.myspring.MoonlightPoem">
    <property name="age" value="25"></property>
    <property name="name" value="luhan"></property>
    <property name="poem" ref="songxiaofeng"></property>
    <property name="list">
    <list>
    <value>zhangsan</value>
    <value>lisi</value>
    </list>
    </property>

    <property name="map">
    <map>
    <entry key="1" value="1"></entry>
    <entry key="2" value="2"></entry>
    <entry key="3" value="3"></entry>
    </map>
    </property>
    </bean>

结果为

in list : luhan 25
in list : songxiaofeng
in map : key1 -- value1
in map : key2 -- value2
in map : key3 -- value3

自动装配bean属性

Spring提供了四种类型的自动装配策略：

byName – 把与Bean的属性具有相同名字(或者ID)的其他Bean自动装配到Bean的对应属性中。

byType – 把与Bean的属性具有相同类型的其他Bean自动装配到Bean的对应属性中。

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

autodetect – 首先使用costructor进行自动装配。如果失败，再尝试使用byType进行自动装配。

spring框架---IOC容器

构造器注入

猜你喜欢