Java經常使用工具類

時間 2019-11-12

標籤 java 經常使用工具欄目 Java 简体版

原文原文鏈接

`集合操做工具類： 1.判斷是否爲空：isEmpty() 2.判斷是否非空：isNotEmpty() 代碼： import org.apache.commons.collections.CollectionUtils; import java.util.Collection; public class CollectionUtil { /** * 判斷集合是否非空 */ public static boolean isNotEmpty(Collection<?> collection) { return CollectionUtils.isNotEmpty(collection); }java

/**
               * 判斷集合是否爲空
               */
              public static boolean isEmpty(Collection<?> collection) {
                  return CollectionUtils.isEmpty(collection);
              }
          }

類加載器工具類： 1.獲取類加載器：Thread.currentThread().getContextClassLoader() 2.獲取類路徑： getClassPath() 3.加載類文件 4.異常處理 5.判斷類型代碼： import java.net.URL; public class ClassUtil { /** * 獲取類加載器： Thread.currentThread().getContextClassLoader() */ public static ClassLoader getClassLoader() { return Thread.currentThread().getContextClassLoader(); }redis

/**
             * 獲取類路徑
             */
            public static String getClassPath() {
                String classpath = "";
                URL resource = getClassLoader().getResource("");
                if (resource != null) {
                    classpath = resource.getPath();
                }
                return classpath;
            }

            /**
             * 加載類（將自動初始化）
             */
            public static Class<?> loadClass(String className) {
                return loadClass(className, true);
            }

            /**
             * 加載類
             */
            public static Class<?> loadClass(String className, boolean isInitialized) {
                try {
                    return Class.forName(className, isInitialized, getClassLoader());
                } catch (ClassNotFoundException e) {
                    throw new RuntimeException("加載類出錯：" + e.getMessage(), e);
                }
            }

            /**
             * 是否爲 int 類型（包括 Integer 類型）
             */
            public static boolean isInt(Class<?> type) {
                return type.equals(int.class) || type.equals(Integer.class);
            }

            /**
             * 是否爲 long 類型（包括 Long 類型）
             */
            public static boolean isLong(Class<?> type) {
                return type.equals(long.class) || type.equals(Long.class);
            }

            /**
             * 是否爲 double 類型（包括 Double 類型）
             */
            public static boolean isDouble(Class<?> type) {
                return type.equals(double.class) || type.equals(Double.class);
            }

            /**
             * 是否爲 String 類型
             */
            public static boolean isString(Class<?> type) {
                return type.equals(String.class);
            }

加載幫助類工具類： 1.編寫相應的方法 2.綁定類標識 3.初始化[定義相關的幫助類和實現加載幫助類] 代碼： //導入相關Jar import org.slf4j.Logger; import org.slf4j.LoggerFactory; public final class HelperLoader { private static final Logger logger = LoggerFactory.getLogger(HelperLoader.class); public static final boolean IS_SERVLET25; static { boolean b; try { Class.forName("包名.類名$標識名"); b = false; } catch(Throwable t) { b = true; } IS_SERVLET25 = b; logger.info("[fw] servlet25 " + IS_SERVLET25); } //存在這個類 private static class 標識名 {} public static void init() { // 定義須要加載的 Helper 類 Class<?>[] classList = { DataSourceHolder.class, //初始化ds JedisHolder.class, //初始化redis EntityHelper.class, ActionHelper.class, BeanHelper.class, AopHelper.class, IocHelper.class, PluginHelper.class, }; // 按照順序加載類 for (Class<?> cls : classList) { ClassUtil.loadClass(cls.getName()); } } }apache

加載AOP框架工具類： 1.獲取ClassScanner[類掃描器] 2.編寫相關的代理 3.添加相關的代理代碼： //導入相關的jar import java.lang.annotation.Annotation; import java.util.*; public class AopHelper {框架

/**
          * 獲取 ClassScanner
          */
         private static final ClassScanner classScanner = InstanceFactory.getClassScanner();

         static {
             try {
                 // 建立 Proxy Map（用於 存放代理類 與 目標類列表 的映射關係）
                 Map<Class<?>, List<Class<?>>> proxyMap = createProxyMap();
                 // 建立 Target Map（用於 存放目標類 與 代理類列表 的映射關係）
                 Map<Class<?>, List<Proxy>> targetMap = createTargetMap(proxyMap);
                 // 遍歷 Target Map
                 for (Map.Entry<Class<?>, List<Proxy>> targetEntry : targetMap.entrySet()) {
                     // 分別獲取 map 中的 key 與 value
                     Class<?> targetClass = targetEntry.getKey();
                     List<Proxy> proxyList = targetEntry.getValue();
                     // 建立代理實例
                     Object proxyInstance = ProxyManager.createProxy(targetClass, proxyList);
                     // 用代理實例覆蓋目標實例，並放入 Bean 容器中
                     BeanHelper.setBean(targetClass, proxyInstance);
                 }
             } catch (Exception e) {
                 throw new InitializationError("初始化 AopHelper 出錯！", e);
             }
         }

         private static Map<Class<?>, List<Class<?>>> createProxyMap() throws Exception {
             Map<Class<?>, List<Class<?>>> proxyMap = new LinkedHashMap<Class<?>, List<Class<?>>>();
             // 添加相關代理
             addPluginProxy(proxyMap);      // 插件代理
             addAspectProxy(proxyMap);      // 切面代理
             addTransactionProxy(proxyMap); // 事務代理
             return proxyMap;
         }

         private static void addPluginProxy(Map<Class<?>, List<Class<?>>> proxyMap) throws Exception {
             // 獲取插件包名下父類爲 PluginProxy 的全部類（插件代理類）
             List<Class<?>> pluginProxyClassList = classScanner.getClassListBySuper(FrameworkConstant.PLUGIN_PACKAGE, PluginProxy.class);
             if (CollectionUtil.isNotEmpty(pluginProxyClassList)) {
                 // 遍歷全部插件代理類
                 for (Class<?> pluginProxyClass : pluginProxyClassList) {
                     // 建立插件代理類實例
                     PluginProxy pluginProxy = (PluginProxy) pluginProxyClass.newInstance();
                     // 將插件代理類及其所對應的目標類列表放入 Proxy Map 中
                     proxyMap.put(pluginProxyClass, pluginProxy.getTargetClassList());
                 }
             }
         }

         private static void addAspectProxy(Map<Class<?>, List<Class<?>>> proxyMap) throws Exception {
             // 獲取切面類（全部繼承於 BaseAspect 的類）
             List<Class<?>> aspectProxyClassList = ClassHelper.getClassListBySuper(AspectProxy.class);
             // 添加插件包下全部的切面類
             aspectProxyClassList.addAll(classScanner.getClassListBySuper(FrameworkConstant.PLUGIN_PACKAGE, AspectProxy.class));
             // 排序切面類
             sortAspectProxyClassList(aspectProxyClassList);
             // 遍歷切面類
             for (Class<?> aspectProxyClass : aspectProxyClassList) {
                 // 判斷 Aspect 註解是否存在
                 if (aspectProxyClass.isAnnotationPresent(Aspect.class)) {
                     // 獲取 Aspect 註解
                     Aspect aspect = aspectProxyClass.getAnnotation(Aspect.class);
                     // 建立目標類列表
                     List<Class<?>> targetClassList = createTargetClassList(aspect);
                     // 初始化 Proxy Map
                     proxyMap.put(aspectProxyClass, targetClassList);
                 }
             }
         }

         private static void addTransactionProxy(Map<Class<?>, List<Class<?>>> proxyMap) {
             // 使用 TransactionProxy 代理全部 Service 類
             List<Class<?>> serviceClassList = ClassHelper.getClassListByAnnotation(Service.class);
             proxyMap.put(TransactionProxy.class, serviceClassList);
         }

         private static void sortAspectProxyClassList(List<Class<?>> proxyClassList) {
             // 排序代理類列表
             Collections.sort(proxyClassList, new Comparator<Class<?>>() {
                 @Override
                 public int compare(Class<?> aspect1, Class<?> aspect2) {
                     if (aspect1.isAnnotationPresent(AspectOrder.class) || aspect2.isAnnotationPresent(AspectOrder.class)) {
                         // 如有 Order 註解，則優先比較（序號的值越小越靠前）
                         if (aspect1.isAnnotationPresent(AspectOrder.class)) {
                             return getOrderValue(aspect1) - getOrderValue(aspect2);
                         } else {
                             return getOrderValue(aspect2) - getOrderValue(aspect1);
                         }
                     } else {
                         // 若無 Order 註解，則比較類名（按字母順序升序排列）
                         return aspect1.hashCode() - aspect2.hashCode();
                     }
                 }

                 private int getOrderValue(Class<?> aspect) {
                     return aspect.getAnnotation(AspectOrder.class) != null ? aspect.getAnnotation(AspectOrder.class).value() : 0;
                 }
             });
         }

         private static List<Class<?>> createTargetClassList(Aspect aspect) throws Exception {
             List<Class<?>> targetClassList = new ArrayList<Class<?>>();
             // 獲取 Aspect 註解的相關屬性
             String pkg = aspect.pkg();
             String cls = aspect.cls();
             Class<? extends Annotation> annotation = aspect.annotation();
             // 若包名不爲空，則需進一步判斷類名是否爲空
             if (StringUtil.isNotEmpty(pkg)) {
                 if (StringUtil.isNotEmpty(cls)) {
                     // 若類名不爲空，則僅添加該類
                     targetClassList.add(ClassUtil.loadClass(pkg + "." + cls, false));
                 } else {
                     // 若註解不爲空且不是 Aspect 註解，則添加指定包名下帶有該註解的全部類
                     if (annotation != null && !annotation.equals(Aspect.class)) {
                         targetClassList.addAll(classScanner.getClassListByAnnotation(pkg, annotation));
                     } else {
                         // 不然添加該包名下全部類
                         targetClassList.addAll(classScanner.getClassList(pkg));
                     }
                 }
             } else {
                 // 若註解不爲空且不是 Aspect 註解，則添加應用包名下帶有該註解的全部類
                 if (annotation != null && !annotation.equals(Aspect.class)) {
                     targetClassList.addAll(ClassHelper.getClassListByAnnotation(annotation));
                 }
             }
             return targetClassList;
         }

         private static Map<Class<?>, List<Proxy>> createTargetMap(Map<Class<?>, List<Class<?>>> proxyMap) throws Exception {
             Map<Class<?>, List<Proxy>> targetMap = new HashMap<Class<?>, List<Proxy>>();
             // 遍歷 Proxy Map
             for (Map.Entry<Class<?>, List<Class<?>>> proxyEntry : proxyMap.entrySet()) {
                 // 分別獲取 map 中的 key 與 value
                 Class<?> proxyClass = proxyEntry.getKey();
                 List<Class<?>> targetClassList = proxyEntry.getValue();
                 // 遍歷目標類列表
                 for (Class<?> targetClass : targetClassList) {
                     // 建立代理類（切面類）實例
                     Proxy baseAspect = (Proxy) proxyClass.newInstance();
                     // 初始化 Target Map
                     if (targetMap.containsKey(targetClass)) {
                         targetMap.get(targetClass).add(baseAspect);
                     } else {
                         List<Proxy> baseAspectList = new ArrayList<Proxy>();
                         baseAspectList.add(baseAspect);
                         targetMap.put(targetClass, baseAspectList);
                     }
                 }
             }
             return targetMap;
         }
     }
                 }`