手写一个最简单的IOC容器,从而了解spring的核心原理
java1234
共 35977字,需浏览 72分钟
· 2021-05-20
点击上方蓝色字体,选择“标星公众号”
优质文章,第一时间送达
作者 | 追极
来源 | urlify.cn/fqyEJv
从事开发工作多年,spring源码没有特意去看过。但是相关技术原理倒是背了不少,毕竟面试的那关还是得过啊! 正所谓面试造火箭,工作拧螺丝。下面实现一个最简单的ioc容器,供大家参考。
1.最终结果
2.涉及相关技术
(1) jdk动态代理
(2) java反射
3.源代码
(1)包扫描工具类
package com.hdwang.ioc.core.utils;
import java.io.File;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.HashSet;
import java.util.Set;
/**
* 类工具
*/
public class ClassUtils {
/**
* 获取某包下所有类
*
* @param packageName 包名
* @param isRecursion 是否遍历子包
* @return 类的完整名称
*/
public static Set<String> getClassName(String packageName, boolean isRecursion) {
Set<String> classNames = new HashSet<>();
ClassLoader loader = Thread.currentThread().getContextClassLoader();
String packagePath = packageName.replace(".", "/");
URL url = loader.getResource(packagePath);
String filePath = null;
try {
filePath = URLDecoder.decode(url.getPath(), "utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
if (filePath != null) {
classNames = getClassNameFromDir(filePath, packageName, isRecursion);
}
return classNames;
}
/**
* 从项目文件获取某包下有类
*
* @param filePath 文件路径
* @param isRecursion 是否遍历子包
* @return 类的完整名称
*/
private static Set<String> getClassNameFromDir(String filePath, String packageName, boolean isRecursion) {
Set<String> className = new HashSet<>();
File file = new File(filePath);
File[] files = file.listFiles();
for (File childFile : files) {
if (childFile.isDirectory()) {
if (isRecursion) {
className.addAll(getClassNameFromDir(childFile.getPath(), packageName + "." + childFile.getName(), isRecursion));
}
} else {
String fileName = childFile.getName();
if (fileName.endsWith(".class") && !fileName.contains("$")) {
className.add(packageName + "." + fileName.replace(".class", ""));
}
}
}
return className;
}
}
(2)字符串工具类
package com.hdwang.ioc.core.utils;
/**
* 字符串工具类
*/
public class StringUtils {
/**
* 判断字符串是否空白
*
* @param str 字符串
* @return 字符串是否空白
*/
public static boolean isBlank(String str) {
return str == null || str.trim().isEmpty();
}
/**
* 判断字符串是否非空白
*
* @param str 字符串
* @return 字符串是否非空白
*/
public static boolean isNotBlank(String str) {
return !isBlank(str);
}
}
(3) Bean对象注解
package com.hdwang.ioc.core.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Bean对象注解
* 待存入ioc容器的相关对象,声明在具体的实现类上
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.TYPE})
public @interface MyBean {
/**
* 待存入ioc容器的Bean名称
*
* @return Bean名称
*/
String value() default "";
}
(4) 自动注入注解
package com.hdwang.ioc.core.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 自动注入注解
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.FIELD})
public @interface AutoInject {
/**
* 注入的bean名称,为空时根据类型注入
*
* @return Bean名称
*/
String value() default "";
}
(5) Bean信息对象
package com.hdwang.ioc.core;
/**
* Bean类信息
*/
public class BeanInfo {
/**
* Bean类的类型
*/
private Class clasz;
/**
* 保存在ioc容器中的Bean名称
*/
private String beanName;
/**
* 保存在ioc容器中的Bean类型
*/
private Class beanType;
/**
* 保存在ioc容器中的bean对象实例
*/
private Object bean;
/**
* 保存在ioc容器中的bean的代理对象实例
*/
private Object proxyBean;
public Class getClasz() {
return clasz;
}
public void setClasz(Class clasz) {
this.clasz = clasz;
}
public String getBeanName() {
return beanName;
}
public void setBeanName(String beanName) {
this.beanName = beanName;
}
public Class getBeanType() {
return beanType;
}
public void setBeanType(Class beanType) {
this.beanType = beanType;
}
public Object getBean() {
return bean;
}
public void setBean(Object bean) {
this.bean = bean;
}
public Object getProxyBean() {
return proxyBean;
}
public void setProxyBean(Object proxyBean) {
this.proxyBean = proxyBean;
}
}
(6) 上下文对象
package com.hdwang.ioc.core;
import java.util.HashMap;
import java.util.Map;
/**
* 上下文对象
* 用于保存应用运行中的信息
*/
public class Context {
/**
* 根据Bean名称存储Bean的Map对象
*/
private Map<String, Object> nameBeanMap = new HashMap<>();
/**
* 根据Bean类型存储Bean的Map对象
*/
private Map<Class, Object> typeBeanMap = new HashMap<>();
public Object getBean(String beanName) {
return nameBeanMap.get(beanName);
}
public Object getBean(Class clasz) {
return typeBeanMap.get(clasz);
}
public void putBean(String beanName, Object bean) {
nameBeanMap.put(beanName, bean);
}
public void putBean(Class beanType, Object bean) {
typeBeanMap.put(beanType, bean);
}
}
(7) Bean的代理对象
package com.hdwang.ioc.core;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* Bean的代理对象
* 使用jdk动态代理原理实现对java对象的代理,必须依赖接口
*/
public class BeanProxy implements InvocationHandler {
/**
* 被代理的bean对象
*/
private Object bean;
public BeanProxy(Object bean) {
this.bean = bean;
}
/**
* 调用目标bean的相关方法
*
* @param proxy 代理对象
* @param method 方法
* @param args 参数
* @return 方法返回值
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before call method: " + method.getName());
Object result = method.invoke(bean, args);
System.out.println("after call method: " + method.getName());
return result;
}
}
(8) Bean工厂类(ioc容器类)
package com.hdwang.ioc.core;
import com.hdwang.ioc.core.annotation.AutoInject;
import com.hdwang.ioc.core.annotation.MyBean;
import com.hdwang.ioc.core.utils.ClassUtils;
import com.hdwang.ioc.core.utils.StringUtils;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
/**
* Bean工厂
*/
public class BeanFactory {
/**
* 基础包路径
*/
private String basePackage;
/**
* 上下文对象
*/
private Context context = new Context();
/**
* 工厂构造器
*
* @param basePackage 基础包路径
*/
public BeanFactory(String basePackage) {
this.basePackage = basePackage;
init();
}
/**
* 工厂初始化
*/
private void init() {
//扫描包和加载bean到ioc容器
List<BeanInfo> myBeanList = scanPackageAndLoadBeans();
//给bean注入依赖对象
injectBeans(myBeanList);
}
/**
* 扫描包和加载bean到ioc容器
*
* @return 加载进ioc容器中的相关Bean信息
*/
private List<BeanInfo> scanPackageAndLoadBeans() {
List<BeanInfo> myBeanList = new ArrayList<>();
//找到包下所有类
Set<String> classNames = ClassUtils.getClassName(basePackage, true);
for (String className : classNames) {
try {
//查找类
Class clasz = Class.forName(className);
//判断类上是否存在MyBean注解
if (clasz.isAnnotationPresent(MyBean.class)) {
//获取类上的MyBean注解
MyBean myBeanAnnotation = (MyBean) clasz.getAnnotation(MyBean.class);
//获取注解值,即Bean名称
String beanName = myBeanAnnotation.value();
//获取类继承的相关接口
Class[] interfaces = clasz.getInterfaces();
//判断类是否可以采用jdk动态代理(有接口方可进jdk动态代理,创建代理对象)
boolean canJdkProxyBean = interfaces != null && interfaces.length > 0;
//获取待注入ioc容器的Bean的类型
Class beanType = getBeanType(clasz, canJdkProxyBean);
//实例化当前类,生成bean实例
Object bean = clasz.newInstance();
Object iocBean = bean;
if (canJdkProxyBean) {
//可以使用jdk动态代理,则创建代理对象,代理此Bean
Object proxyBean = this.createBeanProxy(bean);
iocBean = proxyBean;
}
//保存生成的bean到ioc容器
if (StringUtils.isNotBlank(beanName)) {
context.putBean(beanName, iocBean);
}
context.putBean(beanType, iocBean);
//暂存Bean信息
BeanInfo beanInfo = new BeanInfo();
beanInfo.setClasz(clasz);
beanInfo.setBeanName(beanName);
beanInfo.setBeanType(beanType);
beanInfo.setBean(bean);
beanInfo.setProxyBean(canJdkProxyBean ? iocBean : null);
myBeanList.add(beanInfo);
}
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
System.out.println("加载bean异常");
e.printStackTrace();
}
}
return myBeanList;
}
/**
* 给相关Bean注入依赖的Bean
*
* @param myBeanList 注入到ioc容器中的所有的Bean
*/
private void injectBeans(List<BeanInfo> myBeanList) {
for (BeanInfo myBeanInfo : myBeanList) {
Class beanClass = myBeanInfo.getClasz();
Object bean = myBeanInfo.getBean();
//查找Bean的声明的所有字段
Field[] fields = beanClass.getDeclaredFields();
for (Field field : fields) {
//判断字段上是否有AutoInject注解
if (field.isAnnotationPresent(AutoInject.class)) {
//查找待注入的bean
AutoInject autoInjectAnnotation = field.getAnnotation(AutoInject.class);
//获取注解的值,即待注入的Bean名称
String injectBeanName = autoInjectAnnotation.value();
//获取字段的类型,即待注入的Bean类型
Class injectBeanType = field.getType();
Object proxyBean = null;
//从查找ioc容器中查找待注入的Bean对象
if (StringUtils.isNotBlank(injectBeanName)) {
//Bean名称不为空,则根据名称查找Bean
proxyBean = context.getBean(injectBeanName);
} else {
//Bean名称为空,则根据Bean类型查找Bean
proxyBean = context.getBean(injectBeanType);
}
//设置当前字段可访问
field.setAccessible(true);
try {
//将找到的Bean注入到当前字段上
field.set(bean, proxyBean);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
}
/**
* 获取待注入到ioc容器中的Bean类型
*
* @param clasz Bean类型
* @param canJdkProxyBean 是否可以使用jdk动态代理
* @return 注入到ioc容器中的Bean类型
*/
private Class getBeanType(Class clasz, boolean canJdkProxyBean) {
Class beanType = null;
if (canJdkProxyBean) {
//可以使用jdk动态代理,则bean类型取bean的接口类型
beanType = clasz.getInterfaces()[0];
} else {
//不可以使用jdk动态代理,bean类型就取当前类类型
beanType = clasz;
}
return beanType;
}
/**
* 根据Bean名称获取Bean对象
*
* @param beanName Bean名称
* @param <T> Bean类型
* @return ioc容器中的Bean, 找不到返回null
*/
public <T> T getBean(String beanName) {
return (T) context.getBean(beanName);
}
/**
* 根据Bean类型获取Bean对象
*
* @param clasz 注入到ioc容器中的Bean类型
* @param <T> Bean类型
* @return ioc容器中的Bean, 找不到返回null
*/
public <T> T getBean(Class clasz) {
return (T) context.getBean(clasz);
}
/**
* 创建代理bean
*
* @param bean 当前Bean对象
* @return Bean的代理对象
*/
private Object createBeanProxy(Object bean) {
InvocationHandler invocationHandler = new BeanProxy(bean);
Object proxyBean = Proxy.newProxyInstance(bean.getClass().getClassLoader(),
bean.getClass().getInterfaces(), invocationHandler);
return proxyBean;
}
}
4.示例代码
(1) User模型
package com.hdwang.ioc.example.model;
public class User {
private Long id;
private String name;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
(2) UserService
package com.hdwang.ioc.example.service;
import com.hdwang.ioc.example.model.User;
public interface UserService {
User getUserById(Long id);
}
(3) UserServiceImpl
package com.hdwang.ioc.example.service;
import com.hdwang.ioc.core.annotation.MyBean;
import com.hdwang.ioc.example.model.User;
@MyBean("userService")
public class UserServiceImpl implements UserService {
@Override
public User getUserById(Long id) {
User user = new User();
if (id == 1) {
user.setId(id);
user.setName("张三");
} else if (id == 2) {
user.setId(id);
user.setName("李四");
}
return user;
}
}
(4) UserController
package com.hdwang.ioc.example.controller;
import com.hdwang.ioc.core.annotation.AutoInject;
import com.hdwang.ioc.core.annotation.MyBean;
import com.hdwang.ioc.example.model.User;
import com.hdwang.ioc.example.service.UserService;
@MyBean("userController")
public class UserController {
@AutoInject
UserService userService;
public User getUserById(Long id) {
return userService.getUserById(id);
}
}
(5) 主函数
package com.hdwang.ioc.example;
import com.hdwang.ioc.core.BeanFactory;
import com.hdwang.ioc.example.controller.UserController;
import com.hdwang.ioc.example.model.User;
/**
* 程序启动类
*/
public class Main {
/**
* 主函数入口
*
* @param args 入参
*/
public static void main(String[] args) {
//定义要扫描的包名
String basePackage = "com.hdwang.ioc.example";
//初始化Bean工厂
BeanFactory beanFactory = new BeanFactory(basePackage);
//获取指定的Bean
UserController userController = beanFactory.getBean(UserController.class);
//调用Bean中的方法
User user = userController.getUserById(1L);
System.out.println(user);
}
}
5.运行结果
before call method: getUserById
after call method: getUserById
User{id=1, name='张三'}
6.总结说明
ioc的实现,主要是用到了java的反射技术,和动态代理无关,代理对象可以实现一些增强的功能,所以人们常常称spring的bean的代理类为增强类!哈哈。。。
7.附录
项目源码:https://github.com/hdwang123/iocdemo
粉丝福利:Java从入门到入土学习路线图
👇👇👇
👆长按上方微信二维码 2 秒
感谢点赞支持下哈
评论
【第129期】程序员的新宠:三款终端工具,让你告别Xshell!
概述 WindTerm:跨平台的SSH利器 首先介绍的是WindTerm,这是一款使用C语言开发的跨平台SSH客户端。它不仅完全免费,而且没有商业使用的限制。WindTerm支持SSH v2、Telnet、Raw Tcp等协议,而且性能出色,甚至超过了FinalShell和Electerm。功能
前端微服务
0
上班的时候,有一群摸鱼搭子非常重要...
上班的时候,有一群摸鱼搭子非常重要!一到上班时间,他们就从四面八方涌进群里冒泡...从八卦聊到股市、从职场聊到乌X兰局势,偶尔还会复读、相亲、battle...然后,下午6点钟准时消失不见...所以你要不要加入我们一起摸鱼?我们有北京、上海、深圳、广州、杭州、武汉、成都、南京等8个城市的摸鱼群,还有
产品经理日记
0
周四002 瑞超:同样落寞的境遇——北雪平vs埃尔夫斯堡
上赛季最终排名联赛第9的北雪平本赛季伊始表现不佳,4轮战罢他们仅以1胜1平2负的战绩排在倒数第三,这支历史上曾夺得13次联赛冠军、6次杯赛冠军老牌劲旅,正如英格兰赛场上的一众百年俱乐部,在低谷中不断探索着出路。球队主教练安德烈亚斯·阿尔姆曾是AIK索尔纳及赫根队的主教练,他于今年年初刚刚拿起球队教鞭
产品与体验
0
日本影山优佳最新杂志照,展现充满透明感的美丽
今天的图文分享的是影山优佳的杂志写真。元日向坂46的影山优佳,登上了写真杂志《周刊FLASH》5/7和5/14合并号的封面。影山优佳是日本艺人、女演员、前偶像。身高155厘米。2001年5月8日出生于东京都。2023年7月从组合日向坂46毕业,之后作为演员活跃的影山优佳,在《周刊FLAS
python教程
0
盘点一个使用超级鹰识别验证码并自动登录的案例
点击上方“Python共享之家”,进行关注回复“资源”即可获赠Python学习资料今日鸡汤江上几人在,天涯孤棹还。大家好,我是皮皮。一、前言前几天在Python钻石交流群【静惜】问了一个Python实现识别验证码并自动登录的问题,提问截图如下:验证码的截图如下所示:二、实现过程这里大家激烈的探讨,【
IT共享之家
0
朋友,你也不想一个人孤孤单单的上班吧?
上班的时候,有一群摸鱼搭子非常重要!一到上班时间,他们就从四面八方涌进群里冒泡...从八卦聊到股市、从职场聊到乌X兰局势,偶尔还会复读、相亲、battle...然后,下午6点钟准时消失不见...所以你要不要加入我们一起摸鱼?我们有北京、上海、深圳、广州、杭州、武汉、成都、南京等8个城市的摸鱼群,还有
产品经理日记
0
美团社招一面,比预想的简单。
面试题大全:www.javacn.site面试这件事就很玄学,有时候你觉得他可能很难,但面完之后竟然出奇的顺利,问的问题你都会;有些你觉得这次面试应该很简单,但去了之后就被问懵了,所以面试这件事有很多一部分运气的成分。所以说,在没有 Offer 之前就是多准备、楞怂面,主打一个大力出奇迹。这不,逛牛
Java中文社群
0
Eiten 一个构建投资组合的好帮手
Eiten是Tradytics的一个开源工具包,它实现了各种统计和算法投资策略,如Eigen组合、最小方差组合、最大夏普比率组合和基于遗传算法的组合。Eiten允许你用自己的股票组合建立自己的投资组合。Eiten中自带的严格测试框架使你能够对你的投资组合更有自信。1.准备开始之前,你要确保Pytho
Python实用宝典
0