Community Learn Tools Library Leisure
search
English
Home > Java > javaTutorial > Java reflection commonly used in work

Java reflection commonly used in work

阿神
Release： 2016-11-07 17:25:46
Original
1850 people have browsed it

这次提到的Java反射涉及的代码比较多。因为工作中经常用到反射，对代码做了很多抽象以及过滤器。虽然代码量很多，但是简单易用，过滤插件也易修改。

下面介绍下工作中哪些地方比较容易用到反射。比如插件或者过滤器，如果抽象的子类比较少，配置成XML等结构也是可以达到同样的效果。如果希望灵活一些，添加了插件或者过滤器代码子类后希望可以直接使用。可能反射会比较好点，通过扫描所有class或者jar文件，得到所有继承的子类。如果每次调用都扫描所有的文件会比较影响性能。所以在实现里面加入反射缓存，对所要获取反射子类时涉及的所有参数作为一个key缓存所有的反射结果。下次如果是同样的key，就不在重新扫描。

代码示例如下：

public static void main(String[] args) {//设置扫描范围，可以是class文件所在位置例如bin下或者是mysql开头或者mysql结尾的jar,
//设置为""为全部都扫描,这种比较耗时
ReflectUtils.createSharedReflections("classes", "bin", "mysql");try {//调试阶段可以设置每次都全扫描
//Beans.setDesignTime(true);
final Collection<String> subTypes = ReflectUtils.listSubClass(IA.class);//
for (final String subType : subTypes) {//这里获取的是所有继承IA的子类
System.out.println(subType);final IA impl = ReflectUtils.initClass(subType, IA.class);if (null == impl)continue;//通过该方式，可以统一做操作，
impl.print();
}
} catch (Exception e) {
e.printStackTrace();
}
}
Copy after login

代码执行结果：

//缓存文件，避免每次调用反射都重新扫描//如果删除该文件，再次调用反射时，会重新扫描，一般会在代码里面有添加子类的时候会删除该文件XmlUtils.readXml 

//缓存文件，避免每次调用反射都重新扫描
//如果删除该文件，再次调用反射时，会重新扫描，一般会在代码里面有添加子类的时候会删除该文件
XmlUtils.readXml failure:.\configuration.REF (系统找不到指定的文件。)
net.simple.reflect.test.B
net.simple.reflect.test.B
net.simple.reflect.test.D
net.simple.reflect.test.V
Copy after login

具体的类里面如何实现的大家就看下源码吧，这里贴出两个核心类的代码。

package net.simple.reflect;

import java.io.File;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.zip.ZipEntry;

import net.simple.reflect.filter.IPathURLFilter;
import net.simple.reflect.filter.ISubTypeFilter;
import net.simple.reflect.filter.ITypeFilter;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

public final class Reflections {
    private final Collection<URL> pathUrls;
    private final Collection<IPathURLFilter> pathURLfilters;
    private final Collection<ITypeFilter> typeFilters;
    private ISubTypeFilter subTypeFilter;

    public Reflections() {
        typeFilters = new ArrayList<ITypeFilter>();
        pathURLfilters = new ArrayList<IPathURLFilter>();
        this.pathUrls = ClasspathHelper.getUrlsForCurrentClasspath();
    }

    public Reflections(final Collection<URL> pathUrls) {
        this.pathUrls = pathUrls;
        typeFilters = new ArrayList<ITypeFilter>();
        pathURLfilters = new ArrayList<IPathURLFilter>();
    }

    /**
     * @param subTypeFilter
     *            the subTypeFilter to set
     */
    public void setSubTypeFilter(final ISubTypeFilter subTypeFilter) {
        this.subTypeFilter = subTypeFilter;
    }

    /**
     * @return the subTypeFilter
     */
    public ISubTypeFilter getSubTypeFilter() {
        return subTypeFilter;
    }

    public Reflections addPathURLFilter(final IPathURLFilter pathURLFilter) {
        if (null == pathURLFilter)
            return this;
        if (!this.pathURLfilters.contains(pathURLFilter))
            this.pathURLfilters.add(pathURLFilter);
        return this;
    }

    public Reflections addTypeFilter(final ITypeFilter typeFilter) {
        if (null == typeFilter)
            return this;
        if (!this.typeFilters.contains(typeFilter))
            this.typeFilters.add(typeFilter);
        return this;
    }

    private static final String histFile = "./configuration.REF";
    private Document histDom;

    public Collection<String> getSubTypesFast(final Class<?> baseType) {//, final String... typeNames
        //首先过滤出当前允许扫描的路径
        final StringBuilder bufPathsId = new StringBuilder(32);
        final Map<File, URL> fileUrls = new LinkedHashMap<File, URL>(8);
        for (final URL pathUrl : pathUrls) {
            if (!acceptPathUrl(pathUrl))
                continue;
            File file = null;
            try {
                file = new File(URLDecoder.decode(pathUrl.getFile(), "UTF-8"));
            } catch (final Exception e) {
                file = new File(pathUrl.getFile());
            }
            fileUrls.put(file, pathUrl);
            if (!file.exists())//is url file?ignore
                continue;
            bufPathsId.append(file.getName()).append(file.lastModified());
        }
        final String domId = MD5.getHashString(bufPathsId.toString());
        if (null == histDom)
            histDom = W3cUtils.readXml(histFile);
        if (null == histDom)
            histDom = W3cUtils.newDom("R");
        Element rootEle = histDom.getDocumentElement();
        if (null == rootEle)
            histDom.appendChild(rootEle = histDom.createElement("R"));
        if (!domId.equals(rootEle.getAttribute("id"))) {
            rootEle.getParentNode().removeChild(rootEle);
            histDom.appendChild(rootEle = histDom.createElement("R"));
            rootEle.setAttribute("id", domId);
        }
        final String baseTypeId = MD5.getHashString(baseType.getName());
        Element refEle = W3cUtils.firstChildElement(rootEle, "E", "id", baseTypeId);
        if (null != refEle) {
            final List<Element> valueEles = W3cUtils.childElementList(refEle, "F");
            final Collection<String> result = new ArrayList<String>(valueEles.size());
            for (final Element valueEle : valueEles) {
                result.add(new String(Base64.decodeFast(valueEle.getAttribute("id"))));
            }
            return result;
        }
        final ThreadPool<ListSubTypes> pool = new ThreadPool<ListSubTypes>();
        for (final File fileKey : fileUrls.keySet()) {
            pool.execute(new ListSubTypes(baseType, fileKey, fileUrls.get(fileKey)));
        }
        try {
            pool.shutdown(3, TimeUnit.MINUTES);
        } catch (final InterruptedException e) {
            e.printStackTrace();//for debug
        }
        final Collection<String> result = new ArrayList<String>();
        for (final ListSubTypes task : pool.getThreadRunables()) {
            result.addAll(task.result);
        }
        refEle = W3cUtils.addEle(rootEle, "E");
        refEle.setAttribute("id", baseTypeId);
        for (final String itm : result) {
            W3cUtils.addEle(refEle, "F").setAttribute("id", Base64.encodeToString(itm.getBytes(), false));
        }
        try {
            W3cUtils.writeXmlDocument(histFile, histDom);
        } catch (final Exception e) {
        }
        return result;
    }

    /**
     * @see {@link ReflectUtils#createSharedReflections(String...)}
     * @see {@link ReflectUtils#setSharedReflections(Reflections)}
     * @see {@link ReflectUtils#listSubClass(Class)}
     * @param baseType
     * @return
     */
    public Collection<String> getSubTypes(final Class<?> baseType, final String... typeNames) {//
        final ThreadPool<ListSubTypes> pool = new ThreadPool<ListSubTypes>();
        for (final URL pathUrl : pathUrls) {
            if (!acceptPathUrl(pathUrl))
                continue;
            File file = null;
            try {
                file = new File(URLDecoder.decode(pathUrl.getFile(), "UTF-8"));
            } catch (final Exception e) {
                file = new File(pathUrl.getFile());
            }
            pool.execute(new ListSubTypes(baseType, file, pathUrl, typeNames));
        }
        try {
            pool.shutdown(3, TimeUnit.MINUTES);
        } catch (final InterruptedException e) {
            e.printStackTrace();//for debug
        }
        final Collection<String> result = new ArrayList<String>();
        for (final ListSubTypes task : pool.getThreadRunables()) {
            result.addAll(task.result);
        }
        return result;
    }

    class ListSubTypes implements Runnable {
        final File file;
        final Class<?> baseType;
        final URL pathUrl;
        final String[] typeNames;

        public ListSubTypes(final Class<?> baseType, final File file, final URL pathUrl, final String... typeNames) {
            this.baseType = baseType;
            this.file = file;
            this.pathUrl = pathUrl;
            this.typeNames = typeNames;
        }

        Collection<String> result = new ArrayList<String>(4);

        @Override
        public void run() {
            if (file.isDirectory()) {
                listSubTypesFromDirectory(file, baseType, pathUrl, file, result, typeNames);
            } else
                listSubTypesFromJar(baseType, pathUrl, result, typeNames);
        }
    }

    /**
     * @param baseType
     * @param pathUrl
     * @param result
     */
    public void listSubTypesFromDirectory(final File baseDirectory, final Class<?> baseType, final URL pathUrl, final File directory,
            final Collection<String> result, final String... typeNames) {
        File[] files = directory.listFiles();
        if (null == files)
            files = new File[] {};
        String clazzPath;
        final int baseDirLen = baseDirectory.getAbsolutePath().length() + 1;
        for (final File file : files) {
            if (file.isDirectory()) {
                listSubTypesFromDirectory(baseDirectory, baseType, pathUrl, file, result, typeNames);
            } else {
                clazzPath = file.getAbsolutePath().substring(baseDirLen);
                clazzPath = clazzPath.replace(&#39;\\&#39;, &#39;/&#39;);
                doTypesFilter(baseType, pathUrl, result, clazzPath, typeNames);
            }
        }
    }

    /**
     * @param baseType
     * @param pathUrl
     * @param result
     */
    public void listSubTypesFromJar(final Class<?> baseType, URL pathUrl, final Collection<String> result, final String... typeNames) {
        try {
            // It does not work with the filesystem: we must
            // be in the case of a package contained in a jar file.
            JarFile jarFile = null;
            try {
                if ("file".equals(pathUrl.getProtocol()))
                    pathUrl = new URL("jar:" + pathUrl.toExternalForm() + "!/");
                jarFile = ((JarURLConnection) pathUrl.openConnection()).getJarFile();
            } catch (final Exception e) {
                final String filePath = pathUrl.getFile();
                // if on win platform
                if (filePath.indexOf(&#39;:&#39;) != -1) {
                    if (pathUrl.getFile().charAt(0) == &#39;/&#39;)
                        jarFile = new JarFile(filePath.substring(1));
                }
                if (null == jarFile)
                    jarFile = new JarFile(filePath);
            }
            final Enumeration<JarEntry> e = jarFile.entries();
            ZipEntry entry;
            while (e.hasMoreElements()) {
                entry = e.nextElement();
                doTypesFilter(baseType, pathUrl, result, entry.getName(), typeNames);
            }
        } catch (final IOException ioex) {
        }
    }

    private void doTypesFilter(final Class<?> baseType, final URL pathUrl, final Collection<String> result, final String clazzPath,
            final String... typeNames) {
        if (!clazzPath.endsWith(".class"))
            return;
        final int lastDotIdx = clazzPath.lastIndexOf(&#39;.&#39;);
        if (-1 == lastDotIdx)
            return;
        final String typeDef = clazzPath.substring(0, lastDotIdx).replace(&#39;/&#39;, &#39;.&#39;);
        if (null != typeNames && typeNames.length > 0) {
            final int lastDot = typeDef.lastIndexOf(&#39;.&#39;);
            if (lastDot == -1)
                return;
            final String typeName = typeDef.substring(lastDot + 1);
            boolean withLiked = false;
            for (final String tmpTypeName : typeNames) {
                if (!typeName.contains(tmpTypeName))
                    continue;
                withLiked = true;
                break;
            }
            if (withLiked == false)
                return;
        }
        if (this.typeFilters.isEmpty()) {
            if (null == this.subTypeFilter || this.subTypeFilter.accept(baseType, pathUrl, clazzPath))
                result.add(typeDef);
        } else {
            for (final ITypeFilter typeFilter : this.typeFilters) {
                if (!typeFilter.accept(clazzPath))
                    continue;
                if (null == this.subTypeFilter || this.subTypeFilter.accept(baseType, pathUrl, clazzPath))
                    result.add(typeDef);
            }
        }
    }

    /**
     * @param pathUrl
     * @return
     */
    private boolean acceptPathUrl(final URL pathUrl) {
        if (this.pathURLfilters.isEmpty())
            return true;
        for (final IPathURLFilter pathURLFilter : this.pathURLfilters) {
            if (pathURLFilter.accept(pathUrl))
                return true;
        }
        return false;
    }
}
Copy after login
package net.simple.reflect;

import java.beans.Beans;
import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.zip.ZipEntry;

import net.simple.reflect.filter.PathURLFilter;
import net.simple.reflect.filter.SampleSubInstanceFilter;
import net.simple.reflect.filter.TypeFilter;

/**
 * 
 * @author 李岩飞
 * @email eliyanfei@126.com 
 * 2016年11月2日 下午3:24:02
 *
 */
public final class ReflectUtils {
    public static final String VAR_START_FLAG = "${";
    public static final String VAR_END_FLAG = "}";

    private static Reflections sharedReflections;
    static final Collection<String> EMP_COLL = Collections.emptyList();

    public static final void createSharedReflections(final String... filterExts) {
        final Reflections refs = new Reflections();
        refs.addPathURLFilter(new PathURLFilter(filterExts));//
        refs.addTypeFilter(TypeFilter.DEFAULT);
        refs.setSubTypeFilter(SampleSubInstanceFilter.DEFAULT);
        ReflectUtils.setSharedReflections(refs);
    }

    /**
     * 此方法用于绑定一个通用的共享类型遍列工具.
     * @param sharedReflections
     */
    public static final void setSharedReflections(final Reflections sharedReflections) {
        ReflectUtils.sharedReflections = sharedReflections;
    }

    /**
     * 调用此方法之前必须先设置共享的类型遍列工具,参考:{@link #setSharedReflections(Reflections)},
     * 此方法主要使更方便的遍列给定类的实现,
     */
    public static final Collection<String> listSubClass(final Class<?> baseType, final String... typeNames) {//
        if (null == sharedReflections)
            return EMP_COLL;
        //调用阶段由于可能增加新的子类实现,需要每次都重新扫描,只有在发布的产品时使用保存记录的方法以提高启动速度.
        return Beans.isDesignTime() ? sharedReflections.getSubTypes(baseType, typeNames) : sharedReflections.getSubTypesFast(baseType);
    }

    public static List<Class<?>> listClassOfPackage(final Class<?> cType, final String extenion) {
        final List<Class<?>> result = new ArrayList<Class<?>>();
        final List<String> cPath = ReflectUtils.listClassCanonicalNameOfPackage(cType, extenion);
        for (final String path : cPath) {
            try {
                result.add(Class.forName(path, false, Thread.currentThread().getContextClassLoader()));
            } catch (final Exception e) {
                // ignore
            }
        }
        return result;
    }

    public static List<String> listClassCanonicalNameOfPackage(final Class<?> clazz, final String extenion) {
        return ReflectUtils.listNameOfPackage(clazz, extenion, true);
    }

    public static List<String> listClassNameOfPackage(final Class<?> clazz, final String extenion) {
        return ReflectUtils.listNameOfPackage(clazz, extenion, false);
    }

    public static List<String> listNameOfPackage(final Class<?> clazz, final String extenion, final boolean fullPkgName) {
        return ReflectUtils.listNameOfPackage(clazz.getName().replace(&#39;.&#39;, &#39;/&#39;) + ".class", extenion, fullPkgName);
    }

    public static List<String> listNameOfPackage(final String clazzPkg, final String extenion, final boolean fullPkgName) {
        final List<String> result = new ArrayList<String>();

        final StringBuffer pkgBuf = new StringBuffer(clazzPkg);

        if (pkgBuf.charAt(0) != &#39;/&#39;)
            pkgBuf.insert(0, &#39;/&#39;);

        final URL urlPath = ReflectUtils.class.getResource(pkgBuf.toString());

        if (null == urlPath)
            return result;

        String checkedExtenion = extenion;
        if (!extenion.endsWith(".class"))
            checkedExtenion = extenion + ".class";

        if (pkgBuf.toString().endsWith(".class"))
            pkgBuf.delete(pkgBuf.lastIndexOf("/"), pkgBuf.length());

        pkgBuf.deleteCharAt(0);

        final StringBuffer fileUrl = new StringBuffer();
        try {
            fileUrl.append(URLDecoder.decode(urlPath.toExternalForm(), "UTF-8"));
        } catch (final UnsupportedEncodingException e1) {
            fileUrl.append(urlPath.toExternalForm());
        }

        if (fileUrl.toString().startsWith("file:")) {
            fileUrl.delete(0, 5);// delete file: flag
            if (fileUrl.indexOf(":") != -1)
                fileUrl.deleteCharAt(0);// delete flag
            final String baseDir = fileUrl.substring(0, fileUrl.lastIndexOf("classes") + 8);
            ReflectUtils.doListNameOfPackageInDirectory(new File(baseDir), new File(baseDir), result, pkgBuf.toString(), checkedExtenion, fullPkgName);
        } else {
            ReflectUtils.doListNameOfPackageInJar(urlPath, urlPath, result, pkgBuf.toString(), checkedExtenion, fullPkgName);
        }

        return result;
    }

    /**
     */
    private static void doListNameOfPackageInJar(final URL baseUrl, final URL urlPath, final List<String> result, final String clazzPkg, final String extenion, final boolean fullPkgName) {
        try {
            // It does not work with the filesystem: we must
            // be in the case of a package contained in a jar file.
            final JarURLConnection conn = (JarURLConnection) urlPath.openConnection();
            final JarFile jfile = conn.getJarFile();
            final Enumeration<JarEntry> e = jfile.entries();

            ZipEntry entry;
            String entryname;

            while (e.hasMoreElements()) {
                entry = e.nextElement();
                entryname = entry.getName();

                if (entryname.startsWith(clazzPkg) && entryname.endsWith(extenion)) {
                    if (fullPkgName)
                        result.add(entryname.substring(0, entryname.lastIndexOf(&#39;.&#39;)).replace(&#39;/&#39;, &#39;.&#39;));
                    else
                        result.add(entryname.substring(entryname.lastIndexOf(&#39;/&#39;) + 1, entryname.lastIndexOf(&#39;.&#39;)));
                }
            }
        } catch (final IOException ioex) {
        }
    }

    private static void doListNameOfPackageInDirectory(final File baseDirectory, final File directory, final List<String> result, final String clazzPkg, final String extenion,
            final boolean fullPkgName) {
        File[] files = directory.listFiles();
        if (null == files)
            files = new File[] {};
        String clazzPath;
        final int baseDirLen = baseDirectory.getAbsolutePath().length() + 1;
        for (final File file : files) {
            if (file.isDirectory()) {
                ReflectUtils.doListNameOfPackageInDirectory(baseDirectory, file, result, clazzPkg, extenion, fullPkgName);
            } else {
                if (!file.getName().endsWith(extenion))
                    continue;

                if (fullPkgName) {
                    clazzPath = file.getAbsolutePath().substring(baseDirLen);
                    clazzPath = clazzPath.substring(0, clazzPath.length() - 6);
                    result.add(clazzPath.replace(File.separatorChar, &#39;.&#39;));
                } else {
                    result.add(file.getName().substring(0, file.getName().length() - 6));
                }
            }
        }
    }

    public static final <T> T initClass(final String implClass, final Class<T> tType) {
        return ReflectUtils.initClass(implClass, tType, true);
    }

    public static final <T> T initClass(final String implClass, final Class<T> tType, final boolean doInit) {
        try {
            final Object object = Class.forName(implClass, doInit, Thread.currentThread().getContextClassLoader()).newInstance();
            return tType.cast(object);
        } catch (final Throwable e) {
            return null;
        }
    }
}
Copy after login


Related labels：
java reflection
source：php.cn
Previous article：Example tutorial on communication between java and php through socket Next article：JAVA monthly fortune api calling code example
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Latest Articles by Author
Latest Issues
How to convert a string to a 19-digit number in javaScript without automatic rounding? We have string input number input="6145390195186705543" if we want to convert to...
From 2024-03-30 14:42:35
0
1
367
Related Topics
More>
Popular Recommendations
Popular Tutorials
More>
Related Tutorials
Popular Recommendations
Latest courses
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template