IOC(inversion of control)的中文解释是“控制反转”,对象的使用者不是创建者. 作用是将对象的创建 反转给spring框架来创建和管理。
控制反转怎么去理解呢。 其实它反转的是什么呢,是对象的创建工作。 举个例子:平常我们在servlet或者service里面创建对象,都是使用new 的方式来直接创建对象,现在有了spring之后,我们就再也不new对象了,而是把对象创建的工作交给spring容器去维护。我们只需要问spring容器要对象即可。
IOC 的作用:削减计算机程序的耦合(解除我们代码中的依赖关系)。
本次案例中我们使用工厂模式来创建对象,模拟spring容器从配置文件中读取类路径然后实例化的过程。
- 首先,创建一个接口和它的实现类
public interface UserService {
void insert();
}
public class UserServiceImpl implements UserService {
@Override
public void insert() {
System.out.println("插入了一条数据");
}
}
- 其次,创建一个配置文件。
<?xml version="1.0" encoding="utf-8" ?>
<beans>
<bean id="userService" class="com.hy.serviceImpl.AnotherUserServiceImpl" ></bean>
</beans>
- 然后,我们创建一个工厂类,创建一个getInstance()方法,提供给对象获取实例,方法内使用dom4j解析xml文件的内容。对了,还要引入依赖
<!-- dom4j -->
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<!-- dom4j 的依赖包 jaxen -->
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.1-beta-8</version>
</dependency>
- 下面是这个工厂类的初级版本。至于为什么是初级版本,下面我会解释
package com.hy.factory;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.junit.jupiter.api.Test;
import java.io.InputStream;
import java.util.List;
/**
* @author HY
* @ClassName BeanFactory
* @Description 最原始方法
* @DateTime 2020/12/24 15:36
* Version 1.0
*/
public class BeanFactory {
public static Object getInstance(String name) {
//dom4j解析xml文件
SAXReader saxReader = new SAXReader();
//获得配置文件
InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beanconfig.xml");
try {
Document read = saxReader.read(resourceAsStream);
//拿到标签为bean element对象
List<Element> list = read.selectNodes("//bean");
for (Element element : list) {
//获得标签内id属性的值
String id = element.attributeValue("id");
//与传入的类名做对比
if (name.equals(id)){
//相等,就获得这个标签中的class属性的值。
String aClass = element.attributeValue("class");
//拿到全限定名称,加载到内存中
Class<?> aClass1 = Class.forName(aClass);
//通过反射实例化对象
return aClass1.newInstance();
}
}
throw new RuntimeException("找不到Id为:"+name+"的bean标签");
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e.getMessage());
}
}
}
4.1创建测试类测试。
@Test
public void testRead() {
UserService userService1= (UserService) BeanFactory.getInstance("userService");
userService1.insert();
}
输出:
到这里想必大家已经发现了,每实例化一个类对象就要读取一次xml配置文件,而且这个类的内容是写死不会变的,不会因为不同的对象产生不同的结果,所以没必要每次都去读取配置文件实例化新的对象。这时候就可以使用单例模式来配合工厂模式;
- 饿汉式单例模式配合工厂模式的使用
package com.hy.factory;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author HY
* @ClassName BeanFactoryV2
* @Description 饿汉式单例模式(先实例化所有bean标签中的类)
* @DateTime 2020/12/24 16:37
* Version 1.0
*/
public class BeanFactoryV2 {
/**
* 容器,存储bean标签的id和对应的对象
*/
private static Map<String, Object> map = new HashMap();
static {
//dom4j解析xml文件
SAXReader saxReader = new SAXReader();
//获得配置文件
InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beanconfig.xml");
Document read = null;
List<Element> list = null;
try {
//获得所有标签
read = saxReader.read(resourceAsStream);
//获得标签下的bean标签
list = read.selectNodes("//bean");
for (Element element : list) {
String id = element.attributeValue("id");
String aClass = element.attributeValue("class");
Object object = Class.forName(aClass).newInstance();
map.put(id, object);
}
} catch (Exception e) {
throw new RuntimeException("类加载错误,请检查标签内class的类路径是否拼写错误");
}
}
public static Object getInstance(String name) {
Object obj = map.get(name);
if (obj != null) {
return obj;
}
throw new RuntimeException("找不到Id为:" + name + "的对象");
}
}
5.1测试代码
@Test
public void testRead() {
UserService userService1= (UserService) BeanFactoryV2.getInstance("userService");
userService1.insert();
}
输出:
虽然用饿汉式单例模式可以实现对象的唯一,但是如果配置文件中配置了很多很多个要注册的bean对象,但是某些对象又不会经常被用到,这样就造成了资源的浪费,所以,我们可以使用懒汉式单例模式来实现本案例的终极版本。
- 懒汉式单例模式配合工厂模式
package com.hy.factory;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import javax.crypto.Cipher;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* @author HY
* @ClassName BeanFactoryV3
* @Description 懒汉式单例模式
* @DateTime 2020/12/24 16:37
* Version 1.0
*/
public class BeanFactoryV3 {
/**
* 用于存放类id与类的全限定名
*/
private static Map<String, String> map = new HashMap();
/**
*用户存放已经实例化过的对象
*/
private static Map cache = new HashMap();
static {
//dom4j解析xml文件
SAXReader saxReader = new SAXReader();
//获得配置文件
InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beanconfig.xml");
Document read = null;
List<Element> list = null;
try {
read = saxReader.read(resourceAsStream);
list = read.selectNodes("//bean");
for (Element element : list) {
String id = element.attributeValue("id");
String aClass = element.attributeValue("class");
//存放类id与类路径
map.put(id, aClass);
}
} catch (Exception e) {
throw new RuntimeException("类加载错误,请检查标签内class的类路径是否拼写错误");
}
}
/**
* 双重检测锁实现单例模式
* @param name
* @return
* @throws Exception
*/
public static Object getInstance(String name) throws Exception {
Object obj = cache.get(name);
//如果容器中没有该对象。
if (obj == null) {
//从map中取出全限定名加载
String classPath= map.get(name);
Class<?> aClass = Class.forName(classPath);
synchronized (BeanFactoryV3.class) {
if (cache.get(name) != null) {
cache.put(name,aClass.newInstance());
}
}
}
return obj;
}
}
6.1 开多个线程测试。
@Test
public void testRead() {
for (int i = 0; i < 100; i++) {
new Thread(() -> {
try {
UserService userService = (UserService) BeanFactoryV3.getInstance("userService");
System.out.println(userService);
} catch (Exception e) {
e.printStackTrace();
}
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
测试结果:
成功