package com.gujin.utils;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

public class HQScanPackage
{
 /** 是否循環(huán)迭代 **/
 boolean recursive = true;
 /** 包名集合 **/
 private List<String> packageNames = new ArrayList<String>();
 /** 過(guò)濾器 **/
 private HQScanPackageFilter filter = null;
 /** 監(jiān)聽(tīng)器 **/
 private HQScanPackageListener listener = null;

 /**
 * 是否循環(huán)迭代
 * 
 * @return
 */
 public boolean isRecursive()
 {
  return recursive;
 }

 /**
 * 設(shè)置是否循環(huán)迭代
 * 
 * @param recursive
 */
 public void setRecursive(boolean recursive)
 {
  this.recursive = recursive;
 }

 /**
 * 獲得過(guò)濾器
 * 
 * @return
 */
 public HQScanPackageFilter getFilter()
 {
  return filter;
 }

 /**
 * 設(shè)置過(guò)濾器
 * 
 * @param filter
 */
 public void setFilter(HQScanPackageFilter filter)
 {
  this.filter = filter;
 }

 /**
 * 獲得監(jiān)聽(tīng)器
 * 
 * @return
 */
 public HQScanPackageListener getListener()
 {
  return listener;
 }

 /**
 * 設(shè)置監(jiān)聽(tīng)器
 * 
 * @param listener
 */
 public void setListener(HQScanPackageListener listener)
 {
  this.listener = listener;
 }

 /**
 * 添加掃描包
 * 
 * @param packageName
 */
 public void addPackage(String packageName)
 {
  if (packageName == null || !packageName.matches("[\\w]+(\\.[\\w]+)*"))
  {
   throw new IllegalArgumentException("非法包名.");
  }
  this.packageNames.add(packageName);
 }

 /**
 * 清空掃描包
 */
 public void clearPackage()
 {
  this.packageNames.clear();
 }

 /**
 * 掃描
 */
 public void scan()
 {
  for (String packageName : packageNames)
  {
   scan(packageName);
  }
 }

 /**
 * 是否接受
 * 
 * @param clazz
 * @return
 */
 private boolean accept(Class<?> clazz)
 {
  if (this.filter != null)
  {
   return this.filter.accept(clazz);
  }
  return true;
 }

 /**
 * 觸發(fā)掃描到合法類
 * 
 * @param clazz
 * @return
 */
 private void trrigerOnScanClass(Class<?> clazz)
 {
  if (this.listener != null)
  {
   this.listener.onScanClass(clazz);
  }
 }

 /**
 * 掃描到類
 * 
 * @param clazz
 * @return
 */
 private void onScanClass(Class<?> clazz)
 {
  if (accept(clazz))
  {
   trrigerOnScanClass(clazz);
  }
 }

 /**
 * 從包package中獲取所有的Class
 * 
 * @param packageName
 * @return
 */
 private void scan(String packageName)
 {
  // 獲取包的名字 并進(jìn)行替換
  String packageDirName = packageName.replace('.', '/');
  // 定義一個(gè)枚舉的集合 并進(jìn)行循環(huán)來(lái)處理這個(gè)目錄下的things
  Enumeration<URL> dirs = null;
  try
  {
   dirs = Thread.currentThread().getContextClassLoader()
    .getResources(packageDirName);
   // 循環(huán)迭代下去
   while (dirs.hasMoreElements())
   {
   // 獲取下一個(gè)元素
   URL url = dirs.nextElement();
   // 得到協(xié)議的名稱
   String protocol = url.getProtocol();
   // 如果是以文件的形式保存在服務(wù)器上
   if ("file".equals(protocol))
   {
    // 獲取包的物理路徑
    String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
    // 以文件的方式掃描整個(gè)包下的文件 并添加到集合中
    findAndAddClassesInPackageByFile(packageName, filePath);
   }
   else if ("jar".equals(protocol))
   {
    // 如果是jar包文件
    // 定義一個(gè)JarFile
    JarFile jar = null;
    try
    {
     // 獲取jar
     jar = ((JarURLConnection) url.openConnection()).getJarFile();
     // 從此jar包 得到一個(gè)枚舉類
     Enumeration<JarEntry> entries = jar.entries();
     // 同樣的進(jìn)行循環(huán)迭代
     while (entries.hasMoreElements())
     {
      // 獲取jar里的一個(gè)實(shí)體 可以是目錄 和一些jar包里的其他文件 如META-INF等文件
      JarEntry entry = entries.nextElement();
      String name = entry.getName();
      // 如果是以/開(kāi)頭的
      if (name.charAt(0) == '/')
      {
      // 獲取后面的字符串
      name = name.substring(1);
      }
      // 如果前半部分和定義的包名相同
      if (name.startsWith(packageDirName))
      {
      int idx = name.lastIndexOf('/');
      // 如果以"/"結(jié)尾 是一個(gè)包
      if (idx != -1)
      {
       // 獲取包名 把"/"替換成"."
       packageName = name.substring(0, idx).replace('/',
         '.');
      }
      // 如果可以迭代下去 并且是一個(gè)包
      if ((idx != -1) || recursive)
      {
       // 如果是一個(gè).class文件 而且不是目錄
       if (name.endsWith(".class") && !entry.isDirectory())
       {
        // 去掉后面的".class" 獲取真正的類名
        String className = name.substring(
         packageName.length() + 1,
         name.length() - 6);
        try
        {
         // 添加到classes
         // 使用Class.forName會(huì)觸發(fā)類靜態(tài)方法
         Class<?> clazz = Thread.currentThread()
          .getContextClassLoader().loadClass(
            packageName + '.' + className);
         onScanClass(clazz);
        }
        catch (ClassNotFoundException e)
        {
         System.err.println("加載類出錯(cuò)");
        }
       }
      }
      }
     }
    }
    catch (IOException e)
    {
     System.err.println("在掃描用戶定義視圖時(shí)從jar包獲取文件出錯(cuò)");
     e.printStackTrace();
    }
   }
   }
  }
  catch (IOException e)
  {
   System.err.println("掃描出錯(cuò)");
   e.printStackTrace();
  }
 }

 /**
 * 以文件的形式來(lái)獲取包下的所有Class
 * 
 * @param packageName
 * @param packagePath
 */
 private void findAndAddClassesInPackageByFile(String packageName,
   String packagePath)
 {
  // 獲取此包的目錄 建立一個(gè)File
  File dir = new File(packagePath);
  // 如果不存在或者 也不是目錄就直接返回
  if (!dir.exists() || !dir.isDirectory())
  {
   System.err.println("用戶定義包名 " + packageName + " 下沒(méi)有任何文件");
   return;
  }
  // 如果存在 就獲取包下的所有文件 包括目錄
  File[] dirfiles = dir.listFiles(new FileFilter()
  {
   // 自定義過(guò)濾規(guī)則 如果可以循環(huán)(包含子目錄) 或則是以.class結(jié)尾的文件(編譯好的java類文件)
   public boolean accept(File file)
   {
   return (recursive && file.isDirectory())
     || (file.getName().endsWith(".class"));
   }
  });
  // 循環(huán)所有文件
  for (File file : dirfiles)
  {
   // 如果是目錄 則繼續(xù)掃描
   if (file.isDirectory())
   {
   findAndAddClassesInPackageByFile(packageName + "." + file.getName(),
     file.getAbsolutePath());
   }
   else
   {
   // 如果是java類文件 去掉后面的.class 只留下類名
   String className = file.getName().substring(0,
     file.getName().length() - 6);
   try
   {
    Class<?> clazz = Thread.currentThread().getContextClassLoader()
      .loadClass(packageName + '.' + className);
    onScanClass(clazz);
   }
   catch (ClassNotFoundException e)
   {
    System.err.println("添加用戶自定義視圖類錯(cuò)誤 找不到此類的.class文件");
    e.printStackTrace();
   }
   }
  }
 }

 /**
 * 掃描包過(guò)濾器
 * 
 * @author jianggujin
 *
 */
 public static interface HQScanPackageFilter
 {
  /**
  * 是否接受
  * 
  * @param clazz
  * @return
  */
  public boolean accept(Class<?> clazz);
 }

 /**
 * 掃描包監(jiān)聽(tīng)
 * 
 * @author jianggujin
 *
 */
 public static interface HQScanPackageListener
 {
  /**
  * 掃描到合法類執(zhí)行
  * 
  * @param clazz
  */
  public void onScanClass(Class<?> clazz);
 }

 public static void main(String[] args)
 {
  HQScanPackage scanPackage = new HQScanPackage();
  scanPackage.addPackage(HQScanPackage.class.getPackage().getName());
  scanPackage.setFilter(new HQScanPackageFilter()
  {

   @Override
   public boolean accept(Class<?> clazz)
   {
   return true;
   }
  });
  scanPackage.setListener(new HQScanPackageListener()
  {

   @Override
   public void onScanClass(Class<?> clazz)
   {
   System.out.println(clazz);
   }
  });
  scanPackage.scan();
 }
}

class com.gujin.utils.HQScanPackage$1 
class com.gujin.utils.HQScanPackage$2 
class com.gujin.utils.HQScanPackage$3 
interface com.gujin.utils.HQScanPackage$HQScanPackageFilter 
interface com.gujin.utils.HQScanPackage$HQScanPackageListener 
class com.gujin.utils.HQScanPackage