Spring：编写一个IOC容器

1.IOC

控制反转（Inversion of Control，缩写为IoC），是一种面向对象编程的一种设计思想，主要是为了降低计算机代码之间的耦合度。

在面向对象编程时，在类与类直接存在依赖关系时，通常在类的内部构件依赖对象，当构建的对象越多时，依赖关系就越复杂，耦合度就越高。这样初始化对象需要照顾到的参数就越多，如果被依赖的类做出修改时，改的地方也会很多，较为麻烦。IOC容器就是管理类的与类的依赖以及初始化对象问题，将控制权交给容器，我们需要的时候直接从容器取便可以！

1.1 耦合

现在存在两个类 A，B，B依赖A，在传统的开发时，便这样编程：

public class A {

    int a;

    public A(int a) {
        this.a = a;
    }
}

public class B{
	int b;
	A a;
	public B(int b,int a){
		this.b=b;
		this.a=new A(a);
	}
}

//main
public static void main(String[] args) {
       B b=new B(1,2);
}

可以看到，当我们需要初始化一个B对象时，需要传递参数两个参数，分别在B，A的构造函数使用，如果我们改变底层A的这个类的构造，对于依赖A的B来说，也要做出相应改变。在编程时，可能存在多级依赖情况，耦合度就很高。

1.2解耦

为了降低耦合度，可以使用直接传对象的方法，这样无论A类内部做出什么改变，依赖与它的其他类都不需要做出调整：

public class A {

    int a;

    public A(int a) {
        this.a = a;
    }
}

public class B{
	int b;
	A a;
	public B(int b,A a){
		this.b=b;
		this.a=a;
	}
}

//main
public static void main(String[] args) {
       A a=new A(1);
       B b=new B(1,a);
}

1.3容器

类与类可以使用以上方法解耦，但是，还得初始化所有的类，以构造函数的方式去传递参数，如果有一个容器在程序启动时已经帮我们做好了这些工作，每个我们直接去获取到实例话的对象，省去传递依赖对象作为构造函数的参数，岂不是很方便。

对于这个容器，首先有一个唯一的key值对应相应的类，根据key值取出对象，它的主要功能是对象的注册和获取。

2.依赖注入

IOC是设计规则，而DI（Dependency Injection）是实现IOC的一种方式，DI需要解决两个问题：

• 需要注册到 IoC 容器中的类能够在程序启动时自动进行注册 在 IoC

• 容器中的类实例化时可以直接拿到依赖对象的实例，而不用在构造函数中手动指定

2.1 自定义注解

在最初的Spring中是通过XML配置文件来规定，类的依赖规则的，现在可以通过自定义注解的方式去实现：

@Documented //表明这个注解应该被 javadoc工具记录,注解类型信息也会被包括在生成的文档中，是一个标记注解，没有成员
@Retention(RetentionPolicy.RUNTIME)  //规定注解保留的时间长短，runtime运行时有效
@Target(ElementType.FIELD)  //表明注解使用的目标 FIELD 类属性
public @interface Inject {
    Class<?> value() default String.class;
}

Inject注解类似与Spring中的Component，IocBean类似于Autowired

@Documented 
@Retention(RetentionPolicy.RUNTIME) runtime运行时有效
@Target(ElementType.TYPE)  
public @interface IocBean {
}

2.2类名的扫描

通过获取包名来得到其中的类名

public class ClassHelper {
	
	private static Logger log = Logger.getLogger(ClassHelper.class);
	
	public static List<Class<?>> getClassList(){
		return getClassList("pers.dwl.sardine.ioc.test");
	}
	
	public static List<Class<?>> getClassList(String packageName){
		// 第一个class类的集合
		List<Class<?>> classes = new ArrayList<Class<?>>();
		// 是否循环迭代
		boolean recursive = true;
		// 获取包的名字 并进行替换
		String packageDirName = packageName.replace('.', '/');
		// 定义一个枚举的集合 并进行循环来处理这个目录下的things
		Enumeration<URL> dirs;
		try {
			dirs = Thread.currentThread().getContextClassLoader()
					.getResources(packageDirName);
			// 循环迭代下去
			while (dirs.hasMoreElements()) {
				// 获取下一个元素
				URL url = dirs.nextElement();
				// 得到协议的名称
				String protocol = url.getProtocol();
				// 如果是以文件的形式保存在服务器上
				if ("file".equals(protocol)) {
					// 获取包的物理路径
					String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
					// 以文件的方式扫描整个包下的文件 并添加到集合中
					findAndAddClassesInPackageByFile(packageName, filePath,
							recursive, classes);
				} else if ("jar".equals(protocol)) {
					// 如果是jar包文件
					// 定义一个JarFile
					JarFile jar;
					// 获取jar
					jar = ((JarURLConnection) url.openConnection())
							.getJarFile();
					// 从此jar包 得到一个枚举类
					Enumeration<JarEntry> entries = jar.entries();
					// 同样的进行循环迭代
					while (entries.hasMoreElements()) {
						// 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
						JarEntry entry = entries.nextElement();
						String name = entry.getName();
						// 如果是以/开头的
						if (name.charAt(0) == '/') {
							// 获取后面的字符串
							name = name.substring(1);
						}
						// 如果前半部分和定义的包名相同
						if (name.startsWith(packageDirName)) {
							int idx = name.lastIndexOf('/');
							// 如果以"/"结尾 是一个包
							if (idx != -1) {
								// 获取包名 把"/"替换成"."
								packageName = name.substring(0, idx).replace(
										'/', '.');
							}
							// 如果可以迭代下去 并且是一个包
							if ((idx != -1) || recursive) {
								// 如果是一个.class文件 而且不是目录
								if (name.endsWith(".class")
										&& !entry.isDirectory()) {
									// 去掉后面的".class" 获取真正的类名
									String className = name.substring(
											packageName.length() + 1,
											name.length() - 6);
									try {
										// 添加到classes
										classes.add(Class.forName(packageName
												+ '.' + className));
									} catch (ClassNotFoundException e) {
										log.error(e);
									}
								}
							}
						}
					}
				}
			}
		} catch (Exception e) {
			log.error(e);
		}
		return classes;
	}
	
	public static void findAndAddClassesInPackageByFile(String packageName,
			String packagePath, final boolean recursive, List<Class<?>> classes) {
		// 获取此包的目录 建立一个File
		File dir = new File(packagePath);
		// 如果不存在或者 也不是目录就直接返回
		if (!dir.exists() || !dir.isDirectory()) {
			return;
		}
		// 如果存在 就获取包下的所有文件 包括目录
		File[] dirfiles = dir.listFiles(new FileFilter() {
			// 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
			public boolean accept(File file) {
				return (recursive && file.isDirectory())
						|| (file.getName().endsWith(".class"));
			}
		});
		// 循环所有文件
		for (File file : dirfiles) {
			// 如果是目录 则继续扫描
			if (file.isDirectory()) {
				findAndAddClassesInPackageByFile(
						packageName + "." + file.getName(),
						file.getAbsolutePath(), recursive, classes);
			} else {
				// 如果是java类文件 去掉后面的.class 只留下类名
				String className = file.getName().substring(0,
						file.getName().length() - 6);
				try {
					// 添加到集合中去
					classes.add(Class.forName(packageName + '.' + className));
				} catch (ClassNotFoundException e) {
					log.error(e);
				}
			}
		}
	}

}

2.3实例化IOC容器

通过依赖注入的方式提供一个IOC容器

public class SineIoc implements Ioc {
	
	private static final Object lock = new Object();
	
	/**
	 * 实例对象集合-未完成注入
	 */
	private static Map<Class<?>, Object> beanMap = new HashMap<Class<?>, Object>();
	
	/**
	 * 实例对象集合-已完成注入（第一次调用时注入）
	 */
	private static Map<Class<?>, Object> injectMap = new HashMap<Class<?>, Object>();
	
	//初始化
	static{
		//获取基础包下所有class
		List<Class<?>> classes = ClassHelper.getClassList();
		classes.forEach(clazz->{
			if(clazz.isAnnotationPresent(IocBean.class)){
				try {
					//加入实例对象集合
					beanMap.put(clazz, clazz.newInstance());
				} catch (InstantiationException | IllegalAccessException e) {
					e.printStackTrace();
				}
			}
			
		});
	}
	

	@SuppressWarnings("unchecked")
	public <T> T getEntity(Class<T> clazz) {
		if(!injectMap.containsKey(clazz)){
			if(!beanMap.containsKey(clazz)){
				throw new RuntimeException("没有该示例对象 - "+clazz);
			}else{
				synchronized (lock) {
					if(!injectMap.containsKey(clazz))
						setFiled(clazz);//依赖注入，加入缓存	
				}
			}
		}
		return (T)injectMap.get(clazz);
	}

	public boolean hasEntity(Class<?> clazz) {
		return injectMap.containsKey(clazz);
	}
	
	public void depose() {
		beanMap.clear();
		injectMap.clear();
	}
	
	/**
	 * 给属性赋值-依赖注入
	 * @param clazz
	 */
	public void setFiled(Class<?> clazz){
		 //获取所有属性
		 Field[] fields = clazz.getDeclaredFields();
		 //获取实例对象
		 Object instance = beanMap.get(clazz);
		 //有属性
		 if(!ArrayUtil.isEmpty(fields)){
			 for(Field field:fields){
				 //有待注入的属性
				 if(field.isAnnotationPresent(Inject.class)){
					 //获取属性上的inject信息
					 Inject inject = field.getAnnotation(Inject.class);
					 Class<?> type = inject.value();
					 //默认String.class,表示该属性类型是类不是接口
					 if(type.isAssignableFrom(String.class)){
						 Class<?> implClass = field.getType();
						//为属性对象实例进行依赖注入，不考虑循环依赖
						 setFiled(implClass);
						 //从injectMap获取已经注入好的属性对象实例
						 Object implBean =injectMap.get(implClass);
						 field.setAccessible(true);
						 try {
							 //为属性赋值
							field.set(instance, implBean);
						} catch (IllegalArgumentException | IllegalAccessException e) {
							e.printStackTrace();
						}
					 }else{//为接口时value要声明具体实现类
						 setFiled(type);//为属性对象实例进行依赖注入，不考虑循环依赖
						//从injectMap获取已经注入好的属性对象实例
						 Object implBean =injectMap.get(type);
						 field.setAccessible(true);
						 try {
							 //为属性赋值
							field.set(instance, implBean);
						} catch (IllegalArgumentException | IllegalAccessException e) {
							e.printStackTrace();
						}
					 }
				 }
			 }
			
		 }
		 injectMap.put(clazz, instance);//加入缓存
		 
	}

}

2.4 测试

@IocBean
public class MyService {
	

	public void doSome(){
		System.out.println("-----这个是被注入的对象-----");
	}

}

@IocBean
public class MyAction {
	
	@Inject
	private MyService myService;
	
	public void doSome(){
		myService.doSome();
	}

}

public class test {

	public static void main(String[] args) {
		Ioc ioc= new SineIoc();
		MyAction myBean = ioc.getEntity(MyAction.class);
		myBean.doSome();
	}

}