目录
相信很多朋友对Spring已经很熟悉了，面试中也经常会被问到Spring里面相关的知识，比如IOC、DI、AOP等，下面通过手写IOC的方式来对IOC里面相关的内容，进行熟悉和理解
IOC分析
IOC是什么
Inversion of Control 控制反转，也称依赖倒置（反转）
如何理解这个控制反转呢？
反转：依赖对象的获得被反转了，由自己创建，反转为从IOC容器中获取（和自动注入）；
也就是说，你不要来找我了，我去找你，传统的方式呢，是我在对象内部来去控制另外的对象，有了IOC，IOC是一个专门的容器，来创建和管理这些对象
比如，我们平时找女朋友或者男朋友，就会想方设法的去打听他们的联系方式啊，爱好啊等等，这些东西啊都是需要我们自己去做的。IOC呢就好比婚介所啊，聊天交友群啊之类的，然后我们可以向他们提出我们的要求，身高体重，长相身材啊等等，这些介绍的中间人就会按照我们的要求去提供一个对象，然后我们和提供的这个对象谈恋爱就行了
IOC能够带来什么好处
通过上述的简单描述可以知道，IOC有下面这些好处：
- 代码更加简洁，不需要自己去new使用的对象了，也做到了解耦
- 面向接口编程，使用者和具体者之间解耦，容易扩展和替换实现者
- 可以方便的进行AOP的增强
IOC容器是做什么工作的
IOC主要的工作就是创建、管理这些类的实例，然后可以向使用者提供这些实例
IOC容器是否是工厂模式的实例
是的，IOC负责来创建类的实例对象，需要的话就从IOC容器中get，那么也可以称IOC容器为Bean工厂，生产的就是Bean实例
IOC设计实现
设计IOC需要什么
通过上面短短的信息，可以知道IOC容器既然是一个Bean工厂，那么是不是需要一个Bean工厂的接口，负责创建和获取这些bean呢？
又怎么知道用户提供的bean是什么样的呢？是不是还需要一个接口来去定义这些Bean？
Bean工厂和Bean的定义接口都有了，那么Bean工厂又怎么知道该如何创建Bean，是不是需要把Bean定义的信息告诉Bean工厂啊，那么可以定义一个注册接口，来作为Bean工厂和Bean定义之间沟通的桥梁
总结，设计IOC需要下面三个元素：
1. Bean工厂接口
2. Bean定义接口
3. 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
获取类的实例有下面几种方式：
1. new 构造方法
User user = new User()
2. 工厂方法：静态工厂
public class UserFactory {
public static User getUser() {
return new User();
}
}
3. 工厂方法：成员方法
public class UserFactory {
public User getUser() {
return new User();
}
}
Bean工厂帮助我们创建Bean的时候需要知道哪些信息呢？
5. 通过new构造方法的话，需要知道类名
6. 通过静态工厂方法，需要知道工厂类名、工厂方法名
7. 通过成员工厂方法，需要知道工厂bean名、工厂方法名
那么每次从Bean工厂获取bean的实例时，是不是都需要创建一个新的bean呢？肯定不是啊，有的只需要单例的就行
Bean定义信息是需要告诉Bean工厂如何创建Bean的，那么Bean定义需要向Bean工厂提供一些方法：
- 获取Bean的类名：getBeanClass():Class
- 获取工厂方法名：getFactoryMethodName():String
- 获取工厂Bean名：getFactoryBeanName():String
- 是不是单例，作用范围等：getScope():String、isSingleton()、isPrototype()
提供上述的几种方法是不是就足够了呢？类对象的生命周期还会有什么呢？
- 创建对象后是不是还需要一些初始化：getInitMethodName():String
- 比如有些对象在销毁时还需要进行一些特定的销毁逻辑（如释放资源）：getDestroyMethodName():String
那么提供上面的初始化方法和销毁方法，供用户使用，对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);
/**
* 验证方法：
* 用来在注册Bean定义的时候验证是否可以注册
*/
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类
一：Bean定义的实现GenericBeanDefinition
Bean定义的实现类，相对来说比较简单，主要做的事情就是获取和设置Bean定义信息
/**
* @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
接下来需要实现Bean工厂，让它可以初步的工作起来
首先思考一下，创建的bean定义信息是不是需要存起来啊，那么定义一个Map来缓存Bean定义的信息
/** Bean定义缓存 */
private Map<String, BeanDefinition> beanDefinitionMap
= new ConcurrentHashMap<>();
创建好的Bean也需要存放起来，方便下一次获取
/** Bean缓存 */
private Map<String, Object> beanMap = new ConcurrentHashMap<>();
在getBean中需要做一些事情，创建Bean实例，然后可以初始化
public class DefaultBeanFactory
implements BeanFactory, BeanDefinitionRegistry {
@Override
public Object getBean(String beanName) throws Exception {
return doGetBean(beanName);
}
}
接下来实现doGetBean方法：
通过上面的叙述，可以知道创建一个Bean实例有三种方法：通过构造方法、通过静态工厂、通过成员工厂方法，代码如下：
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;
}
代码逻辑：首先去beanMap里面拿Bean，如果已经存在了就直接返回了；然后根据beanName获取bean定义信息，后面加了一个根据beanName如果获取不到bean定义的非空判断；然后就是获取beanClass，如果说beanClass不等于空，工厂方法名字为空，那么可以知道这个是根据构造方法来创建Bean的；如果工厂方法非空，即是根据静态工厂创建Bean；如果beanClass是空的，那么可以断定是根据成员方法来创建Bean的
1. 通过构造方法创建Bean
首先肯定是要获取到类名，然后根据newInstance实例化Bean，最后返回就可以了
/** 通过构造方法构建对象 */
private Object createBeanByConstructor(BeanDefinition bd) throws Exception {
//获取类名
Class<?> type = bd.getBeanClass();
//实例化bean
Object bean = type.newInstance();
return bean;
}
2. 通过静态工厂创建Bean
静态工厂创建Bean，是根据类.方法名来创建的，首先也是获取到类名，然后就是获取工厂方法名，根据getMethod获取到方法，然后调用方法进行实例化
/** 通过静态工厂构建对象 */
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;
}
3. 通过成员工厂创建Bean
成员工厂创建Bean，首先要获取到的就是工厂Bean，然后再获取工厂方法，最后根据getMethod获取到方法，然后调用方法进行实例化
/** 通过成员工厂构建对象 */
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;
}
下面是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);
}
代码逻辑：注册Bean定义信息，首先要有beanName，这个是用来区分Bean定义信息的，所以加了非空判断，bean定义信息也要判断是否为空，然后根据bean定义接口里面的验证方法，判断bean定义信息是不是合法的，然后再根据containsBeanDefinition方法判断一下是不是已经注册过了，最后把注册的Bean定义信息放到beanDefinitionMap里面就可以了
通过实现Closeable来实现销毁的逻辑：
@Override
public void close() throws IOException {
// 针对单例Bean执行销毁方法
for(Map.Entry<String, BeanDefinition> e : beanDefinitionMap.entrySet()) {
//获取BeanName
String beanName = e.getKey();
//获取Bean定义
BeanDefinition definition = e.getValue();
//如果是单例Bean并且销毁方法非空，那么就执行销毁方法
if(definition.isSingleton() && StringUtils.isNotBlank(definition.getDestroyMethodName())) {
//得到Bean
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();
}
}
}
}
整个代码实现：
/**
* @ClassName DeafultBeanFactory
* @Description: Bean工厂的实现类
* @Author TR
* @Date 2021/3/25
* @Version V1.0
*/
public class DefaultBeanFactory implements BeanFactory, BeanDefinitionRegistry, Closeable {
/** Bean定义缓存 */
private Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();
/** Bean缓存 */
private Map<String, Object> 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<String, BeanDefinition> 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();
}
}
}
}
}
测试一下
首先定义一个接口：
public interface Boy {
void sayLove();
}
Lad实现类：主要是验证通过new的方式
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());
}
};
}
}
测试类：
/**
* @ClassName Test
* @Description: 测试类
* @Author TR
* @Date 2021/3/25
* @Version V1.0
*/
public class TestDemo {
static DefaultBeanFactory factory = new DefaultBeanFactory();
/** 测试构造方法注册Bean */
@Test
public void testRegister() throws Exception {
GenericBeanDefinition definition = new GenericBeanDefinition();
//设置beanClass
definition.setBeanClass(Lad.class);
//设置为单例
definition.setScope(BeanDefinition.SCOPE_SINGLETON);
//设置初始化方法
definition.setInitMethodName("init");
//设置销毁方法
definition.setDestroyMethodName("destroy");
//注册bean定义
factory.registerBeanDefinition("lad", definition);
}
/** 测试静态工厂注册Bean */
@Test
public void testRegisterStaticFactoryMethod() throws Exception {
GenericBeanDefinition definition = new GenericBeanDefinition();
//设置beanClass
definition.setBeanClass(BoyFactory.class);
//设置工厂方法名称
definition.setFactoryMethodName("getBean");
//注册bean定义
factory.registerBeanDefinition("staticFactoryBoy", definition);
}
/** 测试成员方法注册Bean */
@Test
public void testRegisterFactoryMethod() throws Exception {
GenericBeanDefinition definition = new GenericBeanDefinition();
//首先要获取工厂Bean
definition.setBeanClass(BoyFactoryBean.class);
//工厂Bean的名称
String fBeanName = "boyFactoryBean";
//注册工厂Bean定义
factory.registerBeanDefinition(fBeanName, definition);
//然后设置工厂方法
definition = new GenericBeanDefinition();
//设置工厂Bean的名称
definition.setFactoryBeanName(fBeanName);
//设置工厂方法
definition.setFactoryMethodName("buildBoy");
//设置为多例
definition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
//注册bean定义
factory.registerBeanDefinition("factoryBoy", definition);
}
@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是不一样的
至此，手写IOC容器就结束了，希望通过本篇文章，能够让您对Spring的IOC有更深刻的理解，感谢阅读！
本文其他知识点链接：