【初识Spring】对象（Bean）实例化及属性注入（xml方式）


title: 【初识Spring】对象（Bean）实例化及属性注入（xml方式）
date: 2018-08-29 17:35:15
tags: [Java,Web,Spring]
---

?#初识Spring之Bean实例化及属性注入

1.通过xml配置的方式进行实例化。

  • 配置文件中bean标签的常用属性
  • 通过无参构造（常用）
  • 使用静态工厂进行创建
  • 使用实例工厂进行创建

2.属性注入。

  • 使用有参数构造方法注入属性
  • 使用set方法注入属性（常用）
  • 注入对象类型属性
  • 注入复杂类型属性

xml配置的方式进行实例化

  • 配置文件中bean标签的属性

（1）id属性：起名称，id属性值名称任意命名

  • id属性值，不能包含特殊符号
  • 根据id值得到配置对象

（2）class属性：创建对象所在类的全路径

（3）name属性：功能和id属性一样的，id属性值不能包含特殊符号，但是在name属性值里面可以包含特殊符号

（4）scope属性

  • singleton：默认值，单例
  • prototype：多例
  • 无参构造实例化对象
//phone类：
package com.test.vo;
public class Phone {
    public void printTest() {
        System.out.print("Phone.......");
    }
}
<!--applicationContext.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.xsd">
    <bean id="phone" class="com.test.vo.Phone"></bean>
    </beans>

//测试类
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        //加载配置文件，创建对象
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //得到配置创建的对象
        Phone Phone = (Phone) context.getBean("phone");
        //调用对象方法
        Phone.printTest();
    }
}

注：java类中默认有无参构造方法，若类中已声明了有参构造，则需手动声明无参构造方法。

  • 使用静态工厂进行创建
//静态工厂类
package com.test.utils;
import com.test.vo.Phone;

public class BeanFactory {
    //静态方法，返回Phone对象
    public static Phone getPhone() {
        return new Phone();
    }

}

//创建的对象为Phone类对象不变
//配置文件改为：
<!--applicationContext.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.xsd">
        <!--class为静态工厂的路径，factory-method为工厂的方法-->
   <bean id="phoneFa" class="com.test.utils.BeanFactory" factory-method="getPhone"></bean>
    </beans>
//测试类
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Phone Phone = (Phone) context.getBean("phoneFa");
        Phone.printTest();
    }
}
  • 使用实例工厂进行创建
//实列工厂类：
import com.test.vo.Phone;

public class BeanUFactory {
    //普通方法，返回Phone对象
    public Phone getPhone() {
        return new Phone();
    }
}

    配置文件修改：
    <!-- 1.先创建工厂对象 -->
    <!-- 2.再创建Phone对象 -->
    <bean id="BeanUFactory" class="com.test.utils.BeanUFactory"></bean>
    <bean id="phoneUFa" factory-bean="BeanUFactory" factory-method="getPhone"></bean>
//测试类：
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Phone Phone = (Phone) context.getBean("phoneUFa");
        Phone.printTest();
    }
}

属性注入

  • 使用有参数构造方法注入属性：

Phone类改写为：

public class Phone {
    private String name;
    //显示声明无参构造
    public Phone() {}
    //有参构造
    public Phone(String name) {
        this.name=name;
    }
    public void printTest() {
        System.out.print(name+"Phone.......");
    }
}

applicationContext.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.xsd">
        <!--class为静态工厂的路径，factory-method为工厂的方法-->
   <bean id="phoneFa" class="com.test.utils.BeanFactory" factory-method="getPhone">
   <!--name为构造方法的参数名，value为要将其设置的值-->
   <constructor-arg name="name" value="诺基亚"></constructor-arg>
   </bean>
    </beans>

测试类：

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

public class Test {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Phone Phone = (Phone) context.getBean("phoneFa");
        Phone.printTest();
    }
}

结果：

诺基亚Phone.......
  • 使用set方法注入属性：

Phone类改写为：

public class Phone {
    private String name;
    //set方法
    public void setName(String name) {
        this.name = name;
    }
    public void printTest() {
        System.out.print(name+"Phone.......");
    }
}

applicationContext.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.xsd">
        <!--class为静态工厂的路径，factory-method为工厂的方法-->
   <bean id="phoneFa" class="com.test.utils.BeanFactory" factory-method="getPhone">
   <!--name为要注入的属性的名称，value为要将其设置的值-->
   <property name="name" value="三星"></property>
   </bean>
    </beans>

结果：

三星Phone.......
  • 注入对象类型属性

新建Person类：

public class Person {
    private String name;
    private String sex;
    private String age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
}

Phone类修改为：

package com.test.vo;

public class Phone {
    private String name;
    private Person person;

    //set方法
    public void setName(String name) {
        this.name = name;
    }

    public void setPerson(Person person) {
        this.person = person;
    }

    public void printTest() {
        System.out.print(person.getName()+"::"+person.getAge()+"::"+person.getSex());
    }
}

配置文件作如下修改：

<?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.xsd">
    <bean id="person" class="com.test.vo.Person" scope="prototype">
        <property name="name" value="小王"></property>
        <property name="sex" value="man"></property>
        <property name="age" value="11"></property>
    </bean>
    <bean id="phone" class="com.test.vo.Phone">
        <!-- 因注入的是对象写ref属性 -->
        <property name="person" ref="person"></property>
    </bean>
    </beans>

测试方法不变，结果为：

小王::11::man
  • 注入复杂类型属性

Phone类修改为：

package com.test.vo;

import java.util.Arrays;
import java.util.List;
import java.util.Map;

public class Phone {
    private String arr[];
    private List<Integer> list;
    private Map<String,String> map; 

    //set方法
    public void setArr(String[] arr) {
        this.arr = arr;
    }

    public void setList(List<Integer> list) {
        this.list = list;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }
    public void printTest() {
        System.out.println("arr:"+Arrays.toString(arr));
        System.out.println("list:"+list);
        System.out.println("map:"+map);
    }
}

配置文件作如下修改：

<?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.xsd">
    <bean id="phone" class="com.test.vo.Phone">
        <!-- 数组 -->
        <property name="arr">
            <list>
                <value>小米</value>
                <value>中兴</value>
                <value>华为</value>
            </list>
        </property>
        <!-- list集合 -->
        <property name="list">
            <list>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </list>
        </property>
        <!-- map集合 -->
        <property name="map">
            <map>
                <entry key="aa" value="lucy"></entry>
                <entry key="bb" value="bob"></entry>
                <entry key="cc" value="jerry"></entry>
            </map>
        </property>
    </bean>
    </beans>

结果如下：

arr:[小米, 中兴, 华为]
list:[1, 2, 3]
map:{aa=lucy, bb=bob, cc=jerry}

原文地址：https://www.cnblogs.com/flytree/p/11622685.html

时间： 2024-10-25 05:15:49

【初识Spring】对象（Bean）实例化及属性注入（xml方式）的相关文章

Spring IoC Bean 实例化（二）源码分析

目录 Spring IoC 依赖注入(四)构造器或工厂注入 1. doCreateBean 2. createBeanInstance 2. 实例化策略 - InstantiationStrategy 3. instantiateBean 4. autowireConstructor 4.1 整体说明 4.2 缓存匹配 4.3 无参构造器匹配 4.4 有参构造器匹配 5. ConstructorResolver 参数解析 5.1 resolveConstructorArguments 5.2 c

spring中bean的作用域属性singleton与prototype的区别

1.singleton 当一个bean的作用域设置为singleton, 那么Spring IOC容器中只会存在一个共享的bean实例,并且所有对bean的请求,只要id与该bean定义相匹配,则只会返回bean的同一实例.换言之,当把一个bean定义设置为singleton作用域时,Spring IOC容器只会创建该bean定义的唯一实例.这个单一实例会被存储到单例缓存(singleton cache)中,并且所有针对该bean的后续请求和引用都将返回被缓存的对象实例,这里要注意的是singl

Spring属性注入的方式

Spring的属性注入主要有三种: 1.setter方式注入 2.构造方法注入 3.注解注入,注解注入又分为: ①java annotation ②spring annitation 其中第三种中的java annotation是我们推荐使用的方法. 下面就来一一介绍这些注入方式的使用方法: setter方式注入步骤: ①首先在拥有属性的类中建立属性的set方法. ②在配置文件中使用property标签来注入. 构造方法方式注入步骤: ①创建属性所在的类创建构造方法,同时必须把默认的空构造方法也

SpringMVC 源代码深度解析 IOC容器（Bean实例化和依赖注入）

SpringMVC最核心的IOC的控制反转,动态的向某个对象提供它所需要的其他对象,例如:对象A时,需要对象B时,这时不像以前我们之前要在A对象里实例化B对象,这时B对象的实例化由IOC容器会主动创建一个对象B然后注入到对象A里,提供使用.我们项目开发中,最经常用到,那怎么实现实例Bean并依赖注入呢?我们今天带着这些问题来通过SpringMVC源代码进行深入的解析.这篇介绍不对注解实例化和注入进行讲解,这个放在后面在介绍. 我们平常写的一个类,并依赖调用了类的某个方法,这时需要依赖那个类已经实

ZK Spring 整合View/Controller层属性注入

问题场景 ZK实例化的View/Controller不同于Spring MVC实例化的Controller,不受Spring管理,无法进行注入. 解决方案 方法一 在doAfterCompose方法中调用SpringUtil提供的获取bean的方法,给bean赋值,代码如下: userService = (UserService) SpringUtil.getBean("userService"); 方法二 在doAfterCompose方法中调用Spring的自动注入方法进行所有be

Spring（二） Spring中的AOP和属性注入

一.AOP(Aspect Oriented Programing)面向切面编程 AOP的终极目标:让我们可以专心做事 下面通过一个例子来介绍AOP的具体使用 案例的要求:使用AOP实现日志记录系统 ,  核心模块  和    增强  单独  开发  ,运行时再组装 首先定义接口和方法 接口和实现类中的代码,我放在一起了,应该比较简单 package demo04.dao; /** * Created by mycom on 2018/3/5. */ public interface IHello

Spring：特殊数据类型的属性注入（基于配置文件）

该处提到的特殊数据类型指的是除了基础数据类型和String以外的其他常用的数据类型,如:List.Map.Set.以及pojo对象等.则我们创建的Person类定义为: package bjtu.wellhold.testSpring; import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.Properties; import java.util.Set; import org

spring中bean的singleton属性

1.  UserDao.java package com.lxh.springSingleton; public interface UserDao { // 保存User public void save(); } 2.  UserDaoImpl.java package com.lxh.springSingleton; public class UserDaoImpl implements UserDao { @Override public void save() { System.out

Spring -10 -&lt;bean&gt;的 scope 属性 -

1.<bean>的属性; 2.作用:控制对象有效范围(单例,多例等)3.<bean/>标签对应的对象默认是单例的. 3.1无论获取多少次,都是同一个对象 Teacher t1 = ac.getBean("teacher1",Teacher.class); System.out.println(t1); Teacher t2 = ac.getBean("teacher1",Teacher.class); System.out.println(t