创建注入框架（1）

之所以讲jsr330，就是我们要基于这个标准api提供来创建框架。接下来我们就按照这套api一步一步去实现。 首先创建一个maven项目，pom文件内容是：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>zhuru</groupId>
    <artifactId>zhuru</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        
        <dependency>
            <groupId>javax.inject</groupId>
            <artifactId>javax.inject</artifactId>
            <version>1</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>

        </plugins>
    </build>

</project>

我们从底部往前慢慢搭建这个框架，第一个需要创建的类是一个解析class的类，粗布的解决方案比较粗糙，代码如下

ParseClass.java

public class ParseClass<T> {

    private Class<T> tClass;

    private Container container;

    public ParseClass(Class<T> tClass,Container container) {
        this.tClass = tClass;
        this.container = container;
    }

    @SuppressWarnings("unchecked")
    public <K extends T> T newInstance()
            throws IllegalAccessException, InvocationTargetException, InstantiationException {
        if (!container.hasRegisted(tClass)) {
            return null;
        }
        Class<K> implement = container.getImpl(tClass);
        Constructor[] constructors = implement.getConstructors();
        if (constructors.length == 0){
            //没有构造器
            throw new NoConstructorsError();
        }
        T instance = null;
        for (Constructor<K> constructor:constructors) {
            if (constructor.getParameterCount() == 0) {
                instance = constructor.newInstance();
                break;
            }
            if (constructor.isAnnotationPresent(Inject.class)) {
                //获得此构造函数的参数
                Object[] params = new Object[constructor.getParameterCount()];
                int j = 0;
                for (Class z: constructor.getParameterTypes()){
                    Object param = new ParseClass<>(z,container).newInstance();
                    params[j++] = param;
                }
                instance = constructor.newInstance(params);
                break;
            }
        }
        if (instance != null) {
            initFields(instance,implement);
            initMethod(instance,implement);
            return instance;
        }
        return null;
    }

    private <K extends T> void initFields(T instance, Class<K> kClass)
            throws IllegalAccessException, InstantiationException, InvocationTargetException {
        for (Field field : kClass.getDeclaredFields()) {
            if (field.isAnnotationPresent(Inject.class)) {
//                System.out.println(field.getDeclaringClass());
                Object value = new ParseClass<>(field.getType(),container).newInstance();
//                System.out.println(field.getType().isInstance(value));
                field.setAccessible(true);
                field.set(instance,value);
                field.setAccessible(false);
            }
        }
    }

    @SuppressWarnings("unchecked")
    private <K extends T> void initMethod(T instance, Class<K> kClass) throws IllegalAccessException, InstantiationException, InvocationTargetException {
        for (Method method : kClass.getMethods()) {
            if (method.isAnnotationPresent(Inject.class)) {
                Object[] params = new Object[method.getParameterCount()];
                int j = 0;
                for (Class z: method.getParameterTypes()) {
                    params[j++] = new ParseClass<>(z,container).newInstance();
                }
                method.invoke(instance,params);
            }
        }
    }

}

Container.java

public class Container {

    //利用一个容器来存储类
    private Map<Class,Class> mapper;

    public Container() {
        mapper = new HashMap<>();
    }

    public <T,K extends T> void registerClass(Class<T> inter, Class<K> impl) {
        mapper.put(inter,impl);
    }

    @SuppressWarnings("unchecked")
    public <T,K extends T> Class<K> getImpl(Class<T> inter) {
        return mapper.get(inter);
    }

    public boolean hasRegisted(Class inter) {
        return mapper.containsKey(inter);
    }

}

定义了一个异常类:NoConstructorsError.java

public class NoConstructorsError extends RuntimeException {

    public NoConstructorsError() {
        super("没有声明公开的构造器");
    }
}

可以多定义几个异常，弄成RuntimeException，让最终使用用户不用自己去捕获

做了几个测试，还行得通，但有几点需要注意： 第一：封装性不够好，这样很容易出错 第二：对于某些没提供构造函数的类我们无能为力，事实上很多类我们这个都操作不了，这时候需要Provider接口了 第三：每次碰到inject我们都要进行一次构造，对于单例对象来说这个不能满足了。 接下来围绕着三点进行加工。

 

这些文章也同步到了我自己的公众号平台：互联网科技杂谈

转载于:https://my.oschina.net/mylgb634335272/blog/777577