Spring详解一之IOC容器

最新推荐文章于 2024-05-22 23:32:45 发布
最新推荐文章于 2024-05-22 23:32:45 发布
阅读量442 收藏 1
点赞数
分类专栏： Spring 文章标签： IOC Spring DI
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/mxcsdn/article/details/80697162
版权


1、Spring概述

2、Spring的模块介绍

3、IOC依赖注入

4、创建或获取Bean对象

5、Bean的普通属性赋值

6、Bean的属性文件和集合属性赋值

7、Bean之间的关系

8、Bean的作用域——scope

9、基于xml配置文件的自动注入——autowire

10、IOC之abstract抽象Bean

1、Spring概述

①Spring是一个开源框架

②Spring为简化企业级开发而生，使用Spring开发可以将Bean对象，Dao组件对象，Service组件对象等交给Spring容器来管理(可通过注解@Controller

@Service @Repository@Component @Scope)，这样使得很多复杂的代码在Spring中开发却变得非常的优雅和简洁，有效的降低代码的耦合度，极大的方便项目的后期维护、升级和扩展。

③Spring是一个IOC(DI)和AOP容器框架。

④Spring的优良特性

[1]非侵入式：基于Spring开发的应用中的对象可以不依赖于Spring的API

[2]控制反转：IOC——Inversion of Control，指的是将对象的创建权交给Spring去创建。使用Spring之前，对象的创建都是由我们自己在代码中new创建。而使用Spring之后。对象的创建都是由给了Spring框架。

[3]依赖注入：DI（IOC的另一种表达形式）——Dependency Injection，是指依赖的对象不需要手动调用setXX方法去设置，而是通过配置赋值。

[4]面向切面编程：Aspect Oriented Programming——AOP

[5]容器：Spring是一个容器，因为它包含并且管理应用对象的生命周期

        [6]组件化：Spring实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用XML和Java注解组合这些对象。

        [7]一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库（实际上Spring 自身也提供了表述层的SpringMVC和持久层的Spring JDBC）。

开发使用的工具：STS(spring-tool-suite),是在eclipse中帮开发者安装好了spring的插件，其实就是一个eclipse，目前只有eclipse4.3.2(对应jkd7)这一个版本可以自己在eclipse安装插件了，但可能会出错，建议使用sts,主要是sts提示特别多。

2、Spring的模块介绍


Spring框架分为四大模块：

Core核心模块。负责管理组件的Bean对象

spring-beans-4.0.0.RELEASE.jar

spring-context-4.0.0.RELEASE.jar

spring-core-4.0.0.RELEASE.jar

spring-expression-4.0.0.RELEASE.jar

 

面向切面编程

spring-aop-4.0.0.RELEASE.jar

spring-aspects-4.0.0.RELEASE.jar

 

数据库操作

spring-jdbc-4.0.0.RELEASE.jar

spring-orm-4.0.0.RELEASE.jar

spring-oxm-4.0.0.RELEASE.jar

spring-tx-4.0.0.RELEASE.jar

spring-jms-4.0.0.RELEASE.jar

 

Web模块

spring-web-4.0.0.RELEASE.jar

spring-webmvc-4.0.0.RELEASE.jar

spring-websocket-4.0.0.RELEASE.jar

spring-webmvc-portlet-4.0.0.RELEASE.jar

3、IOC依赖注入

3.1、什么是IOC

IOC 全称指的是 Inverse Of Control 控制反转。

 

使用Spring之前，我们对Bean对象的管制，都是自己手动的去new Xxx()。

而使用了Spring模型之后，我们把new的操作。交给Spring容器。

 

 

3.2、什么是DI

DI 指的是Dependency Injection 。是依赖注入的意思。

 

原来在使用Spring之前。

Class BookService{

private BookDao bookDao;

 

public void setBookDao( BookDao bookDao ){

this.bookDao = bookDao

}

 

}

使用了Spring之后。我们只需要使用xml配置，或者注解配置。就可以直接注入。

4、创建或获取Bean对象

一、通过id

二、通过class类名

三、通过创建静态工厂方法

四、通过工厂实例对象（必须先有个工厂实例对象）

五、通过FactoryBean接口方式

4.1、第一个IOC示例程序 -- 通过id获取对象（重点）

实验1：通过IOC容器创建对象，并为属性赋值★

 

1、创建一个Java工程：


2、创建log4j.properties日记配置文件

 

# Global logging configuration

log4j.rootLogger=INFO, stdout

# Console output...

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

 

3、创建Spring的配置文件


4、创建一个JavaBean对象

 

public class Person {

 

private int id;

private String name;

private String phone;

private int age;

5、到Spring配置文件中配置你的Bean对象


<?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标签用于配置一个组件对象（javaBean，Dao，Service）
			id	是给bean对象起一个唯一的标识
			class	bean对象的具体全类名
	 -->
	<bean id="p1" class="com.tcent.pojo.Person">
		<!-- property标签用来配置属性信息
				name 是属性名
				value 是属性值
		 -->
		<property name="id" value="1"/>
		<property name="name" value="华仔"/>
		<property name="age" value="18"/>
		<property name="phone" value="18699998888"/>
	</bean>
	
</beans>

6、如何从Spring容器中获取Bean对象

	@Test
	public void test1() throws Exception {
		// 创建一个Spring容器对象
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
				"application.xml");
		// getBean从Spring容器中获取指定的id值的 bean对象返回
		Person person = (Person) applicationContext.getBean("p1");
		System.out.println(person);
	}

这里"application.xml"，也可以写成"classpath:application.xml",因为ClassPathXmlApplicationContext()方法本身就是从类路径（源码src位置）下加载的，所以代码中此处可选。但在配置文件中必须要加上classpath来引入需要的属性配置文件。

 

问题：

1、FileSystemXmlApplicationContext怎么用?

答：跟使用JavaSE的相对路径一样

2、Bean是在什么时候被创建的?

答：在创建ApplicatiocnContext(类路径)对象一样（默认）

3、如果调用getBean多次，会创建几个?

答：默认创建同一个

 

常见的错误：

指定的id不存在。找不到bean对象。


4.2、IOC示例程序 -- 通过类型获取对象（重点）

实验2：根据bean的类型从IOC容器中获取bean的实例★

 

在application.xml中的配置：


<!-- bean标签用于配置一个组件对象（javaBean，Dao。Service）
			id	是给bean对象起一个唯一的标识
			class	bean对象的具体全类名
	 -->
	<bean id="p1" class="com.tcent.pojo.Person">
		<!-- property标签用来配置属性信息
				name 是属性名
				value 是属性值
		 -->
		<property name="id" value="1"/>
		<property name="name" value="华仔"/>
		<property name="age" value="18"/>
		<property name="phone" value="18699998888"/>
	</bean>
	
	<bean id="p2" class="com.tcent.pojo.Person">
		<!-- property标签用来配置属性信息
				name 是属性名
				value 是属性值
		 -->
		<property name="id" value="1"/>
		<property name="name" value="华仔"/>
		<property name="age" value="18"/>
		<property name="phone" value="18699998888"/>
	</bean>

测试推荐：

	@Test
	public void test2() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person person = applicationContext.getBean(Person.class);
		System.out.println(person);
	}

常见错误说明：

当在applicationContext.xml配置文件中。有多个同Person.class类型实现的时候。


按照Class类型查找的时候，如果没有，也会报如下的错误：


4.3、IOC之静态工厂方法创建Bean对象

实验3：配置通过静态工厂方法创建的bean

 

1、创建一个工厂类


public class PersonFactory {

	public static Person createPerson() {
		Person person = new Person();
		person.setName("这是通过静态工厂方法创建的Person对象");
		return person;
	}
	
}

2、到xml中去配置：

<!-- 
		id		还是bean的唯一标识
		class	属性定义工厂类全类名
		factory-method	属性是调用哪个方法，的方法名
	 -->
	<bean id="p14" class="com.tcent.util.PersonFactory" factory-method="createPerson" />

测试的代码：


@Test
	public void test14() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person person = (Person) applicationContext.getBean("p14");
		System.out.println(person);
	}

4.4、IOC之工厂实例方法创建Bean对象

实验4：配置通过实例工厂方法创建的bean

public class PersonFactory {

	public static Person createPerson() {
		Person person = new Person();
		person.setName("这是通过静态工厂方法创建的Person对象");
		return person;
	}
	
	public Person createPerson2() {
		Person person = new Person();
		person.setName("这是通过工厂实例对象创建的Person");
		return person;
	}
	
}

在xml中的配置：

<bean id="personFactory" class="com.tcent.util.PersonFactory" />
	<!-- 
		id是唯一的标识
		factory-bean	引用哪个工厂对象的实例
		factory-method	同时是调用哪个方法，的方法名
	 -->
<bean id="p15" factory-bean="personFactory" factory-method="createPerson2" />

通过实例的方法，需要先有一个工厂实例对象：<bean id="personFactory" class="com.tcent.util.PersonFactory" />

类似情况：级联属性赋值一定要先注入已存在的对象。再注入对象的属性（类似于重新赋值）

<property name="car" ref="car1"></property>

测试的代码：

@Test
	public void test15() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person person = (Person) applicationContext.getBean("p15");
		System.out.println(person);
	}

4.5、IOC之FactoryBean接口创建Bean对象

实验5：配置FactoryBean接口创建Bean对象

 

1、实现FactoryBean接口

public class PersonFactoryBean implements FactoryBean<Person> {

	/**
	 * 返回创建的对象
	 */
	@Override
	public Person getObject() throws Exception {
		Person person = new Person();
		person.setName("这是FactoryBean接口的方式创建的");
		return person;
	}

	/**
	 * 返回创建的对象的类型
	 */
	@Override
	public Class<?> getObjectType() {
		return Person.class;
	}

	/**
	 * 是否是单例
	 */
	@Override
	public boolean isSingleton() {
		return true;
	}

}

2、在xml配置文件中的配置：

	<bean id="p16" class="com.tcent.util.PersonFactoryBean" />

测试的代码：

@Test
	public void test16() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person person = (Person) applicationContext.getBean("p16");
		System.out.println(person);
	}

5、Bean的普通属性赋值

一、通过property标签（name/value）注入

二、通过构造方法或参数名（name/value/index/type）注入

注：通过index标签索引，索引从0开始，要与构造方法的参数顺序一致

三、通过p名称空间

通过构造器为bean的属性赋值

5.1、IOC示例程序 -- 通过构造方法参数名注入值

实验5：通过构造器为bean的属性赋值

配置内容：

<bean id="p3" class="com.tcent.pojo.Person">
<!-- 	public Person(int id, String name, String phone, int age)  -->
		<constructor-arg name="id" value="3" />
		<constructor-arg name="name" value="p3"/>
		<constructor-arg name="phone" value="13999998869"/>
		<constructor-arg name="age" value="18"/>
	</bean>

测试代码：

@Test
	public void test3() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person person = (Person) applicationContext.getBean("p3");
		System.out.println(person);
	}

5.1.1、IOC示例程序 -- index属性指定参数的位置

实验6：通过index属性指定参数的位置

 

xml中的配置如下：

<bean id="p4" class="com.tcent.pojo.Person">
<!-- 	public Person(int id, String name, String phone, int age)  -->
		<!-- 
			constructor-arg	表示使用构造方法注入属性值
				name	表示构造方法的参数名
				index	表示构造方法的参数顺序从0开始
				value	表示要传入的构造方法的参数值
		 -->
		<constructor-arg value="4" index="0"/>
		<constructor-arg value="p4" index="1"/>
		<constructor-arg value="13999998869" index="2"/>
		<constructor-arg value="18" index="3"/>
	</bean>

测试的代码：

@Test
	public void test4() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person person = (Person) applicationContext.getBean("p4");
		System.out.println(person);
	}

5.1.2、IOC示例程序 -- 根据参数类型注入

实验7：根据参数类型注入

 

xml中的配置：

	<bean id="p5" class="com.tcent.pojo.Person">
<!-- 	public Person(int id, String name, String phone, int age) -->
<!-- 	public Person(int id, String phone, int age, String name)  -->
		<constructor-arg value="5" index="0" type="int"/>
		<constructor-arg value="phone" index="1" type="java.lang.String"/>
		<constructor-arg value="10" index="2" type="java.lang.String"/>
		<constructor-arg value="20" index="3" type="int"/>
	</bean>

注：通过参数类型可用区分构造方法的重载

测试的代码：

@Test
	public void test5() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person person = (Person) applicationContext.getBean("p5");
		System.out.println(person);
	}

5.2Bean的子对象bean赋值

5.2.1、IOC之子对象的赋值（很重点）

实验8：引用其他bean★

 

创建个新的工程。测试Spring的开发环境。此不重复。请参阅前面，环境搭建。

 

创建新的Bean对象

public class Car {

	private int id;
	private String name;

public class Person {

	private int id;
	private String name;
	private String phone;
	private int age;
	private Car car;

在xml中的配置如下：

<bean id="car1" class="com.tcent.pojo.Car">
		<property name="id" value="1"/>
		<property name="name" value="宝马"/>
	</bean>
	
	<bean id="car2" class="com.tcent.pojo.Car">
		<property name="id" value="2"/>
		<property name="name" value="马自达"/>
	</bean>
	
	<bean id="p7" class="com.tcent.pojo.Person">
		<property name="id" value="7"/>
		<property name="name" value="华仔7"/>
		<property name="age" value="187"/>
		<property name="phone" value="18679998888"/>
		<!-- name表示你要注入的哪个属性，ref 属性表示你要引用哪个对象 -->	
		<property name="car" ref="car1" />	
	</bean>

测试的代码：

@Test
	public void test7() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person person = (Person) applicationContext.getBean("p7");
		System.out.println(person);
	}

5.2.2、IOC之内部Bean的使用

实验8：引用内部bean

 

xml中配置的内容如下：

<bean id="p8" class="com.tcent.pojo.Person">
		<property name="id" value="8"/>
		<property name="name" value="华仔8"/>
		<property name="age" value="888"/>
		<property name="phone" value="18688888888"/>
		<!-- name表示你要注入的哪个属性，ref 属性表示你要引用哪个对象 -->	
		<property name="car">
			<!-- 内部的bean标签定义的对象。无法通过Spring容器获取。只能在内部赋值使用 -->
			<bean id="innerCar" class="com.tcent.pojo.Car" p:id="22" p:name="内部汽车"></bean>
		</property>	
	</bean>

测试的代码：

@Test
	public void test8() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person p8 = (Person) applicationContext.getBean("p8");
		System.out.println(p8);
		
		System.out.println( applicationContext.getBean("innerCar") );
	}

常见错误：内部的Bean不能被外部使用，无法通过spring容器获取


5.3、IOC之 P名称空间为bean赋值

实验9：通过p名称空间为bean赋值


xml中的配置：

	<bean id="p6" class="com.tcent.pojo.Person" p:id="60" p:name="第六个" p:phone="6电话" p:age="66"/>

测试的代码：

@Test
	public void test6() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person person = (Person) applicationContext.getBean("p6");
		System.out.println(person);
	}

5.4、IOC之级联属性赋值

实验10：给bean的级联属性赋值

 

 

在xml中的配置：

<bean id="p13" class="com.tcent.pojo.Person">
		<property name="name" value="这是12个Person" />
		<!-- 先赋值 -->
		<property name="car" ref="car1"></property>
		<!-- 再级联修改属性 -->
		<property name="car.id" value="2" />
		<property name="car.name" value="级联属性赋值" />
	 </bean>

测试的代码：

@Test
	public void test13() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person person = (Person) applicationContext.getBean("p13");
		System.out.println(person);
	}

常见错误：

级联属性赋值一定要先注入已存在的对象。再注入对象的属性（类似于重新赋值）

<property name="car" ref="car1"></property>

6、Bean的属性文件和集合属性赋值

6.1、IOC之List属性的赋值一

实验11：使用list子元素为List类型的属性赋值

public class Person {

	private int id;
	private String name;
	private String phone;
	private int age;
	private Car car;
	private List<Object> list;

通过setter方法注入值

要加getter和setter方法

 

xml中的配置：

<bean id="p9" class="com.tcent.pojo.Person">
		<property name="id" value="8"/>
		<property name="name" value="华仔8"/>
		<property name="age" value="888"/>
		<property name="phone" value="18688888888"/>	
		<property name="list">
			<list>
				<value>list1</value>
				<value>list2</value>
				<value>list3</value>
			</list>
		</property>
	</bean>

测试的代码：

@Test
	public void test9() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person p9 = (Person) applicationContext.getBean("p9");
		System.out.println(p9);
	}

6.2、IOC之util 名称空间List属性赋值二

util名称空间，可以定义

实验12：通过util名称空间创建集合类型的bean


在xml中的配置：

<!-- util:list定义一个list集合 -->
	<util:list id="list1">
		<list>
			<value>list1</value>
			<value>list2</value>
			<value>list3</value>
		</list>
	</util:list>
	
	<bean id="p12" class="com.tcent.pojo.Person">
		<property name="name" value="这是12个Person" />
		<property name="list" ref="list1" />
	</bean>

注：单独的list标签不允许定义在bean外部，但可用通过util名称空间定义

测试的代码：

@Test
	public void test12() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person person = (Person) applicationContext.getBean("p12");
		System.out.println(person);
		System.out.println( applicationContext.getBean("list1") );
	}

6.3、IOC之Map属性的赋值

实验13：使用map子元素为Map类型的属性赋值

public class Person {

	private int id;
	private String name;
	private String phone;
	private int age;
	private Car car;
	private List<Object> list;
	private Map<String, Object>map;

通过setter方法注入值

要加getter和setter方法

 

在xml中的配置如下：

<bean id="p10" class="com.tcent.pojo.Person">
		<property name="name" value="这是第10个实验" />
		<property name="map">
			<map>
				<entry key="key1" value="value1" />
				<entry key="key2" value="value2" />
				<entry key="key3" value="value3" />
			</map>
		</property>
	</bean>

测试的代码：

@Test
	public void test10() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person person = (Person) applicationContext.getBean("p10");
		System.out.println(person);
	}

6.4、IOC之Properties属性的赋值

实验14：使用prop子元素为Properties类型的属性赋值

public class Person {

	private int id;
	private String name;
	private String phone;
	private int age;
	private Car car;
	private List<Object> list;
	private Map<String, Object> map;
	private Properties prop;

 

通过setter方法注入值

要加getter和setter方法

 

xml中的配置如下：

<bean id="p11" class="com.tcent.pojo.Person">
		<property name="name" value="这是第10个实验" />
		<property name="prop">
			<props>
				<prop key="jdbc.url">jdbc:mysql://localhost:3306/test</prop>
				<prop key="jdbc.password">root</prop>
			</props>
		</property>
	</bean>

测试的代码：

@Test
	public void test11() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person person = (Person) applicationContext.getBean("p11");
		System.out.println(person);
	}

7、Bean之间的关系

7.1、IOC之继承Bean配置

实验15：通过继承实现bean配置信息的重用

xml配置文件中的内容：

<!-- bean标签用于配置一个组件对象（javaBean，Dao，Service）
			id	是给bean对象起一个唯一的标识
			class	bean对象的具体全类名
	 -->
	<bean id="p1" class="com.tcent.pojo.Person">
		<!-- property标签用来配置属性信息
				name 是属性名
				value 是属性值
		 -->
		<property name="id" value="1"/>
		<property name="name" value="华仔"/>
		<property name="age" value="18"/>
		<property name="phone" value="18699998888"/>
	</bean>

	<!-- 
		parent 设置你继承哪个bean的信息
	 -->	
	<bean id="p17" class="com.tcent.pojo.Person" parent="p1">
		<property name="list">
			<list>
				<value>这是继承的1</value>
				<value>这是继承的2</value>
			</list>
		</property>
	</bean>

测试的代码：

@Test
	public void test17() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		Person person = (Person) applicationContext.getBean("p17");
		System.out.println(person);
	}

7.2、IOC之Bean依赖组件创建顺序

实验16：bean之间的依赖  depends-on 属性

<?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">

	<!-- depends-on="b" 如果要创建a对象，就要有b对象
			也就是要先创建b再创建a
	 -->
	<bean id="a" class="com.tcent.pojo.A" depends-on="b"></bean>
	
	<bean id="b" class="com.tcent.pojo.B"></bean>
	
	<bean id="c" class="com.tcent.pojo.C"></bean>


</beans>

注：不可以三个互相依赖，否在会包错

 

测试的代码：

@Test
	public void test20() throws Exception {
		
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application2.xml");
		
	}

说明：

 默认情况下：在Application.xml中配置的bean对象，默认在创建Spring容器的时候都会创建。而且创建的顺序是在配置文件中从上到下的顺序。

8、Bean的作用域——scope

Scope属性设置范围：

Singleton

Prototype

WEB环境作用域：request/session

8.1、IOC之Bean的单例和多例/作用域（重点）

实验17：测试bean的作用域，分别创建单实例和多实例的bean

scope 属性设置范围:

1、 singleton默认情况是singleton，表示Spring容器中只有一个单例。

 单例是在Spring容器创建的时候，初始化所有单例Bean对象。

 并且每次调用Bean对象的时候，会调用原来Spring容器中的对象

 

2、 prototypeprototype是表示当前配置的Bean对象是多例。

 在Spring容器被创建的时候，bean不会被创建出来。

 并且每次调用getBean方法的时候都会创建一个对象实例

 

 3、request表示一次请求内，不管调用几次getBean方法，返回的都是同一个bean对象

 Object bean = request.getAttribute(xxx);

 if (bean == null) {

 bean = 创建一个

 request.setAttribute(xxx,bean);

 }

 4、session表示一个Session对象内，不管调用几次getBean方法，返回的都同一个Bean对象

  Object bean = session.getAttribute(xxx);

 if (bean == null) {

 bean = 创建一个

 session.setAttribute(xxx,bean);

 }

<bean id="p21" class="com.tcent.pojo.Person" scope="prototype">
		<property name="id" value="1"/>
		<property name="name" value="华仔"/>
		<property name="age" value="18"/>
		<property name="phone" value="18699998888"/>
	</bean>

9、基于xml配置文件的自动注入——autowire

先创建Person类和Car类

public class Car {
private int id;
	private String name;

public class Person {

	private Car car;

	public Person(Car car) {
		this.car = car;
	}

xml中的配置如下：

<bean id="car" class="com.tcent.pojo.Car">
	 	<property name="id" value="1" />
	 	<property name="name" value="宝马1" />
	 </bean>
	 
	 <bean id="car1" class="com.tcent.pojo.Car">
	 	<property name="id" value="2" />
	 	<property name="name" value="宝马2" />
	 </bean>
	 
	 <!-- 
	 	
	  -->
	 <bean id="p22" class="com.tcent.pojo.Person" autowire="constructor">
		<property name="id" value="1"/>
		<property name="name" value="华仔"/>
		<property name="age" value="18"/>
		<property name="phone" value="18699998888"/>	
	 </bean>

autowire设置自动装配的方式：

 1、Default(默认)和 no一样，都表示不装配，如果对象你不手动设置，就没有值。

 

 2、byName表示Spring容器会自动按照子对象的属性名，当成是id来查找对象。

 找到就注入，找不到就为null

 举例：private Car car;

 就会以car做为id去spring容器中去查找对象。找到就把值注入给属性car。

 

3、 byType表示Spring容器会自动的按照子对象的类型去查找bean对象注入。

 举例：private Car car;

 Spring容器就会自动的按照Car.class类型去Spring容器中查找。

 如果说：找到一个，就注入

  没有找到，值就为null

  找到多个，就报错。

 

4、 constructor表示Spring容器会按照子对象的类型去查找构造方法中，参数需要的类型去注入。

 先按照类型查询，如果找到一个就注入，

 如果找到多个再按照构造方法中参数的变量名做为id来查找：

如果找到就注入。如果没有找到，就为null

Constructor:先按照byType查找，找到多个再按照byName




10、IOC之abstract抽象Bean

实验18：通过abstract属性创建一个模板bean

 

 

xml中的配置：

<!-- bean标签用于配置一个组件对象（javaBean,Dao,Service）
			id	是给bean对象起一个唯一的标识
			class	bean对象的具体全类名
			
			表示当前bean标签所配置的bean对象，不能实例化
	 -->
	<bean id="p1" class="com.tcent.pojo.Person" abstract="true">
		<!-- property标签用来配置属性信息
				name 是属性名
				value 是属性值
		 -->
		<property name="id" value="1"/>
		<property name="name" value="华仔"/>
		<property name="age" value="18"/>
		<property name="phone" value="18699998888"/>
	</bean>

如果配置的bean标签对象，设置了属性abstract="true"，那么此标签中的对象不能实例化


说明：

在SpringIOC容器中，读取bean配置，创建bean实例之前，必须对它进行初始化，只有在容器实例化后，才可以在IOC容器里获取bean实例并使用。

默认情况下，spring只为每个在IOC容器里声明的bean创建唯一的实例，整个ioc容器范围内都共享该实例

对于单例的bean，生命周期有11个步骤： 

1.instantiate bean对象实例化，bean对象实例化，是在加载配置文件的时候实例的。即，我们启动spring容器的时候，加载配置文件，此时就实例化bean了。 

2.populate properties 封装属性 

3.如果Bean实现BeanNameAware， 执行 setBeanName 

4.如果Bean实现BeanFactoryAware 或者 ApplicationContextAware，设置工厂 setBeanFactory 或者上下文对象 setApplicationContext 

5.如果存在类实现 BeanPostProcessor（后处理Bean） ，执行postProcessBeforeInitialization（此点常常用来增强bean） 

6.如果Bean实现InitializingBean 执行 afterPropertiesSet 

7.调用<bean init-method="init"> 指定初始化方法 init 

8.如果存在类实现 BeanPostProcessor（后处理Bean） ，执行postProcessAfterInitialization（此点常常用来增强bean） 

9.执行业务处理 

10.如果Bean实现 DisposableBean 执行 destroy 

11.调用<bean destroy-method="customerDestroy"> 指定销毁方法

commons-logging-1.1.3.jar

spring-beans-4.0.0.RELEASE.jar

spring-context-4.0.0.RELEASE.jar

spring-core-4.0.0.RELEASE.jar

spring-expression-4.0.0.RELEASE.jar

下载

spring源码之Ioc容器加载过程详解
bugNoneNull的博客
09-23 1037
一、前言 针对于spring源码的初步学习，我认为首先应该掌握四大块，基于四大块全部掌握的基础上在进行扩展深入研究学习，具体四块如下： 1.Ioc容器加载的过程 2.spring如何解决循环依赖 3.spring Aop的实现 4.spring 事务管理实现 我觉得如果掌握了上面的四点，那么我们基本上就可以很自豪的说精通spring了，也算掌握了spring大概一半的内容了。 本文主要研究Ioc容器的加载过程。 二、什么是Ioc容器？ 我们常说Ioc是一个容器，是的，ioc就是一个容器，并
Spring IoC容器知识点详解
08-25
在Spring IoC容器中，每个对象被称为一个bean，这些bean是Spring管理的对象，它们的生命周期由容器控制。BeanDefinition是Spring容器中用于描述bean的关键数据结构，它包含了bean的完整信息，如类名、构造器参数、...
Spring - SpringIOC容器详解
weixin_34198881的博客
06-09 104
一、什么是Spring IOC: Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。 在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。 二、Spring中如何实现DI（依赖注入） 　　1.构造器注入 <bean id="beanName" class="BeanClassName"> ...
超详细讲解Spring IOC容器
m0_51168740的博客
04-19 301
1. 什么是IOC IOC -- Inverse of Control，控制反转，将对象的创建权力反转给Spring框架！ 就是一个解耦合的作用 在java当中一个类想要使用另一个类的方法，就必须在这个类当中创建这个类的对象，那么可能会出现如下情况， 比如A类当中创建着B对象，B类当中有C对象，C类当中有A对象，这个如果一个类出了问题，那么可能会导致这个框架出现问题。 Spring 将创建对象的权利给了IOC，在IOC当中创建了ABC三个对象吗，那么我们我们其他的类只需要调用集合， 大大的解决了程序耦
深入理解Spring——ioc容器详解
weixin_41186611的博客
07-28 430
BeanDefinitionRegistry接口是将各个BeanDefinition接口的实例统一放到一起，定义抽象了Bean的注册逻辑，将各个Bean联系起来，完成Bean的注册与加载。它大多数使用xml文件注册并管理各个对象之间的相互依赖关系，并不影响应用的设计和开发流程。BeanFactory要干的事就是业务对象的new和对象之间依赖关系的绑定，对于使用者来说，我们只需要按照规则将依赖关系写在配置文件中，当我们需要使用某一个对象时，只需要调用BeanFactory提供的接口去获得对象以及其他的操作。.
springIOC容器详解
Sunmeok的博客
09-15 452
SpringIOC容器又被搞了，我tm今天要搞定这个东西 我目前看过最好的讲解是这篇作者的 https://www.jianshu.com/p/4007079cb6c0 Spring的IoC容器在实现控制反转和依赖注入的过程中,可以划分为两个阶段: 容器启动阶段 Bean实例化阶段 这两个阶段中,IoC容器分别作了以下这些事情:   2、IoC容器及IoC容器如何获取对象间的依赖...
Spring之IOC容器
tq02的博客
03-28 1423
本文讲解的SpringIoc的知识点，对比传统代码，SpringIoc的优点，通过控制反转，如何获取Bean的两种方法，以及配置的xml文件
详解Spring IOC 容器启动流程分析
08-25
Spring IOC 容器是 Java 企业级应用程序的核心组件之一，它提供了一个统一的依赖注入机制，使得应用程序的组件之间能够松耦合。Spring IOC 容器的启动流程是整个 Spring 框架的核心所在，本文将从 ...
Spring为IOC容器注入Bean的五种方式详解
08-25
Spring为IOC容器注入Bean的五种方式详解 Spring 框架中，IOC（Inverse of Control，控制反转）容器是核心组件之一，用于管理 Bean 的生命周期。在 Spring 中，IOC 容器可以通过五种方式来注入 Bean，本文将对这五...
spring在IoC容器中装配Bean详解
08-28
Spring 在 IoC 容器中装配 Bean 详解 Spring 框架中的 IoC 容器是一个核心组件，它提供了 Bean 的装配、管理和依赖注入等功能。在 Spring 框架中，IoC 容器是 Bean 的容器，负责创建、管理和装配 Bean。在本文中，...
spring的IOC容器
ZgaoYi的博客
04-21 1567
文章目录1. IOC、IOC容器、Bean、DI2. 核心概念小结3，入门案例3.1 IOC入门案例3.1.1 入门案例思路分析3.1.2 入门案例代码实现步骤1:创建Maven项目步骤2:添加Spring的依赖jar包步骤3:添加案例中需要的类步骤4:添加spring配置文件步骤5:在配置文件中完成bean的配置步骤6:获取IOC容器步骤7:从容器中获取对象进行方法调用步骤8:运行程序3.2 DI入门案例3.2.1 入门案例思路分析3.2.2 入门案例代码实现步骤1: 去除代码中的new步骤2:为属性提供
Spring_IOC 容器
最新发布
m0_70703282的博客
05-22 1033
FactoryBean 工厂Bean1.设计模式：工厂方法设计模式2.implements FactoryBean<Person>接口2.1 public Xxx getObject(){} 实际返回的bean实例> getObjectType(){} 实际返回的bean的类型2.3 public boolean isSingleton() {} 实际返回的bean是否是单例，true则是单例@Component//1.实际从IOC容器中获取的实例bean，即Person。
重学Spring框架系列之——揭秘Spring两大核心之一的IOC容器
first_M的博客
01-25 159
今天菜鸟和大家一起来探讨一下Spring两大核心之一的“IOC”。 IOC是什么 IOC是“Inversion of Control”的缩写，翻译过来就是“控制反转”。 我们先不深究其在Spring中的含义，先从字面上进行分析。打个比方来说：结婚前你的工资完全由你来支配，想怎么花就怎么花。结婚后变了，你的钱要上交给你媳妇了，你想花的时候得申请。此时你对工资的控制转变了，由原来的你控制，变成了你媳妇控制。这就是“控制反转”，本来属于你控制的事情，交由别人来控制，而你只在需要的时候进行获取就可以了。 相信通过这
Spring IOC容器详解
Java持续实践
05-03 452
IOC : 控制反转， 把原先我们代码里需要实现的对象创建，依赖的代码， 反转给容器来实现。 DI：dependency injection 依赖注入 就是指对象是被动接受依赖类， 而不是主动去找。 对象不是从容器中查找它依赖的类， 而是在容器实例化对象的时候， 主动将它依赖的类，注入给它。 Spring中对象和对象的关系如何表示？ ...
Spring学习（三）-Spring IoC容器
weixin_42544630的博客
08-31 194
IoC的概念 IoC的字面意思就是控制反转，它包括两个“控制”和“反转”。 通俗来说，“控制”就是选择一件东西的控制权，“反转”就是把这种控制权从自己手中移除，交由第三方处理。对于软件来说，即是某一接口具体实现类的选择控制权从调用类中移除，转交给第三方决定。同时可以用依赖注入（DI）来代替IoC,即调用类对某一个接口实现类的依赖关系由第三方注入，以移除调用类的某一接口实现类的依赖。 IoC的类型 ...
Spring之IoC容器篇
kissship的博客
08-17 1584
Spring是一个开源的应用程序开发框架，它由Rod Johnson创建，主要用于构建企业级Java应用程序。它提供了一个全面的编程和配置模型，可以简化Java开发过程，提高开发效率和可维护性。即为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。目的：解决企业应用开发的复杂性功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能范围：任何Java应用简单来说，
SpringIOC容器详解，通俗易懂看这一篇就够了
qq_45369589的博客
02-26 5282
Spring5笔记 1、Spring 框架概述 2、IOC容器 2.1 IOC底层原理 2.2 IOC接口（BeanFactory） 2.3 IOC操作Bean管理（基于xml） 2.4 IOC操作Bean管理（基于注解） 3、AOP 4、JDBCTemplate 5、事务管理 6、Spring5新特性 1、Spring 框架概述 Spring 是轻量级的开源的 JavaEE 框架 Spring 可以解决企业应用开发的复杂性 ...
spring揭秘总结（一)——spring的Ioc容器
北平～
07-26 1472
spring揭秘这本权威书籍阅读后的总结分享，希望能帮助到你
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值