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

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

使用案例：
这是我写的一个简单的带有一个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. public class ActivityMain extends Activity
7. {
8. private MyLogger logger = MyLogger.kLog();
9. private MyLogger logger2 = MyLogger.jLog();
10. @Override
11. protected void onCreate(Bundle savedInstanceState)
12. {
13. // TODO Auto-generated method stub
14. super.onCreate(savedInstanceState);
15. logger.i("This is log [01]");
16. setContentView(R.layout.main);
17. Button button = (Button) this.findViewById(R.id.button);
18. button.setOnClickListener(new OnClickListener() {
19. @Override
20. public void onClick(View arg0)
21. {
22. // TODO Auto-generated method stub
23. logger2.i("This is James action button.OnClick");
24. }
25. });
26. }
27. @Override
28. protected void onResume()
29. {
30. // TODO Auto-generated method stub
31. super.onResume();
32. logger.d("This is kesen log [02]");
33. }
34. @Override
35. protected void onPause()
36. {
37. // TODO Auto-generated method stub
38. super.onPause();
39. logger.w("This is kesen log [03]");
40. }
41. @Override
42. protected void onStop()
43. {
44. // TODO Auto-generated method stub
45. super.onStop();
46. logger.v("This is kesen log [04]");
47. }
48. @Override
49. protected void onDestroy()
50. {
51. // TODO Auto-generated method stub
52. super.onDestroy();
53. logger.e("This is kesen log [05]");
54. }
55. }

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

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

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