自定义一个IOC框架

Posted lisongyu

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了自定义一个IOC框架相关的知识,希望对你有一定的参考价值。

要实现的功能:

  1. 将对象的实例化交给自定的ioc容器.
  2. 通过注解的方式对接口进行依赖注入
  3. 通过getBean("userName")方法那到对象,使用对象的方法
  • 首先,创建一个对象,定义对象的构造函数

    • package cn.lisongyu.ioc.demo.bean;
      
      import cn.lisongyu.ioc.annotation.Component;
      
      /**
       * @author lisongyu
       * @ClassName cn.lisongyu.ioc.demo.bean.UserBean
       * @description userbean
       * @create 2018年11月22日 11:08
       */
      @Component //自定义的组件,让ioc容器扫描带有指定注解的类,将当前类装配到ioc容器中
      public class UserBean {
      
          @Autowired //自定义的注入注解
          private Service service;
      
          public UserBean() {
              System.out.println("UserBean -> instance");
          }
      
          public void getUser(){
              service.test();     //接口的方法,如果注入失败,将报空指针异常
              System.out.println("用户详情展示");
          }
      }
    • package cn.lisongyu.ioc.demo.a.b.c;
      
      import cn.lisongyu.ioc.annotation.Component;
      import cn.lisongyu.ioc.demo.a.b.Service;
      
      /**
       * @author lisongyu
       * @ClassName cn.lisongyu.ioc.demo.a.b.c.TestService
       * @description  Service实现类
       * @create 2018年11月22日 11:22
       */
      @Component
      public class TestService implements Service {
      
          public TestService() {
              System.out.println("TestService -> instance");
          }
      
          @Override
          public void test() {
              System.out.println("Service 接口实现方法");
          }
      }
    • package cn.lisongyu.ioc.demo.a.b;
      
      /**
       * /**
       *
       * @author lisongyu
       * @ClassName cn.lisongyu.ioc.demo.a.b.Service
       * @description Service接口
       * @create 2018年11月22日 17:31
       */
      public interface Service {
      
          void test();
      }
      
  • 创建自定义的注解

    • package cn.lisongyu.ioc.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(ElementType.FIELD) //只能注解到字段上
      public @interface Autowired {
      }
      
    • package cn.lisongyu.ioc.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(ElementType.TYPE)   //该注解指定标注的位置    TYPE:类
      public @interface Component {
      }
  • 定义一个接口,用来获取bean对象的方法

    • package cn.lisongyu.ioc.context;
      
      /**
       * /**
       * Application 接口
       * @author lisongyu
       * @ClassName cn.lisongyu.ioc.context.Application
       * @description
       * @create 2018年11月22日 11:24
       */
      public interface Application {
      
          Object getBean(String beanName);
      }
      
    • package cn.lisongyu.ioc.context;
      
      import cn.lisongyu.ioc.annotation.Component;
      
      import java.io.File;
      import java.io.FileFilter;
      import java.net.URL;
      import java.sql.SQLOutput;
      import java.util.ArrayList;
      import java.util.List;
      import java.util.Map;
      import java.util.SortedMap;
      import java.util.concurrent.ConcurrentHashMap;
      
      /**
       * @author lisongyu
       * @ClassName cn.lisongyu.ioc.context.ApplicationImpl
       * @description Application的实现类
       * @create 2018年11月22日 11:24
       */
      public class ApplicationImpl implements Application {
      
          //定义存放所有类对象的集合
          private List<Class<?>> classList = new ArrayList<>();
      
          //定义存放类的实例对象的集合
          private Map<String,Object> instanceMap = new ConcurrentHashMap<>();
      
      
          //无参构造
          public ApplicationImpl() {
          }
      
          /**
           * 有参构造,通过传入的包路径来实现扫描
           * @param basePackage
           */
          public ApplicationImpl(String basePackage) {
              //扫描包路径
              doScan(basePackage);
      
              //实例化
              doIoc();
      
              System.out.println(instanceMap);
      
              //依赖注入
              doDi();
          }
      
          /**
           * 实例化对象
           */
          private void doIoc() {
              //首先判断一下当前类集合中是否含有元素
              if (classList == null){
                  return;
              }
              //遍历集合
              classList.forEach((clz) ->{
                  try {
                      //通过类对象,实例化一个对象
                      Object instance = clz.newInstance();
                      //创建key
                      String key = getKeyName(clz.getSimpleName());
                      //存放到map集合中
                      //如果集合中存在则报错
                      if (instanceMap.containsKey(key)){
                          throw new RuntimeException("相同的类名");
                      }
                      //放入ioc容器中
                      instanceMap.put(key,instance);
                      //判断当前类是否实现了接口
                      Class<?>[] interfaces = clz.getInterfaces();
                      for (Class<?> inter : interfaces) {
                          instanceMap.put(inter.getName(),instance);
                      }
                  } catch (InstantiationException e) {
                      e.printStackTrace();
                  } catch (IllegalAccessException e) {
                      e.printStackTrace();
                  }
              });
          }
      
          //改名,获取一个首字母小写的类名
          private String getKeyName(String simpleName) {
              char[] chars = simpleName.toCharArray();
              chars[0] += 32;
              return String.valueOf(chars);
          }
      
      
          //依赖注入
          private void doDi() {
              //首先判断实例对象是否有
              if (instanceMap.size() == 0)
                  return;
              //遍历所有的实例对象
              instanceMap.forEach((k,v) -> {
                  Object instance = v;
                  //注入实体对象
                  Object injectionInstance = null;
                  //通过反射获取类对象
                  Class<?> clz = v.getClass();
                  //获取当前类对象的所有声明的字段
                  Field[] fields = clz.getDeclaredFields();
                  //循环遍历所有字段
                  for (Field field : fields) {
                      //判断字段是否含有@Autowired注解
                      if(field.isAnnotationPresent(Autowired.class)){
                          String name = field.getType().getName();
                          injectionInstance = this.instanceMap.get(name);
                      }
                      // 通过反射注入到该属性中
                      field.setAccessible(true);
                      try {
                          field.set(instance,injectionInstance);
                      } catch (IllegalAccessException e) {
                          e.printStackTrace();
                      }
                  }
              });
          }
      
          //包扫描方法
          private void doScan(String basePackage) {
              //获取当前包的位置
              URL resource = this.getClass().getClassLoader().getResource(basePackage.replaceAll("\\.", "/"));
              //创建一个文件对象
              File file = new File(resource.getPath());
      
              //遍历文件
              File[] fileNames = file.listFiles(new FileFilter() {
                  @Override
                  public boolean accept(File childFile) {
                      //判断当前文件是否是一个文件夹
                      if (childFile.isDirectory()){
      
                          //如果是文件夹,递归,获取所有的class文件
                          doScan(basePackage+"."+childFile.getName());
                      }else {
                          //判断当前文件是否是一个类文件
                          if (childFile.getName().endsWith(".class")){
                              String classPath = basePackage + "." + childFile.getName().replaceAll("\\.class", "");
                              Class<?> clz = null;
                              try {
                                  clz = Class.forName(classPath);
                                  //判断是否是有@Component注解的类
                                  if (clz.isAnnotationPresent(Component.class)){
                                      classList.add(clz);
                                  }
                              } catch (ClassNotFoundException e) {
                                  e.printStackTrace();
                              }
      
                          }
                      }
                      return false;
                  }
              });
      
          }
      
          @Override
          public Object getBean(String beanName) {
              return this.instanceMap.get(beanName);
          }
      }
  • 运行main()

    • package cn.lisongyu.ioc;
      
      import cn.lisongyu.ioc.context.Application;
      import cn.lisongyu.ioc.context.ApplicationImpl;
      import cn.lisongyu.ioc.demo.bean.UserBean;
      
      import java.util.*;
      
      /**
       * Hello world!
       *
       */
      public class App
      {
          public static void main( String[] args ) {
      
              //包路径
              Application app = new ApplicationImpl("cn.lisongyu.ioc.demo");
      
              UserBean userBean = (UserBean) app.getBean("userBean");
      
              userBean.getUser();
      
      
          }
      
      }
      
      
  • 结果:

    TestService -> instance     //接口实现类的初始化
    UserBean -> instance            //对象类的初始化
    {cn.lison[email protected]4dd8dc3, [email protected], [email protected]} //装配到容器中的类
    Service 接口实现方法      //service.test();
    用户详情展示          //userBean.getUser();

?

以上是关于自定义一个IOC框架的主要内容,如果未能解决你的问题,请参考以下文章

我的自定义Spring框架 | 自定义Spring IoC功能

我的自定义Spring框架 | 自定义Spring IoC功能

web api 自托管自定义 ioc 将数据注入控制器

设计模式(三十)----综合应用-自定义Spring框架-自定义Spring IOC-定义bean注册表相关类

我的自定义Spring框架 | Spring IoC相关接口分析

我的自定义Spring框架 | Spring IoC相关接口分析