最近一朋友提了几个Android问题让我帮忙写个小分享，我觉得对新人还是挺有帮助的，所以有了这个小分享。

　　 1. 目前， Android APP开发完成后，通常需要在哪些机型上进行测试？

　　 2. 目前， 开发Android APP时，需要考虑的分辨率有哪些？

　　这两个问题可以合起来回答的。

　　 http://developer.android.com/about/dashboards/index.html

　　源自Google Play的数据，每月都会进行update，可以及时了解Android版本比例趋势。

　　屏幕密度数据

　　OpenGL ES版本

　　也可以参考一下国内一个第三方数据： http://www.umindex.com/#android_device

　　目前三星和小米市场占有率是遥遥领先的，三星Note2、Note3、S3、S4、S5、小米123、红米必须测试，魅族也比较坑爹，加入测试名单吧。再选中小屏幕各一款（譬如华为C8650、Moto ME511）。

　　Android 1.5、1.6、2.0、2.1和小屏幕的属于古董级别的机器，市场存量也很少，新出的机器都是4.0以上的了，所以必要时需要舍弃对古董的支持，因为适配成本很高，对于新开发的应用，这个适配不值得投入。

　　 3. 目前， 开发Android APP时，适应多个分辨率的技术方案有哪些？

　　http://developer.android.com/guide/practices/screens_support.html

　　Android的屏幕适配，可以在工程res目录下进行处理，无需写代码，Android自动找最适合的资源进行显示，相信大家都相当熟悉的了。

　　目前我使用的是ADT22.6，新建一个Android工程，会自动在res目录下生成这个目录结构。这里有5个前缀drawable的文件夹，对应不同密度屏幕时所取的图片资源或者样式。

　　做一个功能正常的App，开发者需要遵循一些开发守则，与此同时，设计师也需要有一套标准来设计Android UI，所有的Android UI设计指南都在这里了。

　　 http://developer.android.com/design/style/devices-displays.html

　　9Path这个简单易用的工具，很实用，必须推荐。

　　画个图标，都要出N种分辨率，每次机械操作实在有点弱爆，推荐一个牛X的工具：

　　其中的功能可以自动切图输出各种屏幕密度的icon，可视化构建布局，自动生成布局文件。

　　 http://android-ui-utils.googlecode.com/hg/asset-studio/dist/index.html

　　推荐这个，设计师应该会很喜欢，秒切图。

　　 http://www.cutandslice.me/

　　实际开发中，考虑到包体积大小，不会在所有drawable中都放不同size的图片资源，而是只使用一套图片资源，编写不同的布局。个别特殊的图片资源就每个drawable文件夹中放相应的size，譬如程序图标，不按文件夹放可能会导致在Launcher显示失真。

　　虽然不作任何改动也可以在Android Pad上跑，但由于Pad屏幕较大，操作体验不一样，建议重新设计。

　　 4. 开发Android APP时，配置文件应放在哪里（APP本地、远程WeB Server中）？应该如何考虑？　　

　　这个就要看需求了，如果只是本机使用，譬如保存软件设置，不需要联网操作的，那首选当然是保存在本地。

　　如果业务需要和服务器交互，可以做成云配置方式。为了跨平台的兼容性，可以考虑使用Google的ProtoBuf，比XML更小更快更简单，后台和终端定义一套协议，自动生成C++、Java或者Python代码。

　　 https://developers.google.com/protocol-buffers/docs/overview?hl=zh-CN　　

　　 5. Android APP测试方案通常考虑哪些因素？有测试方案的参考实例吗？　　

　　 机型适配：屏幕大小，这个只能人工检验了（程序不知道你的UI长得好不好看）

　　Android版本（某些API在低版本上没有的，会Crash，推荐Lint静态扫描）

　　 网络质量：联通、电信、移动、WiFi、弱网络等

　　 安全性：网络数据必定经过加密处理；本地不保存安全信息（帐号密码等），或者加密保存

　　代码中敏感信息尽量使用byte数组而不是字符串代码混淆处理(Proguard)

　　SD卡剩余空间很少，没SD卡，双SD卡，飞行模式，时间有误等。

　　 性能：CPU、内存占用（开发可以使用Linux的top命令或者DDMS里面的工具）

　　网络流量消耗（有各种第三方流量监控软件）

　　 6. 开发Android APP时，为了提高工作效率，提高项目质量、通常需要抽象出一些lib出来，请列出经常用到的接口的名称和用途。　　

　　更多精彩可以上github搜搜，这就不班门弄斧了。

　　 7. Android APP开发中其它需要提醒的问题

　　android4.4在UI线程无法进行网络操作不单只android API版本不一定导致运行异常，有些机型还使用Java 1.5进行编译，使用某些Java 1.6的函数会Crash的。

　　注意OOM问题，目前android手机已经有3G内存了，但并非一个应用就能使用全部内存。了解一下堆内存，一个软件至少一个进程，一个进程跑一个虚拟机，进程使用的堆内存大小，每部手机不一定一样。

　　Show Dialog的问题，永远要判断Activity是否还在。

　　使用了高版本的API函数，在低版本机器上挂了。

　　非UI线程不能操作UI。可能有各种权限被禁的问题。

　　没有浏览器、没有软件安装器、没有Email等发生ActivityNotFoundexception。

　　超快速连续点击按钮可能触发跑多个线程的问题。

　　Android4.4短信权限设置，原生系统带有新接口，第三方系统可能裁剪掉了。

　　 8. 什么情况下发生OOM，如何避免？

　　图片操作（图片缩放、bitmap生成等）、序列化反序列化数据等会消耗大量内存。合理使用数据结构（链表和数组），及时释放引用，使用弱引用等能降低OOM情况发生。

　　 9. 出现ANR怎么办？

　　如果Android程序某个操作执行等待超过5s，会出现ANR（Application Not Responding）的对话框，对于执行耗时的操作，譬如网络操作，就不能在主线程上进行了（Android 4.4不让你这样做了），这些任务应该跑在主线程外，譬如新建一个线程处理，或者自己写一个网络引擎对所有网络请求进行管理。

　　 10. 如何跟踪研发质量？

　　Coverity接入： https://scan.coverity.com/

　　代码缺陷扫描，不扫不知道，一扫吓一跳。满分推荐！Fro Free！如果你写的是开源代码，还能直接接入GitHub，超方便。

　　Crash是无法避免的，我们能做的是尽量把Crash的情况减少。发出去的版本，用户发生Crash了，我们需要把Crash数据收集起来。所以软件需要做一个Crash上报，汇总整理。统计每个版本的Crash率，并把Crash按优先级进行修复。

　　当然，版本检查更新也少不了。

　　 11. 如果跟踪用户对产品的反馈？

　　不管你写软件所用的技术有多么牛B，用户是不知道的，也不关心的。用户关心的是你的产品体验到底有多牛B。加上用户可以轻松反馈的反馈功能，你会发现有时用户的idea还不错的。

　　做出来的产品好还是不好，需要有产品数据支撑，所以加插相关数据统计上报点，哪个功能热门，新增用户多少，活跃用户多少，一目了然。

　　 12. 安全检查

　　为避免异常情况的跳转或者恶意攻击，Android组件在启动时都需要判断传入的参数是否为空。

　　敏感信息需要进行权限限制或者加密处理。

　　能不暴露的组件就不暴露，在AndroidManifest中为组件加上android:exported=”false”属性。

　　需要暴露的组件通过自定义权限进行调用，添加自定义权限android:permission=”yourapp.permission.CALL”检测WebView漏洞http://security.tencent.com/index.php/opensource/detail/1

　　 13. 常用工具有哪些：

　　Lint（清理资源、安全检查、layout优化等）

　　一般在提测前清理一下冗余资源，查一下有没有用了一些高API Level才有的接口，查一下安全问题。

　　Findbugs（检查java代码缺陷）

　　在开发工程中就可以对单个文件进行检查，有问题可以及时处理。

　　MAT（内存泄漏调试工具）http://www.eclipse.org/mat/

　　遇到内存或者性能问题时，一般会结合几种工具来查问题，找解决方法。

　　Method Profiling（统计方法耗时）

　　Eclipse Class Decompiler（从此Eclipse不怕看不到jar包内的代码了） http://feeling.sourceforge.net/update

　　Hierarchy Viewer（查看Activity堆栈、layout加载层次、像素眼）

　　只能连接开发板手机或者模拟器，如果你的手机连不上，搜一下“Hierarchy Viewer 真机”，各种教程教你如何连上。

　　Activity太多，有时出问题了，但又想不起这个页面叫什么名字，插上去，一目了然。

　　很清晰看出Layout布局层次， 还能显示计算layout耗时，绘图耗时，UI性能优化好帮手。

　　TinyPNG（压缩图片资源利器，山崩地裂推荐） https://tinypng.com/

　　7z（压缩APK利器，上线前压一下就可以，简单实用，五星推荐）

　　Apktool、Dex2jar 、jd-gui（反编译套装，你懂的）

　　Mark Man（设计师何苦为难工程师）

　　Beyond Compare（各种神对比，我喜欢对比代码）

　　 Tcpdump（Linux dump包工具）

　　adb shell tcpdump -p -vv-s 0 -w /sdcard/capturenet.pcap　　

　　WireShark（查看网络dump包）

　　遇到棘手问题时，还是需要他们帮忙解决的。

　　CMD (很简单的脚本却能大大提高效率，大家多学多分享)

　　一些经常操作的动作，使用手工操作又耗时又麻烦还可能出错，使用命令行去操作的话会极大提供效率。

　　拖放安装应用，不用再弹出xx助手xx宝来的蜗牛速度安装了（速度快了，心情好了）：

　　adb install %1

　　pause

　　卸载应用：

　　adb uninstall com.tencent.qqpim

　　拉去SD卡目录文件

　　adb pull /sdcard/test/log c:testlog

　　获取联系人db

　　adb pull /data/data/com.android.providers.contacts/databases/contacts2.db C:contact2.db

　　tcpdump包

　　adb shell tcpdump -p -vv -s 0 -w /sdcard/capturenet.pcap

　　SDK裁剪打包

　　裁目录：rd/s/q S:tencentsrcAGJ

　　裁文件：del S:tencentsrccomtencenttestTestApplication.java

一、SpringBatch简介

Spring Batch是一个轻量级的批处理框架, 可以用于企业级海量数据处理, 它提供以下技术解决方案:

1. 定时批处理

2. 大规模并行处理

3. 企业消息驱动处理

二、SpringBatch结构

Spring Batch由应用层、核心层、基础架构层等组成:

1. 应用层: 包含所有的批处理作业,  使用spring框架管理程序员自定义的代码

2.核心层: 包含batch启动和控制所需要的核心类, 如: JobLauncher、Job、Setp等

3.基础架构层: 提供共通的读(ItemReader)、写(ItemWriter)和服务(RetryTemplate)

应用层和核心层简历在基础架构层之上, 下图展示了它们之间的关系:

三、SpringBatch流程

1. spring batch执行过程:

外部控制器调用JobLauncher启动一个Job, 每个batch都会包含一个Job, Job就像一个容器, 这个容器里装了若干个Setp, 

batch里面真正干活的就是这些Setp(ItemReader用来读取数据，ItemProcessor用来处理数据，ItemWriter用来写数据), 

Job调用Step实现对数据的操作, Setp处理完成后, 将处理结果一步步返回给上一层。

JobRepository是上述处理提供的一种持久化机制, 它为JobLauncher、Job、Setp实例童工CRUD操作。

2. Step执行过程：
从DB或文件中取出数据的时候, read操作每次只读取一条记录, 然后将这条数据传递给processor处理, batch框架将重复做这两步操作,

直到读取记录的数量达到配置文件中"commin-interval"设定值得时候就会调用一个write操作, 然后再重复以上操作, 直到处理完所有的

数据。当这个Setp工作完成以后可以调到其他Setp或结束处理。

四、HelloWorld实例

本实例没有像前面讲的那样配置ItemReader、ItemProcessor、ItemWriter，而是直接在Setp中调用Tasklet

由Tasklet完成"Hello World!"的输出。

1. 工程结构图：

2. applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans  
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
	http://www.springframework.org/schema/context  
	http://www.springframework.org/schema/context/spring-context-2.5.xsd"
	default-autowire="byName"><bean id="jobLauncher" class="org.springframework.batch.core.launch.support.SimpleJobLauncher"><property name="jobRepository" ref="jobRepository" /></bean><bean id="jobRepository" class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean" /><bean id="transactionManager" class="org.springframework.batch.support.transaction.ResourcelessTransactionManager" /></beans>

applicationContext.xml主要用来配置一些spring信息, JobLaunch类用来启动Batch

3. springBatch.xml

<?xml version="1.0" encoding="UTF-8"?><bean:beans xmlns="http://www.springframework.org/schema/batch"
	xmlns:bean="http://www.springframework.org/schema/beans" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-2.5.xsd
	http://www.springframework.org/schema/batch 
	http://www.springframework.org/schema/batch/spring-batch-2.1.xsd"><!-- 装载spring核心配置文件 --><bean:import resource="applicationContext.xml" /><job id="helloWorldJob"><step id="step_hello" next="step_world"><tasklet ref="hello" transaction-manager="transactionManager"></tasklet></step><step id="step_world"><tasklet ref="world" transaction-manager="transactionManager"></tasklet></step></job><bean:bean id="hello" class="com.zdp.springbatch.WriteTasklet"><bean:property name="message" value="Hello "></bean:property></bean:bean><bean:bean id="world" class="com.zdp.springbatch.WriteTasklet"><bean:property name="message" value=" World!"></bean:property></bean:bean></bean:beans>

springBatch.xml配置了一个ID为helloWorldJob的Job，这个Job有两个Setp：setp_hello和setp_world，

前者负责输出“Hello ”， 后者负责输出“World！”，当第一个Setp完成之后执行第二个Setp。

4. WriteTasklet：

public class WriteTasklet implements Tasklet {

    private String message;

    /**
     * @param message
     * the message to set
     */
    public void setMessage(String message) {
        this.message = message;
    }

    @Override
    public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext)throws Exception {
        System.out.println(message);
        return RepeatStatus.FINISHED;
    }

}

是Tasklet实现业务逻辑的地方，此实例只是简单的输出message信息后直接返回。

5. JobLaunch

/**
 * Test client
 */
public class JobLaunch {

	public static void main(String[] args) {
		try {
			ApplicationContext context = new ClassPathXmlApplicationContext("springBatch.xml");

			JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
			Job job = (Job) context.getBean("helloWorldJob"); 

			// JobLauncher可以用来启动Job
			JobExecution result = jobLauncher.run(job, new JobParameters());
			
			// 处理结束，控制台打印处理结果 
			System.out.println(result.toString());
		} catch (Exception e) {
			throw new RuntimeException("error happens...", e);
		}
	}
}

处理结束后控制台输出处理结果。
转自：http://www.cnblogs.com/gulvzhe

英文原文： 10 Ways You Can Blow a First Impression

不知道你有没有听说过这样一句话：“留给别人好的第一印象的机会，你只有一次”?当然，你应该听说过，因为你过去并不是天真无知的。

要留给别人良好的第一印象所面临的困难是，通常情况下，当你认识新的人时，那个人是否对你或你的公司具有极大的价值，你可能根本不知道。没错，在一家餐厅或者棒球比赛中，朋友刚刚介绍给你的素不相识的人，可能在你目前正努力向其出售你的新产品的公司工作，甚至还可能是那家公司的老板。

但是，在你走进他们的办公室，并且发现你最近遇到过他之前，你是不会知道这些的。但愿你没有犯以下这 10 个错误中的一个，这 10 个错误会导致你留给别人的第一印象被毁掉。

1. 你戴着墨镜。这跟见面的时间是不是中午，你是否必须要面对着太阳没有什么关系。你的眼睛是了解你是一个怎样的人的第一门户。你的眼睛能够说明你的信心、真诚以及对与你见面的人的兴趣，所以帮自己一个忙吧，当你正在和新认识的人会面时，把你的墨镜摘掉——是的，即使他们仍然戴着墨镜。

2. 不知道你有没有听说过“着装上一定要能为对方留下良好印象”这句话?我生活在洛杉矶，所以我非常清楚地知道我刚从床上爬起来的样子，会被人认为是“赶时髦派”的作风，但是说实在的，你的着装究竟是不是会被看起来也是这种作风呢?你应该同时注意到另外一条谚语：“认知即现实”。也就是说，如果你看起来好像并不是那么在乎你自己，以至于甚至不能够稍微像样一点的话，那么你留给别人的第一印象可能就是，你真的不在乎你自己。

3. 握手软弱无力。是的，在有史以来每一篇关于“如何给人留下良好的第一印象”的文章或者书中，这个问题己经出现过很多次，但它是最重要的问题中之一，所以必须一次次被重申。通过握手，你可以了解一个人很多东西——柔如浮云的握手说明这个人软弱，稳定而有力的握手则代表了强大。这真的在别人认知里就这么简单。

4. 你看起来好像一点儿都不在乎。你不知道也不想去问他们是从事什么工作的，所以很显然，他们对你不重要，对不对?很遗憾你错了。如果你不知道他们是怎样的人，或者他们做了什么，你不在乎和他们的见面，他们也将会不在乎与你的见面。

5. 你似乎不能集中注意力。你是否曾经有过和这样的人谈话的经历：他们看起来好像是在看着你身后更远的地方，甚至看起来好像一直在盯着电视上的棒球比赛。那么很显然，你会觉得他们没有足够的的兴趣去了解你，以及也不在乎你是否注意到了这一点。所以，你必须专注在和你谈话的那个人身上，并且在那个时候，要像他们是你的生活中最重要的人一样对待他们。

6. 你带着自己的情绪包袱。一般来说，人们喜欢与别的快乐的人待在一起，但是你可能从早上起来开始就情绪不好，并且将不好的情绪表现了出来。你心情不好真的没有什么关系，但要知道你只有一次机会，所以要露出微笑，至少在相互沟通结束之前，然后你就可以回去宣泄了。

7. 你就是不能停止谈论自己。没有比和不停地谈论自己，或者把每一个故事都编成关于他们自己的故事的人待在一起更糟糕的事情了。很多人都知道，人们喜欢发出自己的声音，所以你需要更聪明一点，并且利用机会，以便让正在与你会面的人充分发表意见。相信我，他们会因为你做到了这一点而喜欢你的。

8. 攀龙附凤可以抬高自己的身份?真的是这样吗?没有人会在乎你整个夏天是不是都在与某某名人或者某某 CEO 一起在加勒比海上航行，因为这会让你看起来像是在过度伪装，而你可能真的就是在过度伪装。创造柔和的气氛，并且练习谦卑，这将会使你在短期和长期都得到更进一步的发展。

9. 你不会把你的手机放在一边。自从智能手机诞生以来，这是一个无疑越来越会成为人们关注的焦点的问题，但是这个问题真的需要一些关注。当你在与某些新认识的人——或者实际上与任何人——谈话的时候，如果你不能把你的手机放在一边，那么很明显，你对他们根本不感兴趣。这一点非常简单，任何人都可以认识得到。

10. 你不记得他们的名字。我知道这个问题有点难，但是这个问题绝对值得通过实践改进。你知道这是为什么吗?因为与谈论他们自己相比，只有一件事情人们更喜欢去做，而这件事情就是听到他们自己的名字。这可能是一个到目前为止最有价值的，获得良好的“第一印象”的工具了——你必须在合理的允许条件下，在整个谈话过程中以及在谈话结束时，尽可能经常的努力尝试去提到他们的名字，这样做绝对会让他们记住你。

本文链接

• —软件人才免语言低担保 赴美带薪读研！—

• —软件人才免语言低担保 赴美带薪读研！—

我本人是HTML5的大粉丝，因为它可以给我带来满足我创造力的开发速度。

但自从移动平台崛起以来，这项技术所涉及的开发就开始变得复杂起来。在桌面平台看来，一切都非常清楚。网站开发就是一场不断持续的进化，即便如此还是有人对其了如指掌。但是在移动平台这就是场噩梦。开发者们被各种开发HTML5移动应用的方法搞得晕头转向，所以我希望这个指南可以帮助他们。

正如我在 前一篇文章中提到过，如果想要实现一个移动应用的话，你首先得是一个web开发者。

在开始给大家介绍现有的不同平台和框架之前，我必须声明我并不认为Titanium Mobile是一个HTML5解决方案。如果想要知道为什么请参阅我的前一篇文章。

目前有四个解决方案（其他新的解决方案也在不断出现，但都还处于初期状态）可以用于开发HTML5移动应用。

Web App

这是最直白的方法。简单来说，就是一个通过浏览器访问的网站。Android和iOS都提供将网站链接添加到桌面的功能。这样的应用通过恰当的配置可以以全屏状态运行，并且配合Appcache可以实现离线运行。

更新： Daniel Appelquist提醒大家在Firefox OS，Android上的Firefox以及今后的Chrome都会为用户提供将web app添加到移动设备的功能。前提是你需要为你的web app声明一个配置清单。嗯，挺好。

对我来说，这并不是一个可靠的方案：

• 首先，Appcache这东西实在是太恶心了： http://alistapart.com/article/application-cache-is-a-douchebag
• ServiceWorker，这是一个Appcache的替代方案，虽然目前无法使用但是他的技术规格非常酷炫： https://github.com/slightlyoff/ServiceWorker/blob/master/explainer.md
• 目前HTML5 API在iOS以及Android 4.x之前版本的支持情况非常之不可靠。
• 不支持推送消息（Firefox OS支持）
• 无法与原生SDK交互（Firefox OS要做得稍微好些）

利用Phonegap / Cordova 集成开发平台

这个是目前来讲，最有效的妥协方案。现在已经有一整套相关生态系统包括工具，论坛，开发者。你能通过它来利用HTML5的API以及原生API。到最后，你得到的会是一个真正的APP。此平台也遵从HTML5规范以协助web应用的转化。

手工接入本地环境

这个方案针对的是那些规模较大并对设备原生代码颇具了解的团队。很多大公司就采用的这种方式。它可以将高性能的原生UI组件与高灵活性的HTML搭配使用。

如果你感兴趣的话，你可以看看这些链接：

• guide/webapps/webview.html
• https://github.com/marcuswestin/WebViewJavascriptBridge
• AppleApplications/Conceptual/SafariJSProgTopics/Tasks/ObjCFromJavaScript.html
• true-javascript-uiwebview-integration-in-ios7

使用Intel XDK基础开发环境

说实话我不能给这个方案一个准确的评价。在我第一次安装这个编辑器后，它的复杂程度让我惊呆了，所以我也没有动力再去研究它。就我所了解的，它和Phonegap应该遵从的同样的精神不过他们专门打造了一个完整的IDE。我并不确切地知道具体地差别在哪。如果哪位在Intel工作的老兄读到这篇文章，麻烦你给我提供一下更多相关细节好吧？

原生HTML

这个是完美的解决方案。操作系统直接执行HTML5代码而不是通过桥接的方式链接HTML和原生代码。你能使用所有的API，debug工具也能完美的使用。而实际上，目前只有 Firefox OS和 Tizen拥有这样的系统。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

现在你知道了这些不同的方案，我们可以摆一摆移动HTML5应用的八卦。当乔布斯在第一代iPhone发布会上宣布有移动HTML5之后，其相关开发就开始了。Safari和Firefox在当时是最好的HTML5浏览器（Google Chrome那时还没出来）。

但是一年之后，应用商店上线了，但是只能用Objective－C开发应用。该死的乔布斯。

之后没过多久，一帮开发者就创造了Phonegap。我还记得当时他们拿一个wiki当主页。它当时bug无数，虽然的确是个天才的想法。但问题是与此同时开发者们也纷纷开始制作移动HTML5应用。所以许多人被它搞得很恼火然后到处说它坏话。

自那以后，又发生了很多事情：智能手机的CPU越来越强大，CSS渲染可以通过GPU完成，HTML5的规范更加精准，浏览器引擎更加强大。

前端开发也同样有了很大的改进。我们的JS代码不再是一个巨大的 $(document).ready函数。我们开始使用更加标准化的框架（AngularJS, BackboneJS, EmberJS, Polymer, ReactJS）而且我们的debug工具也不再弱于那些原生debug工具。我们也开始使用构建系统，包管理器，以及代码风格。

HTML5移动开发自2009年以后就完全变样了。

所以到最后，HTML5的问题是什么？就是 UI。

有些读者已经知道， 我真的很讨厌jQuery Mobile，然而很不幸的是，大多数开发者都用它来做移动开发。Bootstrap也没法解决这个问题。它确实是响应式的但是并不是针对的移动平台。原生应用开发者用他们的原生组件来和HTML/CSS相比较，这明显是很不公平的。

原生平台提供很多“拖来就用”的组件，而且是经过全面的测试，优化，并已经包含了性能优势。iOS提供的原生长列表组件会自动隐藏那些看不到的元素，但是在HTML/CSS里面并非如此。

Web UI是开发者心中永远的痛因为Apple或Google从未提供过Web UI的框架。想像一下如果有种“Bootstrap”可以拥有所有原生组件的特性（性能，渐变，个性化等等）。他们本来可以做到，但这并不是他们优先考虑的。然而现在情况不同了。

Windows Metro

微软是这方面第一让我有深刻印象的。他们的Metro UI无论是在C++，C# 还是 HTML里都有同样的特性:

HTML5中的ListView的一个例子：

• http://msdn.microsoft.com/en-US/library/windows/apps/br211837.aspx
• http://code.msdn.microsoft.com/windowsapps/Universal-Windows-app-cb3248c3

Firefox OS

Firefox OS更加有意思。Mozilla自己同第三方开发者使用同一套CSS。说实话这真是最棒的想法了。你可以直接 去GitHub进行贡献：

• https://github.com/mozilla-b2g/gaia
• http://buildingfirefoxos.com/index.html

那么Google呢？

Google是最后一个但也很不错。他们采用了另一种方式。他们给我们带来了AngularJS以及最新的Polymer。Polymer是是一个让你可以轻易创建web组件的框架。

在他们完成开发web应用底层结构之后，他们开始专注于UI。现在的成果就是Material Design（译注 这里是相关介绍），他们的想法是创造完全响应式的设计，而并不是简单的缩放元素大小，这样可以使得应用在每个屏幕尺寸上看起来都很性感。他们使用Polymer来提供这些组件。

• http://www.polymer-project.org/components/paper-elements/demo.html#core-toolbar
• http://www.polymer-project.org/docs/start/tutorial/intro.html

同时现在还有其他的UI框架！

Ionic Framework

这个是个人最爱。其设计与iOS很相近，但不像某些人，它在Android上看起来也很棒（看什么看我说的就是你jQuery Mobile）。他们带有AngularJS的指令集，现装现用，性能优化，自带动画，等等。简而言之，这货就是春哥附体。下拉刷新，侧边菜单，无限滑滚，支持超长列表（没错，超过1000条元素），选项夹，等等。

这个截图是我正在开发的一个应用

Drifty，这个开发了Ionic Framework的公司，正在同其他开发者一起研发Angular Material，一个类似于Polymer中Material Design的东西不过是基于AngularJS。

还有其他更多不错选择，不过目前还达不到Ionic那么好。不过大家还是可以关注一下，我相信很快他们都会改进：

• Onsen UI
• Ratchet
• TopCoat
• HeartCSS

那么Apple呢？我觉得他们还是更倾向于迫使人们用Swift或者Obj－C进行原生开发。万幸的是，我之前提到的大多数框架都支持iOS。SB了吧，Tim！

我希望现在你对HTML5移动开发能够有了更多的了解。这个指南还没有完成，我只是想到哪写到哪。如果你发现我有什么地方写的不对，请尽管给我留言或者通过你方便的方式联系我： http://www.yrezgui.com

宋冰

想在美国当程序员？可能没你想象的那么难。就算没钱去正经大学念个计算机科学，也有其他出路。

最近，越来越多的在线学习编程学校在美国火了起来。许多真实的案例都为一些有志于此的人指出了一条光明大道：无论你是想找工作的穷学生，还是想改行的中年危机男，程序员的世界都欢迎你。

“闪电战”编程课程

西雅图的“代码伙伴”(Code Fellows)学校，就非常确信他们能够帮助学生找到工作。他们为学生提供六个星期的“闪电战”编程课程，让学生能够完成从零基础达到基本入门状态，收费 1.2 万美元——如果还是找不到工作，学费可以全退。

类似学校的兴起背后，是美国互联网市场的日渐繁荣，这导致了程序员供不应求的局面。据美国劳工部的数据预测，2020 年美国大约会空出 100 万个程序员职位。而且许多传统高校对计算机课程的不怎么上心，正在让这个缺口越来越大。

比如今年华盛顿大学的计算机系，就只招了1/4 完全够格的申请者。这样的事情在全美高校现在比比皆是。无论是报考计算机系，还是在校生选修计算机课程的比例，都在火箭式上升。

对于那些没能成功申请上一个计算机课程的学生来说，好在在程序员的世界里，学位并不是通向工作的唯一途径。

比如业界标杆谷歌公司里，一些团队就有 14% 的程序员没有相关正式学位。放大到全美来看，67% 的编程岗位都是来自非科技类公司，这就意味着编程之外，还需要其他正常商业技能。

从这个角度来看，和焊接工或者木匠一样，编程其实就是一门手艺。是一门任何人都可以在几周或者几个月内稍加学习就具备基础技能的手艺。而且一旦那些刚刚开始的编程菜鸟们靠着这些基本技能混到了第一个工作，此后的职业发展道路上，他们就和其他正规学校出来的程序员同行们获得了相等的机会，只要各凭本事就好。

以脸谱网(Facebook)为例，每一个工程师在进入该公司要做的第一件事，就是 6 个星期的集中训练，大部分的课程自然都和编程相关。公司设立这个规定流程，是因为在大部分的高校里，计算机系都更注重理论学习而不是实打实的编程。后者其实包括了各种最流行的编程语言、项目管理与合作等一系列庞杂知识，这意味着一个合格的程序员往往需要和几十个其他程序员以及几百万运行程序同时打交道。

那些在线编程短训学校们，就试图帮助这些有意进入程序员世界的门外汉，从一开始就跳过单调而不实用的理论，直击那些公司最关注的实际技能——比如网站维护或者做一个 APP。

这倒不是有意忽视基于大学教育基础之上的计算机学位的价值。如果一个学生能够负担得起这样的教育当然很好，但是从美国学生财务数据上来看不太乐观。目前美国学生贷款已经创下了 1.2 万亿美元的纪录，其中许多都注定会变成坏账。

程序员或终被替代

计算机学位有助于理论学习并且帮助那些顶级工程师继续磨练这门艺术，但在这个互联网如此普及的时代，要求每一个程序员都要有一个计算机学位，就相当于要求每一个砌砖工有一个建筑学位一样。

另一家在线编程学校“代码学院”(Codecademy)，号称已经有 2400 万的全球用户注册使用其课程。不过这所学校的联合创始人扎克·西姆斯不太想把代码学院看成是一个职业学校。

“树屋”(Treehouse)的联合创始人卡森则认为，自己那张十几年前获得的计算机学位完全没有用。一日千里的互联网科技让工程师们必须持续学习新的模型和语言，这让很多半路出家的人有时也能站在同一起跑线上，只要他们愿意终其一生磨练这门技能。

“几乎所有我们现在能触摸到的东西都能和一个什么软件连上，这是人类历史上的头一遭。”卡森说。这就如硅谷一句最流行的话所言：“未来只有两种人，知道如何编程的人，和只能遵从机器指令的人。”

当然，就算已经出现了各种令人惊叹的成功个案，所有这些编程速成学校都还没有办法提供毕业生就业率的数据。当然这些学校也都是这两年刚刚开始进入市场，还要考虑到其中一些免费的在线学校中辍学率惊人。在上个月，“代码学院”有 88% 的学员顺利毕业，但是“代码学院”对学员的筛选非常严格。

“你并不需要特别的天才或者学术教育，来成为一个优秀的程序开发者。”卡森说。从“树屋”毕业需要学员支付每个月 25 美元的学费，以及将近一年的时间成本。

随着互联网科技注定要向人类社会的每一方面继续快速渗透，程序员岗位也会像其他被其所代替的劳动分工一样，越来越形形色色。

本文链接

8 月 4 日，来自北京、山西、浙江、吉林等 7 省的 12 名新科状元走进百度公司，并与百度创始人李彦宏进行了一场以“新状元、新起点”为主题的交流对话。

面对这些即将开始大学生活的最聪明的年轻人，坦言喜欢和聪明人打交道的李彦宏，与他们畅谈了人生成长、理想情怀以及对时代的洞察和理解。山西文科状元、和李彦宏一样出自阳泉中学的李天表示，“学长很有亲和力，儒雅帅气。让我印象最深的是他对我们如何从聪明到优秀提出的一些建议，而且他对每位同学的提问都给予了充分细致的解答，大家受益匪浅。希望在未来，我也可以按照他指点的方向努力、发展。”

学会独立思考

对于这样一群在高考独木桥脱颖而出、即将迈入大学校门的年轻人，李彦宏首先和大家分享了他对大学的理解。“在中学，大家基本都是随波逐流的状态，对于人生规划不会想太多。但在大学四年的时间里，很重要的一点是要形成独立思考的能力。在大学里，你能够见识更多优秀的人、听到不同的声音，所以在这个过程中，更重要的是要培养自己的独立思想，知道自己要成为什么样的人。”

北京文科状元、即将进入北京大学元培学院学习的孙一先对此感触颇深，“大学重在培养人的独立性。李彦宏让我们知道在大学最需要关注的是什么，比如形成独立思考的能力，这真的改变了我对上大学的看法，怎样做出正确的选择，做自己，不随波逐流。”孙一先颇有一种顿悟的感觉，“我上大学之后的第一步就是要先找到理想，积累能力，形成自己的价值观。”

除了形成独立思考的能力，李彦宏还表示高考状元都是聪明的人，也非常勤奋，但是从“聪明”到“优秀”有一个过程。“在这个过程中，需要不断锻炼自己的情商、性格，更好地适应这个社会。未来你们在大学里，以及职业生涯里会不断地经受各种考验，希望你们把握这些机会，在未来对性格方面的磨砺有足够的关注。”

改变小环境，适应大环境

而对于如今很多人抱怨整体社会环境不尽如人意，大环境掣肘了个人能力的展现，李彦宏建议大家应该去“改变小环境，适应大环境”。在他看来，“大的环境很难以一人之力改变，需要去适应，可以改变的是自己周围的小环境。如果能改变自己身处的小环境、以更加建设性的角度看待，社会就能进步。”

其实，在李彦宏眼里，如今的“大环境”让他时常会非常兴奋和激动。“现在技术创新的步伐在非常快地加速，过去几千年，人们所使用的技术没有特别大的变化，但是最近这十多年，技术和创新给人们生活带来的变化，是非常非常巨大的。”正是因为如此，李彦宏向高考状元们表示，“我们生活在一个非常幸运的年代，我们可以参与到其中，不仅可以见证人类创新加速发展的过程，还可以在里面扮演重要的角色。”确实，无论是对于青年大学生还是立志创业的人来说，他们都有很多的机会从一文不名成长为各行各业卓越的代表，只要他们真的能够不负时代，处理好小环境和大环境的关系。

河北理科状元、即将进入清华大学建筑系学习的李榕榕，下定决心在未来四年的大学生活中，多拿出时间做兼职，参加社会实践，开阔自己的视野，使他有更好的锻炼以适应外部环境，以实际行动来体会李彦宏提出的“改变小环境，适应大环境”的建议。

心怀远大理想

面对这样一个时代，李彦宏鼓励这些高考状元要心怀远大理想。李彦宏表示，“随着一个人年龄的增长，阅历会越来越丰富，知道的东西会越来越杂。从人生的发展历程来讲，首先要找到什么才是真正的能让你兴奋、并让你为之奋斗很多年的东西。一个没有理想的人是很悲哀的。而很多人之所以挣扎，就是因为理想没有想清楚。在理想逐步清晰的过程之中，达成理想的愿望越迫切，成功的概率就越大。”

实际上，早在两年前，在一场与大学生的对话当中，李彦宏就点出了理想的重要性，“当你心中有理想时，艰苦条件都变得不重要了。当你不再相信理想时，就会发现周围全部是特别黑暗的东西，会特别不舒服。”

在这次与高考状元的对话中，李彦宏还表示，百度和他的理想一直没有变过，是为了“让人们最平等、便捷地获取信息，找到所求”。这个理想，较之百度创立之初，尽管已经实现了很多，但是李彦宏依然还不满意。“不仅不满意，而且知道有哪些地方可以改进，用什么样的技术可以改进。今天这个时代创新步伐飞快，我们不仅可以见证人类创新加速发展的过程，还可以在里面扮演适合的角色。所以，每每想起这些，我就会非常兴奋、非常激动。”

本文链接

2013-02-16 12:40:23,520 [main] INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MapReduceLauncher - More inf ormation at: http://hd09:50030/jobdetails.jsp?jobid=job_201301221227_72618
 2013-02-16 13:47:50,157 [main] INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MapReduceLauncher - 80% comp lete
 2013-02-16 13:47:52,171 [main] INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MapReduceLauncher - job job_ 201301221227_72618 has failed! Stop running all dependent jobs
 2013-02-16 13:47:52,171 [main] INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MapReduceLauncher - 100% com plete
 2013-02-16 13:47:52,175 [main] ERROR org.apache.pig.tools.pigstats.SimplePigStats - ERROR 2997: Unable to recreate exception f rom backed error: Task attempt_201301221227_72618_m_000000_1 failed to report status for 1201 seconds. Killing!
 2013-02-16 13:47:52,176 [main] ERROR org.apache.pig.tools.pigstats.PigStatsUtil - 1 map reduce job(s) failed!
 2013-02-16 13:47:52,178 [main] INFO  org.apache.pig.tools.pigstats.SimplePigStats - Script Statistics:

Exception in thread "Thread for syncLogs" java.lang.OutOfMemoryError: Java heap space
        at java.util.Arrays.copyOf(Arrays.java:2894)
        at java.lang.AbstractStringBuilder.expandCapacity(AbstractStringBuilder.java:117)
        at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:589)
        at java.lang.StringBuilder.append(StringBuilder.java:220)
        at java.io.UnixFileSystem.resolve(UnixFileSystem.java:108)
        at java.io.File.<init>(File.java:329)
        at org.apache.hadoop.mapred.TaskLog.getAttemptDir(TaskLog.java:267)
        at org.apache.hadoop.mapred.TaskLog.getAttemptDir(TaskLog.java:260)
        at org.apache.hadoop.mapred.TaskLog.getIndexFile(TaskLog.java:237)
        at org.apache.hadoop.mapred.TaskLog.writeToIndexFile(TaskLog.java:316)
        at org.apache.hadoop.mapred.TaskLog.syncLogs(TaskLog.java:369)
        at org.apache.hadoop.mapred.Child$3.run(Child.java:141)
Exception in thread "LeaseChecker" java.lang.OutOfMemoryError: Java heap spac

A = LOAD 'A/dt=2013-02-14' USING PigStorage('\u0001') AS (id:int,name:chararray);
B = LOAD 'B/*' USING PigStorage('\u0001') AS (id:int,gender:chararray);                                                                                              
C = FOREACH (JOIN A BY id , B BY id USING 'replicated') GENERATE  A::id, A::name, A::gender;

• —软件人才免语言低担保 赴美带薪读研！—

• —软件人才免语言低担保 赴美带薪读研！—

• —软件人才免语言低担保 赴美带薪读研！—

　　安卓软件启动时，都会有一个全屏的带LOGO，软件名称，版本号的启动屏幕。这个屏幕是怎么做出来的呢！！下面就一步一步的来！

一、新建项目

打开eclipse，新建一个Android项目，不建Activity。这时就出现一个空白的项目。

1、新建Activity文件

点击项目管理里的res，进入layout，右键点击NEW-》Project-》Android-》Android XML Layout File 按步骤新建一个Activity的XML文件

我是选择新建了一个RelativeLayout，起名为index_layout.xml。

2、新建Activity对应的java文件

点击项目管理里的src，建立一个Package，然后在其上新建一个Class，对应上面新建的Activity。我新建的Class名为Index.java

3、新建颜色文件

点击项目管理里的values，建立Android XML Values File文件，用于存放颜色。我是建的名为color.xml，点击Add，选择Color，Name=white，Value=#ffffff

新建完后，点击index_layout.xml进入，这是Activity界面，我们需要它变成全屏的，同时背景为color.xml定义的白色。

代码如下：

<?xml version="1.0" encoding="utf-8"?><RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:background="@color/white"><TextView 
    android:layout_width="fill_parent"
    android:layout_height="match_parent"
    android:text="@string/app_name"
    /></RelativeLayout>

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:background="@color/white"

这三行是比较重要的，layout_width和layout_height必须为fill_parent，不然无法全屏。当然，有这两个并不能全屏，还需要在AndroidManifest.xml里添加一句，这里先暂时不说，说第三句，这里就是设置从color.xml里调用色彩，改变Activity背景颜色的。TextView这里就根据你的需要进行设计。

现在来说说AndroidManifest.xml里使Activity全屏的关键一句！

AndroidManifest.xml代码如下：

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="landian.cihusport"
    android:versionCode="1"
    android:versionName="1.0" ><uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="19" /><application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@android:style/Theme.NoTitleBar.Fullscreen"><activity android:name="landian.cihusport.Index"><intent-filter><action android:name="android.intent.action.MAIN"></action><category android:name="android.intent.category.LAUNCHER"></category> </intent-filter>  </activity>   </application></manifest>

上面代码，在<application里的android:theme="@android:style/Theme.NoTitleBar.Fullscreen"，是Activity全屏的关键语句。没有这个，无法全屏，切记。

<activity内为定义Activity启动的。

在看Index.java

package landian.cihusport;

import android.app.Activity;
import android.os.Bundle;

public class Index extends Activity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		// TODO Auto-generated method stub
		super.onCreate(savedInstanceState);
		setContentView(R.layout.index_layout);
	}

}

上面代码，大多自动生成，extends Activity为手动添加，onCreate方法为手动程序自动添加，添加方法为：在编辑区右建->source->Override/Implement Methods  在里面找到onCreate()方法，确定就成。setContentView(R.layout.index_layout);为手动添加，意思为启动index_layout这个Activity

至此，就做完了，可以启动虚拟机查看了。

下面在把color.xml的代码贴出。

<?xml version="1.0" encoding="utf-8"?><resources><color name="Green">#ffffff</color></resources>

jinfo –flag UseSerialGC 进程

-XX:+PrintGC 输出GC日志
-XX:+PrintGCDetails 输出GC的详细日志
-XX:+PrintGCTimeStamps 输出GC的时间戳（以基准时间的形式）
-XX:+PrintGCDateStamps 输出GC的时间戳（以日期的形式，如 2013-05-04T21:53:59.234+0800）
-XX:+PrintHeapAtGC 在进行GC的前后打印出堆的信息
-Xloggc:../logs/gc.log 日志文件的输出路径

-XX:+PrintGCDateStamps -XX:+PrintGCDetails -Xloggc:./gclogs

2014-07-18T16:02:17.606+0800: 611.633: [GC 611.633: [DefNew: 843458K->2K(948864K), 0.0059180 secs] 2186589K->1343132K(3057292K), 0.0059490 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

2014-07-18T16:02:17.606+0800（当前时间戳）: 611.633（时间戳）: [GC（表示Young GC） 611.633: [DefNew（单线程Serial年轻代GC）: 843458K（年轻代垃圾回收前的大小）->2K（年轻代回收后的大小）(948864K（年轻代总大小）), 0.0059180 secs（本次回收的时间）] 2186589K（整个堆回收前的大小）->1343132K（整个堆回收后的大小）(3057292K（堆总大小）), 0.0059490 secs（回收时间）] [Times: user=0.00（用户耗时） sys=0.00（系统耗时）, real=0.00 secs（实际耗时）]

2014-07-18T16:19:16.794+0800: 1630.821: [GC 1630.821: [DefNew: 1005567K->111679K(1005568K), 0.9152360 secs]1631.736: [Tenured:
2573912K->1340650K(2574068K), 1.8511050 secs] 3122548K->1340650K(3579636K), [Perm : 17882K->17882K(21248K)], 2.7854350 secs] [Times: user=2.57 sys=0.22, real=2.79 secs]

Heap
 def new generation   total 1005568K, used 111158K [0x00000006fae00000, 0x000000073f110000, 0x0000000750350000)
  eden space 893888K,  12% used [0x00000006fae00000, 0x0000000701710e90, 0x00000007316f0000)
  from space 111680K,   3% used [0x0000000738400000, 0x000000073877c9b0, 0x000000073f110000)
  to   space 111680K,   0% used [0x00000007316f0000, 0x00000007316f0000, 0x0000000738400000)
 tenured generation   total 2234420K, used 1347671K [0x0000000750350000, 0x00000007d895d000, 0x00000007fae00000)
   the space 2234420K,  60% used [0x0000000750350000, 0x00000007a2765cb8, 0x00000007a2765e00, 0x00000007d895d000)
 compacting perm gen  total 21248K, used 17994K [0x00000007fae00000, 0x00000007fc2c0000, 0x0000000800000000)
   the space 21248K,  84% used [0x00000007fae00000, 0x00000007fbf92a50, 0x00000007fbf92c00, 0x00000007fc2c0000)
No shared spaces configured.

本文附件下载:
• gcviewer-1.34-SNAPSHOT.jar (449.7 KB)

• —软件人才免语言低担保 赴美带薪读研！—

@Test
public void test1Normal() {
    Jedis jedis = new Jedis("localhost");
    long start = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        String result = jedis.set("n" + i, "n" + i);
    }
    long end = System.currentTimeMillis();
    System.out.println("Simple SET: " + ((end - start)/1000.0) + " seconds");
    jedis.disconnect();
}

@Test
public void test2Trans() {
    Jedis jedis = new Jedis("localhost");
    long start = System.currentTimeMillis();
    Transaction tx = jedis.multi();
    for (int i = 0; i < 100000; i++) {
        tx.set("t" + i, "t" + i);
    }
    List<Object> results = tx.exec();
    long end = System.currentTimeMillis();
    System.out.println("Transaction SET: " + ((end - start)/1000.0) + " seconds");
    jedis.disconnect();
}

@Test
public void test3Pipelined() {
    Jedis jedis = new Jedis("localhost");
    Pipeline pipeline = jedis.pipelined();
    long start = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        pipeline.set("p" + i, "p" + i);
    }
    List<Object> results = pipeline.syncAndReturnAll();
    long end = System.currentTimeMillis();
    System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " seconds");
    jedis.disconnect();
}

@Test
public void test4combPipelineTrans() {
    jedis = new Jedis("localhost"); 
    long start = System.currentTimeMillis();
    Pipeline pipeline = jedis.pipelined();
    pipeline.multi();
    for (int i = 0; i < 100000; i++) {
        pipeline.set("" + i, "" + i);
    }
    pipeline.exec();
    List<Object> results = pipeline.syncAndReturnAll();
    long end = System.currentTimeMillis();
    System.out.println("Pipelined transaction: " + ((end - start)/1000.0) + " seconds");
    jedis.disconnect();
}

@Test
public void test5shardNormal() {
    List<JedisShardInfo> shards = Arrays.asList(
            new JedisShardInfo("localhost",6379),
            new JedisShardInfo("localhost",6380));

    ShardedJedis sharding = new ShardedJedis(shards);

    long start = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        String result = sharding.set("sn" + i, "n" + i);
    }
    long end = System.currentTimeMillis();
    System.out.println("Simple@Sharing SET: " + ((end - start)/1000.0) + " seconds");

    sharding.disconnect();
}

@Test
public void test6shardpipelined() {
    List<JedisShardInfo> shards = Arrays.asList(
            new JedisShardInfo("localhost",6379),
            new JedisShardInfo("localhost",6380));

    ShardedJedis sharding = new ShardedJedis(shards);

    ShardedJedisPipeline pipeline = sharding.pipelined();
    long start = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        pipeline.set("sp" + i, "p" + i);
    }
    List<Object> results = pipeline.syncAndReturnAll();
    long end = System.currentTimeMillis();
    System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0) + " seconds");

    sharding.disconnect();
}

@Test
public void test7shardSimplePool() {
    List<JedisShardInfo> shards = Arrays.asList(
            new JedisShardInfo("localhost",6379),
            new JedisShardInfo("localhost",6380));

    ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);

    ShardedJedis one = pool.getResource();

    long start = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        String result = one.set("spn" + i, "n" + i);
    }
    long end = System.currentTimeMillis();
    pool.returnResource(one);
    System.out.println("Simple@Pool SET: " + ((end - start)/1000.0) + " seconds");

    pool.destroy();
}

@Test
public void test8shardPipelinedPool() {
    List<JedisShardInfo> shards = Arrays.asList(
            new JedisShardInfo("localhost",6379),
            new JedisShardInfo("localhost",6380));

    ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);

    ShardedJedis one = pool.getResource();

    ShardedJedisPipeline pipeline = one.pipelined();

    long start = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        pipeline.set("sppn" + i, "n" + i);
    }
    List<Object> results = pipeline.syncAndReturnAll();
    long end = System.currentTimeMillis();
    pool.returnResource(one);
    System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds");
    pool.destroy();
}

Transaction tx = jedis.multi();
for (int i = 0; i < 100000; i++) {
    tx.set("t" + i, "t" + i);
}
System.out.println(tx.get("t1000").get());  //不允许

List<Object> results = tx.exec();

Pipeline pipeline = jedis.pipelined();
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
pipeline.set("p" + i, "p" + i);
}
System.out.println(pipeline.get("p1000").get()); //不允许

List<Object> results = pipeline.syncAndReturnAll();

Simple SET: 5.227 seconds
Transaction SET: 0.5 seconds
Pipelined SET: 0.353 seconds
Pipelined transaction: 0.509 seconds
Simple@Sharing SET: 5.289 seconds
Pipelined@Sharing SET: 0.348 seconds
Simple@Pool SET: 5.039 seconds
Pipelined@Pool SET: 0.401 seconds

Simple@Sharing SET: 5.494 seconds
Pipelined@Sharing SET: 0.51 seconds
Simple@Pool SET: 5.223 seconds
Pipelined@Pool SET: 0.518 seconds

Simple@Sharing SET: 5.9 seconds
Pipelined@Sharing SET: 0.794 seconds
Simple@Pool SET: 5.624 seconds
Pipelined@Pool SET: 0.762 seconds

Simple@Sharing SET: 14.055 seconds
Pipelined@Sharing SET: 8.185 seconds
Simple@Pool SET: 13.29 seconds
Pipelined@Pool SET: 7.767 seconds

package com.bijian.study;

import java.util.Arrays;
import java.util.List;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPipeline;
import redis.clients.jedis.ShardedJedisPool;
import redis.clients.jedis.Transaction;

import org.junit.FixMethodOrder;
import org.junit.runners.MethodSorters;

@SuppressWarnings("unused")
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class TestJedis {

	private static Jedis jedis;
	private static ShardedJedis sharding;
	private static ShardedJedisPool pool;

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		List<JedisShardInfo> shards = Arrays.asList(new JedisShardInfo("192.168.128.129", 6379), new JedisShardInfo("192.168.128.129",6379)); // 使用相同的ip:port,仅作测试

		jedis = new Jedis("192.168.128.129");
		sharding = new ShardedJedis(shards);

		pool = new ShardedJedisPool(new JedisPoolConfig(), shards);
	}

	@AfterClass
	public static void tearDownAfterClass() throws Exception {
		jedis.disconnect();
		sharding.disconnect();
		pool.destroy();
	}

	@Test
	public void test1Normal() {
		long start = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			String result = jedis.set("n" + i, "n" + i);
		}
		long end = System.currentTimeMillis();
		System.out.println("Simple SET: " + ((end - start) / 1000.0)
				+ " seconds");
	}

	@Test
	public void test2Trans() {
		long start = System.currentTimeMillis();
		Transaction tx = jedis.multi();
		for (int i = 0; i < 100000; i++) {
			tx.set("t" + i, "t" + i);
		}
		// System.out.println(tx.get("t1000").get());

		List<Object> results = tx.exec();
		long end = System.currentTimeMillis();
		System.out.println("Transaction SET: " + ((end - start) / 1000.0)
				+ " seconds");
	}

	@Test
	public void test3Pipelined() {
		Pipeline pipeline = jedis.pipelined();
		long start = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			pipeline.set("p" + i, "p" + i);
		}
		// System.out.println(pipeline.get("p1000").get());
		List<Object> results = pipeline.syncAndReturnAll();
		long end = System.currentTimeMillis();
		System.out.println("Pipelined SET: " + ((end - start) / 1000.0)
				+ " seconds");
	}

	@Test
	public void test4combPipelineTrans() {
		long start = System.currentTimeMillis();
		Pipeline pipeline = jedis.pipelined();
		pipeline.multi();
		for (int i = 0; i < 100000; i++) {
			pipeline.set("" + i, "" + i);
		}
		pipeline.exec();
		List<Object> results = pipeline.syncAndReturnAll();
		long end = System.currentTimeMillis();
		System.out.println("Pipelined transaction: " + ((end - start) / 1000.0)
				+ " seconds");
	}

	@Test
	public void test5shardNormal() {
		long start = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			String result = sharding.set("sn" + i, "n" + i);
		}
		long end = System.currentTimeMillis();
		System.out.println("Simple@Sharing SET: " + ((end - start) / 1000.0)
				+ " seconds");
	}

	@Test
	public void test6shardpipelined() {
		ShardedJedisPipeline pipeline = sharding.pipelined();
		long start = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			pipeline.set("sp" + i, "p" + i);
		}
		List<Object> results = pipeline.syncAndReturnAll();
		long end = System.currentTimeMillis();
		System.out.println("Pipelined@Sharing SET: " + ((end - start) / 1000.0)
				+ " seconds");
	}

	@Test
	public void test7shardSimplePool() {
		ShardedJedis one = pool.getResource();

		long start = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			String result = one.set("spn" + i, "n" + i);
		}
		long end = System.currentTimeMillis();
		pool.returnResource(one);
		System.out.println("Simple@Pool SET: " + ((end - start) / 1000.0)
				+ " seconds");
	}

	@Test
	public void test8shardPipelinedPool() {
		ShardedJedis one = pool.getResource();

		ShardedJedisPipeline pipeline = one.pipelined();

		long start = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			pipeline.set("sppn" + i, "n" + i);
		}
		List<Object> results = pipeline.syncAndReturnAll();
		long end = System.currentTimeMillis();
		pool.returnResource(one);
		System.out.println("Pipelined@Pool SET: " + ((end - start) / 1000.0)
				+ " seconds");
	}
}

Simple SET: 24.316 seconds
Transaction SET: 2.641 seconds
Pipelined SET: 1.016 seconds
Pipelined transaction: 1.484 seconds
Simple@Sharing SET: 29.287 seconds
Pipelined@Sharing SET: 1.953 seconds
Simple@Pool SET: 31.537 seconds
Pipelined@Pool SET: 1.156 seconds

[root@localhost bin]# /usr/local/redis/bin/redis-cli
127.0.0.1:6379> dbsize
(integer) 800000
127.0.0.1:6379> 

本文附件下载:
• commons-pool-1.6.jar (108.5 KB)
• hamcrest-core-1.3.jar (44 KB)
• jedis-2.1.0.jar (136.2 KB)
• junit-4.11.jar (239.3 KB)

• —软件人才免语言低担保 赴美带薪读研！—

if( window.event.shiftKey && event.keyCode==xx) 

function document_onpress() 
{ 

if(event.keyCode=='13') 
{ 
document.all.div_Line.style.pixelLeft=document.all.div_Line.style.pixelLeft+1; 
document.all.div_Q.style.pixelLeft=document.all.div_Q.style.pixelLeft+1; 
document.all.div_T.style.pixelLeft=document.all.div_T.style.pixelLeft+1; 

} 

• —软件人才免语言低担保 赴美带薪读研！—

• —软件人才免语言低担保 赴美带薪读研！—

• —软件人才免语言低担保 赴美带薪读研！—

• —软件人才免语言低担保 赴美带薪读研！—

基本上ZeroMQ（java）中基本的代码都算是过了一遍了吧，不过觉得它在日志这一块貌似基本没有做什么工作，也就是我们通过日志来知道ZeroMQ都发生了什么事情。。

而且由于ZeroMQ中将连接的建立和重连接都进行了隔离，用户不需要做什么事情来维护连接，当然这样做的好处是使程序员的编码工作变少了，但是当然也有不好的地方，那就是用户失去了对ZeroMQ整个运行阶段的控制。。

例如，当我们主动去连接一个远程地址，或者连接中断之后，没有日志告诉我们都这些事情发生了。。。当时对于一个消息通信系统来说，这些日志，或者说事件的监控都是至关重要的。

当然没有日志来记录这些内容，并不代表我们就无法知道当前运行情况都发生了什么事情，ZeroMQ中采用了另外一种方法来监控Socket的情况，不过这种方法比较恶心，需要建立额外的Socket来监控自己感兴趣的Socket。。。

这里先不说这些闲话了，来看看ZeroMQ中都定义了哪些监听事件：

    public static final int EVENT_CONNECTED = zmq.ZMQ.ZMQ_EVENT_CONNECTED;   //当主动建立连接建立成功之后的事件
    public static final int EVENT_DELAYED = zmq.ZMQ.ZMQ_EVENT_CONNECT_DELAYED;   //连接延迟
    public static final int EVENT_RETRIED = zmq.ZMQ.ZMQ_EVENT_CONNECT_RETRIED;    //尝试重新连接
    public static final int EVENT_CONNECT_FAILED = zmq.ZMQ.ZMQ_EVENT_CONNECT_FAILED;   //连接失败

    public static final int EVENT_LISTENING = zmq.ZMQ.ZMQ_EVENT_LISTENING;    //建立了监听
    public static final int EVENT_BIND_FAILED = zmq.ZMQ.ZMQ_EVENT_BIND_FAILED;  //bind失败

    public static final int EVENT_ACCEPTED = zmq.ZMQ.ZMQ_EVENT_ACCEPTED;   //接收到accept事件
    public static final int EVENT_ACCEPT_FAILED = zmq.ZMQ.ZMQ_EVENT_ACCEPT_FAILED;   //accept出错的事件

    public static final int EVENT_CLOSED = zmq.ZMQ.ZMQ_EVENT_CLOSED;   //关闭事件
    public static final int EVENT_CLOSE_FAILED = zmq.ZMQ.ZMQ_EVENT_CLOSE_FAILED;     //关闭失败
    public static final int EVENT_DISCONNECTED = zmq.ZMQ.ZMQ_EVENT_DISCONNECTED;   //连接断开

    public static final int EVENT_ALL = zmq.ZMQ.ZMQ_EVENT_ALL;   //所有的事件

上面是定义的所有可能发生的事件，具体每一种事件代表什么意思后面的注释都已经说明了，当然这里面我觉得最重要的事件有连接的断开，连接的建立，以及重连接等事件。。。

接下来我们来看看如何在ZeroMQ（java）中来监控这些事件吧，直接上代码了：

import org.zeromq.ZMQ;

import zmq.ZMQ.Event;

public class Request {
	public static void main (String args[]) {
		ZMQ.Context context = ZMQ.context(1);
		ZMQ.Socket req = context.socket(ZMQ.REQ);
		
		req.monitor("inproc://reqmoniter", ZMQ.EVENT_CONNECTED | ZMQ.EVENT_DISCONNECTED);  //这段代码会创建一个pair类型的socket，专门来接收当前socket发生的事件
		
		final ZMQ.Socket moniter = context.socket(ZMQ.PAIR);   //这里创建一个pair类型的socket，用于与上面建立的moniter建立连接
		moniter.connect("inproc://reqmoniter");  //连接当前socket的监听
		
		new Thread(new Runnable(){

			public void run() {
				// TODO Auto-generated method stub
				while (true) {
					Event event = Event.read(moniter.base());  //从当前moniter里面读取event
					System.out.println(event.event +  "  " + event.addr);
				}
			}
		}).start();
		req.connect("tcp://127.0.0.1:5000");
		while (true) {
			req.send("aaa");
			req.recv();
		}
	}
}

package monit;

import org.zeromq.ZMQ;

public class Response {
	public static void main(String args[]) {
		final ZMQ.Context context = ZMQ.context(1);
		

	
		ZMQ.Socket response = context.socket(ZMQ.REP);
		response.bind("tcp://*:5000");
		while (!Thread.currentThread().isInterrupted()) {
			response.recv();
			response.send("hello".getBytes());
			try {
				Thread.currentThread().sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		response.close();
		context.term();
	}
}

这里代码用req/rep来举例子的，其实用起来还算是比较的简单，当连接建立之后，将会输出：

1  tcp://127.0.0.1:5000

1就是代表连接建立的事件，后面是建立连接的地址，

这个时候如果关闭response，那么将会输出如下：

512  tcp://127.0.0.1:5000

512代表的就是连接断开的事件。。。

嗯，至于说监控的源码是怎么实现的，这里就不细说了，其实还是非常的简单的，如果有兴趣可以自己去看看。。

到此ZeroMQ(java)的代码就算是读的差不多了，算是告一段落吧，接下来好好看看书。。。另外有想 再搞搞C/C++方面的东西。。。初步计划看看Redis的源码吧。。。。