详解Spring框架---IOC装配Bean
IOC装配Bean
（1）Spring框架Bean实例化的方式提供了三种方式实例化Bean
- 构造方法实例化(默认无参数，用的最多)
- 静态工厂实例化
- 实例工厂实例化
下面先写这三种方法的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"
xmlns:p="http://www.springframework.org/schema/p"
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">
<!-- Bean的三种实例化方式=================== -->
<!-- 2.1 使用无参的构造器 -->
<bean id="bean1" class="com.study.spring.b_instance.Bean1"></bean>
<!-- 2.2使用静态工厂方法 factory-method 是工厂提供的静态方法 -->
<bean id="bean2" class="com.study.spring.b_instance.Bean2" factory-method="createInstance"></bean>
<!-- 2.3配置实例化工厂的方法 -->
<bean id="bean3Factory" class="com.study.spring.b_instance.Bean3Factory"></bean>
<bean id="bean3" factory-bean="bean3Factory" factory-method="getInstance"></bean>
<!-- 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类
public class Bean3Factory {
private Bean3Factory(){
}
public Bean3 getInstance(){
return new Bean3();
}
}
测试类InstanceDemo
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class InstanceDemo {
//实例化工厂方法
@Test
public void demo3(){
//加载配置文件 创建工厂
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
Bean3 bean3 =(Bean3) applicationContext.getBean("bean3");
System.out.println(bean3);
}
//静态工厂方法
@Test
public void demo2(){
//加载配置文件 创建工厂
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
Bean2 bean2 =(Bean2) applicationContext.getBean("bean2");
System.out.println(bean2);
}
//构造方法得到bean对象
@Test
public void demo1(){
//加载配置文件 创建工厂
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
Bean1 bean1 =(Bean1) applicationContext.getBean("bean1");
System.out.println(bean1);
}
}
/*
* 这三个都得到类似于com.study.spring.b_instance.Bean1@7229c204 的内存地址
*/
(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属性的依赖注入
前面已经知道如何获得对象，那我们接下来要知道如果给对象对象的属性赋值。
下面通过举例说明:
Car 类
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 + "]";
}
}
Car2类
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 + "]";
}
}
CarInfo类
public class CarInfo {
public String getName(){
return "哈弗H6";
}
public double caculatePrice(){
return 110000;
}
}
CollectionBean类
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 + "]";
}
}
Employee类
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 + "]";
}
}
TestDi测试类
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);
}
}
上面这几个类都不是最主要的，我们主要是来看配置文件怎么写，这才是最关键的：
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"
xmlns:p="http://www.springframework.org/schema/p"
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">
<!-- Bean的依赖注入=========== -->
<!-- 4.1构造器注入 -->
<bean id="car" class="com.study.spring.e_di.Car">
<!-- 方式一.根据索引的位置 -->
<!-- <constructor-arg index="0" value="保时捷"></constructor-arg>
<constructor-arg index="1" value="1500000"></constructor-arg> -->
<!-- 方式二.根据名字配置 -->
<!-- <constructor-arg name="name" value="宝马"></constructor-arg>
<constructor-arg name="price" value="500000"></constructor-arg> -->
<!-- 方式三.根据类型配置 -->
<constructor-arg type="java.lang.String" value="奔驰"></constructor-arg>
<constructor-arg type="double" value="600000"></constructor-arg>
</bean>
<!-- 4.2setter方法中注入 -->
<bean id="car2" class="com.study.spring.e_di.Car2">
<property name="name" value="雪佛兰"></property>
<property name="price" value="100000"></property>
</bean>
<bean id="employee" class="com.study.spring.e_di.Employee">
<property name="name" value="张三"></property>
<property name="car2" ref="car2"></property>
</bean>
<!-- 引用p命名空间 --><!-- 如果要引用p命名，那在最上面sxd中就要配置 xmlns:p="http://www.springframework.org/schema/p"-->
<bean id="car22" class="com.study.spring.e_di.Car2" p:name="宝马" p:price="500000">
</bean>
<bean id="employee2" class="com.study.spring.e_di.Employee" p:name="李四" p:car2-ref="car22"></bean>
<!-- 引入spEL表达式 -->
<bean id="carInfo" class="com.study.spring.e_di.CarInfo"></bean>
<bean id="car2_2" class="com.study.spring.e_di.Car2">
<property name="name" value="#{carInfo.name}"></property>
<property name="price" value="#{carInfo.caculatePrice()}"></property>
</bean>
<!-- 复杂属性的依赖注入 -->
<bean id="collectionBean" class="com.study.spring.e_di.CollectionBean">
<!-- 简单属性的注入 -->
<property name="name" value="归谷"></property>
<property name="age" value="12"></property>
<!-- 注入list集合 -->
<property name="hobbies">
<list>
<value>吃饭</value>
<value>睡觉</value>
<value>敲代码</value>
</list>
</property>
<!-- 注入set集合 -->
<property name="numbers">
<set>
<value>10</value>
<value>20</value>
<value>30</value>
<value>40</value>
<value>50</value>
</set>
</property>
<!-- 注入map集合 -->
<property name="map">
<map>
<entry key="birthday" value="2017-1-1"></entry>
<entry key="address" value="杭州西湖"></entry>
<entry key="sex" value="female"></entry>
</map>
</property>
<!-- 注入Properties -->
<property name="properties">
<props>
<prop key="compamy">杭州归谷</prop>
<prop key="pnum">200</prop>
</props>
</property>
</bean>
<!-- end Bean的依赖注入============ -->
<import resource="classpath:bean1.xml"/>
<import resource="classpath:bean2.xml"/>
<!-- 这里导入是指如果在src下还有其它的beans.xml我们可以这样去调用 -->
</beans>
有关applicationContext.xml这个配置文件里的内容一定要看懂，我写的还是比较基础和全面的。
有关命名空间p的使用我这里在解释下：
p:<属性名>="xxx" 引入常量值
p:<属性名>-ref="xxx" 引用其它Bean对象
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。
相关推荐
-
Spring学习笔记1之IOC详解尽量使用注解以及java代码
在实战中学习Spring,本系列的最终目的是完成一个实现用户注册登录功能的项目. 预想的基本流程如下: 1.用户网站注册,填写用户名.密码.email.手机号信息,后台存入数据库后返回ok.(学习IOC,mybatis,SpringMVC的基础知识,表单数据验证,文件上传等) 2.服务器异步发送邮件给注册用户.(学习消息队列) 3.用户登录.(学习缓存.Spring Security) 4.其他. 边学习边总结,不定时更新.项目环境为Intellij + Spring4. 一.准备工作. 1.m
-
Spring实现IoC的多种方式小结
控制反转IoC(Inversion of Control),是一种设计思想,DI(依赖注入)是实现IoC的一种方法,也有人认为DI只是IoC的另一种说法.没有IoC的程序中我们使用面向对象编程对象的创建与对象间的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将对象的创建转移给第三方,个人认为所谓控制反转就是:获得依赖对象的方式反转了. IoC是Spring框架的核心内容,使用多种方式完美的实现了IoC,可以使用XML配置,也可以使用注解,新版本的Spring也可以零配置实现Io
-
利用Spring IOC技术实现用户登录验证机制
利用 Spring IOC 技术实现用户登录的验证机制,对用户进行登录验证. 首先利用 Spring 的自动装配模式将 User 对象注入到控制器中,然后将用户输入的用户名和密码与系统中限定的合法用户的用户名和密码进行匹配. 当用户名与密码匹配成功时,跳转到登录成功页面:当用户名与密码不匹配时,跳转到登录失败的页面. 1.创建 User 对象,定义用户名和密码属性,代码如下: package com.importnew; public class User { private String us
-
Spring核心IoC和AOP的理解
spring 框架的优点是一个轻量级笔记简单易学的框架,实际使用中的有点优点有哪些呢! 1.降低了组件之间的耦合性 ,实现了软件各层之间的解耦 2.可以使用容易提供的众多服务,如事务管理,消息服务等 3.容器提供单例模式支持 4.容器提供了AOP技术,利用它很容易实现如权限拦截,运行期监控等功能 5.容器提供了众多的辅助类,能加快应用的开发 6.spring对于主流的应用框架提供了集成支持,如hibernate,JPA,Struts等 7.spring属于低侵入式设计,代码的污染极低 8.独立于
-
深入理解Java的Spring框架中的IOC容器
Spring IOC的原型 spring框架的基础核心和起点毫无疑问就是IOC,IOC作为spring容器提供的核心技术,成功完成了依赖的反转:从主类的对依赖的主动管理反转为了spring容器对依赖的全局控制. 这样做的好处是什么呢? 当然就是所谓的"解耦"了,可以使得程序的各模块之间的关系更为独立,只需要spring控制这些模块之间的依赖关系并在容器启动和初始化的过程中将依据这些依赖关系创建.管理和维护这些模块就好,如果需要改变模块间的依赖关系的话,甚至都不需要改变程序代码,只需要将
-
用java的spring实现一个简单的IOC容器示例代码
要想深入的理解IOC的技术原理,没有什么能比的上我们自己实现它.这次我们一起实现一个简单IOC容器.让大家更容易理解Spring IOC的基本原理. 这里会涉及到一些java反射的知识,如果有不了解的,可以自己去找些资料看看. 注意 在上一篇文章,我说,启动IOC容器时,Spring会将xml文件里面配置的bean扫描并实例化,其实这种说法不太准确,所以我在这里更正一下,xml文件里面配置的非单利模式的bean,会在第一次调用的时候被初始化,而不是启动容器的时候初始化.但是我们这次要做的例子是容
-
Spring boot实现一个简单的ioc（2）
前言 跳过废话,直接看正文 仿照spring-boot的项目结构以及部分注解,写一个简单的ioc容器. 测试代码完成后,便正式开始这个ioc容器的开发工作. 正文 项目结构 实际上三四个类完全能搞定这个简单的ioc容器,但是出于可扩展性的考虑,还是写了不少的类. 因篇幅限制,接下来只将几个最重要的类的代码贴出来并加以说明,完整的代码请直接参考https://github.com/clayandgithub/simple-ioc. SimpleAutowired 代码 import java.la
-
MVC使用Spring.Net应用IOC（依赖倒置）学习笔记3
到现在,我们已经基本搭建起了项目的框架,但是项目中还存在一个问题,就是尽管层与层之间使用了接口进行隔离,但实例化接口的时候,还是引入了接口实现类的依赖,如下面的代码: private IUserService _userService; private IUserService UserService { get { return _userService ?? (_userService = new UserService()); } set { _userService = value; }
-
浅析Java的Spring框架中IOC容器容器的应用
Spring容器是Spring框架的核心.容器将创建对象,它们连接在一起,配置它们,并从创建到销毁管理他们的整个生命周期.在Spring容器使用依赖注入(DI)来管理组成应用程序的组件.这些对象被称为Spring Beans. 容器获得其上的哪些对象进行实例化,配置和组装通过阅读提供的配置元数据的说明.配置元数据可以通过XML,Java注释或Java代码来表示.下面的图是Spring如何工作的高层次图. Spring IoC容器是利用Java的POJO类和配置元数据的产生完全配置和可执行的系统或
-
Spring中IoC优点与缺点解析
本文为大家分享了Spring中IoC优点与缺点,供大家参考,具体内容如下 1. 优点 我们知道,在Java基本教程中有一个定律告诉我们:所有的对象都必须创建:或者说:使用对象之前必须创建,但是现在我们可以不必一定遵循这个定律了,我们可以从Ioc容器中直接获得一个对象然后直接使用,无需事先创建它们. 这种变革,就如同我们无需考虑对象销毁一样:因为Java的垃圾回收机制帮助我们实现了对象销毁:现在又无需考虑对象创建,对象的创建和销毁都无需考虑了,这给编程带来的影响是巨大的. 我们从一个简单例子开始,