从零手写IOC

概述

IOC (Inversion of Control) 控制反转。熟悉Spring的应该都知道。那么具体是怎么实现的呢?下面我们通过一个例子说明。

1. Component注解定义

package cn.com.infcn.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * 指定需要容器管理的类
 * 
 * @author jijs
 * @date 2017-12-3
 */
@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
}

先定义一个@Component注解。只要被@Component自定义主键注释的类都是受容器管理的Bean。

2. Inject注解定义

package cn.com.infcn.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * 指定需要注入的属性
 * @author jijs
 * @date 2017-12-3
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Inject {
}

定义一个@Inject注解,只要是被@Inject注解注释的属性都会自动注入,实现IOC功能。

3. 用户Bean实现

package cn.com.infcn.bean;
/**
 * 用户Bean
 * 
 * @author jijs
 * @date 2017-12-3
 */
public class User {
    private String userName;
    private Integer age;
    public User(String userName, Integer age) {
        this.userName = userName;
        this.age = age;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User [userName=" + userName + ", age=" + age + "]";
    }

}

只是一个普通的模型bean。

4. UserService实现

package cn.com.infcn.service;
import cn.com.infcn.annotation.Component;
import cn.com.infcn.bean.User;
/**
 * 用户Service实现
 * 
 * @author jijs
 * @date 2017-12-3
 */
@Component
public class UserService {
    public User getUser() {
        User user = new User("张三", 20);
        return user;
    }
}

UserService实现。使用@Component注解标注该类是受容器管理的类。

3. UserController实现

package cn.com.infcn.controller;
import cn.com.infcn.annotation.Component;
import cn.com.infcn.annotation.Inject;
import cn.com.infcn.bean.User;
import cn.com.infcn.service.UserService;
/**
 * 用户Controller实现
 * 
 * @author jijs
 * @date 2017-12-3
 */
@Component
public class UserController {
    @Inject
    private UserService userService;
    public void getUser() {
        User user = userService.getUser();
        System.out.println(user);
    }
}

Usercontroller实现,该类被@Component注解注释,表示受容器管理的Bean。 userService熟悉使用了@Inject自定义注解,表示该属性是容器自动注入该实例,实现IOC功能。

6. IocContext 容器实现

package cn.com.infcn.ioc;
import java.io.File;
import java.io.FileFilter;
import java.net.URL;
import java.util.Enumeration;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import cn.com.infcn.annotation.Component;
/**
 * Ioc 容器实现类
 * 
 * @author jijs
 * @date 2017-12-3
 */
public class IocContext {
    public static final Map<Class<?>, Object> applicationContext = new ConcurrentHashMap<Class<?>, Object>();
    static{
        String packageName = "cn.com.infcn";
        try {
            initBean(packageName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private static void initBean(String packageName) throws Exception {
        Enumeration<URL> urls = Thread.currentThread().getContextClassLoader().getResources(packageName.replaceAll("\\.", "/"));
        while (urls.hasMoreElements()) {
            addClassByAnnotation(urls.nextElement().getPath(), packageName);
        }
        
        //IOC实现, 自定注入
        IocUtil.inject();
    }
    //获取指定包路径下实现 Component主键Bean的实例
    private static void addClassByAnnotation(String filePath, String packageName) {
        try {
            File[] files = getClassFile(filePath);
            if (files != null) {
                for (File f : files) {
                    String fileName = f.getName();
                    if (f.isFile()) {
                        Class<?> clazz = Class.forName(packageName + "." + fileName.substring(0, fileName.lastIndexOf(".")));
                        //判断该类是否实现了注解
                        if(clazz.isAnnotationPresent(Component.class)) {
                            applicationContext.put(clazz, clazz.newInstance());
                        }
                    } else {
                        addClassByAnnotation(f.getPath(), packageName + "." + fileName);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //获取该路径下所遇的class文件和目录
    private static File[] getClassFile(String filePath) {
        return new File(filePath).listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                return file.isFile() && file.getName().endsWith(".class") || file.isDirectory();
            }
        });
    }
}
  1. 扫描加载指定包路径下的所有的Class,并判断该Class是否是@Component注解的类,如果是,则创建实例,并保存到applicationContext缓存中。
  2. 调用IocUtil.inject(),进行依赖注入。

7. Ioc 依赖注入实现

package cn.com.infcn.ioc;
import java.lang.reflect.Field;
import java.util.Map;
import java.util.Map.Entry;
import cn.com.infcn.annotation.Inject;
/**
 * Ioc 注入实现
 * 
 * @author jijs
 * @date 2017-12-3
 */
public class IocUtil {
    public static void inject() {
        Map<Class<?>, Object> map = IocContext.applicationContext;
        try {
            for (Entry<Class<?>, Object> entry : map.entrySet()) {
                Class<?> clazz = entry.getKey();
                Object obj = entry.getValue();
                Field[] fields = clazz.getDeclaredFields();
                for (Field field : fields) {
                    if (field.isAnnotationPresent(Inject.class)) {
                        Class<?> fieldClazz = field.getType();
                        field.setAccessible(true);
                        Object fieldObj = map.get(fieldClazz);
                        field.set(obj, fieldObj);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

循环变量 applicationContext中所有的Bean,判断每个Bean中是否有被@Inject注解修饰的属性,如果有则从applicationContext中获取要注入的实例,并使用反射实现自动注入功能。

8. 模拟调用UserController测试类

package cn.com.infcn;
import cn.com.infcn.controller.UserController;
import cn.com.infcn.ioc.IocContext;
/**
 * 模拟调用UserController
 * 
 * @author jijs
 * @date 2017-12-3
 */
public class Main {
    public static void main(String[] args) throws Exception {
        UserController userController = (UserController)IocContext.applicationContext.get(UserController.class);
        userController.getUser();
    }
}

从IocContext 容器中获取UserController实例,并调用getUser()方法。运行结果结果如下图。从结果中我们发现 UserController中的UserService被容器自动注入进来了。然后调用UserService.getUser() 获取用户信息。

运行结果

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏菩提树下的杨过

java调用.net asmx / wcf

一、先用asmx与wcf写二个.net web service: 1.1 asmx web服务:asmx-service.asmx.cs 1 using Sy...

2265
来自专栏精讲JAVA

接口方法上的注解无法被 @Aspect 声明的切面拦截的原因分析

在Spring中使用MyBatis的Mapper接口自动生成时,用一个自定义的注解标记在Mapper接口的方法中,再利用@Aspect定义一个切面,拦截这个注解...

2412
来自专栏菩提树下的杨过

spring mvc4的日期/数字格式化、枚举转换

日期、数字格式化显示,是web开发中的常见需求,spring mvc采用XXXFormatter来处理,先看一个最基本的单元测试:

1433
来自专栏小灰灰

动手实现MVC: 2. bean加载, IoC依赖注入

背景 前面实现了java包的扫描,扫描之后自然就到了bean的加载,以及spring mvc的一大特性 IoC依赖注入的实现; 这里则将在之前的基础上,实现be...

1917
来自专栏互联网研发闲思录

java简单框架设计

     设计框架包可以作为一个工具给大家用,需要有完全不同设计思路给出来,不同于我们去做一个web服务、网站、

1322
来自专栏微信公众号:Java团长

自己手写一个SpringMVC框架

前端框架很多,但没有一个框架称霸,后端框架现在Spring已经完成大一统。所以学习Spring是Java程序员的必修课。

882
来自专栏cmazxiaoma的架构师之路

SpringBoot之路(二)之Web进阶

3254
来自专栏菩提树下的杨过

java 利用JAX-RS快速开发RESTful 服务

JAX-RS(Java API for RESTful Web Services)同样也是JSR的一部分,详细规范定义见 https://jcp.org/en/...

2777
来自专栏码匠的流水账

聊聊rocketmq的NettyClientConfig

org/apache/rocketmq/remoting/netty/NettyClientConfig.java

1111
来自专栏小白鼠

SpringBoot几个注解MockMvcWireMockSwagger2@JsonViewHibernate Validator异常处理拦截方式上传下载异步处理RESTSpring Security

只有特定名称或者类型的Bean(通过@ConditionalOnMissingBean修饰)不存在于BeanFactory中时才创建某个Bean

2473

扫码关注云+社区