从零开始写javaweb框架笔记14-搭建轻量级JAVAWEB框架-实现Bean容器

实现Bean容器

   使用ClassHelper可以获取所加载的类，但无法通过类来实例化对象，因此我们需要提供一个反射工具类，让它封装java反射相关的API，对外提供更好用的工具方法。将该类命名为ReflectionUtil，代码如下：

package org.smart4j.framework.org.smart4j.framework.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * Created by jack on 2017/5/23.
 * 放射工具类
 */
public class ReflectionUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(ReflectionUtil.class);

    /**
     * 创建实例
     */
    public static Object newInstance(Class<?> cls) {
        Object instance;
        try {
            instance = cls.newInstance();
        } catch (Exception e) {
            LOGGER.error("new instance failue", e);
            throw new RuntimeException(e);
        }
        return instance;
    }

    /**
     * 调用方法
     */
    public static Object invokeMethod(Object obj, Method method, Object... args) {
        Object result;
        method.setAccessible(true);
        try {
            result = method.invoke(obj,args);
        } catch (Exception e) {
            LOGGER.error("invoke method failure",e);
            throw new RuntimeException(e);
        }
        return result;
    }

    /**
     * 设置成员变量的值
     */
    public static void setField(Object obj, Field field,Object value){

        try {
            field.setAccessible(true);
            field.set(obj,value);
        } catch (IllegalAccessException e) {
            LOGGER.error("set field failue",e);
            throw new RuntimeException(e);
        }
    }
}

    我们需要获取所有被smart框架管理的bean类，此时需要调用ClassHelper类的getBeanClassSet方法，随后需要循环调用ReflectionUtil的newInstance方法，根据类来实例化对象，最后将每次创建的对象保存在一个静态的Map<Class<?>,Object>中，我们需要随时获取该Map，还需要根据该Map的key（类名）去获取对应的value

（bean对象），BeanHelper类代码如下：

package org.smart4j.framework.helper;

import org.smart4j.framework.org.smart4j.framework.util.ReflectionUtil;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * Created by jack on 2017/5/23.
 * bean 助手类
 */
public class BeanHelper {
    /**
     * 定义bean映射，（用于存放bean类与bean实例的映射关系）
     */
    private static final Map<Class<?>,Object> BEAN_MAP = new HashMap<Class<?>, Object>();

    /**
     * 静态代码块
     */
    static {
        Set<Class<?>> beanClassSet = ClassHelper.getBeanClassSet();
        for (Class<?> beanClass : beanClassSet) {
            Object object = ReflectionUtil.newInstance(beanClass);
            BEAN_MAP.put(beanClass,object);
        }
    }

    /**
     * 获取Bean映射
     */
    public static Map<Class<?>,Object> getBeanMap(){
        return BEAN_MAP;
    }

    /**
     * 获取Bean实例
     */
    public static <T> T getBean(Class<?> cls){
        if (!BEAN_MAP.containsKey(cls)){
            throw new RuntimeException("can not get bean by class:"+cls);
        }
        return (T) BEAN_MAP.get(cls);
    }
}

    现在，BeanHelper就相当于一个“Bean”容器了，因为在Bean map中存放了Bean类和Bean实例的对应关系，我们只需要调用getBean方法，传入一个Bean类，就能获取Bean实例。