Herbert Yang

ANT自动化压缩合并JS/CSS和更改版本号

Herbert — Tue, 20 Jul 2010 13:19:40 +0000

最近做到了前端优化的一些工作，涉及到了自动化部署的问题。前端优化无非是雅虎的优化法则，不过如果想把优化法则加到自动化部署中去的话，下面的几种方法可以帮助你。
1、JS/CSS压缩脚本

2、更新JSS/CSS版本号

接下来就是合并JS/CSS文件

图片外链测试

Herbert — Fri, 28 May 2010 07:25:14 +0000

http://photo.163.com/relgion0108/#p=0&m=0&page=1

http://photo.163.com/relgion0108/list/#aid=203073273&m=0&page=1

HTTP 错误

Herbert — Fri, 28 May 2010 07:12:48 +0000

HTTP 400 – 请求无效
HTTP 401 – 未授权
HTTP 403 – 禁止访问
HTTP 404 – 无法找到文件
HTTP 405 – 资源被禁止
HTTP 406 – 无法接受
HTTP 407 – 要求代理身份验证
HTTP 410 – 永远不可用
HTTP 412 – 先决条件失败
HTTP 414 – 请求 – URI 太长
HTTP 500 – 内部服务器错误
HTTP 501 – 未实现
HTTP 502 – 网关错误

程序员那些事儿

Herbert — Sun, 23 May 2010 16:19:32 +0000

没有最好，只有更好。

前不久，和北京的一个同事讨论一些问题的时候，他突然说：“很高兴自己是做开发的，特别是Web开发，我很喜欢这个行业。” 当时，我凝固了，我想这家伙不是写代码写傻了，不过，随后我回了一句，我也喜欢。哈哈～～自己又是一阵诡异的傻笑。这是我做开发这么长时间以来，第一次听到有朋友说喜欢这个行业，也是自己第一次承认自己也喜欢开发。
当然，这篇文章主要是写给非程序员的人，来了解程序员这个工种。
我是一个程序员（开发工程师），我极力的用其他工种的思维来思考那群程序员。

1、我提出的需求会不会被他们拒绝，我的需求是不是有些离谱？
不，程序员不喜欢拒绝你的想法，越有难度，越有挑战，你的需求也永远不会离谱，在他们看来，需求方的想法很少“正常“过。以前，我在一个香港人开的公司的时候，老板说他要做个像银行一样的叫号机器，还要打印和银行一样那种纸条，说是要卖20W。结果，还是被我用WEB做出来了，最后这个代码卖了10W。

2、我的文档写详细了没？不知道他们理不理解我的想法？
在程序员看来，需求方（客户）的想法永远是模糊的，抽象的。我们的工作就是把抽象事物实例化，具体化。还是叫号机的例子，我一开始就想，就喊我一个人，要搞定银行花了那么多钱做的叫号系统，有点狂想。和老板交谈后，老板说，不管怎么样，只要有声音，如果排队的人有次序，成本最便宜就可以了。得，这就好办，最后我还给他弄了个男女声版的叫号系统。

3、我还有很多想法，要不要告诉他们？
当然要说，越早说越好。早一点告诉我们，总比晚说好，不然他们会发出奇怪的语气助词，并用010的眼神说，“啊！原来你要做成这样。”，即使，有个想法没有做成功，但有一天可能他们会说：“嘿～～上次，你们说的那个想法还想要吗？我们现在可以实现了。”。当然沟通是最花时间的，更何况要把你的想法告诉一堆用120码速度思考问题的”疯子“。高速路上不太好换路线，错过了那个岔路口，要绕很久才能出高速，再上高速，方案的改变需要成本，越早告诉司机要去哪里，越好。

4、技术实现成本和需求强烈程度哪个优先考虑？
在这个时候，你可能被问，你一定要求这样做吗？这是时候需要慎重考虑这个问题。程序员们常在时间，性能，成本，可扩展性之间追求一个平衡，追求性价比最高的解决方案。

5、能不能实现？要多久？
这是我经常被问的一个问题，一般在回答不能实现的后面，我会说你可以这样做。

总之，这是一群可爱的程序员们，他们的世界充满着冒险和刺激，每天都在对付疯狂的需求和诡异的问题。

用JAVA实现简单的Memcached功能

Herbert — Wed, 19 May 2010 10:50:58 +0000

慎用，一般不提倡占用应用服务器的内存。

MemcacheMapVO.java

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * MemcacheMap 保存的对象
 *
 * @author Herbert
 *
 */
public class MemcacheMapVO implements Serializable {
	/**
	 *
	 */
	private static final long serialVersionUID = 2719454259953108119L;

	/**
	 * value
	 */
	private Object value;

	/**
	 * 过期时间
	 */
	private Long expires;

	public Object getValue() {
		return value;
	}

	public void setValue(Object value) {
		this.value = value;
	}

	public Long getExpires() {
		return expires;
	}

	public void setExpires(Long expires) {
		this.expires = expires;
	}

	public int size() {
		try {
			ByteArrayOutputStream buf = new ByteArrayOutputStream();
			ObjectOutputStream o = new ObjectOutputStream(buf);
			o.writeObject(this.value);
			byte[] bytes = buf.toByteArray();
			return bytes.length * 8;
		} catch (IOException e) {
			e.printStackTrace();
		}
		return 0;
	}
}

MemcacheMapUtil.java

import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.Map.Entry;

import com.netease.photo.share.meta.vo.MemcacheMapVO;

/**
 * 用JAVA实现简单的Memcached功能<br>
 *
 * @author Herbert
 *
 */
public final class MemcacheMapUtil {
	private MemcacheMapUtil() {

	}

	public static final int MINUTES = 60;

	/**
	 * MAP个数
	 */
	private static final long MAXSIZE = 3000;

	/**
	 * 安全个数
	 */
	private static final long SAFESIZE = 2800;

	/**
	 * 最大时间
	 */
	private static final int MAXTIME = 24 * 60 * 60 * 1000;

	/**
	 * 存储的值
	 */
	private static HashMap<String, MemcacheMapVO> memcacheMap = new HashMap<String, MemcacheMapVO>();

	/**
	 * 得到值
	 *
	 * @param key
	 *
	 * @return
	 */
	public static Object get(final String key) {
		MemcacheMapVO memcacheMapVO = memcacheMap.get(key);
		long now = new Date().getTime();
		// 判断是否有这个值存在
		if (memcacheMapVO == null) {
			return null;
			// 判断保存的值是否过期
		} else if (now >= memcacheMapVO.getExpires()) {
			memcacheMap.remove(key);
			return null;
		} else {
			return memcacheMapVO.getValue();
		}
	}

	/**
	 * 删除值
	 *
	 * @param key
	 */
	public static void delete(final String key) {
		memcacheMap.remove(key);
	}

	/**
	 *
	 * @param key
	 *            对象的KEY
	 * @param value
	 *            对象的值
	 * @param seconds
	 *            对象的有效时间
	 */
	public static void set(final String key, final Object value, final int seconds) {
		// 清理工作
		int count = memcacheMap.size();
		if (count <= MemcacheMapUtil.SAFESIZE) {
			// 小于安全个数，不需要清理
		} else if (count > MemcacheMapUtil.SAFESIZE) {
			// 大于安全个数，按时间清理
			checkMemcacheMap();
			if (count >= MemcacheMapUtil.MAXSIZE) {
				// 清理后无效，进行强制清理
				clearMemcacheMap();
			}
		}
		// 增加值的工作
		MemcacheMapVO memcacheMapVO = new MemcacheMapVO();
		memcacheMapVO.setValue(value);
		long now = new Date().getTime();

		long expires = seconds * 1000;
		if (expires >= MAXTIME) {
			expires = MAXTIME;
		}
		expires += now;
		memcacheMapVO.setExpires(expires);
		memcacheMap.put(key, memcacheMapVO);
	}

	/**
	 * 默认保存时间为12小时
	 *
	 * @param key
	 * @param value
	 */
	public static void set(final String key, final Object value) {
		set(key, value, 12 * 60 * 60);
	}

	/**
	 * 产生一个KEY
	 *
	 * @param methodName
	 *            方法名
	 * @param parameters
	 *            参数列表
	 */
	public static String createKey(String methodName, Object... parameters) {
		String str = methodName;
		for (Object obj : parameters) {
			str += "_" + obj.toString();
		}
		return str;
	}

	/**
	 * 强制清理到安全值
	 */
	private static void clearMemcacheMap() {
		// 清除
		long clearCount = MemcacheMapUtil.MAXSIZE - MemcacheMapUtil.SAFESIZE;
		String[] keys = (String[]) memcacheMap.keySet().toArray();
		int keyCount = keys.length;
		Random random = new Random();
		for (int i = 0; i < clearCount; i++) {
			int randomIndex = random.nextInt(keyCount);
			String key = keys[randomIndex];
			delete(key);
		}
	}

	/**
	 * 检查过期的对象
	 */
	private static void checkMemcacheMap() {
		// 这种迭代的方式节约了一次迭代
		Iterator<Entry<String, MemcacheMapVO>> iterator = memcacheMap.entrySet().iterator();
		long now = new Date().getTime();
		while (iterator.hasNext()) {
			Map.Entry<String, MemcacheMapVO> entry = (Map.Entry<String, MemcacheMapVO>) iterator.next();
			String key = (String) entry.getKey();
			MemcacheMapVO memcacheMapVO = entry.getValue();
			if (now >= memcacheMapVO.getExpires()) {
				memcacheMap.remove(key);
			}
		}
	}
}

海量数据迁移

Herbert — Tue, 11 May 2010 13:17:29 +0000

#按照文件的行数拆分文件
split -l 5000 large_file.txt new_file_prefix
#批量重命名文件夹里的文件
find -name 'x*' -printf %f\\n|awk -F'.' '{print $1}'|xargs -i{} mv {} {}.txt

这次迁移Exif信息，数据有4亿的数据，为了不影响另外一个系统，采用单节点数据文件迁移（具体还有很多因素）。
首先是拆分数据文件为小文件，即使程序错误或者其它中断，也只影响少量数据，重新迁移的话，只有少量数据是空转。
当然使用小文件还有个原因是考虑到要记录没有处理的数据，所以这些文件数据是要读到内存中去的。
还有就是可以做到多进程多线程迁移数据，只有你的数据库足够强大，抗得住压力。
此过程中可以以文件为单位，采用多线程操作，可以提高速度。

ThreadPoolExecutor threadPool = new ThreadPoolExecutor(15, 100, 1, TimeUnit.SECONDS,
				new ArrayBlockingQueue(10), new ThreadPoolExecutor.DiscardOldestPolicy());

这个线程池当处理不过来时，会丢弃任务，所以我是采用这样的方式解决这个问题的。

			while (threadPool.getPoolSize() > 80) {
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}

得到Java进程的PID

String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];

迁移的效率还是比较高，导致数据库扛不住了，必须在白天放慢迁移速度。

FreeMarker Plugin for Eclipse

Herbert — Mon, 10 May 2010 13:14:54 +0000

搜索了好久的FreeMarker插件，原来在这里。

http://www.jboss.org/tools/download/

在Eclipse中调试Resin的工程

Herbert — Thu, 06 May 2010 16:55:52 +0000

首先把Resin_Lib引入到Eclipse项目，然后Debug Configurations一个新的调试，命名为Resin。
参数配置如下：
Main class:
com.caucho.server.resin.Resin

Program arguments:
-conf “/home/app/resin/conf/resin.xml”

VM arguments:
-Dresin.home=”/home/app/resin/”
-Djava.util.logging.manager=com.caucho.log.LogManagerImpl

这样就可以在Eclipse的控制台下看Resin日志了。

技术交流会

Herbert — Wed, 05 May 2010 09:29:41 +0000

只能说是很久以前了（呵呵，因为没把这件事写入Blog），所以就不介绍了，过期作废。

这样的活动还是不错，目前已经组织了两次了：

程序员圆桌会议第一期–Java并发编程

程序员圆桌会议第二期–关于JVM的那些事

我参加了第一次的交流会，我做的PPT是《线程飞扬》

广州之行

Herbert — Tue, 04 May 2010 16:16:24 +0000

广州之行还是比较顺利，需要办理的事情都成功办好了。之余还和在广州认识的朋友碰了下面，发了些牢骚，哈哈，感谢这些倾听和共鸣的朋友。

这次广州之行恰好是广交会期间，房价和机票贼高，真是有点高成本。

意外的收获是在飞机上认识了一位去广交会的巴西华侨，然后聊了很久，更意外的是，回到杭州后，和这位朋友在杭州也吃了顿饭。

遗憾的是没有看到Raymond的新手机，三脚猫聚餐的时候波哥（林静波）没来。