精华内容
下载资源
问答
  • 用于扫描指定目录下所有jar包内的注解类,方便归类总结。
  • Java包扫描

    包扫描的本质

    包扫描的实质扫描的是所给包中的class文件,且jar包用普通包的扫描方法来扫描是不正确的。
    

    实现包扫描的核心思路

    给出一个需要扫描的包的名称,首先进行判断,该包是jar包还是普通包
    
    	public void packageScann(String PackageName) {
    		String rootname = "";
    		//将包名转换为目录形式
    		rootname = PackageName.replace('.', '/');
    		//通过给出的包名转换成的目录名称得到当前目录的URL
    		URL url = Thread.currentThread().getContextClassLoader().getResource(rootname);
    		//通过url.getProtocol().equals()方法来判断是File文件目录还是Jar包
    		if (url.getProtocol().equals("file")) {
    			try {
    				URI uri = url.toURI();
    				File file = new File(uri);
    				//已检测是目录路径,通过dealDirectory()方法来处理
    				dealDirectory(PackageName, file);
    			} catch (URISyntaxException e) {
    				e.printStackTrace();
    			}					
    		} else if (url.getProtocol().equals("jar")) {
    			//否则是jar包,通过dealJarPackage()方法来处理,此方法只需URL作为参数
    			dealJarPackage(url);
    		}
    	}
    

    处理普通包

    处理目录路径dealDirectory()此时分成两种情况:一是已经是java的class文件,二是仍然未到最底层还是目录

    public void dealDirectory(String PackageName, File file) {
    		//通过当前目录即参数中的File类型的file,可以得到当前目录下的所有文件
    		File[] fileList = file.listFiles();
    		//便利这个list,以此处理每一个file
    		for (File files : fileList) {
    			//判断是否仍是目录路径,若是,调用dealDirectory()方法
    			if (files.isDirectory()) {
    				//但对于参数中的PackageName路径要增加一层,即在末尾追加“.files.getName()”,一定要注意不能省略中间的“.”
    				dealDirectory(PackageName + "." + files.getName(), files);
    			}
    			//此时判断是否已经是class文件,即不再是目录,已经不再有分支
    			else if (files.isFile()){
    				//处理class文件
    				dealClassFile(PackageName, files);
    			}
    			
    		}
    	}
    

    当前已经是ClassFile,进行对该class的完善处理

    	public void dealClassFile(String packageName, File file) {
    		//此时通过file.getName()得到的是文件名,形式为:XXX.XXXX
    		String className = file.getName();
    		//判断一下是否为class文件,即是否以".class"结尾
    		if (className.endsWith(".class")) {
    			//将末尾的.class去掉
    			className = className.replace(".class", "");
    				try {
    					//这里通过反射机制,处理经过完善的该class文件的名字(此时已经是该class文件多对应的类名)
    					Class<?> klass = Class.forName(packageName + "." + className);
    					//调用dealClass()方法,该方法是一个抽象方法,需要在用户使用该工具时对其进行实现,可以在不同的场景下有不同的处理方式
    					dealClass(klass);
    				} catch (ClassNotFoundException e) {
    					e.printStackTrace();
    				}
    		}
    	}
    

    其中有一个抽象方法dealClass,是在已经到了目录最底层的class文件之后,通过对class文件获取名字,进行完善,即前面加上包名,形成一个完整的类名,通过反射机制反射出该类的类型,对于后序得到的Class<?>的通过抽象方法来扩展工具的适用范围,用户根据需求来做不同的处理

    处理Jar包

    jar包需要特殊处理,根据代码进行解析	
    
    	private void dealJarPackage(URL url) {
    		try {
    			//JarURLConnection类通过JAR协议建立了一个访问 jar包URL的连接,可以访问这个jar包或者这个包里的某个文件
    			JarURLConnection connection = (JarURLConnection) url.openConnection();
    			//通过这个连接进一步先得到JarFile
    			JarFile jarFile = connection.getJarFile();
    			//得到该JarFile目录下所有项目
    			Enumeration<JarEntry> jarEntries = jarFile.entries();
    			//遍历得到的jarEntries 
    			while (jarEntries.hasMoreElements()) {
    				JarEntry jar = jarEntries.nextElement();
    				//如果是目录路径或者不是class文件,不予处理
    				if(jar.isDirectory() || !jar.getName().endsWith(".class")) {
    					continue;
    				}
    				//以上是对于Jar包的特殊处理,由于Jar包与普通包不一样,其中一些文件也不能直接以普通文件的方式来处理
    				
    				//以下与前面处理的方式一样
    				String jarName = jar.getName();
    				jarName = jarName.replace(".class", "");
    				jarName = jarName.replace("/", ".");
    				
    				try {
    					Class<?> klass = Class.forName(jarName);
    					dealClass(klass);
    				} catch (ClassNotFoundException e) {
    					e.printStackTrace();
    				}
    			}
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	
    

    以上是对于包扫描的分段解析,下面附上全部代码:

    public abstract class PackageScanner {
    	
    	public PackageScanner() {
    	}
    	
    	public abstract void dealClass(Class<?> klass);
    	
    	public void dealClassFile(String packageName, File file) {
    		//此时通过file.getName()得到的是文件名,形式为:XXX.XXXX
    		String className = file.getName();
    		//判断一下是否为class文件,即是否以".class"结尾
    		if (className.endsWith(".class")) {
    			//将末尾的.class去掉
    			className = className.replace(".class", "");
    				try {
    					//这里通过反射机制,处理经过完善的该class文件的名字(此时已经是该class文件多对应的类名)
    					Class<?> klass = Class.forName(packageName + "." + className);
    					//调用dealClass()方法,该方法是一个抽象方法,需要在用户使用该工具时对其进行实现,可以在不同的场景下有不同的处理方式
    					dealClass(klass);
    				} catch (ClassNotFoundException e) {
    					e.printStackTrace();
    				}
    		}
    	}
    	
    	private void dealJarPackage(URL url) {
    		try {
    			//JarURLConnection类通过JAR协议建立了一个访问 jar包URL的连接,可以访问这个jar包或者这个包里的某个文件
    			JarURLConnection connection = (JarURLConnection) url.openConnection();
    			//通过这个连接进一步先得到JarFile
    			JarFile jarFile = connection.getJarFile();
    			//得到该JarFile目录下所有项目
    			Enumeration<JarEntry> jarEntries = jarFile.entries();
    			//遍历得到的jarEntries 
    			while (jarEntries.hasMoreElements()) {
    				JarEntry jar = jarEntries.nextElement();
    				//如果是目录路径或者不是class文件,不予处理
    				if(jar.isDirectory() || !jar.getName().endsWith(".class")) {
    					continue;
    				}
    				//以上是对于Jar包的特殊处理,由于Jar包与普通包不一样,其中一些文件也不能直接以普通文件的方式来处理
    				
    				//以下与前面处理的方式一样
    				String jarName = jar.getName();
    				jarName = jarName.replace(".class", "");
    				jarName = jarName.replace("/", ".");
    				
    				try {
    					Class<?> klass = Class.forName(jarName);
    					dealClass(klass);
    				} catch (ClassNotFoundException e) {
    					e.printStackTrace();
    				}
    			}
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	public void dealDirectory(String PackageName, File file) {
    		//通过当前目录即参数中的File类型的file,可以得到当前目录下的所有文件
    		File[] fileList = file.listFiles();
    		//便利这个list,以此处理每一个file
    		for (File files : fileList) {
    			//判断是否仍是目录路径,若是,调用dealDirectory()方法
    			if (files.isDirectory()) {
    				//但对于参数中的PackageName路径要增加一层,即在末尾追加“.files.getName()”,一定要注意不能省略中间的“.”
    				dealDirectory(PackageName + "." + files.getName(), files);
    			}
    			//此时判断是否已经是class文件,即不再是目录,已经不再有分支
    			else if (files.isFile()){
    				//处理class文件
    				dealClassFile(PackageName, files);
    			}
    			
    		}
    	}
    	public void packageScann(String PackageName) {
    		String rootname = "";
    		//将包名转换为目录形式
    		rootname = PackageName.replace('.', '/');
    		//通过给出的包名转换成的目录名称得到当前目录的URL
    		URL url = Thread.currentThread().getContextClassLoader().getResource(rootname);
    		//通过url.getProtocol().equals()方法来判断是File文件目录还是Jar包
    		if (url.getProtocol().equals("file")) {
    			try {
    				URI uri = url.toURI();
    				File file = new File(uri);
    				//已检测是目录路径,通过dealDirectory()方法来处理
    				dealDirectory(PackageName, file);
    			} catch (URISyntaxException e) {
    				e.printStackTrace();
    			}					
    		} else if (url.getProtocol().equals("jar")) {
    			//否则是jar包,通过dealJarPackage()方法来处理,此方法只需URL作为参数
    			dealJarPackage(url);
    		}
    	}
    }
    

    测试如下

    com.mec.Complex为测试所用的类
    结果为
    Test类对于一些进行了输出测试

    展开全文
  • 在某些场景中,我们需要得到某个包名下面所有的类,不仅仅是我们自己在写的包下面java类还有一些jar包(一些第三方提供的jar包里的类,一些是自己写的类)可以看下图,其结构如此: 比如我们想得到PackageScanner...

    Java 扫描指定包下类  (包括jar包中的java类)

    在某些场景中,我们需要得到某个包名下面所有的类,不仅仅是我们自己在写的包下面java类还有一些jar包(一些第三方提供的jar包里的类,一些是自己写的类)可以看下图,其结构如此:

    比如我们想得到PackageScanner.java这个类

    执行这个类

    打印出的URL即目前的包的位置的一串字符串,其中replace方法时为了将其变成路径的表示形式

    得到file文件路径

    有两种,一种是文件夹即目录,一种是文件比如.class文件

    Filed.isFile() 可以判断是否为文件。Filed.isDirectory可以判断是否为目录, 但如果是目录但进入目录后还是目录,如上图文件中com->HTT->scanner则需不断判断,如此可用递归处理。

    执行递归直至不是文件即是.class文件,再去处理(里面的方法时自己写的,读者可按照自己想要去怎么用去写相应的代码)

    jar包处理方法与此相似,下面贴出完整代码

    package com.HTT.scanner;
    
    import java.io.File;
    import java.io.IOException;
    import java.net.JarURLConnection;
    import java.net.URI;
    import java.net.URISyntaxException;
    import java.net.URL;
    import java.util.Enumeration;
    import java.util.jar.JarEntry;
    import java.util.jar.JarFile;
    
    public abstract class PackageScanner {
    	
    	public PackageScanner() {
    	}
    	
    	public abstract void dealClass(Class<?> klass);
    	
    	private void dealClassFile(String rootPackage, File curFile) {
    //        以下为我自己的处理.class方式
    		String fileName = curFile.getName();
    		if (fileName.endsWith(".class")) {
    			fileName = fileName.replaceAll(".class", "");
    			try {
    				System.out.println("...  " + rootPackage + "." + fileName);
    				Class<?> klass = Class.forName(rootPackage + "." + fileName);
    				dealClass(klass);
    			} catch (ClassNotFoundException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    	
    	private void dealDirectory(String rootPackage, File curFile) {
    //           若为目录则继续处理目录下面的目录和.class文件
    		File[] fileList = curFile.listFiles();
    		
    		for (File file : fileList) {
    			if (file.isDirectory()) {
    				rootPackage = rootPackage + '.' + file.getName();
    				System.out.println("00  " + rootPackage);
    			//按照文件处理
    				dealDirectory(rootPackage, file);
    			} else if (file.isFile()) {
    			//按照.class处理
    				dealClassFile(rootPackage, file);
    			}
    		} 
    	}
    	
    	private void dealJarPackage(URL url) {
    		try {
    //        得到路径
    			JarURLConnection connection = (JarURLConnection) url.openConnection();
    			JarFile jarFile = connection.getJarFile();
    //        循环执行看是否有实体的存在
    			Enumeration<JarEntry> jarEntries = jarFile.entries();
    			while (jarEntries.hasMoreElements()) {
    				JarEntry jar = jarEntries.nextElement();
    //                                若不是.class文件或者是目录则不处理
    //                                因为实体是一个个的比如这样的
                                        com/
                                        com/google/
                                        com/google/gson/
                                        com/google/gson/annotations/
                                        com/google/gson/internal/
                                        com/google/gson/internal/bind/
                                        com/google/gson/internal/bind/util/
    //                                会将一个个列举出来
    				if(jar.isDirectory() || !jar.getName().endsWith(".class")) {
    					continue;
    				}
    //                                此处为小编我自己的处理
    				String jarName = jar.getName();
    				jarName = jarName.replace(".class", "");
    				jarName = jarName.replace("/", ".");
    				
    				try {
    					System.out.println(jarName);
    					Class<?> klass = Class.forName(jarName);
    					dealClass(klass);
    				} catch (ClassNotFoundException e) {
    					e.printStackTrace();
    				}
    			}
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	public void packageScanner(String packageName) {
    		String rootPacksge = packageName;
    		System.out.println("packageName : " + packageName);
    		packageName = packageName.replace(".", "/");
    		System.out.println("packageName : " + packageName);
    		URL url = Thread.currentThread().getContextClassLoader().getResource(packageName);
    		System.out.println("URL : " + url);
    //判断协议名称是不是file,如果是file 则按照文件路径处理否则按照jar处理
    		if (url.getProtocol().equals("file")) {
    			URI uri;
    			try {
    				uri = url.toURI();
    				File root = new File(uri);
    				dealDirectory(rootPacksge, root);
    			} catch (URISyntaxException e) {
    				e.printStackTrace();
    			}
    		} else {
    			dealJarPackage(url);
    		}
    	}
    }
    
    package com.HTT.scanner;
    
    import java.net.URL;
    
    public class Test {
    
    	public static void main(String[] args) {
    
    		new PackageScanner() {
    		
    		@Override
    		public void dealClass(Class<?> klass) {
    			
    		}
    		}.packageScanner("com.HTT.scanner");
    	}
    
    }
    

    其中dealclass是抽象方法,当要使用此类时需实现自己处理方式。

    执行结果如下:

     

    大家可能会觉得我写成这样麻烦,实则是体现了做一个工具的思想,以后这个类就可以拿到以后直接用,实例化后在抽象方法中写上自己要如何处理这个类的代码即可,而不是简简单单的写一个一次性的代码。

    如果觉得有什么问题可以在下面评论哦,

    展开全文
  • Java 扫描包下所有类(包括jar包

    千次阅读 2017-06-26 11:20:28
    package ... import java.io.File; import java.io.FileFilter; import java.io.IOException; import java.net.JarURLConnection; import java.net.URI; import java.net.URISyntaxException; i...

     

    package com.MyUtils.file;
    import java.io.File;
    import java.io.FileFilter;
    import java.io.IOException;
    import java.net.JarURLConnection;
    import java.net.URI;
    import java.net.URISyntaxException;
    import java.net.URL;
    import java.util.ArrayList;
    import java.util.Enumeration;
    import java.util.List;
    import java.util.jar.JarEntry;
    import java.util.jar.JarFile;
    
    
    /**
     * 扫描包下路径 
     * 包括本地文件和jar包文件
     * @author ljb
     *
     */
    public class ScanningFile {
    	
    	private Class<?> superStrategy = String.class;//接口类class 用于过滤 可以不要
    	
    	private List<Class<? extends String>> eleStrategyList = new ArrayList<Class<? extends String>>();
    	
    	private ClassLoader classLoader = ScanningFile.class.getClassLoader();//默认使用的类加载器
    	
    	private static final String STARATEGY_PATH = "com.MyUtils.file";//需要扫描的策略包名
    	
    	public static void main(String[] args) {
    		ScanningFile s = new ScanningFile();
    		s.addClass();
    	}
    	 
        /**
    	 * 获取包下所有实现了superStrategy的类并加入list
    	 */
        private void addClass(){
        	URL url = classLoader.getResource(STARATEGY_PATH.replace(".", "/"));
    		String protocol = url.getProtocol();  
            if ("file".equals(protocol)) {  
                // 本地自己可见的代码  
           	    findClassLocal(STARATEGY_PATH);
            } else if ("jar".equals(protocol)) {  
                // 引用jar包的代码  
                findClassJar(STARATEGY_PATH);  
            }  
        }
        
        /**
         * 本地查找
         * @param packName
         */
    	private void findClassLocal(final String packName){
    		URI url = null ;
    		try {
    			url = classLoader.getResource(packName.replace(".", "/")).toURI();
    		} catch (URISyntaxException e1) {
    			throw new RuntimeException("未找到策略资源");
    		}
    		
    		File file = new File(url);
    		file.listFiles(new FileFilter() {
    				
    				public boolean accept(File chiFile) {
    					if(chiFile.isDirectory()){
    						findClassLocal(packName+"."+chiFile.getName());
    					}
    					if(chiFile.getName().endsWith(".class")){
    						Class<?> clazz = null;
    						try {
    							clazz = classLoader.loadClass(packName + "." + chiFile.getName().replace(".class", ""));
    						} catch (ClassNotFoundException e) {
    							e.printStackTrace();
    						}
    						System.out.println(chiFile);
    						if(superStrategy.isAssignableFrom(clazz)){
    							eleStrategyList.add((Class<? extends String>) clazz);
    						}
    						return true;
    					}
    					return false;
    				}
    			});
    		 
    	}
    	
    	/**
    	 * jar包查找
    	 * @param packName
    	 */
    	private void findClassJar(final String packName){
    		String pathName = packName.replace(".", "/");
    		JarFile jarFile  = null;
    		try {
    			URL url = classLoader.getResource(pathName);
    			JarURLConnection jarURLConnection  = (JarURLConnection )url.openConnection();
    			jarFile = jarURLConnection.getJarFile();  
    		} catch (IOException e) {
    			throw new RuntimeException("未找到策略资源");
    		}
    		
    		Enumeration<JarEntry> jarEntries = jarFile.entries();
            while (jarEntries.hasMoreElements()) {
                JarEntry jarEntry = jarEntries.nextElement();
                String jarEntryName = jarEntry.getName();
                
                if(jarEntryName.contains(pathName) && !jarEntryName.equals(pathName+"/")){
                	//递归遍历子目录
                	if(jarEntry.isDirectory()){
                		String clazzName = jarEntry.getName().replace("/", ".");
                        int endIndex = clazzName.lastIndexOf("."); 
                        String prefix = null;  
                        if (endIndex > 0) {  
                        	prefix = clazzName.substring(0, endIndex);  
                        }  
                        findClassJar(prefix);
                	}
                	if(jarEntry.getName().endsWith(".class")){
        				Class<?> clazz = null;
        				try {
        					clazz = classLoader.loadClass(jarEntry.getName().replace("/", ".").replace(".class", ""));
        				} catch (ClassNotFoundException e) {
        					e.printStackTrace();
        				}
        				if(superStrategy.isAssignableFrom(clazz)){
        					eleStrategyList.add((Class<? extends String>) clazz);
        				}
                	}
                }
                
            }
    		 
    	 }
    	
    }

     

     

     

    可以去过滤实现了特点接口的类

     

    展开全文
  • java 扫描指定包(包括jar包

    千次阅读 2019-02-16 14:00:22
    /*未经本人同意,禁止转载。 做工程时,有时候需要...以下讲解, 包扫描jar包扫描,自动识别包扫描还是jar包扫描。 //下文需要一个ClassLoader, private ClassLoader classLoader; public PackageParse() ...

    /*未经本人同意,禁止转载。

    做工程时,有时候需要扫描指定包,或者指定jar包,甚至扫描指定包下指定类,本文章详细讲解如何扫描,以及智能扫描,小编讲的很详细了仔细看。

    以下讲解, 包扫描和jar包扫描,自动识别包扫描还是jar包扫描。

    //下文需要一个ClassLoader,
    private ClassLoader classLoader;
    
    	public PackageParse() {
    	}
            
            //因为得到java文件后我们需要把该文件的类型返回给使用者,使用者有该类型,
            //就可以得到成员,方法,注解,等等 ,所以提供一个抽象方法,给使用者返回class<?>类型
    	public abstract void dealClass(Class<?> klass);
    
    
    //提供项目下的包比如  com.mec.util (或者提供com.mec.util.test.java)
    //返回值为PackageParse也就是本类型,是为了外部方便使用而已,无其他意思。
    public PackageParse scanRoot(String packName) {
                    //创建类加载器,不懂的可以百度学习下,以及classLoader.getResources
    		this.classLoader = Thread.currentThread().getContextClassLoader();
                    //packageName存放包名
    		String packageName = "";
                    //如果不含类即不是com.mec.util.test.java格式
    		if(!packName.contains(".java")) {
                            //将包名字变成路径
    			packageName = packName.replace(".", "/");
    		} else {
                            //是com.mec.util.test.java格式
                            //将路径变为com/mec/util
    			int lastIndex = packName.lastIndexOf(".");
    			int secandIndex = packName.substring(0, lastIndex).lastIndexOf(".");
                            //设置包命为com.mec.util即为去掉.test.java
    			packName = packName.substring(0, secandIndex);
                            //将路径变为com/mec/util
    			packageName = packName.substring(0, secandIndex).replace(".", "/");
    		}
    		
    		try {    
                            //加载packageName的路径返回值为Enumeration<URL>类型
    			Enumeration<URL> url = classLoader.getResources(packageName);
    			//如果包名正确且不是空包,循环
    			while(url.hasMoreElements()) {
    				URL ur = url.nextElement();
                                    //查看url的类型
    				String type = ur.getProtocol();
                                    //如果是jar包类型
    				if(type.equals("jar")) {
                                            //处理jarbao,方法在后面
    					dealJar(ur);
                                    //如果是file类型	
    				} else if(type.equals("file")) {
                                          //URL转换为file类型,File构造方法里有File(URI uri)
    					File file = new File(ur.toURI());
                                            //如果file是个目录
    					if(file.isDirectory()) {
                                                    //调用处理目录文件
    						dealFiles(packName, file);	
    					} else {
                                                    //处理文件
    						String name = file.getName();
                                                    //如果是class文件处理
    						if(name.contains(".class")) {
                                                            //调用处理java类型的文件也就是**.class,是我们想要的文件
    							deaJavaFile(file, packName);
    						} else {
                                                    //不是继续循环
    							continue;
    						}
    					}
    				}	
    			}	
    		} catch (IOException e) {
    			e.printStackTrace();
    		} catch (URISyntaxException e) {
    			e.printStackTrace();
    		}
    		
    		return this;
    	}
    
    //处理目录文件
    private void dealFiles(String packageName, File file) {	
                    //安全期间判断下文件是否存在,存在的话进行操作
    		if(file.exists()) {
                            //file一定是目录型文件所以得到该目录下所有文件遍历它们
    			File[] files = file.listFiles();
    			for(File childfile : files) {
                                    //如果子文件是目录,则递归处理,调用本方法递归。
    				if(childfile.isDirectory()) {
                                            //注意递归时候包名字要加上".文件名"后为新的包名
                                            //因为后面反射时需要类名,也就是com.mec.***
    					dealFiles(packageName + "." + childfile.getName(), childfile);
    				} else {
                                    //如果该文件不是目录。
    					String name = childfile.getName();
                                            //该文件是class类型
    					if(name.contains(".class")) {
                                                    处理它
    						deaJavaFile(childfile, packageName);
    					} else {
    						continue;
    					}
    				}
    			}	
    		} else {
    			return;
    		}	
    	}
    
    //得到了我们想要的**.class文件,处理它,我们希望返回该类型即可。
    private void deaJavaFile(File file, String packageName) {
                    //以下操作得到类型
    		int index = file.getName().lastIndexOf(".class");
    		String filename = file.getName().substring(0, index);
    		Class<?> klass = null;
    		try {
    			klass = Class.forName(packageName + "." + filename);
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    		//得到类型后,用户怎么使用这个类型是用户的事情,和工具无关,所以提供一个抽象方法将klass传过去
    		dealClass(klass);
    	}
    
    //处理jar包类型
    private void dealJar(URL url) {
                    //以下六行都是处理jar的固定方法
    		JarURLConnection jarURLConnection;
    		try {
    			jarURLConnection = (JarURLConnection) url.openConnection();
    			JarFile jarFile = jarURLConnection.getJarFile();
    			Enumeration<JarEntry> jarEntries = jarFile.entries();
    			
    			while(jarEntries.hasMoreElements()) {
    				JarEntry jar = jarEntries.nextElement();
                                    //如果是目录,或者不是**.class类型不处理
    				if(jar.isDirectory() || !jar.getName().endsWith(".class")) {
    					continue;
    				} 
                                    //处理class类型
    				String jarName = jar.getName();
    				int dotIndex = jarName.indexOf(".class");
    				String className = jarName.substring(0, dotIndex).replace("/", ".");
    				Class<?> klass = Class.forName(className);
                                    //调用抽象方法,给使用者返回Class<?>类型
    				dealClass(klass);
    			}
    				
    		} catch (IOException e) {
    			e.printStackTrace();
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    		
    	}
    //以上为智能扫描,在提供一个普通扫描方法
    //需要文件的绝对路径,和该项目下的包名字
    public PackageParse scanClassPath(String absolute,String root) { 
    		File file = new File(absolute);
    		if(file.exists()) {
    			if(file.isFile()) {
    				if(file.getName().endsWith(".java")){
    					int index = file.getName().lastIndexOf(".java");
    					String filename = file.getName().substring(0, index);
    					Class<?> klass = null;
    					try {
    						klass = Class.forName(root + "." + filename);
    						dealClass(klass);
    					} catch (ClassNotFoundException e) {
    						e.printStackTrace();
    					}
    				}	
    			}
    		} 
    		return this;
    	}

    以上为代码展示下用法

    展开全文
  • 扫描jar包工具

    2016-04-27 17:54:12
    java -jar jarscan.jar 查看help信息,可以快速扫描目标文件夹下jar包所包含的class文件相关信息
  • java读取jar包文件

    2020-02-29 21:06:51
    通过java代码读取文件的方式有很多种,那么我们应该能理解,不同的场景应该使用不同的读取方式,我在前段时间开发项目的时候遇到一个问题:项目中需要读取xml文件和properties文件,代码示例如下: //读取resources...
  • 包括我们自己在src里写的java类和一些第三方提供的jar包里的类,那么怎么来实现呢? 今天带大家来完成这件事。 src下面的类如何获取: 首先,比较简单的是得到我们自己写的类,我们先来完成这个, 项目的结构...
  • Java】包扫描Jar包扫描工具

    千次阅读 2018-10-03 00:03:47
    为什么要用到包扫描?... 包扫描可分为普通包扫描Jar包扫描扫描工具代码: 1.普通包扫描 // 给定包名及当前文件currentfile private void scanPackage(String packageName, File currentfile) {...
  • 很多框架,比如springmvc,mybatis等使用注解,为了处理注解,必然要对进行扫描,所以下面这篇文章主要给大家分享介绍了关于利用java如何实现一个扫描包的工具类,文中通过示例代码介绍的非常详细,需要的朋友可以...
  • 最近在学习maven 想用maven构建项目试试 但是却遇到问题 无法继续下面是目录结构 view是web层其他都是以jar包的形式集成在view项目中 这是view项目中的一段能访问的代码@Controllerpublic class baseController {@...
  • springboot 项目编译后无法扫描加载到子jar包中的注解解决方法
  • NULL 博文链接:https://xinglu.iteye.com/blog/1457029
  • 主要介绍了详解Java 包扫描实现和应用(Jar篇),本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • java二维码jar包

    2018-10-08 14:28:43
    ZXing是一个开放源码的,用Java实现的多种格式的1D/2D条码图像处理库,它包含了联系到其他语言的端口。Zxing可以实现使用手机的内置的摄像头完成条形码的扫描及解码,可进行二维码开发。
  • 方案一:采用reflections 框架(此框架依赖com.google.guava)2、项目依赖org.reflectionsreflections0.9.11 com.google.guava guava21.03、实现代码//入参 要扫描名Reflections f = new Reflections(...
  • 在网络上使用爬虫,将所有常见的jar组件抓取回来,用数据库保存所有对应的版本jar_list 在公开漏洞网站,获取相对应的常见jar组件的漏洞列表,用数据库保存exp_list,并和之前的jar_list进行绑定 编写审计工具,将...
  • 解决classloader的jar包

    2017-11-07 21:17:15
    包括commons-logging commons-beanutils commons-lang ezmorph json-lib-2.4-jdk15 commons-collections-3.2.1的jar包,可以解决 org/apache/commons/lang/exception/NestableRuntimeException的问题
  • 扫描包下的所有类,分类路径下扫描jar包扫描两种,其中jar包扫描又分项目中引入的三方jar包,同级maven的多个子项目jar相互引用,还有jdk jar包(这里不考虑,一般没哪个项目会扫描jdk jar包里的类). ...
  • zxing jar包

    2018-12-20 16:31:36
    ZXing是一个开放源码的,用Java实现的多种格式的1D/2D条码图像处理库,它包含了联系到其他语言的端口。Zxing可以实现使用手机的内置的摄像头完成条形码的扫描及解码。
  • java引用本地jar包报错

    2020-11-02 17:56:48
    开发工具使用的idea,所以使用idea的配置引入jar包,配置如下: 但是工程打包的时候,依旧提示程序包com.taobao.api不存在,报错如下 刚开始是以为缓存的原因,但是清理缓存之后依旧没发解决,最后,决定修改...
  • 功能强大的Swagger,可以通过注解扫描扫描自动生成API文档,可以进行在线文档调试。但是当api接口文档很多时,是不是觉得查找很不方便,官网也没有提供这样的方法,这里修改了swagger的源码,实现了接口搜索的...
  • JAVA扫描包

    千次阅读 2016-05-10 10:25:22
    我们在使用SpringMVC的时候,知道SpringMVC可以扫描指定下的所有类,在平时的开发中,我们也有这样的场景,所以今天写一个扫描包的工具类
  • socket端口扫描程序,使用java语言编写。工具:Eclipse+windowbuilder插件。实现了IP段的扫描及TCP端口的扫描
  • 更改jar包代码

    2021-03-03 13:45:54
    查看jar包的内容:这个可以使用jd-gui、luyten反编译得到源码xxx.java,方便看到整个jar包的结构。另外,使用jar命令可以将jar包解压出来:jar xvf xxx.jar(具体用法可以查看jar help)如何修改jar包中的.class文件:...
  • web端扫描apk获取名、版本号、版本名称完整代码
  • 不管是在Spring还是Mybatis中,我们都需要配置一个路径进行扫描类对象。 在Spring中,我们需要配置路径,让Spring容器能扫描包下面的Bean组件。在mybatis中,我们需要配置mapper路径,以扫描mapper接口,并...
  • Jar包重复查找工具

    2015-04-04 16:54:58
    Jar包重复查找工具,Java包冲突解决工具,非常好用,通过分析同一个目录下面的JAR类相似度达到80%,自动提示可能是重复包。 输入目录如:D:\JarLib\ 注意后面的\必须要
  • SpringBoot自动扫描管理jar包下Bean

    千次阅读 2019-12-03 13:22:32
    目录一、背景二、准备工作三、启动项目时扫描jar包下bean的三种方式1.@ComponentScan扫描方式2.自定义@Enable****的方式3.自定义xxx-boot-start依赖的方式 一、背景 在springboot项目中,我们难免会引入其他的jar包...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 94,103
精华内容 37,641
关键字:

java扫描jar包

java 订阅