模仿Spring思想设计和实现IOC和AOP

港控/mmm° 2022-12-08 04:58 108阅读 0赞

### 一、前言 ###

文章模仿Spring对于IOC和AOP的处理思路，自定义注解实现了对bean的扫描、依赖注入和事务管理。实现思路大体如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hzZjE1NzY4NjE1Mjg0_size_16_color_FFFFFF_t_70_pic_center]

### 二、具体实现 ###

<dependency>
      <groupId>org.reflections</groupId>
      <artifactId>reflections</artifactId>
      <version>0.9.11</version>
    </dependency>
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>3.6</version>
    </dependency>

#### 2.1 自定义注解 ####

自定义了三个注解@Service，@Autowired和@Transactional，分别用于对象创建，属性注入和事务管理。

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Service { 
        //要注入的对象名称
        String value() default "";
    }

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Transactional { 
    }

@Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Autowired { 
    
    }

#### 2.2 定义单例池 ####

创建容器的入口WebApplicationContext，定义ConcurrentHashMap做为单例池，存放扫描过程中创建的对象，同时定义了扫描的类路径ROOT。

public class WebApplicationContext { 
    
        private static final String ROOT = "com.keduw";
        private static final ConcurrentHashMap<String, Object> beanMap = new ConcurrentHashMap<>(256);
        
    }

#### 2.3 扫描文件 ####

扫描指定路径下的所有文件，获取添加了@Service的所有类信息，通过反射创建指定的对象存到单例池中。

public static void initBeanFactory() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException { 
        Reflections reflections = new Reflections(ROOT);
        Set<Class<?>> serviceClazz = reflections.getTypesAnnotatedWith(Service.class);
        for (Class<?> clazz : serviceClazz) { 
            // 反射创建指定对象
            Object o = clazz.getDeclaredConstructor().newInstance();
            // 有指定value则将value作为key
            // 没有则将对应的类名首字母转为小写后作为key
            Service annotation = clazz.getAnnotation(Service.class);
            String key = annotation.value();
            if(StringUtils.isEmpty(key)){ 
                String[] split = clazz.getName().split("\\.");
                key = CharsetUtils.toLowerCase(split[split.length - 1]);
            }
            registerBean(key, o);
        }
    }

#### 2.4 处理单例池中对象的依赖关系 ####

遍历单例池，获取所有的对象和类信息，通过判断类中的属性是否添加了@Autowired注解，存在则获取依赖属性对应的名称作为key，从单例池中获取到指定对象，通过反射调用属性的set方法实现注入。

同时处理@Transactional注解，如果类中存在指定注解，则判断是否实现接口，如果实现接口则调用JDK动态代理创建代理对象，没有则调用Cglib动态代理创建对象。

for (Map.Entry<String, Object> bean : beanMap.entrySet()) { 
        Object o = bean.getValue();
        Class clazz = o.getClass();
        // 获取所有属性
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) { 
            if (field.isAnnotationPresent(Autowired.class)) { 
                // 获取依赖属性对应的名称
                String[] names = field.getType().getName().split("\\.");
                String name = CharsetUtils.toLowerCase(names[names.length - 1]);
                // 给指定属性赋值
                Field declaredField = clazz.getDeclaredField(name);
                declaredField.setAccessible(true);
                declaredField.set(o, beanMap.get(name));
            }
        }
        // 处理Transactional注解
        if(clazz.isAnnotationPresent(Transactional.class)){ 
            ProxyFactory proxyFactory = (ProxyFactory) getBean("proxyFactory");
            //判断对象是否实现接口
            Class[] interfaces = clazz.getInterfaces();
            o = (interfaces != null && interfaces.length > 0) ? proxyFactory.getJdkProxy(o) : proxyFactory.getCglibProxy(o);
        }
        registerBean(bean.getKey(), o);
    }

#### 2.5 代理实现 ####

代理中处理的事情就相对比较简单，主要是在方法执行前开启事务，在方法执行完后提交事务，如果出现异常则回滚事务。

/** * Jdk动态代理 * @param obj * @return */
    public Object getJdkProxy(Object obj) { 
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), new InvocationHandler() { 
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                Object result = null;
                try{ 
                    transactionManager.beginTransaction();
                    result = method.invoke(obj, args);
                    transactionManager.commit();
                }catch (Exception e) { 
                    e.printStackTrace();
                    transactionManager.rollback();
                    throw e;
                }
                return result;
            }
        });
    }
    
    /** * cglib动态代理 * @param obj * @return */
    public Object getCglibProxy(Object obj) { 
        return  Enhancer.create(obj.getClass(), new MethodInterceptor() { 
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
                Object result = null;
                try{ 
                    transactionManager.beginTransaction();
                    result = method.invoke(obj, objects);
                    transactionManager.commit();
                }catch (Exception e) { 
                    e.printStackTrace();
                    transactionManager.rollback();
                    throw e;
                }
                return result;
            }
        });
    }

### 三、总结 ###

到这里基本就实现了对象的扫描、依赖注入和事务控制，整体思路跟Spring的设计是类似的。文章中只显示了核心代码，完整的代码已提交，感兴趣的可以看看。（地址：https://gitee.com/lveex/kd-container.git）

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hzZjE1NzY4NjE1Mjg0_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/662169e2d225460e8bc71e81850cf64f.png