分享一个我使用的bat可以方便使用java环境1.7

[lozn00]

@echo off
cd %~dp0
set aapt_path=aapt.exe
set PATH=F:\dev\jdk1.7.0_80_64\bin;%PATH%
java -version
echo 上面列出的是您的JAVA版本必须为7.0 不能大于等于8.0
pause
java -Xmx2048m -XX:-UseParallelGC -XX:MinHeapFreeRatio=15 -jar libs\icodetools_1.0.jar %~dp0 src.apk %aapt_path% jw cn.wjdiankong.jw.utils.JWUtils printStackTrace
adb install -r signed.apk
pause..

[lozn00]

支持自动过滤的

package cn.wjdiankong.jw.utils;

import android.text.TextUtils;
import android.util.Log;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.lang.reflect.Method;
import java.util.ArrayList;

public class JWUtils {

private static final String TAG = "JWUtilsFilter";
//过滤规则
public static String logSwitch = null;
public static String filterMethodName = null;
public static String filterMethodReturnType = null;
public static String filterMethodParamType = null;
public static String filterClassName = null;
public static String cmdLineStr = null;
public static ArrayList<String> classFilterlists = new ArrayList<>();//键为className,如果 指定一个过滤类名则一直会开始过滤 ， 如果突然改成指定方法了，那么其他方法都不会过滤了。
public static ArrayList<String> classAndMethodlists = new ArrayList<>();//键为className,如果 指定一个过滤类名则一直会开始过滤 ， 如果突然改成指定方法了，那么其他方法都不会过滤了。

public static long fileModifyTime = System.currentTimeMillis();
public static File file = new File("/data/local/tmp/log.txt");
public static Method[] allMethods;
private static boolean pritnStatck;
private static boolean startAutoFilterClassMethodSign = false;
private static boolean startAutoFilterClass = true;

static {
    cmdLineStr = getCmdArgs();
    parseCmdLineArgs(cmdLineStr);
    fileModifyTime = file.lastModified();
}

private static boolean filterFullClassMatcher;

/**
 * 打印堆栈信息
 *
 * @param tag
 */
public static void printErrorStatckTrace(String tag) {
    if (!isShowLog()) {
        return;
    }


    StackTraceElement[] stackElements = new Throwable().getStackTrace();
    String className = stackElements[1].getClassName();
    boolean haIgnoreClass = classFilterlists.contains(className);
    if (haIgnoreClass) {
        return;
    }

    String currentFucllCall = getCurrentFucllCall(stackElements);
    boolean containsFull = classAndMethodlists.contains(currentFucllCall);
    if (containsFull) {

// Log.w(TAG, "printErrorStatckTrace忽略方法" + currentFucllCall);
return;
}
if (startAutoFilterClassMethodSign) {
synchronized (JWUtils.class) {
if (!classAndMethodlists.contains(currentFucllCall)) {
classAndMethodlists.add(currentFucllCall);
Log.w(TAG, "printErrorStatckTrace下次自动忽略:" + currentFucllCall);
}
}
}
if (startAutoFilterClass) {
classFilterlists.add(className);
Log.w(TAG, "printErrorStatckTrace插入类名忽略:" + className);
return;
}
if (!isFilterInfo(stackElements[1])) {
return;
}

    try {
        throw new NullPointerException();
    } catch (Exception e) {
        Log.d(tag, "++++++++++++++++++Start-Error++++++++++++++++++" + getCurrentFucllCall(stackElements));
        if (pritnStatck) {
            Log.d(tag, "" + e.getLocalizedMessage());
            Log.d(tag, "++++++++++++++++++++Eror-End++++++++++++++++++\n\n");

        }
    }
}

/**
 * 打印堆栈信息
 *
 * @param tag
 */

public static void printStackTrace(String tag) {
    if (!isShowLog()) {
        return;
    }//TMAssistantDownloadSDKService
    StackTraceElement[] stackElements = new Throwable().getStackTrace();
    StackTraceElement stackElement = stackElements[1];
    String className = stackElement.getClassName();
    boolean haIgnoreClass = classFilterlists.contains(className);
    if (haIgnoreClass) {
        //有过滤 则需要看过滤模式了

// Log.w(TAG, "printStackTrace忽略class:" + className);
return;//只是类名过滤
}
String currentFucllCall = getCurrentFucllCall(stackElements);
boolean containsFull = classAndMethodlists.contains(currentFucllCall);
if (containsFull) {
// Log.w(TAG, "printStackTrace忽略方法" + currentFucllCall);
return;
}
if (startAutoFilterClassMethodSign) {
synchronized (JWUtils.class) {
if (!classAndMethodlists.contains(currentFucllCall)) {

                classAndMethodlists.add(currentFucllCall);
                Log.w(TAG, "下次自动忽略classMethod:" + currentFucllCall);
            }
        }
    }

    if (startAutoFilterClass) {
        classFilterlists.add(className);
        Log.w(TAG, "下次自动忽略class:" + currentFucllCall);
    }
    if (!isFilterInfo(stackElements[1])) {
        return;
    }
    if (stackElements != null) {
        Log.d(tag, "+【key:" + currentFucllCall + "】");
        if (pritnStatck) {
            Log.d(tag, "++++++++++++++++++Start++++++++++++++++++");

            for (int i = 0; i < stackElements.length; i++) {
                Log.d(tag, stackElements[i].toString());
            }
            Log.d(tag, "++++++++++++++++++++End++++++++++++++++++\n\n");

        }
    }
}

public static boolean isFilterInfo(StackTraceElement ment) {
    boolean isClassName = isFilterClassName(ment);
    boolean isMethodName = isFilterMethodName(ment);
    boolean isMethodReturnT = isFilterMethodReturnType(ment);
    boolean isMethodParamT = isFilterMethodParamType(ment);
    return isClassName && isMethodName && isMethodReturnT && isMethodParamT;
}

/**
 * 如果方法找不到那就算了找到了如果有多个 多个必须一起填写.
 *
 * @param stackElements
 * @return
 */
public static String getCurrentFucllCall(StackTraceElement[] stackElements) {
    if (stackElements.length >= 2) {
        StackTraceElement stackElement = stackElements[1];//0表示自己 1表示调用自己的位置
        String className = stackElement.getClassName();
        String methodName = stackElement.getMethodName();
        StringBuffer sb = new StringBuffer();
        try {
            Class<?> aClass = Class.forName(className);

            Method[] declaredMethods = aClass.getDeclaredMethods();
            for (int i = 0; i < declaredMethods.length; i++) {

                Method declaredMethod = declaredMethods[i];
                if (declaredMethod.getName().equals(methodName)) {

                    if (sb.length() == 0) {
                        sb.append("" + declaredMethod.toString());
                    } else {
                        sb.append("_" + declaredMethod.toString());
                    }
                }
            }
        } catch (ClassNotFoundException | NoClassDefFoundError e) {
            sb.append("_method_" + methodName);
            e.printStackTrace();
        }
        String temp = sb.toString().replace(" ", "-");
        String code = className + temp;//第三层会导致空指针
        if (stackElements.length >= 3) {
            code += "【From" + stackElements[2].getClassName() + "】";
        }

        return code;
    } else {
        return "";
    }

    //sun.reflect.NativeMethodAccessorImpl.invoke0Fromsun.reflect.NativeMethodAccessorImpl.sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)()-2
}


/**
 * 过滤方法
 *
 * @param ment
 * @return
 */
private static boolean isFilterMethodName(StackTraceElement ment) {
    if (TextUtils.isEmpty(filterMethodName)) {
        return true;
    }
    String methodName = ment.getMethodName();
    if (TextUtils.isEmpty(methodName)) {
        return true;
    }
    if (filterMethodName.equals(methodName)) {
        return true;
    }
    return false;
}

/**
 * 过滤类名
 *
 * @param ment
 * @return
 */
private static boolean isFilterClassName(StackTraceElement ment) {
    if (TextUtils.isEmpty(filterClassName)) {
        return true;
    }
    String className = ment.getClassName();
    if (TextUtils.isEmpty(filterClassName)) {
        return true;
    }
    if (filterClassName.equals(className)) {
        return true;
    }
    return false;
}

/**
 * 过滤方法返回类型
 *
 * @param ment
 * @return
 */
private static boolean isFilterMethodReturnType(StackTraceElement ment) {
    if (TextUtils.isEmpty(filterMethodReturnType)) {
        return true;
    }
    getClassAllMethod(ment);
    for (Method method : allMethods) {
        if (method.getName().equals(ment.getMethodName())) {
            Class<?> returnType = method.getReturnType();
            String returnTypeS = getTypeSign(returnType);
            if (returnTypeS.equals(filterMethodReturnType)) {
                System.out.println("returntype:" + returnTypeS + "," + filterMethodReturnType);
                return true;
            }
        }
    }
    return false;
}

/**
 * 过滤方法参数类型
 *
 * @param ment
 * @return
 */
private static boolean isFilterMethodParamType(StackTraceElement ment) {
    if (TextUtils.isEmpty(filterMethodParamType)) {
        return true;
    }
    getClassAllMethod(ment);
    for (Method method : allMethods) {
        if (method.getName().equals(ment.getMethodName())) {
            Class<?>[] paramTypes = method.getParameterTypes();
            StringBuilder sb = new StringBuilder();
            for (Class<?> paramT : paramTypes) {
                sb.append(getTypeSign(paramT) + ";");
            }
            if (sb.toString().contains(filterMethodParamType)) {
                System.out.println("paramtype:" + sb.toString() + "," + filterMethodParamType);
                return true;
            }
        }
    }
    return false;
}

/**
 * 获取类中所有的方法信息
 *
 * @param ment
 */
private static void getClassAllMethod(StackTraceElement ment) {
    try {
        Class<?> objClass = Class.forName(ment.getClassName());
        Method[] methods1 = objClass.getMethods();
        Method[] methods2 = objClass.getDeclaredMethods();
        allMethods = new Method[methods1.length + methods2.length];
        for (int i = 0; i < methods1.length; i++) {
            allMethods[i] = methods1[i];
        }
        for (int j = methods1.length; j < methods1.length + methods2.length; j++) {
            allMethods[j] = methods2[j - methods1.length];
        }
    } catch (Throwable e) {
    }
}

/**
 * ͨ获取签名信息
 *
 * @param typeClass
 * @return
 */
private static String getTypeSign(Class<?> typeClass) {
    if (boolean.class == typeClass) {
        return "Z";
    }
    if (byte.class == typeClass) {
        return "B";
    }
    if (short.class == typeClass) {
        return "S";
    }
    if (int.class == typeClass) {
        return "I";
    }
    if (float.class == typeClass) {
        return "F";
    }
    if (double.class == typeClass) {
        return "D";
    }
    if (long.class == typeClass) {
        return "J";
    }
    if (char.class == typeClass) {
        return "C";
    }

    String className = typeClass.getName();
    if (className == null) {
        return "";
    }

    return className.replace(".", "/");
}

/**
 * @return
 */
private static boolean isShowLog() {
    if (fileModifyTime != file.lastModified()) {
        fileModifyTime = file.lastModified();
        cmdLineStr = getCmdArgs();
        parseCmdLineArgs(cmdLineStr);
    }
    if ("1".equals(logSwitch)) {
        return true;
    }
    return false;
}

/**
 * 获取命令行参数信息
 *
 * @return
 */
public static String getCmdArgs() {
    File file = new File("/data/local/tmp/log.txt");
    BufferedReader bf = null;
    try {
        bf = new BufferedReader(new FileReader(file));
        String line = null;
        while ((line = bf.readLine()) != null) {
            if (line != null) {
                return line;
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (bf != null)
                bf.close();
        } catch (Exception e) {

        }
    }
    return null;
}

/* protected void static String getReflxMessage(String className,String methodName){
try {
Class<?> aClass = Class.forName(className);
Method declaredMethod = aClass.getDeclaredMethod(aClass, methodName);
} catch (ClassNotFoundException e) {

    }
}
public Method findMethod(){

}*/

/**
 * 解析命令行参数信息
 * -s 1 -m JW -r int -p [int,java.lang.String] -c JWUtils
 *
 * @param cmdLine
 */
private static void parseCmdLineArgs(String cmdLine) {
    try {
        cmdLine = cmdLine.replaceAll("  ", " ");
        String[] strAry = cmdLine.split(" ");
        for (int i = 0; i < strAry.length; i += 2) {
            switch (strAry[i]) {
                case "autofilter":
                    if (i + 1 < strAry.length) {
                        startAutoFilterClassMethodSign = Boolean.parseBoolean(strAry[i + 1]);
                    } else {
                        startAutoFilterClassMethodSign = !startAutoFilterClassMethodSign;
                    }
                    Log.w(TAG, "自动过滤模式为:" + startAutoFilterClassMethodSign + ",将会把所有调用的类方法自动过滤");
                    break;
                case "autofilterclass":
                    if (i + 1 < strAry.length) {
                        startAutoFilterClass = Boolean.parseBoolean(strAry[i + 1]);
                    } else {
                        startAutoFilterClass = !startAutoFilterClass;
                    }
                    Log.w(TAG, "自动过滤模式为:" + startAutoFilterClass + ",将会把所有呗调用的类自动过滤");
                    break;
                case "print":
                    pritnStatck = true;
                    break;
                case "closeprint":
                    pritnStatck = false;
                    break;
                case "-s":
                    logSwitch = strAry[i + 1];
                    break;
                case "-clear":
                    Log.w(TAG, "清空过滤class和classandmethod集合，原来集合总数为：" + classFilterlists.size() + "," + classFilterlists + "," + classAndMethodlists.size() + ",方法过滤" + classAndMethodlists);
                    classFilterlists.clear();

                    break;
                case "-addfullfilter":
                    addFullFilterLine(strAry[i + 1]);
                    break;
                case "-addfilter":
                    addClassFilterLine(strAry[i + 1]);
                    break;
              /*  case "-addfull":
                    filterFullClassMatcher = true;
                    Log.w(TAG, "完全匹配必须保持一致才过滤忽略");
                    break;
                case "-removefull":
                    filterFullClassMatcher = true;
                    Log.w(TAG, "模糊匹配只要className等于就忽略");
                    break;*/
                case "-m":
                    filterMethodName = strAry[i + 1];
                    break;
                case "-r":
                    filterMethodReturnType = getTypeSign(strAry[i + 1]);
                    break;
                case "-p":
                    filterMethodParamType = strAry[i + 1];
                    try {
                        String[] arys = filterMethodParamType.substring(1, filterMethodParamType.length() - 1).split(",");
                        StringBuilder sb = new StringBuilder();
                        for (String str1 : arys) {
                            sb.append(getTypeSign(str1) + ";");
                        }
                        filterMethodParamType = sb.toString();
                    } catch (Exception e) {
                    }
                    break;
                case "-c":
                    filterClassName = strAry[i + 1];
                    break;
            }
        }
    } catch (Exception e) {
    }
}

private static boolean addClassFilterLine(String className) {
 /*   if (strAry.length < i + 1) {
        Log.e(TAG, "无法添加addFilter 后面无参数,所以启动自动移除"+classFilterlists.size()+",map:"+classFilterlists);
        classFilterlists.clear();
        return true;
    }*/
    if (className.indexOf(",") != -1) {
        String[] split = className.split(",");
        Log.w(TAG, "检测到多行进行添加 总数：" + split.length);
        for (String s : split) {
            addClassFilterLine(s);
        }
        return true;//直接处理每一行添加
    }

    if (!classFilterlists.contains(className)) {
        classFilterlists.add(className);
        Log.w(TAG, "忽略类名" + className);//使用 获取那个键名方法进行过滤

    } else {
        Log.w(TAG, "重复添加" + className);
    }
    return false;
}

private static boolean addFullFilterLine(String className) {
 /*   if (strAry.length < i + 1) {
        Log.e(TAG, "无法添加addFilter 后面无参数,所以启动自动移除"+classFilterlists.size()+",map:"+classFilterlists);
        classFilterlists.clear();
        return true;
    }*/
    if (className.indexOf(",") != -1) {
        String[] split = className.split(",");
        Log.w(TAG, "检测到多行进行添加 总数：" + split.length);
        for (String s : split) {
            addClassFilterLine(s);
        }
        return true;//直接处理每一行添加
    }

    if (!classAndMethodlists.contains(className)) {
        classAndMethodlists.add(className);
        Log.w(TAG, "忽略类名" + className);//使用 获取那个键名方法进行过滤

    } else {
        Log.w(TAG, "重复添加" + className);
    }
    return false;
}

/**
 * @param type
 * @return
 */
private static String getTypeSign(String type) {
    switch (type) {
        case "boolean":
            return getTypeSign(boolean.class);
        case "byte":
            return getTypeSign(byte.class);
        case "short":
            return getTypeSign(short.class);
        case "int":
            return getTypeSign(int.class);
        case "char":
            return getTypeSign(char.class);
        case "float":
            return getTypeSign(float.class);
        case "double":
            return getTypeSign(double.class);
        case "long":
            return getTypeSign(long.class);
    }
    try {
        return getTypeSign(Class.forName(type));
    } catch (Exception e) {
        return null;
    }
}

}

[lozn00]

签名文件有待改进哈，建议弄一个支持填写密钥的签名文件，我签名都是右键apk就签名了，很方便

[lozn00]

va -jar apksigner.jar -appname test -keystore E:\sign\1111.keystore -alias 11111 -pswd 11111"D:\360极速浏览器下载\icodetools-master\icodetools-master\signed.apk

[goodhacker]

UNEXPECTED TOP-LEVEL EXCEPTION:
java.lang.RuntimeException: Exception parsing classes
at com.android.dx.command.dexer.Main.processClass(Main.java:752)
at com.android.dx.command.dexer.Main.processFileBytes(Main.java:718)
at com.android.dx.command.dexer.Main.access$1200(Main.java:85)
at com.android.dx.command.dexer.Main$FileBytesConsumer.processFileBytes(
Main.java:1645)
at com.android.dx.cf.direct.ClassPathOpener.processArchive(ClassPathOpen
er.java:284)
at com.android.dx.cf.direct.ClassPathOpener.processOne(ClassPathOpener.j
ava:166)
at com.android.dx.cf.direct.ClassPathOpener.process(ClassPathOpener.java
:144)
at com.android.dx.command.dexer.Main.processOne(Main.java:672)
at com.android.dx.command.dexer.Main.processAllFiles(Main.java:574)
at com.android.dx.command.dexer.Main.runMonoDex(Main.java:311)
at com.android.dx.command.dexer.Main.run(Main.java:277)
at com.android.dx.command.dexer.Main.main(Main.java:245)
at com.android.dx.command.Main.main(Main.java:106)
at cn.wjdiankong.jw.DoWorkUtils.jar2Dex(DoWorkUtils.java:147)
at cn.wjdiankong.jw.JWMain.main(JWMain.java:89)
Caused by: com.android.dx.cf.iface.ParseException: bad class file magic (cafebab
e) or version (0034.0000)
at com.android.dx.cf.direct.DirectClassFile.parse0(DirectClassFile.java:
472)
at com.android.dx.cf.direct.DirectClassFile.parse(DirectClassFile.java:4
06)
at com.android.dx.cf.direct.DirectClassFile.parseToInterfacesIfNecessary
(DirectClassFile.java:388)
at com.android.dx.cf.direct.DirectClassFile.getMagic(DirectClassFile.jav
a:251)
at com.android.dx.command.dexer.Main.parseClass(Main.java:764)
at com.android.dx.command.dexer.Main.access$1500(Main.java:85)
at com.android.dx.command.dexer.Main$ClassParserTask.call(Main.java:1684
)
at com.android.dx.command.dexer.Main.processClass(Main.java:749)
... 14 more
Uncaught translation error: com.android.dx.cf.code.SimException: expected type f
loat but found int
2 errors; aborting