1. throwable，微信运动是否存在作弊刷步数的可能？

动手指关注下我哦！

随着带协处理器和买手环的人越来越多，微信运动一下子火了，只要你在微信关注微信运动，手机就能自动记录你每天行走的步数，还可以跟朋友圈里的好友PK运动量。并且每日排名第一的用户可以占据当日排行榜的封面。这充分激起了大家的求胜的欲望，于是出现了很多励志的和悲伤的故事……

1微信运动作弊大法

其实想要拿第一没有那么麻烦，只要会一点Android的Hook知识，就可以轻松冲到排行榜第一名。接下来我就手把手教你如何变成第一。

首先我们需要一台带协处理的root后的android机器，比如说nexus 5。然后我们装上作弊用的XPosed Hook框架和作弊插件。这两个apk可以在我的github上下载到。

https://github.com/zhengmin1989/WechatSportCheat

下载完后，先安装。接着打开Xposed，选择“”，然后根据提示重启手机。

重启完后，再安装插件。然后打开Xposed的模块界面，会看到xposedwechat这个插件。我们在这里将它选中，然后再根据提示重启手机。

接下来就是见证奇迹的时刻…你随意走两步，然后打开微信运动，咦，怎么就多了1000步？再随便走几步，咦，怎么又多了1000步？… demo视频如下：

仅仅刷步数还是不够过瘾吧？微信运动还推出了益行家活动，可以用每天的步数换取爱心捐款。有了微信运动作弊大法，我们可以每天在家随便走几步然后换取爱心捐款（如图所示）。

2 微信运动作弊原理

我们是如何作弊的呢？简单来说，当微信运动想要知道我们走了多少步的时候，微信app会询问android系统的计数传感器，随后计数传感器会返回我们行走的步数。因此，如果我们能够拦截微信运动和计数传感器之间的对话，然后伪造一个步数传递给微信运动就可以达到我们想要的作弊效果。

具体怎么做呢？首先我们可以用Xposed框架来hook计数传感器的队列函数，这个函数在这个类中。随后在微信运动每次询问行走步数的时候，我们先获取当前步数，然后在目前的步数的基础上加1000步，然后将信息返回给微信运动。微信运动就会误以为我们运动了1000步，从而达到了欺骗的效果。

关键代码如下：

首先这个类的函数：

final Class<?> sensorEL = findClass("android.hardware.SystemSensorManager$SensorEventQueue",lpparam.classLoader); XposedBridge.hookAllMethods(sensorEL, "dispatchSensorEvent", new XC_MethodHook()

接着我们在记步传感器把步数信息返回给微信运动之前，将返回的步数加上1000步：

protected void beforeHookedMethod(MethodHookParam param) throws Throwable { XposedBridge.log(" mzheng Hooked method: " + param.method); ((float[]) param.args[1])[0]=((float[]) param.args[1])[0]+1000*WechatStepCount; WechatStepCount+=1; …

另外我们还可以使用一些传感器的接口获取一些数据的信息：

Sensor ss = ((SparseArray<Sensor>) field.get(0)).get(handle); XposedBridge.log(" SensorEvent: sensor=" + ss);

比如说x就代表开机以来行走的步数，timestamp是获取步数时候的时间戳等。

另外，我们不仅在android上可以hook计步器，在iOS上也是可以通过越狱后hook iHealth的API接口达到同样的作弊效果，有兴趣的同学可以继续研究。

3微信运动反作弊建议

如何防止这种作弊发生呢？我的第一个建议是加强服务器端的逻辑检测功能。比如说一个人是不可能十分钟内走一万步的，如果他做到了，那么他一定是在作弊。 我的第二个建议是增加对hook的检测功能。虽然微信运动作下弊无非就是满足一下大家争强好胜的虚荣心，并不会对大家的隐私和财产产生损失。但是既然微信运动可以被hook，同样也意味着语音聊天，微信支付等功能也是可以被hook的，当黑客利用hook技术对你的隐私和财产产生危害的时候可就不是那么好玩的事了。之前我们在Hacking Team事件中也亲眼目睹了利用hook技术来获取微信语音消息的android木马，所以一定要增加针对hook的检测才行。

4 总结

此文只是介绍了Android Hook的简单场景应用，关于Android Hook的原理以及更多的利用方式，比如说调试，关键API拦截，外挂等技巧，敬请期待WooYun Book系列的文章《安卓动态调试七种武器之离别钩 - Hooking》。 https://github.com/zhengmin1989/TheSevenWeapons

5.参考文章

Android.Hook框架xposed篇(Http流量监控)

人手一份核武器 - Hacking Team 泄露（开源）资料导览手册

http://drops.wooyun.org/tips/7488

http://drops.wooyun.org/news/6977

2. java常用的异常类有哪些？

首先，我们知道Java有3种抛出异常的形式：throw（执行的时候一定抛出某种异常对象）, throws（出现异常的可能性，不一定会发生）, 系统自动抛异常。

throw用在一个语句抛出异常的时候，throw (an instance of exception class)比如一个方法/函数里，try{…}catch(Exception e){throw new ArithmeticException(“XXX”);}finally{…}；

throws则是用在声明方法可能抛出异常的时候，throw (exception class)比如public int division(int x, int y) throws ArithmeticException {…}；

系统自动抛异常则是当程序语句出现逻辑错误，主义错误或类型转换错误的时候，系统自动抛出异常，比如int a = 5; int b = 0; c = a/b; 这个时候移动会自动抛出ArithmeticException。

什么是异常异常，顾名思义，就是有异于正常状态，有错误发生。而这错误会阻止Java当前函数方法的运行。

那么Java里面异常的体系是怎么样的呢？

1.Java里面所有不正常类都继承于Throwable类；而Throwable类包括2类：Error类和Exception类。

2.Error类包括虚拟机错误（VirtualMachineError）和线程死锁（ThreadDeath）。

3.Exception类则是我们在说的异常；包括运行时异常（RuntimeException）和检查异常；这里的异常通常是编码，环境，用户操作输入出现了问题。

4.运行时异常（RuntimeException）包括以下4种异常：空指针异常（NullPointerException），数组下标越界异常（ArrayIndexOutOfBoundsException），类型转换异常（ClassCastException），算术异常（ArithmeticException）。

空指针异常：

数组下标越界异常：

类型转换异常：

算术异常：

5.最后剩下的检查异常则是剩下各种异常的集合；这里发生异常的原因有很多，文件异常（IOException），连接异常（SQLException）等等；和运行时异常不同的是，这里的异常我们必须手动在代码里添加try…catch…(finally…)语句来捕获处理。

今天又了解学习到了一些具体的额外的异常：

Throw抛出异常详细过程和throws声明方法可能会发生异常不同，throw语句则是直接抛出一个异常。

前面有提到，throw (an instance of exception class)，这里的一个exception类的实例其实也可以说是一个ExceptionObject（Throwable类或则其子类 的对象；也可以是自定义的继承自Throwable的直接或间接的异常类）。如果，我们用了throw new String(“异常XXX”); 则会在编译的时候报错，因为String 类并不是Throwable类的子类。

接着让我们回到怎么用throw语句的阶段。

一般我们有两种方式来用throw：直接在某处会发生异常的地方用throw语句或则用try…catch…finally…语句来捕获处理异常和关闭释放资源。

首先是第一种，直接在某处会发生异常的地方用throw语句；这是一种主动的方法，主动抛出异常去处理。

而第二种，用try…catch…finally…语句来捕获处理异常和关闭释放资源 则是被动的方法。try里面放入可能会发生异常的语句块，如果在运行期间遇到了异常，则会交给catch来处理异常（catch可以是多个，处理不同的异常），finally则是无论有没有异常发生，只要加上了就会运行。

首先我们来看第一种方法的函数：

我们的int c = 4/2，其实是正确的；但是我们的throw 语句主动抛出了异常，那么程序就会到catch里面找有没有这个异常，有的话进行处理。所以我们要主动抛异常的话，要很确信这个代码一定会发生异常且后期不太会去变动了（最好放在if条件语句里）。所以我们得到的结果如下：

接着我们来看第二种方法。我们一开始先测正确的，只是把主动抛出异常语句给注释掉：

因为try里面的语句块没有异常，所以只执行了try和finally里面的语句块。运行的结果如下：

我们接着来测当try里面的语句块有异常，且没有主动抛出异常的时候，try会不会捕捉到异常吧：

得到的结果如下，会去处理异常和执行finally里面的语句块：

最后深入理解一点try里面的异常触发会逐层向上的这个概念。在我们try语句里主动/被动抛出异常的时候，程序会调向调用者程序（上面的例子里就是我们自己这个函数；但有的时候我们会在try语句里执行别的函数比如B，这个函数B里我们假如触发了异常，它会调向try语句所在的函数A），寻找和它相匹配的catch语句，执行catch语句里面相应的异常处理程序；但假如没有找到相匹配的catch语句，那么它会再转向上一层的调用程序…这样逐层向上，直到最外层的异常程序终止程序并打印出stack trace。

参考资料

rollbar.com/guides/java…www.javatpoint.com/throw-keywo…www.geeksforgeeks.org/throw-throw…

本文分享自华为云社区《Java-throw异常详解以及过程-云社区-华为云》，作者：gentle_zhou。

3. 学会Java需要多长时间？

一、前言

我想大部分有这个疑问的朋友一般都是想从事IT软件开发相关工作，或者虽然不是从事类似工作但是对这类工作感兴趣的朋友。在此分享下自己的经验，我大学毕业后一直从事这个行业，至今15年，虽然没什么建树，但是靠着这门手艺也算是够养家糊口，当然这个专业也是自己的兴趣所在。这个行业门槛并没有大家想的那么高，只要你能坚持肯努力，我想你一定能够学会并可以找到一份适合自己的工作，当然如果想成为行业大牛的话，那就要看个人了，在此不多说，哈哈，因为我本身也不是这个行业的大牛。

篇幅有限，下面我主要说一下java的基础知识学习以及建议的学习时间。

二、Java的基础知识

2.1面向对象的相关概念

需要清晰理解几个主要概念：类、对象、变量、方法、消息、抽象、封装、继承、多态。

2.2Java语言的特点

面向对象、与操作平台无关性、安全问题、多线程。

2.3Java的运行环境

Java开发工具包（JDK），Java虚拟机（JVM）和Java运行时环境（JRE）共同构成了用于开发和运行Java应用程序的Java平台组件的强大功能。

2.4Java的类型系统

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

2.5Java中的类、方法和变量

2.6Java名空间及访问规则

掌握abstract、final、static、friendly、public、protected、private这些修饰字的作用。

2.7Java中的抽象类、接口和程序包

抽象类（abstract class）：是指不能直接被实例化的类,因此一般作为其它类的超类。

接口（interface）：利用接口可实现多重继承,指定原型,不直接定义方法的内容。

程序包：相当于其它语言中的库函数，使用程序包中的类要用import命令.表示路径,*表示使用包中的所有类。

2.8对象的构造函数

在一个类中和类同名的方法叫构造函数.系统在产生对象时会自动执行，构造函数多半定义一些初值或内存配置工作。

2.9Java异常

异常实际上是程序中错误导致中断了正常的指令流的一种事件，它是一个对象，继承自Throwable类,所有的Throwable类的子孙类所产生的对象都是例外。

Error:由Java虚拟机生成并抛出,Java程序不做处理。

Runtime Exception:由系统检测, 用户的Java 程序可不做处理,系统将它们交给缺省的异常处理程序。

Exception(程序中的问题,可预知的): Java编译器要求Java程序必须捕获或声明所有的非运行时异常。

throw:用户自己产生异常。

2.10Java流

在Java中有数据传输的地方都用到I/O流(通常是文件,网络,内存和标准输入输出等)InputStream和OutputStream是所有输入输出流的祖先,它们是一个抽象类。

三、后续

学习完第二部分这些java基础知识大概需要一到两个月的时间，掌握了这些基础知识之后，朋友们就可以写一些基本的小程序了。如果想找软件开发类工作的朋友还需要进行一些框架方面的学习，这个阶段需要的时间比学基础知识要长一些，大概需要两到三个月的时间。当然最重要的还是实践，最好能找一个实习的岗位边学习边实践，那样会事半功倍。

做IT这个行业，要不停的学习，所以说学习Java也不是说多久学完就可以了，这是一个持续的过程，而且在使用的过程中总会遇到各种各样的问题，需要你不断的去补充自己的短板。感兴趣的朋友可以关注我或者给我留言，大家共同学习，共同进步！

4. jsp结果集对象是什么？

常用的Jsp内置对象：

1、out对象

缓冲区——Buffer，就是内存的一块区域，用来保存临时数据。

out对象是JSPWriter类的实例，向客户端输出内容时常用的对象。

2、request对象

客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应。

request对象是HttpservletRequest类的实例。

request对象具有请求域，即完成客户端的请求之前，该对象一直有效。

3、response对象

response对象包含了，响应客户请求的有关信息，在JSP中很少直接用到它。

response对象是HttpServletResponse类的实例。

response对象具有页面作用域，即访问一个页面时，该页面内的response对象只能对这次访问有效，其它页面的response对象对当前页面无效。

4、session对象

session：客户端与服务器的一次会话

Web中的session：用户在浏览某个网站时，从进入网站，到浏览器关闭所经过的这段时间，也就是，用户浏览这个网站所花费的时间。

session实际上是一个特定的时间概念。

session对象在第一个JSP页面被装载时自动创建，开始会话期管理。

一个session：从客户打开浏览器并连接到服务器开始，到客户关闭浏览器离开这个服务器结束。

session对象，是HttpSession类的实例。

5、application对象

application对象，实现用户间数据的共享，可存放全局变量；

application对象，开始于服务器启动，终止于服务器关闭；

在用户的前后连接或不同用户之间的连接中，可以对application对象的同一属性进行操作；

在任何地方对application对象属性的操作，都将影响到其他用户对此的访问；

application对象是ServletContext类的实例。

6、page对象

page对象，就是指当前JSP页面本身，有点像类中的this指针；

page对象，是java.lang.Object类的实例。

7、pageContext对象

pageContext对象，提供了对JSP页面内所有对象及名字空间的访问；

pageContext对象，可以访问到本页所在的session，也可以取本页面所在的application的某一属性值；

pageContext对象是pageContext类的实例。

8、config对象

config对象，是在一个servlet初始化时，jsp引擎向它传递信息用的，此信息包括servlet初始化时所要用到的参数（由属性名和属性值构成）以及服务器的有关信息（传递一个ServletContext对象）；

9、exception对象

exception对象，是一个异常对象，当一个页面在运行过程中发生了异常，就产生这个对象。如果一个Jsp页面要应用此对象，就必须把isErrorPage设为true，否则无法编译。是java.lang.Throwable的对象。

觉得有用点个赞吧

5. Java爬虫方向怎么样？

写爬虫的话，Python更适合。用Python来写爬虫，简单方便，语法清楚，而且Python爬虫库有着更完善的生态环境；

之前在“ 如鹏网 ”上了解过Python的课程体系，比较详细，可以参考一下，挺不错的；

第一部分：Python 语言基础

第二部分：数据库开发

第三部分：web前端

第四部分：Python web开发

第五部分：Python web项目（项目截图可访问如鹏网官网）

第六部分：Linux

第七部分：NoSQL

第八部分：数据可视化

第九部分：爬虫技术

第十部分：人工智能

有网络的地方就可以学习，随时随地学编程，有问题随时提问，老师实时在线答疑，有新的课程，新的技术更新了，也是可以继续申请了来学习的，口碑不错，基本上都是慕名而去的，具体的可以到如鹏网官网上去了解一下；

6. Throwable与Exception之间有什么关系与区别？

Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。

类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。 两个子类的实例，Error 和 Exception，通常用于指示发生了异常情况。

通常，这些实例是在异常情况的上下文中新近创建的，因此包含了相关的信息（比如堆栈跟踪数据）。

Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。

7. SpringBoot是如何动起来的？

程序入口

SpringApplication.run(BeautyApplication.class, args);

执行此方法来加载整个SpringBoot的环境。

1. 从哪儿开始？

SpringApplication.java

/**

* Run the Spring application, creating and refreshing a new

* {@link ApplicationContext}.

* @param args the application arguments (usually passed from a Java main method)

* @return a running {@link ApplicationContext}

*/

public ConfigurableApplicationContext run(String... args) {

//...

}

调用SpringApplication.java 中的 run 方法，目的是加载Spring Application，同时返回 ApplicationContext。

2. 执行了什么？

2.1 计时

记录整个Spring Application的加载时间！

StopWatch stopWatch = new StopWatch();

stopWatch.start();

// ...

stopWatch.stop();

if (this.logStartupInfo) {

new StartupInfoLogger(this.mainApplicationClass)

.logStarted(getApplicationLog(), stopWatch);

}

2.2 声明

指定 java.awt.headless，默认是true 一般是在程序开始激活headless模式，告诉程序，现在你要工作在Headless mode下，就不要指望硬件帮忙了，你得自力更生，依靠系统的计算能力模拟出这些特性来。

private void configureHeadlessProperty() {

System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, System.getProperty(

SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));

}

2.4 配置监听并发布应用启动事件

SpringApplicationRunListener 负责加载 ApplicationListener事件。

SpringApplicationRunListeners listeners = getRunListeners(args);

// 开始

listeners.starting();

// 处理所有 property sources 配置和 profiles 配置，准备环境，分为标准 Servlet 环境和标准环境

ConfigurableEnvironment environment = prepareEnvironment(listeners,applicationArguments);

// 准备应用上下文

prepareContext(context, environment, listeners, applicationArguments,printedBanner);

// 完成

listeners.started(context);

// 异常

handleRunFailure(context, ex, exceptionReporters, listeners);

// 执行

listeners.running(context);

getRunListeners 中根据 type = SpringApplicationRunListener.class 去拿到了所有的 Listener 并根据优先级排序。

对应的就是 META-INF/spring.factories 文件中的 org.springframework.boot.SpringApplicationRunListener=org.springframework.boot.context.event.EventPublishingRunListener

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,

Class<?>[] parameterTypes, Object... args) {

ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

// Use names and ensure unique to protect against duplicates

Set<String> names = new LinkedHashSet<>(

SpringFactoriesLoader.loadFactoryNames(type, classLoader));

List<T> instances = createSpringFactoriesInstances(type, parameterTypes,

classLoader, args, names);

AnnotationAwareOrderComparator.sort(instances);

return instances;

}

复制代码

在 ApplicationListener 中 , 可以针对任何一个阶段插入处理代码。

public interface SpringApplicationRunListener {

/**

* Called immediately when the run method has first started. Can be used for very

* early initialization.

*/

void starting();

/**

* Called once the environment has been prepared, but before the

* {@link ApplicationContext} has been created.

* @param environment the environment

*/

void environmentPrepared(ConfigurableEnvironment environment);

/**

* Called once the {@link ApplicationContext} has been created and prepared, but

* before sources have been loaded.

* @param context the application context

*/

void contextPrepared(ConfigurableApplicationContext context);

/**

* Called once the application context has been loaded but before it has been

* refreshed.

* @param context the application context

*/

void contextLoaded(ConfigurableApplicationContext context);

/**

* The context has been refreshed and the application has started but

* {@link CommandLineRunner CommandLineRunners} and {@link ApplicationRunner

* ApplicationRunners} have not been called.

* @param context the application context.

* @since 2.0.0

*/

void started(ConfigurableApplicationContext context);

/**

* Called immediately before the run method finishes, when the application context has

* been refreshed and all {@link CommandLineRunner CommandLineRunners} and

* {@link ApplicationRunner ApplicationRunners} have been called.

* @param context the application context.

* @since 2.0.0

*/

void running(ConfigurableApplicationContext context);

/**

* Called when a failure occurs when running the application.

* @param context the application context or {@code null} if a failure occurred before

* the context was created

* @param exception the failure

* @since 2.0.0

*/

void failed(ConfigurableApplicationContext context, Throwable exception);

}

3. 每个阶段执行的内容

3.1 listeners.starting();

在加载Spring Application之前执行，所有资源和环境未被加载。

3.2 prepareEnvironment(listeners, applicationArguments);

创建 ConfigurableEnvironment； 将配置的环境绑定到Spring Application中；

private ConfigurableEnvironment prepareEnvironment(

SpringApplicationRunListeners listeners,

ApplicationArguments applicationArguments) {

// Create and configure the environment

ConfigurableEnvironment environment = getOrCreateEnvironment();

configureEnvironment(environment, applicationArguments.getSourceArgs());

listeners.environmentPrepared(environment);

bindToSpringApplication(environment);

if (this.webApplicationType == WebApplicationType.NONE) {

environment = new EnvironmentConverter(getClassLoader())

.convertToStandardEnvironmentIfNecessary(environment);

}

ConfigurationPropertySources.attach(environment);

return environment;

}

3.3 prepareContext

配置忽略的Bean；

private void configureIgnoreBeanInfo(ConfigurableEnvironment environment) {

if (System.getProperty(

CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME) == null) {

Boolean ignore = environment.getProperty("spring.beaninfo.ignore",

Boolean.class, Boolean.TRUE);

System.setProperty(CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME,

ignore.toString());

}

}

打印日志-加载的资源

Banner printedBanner = printBanner(environment);

根据不同的WebApplicationType创建Context

context = createApplicationContext();

3.4 refreshContext

支持定制刷新

/**

* Register a shutdown hook with the JVM runtime, closing this context

* on JVM shutdown unless it has already been closed at that time.

* <p>This method can be called multiple times. Only one shutdown hook

* (at max) will be registered for each context instance.

* @see java.lang.Runtime#addShutdownHook

* @see #close()

*/

void registerShutdownHook();

3.5 afterRefresh

刷新后的实现方法暂未实现

/**

* Called after the context has been refreshed.

* @param context the application context

* @param args the application arguments

*/

protected void afterRefresh(ConfigurableApplicationContext context,

ApplicationArguments args) {

}

3.6 listeners.started(context);

到此为止， Spring Application的环境和资源都加载完毕了； 发布应用上下文启动完成事件； 执行所有 Runner 运行器 - 执行所有 ApplicationRunner 和 CommandLineRunner 这两种运行器

// 启动

callRunners(context, applicationArguments);

3.7 listeners.running(context);

触发所有 SpringApplicationRunListener 监听器的 running 事件方法

希望对你有帮助