Spring IOC和AOP整合手写源码总结

作者：田超凡

时间：2019年8月20日

1.maven依赖

因为整个项目是纯手写的，所以只需要依赖Apache的一些工具包，如collection、lang包，以及实现aop动态代理功能的cglib源包

       <dependency>
           <groupId>org.apache.commons</groupId>
           <artifactId>commons-lang3</artifactId>
           <version>3.4</version>
       </dependency>

       <dependency>
           <groupId>commons-collections</groupId>
           <artifactId>commons-collections</artifactId>
           <version>3.2.1</version>
       </dependency>

       <dependency>
           <groupId>cglib</groupId>
           <artifactId>cglib</artifactId>
           <version>3.2.5</version>
       </dependency>

</dependencies>

2.base.properties 属性文件

作用：指定IOC扫描的基准包，一般配置为顶级包，下文IOC实现部分会递归扫描该基准包下的类

base_package=com.tcf.smart.framework.demo

3.PropertiesUtil工具类

作用：

(1).属性文件工具类，根据指定的属性文件名加载对应的属性文件
(2).根据Key获取属性值

package com.tcf.smart.framework.util;

import java.io.IOException;
import java.util.Properties;

/***
* TODO TCF 属性文件工具类，根据指定的属性文件名加载对应的属性文件
* TODO TCF 根据Key获取属性值
* @author 71485
*
*/
public class PropertiesUtil {

   //TODO TCF 采用单例模式-饿汉模式
   private static Properties properties=new Properties();

   //TODO TCF 根据属性文件名加载属性文件
   public static Properties loadProperties(String propertiesFileName)
   {
       try
       {
           properties.load(PropertiesUtil.class.getClassLoader().getResourceAsStream(propertiesFileName));
       }
       catch (IOException e)
       {
           e.printStackTrace();
       }

       return properties;
   }

   //TODO TCF 根据Key获取属性文件value
   public static String getProperty(String key)
   {
       return properties.getProperty(key);
   }
}

4.ClassUtil工具类

作用：

(1).类加载器工具类，获取类加载器、根据类名加载类、根据类名一次加载一个类、根据类名、包路径、包名一次加载所有子类、根据包名加载包及其子包下的所有类文件

package com.tcf.smart.framework.util;

import java.io.File;
import java.io.FileFilter;
import java.net.JarURLConnection;
import java.net.URL;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

import org.apache.commons.lang3.StringUtils;

import com.tcf.smart.framework.common.Const;

/***
* TODO TCF 类加载器工具类
* TODO TCF 获取类加载器、根据类名加载类、根据类名一次加载一个类、根据类名、包路径、包名一次加载所有子类、根据包名加载包及其子包下的所有类文件
* @author 71485
*
*/
public class ClassUtil {

   //TODO TCF 获取类加载器
   public static ClassLoader getClassLoader()
   {
       return Thread.currentThread().getContextClassLoader();
   }

   //TODO TCF 根据类名加载类
   public static Class<?> loadClassByName(String className)
   {
       Class<?> cls=null;
       try
       {
           cls=Class.forName(className,true,getClassLoader());
       }
       catch(Exception e)
       {
           e.printStackTrace();
       }

       return cls;
   }

   //TODO TCF 根据类名一次加载一个类
   public static void addSingleClass(Set<Class<?>> classList,String className)
   {
       try
       {
           Class<?> cls=loadClassByName(className);
           classList.add(cls);
       }
       catch(Exception e)
       {
           e.printStackTrace();
       }
   }

   //TODO TCF 根据包路径和包名递归加载所有类文件
   public static void addClassBatch(Set<Class<?>> classList,String packagePath,String packageName)
   {
       try
       {
           if(StringUtils.isNotEmpty(packagePath))
           {
               //TODO TCF 要扫描的基准目录
               File dirFile=new File(packagePath);

               if(dirFile!=null)
               {
                   File[] files=dirFile.listFiles(new FileFilter() {

                       @Override
                       public boolean accept(File file)
                       {
                           return (file.isFile() && file.getName().endsWith(".class")) || file.isDirectory();
                       }
                   });

                   if(files!=null && files.length>0)
                   {
                       for(File file:files)
                       {
                           String fileName=file.getName();

                           if(StringUtils.isNotEmpty(fileName))
                           {
                               if(file.isFile())
                               {
                                   //TODO TCF 扫描到的类文件加载到类加载器
                                   String className=fileName.substring(0,fileName.lastIndexOf("."));
                                   if(StringUtils.isNotEmpty(packageName))
                                   {
                                       className=packageName+"."+className;
                                   }

                                   addSingleClass(classList,className);
                               }
                               else
                               {
                                   //TODO TCF 获取子包路径、子包名并递归加载
                                   String subPackagePath=fileName;
                                   if(StringUtils.isNotEmpty(packagePath))
                                   {
                                       subPackagePath=packagePath+"/"+subPackagePath;
                                   }

                                   String subPackageName=fileName;
                                   if(StringUtils.isNotEmpty(packageName))
                                   {
                                       subPackageName=packageName+"."+subPackageName;
                                   }

                                   addClassBatch(classList, subPackagePath, subPackageName);
                               }
                           }
                       }
                   }
               }
           }
       }
       catch(Exception e)
       {
           e.printStackTrace();
       }
   }

   //TODO TCF 根据包名递归加载所有类文件
   public static Set<Class<?>> loadClassSetByPackageName(String packageName)
   {
       Set<Class<?>> classList=new HashSet<Class<?>>();

       try
       {
           Enumeration<URL> urls=getClassLoader().getResources(packageName.replace(".","/"));
           if(urls!=null)
           {
               while(urls.hasMoreElements())
               {
                   URL url=urls.nextElement();

                   if(url!=null)
                   {
                       //TODO TCF URL协议类型
                       String protocol=url.getProtocol();

                       if(StringUtils.isNotEmpty(protocol))
                       {
                           if(protocol.equals(Const.URL_PROTOCOLS.FILE))
                           {
                               //TODO TCF 文件协议
                               String packagePath=url.getPath().replaceAll("%20"," ");
                               addClassBatch(classList, packagePath, packageName);
                           }
                           else if(protocol.equals(Const.URL_PROTOCOLS.JAR))
                           {
                               //TODO TCF JAR包协议
                               JarURLConnection jarURLConnection=(JarURLConnection)url.openConnection();

                               if(jarURLConnection!=null)
                               {
                                   JarFile jarFile=jarURLConnection.getJarFile();

                                   if(jarFile!=null)
                                   {
                                       Enumeration<JarEntry> entries=jarFile.entries();
                                       if(entries!=null)
                                       {
                                           while(entries.hasMoreElements())
                                           {
                                               JarEntry jarEntry=entries.nextElement();

                                               if(jarEntry!=null)
                                               {
                                                   //TODO TCF jar文件名称
                                                   String entryName=jarEntry.getName();

                                                   if(StringUtils.isNotEmpty(entryName) && entryName.endsWith(".class"))
                                                   {
                                                       String className=entryName.substring(0,entryName.lastIndexOf(".")).replace("/",".");
                                               addSingleClass(classList,className);
                                                   }
                                               }
                                           }
                                       }
                                   }
                               }
                           }
                       }
                   }
               }
           }
       }
       catch (Exception e)
       {
           e.printStackTrace();
       }

       return classList;
   }
}

5.ReflectUtil工具类

作用：

(1).反射工具类，根据类型创建实例、基于反射机制执行对应方法、给对应属性注入属性值

package com.tcf.smart.framework.util;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

/***
* TODO TCF 反射工具类
* TODO TCF 根据类型创建实例、基于反射机制执行对应方法、给对应属性注入属性值
* @author 71485
*
*/
public class ReflectUtil {

   //TODO TCF 根据类型基于反射机制创建对应类型实例
   public static Object newInstance(Class<?> cls)
   {
       Object instance=null;

       try
       {
           instance=cls.newInstance();
       }
       catch(Exception e)
       {
           e.printStackTrace();
       }

       return instance;
   }

   //TODO TCF 基于反射机制给目标属性注入属性值
   public static void setField(Object instance,Field field,Object fieldValue)
   {
       try
       {
           field.setAccessible(true);
           field.set(instance,fieldValue);
       }
       catch(Exception e)
       {
           e.printStackTrace();
       }
   }

   //TODO TCF 基于反射机制执行目标实例的方法
   public static Object invokeMethod(Object instance,Method method,Object[] methodParams)
   {
       Object result=null;

       try
       {
           result=method.invoke(instance,methodParams);
       }
       catch(Exception e)
       {
           e.printStackTrace();
       }

       return result;
   }
}

6.ClassHelper助手类

作用：

(1).类加载器助手类，初始化加载基准包下的所有类存入临时容器，提供根据注解加载指定类的通用方法，提供根据继承关系加载父类下所有子类或接口所有实现类的方法

package com.tcf.smart.framework.helper;

import java.lang.annotation.Annotation;
import java.util.HashSet;
import java.util.Set;
import com.tcf.smart.framework.annotation.KidComponent;
import com.tcf.smart.framework.annotation.KidController;
import com.tcf.smart.framework.annotation.KidRepository;
import com.tcf.smart.framework.annotation.KidService;
import com.tcf.smart.framework.common.Const;
import com.tcf.smart.framework.util.ClassUtil;
import com.tcf.smart.framework.util.PropertiesUtil;

/**
* TODO TCF 类加载器助手类
* TODO TCF 初始化加载基准包下的所有类存入临时容器，提供根据注解加载指定类的通用方法，提供根据继承关系加载父类下所有子类或接口所有实现类的方法
* @author 71485
*
*/
public class ClassHelper {

   public static Set<Class<?>> CLASS_LIST=new HashSet<Class<?>>();

   static
   {
       CLASS_LIST=ClassUtil.loadClassSetByPackageName(PropertiesUtil.loadProperties(Const.PROPERTIES_FILES.BASE_PROPERTIES).getProperty(Const.BASE_KEYS.BASE_PACKAGE));
   }

   //TODO TCF 根据注解加载对应类
   public static Set<Class<?>> loadClassByAnnotation(Class<? extends Annotation> annotation)
   {
       Set<Class<?>> classList=new HashSet<Class<?>>();

       if(CLASS_LIST!=null && CLASS_LIST.size()>0)
       {
           for(Class<?> cls:CLASS_LIST)
           {
               if(cls.isAnnotationPresent(annotation))
               {
                   classList.add(cls);
               }
           }
       }

       return classList;
   }

   //TODO TCF 根据父类或接口加载其子类或实现类
   public static Set<Class<?>> loadClassBySuperClass(Class<?> superClass)
   {
       Set<Class<?>> classList=new HashSet<Class<?>>();

       if(CLASS_LIST!=null && CLASS_LIST.size()>0)
       {
           for(Class<?> cls:CLASS_LIST)
           {
               if(superClass.isAssignableFrom(cls) && !superClass.equals(cls))
               {
                   classList.add(cls);
               }
           }
       }

       return classList;
   }

   //TODO TCF 加载预定义的注解标注类
   public static Set<Class<?>> loadClassExample()
   {
       Set<Class<?>> classList=new HashSet<Class<?>>();

       classList.addAll(loadClassByAnnotation(KidComponent.class));
       classList.addAll(loadClassByAnnotation(KidRepository.class));
       classList.addAll(loadClassByAnnotation(KidService.class));
       classList.addAll(loadClassByAnnotation(KidController.class));

       return classList;
   }
}

7.BeanHelper助手类

作用：

(1).自定义Bean组件及Bean实例映射管理工具类
(2).初始化加载Bean组件及其对应Bean实例，提供根据Bean类型获取Bean实例方法，提供存取元素方法

package com.tcf.smart.framework.helper;

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

/***
* TODO TCF 自定义Bean组件及Bean实例映射管理工具类
* TODO TCF 初始化加载Bean组件及其对应Bean实例，提供根据Bean类型获取Bean实例方法，提供存取元素方法
* @author 71485
*
*/
public class BeanHelper {

public static Map<Class<?>,Object> BEAN_MAP=new HashMap<Class<?>,Object>();

static
{
   Set<Class<?>> classList=ClassHelper.CLASS_LIST;
if(classList!=null && classList.size()>0)
{
   for(Class<?> cls:classList)
   {
       try
       {
                   Object instance=cls.newInstance();
                   BEAN_MAP.put(cls,instance);
               }
       catch (Exception e)
       {
                   e.printStackTrace();
               }
   }
}
}

//TODO TCF 根据Bean类型获取Bean实例
public static Object getBeanByClass(Class<?> cls)
{
   return BEAN_MAP.get(cls);
}

//TODO TCF 存入Bean组件和Bean实例映射元素
public static void putBeanMapping(Class<?> cls,Object instance)
{
   BEAN_MAP.put(cls,instance);
}
}

8.SpringIOC类加载器：IocHelper

作用：

(1).DI/IOC依赖注入助手类，加载基准包下的类并注入属性值，反射方法进行调用

package com.tcf.smart.framework.helper;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import com.tcf.smart.framework.annotation.Aspect;
import com.tcf.smart.framework.annotation.KidController;
import com.tcf.smart.framework.annotation.KidInject;
import com.tcf.smart.framework.demo.TestDemoFirst;
import com.tcf.smart.framework.demo.TestDemoSecond;
import com.tcf.smart.framework.demo.TestDemoThird;
import com.tcf.smart.framework.util.ReflectUtil;

/***
* TODO TCF DI/IOC依赖注入助手类，加载基准包下的类并注入属性值，反射方法进行调用
* @author 71485
*
*/
public class IocHelper {

   static
   {
       //TODO TCF simpleClassName => fieldName:fieldValue
Map<String,Map<String,Object>> fieldMap=new HashMap<String, Map<String,Object>>();

//TODO TCF 需要注入的属性名：属性值
Map<String,Object> paramMap=new HashMap<String,Object>();
paramMap.put("name","张三");
fieldMap.put(TestDemoFirst.class.getSimpleName(),paramMap);

paramMap=new HashMap<String,Object>();
paramMap.put("age",18);
fieldMap.put(TestDemoSecond.class.getSimpleName(),paramMap);

paramMap=new HashMap<String,Object>();
paramMap.put("first",new TestDemoFirst());
fieldMap.put(TestDemoThird.class.getSimpleName(),paramMap);

//TODO TCF 启动容器，实现DI/IOC依赖注入
init(fieldMap);
   }

   //TODO TCF DI/IOC容器启动
   public static void init(Map<String,Map<String,Object>> fieldMap)
   {
       //TODO TCF 获取Bean组件和实例映射Map
       Map<Class<?>,Object> beanMap=BeanHelper.BEAN_MAP;

       if(beanMap!=null)
       {
           for(Map.Entry<Class<?>,Object> entry:beanMap.entrySet())
           {
               //TODO TCF 目标类型
               Class<?> targetClass=entry.getKey();

               //TODO TCF 过滤AOP已经加载的代理类
               if(targetClass.isAnnotationPresent(Aspect.class))
               {
                   continue;
               }

               //TODO TCF 目标类型实例
               Object instance=entry.getValue();

               //TODO TCF 目标类型下面定义的所有属性
               Field[] fields=targetClass.getDeclaredFields();

               if(fields!=null && fields.length>0)
               {
                   for(Field field:fields)
                   {
                       if(field.isAnnotationPresent(KidInject.class))
                       {
                           //TODO TCF 参数注入使用KidInject注解标注的属性
                           for(Map.Entry<String,Map<String,Object>> fieldEntry:fieldMap.entrySet())
                           {
                               //TODO TCF 属性所在类型名称
                               String className=fieldEntry.getKey();

                               //TODO TCF 属性KEY-VALUE键值对
                               Map<String,Object> paramMap=fieldEntry.getValue();

                           if(StringUtils.isNotEmpty(className))
                           {
                               if(className.equals(targetClass.getSimpleName()))
                               {
                                   //TODO TCF 注入属性值
                                   for(Map.Entry<String,Object> destEntry:paramMap.entrySet())
                                   {
                                       //TODO TCF 属性值
                                       Object fieldValue=destEntry.getValue();

                                       //TODO TCF 注入属性值
                                       ReflectUtil.setField(instance, field, fieldValue);
                                   }
                               }
                           }
                           }
                       }
                   }
               }

               //TODO TCF 只执行AOP代理的控制器方法
               //TODO TCF 实际可以去掉该条件或换成其他条件，满足条件的目标类中的方法会被执行
               if(targetClass.isAnnotationPresent(KidController.class))
               {
                   //TODO TCF 反射执行目标方法
                   Method[] methods=targetClass.getDeclaredMethods();
                   if(methods!=null && methods.length>0)
                   {
                       for(Method method:methods)
                       {
                           //TODO TCF 方法参数
                           Object[] methodParams=null;

                           //TODO TCF ...方法入参补全
                           ReflectUtil.invokeMethod(instance, method, methodParams);
                       }
                   }
               }
           }
       }
   }
}

9.注解定义类

作用：自定义项目需要使用的注解及其功能

@KidComponent 注册普通组件 => @Component

@KidRepository 注册持久层组件 => @Repository

@KidService 注册业务层组件 => @Service

@KidController 注册控制器组件 => @Controller

@KidInject 显式指定需要注入值的属性 => @Inject

@Aspect 定义切面类 => @Aspect