文章目录
IOC控制反转
依赖注入
Bean的自动装配方式
丐版IOC实现
BeanDefinition.java
ResourceLoader.java
BeanRegister.java
Bean和DI的注解
BeanFactory.java
ApplicationContext
测试，实现
在这里插入图片描述
大家好，我是Leo。Spring核心中依赖注入和IOC容器是非常常见的，用起来也是非常的顺手，只能说是真香，那如何实现一个丐版的SpringIOC呢？那今天我们就来讲如何实现一个乞丐版的IOC和通过注解进行依赖注入。
IOC控制反转
在开始之前，首先得先理解什么是IOC的控制反转，Spring 通过 IoC 容器来管理所有 Java 对象的实例化和初始化，控制对象与对象之间的依赖关系 。我们将由 IoC 容器管理的 Java 对象称为 Spring Bean，它与使用关键字 new 创建的 Java 对象没有任何区别。
说白了就是，IOC负责我们的饮食，我们要饭和菜，只需要从IOC容器获取就行。
那这样的作用也就非常明显了，解耦、方便
依赖注入
那依赖注入肯定是IOC的精髓所在，我们平常使用@Autowired注解等自动注入方式，用起来确实舒服。
那依赖注入常用方式有哪些呢？
构造函数的参数实现注入
基于set注入（静态工厂和动态工厂）
基于属性的注入
Bean的自动装配方式
可以在文件中设置自动装配（autowire）方式，支持的装配方式有
| 方式 | 描述 |
|---|---|
| no | 手动装配 |
| byName | 通过id的名字自动注入对象 |
| byType | 通过类型自动注入对象 |
| constructor | 通过构造方法自动注入对象 |
| autodectect | 完全交给Spring管理，按先Constructor后byType的顺序进行匹配 |
丐版IOC实现
BeanDefinition.java
Bean的定义类，主要是包括配置Bean定义的对应的实体，对应的构造方法和getset方法就省略了
public class BeanDefinition {
private String beanName;
private Class beanClass;
ResourceLoader.java
资源加载器，用来完成包的扫描和Bean的加载
public class ResourceLoader {
private static String rootPath;
private Map<String, BeanDefinition> beanDefinitionMap = new HashMap(16);
public Map<String, BeanDefinition> getResource(String basePackage) {
// com.zly
try {
// 1. 把.换成/
String packagePath = basePackage.replaceAll("\\.", "\\\\");
// 2.获取包的绝对路径
Enumeration<URL> urls =
Thread.currentThread()
.getContextClassLoader()
.getResources(packagePath);
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
String filePath = URLDecoder.decode(url.getFile(), "utf-8");
rootPath = filePath.substring(0, filePath.length() - packagePath.length());
// 包扫描
try {
loadBean(new File(filePath));
} catch (Exception e) {
e.printStackTrace();
}
}
} catch (IOException e) {
e.printStackTrace();
}
return this.beanDefinitionMap;
}
private void loadBean(File file) throws Exception {
// 1. 判断是否是文件夹
if (file.isDirectory()) {
// 2. 获取文件夹的所有内容
File[] childFiles = file.listFiles();
// 3. 判断文件夹内为空，直接返回
if (childFiles == null || childFiles.length == 0) {
return;
}
// 4. 如果文件夹里面不为空，遍历文件夹所有的内容
for (File childFile : childFiles) {
// 4.1 遍历得到每个File对象，继续是文件夹，递归
if (childFile.isDirectory()) {
loadBean(childFile);
} else {
// 4.2 得到不是文件夹，是文件
// 4.3 得到包路径 和类名称
String pathWithClass = childFile.getAbsolutePath().substring(rootPath.length() - 1);
// 4.4 判断当前文件类型是否为class
if (pathWithClass.contains(".class")) {
// 4.5 是class类型，把\替换成. 把.class去掉
String allName = pathWithClass.replaceAll("\\\\", ".").replace(".class", "");
// 4.6 判断类上面是否有注解@Bean，放到map集合beanFactory
// 4.6.1 获取类的Class对象
Class<?> clazz = Class.forName(allName);
// 4.6.2 判断不是接口
if (!clazz.isInterface()) {
// 4.6.3 判断上面是否有@Bean注解
Bean annotation = clazz.getAnnotation(Bean.class);
if (annotation != null) {
// 4.6.4 实例化
String beanName = annotation.value();
if ("".equals(beanName)) {
beanName = allName;
}
if (clazz.getInterfaces().length > 0) {
System.out.println("正在加载【"+ clazz.getInterfaces()[0] +"】");
BeanDefinition beanDefinition = new BeanDefinition(beanName, clazz);
beanDefinitionMap.put(beanName, beanDefinition);
} else {
System.out.println("正在加载【"+ clazz.getInterfaces()[0]);
BeanDefinition beanDefinition = new BeanDefinition(beanName, clazz);
beanDefinitionMap.put(beanName, beanDefinition);
}
}
}
}
}
}
}
}
}
BeanRegister.java
用于向容器中注册一个Bean，在扫描后，我们的Bean主要是放在了beanDefinitionMap中，还没有进行加载和初始化，在获取中再进行加载到这个缓存Map中
public class BeanRegister {
private Map<String, Object> singletonMap = new HashMap<>(32);
public Object getSingletonBean(String beanName) {
return singletonMap.get(beanName);
}
public void registerSingletonBean(String beanName, Object bean) {
if (singletonMap.containsKey(beanName)) {
return;
}
singletonMap.put(beanName, bean);
}
}
Bean和DI的注解
这里的两个注解主要是用来标志这是一个Bean和进行依赖注入的
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Bean {
String value() default "";
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Di {
}
BeanFactory.java
这里的对象工厂主要是我们最重要的一个类，在创建时，需要加载注册器和资源加载，在获取Bean中，需要进行依赖注入，并创建一个Bean
public class BeanFactory {
/**
* 创建一个map集合，放bean对象
*/
private Map<String , BeanDefinition> beanDefinitionMap = new HashMap<>();
private BeanRegister beanRegister;
public BeanFactory(String basePackage) {
beanRegister = new BeanRegister();
this.beanDefinitionMap = new ResourceLoader().getResource(basePackage);
}
public Object getBean(String beanName) {
// 从缓存中获取
Object bean = beanRegister.getSingletonBean(beanName);
if (bean != null) {
return bean;
}
// 创建bean
return createBean(beanDefinitionMap.get(beanName));
}
public Object getBean(Class<?> clazz) {
BeanDefinition beanDefinition = getBeanNameByType(clazz);
if (Objects.isNull(beanDefinition)) {
log.error("can not find {}", clazz);
return null;
} else {
return getBean(beanDefinition.getBeanName());
}
}
private Object createBean(BeanDefinition beanDefinition) {
try {
Object bean = beanDefinition.getBeanClass().getConstructor().newInstance();
beanRegister.registerSingletonBean(beanDefinition.getBeanName(), bean);
loadDi(beanDefinition.getBeanName());
return bean;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 属性注入
*/
private void loadDi(String beanName) {
// 1. 实例化对象都在beanFactory的map集合中，遍历
Object bean = this.beanRegister.getSingletonBean(beanName);
// 2. 获取map集合每个对象和属性
Class<?> objectClass = bean.getClass();
// 3. 遍历得到每个对象属性数组，得到每个属性
Field[] declaredFields = objectClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
// 4. 判断属性上面是否有@Di注解
Di annotation = declaredField.getAnnotation(Di.class);
if (annotation != null) {
declaredField.setAccessible(true);
// 如果私有属性，可以设置值
// 5. 如果有@Di注解，把对象进行注入
try {
BeanDefinition beanDefinition = getBeanNameByType(declaredField.getType());
if (Objects.isNull(beanDefinition)) {
declaredField.set(bean, null);
} else {
declaredField.set(bean, getBean(beanDefinition.getBeanName()));
}
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}
}
private BeanDefinition getBeanNameByType(Class clazz) {
Set<Map.Entry<String, BeanDefinition>> entries = this.beanDefinitionMap.entrySet();
for (Map.Entry<String, BeanDefinition> entry : entries) {
if (entry.getValue().getBeanClass().equals(clazz)) {
return entry.getValue();
}
if (entry.getValue().getBeanClass().getInterfaces()[0].equals(clazz)) {
return entry.getValue();
}
}
return null;
}
}
ApplicationContext
我也模仿了Spring一样定义了一个ApplicationContext容器，获取Bean从这个容器获取，context容器再从BeanFactory中获取
public class AnnotationApplicationContext implements ApplicationContext {
/**
* 创建一个map集合，放bean对象
*/
private BeanFactory beanFactory;
@Override
public Object getBean(Class clazz) {
return beanFactory.getBean(clazz);
}
@Override
public Object getBean(String beanName) {
return beanFactory.getBean(beanName);
}
/**
* 设置包扫描规则
* 当前包及其子包，哪个类有@Bean注解，把这个类通过反射化
*/
public AnnotationApplicationContext(String basePackage) throws Exception {
this.beanFactory = getBeanFactory(basePackage);
}
private BeanFactory getBeanFactory(String baskPackage) {
return new BeanFactory(baskPackage);
}
}
测试，实现
@Bean
public class UserServiceImpl implements UserService {
@Di
private UserDao userDao;
@Override
public void add() {
System.out.println("service.........");
userDao.add();
}
}
public interface UserService {
void add();
}
@Bean
public class UserDaoImpl implements UserDao {
@Override
public void add() {
System.out.println("dao add...");
}
}
public interface UserDao {
void add();
}
public class UserTest {
public static void main(String[] args){
try {
ApplicationContext context = new AnnotationApplicationContext("com.zly");
UserService userService = (UserService)context.getBean(UserService.class);
userService.add();
} catch (Exception e) {
e.printStackTrace();
}
}
}
相信你看到这里，就可以很容易的理解了这个丐版的Spring就算完成了，希望可以对大家有帮助啦
