自己模拟实现spring ioc原理

JSON配置文件的数据结构:

package light.zhang.ioc.bean; import java.io.Serializable; import java.util.List; import lombok.Data; import lombok.ToString; /** * 数据结构 * @author witts */ @Data @ToString public class Beandefinition implements Serializable{ /** * 序列ID */
    private static final long serialVersionUID = -1723354830429118453L; /**BeanName参数**/
    private String beanName; private String className; private String interfaceName; private List<ConstructorArg> ConstructorArgs; private List<PropertyArg> PropertyArgs; }

参数注入类:

package light.zhang.ioc.bean; import java.io.Serializable; import lombok.Data; @Data public class ConstructorArg implements Serializable { private static final long serialVersionUID = -1094744504486782050L; private String ref; }

package light.zhang.ioc.bean; import java.io.Serializable; public class PropertyArg implements Serializable { private static final long serialVersionUID = 4398781604716858284L; }

读取json配置文件:

package light.zhang.ioc.client; import java.io.InputStream; import java.util.List; import com.fasterxml.jackson.core.type.TypeReference; import light.zhang.ioc.bean.Beandefinition; import light.zhang.ioc.core.ApplicationContextFactory; import light.zhang.ioc.utils.JsonUtils; /** * 通过json格式的方式来存储注册信息,然后让IOC容器管理对象 * @author witts */
public class JsonApplicationContext extends ApplicationContextFactory { private String fileName; public JsonApplicationContext(String fileName) { this.fileName = fileName; initFile(); } private void initFile(){//读取文件,并注册到容器
        InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(fileName);//读取配置文件信息
        List<Beandefinition> beanDefinitions = JsonUtils.readValue(is,new TypeReference<List<Beandefinition>>(){}); if(beanDefinitions != null && !beanDefinitions.isEmpty()) { for (Beandefinition beanDefinition : beanDefinitions) { registerBean(beanDefinition.getBeanName(), beanDefinition);//注册
 } } } }

 通过名称得到bean:

package light.zhang.ioc.core; import light.zhang.ioc.exception.CreateBeanException; import light.zhang.ioc.exception.LoadBeanException; public interface ApplicationContext { /** * 通过bean获取到注册的实例信息 * @param name * @throws Exception * @throws LoadBeanException * @throws CreateBeanException */
    public Object getBean(String name) throws IllegalAccessException; }

负责bean生命周期管理,加载-实例-注册-销毁等

package light.zhang.ioc.core; import java.lang.reflect.Field; import java.util.ArrayList; import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import light.zhang.ioc.bean.Beandefinition; import light.zhang.ioc.bean.ConstructorArg; import light.zhang.ioc.exception.CreateBeanException; import light.zhang.ioc.exception.LoadBeanException; import light.zhang.ioc.utils.BeanUtils; import light.zhang.ioc.utils.ClassLoaderUtils; import light.zhang.ioc.utils.ReflectionUtils; /** * 主要负责对加载到Map里面的对象取舍 beanDefineMap 存储的是对象的名称和对象对应的数据结构的映射。bean 用于保存 * beanName和实例化之后的对象。 容器初始化的时候，会调用 BeanRegisterFactoryImpl.registerBean 方法。把 * 对象的 Beandefinition 数据结构，存储起来 当我们调用 getBean() 的方法的时候。会先到 beanMap * 里面查找，有没有实例化好的对象。如果没有， 就会去beanDefineMap查找这个对象对应的 * BeanDefination。再利用DeanDefination去实例化一个对象。 对象实例化成功以后，我们还需要注入相应的参数，调用 * populatebean()这个方法。在 populateBean 这个方法中， 会扫描对象里面的Field，如果对象中的 Field * 是我们IoC容器管理的对象，那就会调用 我们上文实现的 ReflectionUtils.injectField来注入对象。 * 一切准备妥当之后，我们对象就完成了整个 IoC 流程。最后这个对象放入 beanMap 中,方便下一次使用。 所以我们可以知道 BeanFactory 是管理和生成对象的地方。 */
public class ApplicationContextFactory  implements ApplicationContext { private static final Logger logger=LoggerFactory.getLogger(ApplicationContextFactory.class); private static final ConcurrentHashMap<String, Object> beanMap = new ConcurrentHashMap<String, Object>(); private static final ConcurrentHashMap<String, Beandefinition> undefineMap = new ConcurrentHashMap<String, Beandefinition>(); private static final Set<Object> beanNameSet = Collections.synchronizedSet(new HashSet<Object>());// 同步的hash set
 @Override public Object getBean(String name) throws IllegalAccessException { Object bean = null; bean = beanMap.get(name);// 在已经注册过的情况下通过名称获取注册的实例
        if (null != bean) { return bean; } bean = createBean(undefineMap.get(name)); // 如果没有实例化，那就需要调用createBean来创建对象,第一次加载的情况
        if (bean != null) { // 对象创建成功以后，注入对象需要的参数 
 populatebean(bean); // 再把对象存入Map中方便下次使用。
 beanMap.put(name, bean); } // 结束返回
        logger.debug("This "+name+" is managed by ioc!!!"); return bean; } /** * 注册bean到IOC容器里面 * * @param name * @param bean */
    protected void registerBean(String name, Beandefinition bean) { undefineMap.put(name, bean);// 先注册
        beanNameSet.add(name);// 添加注册信息
 } /** * 主要负责对参数的初始化 * * @param bean * @throws IllegalAccessException * @throws Exception * @throws LoadBeanException * @throws CreateBeanException */
    private void populatebean(Object bean) throws IllegalAccessException { Field[] fields = bean.getClass().getSuperclass().getDeclaredFields();// 获取的代理对象信息
        if (fields != null && fields.length > 0) {// 存在代理对象
            for (Field field : fields) { String beanName = field.getName(); beanName = StringUtils.uncapitalize(beanName);// beanName字符串的第一个字符，转换为小写
                if (beanNameSet.contains(field.getName())) {// 当包从IOC容器检测到注册信息之后
                    Object fieldBean = getBean(beanName);// 获取实例
                    if (fieldBean != null) { ReflectionUtils.initParamter(field, bean, fieldBean);// 初始化参数信息
 } } } } } /** * 创建bean实例 * * @param beanDefinition * @return * @throws IllegalAccessException * @throws LoadBeanException * @throws Exception */
    private Object createBean(Beandefinition beanDefinition) throws IllegalAccessException { if(null == beanDefinition) { try { throw new CreateBeanException(); } catch (CreateBeanException e) { e.printStackTrace(); } } String beanName = beanDefinition.getClassName(); Class<?> classInfo = ClassLoaderUtils.loaderClass(beanName); if (classInfo == null) { try { throw new LoadBeanException(); } catch (LoadBeanException e) { e.printStackTrace(); } } List<ConstructorArg> constructorArgs = beanDefinition.getConstructorArgs();// 获取参数列表
        if (constructorArgs != null && !constructorArgs.isEmpty()) { List<Object> objects = new ArrayList<Object>(); for (ConstructorArg constructorArg : constructorArgs) { objects.add(getBean(constructorArg.getRef()));// ref引用信息
 } try { return BeanUtils.instanceCreate(classInfo, classInfo.getConstructor(), objects.toArray());// 有参数的注入
            } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (SecurityException e) { e.printStackTrace(); } } else { return BeanUtils.instanceCreate(classInfo, null, null);// 没有参数
 } return null; } }

创建对象时异常

package light.zhang.ioc.exception; /** * 创建时异常 * @author witts * */
public class CreateBeanException extends Throwable { private static final long serialVersionUID = 1L; public CreateBeanException() { super("create bean fail,bean name is not found!!!"); } /** * 创建bean异常 * @param exc */
    public CreateBeanException(String exc) { super(exc); } }

加载bean异常

package light.zhang.ioc.exception; /** * 加载时异常 * @author witts */
public class LoadBeanException extends Throwable{ private static final long serialVersionUID = 8520827571307312752L; @Override public synchronized Throwable fillInStackTrace() { return super.fillInStackTrace(); } public LoadBeanException() { super("load bean exception,bean not found!!!"); } public LoadBeanException(String message) { super(message); } }

bean工具类:

package light.zhang.ioc.utils; import java.lang.reflect.Constructor; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.NoOp; /** * 主要负责处理对BEAN的管理,BEAN的初创建,始化,状态管理 * @author witts */
public class BeanUtils { /** * 动态代理,并创建类 * @param clas * @param constructor * @param args * @return
     */
    public static Object instanceCreate(Class<?> clas,Constructor<?> constructor,Object[] args) { /** * Enhancer允许为非接口类型创建一个Java代理。Enhancer动态创建了给定类型的子类但是拦截了所有的方法。和Proxy不一样的是，不管是接口还是类他都能正常工作 */ Enhancer enhancer=new Enhancer(); enhancer.setSuperclass(clas);//代理类
        enhancer.setCallback(NoOp.INSTANCE);//代理类型>初始化实例
        if(null == constructor) { return enhancer.create();//默认创建无参数实例
        }else { return enhancer.create(constructor.getParameterTypes(),args);//带参数的初始化
 } } }

类装载工具类:

package light.zhang.ioc.utils; /** * 主要负责读取配置文件,装载类信息 * @author witts * */
public class ClassLoaderUtils { /**创建读取配置信息的对象**/
    public static ClassLoader install() { return Thread.currentThread().getContextClassLoader(); } /**装载class**/
    public static Class<?> loaderClass(String className) { try { return install().loadClass(className);//通过配置文件装载类信息
        }catch (ClassNotFoundException e) { e.printStackTrace(); } return null; } }

json工具类:

package light.zhang.ioc.utils; import java.io.InputStream; import java.text.SimpleDateFormat; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.MapperFeature; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.SerializationFeature; public class JsonUtils { private static final ObjectMapper mapper = new ObjectMapper(); private JsonUtils() { } public static ObjectMapper getObjectMapper() { return mapper; } public static <T> T readValue(String json, Class<T> cls) { try { return mapper.readValue(json, cls); } catch (Exception var3) { return null; } } public static <T> T readValue(InputStream is,Class<T> cls){ try{ return mapper.readValue(is,cls); }catch (Exception e){ return null; } } public static <T> T readValue(byte[] bytes, Class<T> cls) { try { return mapper.readValue(bytes, cls); } catch (Exception var3) { return null; } } public static <T> T readValue(String json, TypeReference<?> valueTypeRef) { try { return mapper.readValue(json, valueTypeRef); } catch (Exception var3) { return null; } } public static <T> T readValue(byte[] bytes, TypeReference<?> valueTypeRef) { try { return mapper.readValue(bytes, valueTypeRef); } catch (Exception var3) { return null; } } public static <T> T readValue(InputStream is,TypeReference<?> valueTypeRef){ try{ return mapper.readValue(is,valueTypeRef); }catch (Exception e){ return null; } } public static String writeValue(Object entity) { try { return mapper.writeValueAsString(entity); } catch (Exception var2) { return null; } } public static byte[] writeByteValue(Object entity) { try { return mapper.writeValueAsBytes(entity); } catch (Exception var2) { return null; } } static { mapper.enable(SerializationFeature.INDENT_OUTPUT); mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS); mapper.setSerializationInclusion(JsonInclude.Include.USE_DEFAULTS); mapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT); mapper.getDeserializationConfig().withoutFeatures(new DeserializationFeature[]{DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES}); mapper.configure(MapperFeature.ALLOW_COERCION_OF_SCALARS, true); mapper.configure(MapperFeature.ALLOW_EXPLICIT_PROPERTY_RENAMING,true); mapper.configure(MapperFeature.ALLOW_FINAL_FIELDS_AS_MUTATORS, true); mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")); mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false); mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); } }

反射类:

package light.zhang.ioc.utils; import java.lang.reflect.Field; /** * 主要通过 Java 的反射原理来完成对象的信息注入 * @author witts */
public class ReflectionUtils { /** * 初始化参数信息 * @param field * @param key * @param val * @throws IllegalAccessException */
        public static void initParamter(Field field,Object key,Object val) throws IllegalAccessException { if(null !=field) { field.setAccessible(Boolean.TRUE); field.set(key, val);//注入参数信息
 } } }

客户端调用

package light.zhang.ioc.test; import junit.framework.TestCase; import light.zhang.ioc.client.JsonApplicationContext; import light.zhang.ioc.core.ApplicationContext; /** * 模拟spring ioc对象创建管理销毁 * @author witts * */
public class AppTest extends TestCase { private static final ApplicationContext applicationContext=new JsonApplicationContext("application.json"); //读取配置文件
     
     public static void main(String[] args) { try { Robot aiRobot; aiRobot =  (Robot) applicationContext.getBean("robot");//获取对象
            aiRobot.show();//调用对象功能
        } catch (Exception e) { e.printStackTrace(); } } }

需要被管理的对象

package light.zhang.ioc.test; public class Hand { public void waveHand(){ System.out.println("hand out message"); } }

package light.zhang.ioc.test; public class Mouth { public void speak(){ System.out.println("Mouth out message"); } }

package light.zhang.ioc.test; public class Robot { //需要注入 hand 和 mouth,容器自动注入对象并实例化
    private Hand hand; private Mouth mouth; public void show(){ hand.waveHand(); mouth.speak(); } }

主要是理解spring ioc的加载-实例-注册-销毁等一系列的对象生命周期管理,我这里只是模仿一下spring对对象的加载,创建,注册 对象销毁是个复杂的过程,并不是那么容器就模拟出来的,

spring管理的对象方式有很多种,

本来是由应用程序管理的对象之间的依赖关系，现在交给容器管理，这就是控制反转，及交给Ioc容器。Spring的IoC主要使用DI方式实现，

不需要主动查找，对象的查找、定位和创建全部由容器管理。spring中有三种注入方式，一种是set注入，一种是接口注入，另一种是构造方法注入