在Android開發中經常會使用日志來進行調試、記錄運行狀態、定位問題，但是系統提供的日志組件（android.util.Log）只提供了基本的日志輸出功能，使用上并不方面，因此需要分裝系統日志組件，擴展更豐富的功能。
主要功能
根據Gradle配置設置統一的日志開關
在項目開發中常有需要控制日志能否打印，比如，開發中要打印日志，上線后要關閉日志；再如，有些渠道要打印日志，而有些要關閉日志。
??原來都是把開關定義為一個常量
public static final boolean debug = false;
然后根據不同的情況來回來修改,不僅繁瑣而且容易遺忘。
??其實Gradle構建配置提供了一個屬性BuildConfig.DEBUG用來判斷當前構建是否是debug類型，利用這個屬性就可以解決開發中和上線的日志開關的設置。
ps.只能使用主工程的BuildConfig.DEBUG屬性，Libaray工程的構建類型都是release類型，無法區分。
但是如果要處理不同渠道應用的日志開關，就需要新建一個構建屬性，在不同的渠道配置中設置
productFlavors{
dev{
buildConfigField "boolean", "LOG_SWITCH", "true"
}
rele{
buildConfigField "boolean", "LOG_SWITCH", "false"
}
}
利用新的屬性BuildConfig.LOG_SWITCH來區分。
支持對象打印
系統日志組件只能打印字符串類型的內容，但是常有要打印自定對象內容的需要，比如返回的內容、傳遞的參數，希望以json格式展示出來。自己實現了對象轉換為json字符串功能。
ps.為什么不用第三方json庫？
??1.第三方的json庫比如Gson、Jackson,都有100-200KB，而日志組件組件只需要把對象轉換為json字符串這一個功能，不希望為此增加額外的大小。
??2.自己實現json轉換能夠做一些定制化的展示和處理
實現對象轉換為json字符串主要就是利用java反射,獲取到屬性的名稱和對應的值，再按json規則拼接成json字符串。
public String parse(Object obj){
Class clazz = obj.getClass();
Field[] fields = clazz.getDeclaredFields();
for (int i = 0, size = fields.length; i < size; i++) {
Field field = fields[i];
field.setAccessible(true);
Object suObj = field.get(obj);
String fieldName = field.getName();
String value = parse(suObj);
}
}
特殊情況：
- 非靜態內部類解析
非靜態內部類持有一個外部類的引用，這個外部類屬性是沒有必要打印出來的。編譯后內部類所持有的外部類屬性都是命名為"this$0"，利用這個特點判斷屬性名稱做過濾。 - 系統所屬類的解析
如果要解析的類或類其中的屬性涉及到系統所屬的類比如Activity、Application，我們并不希望再去解析這些系統所屬類的屬性，如果解析的話往往會導致屬性過多而一直阻塞，只要直接打印出系統所屬類的名稱就好了。
private boolean isSystemClass(Class clazz) {
String name = clazz.getName();
if (name.startsWith("java") || name.startsWith("android")) {
return true;
} else {
Class superClass = clazz.getSuperclass();
if (superClass != null) {
//如果父類是Object類則不是系統類
if (superClass.equals(Object.class)) {
return false;
} else {
return isSystemClass(superClass);
}
}
}
return false;
}
系統所屬類的包名基本都是以“java”、“android”開頭，可以以此來判斷；如果是系統所屬類的子類，需要遞歸判斷父類是否是系統所屬類。
- 類之間互相引用時的解析
如果兩個類相互引用，解析這樣類就會無線循環,拋出stackOverFlowError異常，因此增加了解析層級判斷，超過3層就不繼續解析。
快速定位到打印日志位置
打印日志后，要查看所打印地方的邏輯，還需要查找對應類所在方法的具體行數，往往這個過程就花了不少時間，而我們平時如果程序出來拋出異常，是可以直接點擊定位到具體行數的。
類似于異常打印的實現，獲取方法的調用棧信息
StackTraceElement[] elements = Thread.currentThread().getStackTrace();
for (int i = 0, size = elements.length; i < size; i++) {
element = elements[i];
if (element.getClassName().equals(MLogger.class.getName())) {
isFindTag = true;
continue;
}
if (isFindTag) {
String methodName = filterMethodName(element.getMethodName());
sb.append(element.getFileName());
sb.append(".");
sb.append(methodName);
String eleStr = element.toString();
int start = eleStr.indexOf("(");
sb.append(eleStr.substring(start));
sb.append("\n");
return sb.toString();
}
}
遍歷出調用日志打印的方法信息拼接成字符串"(類名:行數)"，如
點擊就可以快速定位到日志具體打印的地方。
無侵入打印方法執行時間
在做應用的一些性能測試的時候，有時需要打印出方法的執行時間 ，常用的方式就是在方法的前后獲取時間，計算時間差。
每處需要打印時間的地方都要都要加入這塊邏輯，導致大量重復代碼，而且與方法本身的業務耦合的也很緊密，那么有沒有更好的實現方式呢？
??使用AOP面向切面的設計實現，定義某一類方法為一個切面，在這個切面的前后計算時間，打印出時間差，這樣就統一了方法時間的計算，對方法本身無任何影響。
??AOP只是一種方法論，具體該如何實現呢？先介紹幾種方式
- jdk代理
a. jdk靜態代理
//真實類
class Real{
public void action(){
}
}
//代理類
class ProxyReal{
private Real real;
public ProxyReal(Real real){
this.real = real;
}
public void action(){
long startTime = System.nanoTime();
real.action();
long totalTime = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
Log.d(TAG, totalTime + "");
}
}
就是創建了一個代理類持有真實類的引用，并封裝了被代理類的方法，可以執行時長計算。這種方式的好處就是在編譯器就創建好了代理對象，及靜態代理，雖然把計算時長的邏輯與具體方法的業務隔離開了，但是但是要為每一個計算時長的類創建代理類，會產生大量的代理類不利于管理，而且也無法解決大量重復計算時長邏輯的問題。
b.jdk動態代理
public class Proxy implements InvocationHandler {
private Object object;
public proxy(Object obj){
this.object=obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long startTime = System.nanoTime();
Object resultObject= method.invoke(object, args);
long totalTime = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
Log.d(TAG, totalTime + "");
}
}
//執行
public static void main(String args[]){
Real target = new Real();//要進行代理的目標業務類
Proxy handler = new Proxy(target);//用代理類把目標業務類進行編織
//創建代理實例，它可以看作是要代理的目標業務類的加多了橫切代碼(方法)的一個子類
IReal proxy = (IReal )Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(), handler);
proxy.action();
}
在運行時創建了代理類，利用java反射機制執行被代理的方法。好處就是計算時長的邏輯與具體方法的業務隔離開了，只要定義一個代理對象Proxy ，就是代理其他類，這樣就只要寫一份計算時長的邏輯；但是jdk動態只能針對實現接口的類，但是我要計算時長的類并不能保證一定實現了接口，而且由于是在運行時通過反射執行被代理方法會影響一定的性能。
- CGLib
public class CglibProxy implements MethodInterceptor{
private Enhancer enhancer = new Enhancer();
public Object getProxy(Class clazz){
//設置需要創建子類的類
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
//通過字節碼技術動態創建子類實例
return enhancer.create();
}
//實現MethodInterceptor接口方法
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
long startTime = System.nanoTime();
Object result = proxy.invokeSuper(obj, args);
long totalTime = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
Log.d(TAG, totalTime + "");
return result;
}
}
public static void main(String[] args) {
CglibProxy proxy = new CglibProxy();
//通過生成子類的方式創建代理類
Real proxyImp = (Real)proxy.getProxy(Real.class);
proxyImp.action();
}
CGLib也是動態代理，在運行時通過asm（字節碼處理框架），動態構建字節碼文件，創建一個被代理類的子類，并織入計算時長的邏輯，他的好處就是被代理類不需要實現接口，方法的執行并不是利用反射，所以快很多，但是代理類的創建比jdk動態代理慢，開銷較大。
3、AspectJ
@Aspect
public class TraceAspect {
private static final String POINTCUT_METHOD =
"execution(@aop.annotation.DebugTimeTrace * *(..))";
private static final String POINTCUT_CONSTRUCTOR =
"execution(@aop.annotation.DebugTimeTrace *.new(..))";
@Pointcut(POINTCUT_METHOD)
public void methodAnnotatedWithDebugTrace() { }
@Pointcut(POINTCUT_CONSTRUCTOR)
public void constructorAnnotatedDebugTrace() { }
@Around("methodAnnotatedWithDebugTrace()||constructorAnnotatedDebugTrace()")
public Object traceTimeJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
long beginNanos = System.nanoTime();
Object result = joinPoint.proceed();
long endNanos = System.nanoTime();
long totalMillis = TimeUnit.NANOSECONDS.toMillis(endNanos - beginNanos);
Log.d("TraceAspect", createLogMsg(joinPoint, totalMillis));
return result;
}
}
@DebugTimeTrace
public void action(){
}
AspectJ是在編譯時使用自身的編譯器ajc（ajc只是在java編譯器上增加了對自己的一些關鍵字識別和編譯方法），把我們要添加的計算時長邏輯織入目標類中。
AspectJ的使用非常方便，可以通過java注解的方法來定義。
@Aspect，表示該類處理具體切面定義邏輯
@Pointcut，定義關注的切面，可以用正則表達式來過濾
@Around，定義每一個被關注的執行點的處理邏輯。
??在這個例子中我們定義了一個注解，定義關注的切面是設置這個注解的方法，然后在處理邏輯上加上時長的計算。我們想要打印哪個方法的執行時間，就只要添加這個注解就好了。真正做到了無侵入，而且是在編譯時就織入了計算時長代碼，性能也比較高。
??當然他有個條件就是必須要用自身的編譯器ajc編譯，需要在我們個構建腳本中定義這塊配置
buildscript {
repositories {
jcenter(){
url 'http://jcenter.bintray.com'
}
}
dependencies {
classpath 'org.aspectj:aspectjtools:1.8.6'
}
}
dependencies {
compile 'org.aspectj:aspectjrt:1.8.6'
compile project(':aopannotation')}repositories {
jcenter(){
url 'http://jcenter.bintray.com'
}
}
android {
compileSdkVersion 23
buildToolsVersion "25.0.1"
defaultConfig {
minSdkVersion 14
targetSdkVersion 23
versionCode 1
versionName "1.0"
testInstrumentationRunner
"android.support.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
}
android.libraryVariants.all {variant ->
def log = project.logger
LibraryPlugin plugin = project.plugins.getPlugin(LibraryPlugin)
JavaCompile javaCompile = variant.javaCompile
javaCompile.doLast {
String[] args = [
"-showWeaveInfo",
"-1.5",
"-inpath", javaCompile.destinationDir.toString(),
"-aspectpath", javaCompile.classpath.asPath,
"-d", javaCompile.destinationDir.toString(),
"-classpath", javaCompile.classpath.asPath,
"-bootclasspath", android.bootClasspath.join(File.pathSeparator)
]
MessageHandler handler = new MessageHandler(true);
new Main().run(args, handler);
for (IMessage message : handler.getMessages(null, true)) {
switch (message.getKind()) {
case IMessage.ABORT:
case IMessage.ERROR:
case IMessage.FAIL:
log.error message.message, message.thrown
break;
case IMessage.WARNING:
log.warn message.message, message.thrown
break;
case IMessage.INFO:
log.info message.message, message.thrown
break;
case IMessage.DEBUG:
log.debug message.message, message.thrown
break;
}
}
}
}
配置的代碼非常長，而且每一個要使用AspectJ功能模塊都要在其build.gradle中定義這塊配置，這又是一大串的重復代碼，有沒有更友好的方式呢，這里使用了gradle自定義插件
class MLoggerPlugin implements Plugin<Project> {
void apply(Project project) {
def hasApp = project.plugins.withType(AppPlugin)
def hasLib = project.plugins.withType(LibraryPlugin)
final def variants
final def log = project.logger
if (hasApp) {
variants = project.android.applicationVariants
} else {
variants = project.android.libraryVariants
}
project.dependencies {
debugCompile project.project(":aoplog")
debugCompile 'org.aspectj:aspectjrt:1.8.6'
compile project.project(":aopannotation")
}
variants.all { variant ->
if (!variant.buildType.isDebuggable()) {
println "Skipping non-debuggable build type '${variant.buildType.name}'."
return;
}
JavaCompile javaCompile = variant.javaCompile
javaCompile.doLast {
String[] args = [
"-showWeaveInfo",
"-1.5",
"-inpath", javaCompile.destinationDir.toString(),
"-aspectpath", javaCompile.classpath.asPath,
"-d", javaCompile.destinationDir.toString(),
"-classpath", javaCompile.classpath.asPath,
"-bootclasspath",
project.android.bootClasspath.join(File.pathSeparator)
]
MessageHandler handler = new MessageHandler(true);
new Main().run(args, handler);
for (IMessage message : handler.getMessages(null, true)) {
switch (message.getKind()) {
case IMessage.ABORT:
case IMessage.ERROR:
case IMessage.FAIL:
log.error message.message, message.thrown
break;
case IMessage.WARNING:
log.warn message.message, message.thrown
break;
case IMessage.INFO:
log.info message.message, message.thrown
break;
case IMessage.DEBUG:
log.debug message.message, message.thrown
break;
}
}
}
}
}
}
在需要使用AspectJ功能的module構建配置中引入這個插件就好了
apply plugin: com.logger.plugin.MLoggerPlugin
這對這一塊我們只想在開發時監控，因此在插件中配置debug時依賴aspectJ庫
project.dependencies {
debugCompile project.project(":aoplog")
debugCompile 'org.aspectj:aspectjrt:1.8.6'
compile project.project(":aopannotation")}
這樣對于線上版本不會使用ajc去編譯代碼。
