正文
Spring学习：简单实现一个依赖注入和循环依赖的解决
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
依赖注入
什么是依赖注入
使用一个会创建和查找依赖对象的容器，让它负责供给对象。
当a对象需要b对象时，不再是使用new创建，而是从容器中获取，对象与对象之间是松散耦合的关系，有利于功能复用。
依赖：应用程序依赖容器，需要的对象都从容器获取
注入：容器将对象注入到应用程序中
设计思路
-
我们必须告诉容器：哪些类是由容器来创建的；哪些类是要从容器中获取的
-
使用两个注解对类进行标记
-
容器必须对所有类进行扫描，将标记过的类创建和注入
-
扫描src文件夹下所有java为后缀的文件
-
使用反射的方式查看类定义，构造对象
-
一个能创建、获取对象的容器
-
使用Map作为这个容器：Class类型为key，Object类型为value
代码实现
注解定义
/**
* 被标记的类需要由容器创建
*/
@Retention(value = RetentionPolicy.RUNTIME)
@Target(value = ElementType.TYPE)
public @interface FBean {
}
/**
* 标记需要从容器获取的对象
*/
@Retention(value = RetentionPolicy.RUNTIME)
@Target(value = ElementType.FIELD)
public @interface FAutowired {
}
对所有类进行扫描
- 使用两个注解对类进行标记
- 扫描src文件夹下所有java为后缀的文件
- 使用反射的方式查看类定义，构造对象
- 使用Map作为这个容器：Class类型为key，Object类型为value
注解定义
/**
* 被标记的类需要由容器创建
*/
@Retention(value = RetentionPolicy.RUNTIME)
@Target(value = ElementType.TYPE)
public @interface FBean { }
/**
* 标记需要从容器获取的对象
*/
@Retention(value = RetentionPolicy.RUNTIME)
@Target(value = ElementType.FIELD)
public @interface FAutowired { }
对所有类进行扫描
通过遍历当前项目的所有java文件，由类名(包名 + java文件名)获取class，使用一个List存放用注解标记过的class
static List<Class> classList;
public static void scanClass() throws ClassNotFoundException {
File currentFile = new File("");
// 当前项目的绝对路径
String path = currentFile.getAbsolutePath();
classList = new ArrayList<>();
// 项目下src下的java文件
File javaFile = new File(path + "/src/main/java");
// 类所在的包
File[] packageFiles = javaFile.listFiles();
for (int i = 0; i < packageFiles.length; i++) {
findClass(packageFiles[i], packageFiles[i].getName());
}
}
/**
* 递归打开文件夹，寻找java文件，没有文件夹时结束递归
*
* @param file 当前找的文件
* @param className 类名称
* @throws ClassNotFoundException
*/
private static void findClass(File file, String className) throws ClassNotFoundException {
if (file.isFile()) {
// 将className最后的.java去掉
int endIndex = className.lastIndexOf(".");
String[] fileNames = file.getName().split("\\.");
// 判断是否为java文件
if ("java".equals(fileNames[1])) {
// 反射获取类放入list中
Class clazz = Class.forName(className.substring(0, endIndex));
if (clazz.isAnnotationPresent(FBean.class)){
classList.add(clazz);
}
}
return;
}
File[] files = file.listFiles();
for (int i = 0; i < files.length; i++) {
// 如果是package（文件夹），将文件名加入到类名称中，继续查看包里面的文件
findClass(files[i], className + "." + files[i].getName());
}
}
使用反射构造容器里的对象
使用一个Map作为存储对象的容器，有注解标记的引用通过class属性获取容器里的对象
和上面扫描类的代码写在同一个工具类(IocUtils)中
static final Map<Class, Object> objectMap = new HashMap<>();
static {
try {
// 先扫描类获取class
scanClass();
for (int i = 0; i < classList.size(); i++) {
// 对一个个class进行初始化
constructClass(classList.get(i));
}
} catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
e.printStackTrace();
}
}
public static Object constructClass(Class clazz) throws IllegalAccessException, InstantiationException {
if (clazz.isInterface() || clazz.isAnnotation()) {
return null;
}
if (objectMap.containsKey(clazz)) {
return objectMap.get(clazz);
}
// 反射构造对象
Object obj = clazz.newInstance();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
// 需要容器注入其他对象，并且容器中没有，让容器继续构造对象
if (field.isAnnotationPresent(FAutowired.class)) {
if (!objectMap.containsKey(field.getType())) {
// 递归构造
constructClass(field.getType());
}
// 构造结束进行赋值
field.setAccessible(true);
field.set(obj, objectMap.get(field.getType()));
}
}
// 每个对象构造完放进容器中
objectMap.put(clazz, obj);
return objectMap.get(clazz);
}
-
这里没有考虑使用接口的情况（因为太难了）
- 可以使用一个接口跟实现类对应的Map集合，field为接口类型时，构造实现类返回
进行测试
要交给容器的实体类
@FBean
public class StudentDao {
public void query(){
System.out.println("StudentDao:query()");
}
}
@FBean
public class TeacherDao {
@FAutowired
private StudentDao studentDao;
public void query(){
System.out.println("teacherDao:query()");
}
public StudentDao getStudentDao() {
return studentDao;
}
public void setStudentDao(StudentDao studentDao) {
this.studentDao = studentDao;
}
}
测试代码
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
StudentDao studentDao = (StudentDao) IocUtils.objectMap.get(StudentDao.class);
TeacherDao teacherDao = (TeacherDao) IocUtils.objectMap.get(TeacherDao.class);
if (teacherDao.getStudentDao() == studentDao) {
System.out.println("对象复用，依赖注入成功");
}
}
测试结果
@FBean
public class StudentDao {
public void query(){
System.out.println("StudentDao:query()");
}
}
@FBean
public class TeacherDao { @FAutowired
private StudentDao studentDao; public void query(){
System.out.println("teacherDao:query()");
} public StudentDao getStudentDao() {
return studentDao;
} public void setStudentDao(StudentDao studentDao) {
this.studentDao = studentDao;
}
}
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
StudentDao studentDao = (StudentDao) IocUtils.objectMap.get(StudentDao.class);
TeacherDao teacherDao = (TeacherDao) IocUtils.objectMap.get(TeacherDao.class);
if (teacherDao.getStudentDao() == studentDao) {
System.out.println("对象复用，依赖注入成功");
}
}
循环依赖
问题的产生
修改一下先前的StudentDao，让它引用TeacherDao，两个类就互相引用了
@FBean
public class StudentDao {
@FAutowired
private TeacherDao teacherDao; public TeacherDao getTeacherDao() {
return teacherDao;
} public void setTeacherDao(TeacherDao teacherDao) {
this.teacherDao = teacherDao;
} public void query(){
System.out.println("StudentDao:query()");
}
}
在原本构造对象的方法里面：
如果a类引用了容器的b类，a类在构造时，会让容器去构造b类，等b类构造完毕，a类才构造完毕。
当两个类互相引用时，a让容器构造b，b让容器构造a，最终造成死循环，可以使用上面的代码测试。
解决方案
原本只使用了一个Object_Map存储对象，现在再加上一个Complete_Map。
- Object_Map是第一层，存储的是刚刚实例化的对象。
- Complete_Map是第二层，存储属性填充完毕（引用的b、c、d、e全部构造好）的对象。
新的构造对象步骤
- a在实例化后，让容器去构造b，b实例化后，将b存入Object_Map中，继续a的构造流程。
- a从Object_Map拿到b，继续构造，最后存入Complete_Map。
- 轮到b构造时，使用Object_Map里面的b（也就是a已经引用的b），属性填充时，将Complete_Map里的a拿来用，构造完毕，存入Complete_Map
更新后的完整代码
Spring解决循环依赖的问题，为了AOP的实现使用了第三个Map。没有AOP的话，两个Map解决循环依赖的思路应该跟这差不太多。
主要修改constructClass这个方法，并且多了一个方法参数，所以调用方法的地方要改一下
package com.david.spring.ioc; import java.io.File;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map; public class IocUtils {
// 用注解标记的class集合
static final List<Class> classList = new ArrayList<>();
// 构造好对象的map
static Map<Class, Object> completeMap = new HashMap<>();
// 为了解决循环依赖问题创建的map
static final Map<Class, Object> objectMap = new HashMap<>(); static {
try {
// 先扫描类获取class
scanClass();
for (int i = 0; i < classList.size(); i++) {
// 对一个个class进行初始化，是需要完整构造
constructClass(classList.get(i), true);
}
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
} /**
*
* @param clazz 要构造的类
* @param isInitial true表示类自己需要完整构造，false表示其他对象要求构造
*/
public static void constructClass(Class clazz, boolean isInitial) throws InstantiationException, IllegalAccessException { if (clazz.isInterface() || clazz.isAnnotation() || completeMap.containsKey(clazz)) {
return;
} Object obj;
if (!objectMap.containsKey(clazz)) {
// 反射构造对象
obj = clazz.newInstance();
objectMap.put(clazz, obj);
} else { obj = objectMap.get(clazz);
}
if (!isInitial) {
return;
} Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
// 需要容器注入其他对象，并且容器中没有，让容器继续构造对象
if (field.isAnnotationPresent(FAutowired.class)) { field.setAccessible(true); if (completeMap.containsKey(field.getType())) {
field.set(obj, completeMap.get(field.getType()));
continue; } else if (!objectMap.containsKey(field.getType())) {
// 递归构造
constructClass(field.getType(), false);
}
// 构造结束进行赋值
field.set(obj, objectMap.get(field.getType()));
}
} completeMap.put(clazz,obj);
} /**
* 扫描src文件夹下所有的以java为后缀的文件
*/
public static void scanClass() throws ClassNotFoundException {
File currentFile = new File("");
// 当前项目的绝对路径
String path = currentFile.getAbsolutePath(); // 项目下src下的java文件
File javaFile = new File(path + "/src/main/java");
// 类所在的包
File[] packageFiles = javaFile.listFiles();
for (int i = 0; i < packageFiles.length; i++) {
findClass(packageFiles[i], packageFiles[i].getName());
}
} /**
* 递归打开文件夹，寻找java文件，没有文件夹时结束递归
*
* @param file 当前找的文件
* @param className 类名称
*/
private static void findClass(File file, String className) throws ClassNotFoundException { if (file.isFile()) {
// 将className最后的.java去掉
int endIndex = className.lastIndexOf(".");
String[] fileNames = file.getName().split("\\.");
// 判断是否为java文件
if ("java".equals(fileNames[1])) {
// 反射获取类放入list中
Class clazz = Class.forName(className.substring(0, endIndex));
if (clazz.isAnnotationPresent(FBean.class)) {
classList.add(clazz);
}
}
return;
} File[] files = file.listFiles();
for (int i = 0; i < files.length; i++) {
// 如果是package（文件夹），将文件名加入到类名称中，继续查看包里面的文件
findClass(files[i], className + "." + files[i].getName());
}
}
}
