IOC分析

IOC是什么

控制反转（Inversion of Control，简称IOC）是一种软件设计原则，通过将对象的创建和管理的责任从使用者转移到第三方容器中，从而实现依赖管理和对象的生命周期控制。

如何理解控制反转

反转：依赖对象的获取被反转了，由自己创建，反转为从IOC容器中获取（和自动注入），也就是说，你不要来找我了，我去找你。传统的方式呢，是我在对象内部来去控制另外的对象，有了IOC，IOC是一个专门的容器，来创建和管理这些对象。

比如，我们平时找女朋友或者男朋友，就会想方设法的去打听他们的联系方式啊，爱好啊等等，这些东西啊都是需要我们自己去做的。IOC呢就好比婚介所啊，聊天交友群啊之类的，然后我们可以向他们提出我们的要求，身高体重，长相身材啊等等，这些介绍的中间人就会按照我们的要求去提供一个对象，然后我们和提供的这个对象谈恋爱就行了。

IOC能够带来什么好处

通过上述的简单描述可以知道，IOC有下面这些好处：

代码更加简洁，不需要自己去new使用的对象了，也做到了解耦

面向接口编程，使用者和具体者之间解耦，容易扩展和替换实现者

可以方便的进行AOP的增强

IOC容器是做什么工作的

IOC主要的工作就是创建、管理这些类的实例，然后可以向使用者提供这些实例

IOC容器是否是工厂模式的实例

是的，IOC负责来创建类的实例对象，需要的话就从IOC容器中获取，那么也可以称IOC容器为Bean工厂，生产的就是Bean实例

IOC设计实现

通过上面短短的信息，可以知道IOC容器既然是一个Bean工厂，那么是不是需要一个Bean工厂的接口，负责创建和获取这些bean呢？又怎么知道用户提供的bean是什么样的呢？是不是还需要一个接口来去定义这些Bean？Bean工厂和Bean定义的信息如何传递呢？是不是需要把Bean定义的信息告诉Bean工厂啊，那么可以定义一个注册接口，来作为Bean工厂和Bean定义之间沟通的桥梁

总结，设计IOC需要下面三个元素：

Bean工厂接口

Bean定义接口

Bean定义的注册接口

定义接口

一：Bean工厂接口

主要用来创建和获取Bean实例

/** * @ClassName BeanFactory * @Description: Bean工厂接口，负责创建和获取Bean * @Author TR * @Date 2021/3/25 * @Version V1.0 */public interface BeanFactory {    /** 获取bean */    Object getBean(String beanName) throws Exception;}

二：Bean定义的注册接口

Bean定义的注册接口中需要哪些方法呢？是不是需要能够注册和获取Bean定义的信息，那么注册的这些Bean定义信息还需要去区分它，那是不是给每个Bean定义，让它有一个唯一的名字就行了啊

/** * @ClassName BeanDefinitionRegistry * @Description: Bean定义的注册接口，作为Bean定义和Bean工厂之间的桥梁 * @Author TR * @Date 2021/3/25 * @Version V1.0 */public interface BeanDefinitionRegistry {    /** 注册Bean定义信息，beanName用来区分注册的Bean定义 */    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionRegisterException;    /** 获取Bean信息 */    BeanDefinition getBeanDefinition(String beanName);    /** 是否已经注册过了Bean定义 */    boolean containsBeanDefinition(String beanName);}/** * @ClassName BeanDefinitionRegisterException * @Description: 自定义异常类 * @Author TR * @Date 2021/3/25 * @Version V1.0 */public class BeanDefinitionRegisterException extends Exception {    public BeanDefinitionRegisterException(String message) {        super(message);    }    public BeanDefinitionRegisterException(String message, Throwable cause) {        super(message, cause);    }}

三：Bean定义接口

Bean定义它的用途是啥呢？就是告诉Bean工厂该如何去创建某个类的Bean

/** * @ClassName Beandefinition * @Description: Bean定义接口 * @Author TR * @Date 2021/3/25 * @Version V1.0 */public interface BeanDefinition {    /** 单例 */    String SCOPE_SINGLETON = "singleton";    /** 多例 */    String SCOPE_PROTOTYPE = "prototype";    /** 通过构造方法获取Bean */    Class
    getBeanClass();    /** 设置beanClass */    void setBeanClass(Class
    beanClass);    /** 通过静态工厂获取Bean */    String getFactoryMethodName();    /** 设置工厂方法名称 */    void setFactoryMethodName(String factoryMethodName);    /** 通过成员工厂获取Bean */    String getFactoryBeanName();    /** 设置工厂Bean名称 */    void setFactoryBeanName(String factoryBeanName);    /** 获取范围 */    String getScope();    /** 设置范围 */    void setScope(String scope);    /** 是不是单例的 */    boolean isSingleton();    /** 是不是多例的 */    boolean isPrototype();    /** 获取初始化方法 */    String getInitMethodName();    /** 设置初始化方法 */    void setInitMethodName(String initMethodName);    /** 获取销毁方法 */    String getDestroyMethodName();    /** 设置销毁方法 */    void setDestroyMethodName(String destroyMethodName);    /** 验证方法 */    default boolean validate() {        //没有定义BeanClass，或者没有指定工厂方法或工厂bean，则不合法        if (getBeanClass() == null) {            if (StringUtils.isBlank(this.getFactoryMethodName())                    || StringUtils.isBlank(this.getFactoryBeanName())) {                return false;            }        }        //定义了类，又定义了工厂bean，则不合法        if (getBeanClass() != null && StringUtils.isNoneBlank(this.getFactoryBeanName())) {            return false;        }        return true;    };}

实现接口

一：Bean定义的实现GenericBeanDefinition

/** * @ClassName GenericBeanDefinition * @Description: Bean定义的实现类 * @Author TR * @Date 2021/3/25 * @Version V1.0 */public class GenericBeanDefinition implements BeanDefinition {    private Class
    beanClass;    private String factoryMethodName;    private String factoryBeanName;    private String initMethodName;    private String destroyMethodName;    private String scope = BeanDefinition.SCOPE_SINGLETON;    @Override    public Class
    getBeanClass() {        return beanClass;    }    @Override    public void setBeanClass(Class
    beanClass) {        this.beanClass = beanClass;    }    @Override    public String getFactoryMethodName() {        return factoryMethodName;    }    @Override    public void setFactoryMethodName(String factoryMethodName) {        this.factoryMethodName = factoryMethodName;    }    @Override    public String getFactoryBeanName() {        return factoryBeanName;    }    @Override    public void setFactoryBeanName(String factoryBeanName) {        this.factoryBeanName = factoryBeanName;    }    @Override    public String getScope() {        return scope;    }    @Override    public void setScope(String scope) {        this.scope = scope;    }    @Override    public boolean isSingleton() {        return scope.equals(BeanDefinition.SCOPE_SINGLETON);    }    @Override    public boolean isPrototype() {        return scope.equals(BeanDefinition.SCOPE_PROTOTYPE);    }    @Override    public String getInitMethodName() {        return initMethodName;    }    @Override    public void setInitMethodName(String initMethodName) {        this.initMethodName = initMethodName;    }    @Override    public String getDestroyMethodName() {        return destroyMethodName;    }    @Override    public void setDestroyMethodName(String destroyMethodName) {        this.destroyMethodName = destroyMethodName;    }    @Override    public String toString() {        return "GenericBeanDefinition{" +                 "beanClass=" + beanClass +                 ", factoryMethodName='" + factoryMethodName + '\'' +                 ", factoryBeanName='" + factoryBeanName + '\'' +                 ", initMethodName='" + initMethodName + '\'' +                 ", destroyMethodName='" + destroyMethodName + '\'' +                 ", scope='" + scope + '\'' +                 '}';    }}

二：Bean工厂的实现DefaultBeanFactory

/** * @ClassName DefaultBeanFactory * @Description: Bean工厂的实现类 * @Author TR * @Date 2021/3/25 * @Version V1.0 */public class DefaultBeanFactory implements BeanFactory, BeanDefinitionRegistry, Closeable {    /** Bean定义缓存 */    private Map
   
     beanDefinitionMap = new ConcurrentHashMap<>();    /** Bean缓存 */    private Map
    
      beanMap = new ConcurrentHashMap<>();    @Override    public Object getBean(String beanName) throws Exception {        return doGetBean(beanName);    }    private Object doGetBean(String beanName) throws Exception {        //先去缓存里面判断一下，对应的beanName的对象是不是已经创建好了        Object bean = beanMap.get(beanName);        if (bean != null) {            return bean;        }        BeanDefinition bd = beanDefinitionMap.get(beanName);        Objects.requireNonNull(bd, "招不到【" + beanName + "】的Bean定义信息");        Class
      beanClass = bd.getBeanClass();        if (beanClass != null) {            //通过构造函数构建对象            if (StringUtils.isBlank(bd.getFactoryMethodName())) {                bean = createBeanByConstructor(bd);            } else {                //通过静态工厂构建对象                bean = createBeanByStaticFactory(bd);            }        } else {            //通过成员工厂构建对象            bean = createBeanByFactoryBean(bd);        }        //开始bean的生命周期        if (StringUtils.isNotBlank(bd.getInitMethodName())) {            doInitMethod(bean, bd);        }        //对单例bean的处理        if (bd.isSingleton()) {            beanMap.put(beanName, bean);        }        return bean;    }    /** bean */    private void doInitMethod(Object bean, BeanDefinition bd) throws Exception {        Method method = bean.getClass().getMethod(bd.getInitMethodName(), null);        method.invoke(bean, null);    }    /** 通过成员工厂构建对象 */    private Object createBeanByFactoryBean(BeanDefinition bd) throws Exception {        //获取工厂bean名称        String factoryBeanName = bd.getFactoryBeanName();        //获取工厂bean        Object factoryBean = getBean(factoryBeanName);        //获取工厂方法        String factoryMethodName = bd.getFactoryMethodName();        Method method = factoryBean.getClass().getMethod(factoryMethodName, null);        Object object = method.invoke(factoryBean, null);        return object;    }    /** 通过静态工厂构建对象 */    private Object createBeanByStaticFactory(BeanDefinition bd) throws Exception {        //获取工厂类名        Class
      type = bd.getBeanClass();        //获取工厂方法名称        String factoryMethodName = bd.getFactoryMethodName();        Method method = type.getMethod(factoryMethodName, null);        Object object = method.invoke(type, null);        return object;    }    /** 通过构造函数构建对象 */    private Object createBeanByConstructor(BeanDefinition bd) throws Exception {        //获取类名        Class
      type = bd.getBeanClass();        //实例化bean        Object bean = type.newInstance();        return bean;    }    @Override    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionRegisterException {        Objects.requireNonNull(beanName, "注册bean需要指定beanName");        Objects.requireNonNull(beanDefinition, "注册bean需要指定beanDefinition");        if (!beanDefinition.validate()) {            throw new BeanDefinitionRegisterException("名字为【" + beanName + "】的beanName不合法，" + beanDefinition);        }        if (containsBeanDefinition(beanName)) {            throw new BeanDefinitionRegisterException("名字为【" + beanName + "】的beanName已经注册过了，" + beanName);        }        beanDefinitionMap.put(beanName, beanDefinition);    }    @Override    public BeanDefinition getBeanDefinition(String beanName) {        return beanDefinitionMap.get(beanName);    }    @Override    public boolean containsBeanDefinition(String beanName) {        return beanDefinitionMap.containsKey(beanName);    }    @Override    public void close() throws IOException {        // 针对单例Bean执行销毁方法        for (Map.Entry
     
       e : beanDefinitionMap.entrySet()) {            String beanName = e.getKey();            BeanDefinition definition = e.getValue();            if (definition.isSingleton() && StringUtils.isNotBlank(definition.getDestroyMethodName())) {                Object instance = beanMap.get(beanName);                if (instance == null) {                    continue;                }                Method m = null;                try {                    m = instance.getClass().getMethod(definition.getDestroyMethodName(), null);                    m.invoke(instance, null);                } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ex) {                    ex.printStackTrace();                }            }        }    }}

测试一下

测试构造方法注册Bean

public interface Boy {    void sayLove();}

Lad实现类

public class Lad implements Boy {    @Override    public void sayLove() {        System.out.println("我爱你，亲爱的！" + hashCode());    }    //初始化方法    public void init() {        System.out.println("老天赐予我一个对象吧！");    }    //销毁方法    public void destroy() {        System.out.println("自古多情空余恨，此恨绵绵无绝期！");    }}

BoyFactory类

public class BoyFactory {    public static Boy getBean() {        return new Lad();    }}

BoyFactoryBean实现类

public class BoyFactoryBean {    public Boy buildBoy() {        return new Boy() {            @Override            public void sayLove() {                System.out.println("我爱你，大妹子！" + hashCode());            }        };    }}

测试类

public class TestDemo {    static DefaultBeanFactory factory = new DefaultBeanFactory();    /** 测试构造方法注册Bean */    @Test    public void testRegister() throws Exception {        GenericBeanDefinition definition = new GenericBeanDefinition();        definition.setBeanClass(Lad.class);        definition.setScope(BeanDefinition.SCOPE_SINGLETON);        definition.setInitMethodName("init");        definition.setDestroyMethodName("destroy");        factory.registerBeanDefinition("lad", definition);    }    /** 测试静态工厂注册Bean */    @Test    public void testRegisterStaticFactoryMethod() throws Exception {        GenericBeanDefinition definition = new GenericBeanDefinition();        definition.setBeanClass(BoyFactory.class);        definition.setFactoryMethodName("getBean");        factory.registerBeanDefinition("staticFactoryBoy", definition);    }    /** 测试成员方法注册Bean */    @Test    public void testRegisterFactoryMethod() throws Exception {        GenericBeanDefinition definition = new GenericBeanDefinition();        definition.setBeanClass(BoyFactoryBean.class);        String fBeanName = "boyFactoryBean";        factory.registerBeanDefinition(fBeanName, definition);        GenericBeanDefinition factoryDefinition = new GenericBeanDefinition();        factoryDefinition.setFactoryBeanName(fBeanName);        factoryDefinition.setFactoryMethodName("buildBoy");        factoryDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);        factory.registerBeanDefinition("factoryBoy", factoryDefinition);    }    @AfterClass    public static void testGetBean() throws Exception {        System.out.println("构造方法方式------------");        for (int i = 0; i < 3; i++) {            Boy boy = (Boy) factory.getBean("lad");            boy.sayLove();        }        System.out.println("静态工厂方法方式------------");        for (int i = 0; i < 3; i++) {            Boy ab = (Boy) factory.getBean("staticFactoryBoy");            ab.sayLove();        }        System.out.println("工厂方法方式------------");        for (int i = 0; i < 3; i++) {            Boy ab = (Boy) factory.getBean("factoryBoy");            ab.sayLove();        }        factory.close();    }}

执行后输出结果

可以看到构造方法获取的Bean它的hashCode是一样的，即是单例的；成员方法设置了多例，看到的是hashCode是不一样的

转载地址：http://lliuz.baihongyu.com/

你可能感兴趣的文章