Spring框架---IOC装配Bean

IOC装配Bean

(1)Spring框架Bean实例化的方式提供了三种方式实例化Bean
    构造方法实例化(默认无参数,用的最多)
    静态工厂实例化
    实例工厂实例化

下面先写这三种方法的applicationContext.xml配置文件:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:p="http://www.springframework.org/schema/p"
 5     xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
 6         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 7         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 8
 9     <!-- Bean的三种实例化方式================================================================================ -->
10       <!-- 2.1  使用无参的构造器 -->
11      <bean id="bean1" class="com.study.spring.b_instance.Bean1"></bean>
12       <!-- 2.2使用静态工厂方法  factory-method 是工厂提供的静态方法 -->
13      <bean id="bean2" class="com.study.spring.b_instance.Bean2" factory-method="createInstance"></bean>
14      <!-- 2.3配置实例化工厂的方法 -->
15      <bean id="bean3Factory" class="com.study.spring.b_instance.Bean3Factory"></bean>
16      <bean id="bean3" factory-bean="bean3Factory" factory-method="getInstance"></bean>
17     <!-- end.Bean的三种实例化方式================================================================================ -->    
Bean1类
public class Bean1 {

    //必须提供无参的构造函数  系统有默认无参的构造函数
}
Bean2类
public class Bean2 {
    private static Bean2 Bean2 = new Bean2();

    private Bean2() {
    }

    public static Bean2 createInstance() {
        return Bean2;
    }
}

 Bean3类

public class Bean3 {

}

Bean3Factory类

 1 public class Bean3Factory {
 2
 3     private Bean3Factory(){
 4
 5     }
 6
 7     public Bean3 getInstance(){
 8         return new Bean3();
 9     }
10 }

测试类InstanceDemo

 1 import org.junit.Test;
 2 import org.springframework.context.ApplicationContext;
 3 import org.springframework.context.support.ClassPathXmlApplicationContext;
 4
 5 public class InstanceDemo {
 6
 7     //实例化工厂方法
 8     @Test
 9     public void demo3(){
10        //加载配置文件 创建工厂
11         ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
12
13         Bean3 bean3 =(Bean3) applicationContext.getBean("bean3");
14         System.out.println(bean3);
15
16     }
17
18     //静态工厂方法
19     @Test
20     public void demo2(){
21        //加载配置文件 创建工厂
22         ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
23
24         Bean2 bean2 =(Bean2) applicationContext.getBean("bean2");
25         System.out.println(bean2);
26
27     }
28     //构造方法得到bean对象
29     @Test
30     public void demo1(){
31        //加载配置文件 创建工厂
32         ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
33
34         Bean1 bean1 =(Bean1) applicationContext.getBean("bean1");
35         System.out.println(bean1);
36
37     }
38 }
39 /*
40  * 这三个都得到类似于[email protected] 的内存地址
41  */

(2).Bean的其他配置:

一般情况下,装配一个Bean时,通过指定一个id属性作为Bean的名称

id 属性在IoC容器中必须是唯一的

id 的命名要满足XML对ID属性命名规范 必须以字母开始,可以使用字母、数字、连字符、下划线、句话、冒号

如果Bean的名称中含有特殊字符,就需要使用name属性 例如: <bean name="#person" class="cn.itcast.bean.Person"/>

因为name属性可以相同,所以后出现Bean会覆盖之前出现的同名的Bean

   id和name的区别:

id遵守XML约束的id的约束.id约束保证这个属性的值是唯一的,而且必须以字母开始,可以使用字母、数字、连字符、下划线、句话、冒号

name没有这些要求

如果bean标签上没有配置id,那么name可以作为id.

Bean的scope属性

  <!-- 3.Bean的scope属性===================================================================== -->
     <bean id="product" class="com.study.spring.c_scope.Product" scope="singleton"></bean>
  <!-- end.Bean的scope属性===================================================================== -->    

     * singleton :单例的.(默认的值.)

    * prototype :多例的.

     * request :web开发中.创建了一个对象,将这个对象存入request范围,request.setAttribute();

   * session :web开发中.创建了一个对象,将这个对象存入session范围,session.setAttribute();

   * globalSession :一般用于Porlet应用环境.指的是分布式开发.不是porlet环境,globalSession等同于session;

3.Bean属性的依赖注入

前面已经知道如何获得对象,那我们接下来要知道如果给对象对象的属性赋值。

下面通过举例说明:

public class Car {

    private String name;

    private double price;

    public Car(String name, double price) {
        super();
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car [name=" + name + ", price=" + price + "]";
    }
}

Car 类

public class Car2 {
    private String name;

    private double price;

    public void setName(String name) {
        this.name = name;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car2 [name=" + name + ", price=" + price + "]";
    }

}

Car2类

public class CarInfo {

    public String getName(){
        return "哈弗H6";
    }

    public double caculatePrice(){
        return 110000;
    }
}

CarInfo类

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class CollectionBean {
    private String name;

    private Integer age;

    private List<String> hobbies;

    private Set<Integer> numbers;

    private Map<String, String> map;

    private Properties properties;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public Set<Integer> getNumbers() {
        return numbers;
    }

    public void setNumbers(Set<Integer> numbers) {
        this.numbers = numbers;
    }

    public Map<String, String> getMap() {
        return map;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public String toString() {
        return "CollectionBean [name=" + name + ", age=" + age + ", hobbies=" + hobbies + ", numbers=" + numbers
                + ", map=" + map + ", properties=" + properties + "]";
    }

}

CollectionBean类

public class Employee {

    private String name;

    private Car2 car2;

    public void setName(String name) {
        this.name = name;
    }

    public void setCar2(Car2 car2) {
        this.car2 = car2;
    }

    @Override
    public String toString() {
        return "Employee [name=" + name + ", car2=" + car2 + "]";
    }

}

Employee类

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

public class TestDi {

    @Test
    public void demo6() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        CollectionBean collectionBean = (CollectionBean) applicationContext.getBean("collectionBean");

        System.out.println(collectionBean);
    }

    @Test
    public void demo5() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        Car2 car2 = (Car2) applicationContext.getBean("car2_2");

        System.out.println(car2);
    }

    @Test
    public void demo4() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        Employee e = (Employee) applicationContext.getBean("employee2");

        System.out.println(e);
    }

    @Test
    public void demo3() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        Employee e = (Employee) applicationContext.getBean("employee");

        System.out.println(e);
    }

    @Test
    public void demo2() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        Car2 car2 = (Car2) applicationContext.getBean("car2");

        System.out.println(car2);
    }

    @Test
    public void demo1() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        Car car = (Car) applicationContext.getBean("car");

        System.out.println(car);
    }
}

TestDi测试类

上面这几个类都不是最主要的,我们主要是来看配置文件怎么写,这才是最关键的: 

applicationContext.xml
 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:p="http://www.springframework.org/schema/p"
 5     xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
 6         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 7         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 8
 9
10     <!-- Bean的依赖注入===================================================================================== -->
11      <!-- 4.1构造器注入 -->
12         <bean id="car" class="com.study.spring.e_di.Car">
13             <!-- 方式一.根据索引的位置 -->
14             <!-- <constructor-arg index="0" value="保时捷"></constructor-arg>
15              <constructor-arg index="1" value="1500000"></constructor-arg> -->
16              <!-- 方式二.根据名字配置 -->
17              <!-- <constructor-arg name="name" value="宝马"></constructor-arg>
18              <constructor-arg name="price" value="500000"></constructor-arg> -->
19              <!-- 方式三.根据类型配置 -->
20              <constructor-arg type="java.lang.String" value="奔驰"></constructor-arg>
21              <constructor-arg type="double" value="600000"></constructor-arg>
22         </bean>
23
24       <!-- 4.2setter方法中注入 -->
25       <bean id="car2" class="com.study.spring.e_di.Car2">
26           <property name="name" value="雪佛兰"></property>
27           <property name="price" value="100000"></property>
28       </bean>
29
30       <bean id="employee" class="com.study.spring.e_di.Employee">
31           <property name="name" value="张三"></property>
32           <property name="car2" ref="car2"></property>
33       </bean>
34
35       <!-- 引用p命名空间 --><!-- 如果要引用p命名,那在最上面sxd中就要配置  xmlns:p="http://www.springframework.org/schema/p"-->
36        <bean id="car22" class="com.study.spring.e_di.Car2" p:name="宝马" p:price="500000">
37       </bean>
38       <bean id="employee2" class="com.study.spring.e_di.Employee" p:name="李四" p:car2-ref="car22"></bean>
39
40         <!-- 引入spEL表达式 -->
41       <bean id="carInfo" class="com.study.spring.e_di.CarInfo"></bean>
42         <bean id="car2_2" class="com.study.spring.e_di.Car2">
43             <property name="name" value="#{carInfo.name}"></property>
44             <property name="price" value="#{carInfo.caculatePrice()}"></property>
45         </bean>
46
47      <!-- 复杂属性的依赖注入 -->
48         <bean  id="collectionBean" class="com.study.spring.e_di.CollectionBean">
49             <!-- 简单属性的注入 -->
50             <property name="name" value="归谷"></property>
51             <property name="age" value="12"></property>
52             <!-- 注入list集合 -->
53              <property name="hobbies">
54                  <list>
55                      <value>吃饭</value>
56                      <value>睡觉</value>
57                      <value>敲代码</value>
58                  </list>
59              </property>
60
61              <!-- 注入set集合 -->
62              <property name="numbers">
63                  <set>
64                      <value>10</value>
65                      <value>20</value>
66                      <value>30</value>
67                      <value>40</value>
68                      <value>50</value>
69                  </set>
70              </property>
71              <!-- 注入map集合 -->
72              <property name="map">
73                  <map>
74                      <entry key="birthday" value="2017-1-1"></entry>
75                      <entry key="address" value="杭州西湖"></entry>
76                      <entry key="sex" value="female"></entry>
77                  </map>
78              </property>
79
80              <!-- 注入Properties -->
81              <property name="properties">
82                  <props>
83                      <prop key="compamy">杭州归谷</prop>
84                      <prop key="pnum">200</prop>
85                  </props>
86              </property>
87         </bean>
88
89     <!-- end  Bean的依赖注入===================================================================================== -->
90     <import resource="classpath:bean1.xml"/>
91     <import resource="classpath:bean2.xml"/>
92     <!-- 这里导入是指如果在src下还有其它的beans.xml我们可以这样去调用 -->
93
94 </beans>

有关applicationContext.xml这个配置文件里的内容一定要看懂,我写的还是比较基础和全面的。

有关命名空间p的使用我这里在解释下:

p:<属性名>="xxx" 引入常量值

p:<属性名>-ref="xxx" 引用其它Bean对象

关于这篇文章,我就写到这里,不足之处,欢迎大家多多指点,谢谢!

时间: 2024-10-11 13:16:14

Spring框架---IOC装配Bean的相关文章

Spring之自动装配bean

Spring之自动装配bean 最近学习Spring框架,参考资料是Spring IN ACTION----第一张内容飘过去~~ 从第二章的自动装配bean开始,不过学习Spring核心最重要的还是ioc的注入模式吧! 书上是这么说的----(概念问题,哈哈),首先普及几个概念 --------------------------------------------------------------------------------------------------------------

IOC装配Bean(注解方式)(5)

Spring的注解装配Bean Spring2.5 引入使用注解去定义Bean @Component 描述Spring框架中Bean Spring的框架中提供了与@Component注解等效的三个注解: @Repository 用于对DAO实现类进行标注 @Service 用于对Service实现类进行标注 @Controller 用于对Controller实现类进行标注 ***** 三个注解为了后续版本进行增强的. Bean的属性注入: 普通属性; @Value(value="itcast&q

Spring 之自动化装配 bean 尝试

[Spring之自动化装配bean尝试] 1.添加dependencies如下所示(不是每一个都用得到 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>4.3.9.RELEASE</version> </dependency

spring中自动装配bean

首先用@Component注解类: package soundsystem: import org.springframework.stereotype.Component; @Component public class TestBean{ …… } 开启组件扫描spring才能自动装配bean,创建一个@ComponentScan注解的类 package soundsystem: import org.springframework.context.annotation.componentS

Spring框架—— IOC容器和Bean的配置

 1 IOC和DI ①IOC(Inversion of Control):反转控制. 在应用程序中的组件需要获取资源时,传统的方式是组件主动的从容器中获取所需要的资源,在这样的模式下开发人员往往需要知道在具体容器中特定资源的获取方式,增加了学习成本,同时降低了开发效率. 反转控制的思想完全颠覆了应用程序组件获取资源的传统方式:反转了资源的获取方向--改由容器主动的将资源推送给需要的组件,开发人员不需要知道容器是如何创建资源对象的,只需要提供接收资源的方式即可,极大的降低了学习成本,提高了开发的效

Spring的IOC容器—Bean的自动装配

我们对XML配置文件装配Bean的方式都很熟悉了,但是随着业务的复杂性,我们可能编写越来越复杂的XM配置. Spring提供了4种类型的自动装配的方式,帮助我们减少XML的配置数量.如下: byName:根据与bean的属性具有相同名字(或者ID)的其他bean进行注入 byType:   根据与bean的属性具有相同类型的其他bean进行注入 constructor:根据与bean的构造函数参数有相同类型的bean进行注入 autodetect :  首先尝试使用constructor进行注入

Spring框架IOC,DI概念理解

1.什么是框架? 框架是一种重复使用的解决方案,针对某个软件开发的问题提出的. Spring框架,它是一个大型的包含很多重复使用的某个领域的解决方案. Spring的理念:不要重复发明轮子. 2.Spring的理解? 首先,Spring是一个容器.它是装对象的.主要就是通过搜索class的路径.找出bean对象,实际就是根据反射来获取这个bean对象的: Class<?> classit=Class.forName("com.jinglin.model.Person");

Spring框架 IOC注解

Spring框架的IOC之注解方式的快速入门        1. 步骤一:导入注解开发所有需要的jar包        * 引入IOC容器必须的6个jar包        * 多引入一个:Spring框架的AOP的jar包,spring-aop的jar包        2. 步骤二:创建对应的包结构,编写Java的类        * UserService            -- 接口        * UserServiceImpl        -- 具体的实现类        3.

Spring系列之装配Bean

一.概述 容器是Spring框架的核心,Spring容器使用IOC管理所有组成应用系统的组件.Spring有两种不同的容器:BeanFactory提供最简单的容器,提供了最基础的依赖注入支持,ApplicationContext建立在BeanFactory的基础之上,提供了系统构架服务如从属性文件中读取文本信息,事件传递等. 在Spring容器中拼凑Bean叫做装配,装配Bean的时候,你是在告诉容器需要哪些Bean以及容器如何使用依赖注入将它们配合在一起. 二.装配Bean 2.1  使用XM