spring——IOC控制反转

IOC控制反转思想

一.IOC简介

IOC inversion of controller（控制反转）
spring的控制反转：

是一种设计思想。
把对象的创建，初始化，销毁等工作交给spring ioc容器，由spring ioc容器控制对象的生命周期。

二.spring创建对象的三种方式

创建com.jp.domain包，存放JavaBean对象

package com.jp.domain;
public class Person {
	public String name;
	//无参构造
	public Person(){}
	//有参构造
	public Person(String name){this.name=name;}
	public void talk(){
		System.out.println("讲话...");
	}
}

applicationContext.xml，总的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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!-- applicationContext.xml文件是主文件 -->
	<!-- 导入applicationContext_helloworld.xml文件 -->
	<import resource="com/jp/applicationContext_helloworld.xml"/>
	<!-- 导入applicationContext_person.xml文件 -->
	<import resource="com/jp/domain/applicationContext_person.xml"/>
</beans>

1.无参构造

applicationContext_person.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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!-- 无参构造 -->
	<bean id="p" class="com.jp.domain.Person"></bean>
</beans>

测试类Demo.java

package com.jp.domain;

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

public class Demo {
	//方式1：spring通过默认的构造函数创建对象
	@Test
	public void test1(){
		ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
		Object o = ac.getBean("p");
		Person p=(Person)o;
		System.out.println(p);
	}
}

2.静态工厂

创建工厂类，BeanFactory.java

package com.jp.domain;

public class BeanFactory {
	//静态工厂，不用创建对象，直接类名.方法使用
	public static Person getInstance(){
		return new Person();
	}
}

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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!-- 静态工厂 -->
	<bean id="factory" class="com.jp.domain.BeanFactory" factory-method="getInstance"></bean>
</beans>

测试类Demo.java

package com.jp.domain;

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

public class Demo {
	//方式2：spring通过静态工厂创建对象
	@Test
	public void test2(){
		ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
		Person p = (Person)ac.getBean("factory");
		System.out.println(p);
	}
}

3.实例工厂

创建工厂类，BeanFactory.java

package com.jp.domain;

public class BeanFactory {
	//实例化工厂，要先创建BeanFactory对象，才能调用这个方法
	public Person getInstance(){
		return new Person();
	}
}

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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!-- 实例工厂 -->
	<!-- factory-bean要与上面的id值一样，下面的id值可以随便写 -->
	<bean id="factory" class="com.jp.domain.BeanFactory"></bean>
	<bean id="f" factory-bean="factory" factory-method="getInstance"></bean>
</beans>

测试类Demo.java

package com.jp.domain;

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

public class Demo {
	//方式3：spring通过实例化工厂创建对象
	@Test
	public void test3(){
		ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
		BeanFactory factory = (BeanFactory)ac.getBean("factory");
		System.out.println(factory);
		Person p =(Person)ac.getBean("f");
		System.out.println(p);
	}
}

三.Bean标签

1.bean标签的scope属性

Demo.java

package com.jp.scope;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jp.domain.Person;

public class Demo {
	@Test
	public void test1(){
		ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
		Person p1 = (Person) ac.getBean("p");
		System.out.println(p1);
		Person p2 = (Person) ac.getBean("p");
		System.out.println(p2);
		Person p3 = (Person) ac.getBean("p");
		System.out.println(p3);
	}
}

①.singleton

单例，scope属性的默认值。代表在spring ioc容器中只创建一个bean实例，每次都调用这一个对象。当使用单例时，对象中的List集合等存储容器放在成员位置会有线程安全问题，但可以放到某个函数中，即局部位置。

applicationContext_scope.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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">
	<bean id="p" class="com.jp.domain.Person" scope="singleton"></bean>
</beans>

Demo.java的三个结果相同

②.prototype多例

多例，每次从spring ioc容器中获取时，都会返回一个新的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" xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">
	<bean id="p" class="com.jp.domain.Person" scope="prototype"></bean>
</beans>

Demo.java的三个结果不相同

③.request

用在web开发中，将bean对象request.setAttribute()存储到request作用域中

④.session

用在web开发中，将bean对象session.setAttribute()存储到session作用域中

2.bean创建生命周期

①.创建对象

spring容器通过默认的构造函数创建对象

②.调用初始化方法

init-method=“init”

③.调用工程方法

talk()

④.调用销毁方法

estory-method=“destory”

<?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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">
	<bean id="person" class="com.jp.domain.Person" lazy-init="true" init-method="init" destroy-method="destroy"></bean>
</beans>

package com.jp.domain;

public class Person {
	public String name;
	public Person(){
		System.out.println("Person对象创建了...");
	}
	public Person(String name){
		this.name=name;
	}
	public void talk(){
		System.out.println("讲话...");
	}
	public void init(){
		System.out.println("初始化方法...");
	}
	public void destroy(){
		System.out.println("销毁方法...");
	}
}

package com.jp.life;

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

import com.jp.domain.Person;

public class Demo {
	@Test
	public void test1(){
		ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
		Person p=(Person)ac.getBean("person");
		p.talk();
	}
}

lazy-init属性
lazy-init="false"或者"default"或者不写
spring容器一启动，对象就创建完毕（调用空的构造方法）
lazy-init=“true”
调用spring容器调用getBean方法时，对象才创建（调用空的构造方法）
init-method=“Person对象中的初始化方法名”；
destroy-method=“Person对象中的销毁方法名”；

原文链接：https://blog.csdn.net/weixin_43908649/article/details/104845860