看完上一个章节，相信你已经掌握了一些思考的本领了。今天我们来聊一个新的话题。上一篇文章是一个简约的话题，希望简约而不简单。当然，如果觉得太浅了也请立刻告知猿人工厂君，可以考虑做一些调整来更好的帮助到你，另外真的很感谢大家的支持，和巨兽的斗争暂时进入僵持阶段，猿人工厂君已经说了，虽千万人，吾往矣。中间细节，猿人工厂君，会在方便的时候公开，程序猿鸭，且行且珍惜。

猿思考是一个原创系列文章，帮助你从一个小白快速掌握基础知识，很多基础知识，在于思考的变通，更多精彩内容，敬请大家关注公主号猿人工厂，点击猿人养成获取！

IOC是Inversion ofControl的英文缩写，中文译名控制反转。控制反转？哈哈，是不是看起来怪怪的？控制反转，也是面向对象的一种编程原则，是一种编程思想。它是指将创建对象的管理权交给容器，由容器来装配和创建对象,从而降低代码之间的耦合度。IOC思想的实现，一般有两种方式，一种是依赖查找（Dependency Lookup）一种就是最常见的依赖注入（Dependency Injection） 。依赖查找是指程序运行时，程序使用容器提供的回调接口和上下文条件来查找资源和对象，从而让程序获得相应资源。这个种方式应用不是很多，需要应用服务器的支持，也就是JAVAEE规范的套路，比如JNDI,EJB...本文就不详细讨论了。而依赖注入（Dependency Injection）是什么呢?依赖注入是指，程序在运行时，程序不用做依赖的定位查询，提供普通的java方法去让容器决定依赖关系，容器全权负责程序使用对象的装配，把符合依赖关系的对象，通过属性或者是构造器的方式传递给依赖的对象。

我们看个简单的例子，我们有三个类：分别是TestServiceTestManager TestDao.其中TestService种有一个test()方法，调用了TestManager种的test()方法，而TestManager的test方法又调用了TestDao的test()方法。如果我们要调用TestService的test()方法，在正常情况下我们编写java代码，必然需要new TestService() newTestManager(), new TestDao().然后将TestManager对象作为TestService的一个属性传递给TestService（testService.setXXX或者是构造函数的方式传递），TestDao对象作为TestManager的一个属性，那么在使用TestService的类中，必然就需要在代码中import TestManager，

这样新编写的这个类代码依赖程度就高，耦合性强，不好维护。那现在改为依赖注入的方式，我们要使用TestService，就找容器拿TestService,容器提供的 TestService对象里已经存在TestManager对象了，那么我们使用TestService时，就只用在代码里import TestService就好了！新编写的类耦合性就没那么强了，易于维护多了。

那怎么去做到它呢？

不就是提供一个容器，获取对象嘛，只是获取的对象里的属性，已经由容器设置好了嘛。怎么办？通过名字创建对象！嗯，说白了，还是反射。下面我们来看一个小例子，实现简单的依赖注入。

先定义两个annotation：

package  com.pz.study.frame.ioc;import  java.lang.annotation.ElementType;
import  java.lang.annotation.Retention;
import  java.lang.annotation.RetentionPolicy;
import  java.lang.annotation.Target;/*** 用于注解需要由容器管理的类** @author pangzi**/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {String value() default"";}

package com.pz.study.frame.ioc;import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;/*** 用于注解需要注入的属性* @author pangzi**/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public@interfaceAutowared {}

定义一个简单的容器类：

package  com.pz.study.frame.ioc;import  java.io.File;
import  java.io.IOException;
import  java.io.InputStream;
import  java.lang.reflect.Field;
import  java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;public class ApplicationContext {public static final Map<String,Object> applicationContext = new ConcurrentHashMap<String, Object>();static {InputStream stream =ApplicationContext.class.getClassLoader().getResourceAsStream("ioc-frame.properties");Propertiesproperties = new Properties();try {properties.load(stream);} catch (IOException e) {e.printStackTrace();}StringpackageName=properties.getProperty("package").toString();try {instanceBean(packageName);} catch (Exception e) {e.printStackTrace();}}/*** 根据annotation上的名字获取对象* @param beanId* @return*/public static Object getBean(String beanId){returnapplicationContext.get(beanId);}/*** 创建包名下的对象并完成依赖注入* @param packageName* @throws Exception*/private static void instanceBean(StringpackageName) throws Exception {instanceByPackageName(packageName);autoWared();}// 获取指定包路径下使用了 ComponentAnnotationBean的实例private static void instanceByPackageName(String packageName) {try {List<String>classNames= getClassName(packageName,true);for(String className:classNames){Class<?>clazz = Class.forName(className);if (clazz.isAnnotationPresent(Component.class)) {clazz.getAnnotation(Component.class).value();applicationContext.put(clazz.getAnnotation(Component.class).value(), clazz.newInstance());}}} catch (Exception e) {e.printStackTrace();}}/*** 获取某包下所有类** @param packageName*            包名* @param childPackage*            是否遍历子包* @return类的完整名称*/private static List<String> getClassName(String packageName, boolean childPackage) {List<String> fileNames= null;ClassLoader loader = Thread.currentThread().getContextClassLoader();String packagePath =packageName.replace(".", "/");URL url =loader.getResource(packagePath);if (url != null) {String type =url.getProtocol();if (type.equals("file")) {fileNames = getClassNameByFile(url.getPath(), null, childPackage);}}return fileNames;}/*** 从项目文件获取某包下所有类** @param filePath*            文件路径* @param className*            类名集合* @param childPackage*            是否遍历子包* @return类的完整名称*/private static List<String> getClassNameByFile(String filePath,List<String> className, boolean childPackage) {List<String> myClassName= new ArrayList<>();File file = new File(filePath);File[] childFiles =file.listFiles();for (File childFile :childFiles) {if (childFile.isDirectory()) {if (childPackage) {myClassName.addAll(getClassNameByFile(childFile.getPath(),myClassName, childPackage));}} else {String childFilePath= childFile.getPath();if (childFilePath.endsWith(".class")) {childFilePath =childFilePath.substring(childFilePath.indexOf("/classes") + 9,childFilePath.lastIndexOf("."));childFilePath =childFilePath.replace("/", ".");myClassName.add(childFilePath);}}}return myClassName;}/*** 遍历map注入属性*/private static void autoWared() {Map<String, Object> map= applicationContext;try {for(StringbeanId:map.keySet()){Object obj=map.get(beanId);Field[] fields =obj.getClass().getDeclaredFields();for (Field field : fields) {if (field.isAnnotationPresent(Autowared.class)) {field.setAccessible(true);Object fieldObj= map.get(field.getName());field.set(obj,fieldObj);}}}}catch(Exception e){e.printStackTrace();}}
}

我们如果要使用容器创建的对象直接使用ApplicationContext.getBean()就好了。

接下来我们编写一单验证代码，使用我们的annotation和ApplicationContext提供的对象。

编写3个接口：

package com.pz.study.frame.test;public interface TestService {public void test();}

package com.pz.study.frame.test;public interface TestManager {public void test();}

package com.pz.study.frame.test;public interface TestDao {public void test();}

package com.pz.study.frame.test;import com.pz.study.frame.ioc.Autowared;
import com.pz.study.frame.ioc.Component;@Component(value="testService")
public class TestServiceImpl implements TestService {@Autowaredprivate TestManager testManager;public void test(){testManager.test();}}

package com.pz.study.frame.test;import com.pz.study.frame.ioc.Autowared;
import com.pz.study.frame.ioc.Component;@Component(value="testManager")
public class TestManagerImpl implements TestManager {@Autowaredprivate TestDao testDao;publicvoid test(){testDao.test();}}

package com.pz.study.frame.test;import com.pz.study.frame.ioc.Component;@Component(value="testDao")
public class TestDaoImpl implements TestDao {public void test(){System.out.println("ioc 小框架测试");}}

最后编写运行程序

package com.pz.study.frame.test;import com.pz.study.frame.ioc.ApplicationContext;public class TestIoc {public static void main(String args[]){TestService testService=(TestService) ApplicationContext.getBean("testService");testService.test();}}

运行程序，我们发现代码正确运行，而我们的程序只依赖了TestService这个接口，程序将需要依赖的对象交由自己定义的容器ApplicationContext去创建和装备。我们简单的实现了依赖注入的原理！

我建了一个群，群里有很多高手，大家可以一起讨论技术问题。