@Compenent,@Autowired,@PostConstruct自实现

2021-09-28 09:51:37

本来是想为安卓开发一套可以依赖注入的标签，但是发现安卓很难找到选定包内的java或者class文件。所以只能当做学习参考了，全套代码如下
package com.guanjian.annotion;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**

  • Created by Administrator on 2018-06-11.
    */

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Autowired {
}
package com.guanjian.annotion;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**

  • Created by Administrator on 2018-06-11.
    */

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
}
package com.guanjian.annotion;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**

  • Created by Administrator on 2018-06-11.
    */

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface PostConstruct {
}
package com.guanjian.util;

import com.guanjian.utils.StringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
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;

/**

  • 类操作工具类
  • Created by Administrator on 2018-06-11.
    */

public final class ClassUtil {

private static final Logger LOGGER = LoggerFactory.getLogger(ClassUtil.class);

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

/**
 * 加载类
 * @param className
 * @param isInitialized
 * @return
 */
public static Class<?> loadClass(String className,boolean isInitialized) {
    Class<?> cls;
    try {
        cls = Class.forName(className,isInitialized,getClassLoader());
    } catch (ClassNotFoundException e) {
        LOGGER.error("load class failure",e);
        throw new RuntimeException(e);
    }
    return cls;
}

/**
 * 获取制定包名下的所有类
 * @param packageName
 * @return
 */
public static Set<Class<?>> getClassSet(String packageName) {
    Set<Class<?>> classSet = new HashSet<Class<?>>();
    try {
        Enumeration<URL> urls = getClassLoader().getResources(packageName.replace(".","/"));
        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            if (url != null) {
                String protocol = url.getProtocol();
                if (protocol.equals("file")) {
                    String packagePath = url.getPath().replaceAll("%20"," ");
                    addClass(classSet,packagePath,packageName);
                }else if (protocol.equals("jar")) {
                    JarURLConnection jarURLConnection = (JarURLConnection)url.openConnection();
                    if (jarURLConnection != null) {
                        JarFile jarFile = jarURLConnection.getJarFile();
                        if (jarFile != null) {
                            Enumeration<JarEntry> jarEntries = jarFile.entries();
                            while (jarEntries.hasMoreElements()) {
                                JarEntry jarEntry = jarEntries.nextElement();
                                String jarEntryName = jarEntry.getName();
                                if (jarEntryName.endsWith(".class")) {
                                    String className = jarEntryName.substring(0,jarEntryName.lastIndexOf(".")).replaceAll("/",".");
                                    doAddClass(classSet,className);
                                }
                            }
                        }
                    }
                }
            }
        }
    } catch (Exception e) {
        LOGGER.error("get class set failure",e);
        throw new RuntimeException(e);
    }
    return classSet;
}

private static void addClass(Set<Class<?>> classSet, String packagePath, final String packageName) {
    File[] files = new File(packagePath).listFiles(new FileFilter() {
        public boolean accept(File pathname) {
            return (pathname.isFile() && pathname.getName().endsWith(".class")) || pathname.isDirectory();
        }
    });
    for (File file:files) {
        String fileName = file.getName();
        if (file.isFile()) {
            String className = fileName.substring(0,fileName.lastIndexOf("."));
            if (StringUtil.isNotEmpty(packagePath)) {
                className = packageName + "." + className;
            }
            doAddClass(classSet,className);
        }else {
            String subPackagePath = fileName;
            if (StringUtil.isNotEmpty(packagePath)) {
                subPackagePath = packagePath + "/" +subPackagePath;
            }
            String subPackageName = fileName;
            if (StringUtil.isNotEmpty(packageName)) {
                subPackageName = packageName + "." +subPackageName;
            }
            addClass(classSet,subPackagePath,subPackageName);
        }
    }
}
private static void doAddClass(Set<Class<?>> classSet,String className) {
    Class<?> cls = loadClass(className,false);
    classSet.add(cls);
}

}
package com.guanjian.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Field;

/**

  • 反射工具类
  • Created by Administrator on 2018-06-11.
    */

public final class ReflectionUtil {

private static final Logger LOGGER = LoggerFactory.getLogger(ReflectionUtil.class);

/**
 * 创建实例
 * @param cls
 * @return
 */
public static Object newInstance(Class<?> cls) {
    Object instance;
    try {
        instance = cls.newInstance();
    } catch (Exception e) {
        LOGGER.error("new instance failure",e);
        throw new RuntimeException(e);
    }
    return instance;
}

/**
 * 设置成员变量值
 * @param obj
 * @param field
 * @param value
 */
public static void setField(Object obj, Field field,Object value) {
    try {
        field.setAccessible(true);
        field.set(obj,value);
    } catch (IllegalAccessException e) {
        LOGGER.error("set field failure",e);
        throw new RuntimeException(e);
    }
}

}
package com.guanjian.util;

import com.guanjian.annotion.Component;

import java.util.HashSet;
import java.util.Set;

/**

  • 类操作助手类
  • Created by Administrator on 2018-06-11.
    */

public final class ClassHelper {

/**
 * 定义类集合(用于存放所加载的类)
 * @param basePackage
 */
private static  Set<Class<?>> CLASS_SET;

/**
 * 扫描所有的包，获取类集合放入CLASS_SET
 * @param basePackage
 */
public static void setClassSet(String basePackage) {
    CLASS_SET = ClassUtil.getClassSet(basePackage);
}

/**
 * 获取应用包名下的所有类
 * @return
 */
public static Set<Class<?>> getClassSet() {
    return CLASS_SET;
}

/**
 * 获取应用包名下所有Comonent类
 * @return
 */
public static Set<Class<?>> getComponentClassSet() {
    Set<Class<?>> classSet = new HashSet<Class<?>>();
    for (Class<?> cls:CLASS_SET) {
        if (cls.isAnnotationPresent(Component.class)) {
            classSet.add(cls);
        }
    }
    return classSet;
}

/**
 * 获取应用包名下所有Bean类
 * @return
 */
public static Set<Class<?>> getBeanClassSet() {
    Set<Class<?>> beanClassSet = new HashSet<Class<?>>();
    beanClassSet.addAll(getComponentClassSet());
    return beanClassSet;
}

}
package com.guanjian.util;

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

/**

  • Bean助手类
  • Created by Administrator on 2018-06-11.
    */

public final class BeanHelper {

/**
 * 定义Bean映射(用于存放Bean类与Bean实例的映射关系)
 */
private static final Map<Class<?>,Object> BEAN_MAP = new HashMap<Class<?>, Object>();

/**
 * 获取所有的映射关系
 */
public static void setBeanMap() {
    Set<Class<?>> beanClassSet = ClassHelper.getBeanClassSet();
    for (Class<?> beanClass:beanClassSet) {
        Object obj = ReflectionUtil.newInstance(beanClass);
        BEAN_MAP.put(beanClass,obj);
    }
}

/**
 * 获取Bean映射
 * @return
 */
public static Map<Class<?>,Object> getBeanMap() {
    return BEAN_MAP;
}

/**
 * 获取Bean实例
 * @param cls
 * @param <T>
 * @return
 */
public static <T> T getBean(Class<T> cls) {
    if (!BEAN_MAP.containsKey(cls)) {
        throw new RuntimeException("Can not get bean by class:" + cls);
    }
    return (T)BEAN_MAP.get(cls);
}

}
package com.guanjian.util;

import com.guanjian.annotion.Autowired;
import com.guanjian.annotion.PostConstruct;
import com.guanjian.utils.ArrayUtil;
import com.guanjian.utils.CollectionUtil;

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

/**

  • Created by Administrator on 2018-06-11.
    */

public final class IocHelper {

public static void ioc(){
    //获取所有的Bean类与Bean实例之间的映射关系
    Map<Class<?>,Object> beanMap = BeanHelper.getBeanMap();
    if (CollectionUtil.isNotEmpty(beanMap)) {
        //遍历Bean Map
        for (Map.Entry<Class<?>,Object> beanEntry:beanMap.entrySet()) {
            //从BeanMap中获取Bean类与Bean实例
            Class<?> beanClass = beanEntry.getKey();
            Object beanInstance = beanEntry.getValue();
            //获取Bean类定义的所有成员变量
            Field[] beanFields = beanClass.getDeclaredFields();
            if (ArrayUtil.isNotEmpty(beanFields)) {
                //遍历Bean Field
                for (Field beanField:beanFields) {
                    //判断当前Bean Field是否带有Autowired注解
                    if (beanField.isAnnotationPresent(Autowired.class)) {
                        //在Bean Map中获取Bean Field对应的实例
                        Class<?> beanFieldClass = beanField.getType();
                        Object beanFieldInstance = beanMap.get(beanFieldClass);
                        if (beanFieldInstance != null) {
                            //通过反射初始化BeanField的值
                            ReflectionUtil.setField(beanInstance,beanField,beanFieldInstance);
                        }
                    }
                }
            }
            Method[] beanMethods = beanClass.getMethods();
            if (ArrayUtil.isNotEmpty(beanMethods)) {
                //遍历method
                for (Method method:beanMethods) {
                    //判断当前注解是否有PostConstruct注解
                    if (method.isAnnotationPresent(PostConstruct.class)) {
                        try {
                            //执行该方法
                            method.invoke(beanInstance,null);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

}
package com.guanjian.manage;

import com.guanjian.util.BeanHelper;
import com.guanjian.util.ClassHelper;
import com.guanjian.util.IocHelper;

/**

  • Created by Administrator on 2018-06-11.
    */

public class Manager {

public static Object getBean(Class<?> beanClass) {
    return BeanHelper.getBean(beanClass);
}
public static void scanAndImp(String basePackage) {
    ClassHelper.setClassSet(basePackage);
    BeanHelper.setBeanMap();
    IocHelper.ioc();
}

}
测试代码

package com.guanjian.test.compent;

import com.guanjian.annotion.Component;
import com.guanjian.annotion.PostConstruct;

/**

  • Created by Administrator on 2018-06-11.
    */

@Component
public class Test1 {

private String hello;
@PostConstruct
public void init() {
    hello = "你好";
}
public void show() {
    System.out.println(hello);
}

}
package com.guanjian.test.compent;

import com.guanjian.annotion.Autowired;
import com.guanjian.annotion.Component;

/**

  • Created by Administrator on 2018-06-11.
    */

@Component
public class Test2 {

@Autowired
private Test1 test1;
public void show() {
    test1.show();
}

}
package com.guanjian.test;

import com.guanjian.manage.Manager;
import com.guanjian.test.compent.Test2;

/**

  • Created by Administrator on 2018-06-11.
    */

public class Test {

public static void main(String[] args) {
    Manager.scanAndImp("com.guanjian.test");
    Test2 test2 = (Test2)Manager.getBean(Test2.class);
    test2.show();
}

}

上一篇：elasticsearch中文分词器的安装和体验


下一篇：函数式接口、默认方法、纯函数、函数的副作用、高阶函数、可变的和不可变的、函数式编程和 Lambda 表达式 - 响应式编程 ［Android RxJava2］（这到底是什么）第三部分