Android开发中ExecutorService线程池的应用教程
首先我们先了解一下到底什么是线程池，只有了解了其中的道理，我们才能够进行应用...java.util.concurrent.ExecutorService表述了异步执行的机制
首先我们简单的举一个例子...
package executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Executor {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("cc");
ExecutorService executorService=Executors.newFixedThreadPool(10);
executorService.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
System.out.println("aa");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
});
System.out.println("bb");
}
}
这里我们指定了十个线程处于一个线程池内部，线程池的原理其实就是对多线程的一个管理，为了实现异步机制的一种方法，其实就是多个线程执行多个任务，最终这些线程通过线程池进行管理...不用手动去维护...一次可以处理多个任务，这样就可以迅速的进行相应...比如说一个网站成为了热点网站，那么对于大量的点击量，就必须要对每一次的点击做出迅速的处理，这样才能达到更好的交互效果...这样就需要多个线程去处理这些请求，以便能够更好的提供服务...
1. 简单的说一下如何创建线程池进行初始化....创建线程有几种常用方式...这里都是使用了Executors工厂来实例化对象，同时我们也可以根据需求自己去写一个ExecutorService...这几种常用的方法有一定的区别...
ExecutorService executorService1 = Executors.newSingleThreadExecutor();
ExecutorService executorService2 = Executors.newFixedThreadPool(10);
ExecutorService executorService3 = Executors.newScheduledThreadPool(10);
ExecutorService executorService4 = Executors.newCacheThreadPool();
Executors.newSingleThreadExecutor()
单例线程，表示在任意的时间段内，线程池中只有一个线程在工作...
Executors.newCacheThreadPool()
缓存线程池，先查看线程池中是否有当前执行线程的缓存，如果有就resue(复用),如果没有,那么需要创建一个线程来完成当前的调用.并且这类线程池只能完成一些生存期很短的一些任务.并且这类线程池内部规定能resue(复用)的线程，空闲的时间不能超过60s,一旦超过了60s,就会被移出线程池.
Executors.newFixedThreadPool(10) 固定型线程池，和newCacheThreadPool()差不多，也能够实现resue(复用),但是这个池子规定了线程的最大数量，也就是说当池子有空闲时，那么新的任务将会在空闲线程中被执行，一旦线程池内的线程都在进行工作，那么新的任务就必须等待线程池有空闲的时候才能够进入线程池,其他的任务继续排队等待.这类池子没有规定其空闲的时间到底有多长.这一类的池子更适用于服务器.
Executors.newScheduledThreadPool(10)
调度型线程池,调度型线程池会根据Scheduled(任务列表)进行延迟执行，或者是进行周期性的执行.适用于一些周期性的工作.
这就是线程池创建的几种方式...我们需要根据不同的需求来适当的选择到底使用哪种线程池...
2.那么创建了线程池以后就需要对线程池进行调用..将任务加载到其中...
i.ExecutorService.execute(Runnable);
第一种调用方式...通过这种方式将线程任务加载到线程池当中...我们可以添加多个任务...贴上一个完整的代码...大家看一下代码的解释就明白到底是怎么回事了..不难理解...
package executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Executor {
/**
* @param args
*
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ExecutorService executorService=Executors.newFixedThreadPool(2);//定义了线程池中最大存在的线程数目...
//添加了第一个任务...这个任务会一直被执行...
executorService.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
System.out.println("aa");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
});
//添加第二个任务，被执行三次停止...
executorService.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
int i=0;
while(true){
i++;
System.out.println("bb");
if(i==3){
break;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
});
/*
* @param
* 第三个任务...只有当第二个任务被执行三次之后才能被执行...
* 由于三次前，线程池已经满了,这个任务是轮不到被执行的..只能排队进行等待.
* 三次之后，第二个任务被终止，也就是线程池中出现了空闲的状态，所以这个任务将被放入到线程池中执行...
* */
executorService.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
System.out.println("cc");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
});
}
}
ii.executorService.submit(Runnable) 第二种调用方式...这种方式与第一种的区别在于可以使用一个Future对象来判断当前的线程是否执行完毕...但是这种方法只能判断当前的线程是否执行完毕，无法返回数据信息...
Future future = executorService.submit(new Runnable() {
public void run() {
System.out.println("Asynchronous task");
}
});
//如果任务结束执行则返回 null
System.out.println("future.get()=" + future.get());
iii.executorService.submit(Callable)... 第三种调用方式...这种调用方式与前一种有所不同，传递的参数为Callable对象，Callable与Runnbale很相似，但是Callable的call()方法可以返回数据信息...通过Future就能够获取到其中的信息..而Runnbale.run()方法时无法获取数据信息的....Future应用于多线程...可以获取call()方法返回的数据信息...其实他是一种模式，是为了性能优化而提供的一种思想...这里我就不说Future...
uture future = executorService.submit(new Callable(){
public Object call() throws Exception {
System.out.println("Asynchronous Callable");
return "Callable Result";
}
});
System.out.println("future.get() = " + future.get());
//上述样例代码会输出如下结果：
//Asynchronous Callable
//future.get() = Callable Result
iv.inVokeAny()...第四种调用方式...方法 invokeAny() 接收一个包含 Callable 对象的集合作为参数。调用该方法不会返回 Future 对象，而是返回集合中某一个 Callable 对象的结果，而且无法保证调用之后返回的结果是哪一个Callable，只知道它是这些 Callable 中一个执行结束的 Callable 对象...说实话这个方法我不知道它创建的目的到底是什么...这里执行后的结果是随机的...也就是输出是不固定的....
ExecutorService executorService = Executors.newSingleThreadExecutor();
Set<Callable<String>> callables = new HashSet<Callable<String>>();
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 1";
}
});
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 2";
}
});
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 3";
}
});
String result = executorService.invokeAny(callables);
System.out.println("result = " + result);
v.inVokeAll()这个方法和上面不同的地方就在于它可以返回所有Callable的执行结果...获取到所有的执行结果，我们可以对其进行管理...相对而言，我觉得这个方法比上一个更实用吧...
ExecutorService executorService = Executors.newSingleThreadExecutor();
Set<Callable<String>> callables = new HashSet<Callable<String>>();
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 1";
}
});
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 2";
}
});
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 3";
}
});
List<Future<String>> futures = executorService.invokeAll(callables);
for(Future<String> future : futures){
System.out.println("future.get = " + future.get());
3.线程池的关闭...
当我们不需要使用线程池的时候，我们需要对其进行关闭...有两种方法可以关闭掉线程池...
i.shutdown()...
shutdown并不是直接关闭线程池，而是不再接受新的任务...如果线程池内有任务，那么把这些任务执行完毕后，关闭线程池....
ii.shutdownNow()
这个方法表示不再接受新的任务，并把任务队列中的任务直接移出掉，如果有正在执行的，尝试进行停止...
大家自己试着运行下面的代码就了解其中到底是怎么回事了...
package executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Executor {
/**
* @param args
*
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ExecutorService executorService=Executors.newFixedThreadPool(1);//定义了线程池中最大存在的线程数目...
//添加了第一个任务...这个执行三次停止...
executorService.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
int j=0;
while(true){
j++;
System.out.println("aa");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(j==3){
break;
}
}
}
});
//添加第二个任务，由于使用executorService.shutdown()，由于它的加入是在这个方法调用之前的，因此这个任务也会被执行...
//如果我们使用了executorService.shutdownNow();方法，就算是他在之前加入的，由于调用了executorService.shutdownNow()方法
//那么这个任务将直接被移出队列并且不会被执行...
executorService.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
int i=0;
while(true){
i++;
System.out.println("bb");
if(i==3){
break;
}
}
}
});
executorService.shutdown();//这里无论使用了那种方法,都会抛出一个异常...
/*
* @param
* 第三个任务...只有当第二个任务被执行三次之后才能被执行...
* 由于三次前，线程池已经满了,这个任务是轮不到被执行的..只能排队进行等待.
* 三次之后，第二个任务被终止，也就是线程池中出现了空闲的状态，所以这个任务将被放入到线程池中执行...
* */
executorService.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
System.out.println("cc");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
});
}
}ExecutorService线程池的用法
在Java5之后，并发线程这块发生了根本的变化，最重要的莫过于新的启动、调度、管理线程的一大堆API了。在Java5以后，通过 Executor来启动线程比用Thread的start()更好。在新特征中，可以很容易控制线程的启动、执行和关闭过程，还可以很容易使用线程池的特性。
一、创建任务
任务就是一个实现了Runnable接口的类。
创建的时候实run方法即可。
二、执行任务
通过java.util.concurrent.ExecutorService接口对象来执行任务，该接口对象通过工具类java.util.concurrent.Executors的静态方法来创建。
Executors此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。
ExecutorService提供了管理终止的方法，以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。 可以关闭 ExecutorService，这将导致其停止接受新任务。关闭后，执行程序将最后终止，这时没有任务在执行，也没有任务在等待执行，并且无法提交新任务。
executorService.execute(new TestRunnable());
1、创建ExecutorService
通过工具类java.util.concurrent.Executors的静态方法来创建。
Executors此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。
比如，创建一个ExecutorService的实例，ExecutorService实际上是一个线程池的管理工具：
ExecutorService executorService = Executors.newCachedThreadPool();
ExecutorService executorService = Executors.newFixedThreadPool(3);
ExecutorService executorService = Executors.newSingleThreadExecutor();
2、将任务添加到线程去执行
当将一个任务添加到线程池中的时候，线程池会为每个任务创建一个线程，该线程会在之后的某个时刻自动执行。
三、关闭执行服务对象
executorService.shutdown();
五、获取任务的执行的返回值
在Java5之后，任务分两类：一类是实现了Runnable接口的类，一类是实现了Callable接口的类。两者都可以被 ExecutorService执行，但是Runnable任务没有返回值，而Callable任务有返回值。并且Callable的call()方法只能通过ExecutorService的(<T> task) 方法来执行，并且返回一个 <T><T>，是表示任务等待完成的 Future。
public interface Callable<V>
返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做 call 的方法。
Callable 接口类似于，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。
类包含一些从其他普通形式转换成 Callable 类的实用方法。
Callable中的call()方法类似Runnable的run()方法，就是前者有返回值，后者没有。
当将一个Callable的对象传递给ExecutorService的submit方法，则该call方法自动在一个线程上执行，并且会返回执行结果Future对象。
同样，将Runnable的对象传递给ExecutorService的submit方法，则该run方法自动在一个线程上执行，并且会返回执行结果Future对象，但是在该Future对象上调用get方法，将返回null。
遗憾的是，在Java API文档中，这块介绍的很糊涂，估计是翻译人员还没搞清楚的缘故吧。或者说是注释不到位。下面看个例子：
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
publicclass CallableDemo {
publicstaticvoid main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
List<Future<String>> resultList = new ArrayList<Future<String>>();
//创建10个任务并执行
for (int i = 0; i < 10; i++) {
//使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中
Future<String> future = executorService.submit(new TaskWithResult(i));
//将任务执行结果存储到List中
resultList.add(future);
}
//遍历任务的结果
for (Future<String> fs : resultList) {
try {
System.out.println(fs.get()); //打印各个线程（任务）执行的结果
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
} finally {
//启动一次顺序关闭，执行以前提交的任务，但不接受新任务。如果已经关闭，则调用没有其他作用。
executorService.shutdown();
}
}
}
}
class TaskWithResult implements Callable<String> {
privateint id;
public TaskWithResult(int id) {
this.id = id;
}
public String call() throws Exception {
System.out.println("call()方法被自动调用,干活！！！ " + Thread.currentThread().getName());
//一个模拟耗时的操作
for (int i = 999999; i > 0; i--) ;
return"call()方法被自动调用，任务的结果是：" + id + " " + Thread.currentThread().getName();
}
}
运行结果：
call()方法被自动调用,干活！！！ pool-1-thread-1
call()方法被自动调用,干活！！！ pool-1-thread-3
call()方法被自动调用,干活！！！ pool-1-thread-4
call()方法被自动调用,干活！！！ pool-1-thread-6
call()方法被自动调用,干活！！！ pool-1-thread-2
call()方法被自动调用,干活！！！ pool-1-thread-5
call()方法被自动调用，任务的结果是：0 pool-1-thread-1
call()方法被自动调用，任务的结果是：1 pool-1-thread-2
call()方法被自动调用,干活！！！ pool-1-thread-2
call()方法被自动调用,干活！！！ pool-1-thread-6
call()方法被自动调用,干活！！！ pool-1-thread-4
call()方法被自动调用，任务的结果是：2 pool-1-thread-3
call()方法被自动调用,干活！！！ pool-1-thread-3
call()方法被自动调用，任务的结果是：3 pool-1-thread-4
call()方法被自动调用，任务的结果是：4 pool-1-thread-5
call()方法被自动调用，任务的结果是：5 pool-1-thread-6
call()方法被自动调用，任务的结果是：6 pool-1-thread-2
call()方法被自动调用，任务的结果是：7 pool-1-thread-6
call()方法被自动调用，任务的结果是：8 pool-1-thread-4
call()方法被自动调用，任务的结果是：9 pool-1-thread-3
几种不同的ExecutorService线程池对象
1.newCachedThreadPool() -缓存型池子，先查看池中有没有以前建立的线程，如果有，就reuse.如果没有，就建一个新的线程加入池中
-缓存型池子通常用于执行一些生存期很短的异步型任务
因此在一些面向连接的daemon型SERVER中用得不多。
-能reuse的线程，必须是timeout IDLE内的池中线程，缺省timeout是60s,超过这个IDLE时长，线程实例将被终止及移出池。
注意，放入CachedThreadPool的线程不必担心其结束，超过TIMEOUT不活动，其会自动被终止。
2. newFixedThreadPool -newFixedThreadPool与cacheThreadPool差不多，也是能reuse就用，但不能随时建新的线程
-其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子
-和cacheThreadPool不同，FixedThreadPool没有IDLE机制（可能也有，但既然文档没提，肯定非常长，类似依赖上层的TCP或UDP IDLE机制之类的），所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器
-从方法的源代码看，cache池和fixed 池调用的是同一个底层池，只不过参数不同:
fixed池线程数固定，并且是0秒IDLE（无IDLE）
cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力），60秒IDLE
3.ScheduledThreadPool -调度型线程池
-这个池子里的线程可以按schedule依次delay执行，或周期执行
4.SingleThreadExecutor -单例线程，任意时间池中只能有一个线程
-用的是和cache池和fixed池相同的底层池，但线程数目是1-1,0秒IDLE（无IDLE）
上面四种线程池，都使用Executor的缺省线程工厂建立线程，也可单独定义自己的线程工厂
下面是缺省线程工厂代码:
static class DefaultThreadFactory implements ThreadFactory {
static final AtomicInteger poolNumber = new AtomicInteger(1);
final ThreadGroup group;
final AtomicInteger threadNumber = new AtomicInteger(1);
final String namePrefix;
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null)? s.getThreadGroup() :Thread.currentThread().getThreadGroup();
namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-";
}
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(),0);
if (t.isDaemon())
t.setDaemon(false);
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
return t;
}
}
也可自己定义ThreadFactory，加入建立池的参数中
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
Executor的execute()方法
execute() 方法将Runnable实例加入pool中,并进行一些pool size计算和优先级处理
execute() 方法本身在Executor接口中定义,有多个实现类都定义了不同的execute()方法
如ThreadPoolExecutor类（cache,fiexed,single三种池子都是调用它）的execute方法如下：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
if (runState == RUNNING && workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);
}
else if (!addIfUnderMaximumPoolSize(command))
reject(command); // is shutdown or saturated
}
}
一、前言
对抗反编译是指让apk文件或者dex文件无法正常通过反编译工具，而且有可能导致工具异常或者崩溃，如apktool、baksmali、dex2jar、JEB等等工具，如下图dex2jar无法正常工作。
二、Dex文件格式解析
目前大多数android软件的反编译工具都是开源的，比如apktool、Dex2jar、baksamli，大家可以非常方便的从github下载并源阅读代码，然后找到可以利用的点，再在自己的软件中加入干扰代码，让反编译工具出现异常或者无法正常阅读代码。
接下来让我们先来熟悉一下dex文件格式 ,一个dex文件由以下几个部份组成：
1. Dex Header： Dex结构头它指定了dex文件的一些基本属性，并记录了部份数据表在dex文件中的物理偏移。 2. String Table： 字符串表，存储字符串的索引和个数 3. Type Table： 类型表，存储类型的索引和个数 4. Proto Table： 函数元型表，存储函数元型索引和个数 5. Field Table： 字段表，存储字段索引和个数 6. Method Table： 方法表，存储方法索引和个数 7. Class def Table：类定义表，存储类定义索引和个数 8. Data Section： 存储数据，由以上类型的索引查找，
有兴趣的可以直接翻看android的源码或者参考以下链接：
http://www.netmite.com/android/mydroid/dalvik/docs/dex-format.html
既然要在代码中添加干扰指令，接下的DexClassDef结构，肯定是要了解的非常清楚。
结构中包含了类的类型偏移、访问标志、父类类型索引、接口偏移、注释、静态类型的偏移信息，整体结构图定义如下：
struct DexClassDef
{
u4 classIdx；
u4 accessFlags；
u4 superclassIdx；
u4 interfacesOff；
u4 sourcefileIdx；
u4 annotationsOff；
u4 classDataOff；
u4 staticValuesOff；
}
classIdx 字段是一个索引值，类的类型，做为下标索引在DexTypeID结构列表中查找
accessFlags 字段是类的访问标志，以ACC_开头的枚举值
superclassIdx 字段是父类的类型,做为下标索引在DexTypeID结构列表中查找
interfacesOff 字段是接口类型，做为下标索引在DexTypeList结构列表中查找
sourcefileIdx 字段是源文件名，做为下标索引在DexTypeList结构列表中查找
annotationsOff 字段是注释信息的偏移，指向DexAnnotationsDirectoryItem结构
classdataOff 字段是指向了DexClassData结构体的偏移
staticValuesOff 字段是指向DexEncodeArray结构体的偏移，记录静态数据的信息
DexClassData结构说明:
struct DexClassData
{
DexClassDataHeader header;
DexField* staticFields； //静态字段，DexField结构
DexField* instanceFields； //实例字段，DexField结构
DexMethod* directMethods； //直接方法，DexMethod结构
DexMethod* virtualMethods； //虚方法， DexMethod结构
}
DexClassData结构中的DexMethod类型描述了：方法的原型、名称、访问标志以及代码数据块，codeOff字段指向了一个DexCode结构，它描述了方法更详细的信息以及方法中指令的内容。
DexMethod结构声明如下
struct DexMethod
{
u4 methodIdx； //指向DexMethodId的索引
u4 accessFlags；//访问标志
u4 codeOff； //指向dexCode的结构偏移
}
struct DexCode
{
ushort registerSsize；//使用的寄存器的数目
ushort insSize； //传入参数的数目
unshort outsSize； //调用其他方法时使用的寄存器个数
unshort triesSize； //try/catch异常块个数
uint debugInfoOff； //调试信息的偏移
uint insnsSize； //指令集个数
ushort insns[1]； //指令集数组，变长数组
}
DexClassData树型结构图：
：
三、调试dex2jar工程
1. 将dex2jar源码导入IntelliJ IDEA，导入后IntelliJ IDEA会自动查找对应 Grable并下载，需要比较长的时间等待
源码地址: https://github.com/pxb1988/dex2jar
2. 选中Grable中的dex2jar/dex2jar/Tasks/other/antlr2java进行编译
3. 点击工具栏的 Project Structure， 然后选择Modules -> d2j-smali -> build，然后点击Excluded
4. 选择 build/generated-sources/antlr， 然后点击 Sources
5. 最后打开Excluded Gradle Task弹出对话框，运行clean distZip 命令
执行完Gradl clean distZip命令后会在\dex2jar-2.x\dex-tools\build\distributions目录下生成 dex-tools-2.1-SNAPSHOT.zip，压缩包内是编译完后生成的jar文件和一些配置信息文件。大家请参考dex2jar.sh文件，它向我们说明需要使用lib目录下的所有jar文件和入口函数com.googlecode.dex2jar.tools.Dex2jarCmd 才能将dex文件转换成jar文件
6.将dex文件转换成jar文件需要执行转换命令
格式如下:
java -Xms512m -Xmx1024m -classpath .\lib\*.jar “com.googlecode.dex2jar.tools.Dex2jarCmd” classdex.dex
根据以上的命令，来配置调试参数，设置如下：
7.设置完成后，就可以开始调试
四、dex2jar反编译失败原因分析
1.首先我们从解包失败的错误异常入手,定位崩溃处的代码。
通过错误提示可以定位到dex2jar崩溃处的代码，源码位置如下：
dex-ir\src\main\java\com\googlecode\dex2jar\ir\TypeClass.java
2. 在崩溃的函数处下断点，开始调试。
a)通过抛出的异常的说明“cant not merge I and Z”，以及整个调用堆栈。
我们可以看出造成这个异常的原因是函数调用时，实参的类型和形参类型不匹配引起的。因为在Java语法中，将实参是布尔类型传递给形参是int类型。这样是不合法的，所以导致dex2jar在检查的参数类型的时候失败。
b)知道了崩溃的原因,那我们就需要确定它具体是使用怎样的方法做到的,通过dex2jar生成的error异常信息详细说明文件得知该dex文件中的每一个函数头部都加了一句这样的代码Exit.b(Exit.a())请看Ida，现在大致能猜到混淆者所做的工作：
1.首先解析dex文件格式,定位到DexCode结构中的insns成员
2.向代码中添加一个类成员对象名字叫Exit，然后添加代码Exit.b(Exit.a())
3.明白了怎么添加干扰代码，接下来分析一下dex2jar的工作流程，dex2jar转换成jar文件这个过程中会验证，函数调用时的形参和实参的合法性，请看下图，解析到INVOKE_开头的指令时，会开始解析返回值，供给参数，和实参等信息，具体逻辑和代码大家有兴趣可以详细地研究一下dex2jar源码。
4.merge负责的工作是参数类型的验证，如果两个类型相同，返回形参的类型，形参为UNKONW返回实参，实参为UNKONW返回形参，两个类型都不相同，则匹配异常
5.最后在dex2jar里添加代码，使dex文件能正确的被反编译成功。这里给出一段可以成功让dex2jar反编译的出jar文件的代码（其实方法有很多）
下图是成功反编译的jar文件
本文我们讲讲Android开发中比较高级的内容，应用程序组成部分，Manifest文件，Manifest文件节点，在Android平台的应用程序开发过程中,Manifest文件举足轻重。每一个应用程序都要有一个Manifest文件,他配置了应用程序在Android系统上的基本信息。
Android应用程序的组成部分和Manifest文件
Android应用程序由松散耦合的组件组成，并使用应用程序Manifest绑定到一起；应用程序Manifest描述了每一组件和它们之间的交互方式，还用于指定应用程序元数据、其硬件和平台要求、外部库以及必需的权限。
一、应用程序的基本结构模块
· Activity：应用程序的表示层。每个UI都是通过Activity类的一个或多个扩展实现的。Activity使用Fragment和视图来布局和显示信息，以及响应用户动作。
· Service：应用程序中不可见的工作者。运行时没有UI，可以更新数据源和Activity、触发通知和广播Intent。可以用来执行一个运行时间长的任务，或者不需要和用户交互的任务。
· Content Provider：可共享的持久数据存储器（内容提供者）。用来管理和持久化应用程序数据，通常会与SQL数据库交互。可以通过配置自己的Content Provider来允许其他应用程序访问，也可以访问其他应用。
· Intent：消息传递框架。Android中大量使用了Intent、Service或者Broadcast Receiver广播消息，以及请求对特定的一条数据执行操作。
· Broadcast Receiver： Intent侦听器（广播接收者）。可以监听到那些匹配指定的过滤标准的Intent广播。它会自动地启动应用程序来响应某个接收到Intent。
· Widget：可视化应用程序组件。它是Broadcast Receiver的特殊变体，可用于创建动态的交互式应用程序组件，用户可以把这些组件添加到他们的主屏幕上。
· Notification：它允许向用户发送信号，但却不会过分吸引他们的注意力或者打断他们当前的Activity。它们是应用程序不可见或者不活动时吸引用户注意的首选方法。
二、Manifest文件简介
每一个Android项目都包含一个Manifest文件——Android Manifest.xml，它存储在项目层次中的最底层。Manifest可以定义用用程序及其组件和需求的结构和元数据。
Manifest包含了组成应用程序的每一个Activity、Service、Content Provider和Broadcast Receiver的节点，并使用Intent Filter和权限来确定这些组件和其他应用程序是如何交互的。此文件还可以指定应用程序的元数据（图标、版本号、主题等等） 以及额外的顶层节点，这些节点可以指定必需的安全权限和单元测试，以及定义硬件、屏幕和平台支持要求。
Manifest文件有一个根manifest标签构成，该标签带有一个被设为项目包的package属性。它通常包含一个xmls:android属性来提供文件内使用的某些系统属性。
使用versionCode属性可讲当前的应用版本定义为一个整数，每次版本更新，这个数字都会增加。使用versionName可以定义一个显示给用户的公共版本号。
installLocation属性，是制定是否允许将程序安装到SD卡上，其值有preferExternal（首选外部存储器）和auto（系统决定）。不指定时，默认按到内部存储器中。由于取出或拒绝外部存储器存在的问题，以下程序不适合安装到外部存储器及其后果：
· 具有Widget／Live Wallpaper和Live Folder的应用程序： Widget／Live Wallpaper和Live Folder将从主屏幕上移除，而且重启系统后可能不在可用。
· 提供不中断服务的应用程序：程序和它运行的服务将被停止，并且不会自动重启。
· 输入法引擎：安装到外部存储器的任何IME都会被禁用。在外部存储器再次可用后，用户必须重新选择IME。
· 设备管理器：DeviceAdminReceiver及其管理能力将被禁用。
Manifest文件节点详解
首先看一下Manifest文件最基本的结构：
<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.codingblock.manifesttest" android:versionCode="1" android:versionName="1.0" android:installLocation="preferExternal" > <!-- ...nodes... --> </manifest>
manifest标签包含了一些节点（node），定义了组成应用程序的应用程序组建、安全设置、测试类和需求。下面是一些manifest子节点标签：
· uses-sdk：要想正确的运行程序，需要有minSKDVersion（默认值：1）、maxSDKVersion和targetSDKVersion属性。
· uses-configuration：使用此节点可以指定应用程序支持的每个输入机制的组合。一般不需要包含这个节点，不过对于需要特殊输入控制的游戏说很有用。以下是它的几个属性：
· reqFiveWayNav：要求设备有上、下、左、右导航，并且能够单击当前的选项时为true。包括跟踪求和D-pad。
· reqHarKeyboard：要求设备有硬件键盘时为true。
· reqKeyboardType：指定键盘类型为nokeys、qwerty、twelvekey、undefined。
· reqNavigation：导航设备（值：nonav、dpad、trackball、wheel或undefined）。
· reqTouchScreen：以指定必需的触摸屏输入（notouch、stylus、finger或undefined）。
· uses-feature：Android可以在各种各样硬件平台上运行。可以使用多个uses-feature节点来指定应用程序需要的每个硬件功能，以避免安装到不包含硬件功能的设备上。（如：NFC、蓝牙、摄像头等等）
· supports-screens：用于指定应用程序针对那些屏幕尺寸惊醒了设计和测试。当应用程序支持某个设备的屏幕是，一般就会使用开发人员提供的布局文件中的缩放属性来布局。在不支持的设备上运行时，系统可能会应用“兼容模式”来显示应用程序。
· supports-gl-texture：用于声明应用程序能够提供以一种特定的GL纹理压缩格式压缩的纹理资源。如果应用程序能够多种纹理压缩格式，就必须使用多个supports-gl-texture元素。
· uses-permission：声明应用程序所需权限。
· permission：应用程序组件也可以创建权限来限制对共享应用程序组件的访问。（可以使用permission标签来创建权限定义）
· instrumentation：instrumentation类提供了一个测试框架，用来在应用程序运行时测试应用程序组件。
· application：一个Manifest只能包含一个application节点。用于指定应用程序的各种元数据（标题、图标和主题）。在开发时，建议将debuggable设为true，以启用调试，发布时可以禁用此属性。application节点包含了Activity、Service、Content Provider和Broadcast Receiver等子节点。并通过创建和是用自己的Application类扩展来管理应用程序的状态。
<application android:allowBackup="true" android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:theme="@style/AppTheme" android:debuggable="true" > <!-- ...nodes... --> </application>
以下是对application子节点的简单介绍：
· activity：应用程序的每一个Activity都需要一个此节点，并使用andorid:name属性来指定Activity类的名称。必须包含核心的启动Activity和其他所有可显示的Activity。启动一个没有定义的Activity就会抛出运行时异常。每一个activity节点都可以使用intent-filter子标签来定义用于启动该Activity的Intent。（指定类名时，可以使用“.”作为简写方式代替应用程序的包名）如下代码：
<activity android:name="com.codingblock.manifesttest.MainActivity" android:label="@string/app_name" > <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity>
· service和activity标签一样，需要为应用程中使用的每一Service类添加一个此标签。同样它也支持使用intent-filter子标签来进行运行时绑定。
<service android:name=".MyService"> </service>
· provider：此标签用于指定应用程序中的每一Content Provider。（Content Provider用来管理数据库访问和共享）
<provider android:name=".MyContentProvider" android:authorities="com.codingblock.manifesttest.MyContentProvider"> </provider>
· receiver：通过添加receiver标签，可以注册一个Broadcast Receiver，而不用事先启动应用程序。一旦注册了之后，无论何时，只要与它相匹配的Intent被系统或应用程序广播出来，它就会立即执行。通过在manifest中注册一个Broadcast Receiver，可以使这个进程实现完全自治。如果一个匹配的Intent被广播了，则应用程序就会自动启动，并且你注册的Broadcast Receiver也会开始执行。每一个receiver节点都允许使用intent-filter子标签来定义可以用来触发接收器的Intent：
<receiver android:name=".MyIntentReceiver"> <intent-filter> <action android:name="com.codingblock.manifesttest.MyIntentReceiver"/> </intent-filter> </receiver>
· uses-library：用于指定该应用程序需要的共享库。
Android Fragment的使用
1、使用支持库
如果您的应用需要运行在3.0及以上的版本，可以忽略这部分内容。
如果您的应用使用在3.0以下、1.6及以上的版本，需要使用支持库来构建。
使用支持库的步骤：
1.使用SDK下的SDK Manager工具下载Android Support Package
2. 在您的Android工程的顶级目录下创建一个libs目录
3. 找到您的SDK下的/extras/android/support/v4/android-support-v4.jar，并且拷贝到您的项目的libs下，选中这个jar包 → 右键 → Build Path → Add to Build Path
4.在您的项目的Manifest.xml文件的标签下添加：
android:targetSdkVersion="8"/>
其中targetSdkVersion是您的软件最小支持的版本
5.如果您的项目支持3.0以下的版本，请导入如下的包：android.support.v4.*;
在使用Fragment的Activity请继承FragmentActivity而不是Activity。如果您的系统是3.0或以上版本，同样需要导入类似的包，但是可以使用普通的Activity。
2、创建一个Fragment
Fragment支持在不同的Activity中使用并且可以处理自己的输入事件以及生命周期方法等。可以看做是一个子Activity。
创建一个Fragment
创建一个Fragment和创建一个Activity很类似，继承Fragment类，重写生命周期方法，主要的不同之处就是需要重写一个onCreateView()方法来返回这个Fragment的布局。例子：
Fragment的生命周期方法依赖于Activity的生命周期，例如一个Activity的onPause()的生命周期方法被调用的时候这个Activity中的所有的Fragment的onPause()方法也将被调用。
更多的内容请参照类Fragment。
使用XML添加Fragment到Activity
尽管Fragment可以被多个Activity重用，但是您也必须把Fragment关联到一个FragmentActivity上。可以使用XML布局文件的方式来实现这种关联。
说明：上面的所说的FragmentActivity适用在API在3.0以下的版本，3.0及以上的版本可以使用普通的Activity。
例子：
上面使用fragment标签，android:name=””指定一个添加到xml中的Fragment。对于创建不同的屏幕尺寸布局的更多信息，请阅读支持不同的屏幕尺寸。
当您添加一个片段一个活动布局定义的布局XML文件中的片段，你不能删除在运行时的片段。如果您打算在用户交互和交换片段，你必须添加的活性片段的活动时第一次启动。
3、构建一个灵活的UI
FragmentManager提供了对Activity运行时的Fragment的添加、删除、替换的操作。
在Activity运行期间你可以添加Fragment而不是在XML布局文件中进行定义。如果你打算在Activity中改变Fragment的生命过程。
如果要执行添加、删除、修改的操作，你必须通过FragmentManager的对象获得一个FragmentTransaction对象，通过它的API来执行这些操作。
添加一个Fragment到一个Activity，必须把这个Fragment添加到一个容器视图中。例子：
在Activity中你可以通过getFragmentManager()来获得Fragment对象，然后通过FragmentManager对象的beginFragmentTransaction()方法来获得FragmentTransaction对象。通过它的add()方法来添加一个Fragment到当前的Activity中。
一个FragmentTransaction对象可以执行多个增删修的方法，如果你想把这些修改提交到Activity上，必须在最后调用一下这个对象的commit()方法。例子：
由于不是定义在XML布局中的，所有可以转型删除和修改的操作。
如果替换或者删除一个Fragment然后让用户可以导航到上一个Fragment，你必须在调用commit()方法之前调用addToBackStack()方法添加到回退栈。如果你把这个Fragment添加到了回退栈，在提交之后这个Fragment是会被Stop而不是Destroyed。如果用户导航到这个Fragment，这个Fragment会被Restart而不是重新创建。如果你没有把它添加到回退栈，则在删除或者替换的时候它将被Destroyed。例子：
4、与其他Fragment的交互
两个单独的Fragment之间是不应该进行通信的。应该使用他们所存在的Activity作为沟通的纽带。
为了实现两个Fragment的交互，您可以在Fragment中定义一个接口，然后再这个接口中定义一个方法，在Fragment的onAttach()方法中调用这个接口中的方法。然后让Activity实现这个方法来完成Activity和Fragment之间的通信。例子：
定义接口并调用方法：
实现接口，在这个方法中可以进行与其他Fragment的数据的交互：
可以通过FragmentManager的findFragmentById()来查找一个Fragment。
FragmentManager findFragmentById返回nul解决办法
看Fragment的两种生成方式
一.用xml标签生成
在fragment的宿主activity中添加xml标签
<fragment
android:id="@+id/fragment_newsContent"
android:name="com.firstcode.section4_news.NewsContentFragment"
android:layout_width="match_parent"
android:layout_height="match_parent"/>
name为你创建的fragment类
这种方法在activity创建时fragment已经生成了
在Activity中获取fragment实例的操作：
NewsContentFragment fragment = (NewsContentFragment) getFragmentManager().findFragmentById(R.id.fragment_newsContent);
二、用java代码动态生成
在fragment的宿主activity的视图文件中添加FrameLayout进行占位
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/fragmentContainer"/>
在Activity中生成fragment的操作
FragmentManager fm = getFragmentManager();
fm.beginTransaction()
.add(R.id.fragmentContainer,“你创建的fragment类实例”)
.commit();
问题分析：
我在使用用FragmentManager.findFragmentById 返回nul的问题就在这，我是通过第二种方式来生成fragment的，也就是说在findFragmentById的实参
我填的是FrameLayout的Id，而非fragment的Id 所以会返回null
解决方案：
1.如果是静态生成fragment，获取fragment实例用getFragmentManager().findFragmentById
2.如果是java代码动态生成fragment，获取fragment实例直接new 一个就好了 没必要用getFragmentManager().findFragmentById
3.注意xml文件中的标签FrameLayout与fragment
还有个问题，我也是这样解决的 在fragment视图里给textview添加文字
Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'void android.widget.TextView.setText(java.lang.CharSequence)' on a null object reference
原因是通过java代码生成的fragment add里的Id参数填的是fragment的id 所以fragment的视图没有生成
理解两种fragment生成方式最好的文档莫过于google官方的Android Training下面是中文翻译
使用xml标签添加fragment
使用java代码动态添加fragment
最近在做的项目中有很多下拉框，为了实现方便就用了Android 自带的Spinner,但是自带的Spinner的样式又不符合要求，就学习了一下自定义Spinner。下面是整个步骤：
1.准备好图片
2.style中定义
<!-- spinner -->
<style name="spinner_style">
<item name="android:background">@drawable/spinner</item>
<item name="android:paddingLeft">5dip</item>
3.调用
<Spinner
android:id="@+id/field_item_spinner_content"
style="@style/spinner_style"
android:layout_width="fill_parent"
android:layout_height="wrap_content"/>
4.在layout中定义simple_spinner_item.xml
<?xml version="1.0" encoding="utf-8"?>
<CheckedTextView xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@android:id/text1"
android:paddingLeft="5dip"
android:paddingRight="5dip"
android:gravity="center_vertical"
android:textColor="#808080"
android:singleLine="true"
android:layout_width="fill_parent"
android:layout_height="wrap_content" />
5.java代码
ArrayAdapter<String> adapter = new ArrayAdapter<String>(mContext,R.layout.simple_spinner_item);
String level[] = getResources().getStringArray(R.array.affair_level);//资源文件
for (int i = 0; i < level.length; i++) {
adapter.add(level[i]);
}
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
spinner.setAdapter(adapter);
效果图：
相关文章
基于springcloud异步线程池、高并发请求feign的解决方案
这篇文章主要介绍了基于springcloud异步线程池、高并发请求feign的解决方案，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...2021-02-25- 下面我们来看一篇关于Android子控件超出父控件的范围显示出来方法，希望这篇文章能够帮助到各位朋友，有碰到此问题的朋友可以进来看看哦。 <RelativeLayout xmlns:an...2016-10-02
- 这篇文章主要介绍了c# 三种方法调用WebService接口的相关资料，文中示例代码非常详细，帮助大家更好的理解和学习，感兴趣的朋友可以了解下...2020-07-07
C#使用Http Post方式传递Json数据字符串调用Web Service
这篇文章主要为大家详细介绍了C#使用Http Post方式传递Json数据字符串调用Web Service，具有一定的参考价值，感兴趣的小伙伴们可以参考一下...2020-06-25Android开发中findViewById()函数用法与简化
findViewById方法在android开发中是获取页面控件的值了，有没有发现我们一个页面控件多了会反复研究写findViewById呢，下面我们一起来看它的简化方法。 Android中Fin...2016-09-20- 如果我们的项目需要做来电及短信的功能，那么我们就得在Android模拟器开发这些功能，本来就来告诉我们如何在Android模拟器上模拟来电及来短信的功能。 在Android模拟...2016-09-20
- 夜神android模拟器如何设置代理呢？对于这个问题其实操作起来是非常的简单，下面小编来为各位详细介绍夜神android模拟器设置代理的方法，希望例子能够帮助到各位。 app...2016-09-20
- 为了增强android应用的用户体验，我们可以在一些Button按钮上自定义动态的设置一些样式，比如交互时改变字体、颜色、背景图等。 今天来看一个通过重写Button来动态实...2016-09-20
- 如果我们要在Android应用APP中加载html5页面，我们可以使用WebView，本文我们分享两个WebView加载html5页面实例应用。 实例一：WebView加载html5实现炫酷引导页面大多...2016-09-20
- 深入理解Android中View和ViewGroup从组成架构上看，似乎ViewGroup在View之上，View需要继承ViewGroup，但实际上不是这样的。View是基类，ViewGroup是它的子类。本教程我们深...2016-09-20
- 下面我们来看一篇关于Android自定义WebView网络视频播放控件开发例子，这个文章写得非常的不错下面给各位共享一下吧。 因为业务需要，以下代码均以Youtube网站在线视...2016-10-02
- java开发的Android应用，性能一直是一个大问题，，或许是Java语言本身比较消耗内存。本文我们来谈谈Android 性能优化之MemoryFile文件读写。 Android匿名共享内存对外A...2016-09-20
- TextView默认是横着显示了，今天我们一起来看看Android设置TextView竖着显示如何来实现吧，今天我们就一起来看看操作细节，具体的如下所示。 在开发Android程序的时候，...2016-10-02
- 这篇文章介绍了c#动态调用Webservice的两种方法实例，有需要的朋友可以参考一下...2020-06-25
android.os.BinderProxy cannot be cast to com解决办法
本文章来给大家介绍关于android.os.BinderProxy cannot be cast to com解决办法，希望此文章对各位有帮助呀。 Android在绑定服务的时候出现java.lang.ClassCastExc...2016-09-20- 这篇文章主要给大家介绍了关于c#中的WebService及其调用方式的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧...2020-06-25
- 这篇文章主要介绍了Android 实现钉钉自动打卡功能的步骤，帮助大家更好的理解和学习使用Android，感兴趣的朋友可以了解下...2021-03-15
- 下面我们来看一篇关于Android 开发之布局细节对比：RTL模式 ，希望这篇文章对各位同学会带来帮助，具体的细节如下介绍。 前言 讲真，好久没写博客了，2016都过了一半了，赶紧...2016-10-02
- 这篇文章主要介绍了Java线程池中的各个参数如何合理设置操作，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教...2021-06-19
- 在Java中,我们可以利用多线程来最大化地压榨CPU多核计算的能力,下面这篇文章主要给大家介绍了关于java中多线程与线程池基本使用的相关资料,需要的朋友可以参考下...2021-09-13