手把手撸一个最简单的Spring框架，从而学会Spring的核心原理

小灰灰 2023-01-23 02:53 12阅读 0赞

## 你知道的越多，不知道的就越多，业余的像一棵小草！ ##

成功路上并不拥挤，因为坚持的人不多。

## 编辑：业余草 ##

urlify.cn/fqyEJv

## 推荐：https://www.xttblog.com/?p=5184 ##

从事开发工作多年，spring源码没有特意去看过。但是相关技术原理倒是背了不少，毕竟面试的那关还是得过啊! 正所谓面试造火箭，工作拧螺丝。下面实现一个最简单的ioc容器，供大家参考。

1.最终结果

![cb58d27f6e1c0ee8d2b43d2c83f1ecf9.png][]

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的代理类为增强类！最后，如果需要源码的朋友请加我微信：codedq

![d32dbdc8297abae7d1b6dd19007c3788.png][]

[cb58d27f6e1c0ee8d2b43d2c83f1ecf9.png]: /images/20221020/c3406a38a0f94aa2a4aa0eade15e16f1.png
[d32dbdc8297abae7d1b6dd19007c3788.png]: /images/20221020/11ec4945a98a4160a7e3ed91e82263fa.png