猿思考系列4——反射之一文学会java的斗转星移

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

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

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 {
       @Autowared
       private 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 {

       @Autowared
       private 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去创建和装备。我们简单的实现了依赖注入的原理！