封装一个简单好用的打印Log的工具类And快速开发系列 10个常用工具类

快速开发系列 10个常用工具类

http://blog.csdn.net/lmj623565791/article/details/38965311

------------------------------------------------------------------------------------------------

不知众多Android开发者是否在程序开发的工程中也遇到过下面的问题：

0.如何在众多log中快速找到你设置打印的那行log？

1.是否还在不断的切换标签来查看使用不同TAG标签打印的log?

2.找到需要的log后是否苦恼不能快速定位到Java源代码中查看？

起初我也和大多数Android开发者一样，使用官方的打印log的方法，设置TAG，在Eclipse里面设置过滤标签，切换来回的看Log，可是这样却效率很低，会遇到上面所述的问题，那么现在我就把学习到的一种方便快捷的打印Log的方法分享给大家，有不对的地方还望不吝赐教，谢谢。

Log类具有的功能

0.使用一个标签来标记当前的AP（避免设置过多的TAG来过滤显示不同Java文件下的Log）

1.支持多用户打印Log（在AP比较大，文件比较多，每人负责的模块不同时，可以使用自己的log来打印，这样看log的时候可以快速筛选出当前AP中你所设置的Log，比如只看     kesen的log就可以在Eclipse的filter里面输入kesen，这样显示的就都是你的log了）

2.显示当前的线程名

3.显示当前的Java文件与打印log的行号，便于快速定位到源文件

4.显示当前是在那个方法体里面

5.最后显示你设置打印出来的信息

下面是一个打印Log的工具类：

  1. /** 
  2.  * The class for print log 
  3.  * @author kesenhoo 
  4.  * 
  5.  */  
  6. public class MyLogger  
  7. {  
  8.     private final static boolean                logFlag         = true;  
  9.       
  10.     public final static String                  tag             = "[AppName]";  
  11.     private final static int                    logLevel        = Log.VERBOSE;  
  12.     private static Hashtable<String, MyLogger>    sLoggerTable    = new Hashtable<String, MyLogger>();  
  13.     private String                              mClassName;  
  14.       
  15.     private static MyLogger                     jlog;  
  16.     private static MyLogger                     klog;  
  17.       
  18.     private static final String                 JAMES           = "@james@ ";  
  19.     private static final String                 KESEN           = "@kesen@ ";  
  20.       
  21.     private MyLogger(String name)  
  22.     {  
  23.         mClassName = name;  
  24.     }  
  25.       
  26.     /** 
  27.      *  
  28.      * @param className 
  29.      * @return 
  30.      */  
  31.     @SuppressWarnings("unused")  
  32.     private static MyLogger getLogger(String className)  
  33.     {  
  34.         MyLogger classLogger = (MyLogger) sLoggerTable.get(className);  
  35.         if(classLogger == null)  
  36.         {  
  37.             classLogger = new MyLogger(className);  
  38.             sLoggerTable.put(className, classLogger);  
  39.         }  
  40.         return classLogger;  
  41.     }  
  42.       
  43.     /** 
  44.      * Purpose:Mark user one 
  45.      * @return 
  46.      */  
  47.     public static MyLogger kLog()  
  48.     {  
  49.         if(klog == null)  
  50.         {  
  51.             klog = new MyLogger(KESEN);  
  52.         }  
  53.         return klog;  
  54.     }  
  55.     /** 
  56.      * Purpose:Mark user two 
  57.      * @return 
  58.      */  
  59.     public static MyLogger jLog()  
  60.     {  
  61.         if(jlog == null)  
  62.         {  
  63.             jlog = new MyLogger(JAMES);  
  64.         }  
  65.         return jlog;  
  66.     }  
  67.       
  68.     /** 
  69.      * Get The Current Function Name 
  70.      * @return 
  71.      */  
  72.     private String getFunctionName()  
  73.     {  
  74.         StackTraceElement[] sts = Thread.currentThread().getStackTrace();  
  75.         if(sts == null)  
  76.         {  
  77.             return null;  
  78.         }  
  79.         for(StackTraceElement st : sts)  
  80.         {  
  81.             if(st.isNativeMethod())  
  82.             {  
  83.                 continue;  
  84.             }  
  85.             if(st.getClassName().equals(Thread.class.getName()))  
  86.             {  
  87.                 continue;  
  88.             }  
  89.             if(st.getClassName().equals(this.getClass().getName()))  
  90.             {  
  91.                 continue;  
  92.             }  
  93.             return mClassName + "[ " + Thread.currentThread().getName() + ": "  
  94.                     + st.getFileName() + ":" + st.getLineNumber() + " "  
  95.                     + st.getMethodName() + " ]";  
  96.         }  
  97.         return null;  
  98.     }  
  99.       
  100.     /** 
  101.      * The Log Level:i 
  102.      * @param str 
  103.      */  
  104.     public void i(Object str)  
  105.     {  
  106.         if(logFlag)  
  107.         {  
  108.             if(logLevel <= Log.INFO)  
  109.             {  
  110.                 String name = getFunctionName();  
  111.                 if(name != null)  
  112.                 {  
  113.                     Log.i(tag, name + " - " + str);  
  114.                 }  
  115.                 else  
  116.                 {  
  117.                     Log.i(tag, str.toString());  
  118.                 }  
  119.             }  
  120.         }  
  121.           
  122.     }  
  123.       
  124.     /** 
  125.      * The Log Level:d 
  126.      * @param str 
  127.      */  
  128.     public void d(Object str)  
  129.     {  
  130.         if(logFlag)  
  131.         {  
  132.             if(logLevel <= Log.DEBUG)  
  133.             {  
  134.                 String name = getFunctionName();  
  135.                 if(name != null)  
  136.                 {  
  137.                     Log.d(tag, name + " - " + str);  
  138.                 }  
  139.                 else  
  140.                 {  
  141.                     Log.d(tag, str.toString());  
  142.                 }  
  143.             }  
  144.         }  
  145.     }  
  146.       
  147.     /** 
  148.      * The Log Level:V 
  149.      * @param str 
  150.      */  
  151.     public void v(Object str)  
  152.     {  
  153.         if(logFlag)  
  154.         {  
  155.             if(logLevel <= Log.VERBOSE)  
  156.             {  
  157.                 String name = getFunctionName();  
  158.                 if(name != null)  
  159.                 {  
  160.                     Log.v(tag, name + " - " + str);  
  161.                 }  
  162.                 else  
  163.                 {  
  164.                     Log.v(tag, str.toString());  
  165.                 }  
  166.             }  
  167.         }  
  168.     }  
  169.       
  170.     /** 
  171.      * The Log Level:w 
  172.      * @param str 
  173.      */  
  174.     public void w(Object str)  
  175.     {  
  176.         if(logFlag)  
  177.         {  
  178.             if(logLevel <= Log.WARN)  
  179.             {  
  180.                 String name = getFunctionName();  
  181.                 if(name != null)  
  182.                 {  
  183.                     Log.w(tag, name + " - " + str);  
  184.                 }  
  185.                 else  
  186.                 {  
  187.                     Log.w(tag, str.toString());  
  188.                 }  
  189.             }  
  190.         }  
  191.     }  
  192.       
  193.     /** 
  194.      * The Log Level:e 
  195.      * @param str 
  196.      */  
  197.     public void e(Object str)  
  198.     {  
  199.         if(logFlag)  
  200.         {  
  201.             if(logLevel <= Log.ERROR)  
  202.             {  
  203.                 String name = getFunctionName();  
  204.                 if(name != null)  
  205.                 {  
  206.                     Log.e(tag, name + " - " + str);  
  207.                 }  
  208.                 else  
  209.                 {  
  210.                     Log.e(tag, str.toString());  
  211.                 }  
  212.             }  
  213.         }  
  214.     }  
  215.       
  216.     /** 
  217.      * The Log Level:e 
  218.      * @param ex 
  219.      */  
  220.     public void e(Exception ex)  
  221.     {  
  222.         if(logFlag)  
  223.         {  
  224.             if(logLevel <= Log.ERROR)  
  225.             {  
  226.                 Log.e(tag, "error", ex);  
  227.             }  
  228.         }  
  229.     }  
  230.       
  231.     /** 
  232.      * The Log Level:e 
  233.      * @param log 
  234.      * @param tr 
  235.      */  
  236.     public void e(String log, Throwable tr)  
  237.     {  
  238.         if(logFlag)  
  239.         {  
  240.             String line = getFunctionName();  
  241.             Log.e(tag, "{Thread:" + Thread.currentThread().getName() + "}"  
  242.                     + "[" + mClassName + line + ":] " + log + " ", tr);  
  243.         }  
  244.     }  
  245. }  
  1.   


关于里面的代码就不做解释了，大家看看应该差不多

使用案例：
这是我写的一个简单的带有一个button与textview的Activity,演示一下点击button与Activity的常规生命周期。

  1. import android.app.Activity;  
  2. import android.os.Bundle;  
  3. import android.view.View;  
  4. import android.view.View.OnClickListener;  
  5. import android.widget.Button;  
  6.   
  7. public class ActivityMain extends Activity  
  8. {  
  9.     private MyLogger logger = MyLogger.kLog();  
  10.     private MyLogger logger2 = MyLogger.jLog();  
  11.       
  12.     @Override  
  13.     protected void onCreate(Bundle savedInstanceState)  
  14.     {  
  15.         // TODO Auto-generated method stub  
  16.         super.onCreate(savedInstanceState);  
  17.         logger.i("This is log [01]");  
  18.         setContentView(R.layout.main);  
  19.           
  20.         Button button = (Button) this.findViewById(R.id.button);  
  21.         button.setOnClickListener(new OnClickListener() {  
  22.               
  23.             @Override  
  24.             public void onClick(View arg0)  
  25.             {  
  26.                 // TODO Auto-generated method stub  
  27.                 logger2.i("This is James action button.OnClick");  
  28.             }  
  29.         });  
  30.     }  
  31.       
  32.     @Override  
  33.     protected void onResume()  
  34.     {  
  35.         // TODO Auto-generated method stub  
  36.         super.onResume();  
  37.         logger.d("This is kesen log [02]");  
  38.     }  
  39.       
  40.     @Override  
  41.     protected void onPause()  
  42.     {  
  43.         // TODO Auto-generated method stub  
  44.         super.onPause();  
  45.         logger.w("This is kesen log [03]");  
  46.     }  
  47.   
  48.     @Override  
  49.     protected void onStop()  
  50.     {  
  51.         // TODO Auto-generated method stub  
  52.         super.onStop();  
  53.         logger.v("This is kesen log [04]");  
  54.     }  
  55.       
  56.     @Override  
  57.     protected void onDestroy()  
  58.     {  
  59.         // TODO Auto-generated method stub  
  60.         super.onDestroy();  
  61.         logger.e("This is kesen log [05]");  
  62.     }  
  63. }  

下面是用这个log工具类打印出来的Log效果：

从上面的解释差不多可以看出这个Log工具类具有的功能：
0.使用一个标签来标记当前的AP
1.支持多用户打印Log（在AP比较大，文件比较多，每人负责的模块不同时，可以使用自己的log来打印，这样看log的时候可以快速筛选出当前AP中你所设置的Log，比如只看     kesen的log就可以在Eclipse的filter里面输入kesen，这样显示的就都是你的log了）
2.显示当前的线程名
3.显示当前的Java文件与打印log的行号，便于快速定位到源文件
4.显示当前是在那个方法体里面
5.最后显示你设置打印出来的信息


写的不好，有不对的地方还请见谅，谢谢！

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/ArRan/p/4829422.html