<?xml version="1.0" encoding="UTF-8"?><!-- generator="WordPress/2.9.1" -->
<rss version="0.92">
<channel>
	<title>J2EE企业应用 顾问/咨询- H.E.&#039;s Blog</title>
	<link>http://www.javabloger.com</link>
	<description>用最简洁的页面描述企业应用与Java艺术!</description>
	<lastBuildDate>Tue, 06 Dec 2011 04:31:48 +0000</lastBuildDate>
	<docs>http://backend.userland.com/rss092</docs>
	<language>en</language>
	
	<item>
		<title>大型互联网站解决海量数据的常见策略</title>
		<description><![CDATA[&#160; &#160;大型互联网站的数据存储与传统存储环境相比不仅是一个服务器、一个数据库那么简单，而是由网络设备、存储设备、应用服务器、公用访问接口、应用程序 等多个部分组成的复杂系统。分为 业务数据层、计算层、数据仓储、数据备份，通过应用服务器软件提供数据存储服务，并且通过监控工具对存储单元监控。
&#160; &#160; 随着系统中用户数据量的线性增长，数据量将会越来越多。在这样一个数据不断膨胀的环境中，数据已经如洪水般汹涌泛滥。数据查找和调用困难，在海量数据中一些用户提交的请求往往要等到第二天才能得知结果，直接影响到了用户满意度的提升和新业务的布局。在技术上而言，这一特点使得RDBMS在大型应用场景被大幅限制，唯一的可选方案是Scale Out,通过增加多个逻辑单元的资源,并使它们如同一个集中的资源那样提供服务来实现系统的扩展性。
	&#160; &#160;系统中的数据就好比我们家里的物品，衣服放在衣柜里，碟子放在碗橱里，数据库、存储系统就好比你的衣柜和碗橱是一个存放的容器，衣服和碟子就好比不同的数据，将不同类型的东西放入合适的存储空间里面，这样系统的效率和利用率将会更高，所以我们将会做出如下设计，如图所示：
	
查看大图请点击这里
对于大型系统存储单元的结构模型我们分为6个部分组成，清单如下：
1. 业务数据层
	各类业务所产生的各种文件类型的数据，其中包含 用户信息、用户操作记录、实时业务数据、手机客户端升级应用程序、图片，等。
2. 计算层
	针对不同的数据格式、不同类型的数据文件，通过不同的工具、计算方法进行操作，针对大量的数据计算采用一些分布式、并行计算的算法，例如：MapReduce，BSP。并且对一部分的数据进行缓存，缓解对存储应用服务器的压力。
3. 数据存储层
	对于海量数据的查询与存储，特别是针对用户行为日志操作，需要使用到一些列式数据库服务器，对于处理业务和一些业务规则的数据依然存放在关系型数据库中，将采用MySQL来存储。
4. 数据仓储
	数据存储主要是针对于用户行为日志和用户行为分析，也是系统中数据量产生较大的一个环节，将会采用Apache Hive、Pig、Mathout 对数据仓储进行构建。
5. 数据备份
	分为在线数据备份和离线数据备份，数据备份环节需要经过运维经验的积累，根据业务和用户访问量进行定制合理的备份规律。
6. 硬件
	硬件环境是存储单元最基础的部分，分为磁盘、内存、网络设备存储，将不同的业务数据、文件存储在不同的硬件设备上。
技术实现
	对于系统不同的业务数据和应用服务器的架构需要采用不同的读写方式，以及数据存储类型存放，数据仓储构建，数据冷热分离、数据索引多个部分组成。例如：业务应用程序、日志采集代理、用户空间文件系统（Filesystem in Userspace）。Data Access Proxy Layer(DDAL/Cache Handler)、OLAP、日志服务器、Oracle(暂定)、MySQL、Redis、Hive、HDFS、Moosefs。
如图所示：
	
	查看大图请点击这里
针对以上设计架构，描述清单如下：
1. Data Access Proxy Layer
	统称数据访问代理层(简称 DAPL)，封装了DDAL和Cache Handler层，抽象的对编写的应用程序进行了划分，便于扩展和维护，例如：需要对HDFS或者图形数据库操作，上层不需要知道HDFS具体操作，只需要关注提供的接口。DAPL封装了很多访问各种数据源的读写策略。因此，可以保证对不同数据库、数据源操作的事务完整性。
2. DDAL
	统称分布式数据访问层(简称 DDAL)主要针对关系数据库的读写分离操作，需要做到读写分离，首先需要对传入的SQL语句进行解析，并且采用Round-Robin算法负载分载对数据大量读取的操作，在代码实现中将使用MySQL-JDBC中的参数配置实现对MySQL-Slave的读取压力分载。
3. Cache Handler
	与DDAL的相似，具体区别在于自己实现了Round-Robin算法负载分载对数据大量读取的操作，并且能在Redis Master当机的状态下重新指派新的Master进行写的操作。
4. Redis一主多从
	对缓存数据进行读写分离，减少单台机器的I/O瓶颈，值得一提的是Cache不是可靠的存储，所以在设计时，需要容许Cache的数据丢失，因此，Cache的数据全部失效时，会从数据库里重新装载。
5. MySQL双主多从
	这种方式是MySQL架构设计中最折中的方案，对数据的访问压力分载和数据的可靠性都有了相应的保障。前端2台Master MySQL相互进行数据备份，后端大量的Slave MySQL对Master写入的数据进行同步，所以每台机器节点上的MySQL数据库中的数据都是一致的，并且DDAL应用程序将数据轮询写入Master MySQL数据库中。
6. 数据库读写分离
	主要采用mysql的策略，学习MySQL-Prxoy的策略，自己开发对MySQL书籍节点进行读写分离的方法，MySQL驱动支持读写分离的数据完整性，当数据量超大规模的时候将会采用Sharding策略。
7. 缓存读写分离
	缓存Redis的策略，采用自己开发的应用程序需要实现Round Robin算法，对Redis Master和Slave缓存集群进行读写分离操作。
8. ETL Tools
	采用Apache Hadoop项目中的Pig对海量的行为数据进行清洗，Pig可以针对有规律的半结构化数据执行类似SQL的脚本，并且可以将计算压力分载到每台服务器上进行分布式、并行处理。
9. Hive集群
	针对数据仓库的建设由Apache Hive进行构建，是一个建立在Hadoop上的数据仓库框架，它提供了一个方便的数据集成方法和类似SQL的Hive QL查询语言，实现了Map/Reduce算法支持在Hadoop框架上进行大规模数据分析。
10. HDFS分布式文件系统
	Hive中的数据全部存储在Hadoop分布式文件系统中，所有被存储的数据都会有数据的存储副本，这样对数据的可靠性有了保障。
11. Moosefs分布式文件系统
	与上面提到的HDFS一个文件系统是有区别的，Moosefs不需要任何客户端程序对分布式文件进行操作的服务器，可以直接与任何运行环境进行对接，而且服务端也有副本复制的功能。
12. 冷热数据分离
	将系统中产生的进行归类存放，将用户更多关心、热门话题等内容 抽象为&#8220;最近几天&#8221;的&#8220;热数据&#8221;，而越早的数据我们在设计中抽象的分为&#8220;冷数据&#8221;。由此可见，&#8220;热节点&#8221;存放最新的、被访问频率较高的数据。对于这部分数据，我们希望能给用户提供尽可能快的查询速度，因此无论在硬件还是软件的选择上都会有了明显的区分，例如：最近常访问频率高的数据将会存储在系统缓存中，需要经常性被的业务数据将会存储在MySQL或者Oracle数据库系统中，
&#160;
相关文章
	大型互联网站解决高并发的常见策略
&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/big-data-architecture.html?source=rss</link>
			</item>
	<item>
		<title>大型互联网站解决高并发的常见策略</title>
		<description><![CDATA[一个运营的系统在正式上线后将会遇到各种层级的高并发请求，因此我们必须对此做出相应的策略和技术解决方案，首先我们需要认清系统的高并发由3个层面导致：
1. 传输层
	大量用户对系统请求后，将会造成网络带宽和Web服务器的I/O瓶颈。
2. 计算层
	接收大量用户请求进行计算，将会造成业务服务器和业务支撑服务器的瓶颈。
3. 存储层
	传输层和计算层将会产生大量的数据，数据量暴增，将会导致数据库和储存上的瓶颈。
针对以上将会造成的系统高并发瓶颈，我们需要采用不同的技术手段解决。
从总体上来看
	1.首先需要解决网络带宽和Web请求的高并发，需要合理的加大服务器和带宽的投入，并且需要充分的利用系统中软件、硬件的缓存机制，将能缓存的内容都进行缓存存储，减少计算层和存储层的压力。
2.其次需要对业务服务器和业务支撑服务器进行合理的分层，并且采用并行计算和分布式算法对大量计算进行处理，并且在开发的过程中需要采用Java SDK中并发包(Concurrency)进行编码实现。
3.存储层需要采用分布式文件服务器和列式的存储服务器进行构建，支撑海量数据的存放和读取，并且还要对关系型数据进行深层次的配置参数优化。
4.我们还需要清楚的认识到，将来根据系统运行的状态以及平台中不同的业务场景循序渐进的进行调整和优化。

&#160; &#160;对于大型系统来说，采用的技术是涉及面非常广，从硬件到软件、编程语言、数据库、WebServer、防火墙等各个领域都有了很高的要求。在面对大量用户访问、高并发请求方面，基本的解决方案集中在这样几个环节：将会使用高性能的服务器、高性能的数据库、高效率的编程语言、还有高性能的Web容器。
&#160; &#160;但是除了这几个方面，还没法根本解决面临的高负载和高并发问题，所以需要将计算和负载的压力分载到每个计算机上，使用不同的服务器集群机组进行分布式和并行计算，面对所产生的压力，下面这张图清晰的描述了，我们对系统中不同的计算瓶颈采用的不同解决手段，如图所示：


		查看大图请点击这里

&#160;
以下描述是针对不同层面产生的计算压力所采用的计算策略，清单如下：
传输层
1. CDN
&#160; &#160; 网络链路出口进行压力分载，通过CDN让用户访问最近的数据缓存。
2. 智能双路
&#160; &#160; 针对电信、网通 不同的访问用户访问请求，对应用户访问请求进行服务器带宽的智能切换。
3. LVS
&#160; &#160; 对用户的请求进行压力分载，并且实现多种负载均衡的策略，也可以选择使用HA-Proxy实现。
4. HA-Proxy
&#160; &#160;针对Web服务器进行方向代理，通过HA-Proxy将用户的请求分发到不同的Web服务器上。
5. Long-Polling
&#160; &#160; 在Web服务器上采用的一种策略，专门针对某个用户需要不断频繁的轮询访问。
6. Session2Cache
&#160; &#160; 将用户的会话进行集中处理，存放在中央式的缓存服务器当中，减少服务器之间的会话通信
&#160;
计算层
1. MapReduce
&#160; &#160;采用最经典的分布式算法对海量数据进行处理，将计算进行分载。
2. BSP
&#160; &#160; BSP(Bulk Synchronous Parallel-大型同步模型)算法是基于MPI算法的基础进行演化，运用在系统中并行计算的部分。
3. Result Cache
&#160; &#160; 将计算的一部分结果进行缓存，缓解对存储层读取的请求。
4. Scatter/Gather
&#160; &#160; 中间通过一个服务器进行中转，将大量的请求分发给内部的服务器进行计算，类似前端的web反向代理。
&#160;
存储层
1. 读写分离
&#160; &#160; 由于系统的读大于写的频率，数据库架构采用了1主/多从，双主多从的策略，所以我们将会将读和写进行分离，并且将大量的读请求分散给多台不同的(Slave)服务器。
2. 分区策略
&#160; &#160; 系统采用不同的时间段作为分区的主要策略，提高对数据的读写性能。
3. Sharding
&#160; &#160; 一台数据库将很快无法满足大量并发，需要使用库表散列，将数据库中的数据进行分散存储。
4. Column-Based
&#160; &#160;使用在海量数据中的查询功能，采用列模式的存储方式将可以有效的提高系统查询效率。

&#160;
&#160;
&#8211;end&#8211;
&#160;
&#160;
&#160;

]]></description>
		<link>http://www.javabloger.com/article/high-concurrent-common-coping-strategies.html?source=rss</link>
			</item>
	<item>
		<title>Keep Looking Don&#8217;t Settle</title>
		<description><![CDATA[keep looking don't settle]]></description>
		<link>http://www.javabloger.com/article/keep-looking-dont-settle.html?source=rss</link>
			</item>
	<item>
		<title>视频网站的推荐搜索引擎介绍</title>
		<description><![CDATA[   在一个推荐系统中可以分析用户的行为，在后台对用户行为数据建模，经过分析去预测用户的喜好、向用户推荐。这里讲的动态，是因为用户的行为是跟时间有关系的，系统中包含了大量和时间有关的数据集合。现实社会是处于变化之中的，用户的喜好也在不断的变化着。系统中每天都会有大量的新用户，新的商品加入，按照时间段划分，一个用户在不同的时间段、不同的季节喜好的商品也会有所不同，一个好的智能推荐系统要满足以下两点：1.向用户推荐他们喜欢的内容；2.能够为内容服务提供商提升节目访问量。

     一个完整的推荐系统应该包括几大方面：用户界面、日志系统、推荐引擎。用户界面有两个作用，一方面给用户展示推荐结果，另一方面收集用户对推荐结果的反馈。收集到的用户反馈将通过日志系统写入用户行为数据库中，最后推荐引擎通过分析用户行为数据库中的用户行为，给用户生成推荐结果并展示在用户界面上。从这个循环可以看到，推荐系统是一个不断收集用户行为，不断更新用户兴趣模型，从而不断改善用户推荐结果的闭环反馈系统。]]></description>
		<link>http://www.javabloger.com/article/hadoop-dynamic-intelligent-recommendation-system.html?source=rss</link>
			</item>
	<item>
		<title>MySQL空间数据库&#8211;查询点到多点间的最短路径</title>
		<description><![CDATA[当SNS产品加入LBS的技术将会让移动互联网领域更加丰富多彩，例如：大众点评，街旁，盛大切客 这些运行在智能手机端的应用，当用户拿出手机就可以根据你当前的所在地向你推荐一些有用的信息，例如：附近的美食，商铺，周边生活信息，等。
	攻城师们，你有没有想过这些应用背后的技术实现呢？手机端获得当前的坐标后是怎么进行计算和查询返回附件的结果呢？
	用Java程序可以实现Dijkstra算法获得点与多点之间最短路径的计算结果，但是我个人认为是一种暴力的方法，开发的简化程度和计算的执行效率不会非常高。
	参考资料：http://baike.baidu.com/view/7839.htm
	接着再往下想，用到数据库技术是必然，但不会把节点的坐标信息存储到数据库普通的字段中进行查询，如果和Dijkstra算法相比不会简化工作量也不会提高性能，但使用到MySQL中空间数据库的概念就会简化很多也会得到性能的提升，开源的MySQL Spatial空间索引机制就可以对点到多点之间的距离计算，类似的Spatial Database还有，PostGIS，SpatiaLite。
	我的废话：
	在android手机上获得当前坐标后，将数据整好录入android中的SQLite数据库也可以获得当前点对多点的最短路径，也就是说在地理数据不会更新的场景下完全可以采用android手机上的数据库完成这项工作，没有必要非要利用服务器端的Spatial Database完成最短路径的计算。
	MySQL空间数据几种主要类型:
	&#160;&#160;&#160;&#160; &#8211; GEOMETRY&#160; Geometry是层次结构的根类。它是一种非实例化类，但具有很多属性，这些属性对由任何Geometry子类创建的所有几何值来说是共同的。
	&#160;&#160;&#160;&#160; &#8211; POINT&#160;&#160; 代表坐标空间中单个位置的几何类，他的属性包含 X-坐标值，Y-坐标值。
	&#160;&#160;&#160;&#160; &#8211; LINESTRING&#160; 具有线段的坐标，由每个连续的点对(两点)定义。如果仅包含两点，LineString为Line。 如果它既是简单的也是封闭的，LineString为LinearRing。
	&#160;&#160;&#160;&#160; &#8211; POLYGON&#160; 它由单个外部边界以及0或多个内部边界定义，其中，每个内部边界定义为Polygon中的1个孔。例如:在地区地图上，Polygon对象可表示森林。
	&#160;&#160;&#160;&#160; &#8211; MULTIPOINT&#160; MultiPoint是一种由Point元素构成的几何对象集合。这些点未以任何方式连接或排序。
	&#160;&#160;&#160;&#160; &#8211; MULTILINESTRING&#160; MultiLineString是一种由 LineString元素构成的MultiCurve几何对象集合，例如：河流体系或高速路系统。
	&#160;&#160;&#160;&#160; &#8211; MULTIPOLYGON&#160; MultiPolygon是一种由Polygon元素构成的几何对象集合。在地区地图上，MultiPolygon可表示湖泊系统。
	&#160;&#160;&#160;&#160; &#8211; GEOMETRYCOLLECTION&#160;&#160; 他是由1个或多个任意类几何对象构成的几何对象。GeometryCollection中的所有元素必须具有相同的空间参考系(即相同的坐标系).
	以上几种的类型依赖关系，如图所示：
	
	了解过上述一些基本知识，下面来创建一张商户表，并且包含定义的空间数据库的POINT字段：
	&#160; Create table shop (
	&#160;&#160;&#160;&#160; shop_id int(3) primary key,
	&#160;&#160;&#160;&#160; Location POINT,
	&#160;&#160;&#160;&#160; Shop_na vachar(100),
	&#160;&#160;&#160;&#160; Shop_info vachar(300)
	&#160;&#160;&#160;&#160; );
	插入几条商家的门店信息，其中采用GeomFromText方法将坐标的数据库插入POINT字段中，例如：
	insert into shop values (&#8216;XXX&#8217;,&#8217;,GeomFromText(&#8216;POINT(1 1)&#8217;),&#8217;XX店&#8217;,&#8217; &#39;其他信息&#39;);
	下面将根据客户当前所在位置在MySQL中查询，搜索出在当前位置附近的一定范围内的门店，并且可以做到按距离由近到远排列显示出来，从让用户而找到离他最近的门店。
	把客户当前所在位置可设成变量 ，例如:set @center=GeomFromText(&#8216;POINT(10 [...]]]></description>
		<link>http://www.javabloger.com/article/mysql-spatial-database.html?source=rss</link>
			</item>
	<item>
		<title>使用Java开发需要关注的那些事儿</title>
		<description><![CDATA[近期各家IT媒体举办的业内技术大会让很多网站都在披露自己的技术内幕与同行们分享，大到facebook，百度，小到刚起步的网站。facebook，百度之类的大型网站采用的技术和超凡的处理能力的确给人耳目一新的感觉，但并不是每个网站都是像facebook，百度 有上亿的用户访问流量，有海量的数据需要存储，需要使用到mapreduce/并行计算，HBase/列存储这些技术不可。技术手段始终是运营的支撑，对于当前的运营环境适用就好，没有必要非要赶个时髦，一定要和某项流行的技术产生点关系才善罢甘休。
	在最近的技术大会中我们更多的目光都聚焦在这些大型网站，其实中小型门户网站的技术体系也是值得去探讨和关注。全天下的攻城师们并不是都在为这些大型门户网站服务，更多的攻城师们正在默默无闻的为一些刚刚起步的中小型网站服务，而且占据了攻城师队伍中的60%以上的人群。在关注大型门户网站的时候，中小型门户网站的技术发展和实战经验更值得去分享。
	无论大型门户网站还是中小型垂直类型网站都会对稳定性、性能和可伸缩性有所追求。大型网站的技术经验分享值得我们去学习和借用，但落实到更具体的实践上并不是对所有网站可以适用,其他语言开发的网站我还不敢多说，但Java开发的系统，我还是能您给插上几句话：
	JVM
	JEE容器中运行的JVM参数配置参数的正确使用直接关系到整个系统的性能和处理能力，JVM的调优主要是对内存管理方面的调优，优化的方向分为以下4点：
	1.HeapSize&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; 堆的大小，也可以说Java虚拟机使用内存的策略，这点是非常关键的。
	2.GarbageCollector&#160; 通过配置相关的参数进行Java中的垃圾收集器的4个算法(策略)进行使用。
	3.StackSize&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; 栈是JVM的内存指令区,每个线程都有他自己的Stack，Stack的大小限制着线程的数量。
	4.DeBug/Log&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; 在JVM中还可以设置对JVM运行时的日志和JVM挂掉后的日志输出，这点非常的关键，根据各类JVM的日志输出才能配置合适的参数。
	网上随处可见JVM的配置技巧，但是我还是推荐阅读Sun官方的2篇文章，可以对配置参数的其所依然有一个了解
	1.Java HotSpot VM Options http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html
	2.Troubleshooting Guide for Java SE 6 with HotSpot VM http://www.oracle.com/technetwork/java/javase/index-137495.html
	另外，我相信不是每个人攻城师都是天天对着这些JVM参数的，如果你忘记了那些关键的参数你可以输入Java -X(大写X)进行提示。
	JDBC
	针对MySQL的JDBC的参数在之前的文章中也有介绍过，在单台机器或者集群的环境下合理的使用JDBC中的配置参数对操作数据库也有很大的影响。
	一些所谓高性能的 Java ORM开源框架也就是打开了很多JDBC中的默认参数：
	&#160;1.例如：autoReconnect、prepStmtCacheSize、cachePrepStmts、useNewIO、blobSendChunkSize 等，
	&#160;2.例如集群环境下：roundRobinLoadBalance、failOverReadOnly、autoReconnectForPools、secondsBeforeRetryMaster。
	具体内容可以参阅MySQL的JDBC官方使用手册：
	http://dev.mysql.com/doc/refman/5.1/zh/connectors.html#cj-jdbc-reference
	数据库连接池(DataSource)
	应用程序与数据库连接频繁的交互会给系统带来瓶颈和大量的开销会影响到系统的性能，JDBC连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而再不是重新建立一个连接，因此应用程序不需要频繁的与数据库开关连接，并且可以释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。
	在此我认为有一点需要说明：
	连接池的使用也是需要关闭，因为在数据库连接池启动的时候就预先和数据库获得了相应的连接，之后不再需要应用程序直接的和数据库打交道，因为应用程序使用数据库连接池是一个&#8220;借&#8221;的概念，应用程序从数据库连接池中获得资源是&#8220;借出&#8221;，还需要还回去，就好比有20个水桶放在这里，需要拿水的人都可以使用这些木桶从水池里面拿水，如果20个人都拿完水，不将水桶还回原地，那么后面来的人再需要拿水，只能在旁边等待有人将木桶还回去，之前的人用完后需要放回去，不然后面的人就会一直等待，造成资源堵塞，同理，应用程序获取数据库连接的时候Connection连接对象的时候是从&#8220;池&#8221;中分配一个数据库连接出去，在使用完毕后，归还这个数据库连接，这样才能保持数据库的连接&#8220;有借有还&#8221;准则。 
	参考资料：
	http://dev.mysql.com/doc/refman/5.1/zh/connectors.html#cj-connection-pooling
	数据存取
	数据库服务器的优化和数据的存取，什么类型的数据放在什么地方更好是值得去思考的问题，将来的存储很可能是混用的，Cache，NOSQL，DFS，DataBase 在一个系统中都会有，生活的餐具和平日里穿衣服需要摆放在家里，但是不会用同一种类型的家具存放，貌似没有那个人家把餐具和衣服放在同一个柜子里面的。这就像是系统中不同类型的数据一样，对不同类型的数据需要使用合适的存储环境。文件和图片的存储，首先按照访问的热度分类，或者按照文件的大小。强关系类型并且需要事务支持的采用传统的数据库，弱关系型不需要事务支持的可以考虑NOSQL，海量文件存储可以考虑一下支持网络存储的DFS，至于缓存要看你单个数据存储的大小和读写的比例。
	还有一点值得注意就是数据读写分离，无论在DataBase还是NOSQL的环境中大部分都是读大于写，因此在设计时还需考虑 不仅仅需要让数据的读分散在多台机器上，还需要考虑多台机器之间的数据一致性，MySQL的一主多从，在加上MySQL-Proxy或者借用JDBC中的一些参数(roundRobinLoadBalance、failOverReadOnly、autoReconnectForPools、secondsBeforeRetryMaster)对后续应用程序开发，可以将读和写分离，将大量读的压力分散在多台机器上，并且还保证了数据的一致性。
	缓存
	在宏观上看缓存一般分为2种：本地缓存和分布式缓存
	1.本地缓存，对于Java的本地缓存而言就是讲数据放入静态(static)的数据结合中，然后需要用的时候就从静态数据结合中拿出来,对于高并发的环境建议使用 ConcurrentHashMap或者CopyOnWriteArrayList作为本地缓存。缓存的使用更具体点说就是对系统内存的使用，使用多少内存的资源需要有一个适当比例，如果超过适当的使用存储访问，将会适得其反，导致整个系统的运行效率低下。
	2. 分布式缓存，一般用于分布式的环境，将每台机器上的缓存进行集中化的存储，并且不仅仅用于缓存的使用范畴，还可以作为分布式系统数据同步/传输的一种手段，一般被使用最多的就是Memcached和Redis。
	数据存储在不同的介质上读/写得到的效率是不同的，在系统中如何善用缓存，让你的数据更靠近cpu，下面有一张图你需要永远牢记在心里，来自Google的技术大牛Jeff Dean(Ref)的杰作，如图所示：
	
	并发/多线程
	在高并发环境下建议开发者使用JDK中自带的并发包(java.util.concurrent)，在JDK1.5以后使用java.util.concurrent下的工具类可以简化多线程开发，在java.util.concurrent的工具中主要分为以下几个主要部分：
	1.线程池，线程池的接口(Executor、ExecutorService)与实现类(ThreadPoolExecutor、 ScheduledThreadPoolExecutor），利用jdk自带的线程池框架可以管理任务的排队和安排，并允许受控制的关闭。因为运行一个线程需要消耗系统CPU资源，而创建、结束一个线程也对系统CPU资源有开销，使用线程池不仅仅可以有效的管理多线程的使用，还是可以提高线程的运行效率。
	2.本地队列，提供了高效的、可伸缩的、线程安全的非阻塞 FIFO 队列。java.util.concurrent 中的五个实现都支持扩展的 BlockingQueue 接口，该接口定义了 put 和 take 的阻塞版本：LinkedBlockingQueue、ArrayBlockingQueue、SynchronousQueue、PriorityBlockingQueue 和 DelayQueue。这些不同的类覆盖了生产者-使用者、消息传递、并行任务执行和相关并发设计的大多数常见使用的上下文。
	3.同步器，四个类可协助实现常见的专用同步语句。Semaphore 是一个经典的并发工具。CountDownLatch 是一个极其简单但又极其常用的实用工具，用于在保持给定数目的信号、事件或条件前阻塞执行。CyclicBarrier 是一个可重置的多路同步点，在某些并行编程风格中很有用。Exchanger 允许两个线程在 collection 点交换对象，它在多流水线设计中是有用的。
	4.并发包 Collection，此包还提供了设计用于多线程上下文中的 Collection 实现：ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、CopyOnWriteArrayList 和 CopyOnWriteArraySet。当期望许多线程访问一个给定 collection 时，ConcurrentHashMap 通常优于同步的 [...]]]></description>
		<link>http://www.javabloger.com/article/java-development-concern-those-things.html?source=rss</link>
			</item>
	<item>
		<title>巧用zookeeper实现分布式并行计算</title>
		<description><![CDATA[云计算的技术话题中少不了&#8220;分布式&#8221;，&#8220;并行计算&#8221; 这些个关键词，我们知道硬件扩展的条件(​Scale-up)始终是有限制的，将计算分散到网络中更多机器的CPU上提供更高的计算性能(Scale-out)，并在这基础上能将计算同时进行，那么总体计算瓶颈会减小，计算的性能会显著提高，也就是说将串行计算变为并行计算，将大量的计算在同一时间发生，，将任务分配到每一个处理器上。这里面需要一个重要的角色，分布式计算资源中的协调者。
	有这样一个场景：系统中有大约100w的用户，每个用户平均有3个邮箱账号，每隔5分钟，每个邮箱账需要收取100封邮件，最多3亿份邮件需要下载到服务器中(不含附件和正文)。用20台机器划分计算的压力，从多个不同的网路出口进行访问外网，计算的压力得到缓解，那么每台机器的计算压力也不会很大了。
	通过我们的讨论和以往的经验判断在这场景中可以实现并行计算，但我们还期望能对并行计算的节点进行动态的添加/删除，做到在线更新并行计算的数目并且不会影响计算单元中的其他计算节点，但是有4个问题需要解决，否则会出现一些严重的问题：
	1.20台机器同时工作时，有一台机器down掉了，其他机器怎么进行接管计算任务，否则有些用户的业务不会被处理，造成用户服务终断。
	2.随着用户数量增加，添加机器是可以解决计算的瓶颈，但需要重启所有计算节点，如果需要，那么将会造成整个系统的不可用。
	3.用户数量增加或者减少，计算节点中的机器会出现有的机器资源使用率繁忙，有的却空闲，因为计算节点不知道彼此的运行负载状态。
	4.怎么去通知每个节点彼此的负载状态，怎么保证通知每个计算节点方式的可靠性和实时性。
	先不说那么多专业名词，白话来说我们需要的是：1记录状态，2事件通知 ，3可靠稳定的中央调度器，4易上手、管理简单。
	采用Zookeeper完全可以解决我们的问题，分布式计算中的协调员，观察者，分布式锁&#160; 都可以作为zookeeper的关键词，在系统中利用Zookeeper来处理事件通知,队列,优先队列,锁,共享锁等功能，利用这些特色在分布式计算中发挥重要的作用。
	zookeeper的服务器端是采用Java编写，而zookeeper的客户端不仅可以支持java还可以支持C语言的客户端，在zookeeper服务端可以创建一个树状的Key/Vaule 存在着父子节点之间的关系。
	Zookeeper允许多个Client对一个或多个ZNode数据进行监控，当ZNode有变化时能够通知到监控这个ZNode的各个Client，所有监听这个节点的成员都会知道了，Zookeeper使用Watcher察觉事件信息,当客户端接收到事件信息,比如连接超时,节点数据改变,子节点改变,可以调用相应的行为来处理业务逻辑。相反，如果zookeeper客户端对服务端的znode不关注，不Watcher，那么发生任何变化zookeeper的客户端都不会收到事件通知。
	zookeeper中znode的数据模型
	
	每次zookeeper客户端与服务器端连接后都会创建一个session ID 给客户端，客户端将会定期心跳协议到服务器端验证这个连接的有效性。如果由于某种原因，客户端无法发送心跳到服务器，将导致服务器验证过期的会话，会话ID将变为无效。客户持有的连接/对象将不可用，因此应用程序必须创建一个新的客户对象。如果zookeeper客户端连接到服务器没有任何响应，首先客户端会作抛出的异常并且被捕获，清除当前与Server相关的网络资源和连接会话，然后客户端逐个尝试配置列表中Server的连接地址，选择可用的服务器继续进行工作。
	上述Zookeeper客户端和服务器端的关系又是一个典型的&#8220;观察者&#8221;模式，客户端关注自己关心的对象(znode)，一旦发送变化就立刻通知。在《Head First设计模式》中有这样的一张图来表达 观察者模式的。
	
	如图所示，此系统中的三个部分是气象站(获取实际气象数据的物理装置)、WeatherData对象(追踪来自气象站的数据，并更新布告板)和布告板,再来看看百度百科对&#8220;观察者&#8221;模式的解释：http://baike.baidu.com/view/1854779.htm
	通过对Zookeeper的了解，实现我们系统中需要的Failure detection和Load detection 功能，只需要在每个计算的节点中实现zookeeper客户端程序，计算节点关注zookeeper服务器上znode节点变化。可以在zookeeper服务器的znode上创建一个根节点/clusterA,下面根据计算节点机器名创建对应的子节点，子节点中的value就是这台计算节点的ip地址。
	如：/clusterA/node1,/clusterA/node2,/clusterA/nodeN,这些节点都是临时节点(EPHEMERAL)，一旦连接断开，创建的节点自动会被删除，关注/clusterA这个根节点/clusterA的机器都会知道现在哪台机器离开计算单元了，并且获知现在有多少个计算节点在这个计算单元中。
	如果有新的计算节点添加，在程序运行的第一步将会到zookeeper服务器上的/clusterA 的znode上创建一个子节点/clusterA/nodeZ，这样关注 /clusterA这个znode的机器都会知道现在多了一个计算节点。
	通过zookeeper客户端API中的getChildren()方法对应的数据类型是java.util.List,其返回/clusterA下面的机器列表，这样还能判断出自己在这个列表中排行位置，通过列表中排行位置可以对应用户列表中的数目，这样就知道自己去获得需要计算总数中的几分之分。
	例如：有100w用户，20个节点时，每个节点处理5w用户进行同时计算，node3计算节点承载用户总数中10w-15w用户之间的计算压力，有200w用户，20个节点时，每个节点处理10w个用户的业务进行同时计算，node3计算节点承载用户总数中30w-40w用户的计算压力，以此类推。
	这样一来无论计算节点的数目发生变化还是，需要计算的数目发生变化，都可以保证计算压力的平均分载。 
	我的废话：
	1.根据节点数对应用户数算出百分比之后进行计算分载，貌似我们通常的分页查询，只不过将每页的分页结果同时显示在N多个显示器上输出，希望这样比喻能让您更好的理解。
	2.在计算的中间有新的用户数量增加，将会通知每个计算节点 下次轮询时需要重新统计用户数量，因为用户所有用户的数据分块拿走以后放入本地的静态hashmap(缓存)，没有发生变化就从本地加载，操作数据库发生变化后，通知zookeeper的znode节点 每个计算节点重新从数据库中加载一次。
	3.在并行计算中时间同步也是一个需要注意的地方，如果每台机器上的时间不一致会导致潜在的隐患，可以找些工具通过时间服务器同步每台机器上的当前时间和时区。
	4.使用zookeeper对计算节点的状态管理只是zookeeper实现的一部分，zookeeper还可以对外提供分组，配置管理，命名空间等服务等，这里只是做了一个抛砖引玉的作用。

	对于zookeeper的可靠性和性能而言，有足够的机器那么稳定性就会越高，但是性能会降低，因为ZooKeeper在运行时全部的数据都会加载到内存中，集群中每一台服务器都包含全量的数据，每个节点实时保持数据的同步。因此整个集群中Follower数量越多，整个集群写入的性能越差。后来zookeeper Server为了避免这个问题，可以将ZooKeeper集群中部分服务器指定为Observer。
	相关文章：
	Apache ZooKeeper入门3  
	Apache ZooKeeper入门2  
	Apache Zookeeper入门1  

	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/zookeeper-parallel-computing.html?source=rss</link>
			</item>
	<item>
		<title>JDBC操作MySQL产生的read-only连接异常</title>
		<description><![CDATA[对于Java(JEE)的攻城师来说，使用JDBC操作MySQL数据库是再平常不过的事儿了，但是你知道吗？在MySQL的JDBC驱动里还要很多配置参数，例如：autoReconnectForPools/failOverReadOnly/queriesBeforeRetryMaster/secondsBeforeRetryMaster 这些参数对双机或者集群环境是很有用的，昨天在就发生了一些MySQL运维的事儿，而这几个参数也引起了我们的关注。
	我的废话：MySQL的JDBC参数加起来有百来个，分为6大类，更多详情请查阅，《MySQL-JDBC连接器使用手册》。
	我们有一个生产环境的数据库是MySQL双主，12台JEE应用服务器对MySQL先读再写的轮训操作。昨天运维的人员需要对数据库机器添加内存，添加内存的事儿显然是需要对数据库服务器进行开关机，一拨人负责一台，两台服务器很快内存升级完毕，MySQL服务器也正常工作了。
	但回头发现无法执行业务操作，12台应用服务器抛出全部Cause: java.sql.SQLException: Connection is read-only 异常。之前我们没有动应用服务器啊，只是重启数据库服务器按理说应该等数据库服务器重启完毕以后应用服务器会自动重连正常工作了。
	由于时间紧迫需要立即恢复，没有办法，我们对12台应用服务器重启了一下，天下太平，世界又恢复平静了。当时没时间去研究个究竟到底是什么原因导致，但我知道如果再次遇到这样的类似场景还是出现同样的问题，所以需要找出问题的根本原因，给自己一个解释。
	在MySQL的官方网站上找了一些可能性的依据，原因是设置了autoReconnectForPools=true参数，导致failOverReadOnly参数默认生效。原来failOverReadOnly的默认值是true，导致失效重新连接后出现&#160; Cause: java.sql.SQLException: Connection is read-only. Queries leading to data modification are not allowed 的错误。
	
	看了官方文档中的上面这段话为何是ReadOnly的状态也很能理解是为什么了，其实MySQL官方倡导的是Master-To-Slave的数据库备份方案,而我们的运行环境是Master-To-Master，如果前一个Master挂掉的话 往Slave中去写，等到Master恢复再对Master操作的时候数据就沉于大海，那么数据就不一致了，恢复起来会非常的麻烦，当前一个挂掉的时候，MySQL驱动会认为你的Master挂了，如果继续写将会写入Slave，所以默认的状态是ReadOnly=true，失败后重连，但重连后对下一台操作的是只读(ReadOnly)。
	后来我们在测试环境中也重现了这个错误，然后加上failOverReadOnly=false，并且加上了queriesBeforeRetryMaster 和secondsBeforeRetryMaster 配置参数缩短切换和重试之间的时间长度。这两个参数是表示如果出现故障切换(使用多主机故障切换)并返回主机之前发出的查询数。无论首先满足了哪个条件，&#8220;queriesBeforeRetryMaster&#8221;或&#8220;secondsBeforeRetryMaster&#8221;，均会再次与主机进行连接，secondsBeforeRetryMaster是表示 出现故障切换后，在尝试再次连接到主服务器。
	在测试环境中无论怎么重试、重启或者重连，世界很平静，哥很淡定，才能现在有空写这个blog，将整个过程记录下来。等下次需要停机或者重启的时候将这个参数加上，现已经记录在下个版本的发布计划中了。另外，我整理了一份JDBC操作MySQL的文档，方面日后查阅，下载地址。
相关文章：
	MySQL JDBC中autoReconnectForPools的用途  
	MySQL JDBC 集群  

	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/mysql-read-only-ibatis-dbcp-hibernate.html?source=rss</link>
			</item>
	<item>
		<title>山寨技术下的网站图片服务器(NGINX)</title>
		<description><![CDATA[网站数据存储需要做好前期的规划，不然数据量上来以后无论是管理还是性能上都带来很多问题，对于需要存储大量文件、图片的网站来说是个重点的话题，通常网页文字内容和网页图片内容 所占用的存储空间相比较的话，显然是图片存储占用的空间要远远超过网站文字内容所需要存储的空间，从另外一个角度上来看访问图片所占用的网络带宽要远远超过文字内容所占用的带宽。
	在系统运行上的瓶颈对于互联网用户来说往往不是落在系统内部计算的I/O瓶颈上，而是落在网络带宽的瓶颈上。把存储图片的服务器和访问图片服务器的网络入口独立出来，在条件允许的情况下给予更的高网络带宽和独立的域名，有利于扩展性和整体性能的发挥，将计算、存储的扩展性和带宽的资源做到合理分配，互不影响，是我们当前的目标。
	除此之外，还需要能做到：
	&#160; 1.使用廉价机器(老机器)构建分布式网络存储环境，支持150TB以上的存储容量，
	&#160; 2.数据在线同步，支持文件副本复制，无明显的单点问题，可快速恢复故障节点，
	&#160; 3.通用文件系统，不需要修改上层应用就可以使用(支持fuse)，web服务器可以直接读取分布式存储空间，无中间转取。
	&#160; 4.支持在线不停机的情况下扩展存储的空间，
	&#160; 5.随机读写的高效，并且支持海量小文件(5kb)的高效读写，
	&#160; 6.可监控运行时的存储使用状态，最好是web界面。
	得到了一些个解决方案，但依然不满足，对存储本身还有更高的期望：
	&#160;&#160;&#160; 1.需要避免图片文件重复的写入，建立图片存储的索引，根据唯一的图片文件名的查询后，再判断是否写入，
	&#160;&#160;&#160; 2.小图片，签名照，小头像，表情图片 放在缓存里读取，让数据更靠近cpu，设计的黄金原则，我们尽量把能放入Redis缓存中的数据就在Redis里读取。
	&#160;&#160;&#160; 
	架构介绍
	&#160; 1.负载均衡：HAproxy采用RoundRobin负载均衡算法，分载前端用户请求的压力到每个web图片服务器上，
	&#160; 2.web服务：采用Nginx-0.9.6 做图片的web服务器，对网站的大、中、小图片进行读取，加上Nginx的Redis模块对缓存中的微型(头像)图片进行读取，
	&#160; 3. 缓存服务器：存储网站的 微型图片，签名照，小头像，表情图片，通过Nginx的Redis模块直接读取，通过调用Redis的java API程序对数据进行写入，
	&#160; 4.存储单元：采用Moosefs 存储&#160; 大、中、小图片，并且提供监控管理界面，查看存储空间运行状态，
	&#160; 5.图片索引：将图片名和图片url路径作为键值对(Key/Value)，放入HBase 中存储，并且进行数据查询，避免图片重复存储，便于将来管理，
	&#160; 6.应用服务器：对图片写入的操作全部由Java应用服务器完成。
	我们目前图片存储的系统架构，如图所示：
	
	查看大图请点击这里
	关于HBase的话题在这里就不多说了，可以参考我之前写的几篇文件文章，主要想说说Moosefs的体系：
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 1 Master 管理服务器:负责各个数据存储服务器的管理,文件读写调度,文件空间回收以及恢复.多节点拷贝 
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 2 Chunk 元数据日志服务器: 负责备份master服务器的变化日志文件，文件类型为changelog_ml.*.mfs，以便于在master server出问题的时候接替其进行工作
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 3 Metalogger&#160; 数据存储服务器:负责连接管理服务器,听从管理服务器调度,提供存储空间，并为客户提供数据传输. 
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 4 Client&#160; 客户端: 通过fuse内核接口挂接远程管理服务器上所管理的数据存储服务器,看起来共享的文件系统和本地unix文件系统使用一样的效果.
	最有代表性的成功案例
	&#160;&#160;&#160;&#160; 豆瓣网(Douban Inc),155 TB的存储空间，&#160;&#160; 
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; Master server: Gentoo Linux / ReiserFS 3.6
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; 24 chunk [...]]]></description>
		<link>http://www.javabloger.com/article/nginx-moosefs-hbase-haproxy.html?source=rss</link>
			</item>
	<item>
		<title>轻量级消息(MQ)服务器Kestrel 和 Redis</title>
		<description><![CDATA[Kestrel是twitter的开发团队用scala语言写的开源消息中间件，可以将消息持久存储到磁盘上，也可以将消息存储于内存中，但是不论保存磁盘还是内存中都可以设置消息存储的超期时间长短。
	原先Kestrel是由Ruby写的Starling项目，但是后来 twitter的开发人员尝试用scala重新实现，并且可以支持Memcached的部分协议，例如：GET、SET、FLUSH_ALL、STATS。对于Kestrel 服务器端而言如果有N个接收端连接在Kestrel服务器上，那么每个接收端会平均或者随机的收到不同的消息，并且发送端发过了消息接收端就算不接收，等到接收端再上去接收的时候还能收到消息，因为Kestrel支持消息持久化。
	Kestrel 不存在主从 和 集群的概念，只存在分布式的说法，这有点类似memcached 通过客户端组成一个环状，对于Kestrel 服务器端而言，如果服务器端收到消息了，但是里面有消息没有收下来就挂了，再重启的时候接收端还能收到之前的消息。
	Redis是一个key/value存储系统,大多数开发者把他当做类似Memcached的缓存系统使用，
	Redis和MemCached区别的是：
	&#160;&#160;&#160; 1.会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件
	&#160;&#160;&#160; 2.对于我来说更重要的是Redis还实现了master-slave(主从)数据同步的功能。
	&#160;&#160;&#160; 3.Redis不仅支持传统的存储的value类型，还可以支持list(链表)、set(集合)和zset(有序集合)，
	&#160;&#160;&#160; 4.Redis还支持多种方式的排序，并且可以按照数据存储的范围来访问，有点像查询(select)，
	&#160;&#160;&#160; 5.支持消息发布和订阅功能。
	Redis也有我们对他不满意之处，例如：
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 1.对于同一个队列或者通道来说，有N个接收端连接在Redis服务器上，每个接收端会收到相同的消息。
	&#160;&#160; &#160; &#160;&#160; 2.发过了 你不接收 等接收端再上去消息就没有了，默认的配置是写在内存中，重启后不保存。
	这2点上跟 Kestrel 是相反的，但通过一些奇巧淫技将Redis消息视为缓存进行持久化，保证redis服务器重启后数据还在，并且通过Redis客户端动态设置机器的主从备份，只要有两台或以上的Redis做集群可以对数据永远有保证，除非服务器集群环境全挂，这样的话Redis还算是对数据提供了可靠性。
	但动态指定主从关系的话此时又会面临一致性的话题，在客户端指定Master的时候，为避免相互竞争或者重复指定，我们通过Jgroups工具作为Redis for Java客户端之间的通讯工具，在通讯过程中采用了Paxos算法，由客户端先选出一个Leader，再由这个选出来的Leader进行动态指定Redis集群中的master机器，这样可以提高一致性，避免竞争和冲突。
	回到一开始说的Kestrel， 经过一番测试比较使用 xmemcached、spymemcached 等客户端对Kestrel进行收发操作，发现效果都比较烂，很遗憾没有找到让人满意的Kestrel for Java的客户端，所以我们一致认为使用Kestrel 这货将来的杯具估计产生在客户端(java)，也许Twitter使用的是ruby，是不是对ruby反而支持的很好？对Java支持的不够给力？Kestrel 接收端 需要不断的循环服务器 才能及时的收到消息， 这样节点数一多的话网络开销会不会很大？
	在测试的过程中，我们使用xmemcached作为客户端，貌似不太靠谱，开10个线程，循环1000次，表示鸭梨很大，出现以下异常信息，producer和consumer都有，而且同时冒出来。
	发送端：
	Exception in thread &#34;main&#34; java.util.concurrent.TimeoutException: Timed out(1000) waiting for operation
	接收端：
	Exception in thread &#34;main&#34; java.util.concurrent.TimeoutException: Timed out waiting for operation
	随后google之，作者提供了解答：http://code.google.com/p/xmemcached/issues/detail?id=108
	作者给出的解释是：&#8220;这主要是因为xmc的操作都是异步的，同步等待有个超时时间，默认的1秒在高并发或者存取大数据的时候通常是不够的。&#8221;晕啊，表示不能接受这样的解释。
	随后目光开始关注Redis，Redis采用长连接，事件监听，不需要轮询，接收端等待消息，只接收字符串类型的消息，对消息的数据没有保证，不接收就没有了服务器端不保存，也不支持Queue的消息模式，就像JMS中的Topic消息那样一个发送端对应N个接收端每个接收端收到同样的消息。
	但我们将publish/subscribe和rpush/rpop 4个协议混合使用就可以完全满足我们的要求，客户端不轮训可以保证及时性和消息持久化的问题，而且还是Queue的模式。思路上通了后，做了压力测试，收发100w个消息开1000个线程，8秒以内搞定收发，表示毫无压力，体积小，部署简单比JMS方便，而且无单点，支持可散列。
	在压力测试的过程中发现使用Redis Java客户端需要注意的两个问题：1.接收端莫名其妙的异常退出，这是由于没有设置连接空闲的超时导致的，就和MySQL的8小时问题一样，在Redis客户端设置一下config.setMaxIdle(num) 就好了。2.发送端由于发送大量请求会崩溃，出现超时错误，例如：JedisConnectionException: java.net.SocketTimeoutException: [...]]]></description>
		<link>http://www.javabloger.com/article/mq-kestrel-redis-for-java.html?source=rss</link>
			</item>
	<item>
		<title>最近的那点事儿-2011-3</title>
		<description><![CDATA[1.通过某种机缘结实了ghoho.com 创业团队几位哥们，该团队目前处于创业的阶段，成员的平均年龄不超过27岁，感情上各个都是敢死队员，吃苦耐劳，日夜拼搏，可以说我被他们的认真和激情的态度打动了，在某个周日下午与团队的几个主要成员会了面，彼此分享了技术上和团队建设上的经验，我认真的听取了他们对互联网产品的见解和认识，让我长了些见识，同时他们也给我留下了很深刻的印象。在这里希望他们的产品能早日上线，在业内打响自己的知名度。
	2.就在三月非常荣幸能受到国内云计算知名人物单独会面的邀请(Ref)，与其畅聊了一把云计算的相关话题，大师语出非凡，从他身上通过4个小时的会面学习到了很多东西，感到自己还有很多不足和欠缺的地方， 有待弥补和加强。
	3.Redis的话题在团队中不断的被展开和讨论，我们打算使用redis中的缓存和mq功能对目前的技术进行一些革新，现在正在做大量的准备工作。带领的其中一个团队新人较多而且多数是实习生，另一个团队多数是实力相当的技术精英，当需要对新项目技术创新时，我并没有选择后者，而选择了前者，我给出的理由有三：1需要充分给予新人机会发挥，2做创新这档事儿新人更有潜质，更敢想。3摸什么牌跟打什么牌无关，看的是成员执行力和领导者的能力。另外，这些日子在微博上看见不仅是我们似乎国内的很多技术团队都开始对Redis表示关注，通过淘宝几位兄弟在新浪微博上的言论，能看出他们在为此花了不少功夫，记得新浪微博是最早在网上披露自己使用redis的经验，在redis的官方网站上也能看见新浪微博的标记，等我们弄出点什么后在这里会和大家分享，请期待，稍安勿躁。
	4.还是Hadoop的云计算话题，最近研究了一把MapReduce和Avro相关的话题，写了几篇日志(ref)，并且打算在新项目中使用hbase对用户的大量离线消息进行储存，avro对于数据传输和存储是不错的工具，具体使用avro做数据传输工具的事情现在正在和几位负责android开发的同学们商讨中，而使用avro工具对后端服务器数据储存的工作已经安排几位同学去实施，有机会和大家分享一些心得和过程。
	5.公司新项目越来越多，产品也需要继续优化，需要大量的人手来做事，在不断的招人，经过这个月的连续招聘，每日面试3ˉ5 人，我越来越认为责任心，表达能力，思维方式是更主要的，我们不可能招聘到100%符合条件的人才，需要他有所超般，那只会加大招聘的成本，同时抹杀别人机会，我们不是google也不是微软，相反我们需要有一套好的体制流程和氛围加速新员工融入我们的团队中。在这里继续做个小广告，如果你身边有朋友在南京搞jee、android开发的可以与我联系。
	6.吃喝玩乐的三月啊，海底捞，多佐，金钱豹，代官山，等等总之腐败的一塌糊涂，4月还会继续腐败将随着我肚子上的肥肉继续猛烈吧。
	7.筹备5月份的技术交流活动，打算和本地的几个业内同行，展开一次线下的技术沙龙活动，届时会邀请在本地各路英雄来畅谈后端和云计算相关的话题。
&#160;
&#8211;end&#8211;
&#160;

	&#160;
]]></description>
		<link>http://www.javabloger.com/article/recently-that-simple-thing.html?source=rss</link>
			</item>
	<item>
		<title>Avro入门1&#8211;序列化与远程通信</title>
		<description><![CDATA[Avro是Hadoop中的一个子项目，也是Apache中一个独立的项目，Avro是一个基于二进制数据传输高性能的中间件。在Hadoop的其他项目中例如HBase(Ref)和Hive(Ref)的Client端与服务端的数据传输也采用了这个工具，Avro可以做到将数据进行序列化，适用于远程或本地大批量数据交互。
	在传输的过程中Avro对数据二进制序列化后 节约数据存储空间 和 网络传输带宽。做个比方：有一个100平方的房子，本来能放100件东西，现在期望借助某种手段能让原有面积的房子能存放比原来多150件以上或者更多的东西，就好比数据存放在缓存中，缓存是精贵的，需要充分的利用缓存有限的空间，存放更多的数据。再例如网络带宽的资源是有限的，希望原有的带宽范围能传输比原来高大的数据量流量，特别是针对结构化的数据传输和存储，这就是Avro存在的意义和价值。
	Avro还可以做到在同一系统中支持多种不同语言，也有点类似Apache的另一个产品：Thrift(Ref)，对于Thrift不同的是Avro更加具有灵活性，Avro可以支持对定义的数据结构(Schema)动态加载，利于系统扩展。
	使用Avro可以通过2中方式来实现：
	1.二进制编码，Avro-specific方式依赖代码(文件)生成特定类，并内嵌JSON Schema；
	2.JSON编码，Avro-generic方式通过JSON文件动态加载Schema，不需要编译加载直接就可以处理新的数据源。
	我肤浅的认为，两者的区别在于同样的数据大小，在二进制编码下所产生的Avro数据的大小为100个字节，而在JSON编码下产生了450个字节。虽然看起来第1种二进制编码的方式占据一定优势，但是二进制传输最大的问题就是出了 bug 不方便追查，而JSON编码的方式更实用于系统与系统之间的数据通讯。
	我的废话:
	&#160;&#160; 1.从XML到JSON，再从JSON到Avro/Google PBs，技术不断的在发展，中间经历的时间跨度也越来越短。
	&#160;&#160; 2.我个人认为Avro是比使用压缩(Gzip/z7)对结构化数据处理(JSON/XML)更好的手段。
	&#160;&#160; 3.还可以借用Avro对以下产品进行序列化存储或者传输通信：
	&#160;&#160;&#160; a)HBase、Hive、MySQL
	&#160;&#160;&#160; b)Redis、MemCached
	&#160;&#160;&#160; c)本地文件存储 、Solr远程调用 
	&#160;&#160;&#160; d)MapReduce分布式计算
	参考资料：https://github.com/spullara/havrobase
	4.别拿Avro的Socket当炮使，那玩意儿经不起折腾，在这个api的 ref里面已经明确的说明了。
	参考资料：http://avro.apache.org/docs/1.5.0/api/java/org/apache/avro/ipc/SocketServer.html
	5.如果specific方式需要用avro-tools.jar包进行编译，而generic方式直接调用JSON文件。
	Avro支持本地和远程RPC(Ref)调用,RPC远程调用又分为Http和Netty2种，在这里主要介绍基于Http协议的Avro远程调用，首先需要定义一个JSON文件作为双方通信的传输协议规范，便于解析从对方发送过来的数据。
	在这个协议中可以看做分为3大部分：
	&#160;&#160;&#160; 1.描述(Protocol Declaration)，定义命名空间，协议名称 等。
	&#160;&#160;&#160; 2.数据类型(types)，根据规范中的Primitive和Complex Types数据类型，自己封装一套数据格式。
	&#160;&#160;&#160; 3.消息(messages)，根据自己定义的数据类型，再去定义 a)请求、b)回应、c)异常(可选)&#160; 数据格式。
	以上内容可以详见下面代码示例中的user.avpr文件。
	消息从客户端发送到服务器端需要经过传输层(Transport Layer)，它发送消息并接收服务器端的响应。到达传输层的数据就是二进制数据。通常以HTTP作为传输模型，客户端数据以POST方式发送到服务器端。消息被封装成为一组缓冲区(Buffer)，Avro规定一个标准的序列化的格式，即无论是文件存储还是网络传输，数据的Schema都出现在数据的前面。数据本身并不包含任何Metadata(Tag). 在文件储存的时候，schema出现在文件头中。在网络传输的时候Schema出现在初始的握手阶段，客户端和服务器端需要维护一个可见的协议缓存，因此，简单来说一个握手完成后，在进行网络交 换的时候不需要再传输协议的全部文本。
	这是我在程序运行的过程中抓包的截图：
	
图示说明：
	192.168.1.2是服务器端，192.168.1.106是客户端，可以看出第一次传输的时候服务器端返回的数据包大小为891，第二次和第三次返回的数据库包大小为77。而且返回的内容明显能看出是经过序列化的(上图的左下方)，也就是服务器端组装好的回应数据。
	Avro 的消息被分为多个帧，形成一个缓冲列表。分帧是位于消息和传输层中的一层。它可以优化一些操作。分帧消息的格式为：
	&#160;&#160;&#160; * 一系列的缓存，每个缓冲包括：
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; o 一个4字节，大端的缓存长度
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; o 缓冲数据
	&#160;&#160;&#160; * 消息以一个零长度的缓存结束。
	分帧对于请求和响应消息格式来说是透明的。任何消息都可能被分为一个或者多个缓存。
	再来说说，这个代码例子，我大致分了3个包和一个user.avpr文件：
	&#160;&#160;&#160; 1.client，我就直接放在最外面了，ClientHandler用来组装根据协议请求的数据，并且得到返回的结果。
	&#160;&#160;&#160; 2.server，利用自带的Jetty作服务器，AvroFactory判断不同的请求的message类型，我定义了search、update 2种，也就是说在同一份user.avpr协议中经过处理和判断可以传输不同的协议内容。
	&#160;&#160;&#160; AvroHandler组装经过业务逻辑处理后返回结果，我在updateRespond/searchRespond2个方法中造了一些数据，模拟获取数据的结果
	&#160;&#160;&#160; 3.tools，协议解析工具(AvroUtils.java)。
	&#160;&#160;&#160; 4.user.avpr&#160; 传输协议文件。
	将代码导入IDE环境后，运行AvroServer.java启动服务器，再运行ClientHandler.java执行客户端调用。
	代码示例下载：
	http://javabloger-mini-books.googlecode.com/files/avro-http-json.rar
	以上代码示例采用的是Avro的1.4.1版本，如果需要Avro依赖的jar可以从这里下载：
	http://javabloger-mini-books.googlecode.com/files/avro-lib-1.4.rar 
	通过阅读Avro的部分源码，按照其中的设计思路去实现，还可以将Avro集成到Tomcat，GlassFish，Resin 等 其他服务器中去，不见得非要使用Avro自带的Jetty作为服务器，只需要自己实现一个Servlet即可。这样就不受Avro中嵌入式Jetty服务器的限制，可以使用一些技术特性，例如：长连接、长轮询、Servlet监听器和过滤器，并且可以对Web容器进行更深入的性能优化。
	在这里提供一个简单代码示例，大家可以参考一下，下载后直接将war工程部署到tomcat 等web容器中，客户端的代码也在这里war工程中(Client.java)。
	代码示例下载：
	http://javabloger-mini-books.googlecode.com/files/avroweb.war
	暂时先说到这里，有空再聊一聊Avro中的MapReduce以及Avro中的内部结构。

	&#8211;end&#8211;
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/hadoop-avro-rpc-java.html?source=rss</link>
			</item>
	<item>
		<title>mapreduce操作HBase</title>
		<description><![CDATA[我的废话：
	本文提供代码示例，但是不讲述mapreduce对HBase代码层面的细节，主要讲述我片面的理解和体会。
	最近看见Medialets(Ref)在网站架构中提到对MapReduce使用的经验分享，采用HDFS作为MapReduce分布式计算的基础环境，基于Python的MapReduce框架计算具体的内容，将计算的结果写入MongoDB中存储，对外宣称每秒1可以处理百万级的业务事件，可见MapReduce的运用场景在越来越多的丰富起来，说明除了Google和Yahoo这样的超大型互联网公司以外，更多的中小门户都对MapReduce和Hadoop开始产生兴趣，使用Hadoop的Mapreduce分布式计算的场景将和我们越来越近。
	Hadoop Map/Reduce的框架的确简单易懂，基于他开发的应用程序能够运行在上千个机器组成的大型集群上，或者说MapReduce是一种&#8220;蛮力&#8221;计算，在一定程度上机器数量越多，得到的效果越显著，而且MapReduce提供了一种可靠容错的方式可并行处理上T级别的数据集。
	在现实场景中执行一个Map/Reduce作业(job)会把Input的数据分为多个数据块(就像下面图中左边的黄色小块)，MapperTask以分布式并行的方式处理这些输入的数据。mapreduce框架会对map的输出先排序， 再map把计算结果输入给reduce最终对计算结果合并输出。
	
	集群环境中的mapreduce计算节点失效转发、 分布式存储，工作调度，容错处理，网络通信，负载均衡 等问题不用开发者去考虑，MapReduce框架和MapReduce运行环境早就为此做出的考虑，如下图所示 在集群环境中有一个master负责调度构成一个作业的所有任务，大量的任务存在master的Task Queue里面，将这些任务分配在不同的slave上，master监控它们的执行 如果任务执行失败，由master指派slave(work)重新执行任务，如图所示：
	
	通常作业的输入和输出都会被存储在文件系统HDFS中，也就是说，通常MapReduce框架和分布式文件系统是运行在一组相同的节点上的，允许在那些已经存好数据的节点上高效地调度任务，这可以使整个集群的网络带宽被非常高效地利用。MapReduce框架由一个单独的JobTracker(master)和很多个TaskTracker(slave)集群节点一个共同组成。
	在MapReduce客户端的代码需要指明输入/输出的位置(文件路径/DB/NOSQL)，客户端再加上作业的参数，就构成了作业配置(job configuration)，客户端代码需要定义map和reduce方法通过实现合适的抽象类，并在实现的方法中编写你的业务逻辑，在客户端程序中还要定义你的map/reduce输入和输出的类型，当Hadoop的 job client提交作业(jar包/class/可执行程序等)和配置信息给JobTracker，后者负责分发这些软件和配置信息给slave、调度任务并监控它们的执行，同时提供状态和诊断信息给job-client。至于客户端job提交后的工作流程就是hadoop的事情了，分为4个过程，输入&#124; 切分、排序、洗牌，合并 &#124; 输出 ，输出的结果是有序的，因为mapreduce框架是天然排序的。如图所示：
	
	MapReduce把数据集的操作分散到网络节点上，每个节点会周期性的把执行状态报告回，当某个节点连接或者计算超时达到一定次数，主节点记录下这个节点状态为死亡状态，并且分配给这个节点的任务发到别的节点上运行，例如Apache的Hive就是一个MapReduce框架的实现，Hive可以将SQL语句转换为 MapReduce任务把执行的SQL分散到每台机器上运行，最后返回计算结果。

	我写了一个代码示例，这个示例通过mapreduce框架从文件夹中读取数据，进过格式化、对内容的加工，再写入HBase的的程序。当输入后根据输入的条件和状态产生多个Mapper(maptask)处理输入的内容，mapper先是从目录中读取所有文件信息，然后加工进行格式化，这一切都处理完成之后，将计算的结果交给Reducer去执行，Reducer根据客户端定义的输入类型做出对应的操作，将最终的结果存入HBase中。
示例例说明：
	有一个 input&#160; 的输入目录，里面有3个文件 1.txt/2.txt/3.txt,需要在HBase中建立一张 tab1表，f1 是列名称，然后运行代码示例，最后在Hbase查看到3个txt中的数据全部写入hbase中。运行的过程中可以在eclipse的控制台上看见，先读取/格式化数据，最后写入hbase中的效果，如图所示：
	
Reduce的计算结果，如图：
	
代码示例下载地址：http://javabloger-mini-books.googlecode.com/files/txt-to-hbase.rar
通过这个例子可以假定一种场景，例如百度文库，每时每刻都有成千上万的人向百度的服务器上传文件，需要做到在最短的时间内对不同格式的文档进行处理、格式化，最终保存起来。前端服务器拿到用户上传的文档后，就像这个例子中x:\input下的3个文件，对于百度文库的运行场景来说也许是3w个，将大量的文档全部扔给mapreduce，mapreduce把需要解析、排版、格式化的文档交给每个分布的hadoop节点，将计算压力分布在多个CPU上进行计算，因为多人力量大的原因很快将能把3w个文档处理完毕，并且保存数据库/NOSQL，用户可以立刻在线阅读到刚刚上传的文档。
	在离线的场景中通过mapreduce写入HBase还可以采用另外一种方式，先将文档扔给mapreduce，然后通过HFileOutputFormat输出HBase的数据文件，最后通过Hbase 工具将数据文件导入到HBase中，对于海量数据的迁移可以考虑这样的方式，在这种方案的基础上HBase官方提供了importtsv 工具 可以参考HBase的官方文档(Ref)。 
	我的废话：
	最近有一个项目需要对 国内最大的网络设备供应商&#160; 提供方案实施，该项目主要针对android平台上的联系人功能进行扩展，比如2个客户端都安装这个联系人软件可以发送免费短信，类似现在的飞信、kiki，该产品还会向中国以外的市场推广，一旦二期上线用户的数量级将达到上千万，很可能产生大量的离线消息，打算采用HBase对用户的离线消息进行存储，在这点上不折不扣的向FaceBook学习了一把。
&#160;
相关文章:
	Hbase入门6 -白话MySQL(RDBMS)与HBase之间  
	Lily-建立在HBase上的分布式搜索  
	MySQL向Hive/HBase的迁移工具  
	HBase入门5(集群) -压力分载与失效转发  
	Hive入门3&#8211;Hive与HBase的整合  
	HBase入门篇4  
	HBase入门篇3  
	HBase入门篇2-Java操作HBase例子  
	HBase入门篇 
	基于Hbase存储的分布式消息(IM)系统-JABase 
	HBase入门7 -安全&#38;权限 
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/hadoop-mapreduce-hbase.html?source=rss</link>
			</item>
	<item>
		<title>2010冬日里的一次顾问咨询后记</title>
		<description><![CDATA[&#160; 大约在去年冬季受到一位仁兄的推荐，邀请我帮助某大型垄断国企做一次系统架构方面的优化工作，客户期望将原有分散在全身每个地市的oracle数据库进行集中，并对集中后的数据库构建集群环境，做到压力分载和失效转发的目的，在系统架构上做出了改动，所以免不了代码上也需要做出相应的修改，对方要求我包揽整个过程包裹顾问和方案实施，于是对方开出的实施顾问的价码足以让人信服，为了自己在朋友圈的口碑、为了对得起客户方开出的价码，克服一切困难将任务执行到底。
	&#160;
	&#160;我的废话：
	&#160; 这个项目的难点在于
	&#160;&#160;&#160; 1.关键性业务表每月每个地区产生的数据量有2T，13个地区就是26T的数据量，保存一年的数据，再乘以12个月，海量数据需要存储。
	&#160;&#160;&#160; 2.BT要求，所有数据只允许放在一个数据库中，再多的机器也是从节点，对于海量查询需要根据业务进行SQL、数据库性能优化。
	&#160;&#160;&#160; 3.全省所有的数据都集中后，存储量和计算的压力都在一个计算中心的节点上，数据量和访问量比以前大，不能比改造前的性能低。
	&#160;&#160;&#160; 4.架构改动，代码必改，客户的领导发话又不让大改，所以2难。
	&#160;&#160;&#160; 5.人事上，领导太多，领导与领导之间意见不统一，说起来话来都是专家，落实下去有点囧。
	&#160;
	整个实施历经4月个还算顺利，本来想找个机会写写这次的经历心得，但是怕给自己或者朋友惹来不必要的麻烦而断了后续的服务，虽然脑海中一直不断回想当时的实施过程，有些地方还算做的不够完美，还可以继续优化，想把这些东西记录下来，但是思前顾后想来想去却不知如何去写。
	正好前些日子有位网友看见了我的blog，向我提问关于日志系统需要使用到hadoop和mysql的问题，于是我回问到为何需要使用hadoop的原因，经过一番了解，我建议对方采用缓存+文档数据库的方案，我向这位网友提出的方案可以看做是那个大型垄断国企方案的一个缩小版，除了具体使用的具体技术和产品有差别以外，2者从总体设计思想上大同小异，而且场景也比较相似，对数据库读、写基本不在同一个时段，不论写和读对数据库的操作还是开销比较大的，因此我想借用这位网友的提问阐述对上一次实施中的部分经验分享。
	&#160;
	这位网友在来信中写到：
	&#160;&#160;&#160; 您好，我最近在处理web日志的事情，涉及大量日志的处理，然后在网上搜到你关于Hadoop和Mysql的文章，想向你请教如何将Hadoop和Mysql结合起来处理大批量数据的，网站每个新闻页嵌入了一段js统计代码，每次页面打开时这段代码会在apache服务器端的文件记录一条日志(关于访客的详细信息)，然后后台服务器每隔一段时间将日志文件打成压缩包；同时服务器端每隔一个小时会运行一个jar文件，这个jar文件作用是将压缩包解压，并解析每一条日志信息，同时将日志信息分解后插入mysql数据库。前台可以浏览日志分析图表。现在的问题是随着网站流量越来越大，单台服务器已经不能满足要求了，jar文件现在处理压缩包的时间越来越长，所以考虑网站流量未来几年的增长，想到用数台服务器来处理这个问题。想用hadoop来在每台机子上处理这个压缩包文件，同时将处理好的日志字段写入mysql中。不知道问题我是否解释清楚了。
	我回信中写到：
	&#160;&#160;&#160; 你好，我只能给你一个方向上的指引，首先hadoop做这样的事情不值得 ,有点大材小用，不是上pb级别的数据量使用hadoop划不来的。
	&#160;&#160;&#160; 我建议你是否可以采用这样的一种方案：
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 1.前端JS通过http协议调用 Java/REST程序，获得请求
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 2.Java/REST程序将获得的数据写入memcached中，将memcached作为缓冲区，
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 3.另一个程序作为一个轮询的定时器，可以根据时间范围或者数量级别判断memcached上限的阀值，
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 4.到达上限的时候一次性将数据写入mongoDB，如果写入数量较大还可以采用多线程的方式，
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 5.最后从mongDB中查询存储的结果。
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 6.如果不想使用mongoDB使用mysql也可以，到时候再对mysql对优化，例如：多块物理磁盘分区，mysql参数调整，读写分离。
	大致的系统架构：
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#124;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; 
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#124;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#124;&#8212;&#62;tomcat 1&#160;&#160; &#8212;&#8212;&#8212;-&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; 
	&#160;&#160;&#160;&#160;&#160;&#160; js&#8212;-http&#8211;&#62;loadbalance&#124;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#124; &#8212;&#8212;&#62;memcache&#60;&#8212;&#8212;scheduler&#8212;&#8211;&#62;DB/NOSQL
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#124;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#124;&#8212;&#62;tomcat&#160; N+1&#8212;&#8212;&#8211;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; multithread
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#124;
	这样做的理由是 ：
	&#160;&#160;&#160; 1.写入日志和分析读取日志不是实时的，完全可以采用异步架构，我建议中间通讯采用http，将来扩展方便。如果将来前端的请求日志系统的并发量很高，可以选用 类似 tomcat+haproxy、tomcat+apache的方案，分载前端请求压力。
	&#160;&#160;&#160; 2.采用memcached是为了提高写入的效率，写入比读更占用O/I资源，将平凡写入的数据放入缓存/内存，让数据更靠近CPU这是黄金原则。 
	&#160;&#160;&#160; 3. 不论是nosql还是mysql批量写入和一次一次写入所产生的开销大小这个差距是不用质疑的。
	我的废话：
	&#160;&#160;&#160; 希望通过这个blog能与业内更多的同行们得到交流，再次感谢您的阅读。

	&#8211;end&#8211;
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/oracle-memcached-mongodb-java.html?source=rss</link>
			</item>
	<item>
		<title>Hadoop MapReduce操作MySQL</title>
		<description><![CDATA[我的废话：
	&#160; &#34;不知你是否想过，计算一下在城市中的每台电脑里的文件数加起来的共数有多少？似乎是一个非常不可思议的问题，将会是一个非常庞大的数字，如果用计算机去远程挨个统计一遍数以万计的计算机，首先要去扫描磁盘，然后再去做统计，最后把结果累加，很难在容许的时间范围内得出一个结果。
	&#160; 但如果在每台机器上有一个程序让他去计算(统计)，在分组里合并计算结果，最后返回给中心服务器，貌似这样能在一定的短时间内得出结果。并非是我那么无聊的要去统计全市计算机中的文件数量，只是做了一个比方，我想说利用分布式并行计算可以更快的得到超大型数据的计算结果。 目前中国 很多互联网公司 已经采用了MapReduce框架便捷的去实现这样超大型数据的计算，例如：百度、淘宝、中国雅虎、金山 这样的互联网企业都在使用MapReduce，将计算的任务交给每台计算机，进行并行计算提高计算的能力。&#34;
	&#160; 在今天越来越多的人在讨论云计算相关的话题，越来越多的人知道云计算是有很多的计算机组成，但人们不会是关心云计算中的运用的具体技术，但是对于今天的程序员和工程师们来说会慢慢的会接触到云计算相关的需求，所以自然的就会接触到云计算相关的技术，云计算技术中包含分布式并行计算，分布式运算模型就是能够把任务分布到多台服务器上面执行，最后把任务归并回来获得计算的结果，而 MapReduce 就是一个为并行处理大量数据而设计的编程模型，它将工作划分为一个独立任务组成的集合。它是一种并行编程，现有的产品包括，如： Google 的 BigTable、Hadoop 、HBase 都用到了MapReduce的计算框架。
	&#160;
	&#160; Hadoop项目中Mapreduce的分布式计算框架需要依托于Hadoop的集群环境，在集群环境中 MapReduce 程序用于以并行方式计算大量数据，并且可以分配计算机之间的计算负荷，带来很高的运算效率，当计算时需要输入一组键/值对，生成一组输出键/值对。计算涉及的两个基本操作：Map 和 Reduce。用户编写的 Map 操作需要输入并生成一组中间键/值对。MapReduce 库将所有与同一中间键相关联的中间值组合到一起，并且将它们传递给 Reduce 功能。Hadoop 提供了MapReduce这种方法来实现并行计算程序设计的框架，当客户端发出MapReduce计算的请求转发到 Hadoop NameNode。然后Hadoop NameNode 负责具体的操作，它将启动大量 Map 和 Reduce 进程 执行具体的计算任务。当 MapReduce 完成操作之后，主节点 NameNode 将输出值返回到服务器并交付客户端。
	&#160; 在Hadoop集群环境的节点状态被分类为3类：高利用、平均利用 和未充分利用。根据每个节点的利用率，将负载在节点之间转移以平衡集群。首选需要获取邻近节点详细信息：1. 当 DataNode 的负载增加到阈值级别时，它将向该 NameNode 发送一个请求。2. NameNode 获得特定 DataNode 最邻近节点的负载级别信息。3. NameNode 比较负载，然后将有关最空闲相邻节点的详细信息发送到特定的 DataNode。其次DataNodes 开始工作：1. 每个 [...]]]></description>
		<link>http://www.javabloger.com/article/mapreduce-mysql.html?source=rss</link>
			</item>
	<item>
		<title>谈谈MapReduce</title>
		<description><![CDATA[我的废话1：
	&#160;&#160;&#160; 这篇文章不讲述有关mapreduce的具体技术和代码示例，只是谈谈我对mapreduce初试+摸索阶段的感受，所以欢迎各路英雄的板砖向我抛来。
我的废话2：
	&#160;&#160;&#160;&#160; MapReduce 让运算散列 且 并行着。
&#160;&#160; MapReduce被业界认定是Google推出，如今也不是什么新的技术，自从Apache的Hadoop项目启动以来MapReduce就是整个Hadoop项目的核心内容，Pig、Hive和Hbase都是针对mapreduce框架的实现工具，所以对Hbase、Hive、Pig的深入了解必须对MapReduce有一定研究，以我自己的理解MapReduce就是把要计算的大型数据集切分成多个小的分区，根据这些被划分的小分区创建多个对应的任务去计算这些被切分的数据，在集群的节点上结合分区表分布式的执行计算,中间有调度器和计数器的环节，最后再把多个任务的计算结果进行合并，输出计算的结果。在这些执行每个分块的分布式集群节点中，可以使用非常廉价的机器，这样就可以使用低端的设备组成一个超大的型的运算。
	&#160; MapReduce的原理是比较简单的，并且目前流行大部分语言都能实现。如今Yahoo利用MapReduce定期在搜索业务上使用Hadoop来提高其产品和服务，如排名功能和目标广告。Google利用MapReduce来进行分布排序，web连接图反转，每台机器的词矢量，web访问日志分析，也有一些开源项目利用MapReduce来实现产品的功能，例如：最著名的MongoDB和Apache的Nutch，还有一些项目提出使用MapReduce来执行对数据库的分布式计算，例如：Gearman(Ref)，运行在微软云计算平台上的lokad-cloud(Ref) 。&#160; MySpace也自己研制的MapReduce框架Qizmt开源了(Ref)，可用于在大规模Windows集群上开发或运行分布式计算程序。
	&#160;&#160; 对于在Hadoop中涵盖的技术(Hive/HBase/Pig)对于传统的数据库来说，具有天然的可扩展性和支持海量数据存储的能力，并且对非结构化的数据处理能力完全超越于传统的数据库技术。例如，当MySQL运行的集群节点达到100台以上，虽然说理论上MySQL单张表的最大数据容量可以达到2T，但是如果真正需要依靠MySQL来存储的数据上T再加上大并发的用户访问，无论是维护还是操作都是非常头痛的事情，让MySQL或者传统数据库肩负超大型的数据运算/查询，化九牛二虎之力跑起来稳定一段时间过后，我想也会把MySQL累个半死，这是也并不是说让Hadoop/MapReduce/Hive 这些技术去替代传统的技术，而是希望Hadoop/MapReduce/Hive去用于做数据转换或者装载的(ETL)方面的工作，MapReduce适合海量数据数据被一次写入和多次读取的应用，在这些场合，MapReduce可以成为传统数据库的良好补充，而不是替代品。
	&#160; 某些特定的场景中要存储上亿个文件本身就是一个头疼的问题，还要找出上亿个文件中存储的文档、图片、网页 哪个最大，并且还要分别列出3类，那更是雪上加霜，但利用Hadoop提供的MapReduce框架，基于HDFS分布式海量数据存储的手段，相对传统的方法而言会轻松一点，因为利用Hadoop的技术可以让廉价的机器组成在一起带来更高的计算性能，并且支持海量存储，换而言之，如果你的数据还没有上千万 上了Hadoop基本上是用&#8220;关公的大刀切青菜&#8221;，资源浪费。
	&#160;&#160; Hadoop并非是完全用于非结构化和半结构化的数据处理，在Apache Hadoop的MapReduce中为了方便MapReduce直接访问关系型数据库(Mysql,Oracle)，MapReduce输入的键和值并不是数据固有的属性，可以人为的来选择数据来源。Hadoop提供了DBInputFormat和DBOutputFormat两个类。这样就可以将现有数据库中的数据转储到Hadoop/HDFS中，由MapReduce进行分布式计算，通过MapReduce框架对海量数据进行分析，或者也可以倒过来从海量的非结构/半结构/结构化的数据分析，将计算的结果存储到数据库。关键字：DBOutputFormat、DBInputFormat、DBConfiguration，根据这几个关键字可以Google到更多结果，暂时先不提供代码了，稍后会提供完整的代码示例和个人见解，需要了解的同学可以先看看这里(Ref)。
	让我更值得关注的是如何将mapreduce使用在适合的场景，将hadoop mapreduce的框架用途发挥到极致，或者说当面对大型计算该如何借用mapreduce框架、原理将计算进项散列在不同的计算机上去执行同一份作业，去更高的发挥机器的资源，更快的得到计算的运行结果，我想这才是使用mapreduce真正的目标吧。
&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/mapreduce.html?source=rss</link>
			</item>
	<item>
		<title>Apache Thrift入门2-Java代码实现例子</title>
		<description><![CDATA[&#160; 在上一篇文章中提到了Thrift的架构、传输协议(Ref)，本篇文章将对Thrift的入门实例进行介绍。 分为如下5个部分： 运行环境、安装/配置、脚本文件、创建代码、运行程序。
	一、开发环境(清单1)
	1.操作系统
	&#160;&#160; &#160;Server-Linux / Client-WinXP
	2.SDK
	&#160;&#160; &#160;Sun JDK1.5+
	3.需要的jar依赖包
	&#160;&#160; &#160;libthrift.jar
	&#160;&#160; &#160;slf4j-api-1.5.8.jar
	&#160;&#160; &#160;slf4j-log4j12-1.5.8.jar
	&#160;&#160; &#160;log4j-1.2.15.jar
	4.编译工具
	&#160;&#160; &#160;Apache Ant&#160; &#38; Apache ivy
	二、安装/配置 (清单2)
	&#160;&#160; &#160;1.下载thrift源文件
	&#160;&#160; &#160;&#160;&#160; &#160;http://labs.renren.com/apache-mirror//incubator/thrift/0.5.0-incubating/thrift-0.5.0.tar.gz
	&#160;&#160; &#160;&#160;&#160; &#160;
	&#160;&#160; &#160;2.编译thrift源文件
	&#160;&#160; &#160;&#160;&#160; &#160;1)解压 thrift-0.5.0.tar.gz 
	&#160;&#160; &#160;&#160;&#160; &#160;2)用ant编译源代码，进入x:\thrift-0.5.0\lib\java目录，执行ant，通过ant中的ivy工具会自动从站点下载所需要的依赖包，编译完成后如图所示:
	&#160;&#160;&#160; &#160; &#160;&#160; 
	&#160;&#160; &#160;&#160;&#160;&#160; 3)编译过程中下载的依赖包在x:\thrift-0.5.0\lib\java\build\ivy\lib 目录下可以看见下载的jar依赖包，将编译成功以后的jar包加入Eclipse的开发环境中。
三、脚本文件(清单3)
	&#160;&#160; &#160;1.创建脚本
	&#160;&#160; &#160;&#160;&#160; &#160;创建脚本文件 testJava.thrift ，脚本文件内容如下：
	&#160;&#160; &#160;&#160;&#160; &#160;namespace java com.javabloger.gen.code&#160;&#160; # 注释1&#160;&#160; 定义生成代码的命名空间，与你需要定义的package相对应。
	&#160;&#160; &#160;&#160;&#160; &#160;struct Blog {&#160;&#160; #&#160; 注释2.1&#160;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/thrift-java-code-example.html?source=rss</link>
			</item>
	<item>
		<title>Apache Thrift入门1-架构&amp;介绍</title>
		<description><![CDATA[Thrift&#160; 是什么？
	&#160; Thrift源于大名鼎鼎的facebook之手，在2007年facebook提交Apache基金会将Thrift作为一个开源项目，对于当时的facebook来说创造thrift是为了解决facebook系统中各系统间大数据量的传 输通信以及系统之间语言环境不同需要跨平台的特性。所以thrift可以支持多种程序语言，例如:&#160; C++, C#, Cocoa, Erlang, Haskell, Java, Ocami, Perl, PHP, Python, Ruby, Smalltalk. 在多种不同的语言之间通信thrift可以作为二进制的高性能的通讯中间件，支持数据(对象)序列化和多种类型的RPC服务。Thrift适用于程序对程 序静态的数据交换，需要先确定好他的数据结构，他是完全静态化的，当数据结构发生变化时，必须重新编辑IDL文件，代码生成，再编译载入的流程，跟其他IDL工具相比较可以视为是Thrift的弱项，Thrift适用于搭建大型数据交换及存储的通用工具，对于大型系统中的内部数据传输相对于JSON和xml无论在性能、传输大小上有明显的优势。
	&#160;&#160; Thrift是IDL(interface definition language)描述性语言的一个具体实现，关于IDL的话题我们可以追溯到CORBA盛行1999-2001年(Common Object Request Broker Architecture/公用对象请求代理体系结构)，在 IDL 中我们似乎不会忘记到这几个关键字：module、interface、string、long 和 int，我还记得IDL利用module来创建名称空间，并且准确地映射为 Java 的 package，这些特性几乎和现在thrift的特性完全相同，所以thrift的设计思想和理念绝不是什么从火星来的new idea，看看在那个CORBA盛行的年代人们提出的概念，如图所示CORBA 请求的各个部分，回头我们再与thrift进行对比一下：
	
	Thrift 基础架构
	&#160;&#160; Thrift是一个服务端和客户端的架构体系，从我个人的感官上来看Thrift是一个类似XML-RPC+Java-to- IDL+Serialization Tools=Thrift 的东东，Thrift 具有自己内部定义的传输协议规范(TProtocol)和传输数据标准(TTransports)，通过IDL脚本对传输数据的数据结构(struct) 和传输数据的业务逻辑(service)根据不同的运行环境快速的构建相应的代码，并且通过自己内部的序列化机制对传输的数据进行简化和压缩提高高并发、 大型系统中数据交互的成本，下图描绘了Thrift的整体架构，分为6个部分：1.你的业务逻辑实现(You Code) 2.客户端和服务端对应的Service 3.执行读写操作的计算结果4.TProtocol 5.TTransports&#160; 6.底层I/O通信
	
	图 中前面3个部分是1.你通过Thrift脚本文件生成的代码，2.图中的褐色框部分是你根据生成代码构建的客户端和处理器的代码，3.图中红色的部分是2 端产生的计算结果。从TProtocol下面3个部分是Thrift的传输体系和传输协议以及底层I/O通信，Thrift并且提供 堵塞、非阻塞，单线程、多线程的模式运行在服务器上，还可以配合服务器/容器一起运行，可以和现有JEE服务器/Web容器无缝的结合。
数据类型
	&#160;&#160;&#160; &#160;* Base Types：基本类型
	&#160;&#160;&#160; &#160;* Struct：结构体类型
	&#160;&#160;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/apache-thrift-architecture.html?source=rss</link>
			</item>
	<item>
		<title>2011 新年里</title>
		<description><![CDATA[
查看更多照片
	
&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/2011-pic-1.html?source=rss</link>
			</item>
	<item>
		<title>HBase入门7 -安全&amp;权限</title>
		<description><![CDATA[我的废话：
	&#160;&#160;&#160; 大年三十夜，看春晚实在是太无聊了，整个《新闻联播》的电视剧版本，还不如上上网，看看资料，喝喝老酒，写点东西来的快活。
	&#160;&#160; 近2年来云计算的话题到目前为止风风火火从来没有平静过，一直是大家嘴边讨论的热门话题，人们期望运用云计算提供可靠、稳定、高速的计算，在云计算中Google是目前最大的云计算供应商，例如：Google GAE(Google App Engine)和Google的Docs在线文章服务，这些SaaS上线产品的数据存储(datastore)是由BigTable提供存储服务的，在次之前我提到过Yahoo贡献给Apache的那些山寨版本(Google与Yahoo的那些利器)，其中Apache的HBase就是山寨了Google的BigTable。
	&#160;&#160; 我们知道在云计算的技术话题中Apache的Hadoop项目是一块基石，利用Hadoop项目中的产品可以建立云计算平台和超大型的计算。不知道你是否有想过如果将HBase作为Google GAE上的数据存储(datastore)，那么每个用户之间的数据访问权限怎么办？如果使用HBase提供对大客户提供&#8220;私有云&#8221;(private cloud)或者另一种可能一个公司内部的集群上运行HBase，公司的内部可能有几个部门，某几个部门之间的数据都是独立分离但又运行在一个平台上，那么你就会发现HBase不具备这样的功能，貌似目前HBase的最高版本0.90.0还没有这样的功能对用户的表、Row、Cell的访问权限。但是我们知道Google的GAE上每个用户访问的数据肯定是有权限划分的，不然我只要有权限登录GEA就能看见所有用户存放的数据了。这样的问题你有可能没有想过，但趋势公司的工程师们却为此想到了这点，并且把他们的设想和设计提交了HBase项目组，并且提出了以下主要的设计思想：
	&#160;&#160; 1. Client access to HBase is authenticated
	&#160;&#160; 2. User data is private unless access has been granted
	&#160;&#160; 3. Access to data can be granted at a table or per column family basis.
对HBase中的表和数据划分权限等级和身份验证后，操作权限被分为3大类，每类中包含的操作权限如下所示：
	
对于方案中涉及到存储的权限的是指整个表或表中的列族，也就是说只考虑在表这个级别的权限，表与表之间的所属关系是存放在 .META. 系统表中，以regioninfo:owner 的格式进行存放，例如:系统中table1这个表是有权限的，这个表权限的存根保存在3个地方 ：
	&#160;&#160;&#160; * The row in .META. for the first region of [...]]]></description>
		<link>http://www.javabloger.com/article/hbase-secure-privilege.html?source=rss</link>
			</item>
	<item>
		<title>Hbase入门6 -白话MySQL(RDBMS)与HBase之间</title>
		<description><![CDATA[我的废话1:
	&#160;&#160; 任何一项新技术并非救命稻草，一抹一擦立马药到病除的百宝箱，并非使用Spring或者NOSQL的产品就神乎其神+五光十色，如果那样基本是扯淡。同类 型产品中不管那种技术最终要达到的目的是一样的，通过新的技术手段你往往可能避讳了当前你所需要面对的问题，但过后新的问题又来了。也许回过头来看看还不 如在原来的基础上多动动脑筋 想想办法 做些改良可以得到更高的回报。&#160;&#160; 
	&#160;
&#160;&#160; 传统数据库是以数据块来存储数据，简单来说，你的表字段越多，占用的数据空间就越多，那么查询有可能就要跨数据块，将会导致查询的速度变慢。在大型系统中一张表上百个字段，并且表中的数据上亿条这是完全是有可能的。因此会带来数据库查询的瓶颈。我们都知道一个常识数据库中表记录的多少对查询的性能有非常大的影响，此时你很有可能想到分表、分库的做法来分载数据库运算的压力，那么又会带来新的问题，例如：分布式事务、全局唯一ID的生成、跨数据库查询 等，依旧会让你面对棘手的问题。如果打破这种按照行存储的模式，采用一种基于列存储的模式，对于大规模数据场景这样情况有可能发生一些好转。由于查询中的选择规则是通过列来定义的，因此整个数据库是自动索引化的。按列存储每个字段的数据聚集存储， 可以动态增加，并且列为空就不存储数据，节省存储空间。 每个字段的数据按照聚集存储，能大大减少读取的数据量，查询时指哪打哪，来的更直接。无需考虑分库、分表 Hbase将对存储的数据自动切分数据，并支持高并发读写操作，使得海量数据存储自动具有更强的扩展性。
	&#160;&#160; Java中的HashMap是Key/Value的结构，你也可以把HBase的数据结构看做是一个Key/Value的体系,话说HBase的区域由表名和行界定的。在HBase区域每一个&#34;列族&#34;都由一个名为HStore的对象管理。每个HStore由一个或多个MapFiles(Hadoop中的一个文件类型)组成。MapFiles的概念类似于Google的SSTable。 在Hbase里面有以下两个主要的概念，Row key 和 Column Family，其次是Cell qualifier和Timestamp tuple，Column family我们通常称之为&#8220;列族&#8221;，访问控制、磁盘和内存的使用统计都是在列族层面进行的。列族Column family是之前预先定义好的数据模型，每一个Column Family都可以根据&#8220;限定符&#8221;有多个column。在HBase每个cell存储单元对同一份数据有多个版本，根据唯一的时间戳来区分每个版本之间的差异，最新的数据版本排在最前面 。
口水：Hbase将table水平划分成N个Region，region按column family划分成Store，每个store包括内存中的memstore和持久化到disk上的HFile。
	上述可能我表达的还不够到位，下面来看一个实践中的场景，将原来是存放在MySQL中Blog中的数据迁移到HBase中的过程：
	MySQL中现有的表结构：
	
	迁移HBase中的表结构：
	
	原来系统中有2张表blogtable和comment表，采用HBase后只有一张blogtable表，如果按照传统的RDBMS的话，blogtable表中的列是固定的，比如schema 定义了Author,Title,URL,text等属性，上线后表字段是不能动态增加的。但是如果采用列存储系统，比如Hbase，那么我们可以定义blogtable表，然后定义info 列族，User的数据可以分为：info:title&#160; ,info:author ,info:url 等，如果后来你又想增加另外的属性，这样很方便只需要 info:xxx 就可以了。
	对于Row key你可以理解row key为传统RDBMS中的某一个行的主键，Hbase是不支持条件查询以及Order by等查询，因此Row key的设计就要根据你系统的查询需求来设计了额。 Hbase中的记录是按照rowkey来排序的，这样就使得查询变得非常快。
	具体操作过程如下：
	============================创建blogtable表=========================
	create &#39;blogtable&#39;, &#39;info&#39;,&#39;text&#39;,&#39;comment_title&#39;,&#39;comment_author&#39;,&#39;comment_text&#39;
	&#160;
	============================插入概要信息=========================
	put &#39;blogtable&#39;, &#39;1&#39;, &#39;info:title&#39;, &#39;this is doc title&#39;
	put &#39;blogtable&#39;, &#39;1&#39;, &#39;info:author&#39;, &#39;javabloger&#39;
	put &#39;blogtable&#39;, &#39;1&#39;, &#39;info:url&#39;, &#39;http://www.javabloger.com/index.php&#39;
	put &#39;blogtable&#39;, [...]]]></description>
		<link>http://www.javabloger.com/article/hbase-mysql-rdbms.html?source=rss</link>
			</item>
	<item>
		<title>Lily-建立在HBase上的分布式搜索</title>
		<description><![CDATA[&#160;
Lily以NoSQL技术为主题，是建立在云计算上的内容仓库(content repository)。它是基于Apache的 HBase(存储)和Solr(索引/搜索)，并提供了大型内容集合存储与检索的解决方案。可运用在 门户网站，内容管理系统，及时搜索，档案应用，文案管理，等等。
&#160;
&#160;

Lily项目与传统的Lucene框架相比体现了以下几点关键性的优势：
	&#160;&#160;&#160; &#183;伸缩性&#160; &#8211;&#62; sharding/MapReduce 
	&#160;&#160;&#160; &#183;可用性&#160; &#8211;&#62; replication 
	&#160;&#160;&#160; &#183;及时性&#160; &#8211;&#62; real-time update index
	&#160;&#160;&#160; &#183;容错性&#160; &#8211;&#62; no SPFO
另外，Lily 借用了Apache的 HBase进行存储 ，Solr进行Index/Search；
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; Lily 重新构建大数量的索引Lily会采用MapReduce把索引当做文件切在HDFS上；
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#160; Lily 索引更新时切换并没有像LinkedIn的Zoie那样保存在内存里，Lily在Hbase上建立了secondary indexes；
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; Lily 在建立索引的结构方面 借鉴了Google App Engine的索引设计思想；
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#160; &#160; Lily 提供REST 和 API 2种方式提供客户端调用；
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; 
	BTW：关于上面提到了LinkedIn的Zoie我想多数两句，Zoie跟LinkedIn的其他产品捆绑的非常紧密，导致你如果单一的使用Zoie总会觉得很变扭，而且文档非常少，那篇让人貌似惊喜的中文文档仍然不够详细，只好对Zoie望而却步了。
	Lily的系统架构由4个主要的部分组成：
	&#160;&#160;&#160; 1.Zookeeper &#8211; 对分布式环境中的状态和配置进行管理，让Client可以知道当前有多少个工作的 Lily Node。
	&#160;&#160;&#160; 2.Lily Node &#8211; a)WAL(预写日志)、b)Message Queue(消息队列)、c)Indexer(索引策略)、d)Lily Repository(索引CRUD) 组成。
	&#160;&#160;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/lily-hbase-solr-lucene-zookeeper.html?source=rss</link>
			</item>
	<item>
		<title>基于Hbase存储的分布式消息(IM)系统-JABase</title>
		<description><![CDATA[&#160;&#160; 前段日子看了在highscalability.com上一篇介绍facebook消息系统的文章，一夜之后被无数个网站无数次的转载，现如今facebook的任何一个话题都会引起很多人的关注，但我对只对这文章里面没有说明的部分比较感兴趣，系统里是怎么获得即时消息的？PHP监听器？开启很多个监听器服务？推模式？拉模式？跟Twitter一样采用消息中间件？对此有了些疑问，期待日后有人能给出明确解答。
	&#160;
	&#160;&#160;&#160; 这个叫JABase的 东东 能给我一些启示，JABase是应用在分布式IM系统中的中间件，可以支持大规模的集群环境的伸缩性架构，并采用Java语言来实现的，JABase是介于分布式数据存储(HBase/HDFS)和即时消息收发(Erlbase/XMPP Server)的一个中介体，JABase将XMPP Server中的收/发消息存放在HBase中，这点与facebook消息系统文章中提到的极为相似。另外提一下，JABase给出的方案中的IM消息服务器(XMPP Server) Erlbase是采用 Erlang 语言编写，有点像Twitter。
	整个系统架构由HBase/HDFS、JABase、ErlBase 这3大部分组成，整体架构如图所示：

除了需要安装HBase和HDFS一些主要部件以外，还需要有以下一些组件支持：
	&#160;&#160; &#8211; ejabberd-2.0.3.tar.gz&#160;&#160;&#160; (Erlang)
	&#160;&#160; &#8211; erlbase-1.0.tar.gz&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; (Erlang)
	&#160;&#160; &#8211; jabase-1.0.tar.gz&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; (Java)

	对JABase项目的了解，结合目前采用的架构引发出2个的设想：
	&#160;&#160;&#160; 1、XMPP与MQ 可扩展性的比较，有时间需要坐下来跟大家讨论一下。
	&#160;&#160;&#160; 2、MQ的性能扩展 a)前端集成缓存 b)后端消息存储，看看这么加才对我们有真正的帮助。
	&#160;
&#160;

	相关文章:
	MySQL向Hive/HBase的迁移工具  
	HBase入门5(集群) -压力分载与失效转发  
	Hive入门3&#8211;Hive与HBase的整合  
	HBase入门篇4  
	HBase入门篇3  
	HBase入门篇2  
	HBase入门篇  
	Lily建立在HBase上的分布式搜索  

	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/hbase-im-jabase-xmpp.html?source=rss</link>
			</item>
	<item>
		<title>MySQL向Hive/HBase的迁移工具</title>
		<description><![CDATA[&#160;&#160; Apache Hive是目前大型数据仓库的免费首选产品之一，使用Apache Hive的人是不会期望在小数据量上做什么文章，例如把MySQL中的数据搬到Hive/HBase中去，那样的话原先很快能执行完毕的SQL，估计在Hive上运行跟原来相比时间延长10倍都不止。但如果你有MySQL数据可以把大量的数据向Hive导入，如果上亿条的数据量再加上复杂的SQL查询条件对于MySQL来说是一件比较头疼的事情，此时相比而言对于Hive来说还算比较easy没有那么非常的头痛，但是两者之间缺少一个沟通的桥梁。

	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; 
	而然伟大的云计算公司cloudera.com也是Hadoop强力支持者推出了Sqoop，Sqoop顾名思义SQL-to-Hadoop，在sqoop中通过 ManagerFactory 抽象类对多种数据库类型进行了抽象，可以做到 Hsqldb、MySQL、Oracle、PostgreSQL 这些数据库中的数据可以向Hive中写入。
	
&#160;&#160; 从导出/导入所有数据一条命令即可，而且可以对表和数据的筛选，开发的效率提升和配置的简洁是这个工具的特色所在，同样的机器配置、机器数量、数据量和数据内容，但是换了不同的环境得到了不同的执行效率，通过对RMDBS到Hadoop的迁移，带来了性能的提升，所以就体现了sqoop的价值。
在一次开发大会上提到的Sqoop主要功能
	&#160;&#160;&#160; JDBC-based implementation
	&#160;&#160;&#160; &#160;&#160;&#160; ▪ Works with many popular database vendors
	&#160;&#160;&#160; Auto-generation of tedious user-side code
	&#160;&#160;&#160; &#160;&#160;&#160; ▪ Write MapReduce applications to work with your data, faster
	&#160;&#160;&#160; Integration with Hive
	&#160;&#160;&#160; &#160;&#160;&#160; ▪ Allows you to stay in a SQL-based environment
	&#160;&#160;&#160; Extensible backend
	&#160;&#160;&#160; &#160;&#160;&#160; ▪ Database-specific code [...]]]></description>
		<link>http://www.javabloger.com/article/hadoop-hive-mysql-sqoop.html?source=rss</link>
			</item>
	<item>
		<title>JEE技术在移动互联网中的应用</title>
		<description><![CDATA[去年写的PPT， 一些应用案例中的片段和场景，跟大家做个小小的分享，献丑了。

其中的技术架构是我们在2007-2009年实施的案例摘录，2009-2011年实施的一些架构暂时还没有全部整理好。
以上PPT内容非公司内部资料，解释权 归本人所有。
H.E. 最想看到您对这份 PPT宝贵的观点和评论，先跟各位说声：谢谢了。
&#160;
&#160;BTW：今年将主打GIS和云计算(Hadoop) 话题。
	
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/jee-and-mobile-internet.html?source=rss</link>
			</item>
	<item>
		<title>新年，新功能</title>
		<description><![CDATA[我的废话：
	&#160;&#160; 用户体验是第一位的，如何通过现有的平台给用户带来更好和更有价值的体验？是值得每个工程师是去思考的话题，我这里不说是说哪一类的工程师。也不论是前端还是后端的工程师。 
	&#160;&#160; 我记得在Google的公司介绍中 有关Google公司的价值观介绍中有这样一句话：&#8220;1. 以用户为中心，其他一切水到渠成&#8221;。也就是说要完成这一目标不是达到自己的内部目标或意愿，而是将用户的利益放在第一位。
	&#160;&#160; 在不断的学习互联网大佬Google的10大理念的同时 不仅让我琢磨着如何提高客户的产品体验，不时的也让我想着如何改善这个站点的用户体验，平日想到了一些，现在做到了一些，仍有些想法还未实现，但我先把做到的记录下来：
	读书推荐
	在每篇文章中可以向读者推荐与当前文章有关话题的书籍，一般可以做到有效推荐10几本，多则可以上百本。该功能是为了：
	1.推荐相关书籍可以帮助读者系统性的学习，因为光是阅读一篇文章不可能掌握某想技术的全部知识，
	2.推荐的书籍列表可以帮助读者开拓视野，读者会知道哪几项技术是有必然的关联性的，此时会放在同一阶段的学习计划中。
	3.推荐读者离线的阅读书籍/资料，可以让读者循序渐进的进行学习。
	&#160;&#160; 设想一下，站在用户的角度看待这个功能，他阅读这个片文章《Glassfish(EJB)与Quartz Job Scheduler整合》，该文章与GlassFish话题相关并且还与J2EE服务器有关，根据文章的标签再对应豆瓣的API，读者可以得到两类书籍推荐 GlassFish，J2EE服务器，学习Java的人都知道J2EE服务器包含了GlassFish服务器 要掌握 GlassFish服务器 学习J2EE服务器还是必不可少的。再比如我写的上一篇文章《谷歌分析数据》，通过这篇文章会向你推荐&#160; 有关 SEO 和 google-analytics 类别的书籍，对用户系统化的学习和开拓视野可以起到一定的作用。&#160;&#160; 
	&#160;&#160; 此时推荐的书籍98%是有效的推荐，因为推荐的内容完全针对用户感兴趣的话题。用这项功能的服务是&#8220;豆瓣读书&#8221;提供的API做到的。BTW: 豆瓣不是网上书店，只是一个中间机构，所以我觉得他给出的结果相对客观。
	
	在文章中推荐的链接，如下图所示：
	&#160;&#160;&#160;&#160; 

	首页栏目
	&#160; 方便访问用户对本站作者更多的了解，比如：读什么书籍?看什么电影?听什么音乐? 通过这些内容可以大致了解作者的什么性格、类型的人，这样便于彼此在线上和线下更好的交流，展开更多扩展的共同话题，提高彼此的认知度，拉近与读者直接的距离。
	新浪微博
	&#160;&#160; 不论是作为推广和获得新识 都是一个不错的选择，但新浪微博对于非注册用户是不开放里面的内容，你在新浪微博里面的内容再精彩对于非注册用户来说一切都是空白。所以我利用新浪微博的API直接面向所有用户，可以知道我最近关注的一些正经事和破事儿，这样做也是拉近与读者的距离。点击这里可以查阅。
	其他
	&#160;&#160; 还添加了 留言板和 废话录 2个页面，方便与用户直接进行交流，并且修改了评论字体样式 。
	最后
	没有什么总结，因为还没有做完，先记着在这里，有些东西完善以后和现在记录下来的东西整合在一起。
	&#160;
最后，再来一个小投票：
	


请告诉我&#34;读书推荐&#34;这个功能怎么样？

 一般

 很好

 很烂


&#160;




	&#8211;end&#8211;
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/javabloger-site-features.html?source=rss</link>
			</item>
	<item>
		<title>谷歌分析数据</title>
		<description><![CDATA[废话少说，进入正题，关于Google Analytics(谷歌分析)工具的使用和相关介绍请查阅这里，下面是使用Google Analytics(谷歌分析)工具查看本站2010年流量统计分析，统计时间是从2010-1-1到2011-1-1产生的数据。
	　　
	1、网站访问量：
	　　在这一年里网站的独立访问数有74000多个访问者，平均每天有200多个独立访问者，如图所示:
	查看大图请点击这里
	2、网站使用率 :&#160;&#160;&#160; 
	&#160;&#160;&#160; 综合浏览量为199,512次，每次访客访问页数为2.70个页面，&#160;&#160; 跳出率到达38.66%，平均网站停留时间为00:01:36，新访问次数百分比为84.87%，如图所示:
	
	查看大图请点击这里
	3、访客流量来源:
	&#160;&#160;&#160; 91 个国家/地区带来了 74020 次的独立访问量，其中除中国外访问来源最多的地区就是台湾(Taiwan)，有3,116个独立访客，其次是美国(United States)有1,388个独立访客.如图所示：
	
	查看大图请点击这里
	&#160;&#160;&#160; 
	&#160;&#160; 中国有 378 个城市带来了 66,274 次的独立访问，其中访问来源最多的3个城市是:Beijing、Shanghai、Shenzhen ，而我所在的城市南京只排在第6位,如图所示：
	
	查看大图请点击这里
	4、访问途径来源:
	&#160;&#160;&#160; 直接进入本站的访问是最大的访问来源，其次是来自Google和Baidu2个搜索引擎的访问来源，再次是来自stackoverflow.com和tech-q.cn的访问来源，如图所示：
	
	5、被查看最多的网页:
	&#160;&#160;&#160; 除了本站首页之外，人们看的最多的就是关于本人的自我介绍，其次是关于spring框架和系统架构(architecture)相关的话题,如图所示：
	
	查看大图请点击这里
	6、被查看最多的目标网页:
	&#160;&#160;&#160; 不论是通过直接输入网址还是通过其他网站跳转，除了本站首页以外，被访问最多的页面就是与Spring框架有关的页面，其次是和mongodb话题有关的网页，如图所示：
	
	查看大图请点击这里
	我的废话:
	&#160;这些数据让我判断出中国的程序员在北京和上海的最多，本站Hadoop系列的文章要比spring多，但是SSH框架之类的话题依然是最被关注的，这些可能我说的不准确，但是这至少是我从数据上得到的直观判断，暂时先这样，现在的数据需要跟来年相比较才会有更大的价值，来年在看吧，呵呵，新年快乐。
&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/javabloger-google-analytics-2010.html?source=rss</link>
			</item>
	<item>
		<title>谁引用了本站的内容?</title>
		<description><![CDATA[我的废话：
	无意中用Google的blogsearch.google.com工具搜索了一下, 发现在网上不少博文引用了本站文章，以下是从搜索结果中贴过来的一部分内容。
	&#160;
JMS与JMX(页1) &#8211; J2EE开发者- web思想社区关注互联网平台级架构设计 &#8230;
	1 个帖子 &#8211; 新贴子： 10月4日
	可以使用JEE规范中的JMX协议进行管理OpenMQ中的集群管理节点(managing brokers)、服务(admin/jms)、消息队列(destinations), 接收者(consumers), &#8230;
	www.tech-q.cn/archiver/tid-12594.html 
百万级大型J2EE Push Mail 项目后记
	百万级大型J2EE Push Mail 项目后记. &#8230; 2.JVM的优化是任何大型J2EE项目中必不可少的话题，当然并不是你把JVM的内存使用空间设置的越大越好，SUN的官方网站已经指出， &#8230;
	http://www.360doc.com/content/10/1111/15/15643_68489672.shtml
	百万级J2EE Push Mail 后记（转自H.E.）_Kyle&#39;s BLOG_百度空间
	1、虽然都是搞J2EE的老手，都没有接触过Push Mail这样的国外项目，所以对业务的精髓不能完全 &#8230; 5、对J2EE以外的技术只有1-2人了解。比如：分布式计算、应用服务器,数据库集群技术和大型 &#8230;
	http://hi.baidu.com/zhizhesky/blog/item/6c693dd35f69e00e3bf3cf62.html
JavaBloger迷你书(系统架构专题).pdf &#8211; OPEN开源文档
	2010年12月13日 &#8230; JavaBloger迷你书(系统架构专题).pdf. &#8230; JavaBloger迷你书(JMS与消息中间件专题).pdf. 1人评 48页. 利用iText生成PDF.doc. 6人评 4页 &#8230;
	http://doc.open-open.com/view/6e500b5643e44013980fb04f1d0bed5e
	JavaBloger迷你书(JMS与消息中间件专题).pdf &#8211; OPEN开源文档
	2010年12月13日 &#8230; JavaBloger迷你书(JMS与消息中间件专题).pdf. &#8230; 相关文档. JavaBloger迷你书(系统架构专题).pdf. 1人评 45页. JavaBloger迷你书(性能优化专题).pdf &#8230;
	http://doc.open-open.com/view/c0d19a098dff4308bfbf4446717a039b
	JavaBloger迷你书(性能优化专题).pdf &#8211; [...]]]></description>
		<link>http://www.javabloger.com/article/egosurf.html?source=rss</link>
			</item>
	<item>
		<title>GoodBye,2010</title>
		<description><![CDATA[&#160;
&#160;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; Hello 2011,Hello Baby(HTY)
&#160;
&#160;
&#8211;start&#8211;
&#160;
什么都不想说，说什么愿望都是以后的事儿，人入30后，我渐渐习惯不去多想大于明天的事，因为那些事儿后天我就会明白。
&#160;
&#160;
&#160;
]]></description>
		<link>http://www.javabloger.com/article/bye-2010-hello-hty.html?source=rss</link>
			</item>
	<item>
		<title>Hadoop Hama项目&#8211;BSP模型的实现</title>
		<description><![CDATA[目前Hama是Apache众多项目中一个被孵化的项目，也就是说Hama项目还没有真正成型,目前Hama是Hadoop项目下的一个子项目，Hama 一个基于BSP计算模型实现了分布式的计算框架，BSP模型是Hama计算的核心，采用这个计算模型可以用于矩阵计算(matrix)和向量图计算 (grah)、网络计算(network)，类似Google发明的Pregel，如果你听过Google Pregel这个利器的话，那么就对BSP计算模型不会陌生，Google的Pregel也是基于BSP模型，在Google的整个计算体系中有20%的计算是依赖于Pregel的计算模型，Google利用Pregel实现了图遍历(BFS)、最短路径(SSSP)、PageRank计算,我猜想 Google的Google Me 产品很有可能会大量采用Pregel的计算方式，用Pregel来绘制Google Me中SNS的关系图。  ]]></description>
		<link>http://www.javabloger.com/article/apache-hadoop-hama-bsp.html?source=rss</link>
			</item>
	<item>
		<title>停止你的抱怨！</title>
		<description><![CDATA[&#8220;别在跟谁说你的抱怨！&#8221;&#160; &#8220;去解决问题，别去解释问题！&#8221;&#160; 这是我在工作中的一段对白。
	如果你是一个喜欢去解释，习惯去解释的人，下面的文字就不用看，因为你会反对我这样的说法。
	看一下在现代汉语词典中对抱怨的解释：
	抱怨 b&#224;oyu&#224;n
	[complain;grumble] 心中怀有不满,责怪别人
	我，现在在一个900-1000个人生长型公司生存的技术人员、核心工程师、架构师、部门经理、新人导师 这些都是我在这个公司的称号和头衔。不管是谁，不管怎么称呼我都没问题。新来的菜鸟，资深的老员工向我请教问题我都满怀耐心去对待他们，同时我也会向他们请教我不解的问题。这些我都无所谓，但是我不喜欢别人向我抱怨，对问题，对人，对公司等等，一切的抱怨我都表示从潜意识上的反感，对待问题我可以耐心去接受与聆听，但对待抱怨和无聊的解释我一概无视，但我至少会聆听。
	没有完成你的目标也别跟我谈什么理想，我太不爱听！因为我们不是评论家，也不是社会关系学家，没有那个水平和足够的资格对这些、那些说三道四，解决了问题我们才有闲功夫去说三道四。
	我是在一个提交解决方案的公司，客户只想看最终的结果，不会想听我的解释。生存的环境就是这样，大环境也是这样，被逼的。看到这些文字被我说过的人，请原谅我对您的刻薄。
	一些刚刚入职的新人向我解释说到：这个技术、这个问题我没有接触过，不知道能不能解决。我记得在《娱乐现场》的节目中，记者采访汤灿关于歌舞剧《雪狼湖》的情节，让我尤为深刻，汤灿说到&#8220;和学友大哥每一次排练都有50-60遍，我本来以为只需要5-6遍，没有想到学友大哥非常认真&#8221;。我想表达的是：不是你没有这个能力解决当前的问题，而是看的太少，想的太少，试验的太少，对待问题没有充分的理解，所以导致对问题没有底气，才会有了为难的情绪向人抱怨，天王级别的人物都丝毫不敢放松，还是那样的刻苦练习，别说我们这些普通人了。
	当然新人在做的事过程中方法很重要，我只会告诉他该如何去做的方法和做事情的方向，而绝不会是问题的答案，不然我就贪污了他的一次成长过程，那样对他的成长和公司的成长丝毫没有帮助，只告诉他问题的答案那是徒劳的过程。
	有人问过我，你想去什么样的公司？我回答道：&#8220;什么样的公司，并不非常重要，而是你在什么样的公司，能改变什么,这个才是最重要的，就算在微软，google 进去了没有能力胜任工作去了也毫无意义。&#8221;
再看看看 淘宝、腾讯这些多年前的小公司，在成长的过程中肯定不会是马云、马化腾一个人在奋斗，我相信而是一帮人，一帮能改变现有环境的人，才会成就他们的今天。我认为在有前景的中小型公司里，通过每个人的努力不是没有可能成为一家大公司，因为现在的大公司都是原本的小公司变成了，那时你也是一位大公司中元老级的人物。
	有人说过公司某些项目没有技术含量，我觉得并不是没有技术含量，而是他对技术本身就没有完全的认识，有人说公司没有一帮牛人，我觉得并非没有一帮牛人，而是他没有成为牛人的愿望和理想。
	问题和对手不会管你是否疲劳，一旦给你自己找一个借口，你就会停下来一会，你将来会花费十倍的力气去追赶，才能赶上他们，你只有拼命的去跑，这并不代表你贪婪，这个的游戏规则就是剩者为王，意志力尤为重要，踏实的心态尤为重要。
	在奔跑的过程中每个人都是艰辛的，但你只有挨过最困难的时光，才能看见希望，如果你停下来了，你所处的位置就决定了你所能看见什么样的视野，因为什么样的视野，决定了你能看见什么样的未来，什么样的胸怀就创建什么样的事业。
	我相信一个真理，成功没有捷径，需要付出，需要忍耐，需要坚持，一个人真正的成功，是来自于点滴的成果。别去再谈什么超级壮观的理想，把小于等于明天的事情做好，一切水到渠成，喜悦的时分自然而来。
	以上的这些字我早就想说了，只是最近我听了太多的抱怨和解释，但我都无视，团队需要的是结果和有能力解决问题的人！我喜欢做事踏实的人，因为我就是这样爬过来的，我也感谢我现在的公司，他不仅给了我一个不错的工作氛围，同时也让我戒掉了一些浮躁的态度。

	&#8220;我没有天分，所以我很勤奋&#8221;&#8211;天王刘德华在一次颁奖典礼上说过的话。

	&#8211;end&#8211;
	祝大家2010年的平安夜快乐。
]]></description>
		<link>http://www.javabloger.com/article/stop-complaining.html?source=rss</link>
			</item>
	<item>
		<title>Apache Pig入门1 &#8211;介绍/基本架构/与Hive对比</title>
		<description><![CDATA[本文分为4个分部：1. 介绍&#160; 2.基本架构&#160;&#160; 3.与Hive对比&#160; 4.使用
	一、介绍
	Google的工程师为了方便自己对MapReduce的实现搞了一个叫做Sawzall的工具，Google就放了几篇论文放在网上，但这玩意在代码上不开源在设计思想是开源的，在前面一篇文章中我也提到过Hadoop也推出了类似Sawzall的Pig语言，就是根据Google放出来的论文山寨的。
Pig是对处理超大型数据集的抽象层，在MapReduce中的框架中有map和reduce两个函数，如果你亲手弄一个MapReduce实现从编写代码，编译，部署，放在Hadoop上执行这个MapReduce程序还是耗费你一定的时间的，有了Pig这个东东以后不仅仅可以简化你对MapReduce的开发，而且还可以对不同的数据之间进行转换，例如：包含在连接内的一些转化在MapReduce中不太容易去实现。
	Apache Pig的运行可以纯本地的，解压，敲个&#8220;bin/pig -x local&#8221;命令直接运行，非常简单，这就是传说中的local模式，但是人们往往不是这样使用，都是将Pig与hdfs/hadoop集群环境进行对接，我看说白了Apache的Pig最大的作用就是对mapreduce算法(框架)实现了一套shell脚本 ，类似我们通常熟悉的SQL语句，在Pig中称之为Pig Latin，在这套脚本中我们可以对加载出来的数据进行排序、过滤、求和、分组(group by)、关联(Joining)，Pig也可以由用户自定义一些函数对数据集进行操作，也就是传说中的UDF(user-defined functions)。
	经过Pig Latin的转换后变成了一道MapReduce的作业，通过MapReduce多个线程，进程或者独立系统并行执行处理的结果集进行分类和归纳。Map() 和 Reduce() 两个函数会并行运行，即使不是在同一的系统的同一时刻也在同时运行一套任务，当所有的处理都完成之后，结果将被排序，格式化，并且保存到一个文件。Pig利用MapReduce将计算分成两个阶段，第一个阶段分解成为小块并且分布到每一个存储数据的节点上进行执行，对计算的压力进行分散，第二个阶段聚合第一个阶段执行的这些结果，这样可以达到非常高的吞吐量，通过不多的代码和工作量就能够驱动上千台机器并行计算，充分的利用计算机的资源，打消运行中的瓶颈。
	所以用Pig可以对TB级别海量的数据进行查询非常轻松，并且这些海量的数据都是非结构化的数据，例如：一堆文件可能是log4j输出日志存又放于跨越多个计算机的多个磁盘上，用来记录上千台在线服务器的健康状态日志，交易日至，IP访问记录，应用服务日志等等。我们通常需要统计或者抽取这些记录，或者查询异常记录，对这些记录形成一些报表，将数据转化为有价值的信息，这样的话查询会较为复杂，此时类似MySQL这样的产品就并非能满足我们的对速度、执行效率上的需求，而用Apache的Pig就可以帮助我们去实现这样的目标。
	反之，你如果在做实验的时候，把MySQL中的100行数据转换成文本文件放在在pig中进行查询，会让你非常失望，为何这短短的100行数据查询的效率极低，呵呵，因为中间有一个生成MapReduce作业的过程，这是无法避免的开销，所以小量的数据查询是不适合pig做的，就好比用关二哥的大刀切青菜一样。另外，还可以利用Pig的API在Java环境中调用，对Apache的Pig以上内容请允许我这样片面的理解，谢谢。
	&#160;
	二、基本架构
	&#160;
	从整体上来看大量的数据聚集在HDFS系统上，通过输入类似SQL的脚本简化对MapReduce的操作，让这几行代码/脚本去驱动上千台机器进行并行计算。
	如图所示：
	

	Pig的实现有5个主要的部分构成：
	如图所示：
	
	1.Pig自己实现的一套框架对输入、输出的人机交互部分的实现，就是Pig Latin 。
	2.Zebra是Pig与HDFS/Hadoop的中间层、Zebra是MapReduce作业编写的客户端，Zerbra用结构化的语言实现了对hadoop物理存储元数据的管理也是对Hadoop的数据抽象层，在Zebra中有2个核心的类 TableStore(写)/TableLoad(读)对Hadoop上的数据进行操作。
	3.Pig中的Streaming主要分为4个组件: 1. Pig Latin 2. 逻辑层(Logical Layer) 3. 物理层(Physical Layer) 4. Streaming具体实现(Implementation)，Streaming会创建一个Map/Reduce作业，并把它发送给合适的集群，同时监视这个作业的在集群环境中的整个执行过程。 
	4.MapReduce在每台机器上进行分布式计算的框架(算法)。
	5.HDFS最终存储数据的部分。
	三、与Hive对比
	请允许我很无聊的把飞机和火车拿来做比较，因为2者根本没有深入的可比性，虽然两者都是一种高速的交通工具，但是具体的作用范围是截然不同的，就像Hive和Pig都是Hadoop中的项目，并且Hive和pig有很多共同点，但Hive还似乎有点数据库的影子，而Pig基本就是一个对MapReduce实现的工具(脚本)。两者都拥有自己的表达语言，其目的是将MapReduce的实现进行简化，并且读写操作数据最终都是存储在HDFS分布式文件系统上。看起来Pig和Hive有些类似的地方，但也有些不同，来做一个简单的比较，先来看一张图：
	
	查看大图请点击这里
再让我说几句废话：
	Language
	在Hive中可以执行&#160; 插入/删除 等操作，但是Pig中我没有发现有可以 插入 数据的方法，请允许我暂且认为这是最大的不同点吧。
	Schemas
	Hive中至少还有一个&#8220;表&#8221;的概念，但是Pig中我认为是基本没有表的概念，所谓的表建立在Pig Latin脚本中，对与Pig更不要提metadata了。 
	Partitions
	Pig中没有表的概念，所以说到分区对于Pig来说基本免谈，如果跟Hive说&#8220;分区&#8221;(Partition)他还是能明白的。
	Server
	Hive可以依托于Thrift启动一个服务器，提供远程调用。 找了半天压根没有发现Pig有这样的功能，如果你有新发现可以告诉我，就好像有人开发了一个Hive的REST 
	Shell
	在Pig 你可以执行一些个 ls 、cat 这样很经典、很cool的命令，但是在使用Hive的时候我压根就没有想过有这样的需求。
	Web Interface
	Hive有，Pig无
	JDBC/ODBC
	Pig无，Hive有
	
	四、使用
	1启动/运行&#160; 
	分为2台服务器,一台作为pig的服务器，一台作为hdfs的服务器。
	首先需要在pig的服务器上进行配置，将pig的配置文件指向hdfs服务器，修改pig/conf目录下的
	&#160;vim /work/pig/conf/pig.properties
	&#160;添加以下内容：
	fs.default.name=hdfs://192.168.1.201:9000/&#160;&#160;&#160; #指向HDFS服务器
	mapred.job.tracker=192.168.1.201:9001&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; #指向MR job服务器地址
	如果是第一次运行请在Hadoop的HDFS的服务器上创建root目录，并且将etc目录下的passwd文件放在HDFS的root目录下，请执行以下两条命令。
	hadoop fs -mkdir /user/root
	hadoop fs -put /etc/passwd [...]]]></description>
		<link>http://www.javabloger.com/article/apache-pig-hive-mapreduce-piglatin.html?source=rss</link>
			</item>
	<item>
		<title>Google与Yahoo的那些利器</title>
		<description><![CDATA[&#160;&#160; 在Google还没有出世之前Yahoo绝对是互联网中的大佬，Google没有出世之前也没有人怀疑过能有谁能动摇Yahoo在互联网中的大佬的地位，Google的问世对于Yahoo来说是噩梦的开始，特别是在互联网搜索领域中Google不仅仅在运营模式还是在技术上都领先于Yahoo，还创出了PangRank的算法，成为今天业内的一项标准。
	&#160;&#160; 对于Google简单搜索的页面而言后端服务器数量是超级庞大的，有最新统计资料显示Google全球的计算机数量加起来有1000w台，这样的一个庞大而复杂的计算系统，当然是要有一套强大的体系支撑，其中最最著名的就是Google的文件系统简称GFS(Google File System)，在这个GFS上存放了Google所有的数据，例如：你Gmail中的数据就放在上面了跑着。目前据Google保守估计有200个的GFS集群，其中有些集群的服务器数量超过5000台。
	&#160;&#160; 在Yahoo默认了若干年后，一个小孩在纸上画了一个大象，激发了Doug Cutting这位大牛人的灵感，决定采用他儿子画的那只小象作为Hadoop项目的吉祥物， Doug Cutting是 Lucene 的创始人，也是Hadoop项目的创始人， Doug Cutting创造的Hadoop是一个用Java语言实现的软件框架，他在看了Google的几篇论文以后就在硬生生的把Google这些牛x的分技术都山寨了一把， 例如：HDFS类似Google的GFS，HBase类似Google的BigTable，Zookeeper类似Google的Chubby，pig类似Google的Sawzall。我列了一下Google被Yahoo 和 Doug Cutting 山寨的产品列表，如图所示：
	
	 查看大图请点击这里
	通过Hadoop的开源项目对分布式计算进行简化可以让更多的人可以体验到分布式计算和云计算的快乐和价值，在此向Doug Cutting致敬。
	&#160;
相关文章:
	Hbase入门6 -白话MySQL(RDBMS)与HBase之间  
	Lily-建立在HBase上的分布式搜索  
	MySQL向Hive/HBase的迁移工具  
	HBase入门5(集群) -压力分载与失效转发  
	Hive入门3&#8211;Hive与HBase的整合  
	HBase入门篇4  
	HBase入门篇3  
	HBase入门篇2-Java操作HBase例子  
	HBase入门篇 
	基于Hbase存储的分布式消息(IM)系统-JABase 
	&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/hdfs-mahout-mapreduce-pig-hbase-zookeeper.html?source=rss</link>
			</item>
	<item>
		<title>HBase入门5(集群) -压力分载与失效转发</title>
		<description><![CDATA[在上一篇关于HBase的文章中曾经讲述过HBase在分布式中的架构，这篇文章将会讲述HBase在分布式环境中是如何排除单点故障的(SPFO)，做一个小实验讲述HBase在分布式环境中的高可用性，亲眼看到一些现象，延伸一些思考的话题。
	先来回顾一下HBase主要部件：
	&#160;&#160; 1.HBaseMaster&#160; 
	&#160;&#160; 2.HRegionServer 
	&#160;&#160; 3.HBase Client
	&#160;&#160; 4.HBase Thrift Server
	&#160;&#160; 5.HBase REST Server
	HBaseMaster
	&#160;&#160;&#160; HMaster 负责给HRegionServer分配区域,并且负责对集群环境中的HReginServer进行负载均衡，HMaster还负责监控集群环境中的HReginServer的运行状况，如果某一台HReginServer down机，HBaseMaster将会把不可用的HReginServer来提供服务的HLog和表进行重新分配转交给其他HReginServer来提供，HBaseMaster还负责对数据和表进行管理，处理表结构和表中数据的变更，因为在 META 系统表中存储了所有的相关表信息。并且HMaster实现了ZooKeeper的Watcher接口可以和zookeeper集群交互。
	HRegionServer
	&#160;&#160;&#160; HReginServer负责处理用户的读和写的操作。HReginServer通过与HBaseMaster通信获取自己需要服务的数据表，并向HMaster反馈自己的运行状况。当一个写的请求到来的时候，它首先会写到一个叫做HLog的write-ahead log中。HLog被缓存在内存中，称为Memcache，每一个HStore只能有一个Memcache。当Memcache到达配置的大小以后，将会创建一个MapFile，将其写到磁盘中去。这将减少HReginServer的内存压力。当一起读取的请求到来的时候，HReginServer会先在Memcache中寻找该数据，当找不到的时候，才会去在MapFiles 中寻找。
	HBase Client
	&#160;&#160;&#160; HBase Client负责寻找提供需求数据的HReginServer。在这个过程中，HBase Client将首先与HMaster通信，找到ROOT区域。这个操作是Client和Master之间仅有的通信操作。一旦ROOT区域被找到以后，Client就可以通过扫描ROOT区域找到相应的META区域去定位实际提供数据的HReginServer。当定位到提供数据的HReginServer以后，Client就可以通过这个HReginServer找到需要的数据了。这些信息将会被Client缓存起来，当下次请求的时候，就不需要走上面的这个流程了。
	HBase服务接口
	&#160;&#160;&#160; HBase Thrift Server和HBase REST Server是通过非Java程序对HBase进行访问的一种途径。
	&#160;
进入正题
	
先来看一个HBase集群的模拟环境，此环境中一共有4台机器，分别包含 zookeeper、HBaseMaster、HReginServer、HDSF 4个服务，为了展示失效转发的效果HBaseMaster、HReginServer各有2台，只是在一台机器上即运行了HBaseMaster，也运行了HReginServer。
	注意，HBase的集群环境中HBaseMaster只有失效转发没有压力分载的功能，而HReginServer即提供失效转发也提供压力分载。
	服务器清单如下：
	&#160;&#160;&#160; 1、zookeeper&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160; 192.168.20.214
	&#160;&#160;&#160; 2、HBaseMaster&#160;&#160;&#160; &#160;&#160;&#160;&#160; 192.168.20.213/192.168.20.215
	&#160;&#160;&#160; 3、HReginServer&#160;&#160;&#160; &#160; &#160;&#160; 192.168.20.213/192.168.20.215
	&#160;&#160;&#160; 4、HDSF&#160;&#160;&#160; &#160;&#160;&#160; &#160; &#160; &#160; &#160; &#160; &#160; &#160;&#160; &#160; 192.168.20.212
	整个模拟环境的架构如图所示：
	
	注意，这里只是做了一个模拟环境，因为这个环境的重点是HBase，所以zookeeper和HDFS服务都是单台。 [...]]]></description>
		<link>http://www.javabloger.com/article/hbase-cluster-replication.html?source=rss</link>
			</item>
	<item>
		<title>我爱折腾&#8211;PC上的苹果操作系统</title>
		<description><![CDATA[家里闲置几块硬盘闲着也是闲着，安了一个苹果的操作系统，为了安装驱动折腾了几天，最后还是搞定了。穷人也算是体验了一把贵族的操作系统，日后买了mac book能很快的适应过来。还装了一大推软件 QQ、MSN、MSOffice 、RSS阅读器 等等，总之一大堆玩意，不过用起来还真的不是非常适应，囧啊。
高清无码的屏幕截图

还有2张照片，（请忽略我贴在书桌上乱写乱画的小纸片。。。）

 


配置：GIGABYTE GA-G31M-ES2C主板(声卡/显卡集成)、3G内存、250G硬盘、Dell 19寸的显示器+Dell键盘鼠标。
&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/pc-install-macosx.html?source=rss</link>
			</item>
	<item>
		<title>Apache的XML-RPC简化你的WebService应用</title>
		<description><![CDATA[&#160;&#160; 在商谈需求的过程中客户非常期待很快的能看到产品的原型，这样可以对他们公司高层进行演示，促进2个公司项目合作的进展。如果在开发的过程中采用实际系统架构中技术去实现不太实际，所以我想到了一个简单的方式来满足客户的要求，采用 Apache的XML-RPC 对多个模块之间通讯，并且不需要自己去定义XML协议，也无需定义无序的URL参数传递，因为这一切都由 Apache的XML-RPC中现成的xml传输协议实现了。虽然采用Apache XML-RPC的方式实现整个功能比较简单，但在原型中可以满足我们和客户想要达到的效果。
	&#160; 说白了XML-RPC其实就是一个通过xml协议实现的远程方法调用，XML-RPC的全称是XML Remote Procedure Call，在我看来是一个非常简单的WebService的实现，只要在服务端自己写一个类，构造一个方法，实现自己需要的业务逻辑，再通过一个配置文件指明其中映射的关系，例如：配置文件中的Calculator=com.demo.xmlrpc.DataHandler描述，客户端指明在服务端配置文件需要调用的对象名称和方法名称即可进行数据传输和通讯了，这种远程过程调用使用http作为传输协议，XML作为传送信息的编码格式。Xml-RPC的定义尽可能的保持了简单，但同时能够传送、处理、返回复杂的数据结构。原理如图所示：
	
服务端代码示例：
	WebServer webServer = new WebServer(8080);
	XmlRpcServer xmlRpcServer = webServer.getXmlRpcServer();
	PropertyHandlerMapping phm = new PropertyHandlerMapping();
	phm.load(Thread.currentThread().getContextClassLoader(), &#34;DataHandlers.properties&#34;);

	 客户端代码示例：
	XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
	config.setServerURL(new URL(&#34;http://127.0.0.1:8080&#34;));
	XmlRpcClient client = new XmlRpcClient();
	client.setConfig(config);
	List&#60;String&#62; list = new ArrayList&#60;String&#62; (); 
	list.add( &#34;data1&#34; );list.add( &#34;data2&#34; );list.add( &#34;data3&#34; );
	Object result = client.execute(&#34;Calculator.getRequestData&#34;, new Object[]{list&#160;&#160; } );

	 业务逻辑代码示例：
	public int getRequestData( List&#60;String&#62; [...]]]></description>
		<link>http://www.javabloger.com/article/apache-xml-rpc-webservice.html?source=rss</link>
			</item>
	<item>
		<title>因为难，才好玩</title>
		<description><![CDATA[&#160; 公司接到一个项目，要我上周日去公司加班，与全球最大的手机制造商进行需求讨论，开发一套新产品。对方来了3人，其中一个是德国人，见面之前我了解过这位仁兄的一些信息，Google上显示他在移动通讯/计算领域是响当当的技术大牛，那天说起话来也是牛逼闪闪，他那个来势的凶猛。
	&#160; 这也让我感受到国内工程师和国外技术水平的差距有多么的大，并非1公里和2公里之间的差距，而是十万八千里。我实话实说，并非夸大其词，因为他曾经做的事情，的确有些价值，因为他是在创造，而不是在制造，他在用一行行代码创造了一些个规则，而我们在用一行行代码执行他的规则，这也不能去忽略是我们的教育体质的不同，导致我们目前所处现状的不同，请容许我这样的为自己去辩解一下。
	立场
	&#160;&#160;&#160; 大公司找我们做生意，必然是一笔大买卖，无论是公司还是我自己对这个项目的重视程度都很高，丝毫不敢怠慢整个人和整个事。而对方希望通过技术大牛给我们1-2次的播种 能很快的看见做出东东，对于时间概念完全等同于金钱。
	沟通
	&#160;&#160;&#160; 外国人也好，外企也罢，就是让你觉得沟通起来比较简单，1和0，黑和白，讲究的就是效率，不会跟你绕什么弯子。看的就是你的执行力。
	&#160;&#160;&#160; &#160;&#160;&#160; 
	迎战
	&#160;&#160;&#160; 兄弟们个个都是铁打的，让我感觉到没人愿意闲着，都在加班加点的做技术预研，系统分析，风险评估，不亦乐乎。
	借兵
	&#160;&#160;&#160; Oh，No！不是我向其他部门的兄弟借兵，是其他部门的兄弟向过来借兵，上头的旨意，一个字借！没有什么话多问的。
	&#160;
	牛逼闪闪的大牛，牛逼闪闪的客户，我们能做出牛逼闪闪的产品乎？拭目以待吧。
&#160;
口水：
	&#160;&#160; 以本职工作为主，只好放慢关于Hadoop项目的研究了。
	&#160;
最后，再来一个跟项目有关小科普 ：闪信。
&#160;
以上内容，纯属虚构，如同雷同，纯属巧合。
	

	&#8211;end&#8211;
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/as-difficult-just-fun.html?source=rss</link>
			</item>
	<item>
		<title>Hive入门3&#8211;Hive与HBase的整合</title>
		<description><![CDATA[开场白：
	Hive与HBase的整合功能的实现是利用两者本身对外的API接口互相进行通信，相互通信主要是依靠hive_hbase-handler.jar工具类 (Hive Storage Handlers)， 大致意思如图所示：
	
	口水：
	&#160;对 hive_hbase-handler.jar 这个东东还有点兴趣，有空来磋磨一下。
	一、2个注意事项：
	1、需要的软件有 Hadoop、Hive、Hbase、Zookeeper，Hive与HBase的整合对Hive的版本有要求，所以不要下载.0.6.0以前的老版本，Hive.0.6.0的版本才支持与HBase对接，因此在Hive的lib目录下可以看见多了hive_hbase-handler.jar这个jar包，他是Hive扩展存储的Handler ，HBase 建议使用 0.20.6的版本，这次我没有启动HDFS的集群环境，本次所有测试环境都在一台机器上。
	&#160;&#160; &#160; 
	2、运行Hive时，也许会出现如下错误，表示你的JVM分配的空间不够，错误信息如下：
	Invalid maximum heap size: -Xmx4096m
	The specified size exceeds the maximum representable size.
	Could not create the Java virtual machine.
	解决方法：
	/work/hive/bin/ext# vim util/execHiveCmd.sh 文件中第33行
	修改，
	HADOOP_HEAPSIZE=4096
	为
	HADOOP_HEAPSIZE=256
	另外，在 /etc/profile/ 加入 export $HIVE_HOME=/work/hive
	二、启动运行环境
	1启动Hive
	hive &#8211;auxpath /work/hive/lib/hive_hbase-handler.jar,/work/hive/lib/hbase-0.20.3.jar,/work/hive/lib/zookeeper-3.2.2.jar -hiveconf hbase.master=127.0.0.1:60000
	加载 Hive需要的工具类，并且指向HBase的master服务器地址，我的HBase master服务器和Hive运行在同一台机器，所以我指向本地。
	2启动HBase
	/work/hbase/bin/hbase master start 
	3启动Zookeeper
	/work/zookeeper/bin/zkServer.sh start
	三、执行
	在Hive中创建一张表，相互关联的表
	CREATE TABLE hbase_table_1(key int, value string) STORED BY &#39;org.apache.hadoop.hive.hbase.HBaseStorageHandler&#39; [...]]]></description>
		<link>http://www.javabloger.com/article/apache-hadoop-hive-hbase-integration.html?source=rss</link>
			</item>
	<item>
		<title>Apache Hive入门2</title>
		<description><![CDATA[我的偏见:
	&#160; 对于互联网公司来说提炼挖掘生产中用户产生的大量日志是个有价值的工作，在这些看似垃圾东西中蕴含着大量的商业机会和用户的需求，如果可以简单的实现当然皆大欢喜，但是面对庞大的输出日志需要去提炼的时候只好束手无则无视他的存在，就拿我们最熟悉的Log4J来说，如果是上TB的海量文本类型输出的格式根本无法查询，更谈不上数据挖掘。
	&#160;&#160; 当然我们也知道存放在数据库里面当然是不错的选择，对抗海量的日志数据存储与查询坚持做下去的话最后换来的是高昂的代价，Hive借助MapReduce的计算+HDFS的海量存储的功能，对与海量的日志存储、查询，数据挖掘Hive也是个不错的选择，在功能上和总体成本上高于刚刚所说的前两者。
	&#160;&#160; 但是对与存储在其他类型的NOSQL产品，Hive投入正式生产的环境我们还需要进一步的分析与比较，例如：MongoDB vs Hive，这个2个产品对于海量日志数据挖掘的性能与系统的扩展性来说谁将会比谁更胜一筹喃？因为 MongoDB 中也是支持海量级分布式存储，并且MongoDB也支持了MapReduce算法，这样我就需要为此得出一个结论，或者说我需要一个折中的方案，但不是现在。
	&#160;
	&#160;&#160; Hive 中不支持对数据的改写和添加，所有的数据都是在加载的时候中确定好的。Hive中你添加了数据就无法删除的，SQL的fans们是不是很费解？我是这样认为的就拿Google的Google Analytics分析工具为例子，在Google Analytics分析工具 会有对日志进行删除的操作吗？答案是&#8220;NO!&#8221;，也许在Hive设计的时候Facebook的工程师就认为对需要进行挖掘的数据删除是一项没有必要的工作，Hive在Facebook能成功，并且运行在上千台的节点上 或许就是Facebook工程师们明确了Hive不去做的事情，让Hive只做好那一部分事情。
以上是我对 Hive Why(为什么使用Hive)片面的观点。
	&#160;
集群中的Hive
	Hive的失效转发可以设计成这样的，将元数据和存储的数据分别保存在同一个位置，如图所示：
	
多个Hive的物理节点连接到相同的数据库和HDFS环境,防止Hive Thrift Server单点失效(SPFO)问题。
	将Hive的MetaData 存储在 MySQL中，MySQL的运行环境支持双向同步或者集群，这样至少2台数据库服务器上热备份着Hive的元数据存储,例如:
	&#60;property&#62;
	&#160; &#60;name&#62;javax.jdo.option.ConnectionURL&#60;/name&#62;
	&#160; &#60;value&#62;jdbc:mysql://192.168.1.203:3306/hive?createDatabaseIfNotExist=true&#60;/value&#62;
	&#60;/property&#62;
	多个物理Hive节点的数据内容保存在HDFS上，通过修改 hive-default.xml 配置 文件，指向NameNode节点即可，例如：
	&#60;property&#62;
	&#160; &#60;name&#62;hive.metastore.warehouse.dir&#60;/name&#62;
	&#160;&#160; &#60;value&#62;hdfs://serv1:9000/user/hive/warehouse&#60;/value&#62;
	&#160;&#160; &#60;!&#8211; &#60;value&#62;/user/hive/warehouse&#60;/value&#62; &#8211;&#62;
	&#160; &#60;description&#62;location of default database for the warehouse&#60;/description&#62;
	&#60;/property&#62;

	Hive 与 Log4J 
	在Hive中建一张表叫user_log，里面含有4个字段，以\t划分，一行一条数据，建表的脚本如下：
	CREATE TABLE USER_LOG(DateInfo STRING,LogName STRING,LogLevel STRING,MSG STRING)
	ROW FORMAT DELIMITED FIELDS TERMINATED BY &#39;\t&#39; LINES TERMINATED BY [...]]]></description>
		<link>http://www.javabloger.com/article/apache-hive-2.html?source=rss</link>
			</item>
	<item>
		<title>Apache Hive入门1</title>
		<description><![CDATA[&#160;&#160; Hive是Hadoop项目中的一个子项目，由FaceBook向Apache基金会贡献，其中TaoBao也是其中一位使用者+贡献者，Hive被视为一个仓库工具，可以将结构化的数据文件映射为一张数据库表，并可以将sql语句转换为 MapReduce 任务进行运行。 其优点是学习成本低，可以通过类SQL语句快速实现简单的MapReduce统计，不必开发专门的MapReduce应用，十分适合数据仓库的统计分析。 
	&#160; 
	Hive主要分为以下几个部分：
	&#160;&#160;&#160; 1.用户接口 
	&#160;&#160;&#160; &#160;&#160; 用户接口主要有三个：命令行(CLI)，客户端(Client) 和 Web界面(WUI)。其中最常用的是 CLI，启动的时候，会同时启动一个 Hive 服务。Client 是 Hive 的客户端，用户连接至 Hive Server。在启动 Client 模式的时候，需要指出 Hive Server 所在节点，并且在该节点启动 Hive Server。 WUI 是通过浏览器访问 Hive的Web工具。
	&#160;&#160; 2.元数据存储 
	&#160;&#160;&#160; &#160;&#160; Hive 将元数据存储在数据库中，如 MySQL或者Derby嵌入式数据库。若将元数据存储在MySQL中，在TBLS中可以看见你建立的所有表信息，Hive 中的元数据包括表的名字，表的列和分区及其属性，表的属性(是否为外部表等)，表的数据所在目录等。
	&#160;&#160; 3. 执行
	&#160;&#160;&#160; 解释器、编译器、优化器完成 HQL 查询语句从词法分析、语法分析、编译、优化以及查询计划的生成。生成的查询计划存储在 HDFS 中，并在随后有 MapReduce 调用执行。
	&#160;&#160; 4. HDFS存储
	&#160;&#160;&#160; Hive 的数据存储在 HDFS 中，大部分的查询由 MapReduce 完成（包含 [...]]]></description>
		<link>http://www.javabloger.com/article/apache-hive-jdbc-mapreduce.html?source=rss</link>
			</item>
	<item>
		<title>Apache ZooKeeper入门3</title>
		<description><![CDATA[开场白：
	&#160; 在上一篇关于介绍Zookeeper的文章中有同学给我留言，说到Zookeeper/Hbase/Hadoop三者之间的关系，在此我把三者之间的关系画在一张图上希望能表达的清楚一些。

Zookeeper用来同步Hbase服务状态、监控集群防止单点失效
	HDFS是Hadoop中最核心的一部分,用来对Hbase的数据进行存储
1、Zookeeper客户端与服务端的大致结构
	&#160;&#160; 服务端
	&#160;&#160;&#160; Zookeeper还是属于一个C/S的架构的应用服务，Zookeeper的服务器端分为2种运行模式：单台和集群多台的运行模式，通过conf/zoo.cfg中的配置判定你启用的运行模式，以及在群集模式中数据同步和心跳的频率等等。
	&#160;&#160; Zookeeper集群中的Leader和Follower之间的选举通过Paxos算法来实现的，它是一个基于消息传递的一致性算法，这里讲述了http://zh.wikipedia.org/zh-cn/Paxos算法，传说中Paxos算法是分布式一致性算法中最有效的一种算法。
	口水:在源代码中的通讯部分看见了大量采用NIO和concurrent的代码(例如:LinkedBlockingQueue/AtomicLong)。
	&#160; 客户端
	ZooKeeper的Client由三个主要模块组成：
	Zookeeper
	&#160;&#160;&#160; Zookeeper是最主要的类，可以写入一个或者多个Zookeeper的服务器地址，例如：&#34;127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002&#34; ，当你new Zookeeper( &#8230;.)的时候会有两个线程被创建：SendThread和EventThread，会在Server端创建大量的Session。
	WatcherManager
	&#160;&#160;&#160; 在Zookeeper类中还有一个WatcherManager，用来管理Watcher的，Watcher是ZK的一大特色功能，允许多个Client对一个或多个 ZNode进行监控，当ZNode有变化时能够通知到监控这个ZNode的各个Client，管理了ZK Client绑定的所有Watcher。
	ClientCnxn
	&#160;&#160;&#160; 在Zookeeper类中还包含了对ClientCnxn类的调用，ClientCnxn这个类管理所有对Zookeeper服务器端的网络通讯，服务端和客户端所有交互的数据都要调用这个类，包括给ZK Server发送Request，从ZK Server接受Response，以及从ZK Server接受Watcher Event。
2、服务端运行模式
	服务端单机模式
	&#160;&#160;&#160; zoo.cfg文件配置参数详解
	&#160;&#160;&#160; # 这个时间是被用来做服务器之间或客户端与服务器心跳和最低会话超时时间的基数。
	&#160;&#160;&#160; tickTime=2000
	&#160;&#160;&#160; # 存储在内存中数据快照的目录。
	&#160;&#160;&#160; dataDir=d:/zookeeperdata/1
	&#160;&#160;&#160; # 服务器端开启的监听端口，用来接受客户端访问请求的端口。
	&#160;&#160;&#160; clientPort=2181
	服务端集群模式
	&#160;&#160;&#160; 配置参数详解
	&#160;&#160;&#160; &#160;#Zookeeper服务器集群中连接到Leader与Follower 服务器少次心跳时间间隔数，以及最大通讯的超时时间，总时间为 5(initLimit)*2000(tickTime)=10 秒。
	&#160;&#160;&#160; &#160;initLimit=5 
	&#160;&#160;&#160; &#160;#Leader与Follower间请求/应答时间长度,这里总时间长度就是 2(syncLimit)*2000(tickTime)=4 秒。
	&#160;&#160;&#160; &#160;syncLimit=2 
	&#160;&#160;&#160; &#160;#server是固定配置，1和2表示这个是第几号服务器，2888:3888表示服务器与集群中的 Leader 服务器的通讯端口。
	&#160;&#160;&#160; &#160;server.1=192.168.1.1:2888:3888 
	&#160;&#160;&#160; &#160;server.2=192.168.1.2:2888:3888 
	另外，集群模式下还要在 dataDir 目录下创建一个myid文件，这个文件中写入的内容就是一个数字，这个数字就是和server.x中的x这个数字对应，Zookeeper 启动时会读取这个文件判定自己是谁，myid文件的编码格式是ANSI。
	&#160;
相关文章：
	Apache ZooKeeper入门2  
	Apache Zookeeper入门1 
&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/apache-zookeeper-hbase-hadoop-3.html?source=rss</link>
			</item>
	<item>
		<title>第三期 “迷你书”(PDF) –JMS与消息中间件</title>
		<description><![CDATA[读物封面：

内容提要：
&#160;&#160; 本期内容主要对JavaEE中的JMS话题进行讲述，其中一些文章是我们经过了很多错/败与大量的测试总结出的经验和心得，所以拿来与大家分享。
	&#160;&#160; 在大型系统中不仅仅要考虑JMS服务器端或者JMS客户端消息收/发的效率和性能，在系统架构设计方面还需要考虑到JMS服务器的可扩展性、伸缩性、容错性。在设计时如何巧妙的将JMS的性能提高，如何充分发挥JMS所有的功能，如何提高JMS服务器的容错能力 等等，都是我们一线架构师们需要思考的话题。
	&#160;&#160; 对于JMS服务器的每一项参数必须在投入使用前理解的明明白白，做到一旦出现关于JMS的问题能迅速定位，提供开发团队解决问题的明确思路。我在此感谢我们技术团队的所有同仁，没有你们的投入与陪伴，不会让我有机会遇见各种形形色色的问题，也不会让我对JMS产品去深入的了解与提高。
	&#160;
下载地址: 
	http://javabloger-mini-books.googlecode.com/files/Java-JMS-Javabloger-mini-book.pdf
	
其他资源:
	http://code.google.com/p/javabloger-mini-books/downloads/list
	
	
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/java-jms-mini-pdf-3.html?source=rss</link>
			</item>
	<item>
		<title>Hadoop与Facebook</title>
		<description><![CDATA[&#160; Hadoop 是当今在分布式/并行计算中最流行的开源工具，他不仅仅可以用于存储的分布式文件系统，可以用来构建大量集群计算机用来大规模的数据集分布式存储和存档处理。目前Yahoo在Hadoop上的贡献占了很大的一部分，关键是Yahoo贡献给Hadoop社区的是Yahoo全部的研究成果。
口水：
	Hive数据仓库工具是Hadoop中的一个子项目，Hadoop中的子项目还包括Zookeeper分布式锁，提供类似Google Chubby的功能，我在前面几篇文章中也有提到过关于Zookeeper的应用 ，在Hadoop大型计算中Zookeeper与他们密不可分。
	&#160;&#160; Facebook是Hadoop的忠实用户和贡献源码的参与者，并且Facebook还贡献了Hive和Thrift两个重要Hadoop组件，目前已经收入在Apache的Hadoop的子项目中，Hive是基于 Hadoop DFS的 adhoc query system，定义了HQL语言，基于MapReduce实施查询但是别指望性能有多么的高，Thrift是Hadoop的跨语言接口，可以支持多种语言，例如php和ruby。
	&#160; 除了Yahoo!和FaceBook两大站点在大量使用超过10,000个微处理器核心的Linux计算机集群运行Hadoop，还有A9.com、 IBM 、 ImageShack、 Last.fm、Powerset、 纽约时报 等 也在使用 Hadoop系统。
&#160;&#160; 在国内百度也是一个Hadoop的忠实用户，传说中百度的Hadoop的运行节点达到了2000个左右，并且采用SSD硬盘对Hadoop的数据进行存储。还有淘宝，在淘宝的数据库团队的博客上我看见过几篇介绍使用 Hive和Hadoop的经验分享，但是不知道他们的具体使用情况(或者我没有注意到)。
	&#160; Facebook目前全球用户数量有5亿，每天有超过一半以上的用户进行登录，每月处理超过250亿的信息内容其中包括用户状态更新，评论等，替代以前Oracle的RAC，Facebook从两个主要的数据源输入数据到Hadoop集群。他们使用开源的Scribe上传工具从Web集群载入数据，每10到15分钟就从成千上万的机器传输数据。他们每天还从系统记录载入数据，一个超过2000节点的MySQL联合集群。这些数据包括概要文件，好友信息，以及广告和广告推广信息。
&#160; 将来 FaceBook 会把数据库直接写到 Hive上，Hadoop和Hive 最基本的设计思想和传统数据库存储最大的不同是基于列的存储模式，这样可以让更多的开发人员去使用Hive系统。已知Facebook在DFS中存储的数据达到22T，目前肯定更大了。
	
	上面这张图告诉我们采用哪些组件是用来处理数据 ，显示了FaceBook对于Hadoop架构的基本组成部分和数据流。
&#160; Facebook的工程师邵铮(2008年3月加入facebook,现居加州) 介绍在2009年一次技术会议上说到，Facebook是采用 自主研发的 Hive 把用户每一个用户操作的行为习惯记录下来，便于Facebook内部分析师更好的从用户使用的行为习惯去分析用户需求，对于Hive/Hadoop的使用并不是意味着将会完全放弃原来传统的数据库(Oracle/MySQL)，而且把Hadoop/Hive看做是数据库仓库的和应用操作层的交集。据说现在在开发支持JDBC和ODBC的接口，我记得他当时说到：&#8220;Facebook计算节点上Hadoop节点有600个集群的节点，每个机器的2个CPU，将来会达到1000台节点&#8221;，这里有一个相关的视频介绍.
&#160; 今年五月份(2010/5)，一位Facebook工程师 Dhruba Borthakur 说到，&#8220;Facebook是当今使用Hadoop最大的用户了，这已经不是什么秘密&#8221;，并且公布了在Facebook使用Hadoop/HDFS 集群的一些详细信息：
	&#160;&#160;&#160; * 21 PB of storage in a single HDFS cluster
	&#160;&#160;&#160; * 12 TB per machine (a [...]]]></description>
		<link>http://www.javabloger.com/article/hadoop-and-facebook.html?source=rss</link>
			</item>
	<item>
		<title>JMS与Java消息中间件</title>
		<description><![CDATA[&#160;&#160; JMS是一种企业消息传送的API，并不是MOM消息中间件系统的全部，JMS也是一种规范，类似于JDBC，我们通JMS API访问 JMS的服务器。目前JMS服务器的主要产品有 IBM WebSphere MQ、SonicMQ、Sun Open MQ、BEA&#160; WebLogic&#160; JMS、Oracle AQ&#160; 以及 我们最常用的JBoss MQ 和 Apache的 ActiveMQ.。而JMS服务器是MQ(Message Queen)产品家族中的一种，Microsoft Message Queuing（mSMQ）也是MQ产品类似于JMS服务器。
JMS在J2EE系统中的应用场景
	
&#160;&#160; 异步消息比同步消息操作更加便利。在J2EE系统中最常见的一个场景，前端浏览器 jsp/servlet向服务器端发出一个请求，jsp/servlet将请求传递给后端的应用程序处理业务逻辑，业务模块将响应的结果直接返回给客户端，而不是真正的计算结果，例如一个网站的用户注册功能，一个用户点击注册以后，将会发送一份邮件给他当时的注册邮箱，如果需要等到邮件发送成功再返回给用户结果的话，用户体验将会很差，所以将结果直接返回给用户，将用户注册的信息通过消息发送给后端程序慢慢处理。

点击这里查看大图
	
谈到 JMS一词 大体上有 3个部分&#160; 1 消息发送端&#160; 2中间件服务器&#160; 3消息接收端&#160; 3个组件缺一不可。 JMS消息分为两种消息模式，点对点和发布者/订阅者。许多提供商支持这一因此，程序员可以在他们的分布式软件中实现面向消息的操作，这些操作将具有不同面向消息中间件产品的可移植性。
	&#160;

	
	
Java消息服务器是指，将数据通过消息作为载体在网络中从一个系统异步传送给另一个系统。这样的异步消息传送意味着：发送者不需要等待接收者接收或处理该消息；它可以自由地发送消息并持续进行处理。这样一个异步式的架构主要依赖于一台消息服务器（message server）。消息服务器，也称为消息路由器（message router）或代理（broker），它负责从一个消息传送客户端向其他消息传送客户端传送消息。
JMS对与一个大型系统是必不可少的一个应用组件，可以利用JMS来实现3个目的：
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; 1.提高可伸缩性(Increase Scalability),
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; 2.可以利用JMS来缓解系统瓶颈(Reduce&#160; Bottlenecks)
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; 3.提高系统对用户的响应能力
JMS公共API内部，和发送和接收JMS消息有关的JMS API接口常用的有7个：
	&#160;&#160;&#160; &#160;&#160;&#160; &#183;ConnectionFactory
	&#160;&#160;&#160; &#160;&#160;&#160; &#183;Destination
	&#160;&#160;&#160; &#160;&#160;&#160; &#183;Connection
	&#160;&#160;&#160; &#160;&#160;&#160; &#183;Session
	&#160;&#160;&#160; &#160;&#160;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/spring-jms-j2ee-middleware.html?source=rss</link>
			</item>
	<item>
		<title>Apache ZooKeeper入门2</title>
		<description><![CDATA[&#160;&#160; 记得在大约在2006年的时候Google出了Chubby来解决分布一致性的问题(distributed consensus problem)，所有集群中的服务器通过Chubby最终选出一个Master Server ，最后这个Master Server来协调工作。简单来说其原理就是：在一个分布式系统中，有一组服务器在运行同样的程序，它们需要确定一个Value，以那个服务器提供的信息为主/为准，当这个服务器经过n/2+1的方式被选出来后，所有的机器上的Process都会被通知到这个服务器就是主服务器 Master服务器，大家以他提供的信息为准。很想知道Google Chubby中的奥妙，可惜人家Google不开源，自家用。
	&#160; 但是在2009年3年以后沉默已久的Yahoo在Apache上推出了类似的产品ZooKeeper，并且在Google原有Chubby的设计思想上做了一些改进，因为ZooKeeper并不是完全遵循Paxos协议，而是基于自身设计并优化的一个2 phase commit的协议，如图所示：
	
	&#160; ZooKeeper跟Chubby一样用来存放一些相互协作的信息(Coordination)，这些信息比较小一般不会超过1M，在zookeeper中是以一种hierarchical tree的形式来存放，这些具体的Key/Value信息就store在tree node中，如图所示：
	
	当有事件导致node数据，例如：变更，增加，删除时，Zookeeper就会调用 triggerWatch方法，判断当前的path来是否有对应的监听者(watcher),如果有watcher，会触发其process方法，执行process方法中的业务逻辑，如图所示：
	&#160;
应用实例
	&#160;&#160; ZooKeeper有了上述的这些用途，让我们设想一下，在一个分布式系统中有这这样的一个应用：
	&#160;&#160;&#160;&#160; 2个任务工厂(Task Factory)一主一从，如果从的发现主的死了以后，从的就开始工作，他的工作就是向下面很多台代理(Agent)发送指令，让每台代理(Agent)获得不同的账户进行分布式并行计算，而每台代理(Agent)中将分配很多帐号，如果其中一台代理(Agent)死掉了，那么这台死掉的代理上的账户就不会继续工作了。
	上述，出现了3个最主要的问题：
	&#160;&#160;&#160; 1.Task Factory 主/从一致性的问题
	&#160;&#160;&#160; 2.Task Factory 主/从心跳如何用简单+稳定 或者2者折中的方式实现。
	&#160;&#160;&#160; 3.一台代理(Agent)死掉了以后，一部分的账户就无法继续工作，需要通知所有在线的代理(Agent)重新分配一次帐号。
	怕文字阐述的不够清楚，画了系统中的Task Factory和Agent的大概系统关系，如图所示：
	&#160;
	OK，让我们想想ZooKeeper是不是能帮助我们去解决目前遇到的这3个最主要的问题呢？
	解决思路
	1. 任务工厂Task Factory都连接到ZooKeeper上，创建节点，设置对这个节点进行监控，监控方法例如：
	&#160;&#160;&#160; event= new WatchedEvent(EventType.NodeDeleted, KeeperState.SyncConnected, &#34;/TaskFactory&#34;);
	&#160;&#160; 这个方法的意思就是只要Task Factory与zookeeper断开连接后，这个节点就会被自动删除。
	2.原来主的任务工厂断开了TCP连接，这个被创建的/TaskFactory节点就不存在了，而且另外一个连接在上面的Task Factory可以立刻收到这个事件(Event)，知道这个节点不存在了，也就是说主TaskFactory死了。
	3.接下来另外一个活着的TaskFactory会再次创建/TaskFactory节点，并且写入自己的ip到znode里面，作为新的标记。
	4.此时Agents也会知道主的TaskFactory不工作了，为了防止系统中大量的抛出异常，他们将会先把自己手上的事情做完，然后挂起，等待收到Zookeeper上重新创建一个/TaskFactory节点，收到 EventType.NodeCreated 类型的事件将会继续工作。
	5.原来从的TaskFactory 将自己变成一个主TaskFactory，当系统管理员启动原来死掉的主的TaskFactory，世界又恢复平静了。
	6.如果一台代理死掉，其他代理他们将会先把自己手上的事情做完，然后挂起，向TaskFactory发送请求，TaskFactory会重新分配(sharding)帐户到每个Agent上了，继续工作。
	上述内容，大致如图所示：
	
	口水：
	1.以上内容说的还不够好，希望能和有经验的同学们交流一下，说说你们在大规模计算中是如何解决分布式一致性的问题，谢谢
	2.大量了很多文章，最后的确是看了Hbase部分和zookeeper的源代码 有了点启发。
	http://hbase.apache.org/docs/r0.89.20100726/xref/org/apache/hadoop/hbase/master/ZKMasterAddressWatcher.html

	相关文章：
	Zookeeper入门1  
	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/zookeeper-hapood-apache.html?source=rss</link>
			</item>
	<item>
		<title>Apache Zookeeper入门1</title>
		<description><![CDATA[口水:Zookeeper是我目前接触过Apache开源系统中比较复杂的一个产品，要搞清楚这个东东里面的运作关系还真不是一时半会可以搞定的事，本人目前只略知皮毛之术。
	ZooKeeper 是什么？
&#160; ZooKeeper 顾名思义 动物园管理员，他是拿来管大象(Hadoop) 、 蜜蜂(Hive) 、 小猪(Pig)&#160; 的管理员， Apache Hbase和 Apache Solr 以及LinkedIn sensei&#160; 等项目中都采用到了 Zookeeper。ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，ZooKeeper是以Fast Paxos算法为基础，实现同步服务，配置维护和命名服务等分布式应用。
	&#160;
ZooKeeper 如何工作？
	&#160; ZooKeeper是作为分布式应用建立更高层次的同步(synchronization)、配置管理 (configuration maintenance)、群组(groups)以及名称服务(naming)。在编程上，ZooKeeper设计很简单，所使用的数据模型风格很像文件系统的目录树结构，简单来说，有点类似windows中注册表的结构，有名称，有树节点，有Key(键)/Value(值)对的关系，可以看做一个树形结构的数据库，分布在不同的机器上做名称管理。
	&#160;&#160; Zookeeper分为2个部分：服务器端和客户端，客户端只连接到整个ZooKeeper服务的某个服务器上。客户端使用并维护一个TCP连接，通过这个连接发送请求、接受响应、获取观察的事件以及发送心跳。如果这个TCP连接中断，客户端将尝试连接到另外的ZooKeeper服务器。客户端第一次连接到ZooKeeper服务时，接受这个连接的 ZooKeeper服务器会为这个客户端建立一个会话。当这个客户端连接到另外的服务器时，这个会话会被新的服务器重新建立。
	&#160;&#160; 启动Zookeeper服务器集群环境后，多个Zookeeper服务器在工作前会选举出一个Leader，在接下来的工作中这个被选举出来的Leader死了，而剩下的Zookeeper服务器会知道这个Leader死掉了，在活着的Zookeeper集群中会继续选出一个Leader，选举出leader的目的是为了可以在分布式的环境中保证数据的一致性。如图所示：
	
&#160; 另外，ZooKeeper 支持watch(观察)的概念。客户端可以在每个znode结点上设置一个观察。如果被观察服务端的znode结点有变更，那么watch就会被触发，这个watch所属的客户端将接收到一个通知包被告知结点已经发生变化。若客户端和所连接的ZooKeeper服务器断开连接时，其他客户端也会收到一个通知，也就说一个Zookeeper服务器端可以对于多个客户端，当然也可以多个Zookeeper服务器端可以对于多个客户端，如图所示：
	

	你还可以通过命令查看出，当前那个Zookeeper服务端的节点是Leader，哪个是Follower，如图所示：
	
	我通过试验观察到 Zookeeper的集群环境最好有3台以上的节点，如果只有2台，那么2台当中不管那台机器down掉，将只会剩下一个leader，那么如果有再有客户端连接上来，将无法工作，并且剩下的leader服务器会不断的抛出异常。内容如下：
	java.net.ConnectException: Connection refused
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; at sun.nio.ch.Net.connect(Native Method)
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; at sun.nio.ch.SocketChannelImpl.connect(SocketChannelImpl.java:507)
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; at java.nio.channels.SocketChannel.open(SocketChannel.java:146)
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; at org.apache.zookeeper.server.quorum.QuorumCnxManager.connectOne(QuorumCnxManager.java:347)
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; at org.apache.zookeeper.server.quorum.QuorumCnxManager.connectAll(QuorumCnxManager.java:381)
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; at org.apache.zookeeper.server.quorum.FastLeaderElection.lookForLeader(FastLeaderElection.java:674)
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; at org.apache.zookeeper.server.quorum.QuorumPeer.run(QuorumPeer.java:611)
	2010-11-15 00:31:52,031 &#8211; INFO&#160; [QuorumPeer:/0:0:0:0:0:0:0:0:2181:FastLeaderElection@683] &#8211; Notification time out: 12800
	并且客户端连接时还会抛出这样的异常，说明连接被拒绝，并且等待一个socket连接新的连接，这里socket新的连接指的是zookeeper中的一个Follower。
	org.apache.zookeeper.ClientCnxn$SendThread.startConnect(ClientCnxn.java:1000) [...]]]></description>
		<link>http://www.javabloger.com/article/apache-zookeeper-hadoop.html?source=rss</link>
			</item>
	<item>
		<title>ChukWa入门1</title>
		<description><![CDATA[Chukwa 是什么？
	&#160; 在印度神话中Chukwa是一只最古老的龟。它支撑着世界。在它的背上还支撑着一种叫做Maha-Pudma的大象，在大象的背上顶着这个地球。呵呵，大象？Hadoop？不难理解为什么在Hadoop中的这个子项目叫做Chukwa了，或许Chukwa的其中一位开发者是印度人？呵呵，我瞎猜的，神话中的Chukwa的，貌似是这样的，如图所示：
	
	&#160;Chukwa是由Yahoo贡献，基于Hadoop的大集群监控系统，可以用他来分析和收集系统中的数据(日志)。Chukwa运行HDFS中存储数据的收集器和MapReduce框架之上，并继承了Hadoop的可扩展性和鲁棒性， Chukwa使用MapReduce来生成报告，他还包括一个用于监测和分析结果显示的web-portal工具，通过web-portal工具使这个收集数据的更佳具有灵活性，这点有点像是类似 linux工具，例如：awk 。这几乎是一个日志处理/分析的full stack solution，国内用hadoop做日志分析的，或者将要做日志分析的可以关注下。
&#160;&#160; 搭建、运行Chukwa要在Linux环境下，要安装MySQL数据库，在Chukwa/conf目录 中有2个SQL脚本 aggregator.sql、database_create_tables.sq l 导入MySQL数据库，此外还要有Hadoo的HDSF运行环境，Chukwa的整个系统架构如图所示：
	&#160; 
	
	&#160;
Chukwa 由哪几个组件组成的？&#160; 
	&#160;&#160;&#160; Chukwa是Yahoo开发的Hadoop之上的数据采集/分析框架，主要用于日志采集/分析。该框架提供了采集数据的Agent，由Agent采集数据通过HTTP发送数据给Cluster的Collector，collector把数据sink进Hadoop，然后通过定期运行Map reducer来分析数据，将结果呈现给用户。
	Chukwa 有以下4个主要的组成部分:
	&#160;&#160;&#160; Agent 收集各服务器的数据
	&#160;&#160;&#160; Collectors 接收agent的数据;并写进存储
	&#160;&#160;&#160; MapReduce jobs&#160; 归档数据
	&#160;&#160;&#160; HICC 就是 Hadoop Infrastructure Care Center的四个英文单词的缩写，简单来说是个Web工程用于ChukWa的内容展示。&#160;
几个部件大致的处理流程如下：

	在这个Blog中后续会对ChukWa有进一步的描述，再次感谢你的阅读。

	&#8211;end&#8211;
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/hadoop-chukwa.html?source=rss</link>
			</item>
	<item>
		<title>上海路3号咖啡店的那些花儿(南京)</title>
		<description><![CDATA[
3号咖啡搬家了，老店新开张，一个以摄影为主题的咖啡店，样子很破，但很别致，咖啡的价格快赶上星巴克了。
	查看更多照片
	
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/%e5%8d%97%e4%ba%ac-%e4%b8%8a%e6%b5%b7%e8%b7%af-3%e5%8f%b7%e5%92%96%e5%95%a1.html?source=rss</link>
			</item>
	<item>
		<title>HBase入门篇4&#8211;存储</title>
		<description><![CDATA[在HBase中创建的一张表可以分布在多个Hregion，也就说一张表可以被拆分成多块，每一块称我们呼为一个Hregion。每个Hregion会保 存一个表里面某段连续的数据，用户创建的那个大表中的每个Hregion块是由Hregion服务器提供维护，访问Hregion块是要通过 Hregion服务器，而一个Hregion块对应一个Hregion服务器，一张完整的表可以保存在多个Hregion 上。HRegion Server 与Region的对应关系是一对多的关系。每一个HRegion在物理上会被分为三个部分：Hmemcache(缓存)、Hlog(日志)、 HStore(持久层)。]]></description>
		<link>http://www.javabloger.com/article/apache-hbase-hadoop.html?source=rss</link>
			</item>
	<item>
		<title>HBase入门篇3</title>
		<description><![CDATA[前两篇文件分别说到了我在学习HBase中的一些入门经验，而《HBase 入门3》这篇文章浅显的从几个方面谈谈HBase的一些优化技巧，只能作为我学习笔记的一部分，因为学多了怕忘，留给自己以后看看。
	1 修改 linux 系统参数 
	&#160;&#160;&#160; Linux系统最大可打开文件数一般默认的参数值是1024,如果你不进行修改并发量上来的时候会出现&#8220;Too Many Open Files&#8221;的错误，导致整个HBase不可运行，你可以用ulimit -n 命令进行修改，或者修改/etc/security/limits.conf 和/proc/sys/fs/file-max&#160; 的参数，具体如何修改可以去Google 关键字 &#8220;linux limits.conf &#8221;
	2JVM 配置&#160; 
	修改 hbase-env.sh 文件中的配置参数，根据你的机器硬件和当前操作系统的JVM(32/64位)配置适当的参数
	&#160;&#160;&#160; HBASE_HEAPSIZE 4000&#160;&#160; HBase使用的 JVM 堆的大小
	&#160;&#160;&#160; HBASE_OPTS&#160; &#34;‐server ‐XX:+UseConcMarkSweepGC&#34;JVM GC 选项
	&#160;&#160;&#160; HBASE_MANAGES_ZKfalse&#160;&#160; 是否使用Zookeeper进行分布式管理
	3 HBase持久化
	重启操作系统后HBase中数据全无，你可以不做任何修改的情况下，创建一张表，写一条数据进行，然后将机器重启，重启后你再进入HBase的shell中使用 list 命令查看当前所存在的表，一个都没有了。是不是很杯具？没有关系你可以在hbase/conf/hbase-default.xml中设置hbase.rootdir的值，来设置文件的保存位置指定一个文件夹 ，例如：&#60;value&#62;file:///you/hbase-data/path&#60;/value&#62;，你建立的HBase中的表和数据就直接写到了你的磁盘上，如图所示：
	同样你也可以指定你的分布式文件系统HDFS的路径例如: hdfs://NAMENODE_SERVER:PORT/HBASE_ROOTDIR，这样就写到了你的分布式文件系统上了。
	4配置HBase运行参数 
	其次就需要对hbase/conf/hbase-default.xml 文件进行配置，以下是我认为比较重要的配置参数
	hbase.client.write.buffer&#160;&#160;&#160; 
	描述：这个参数可以设置写入数据缓冲区的大小，当客户端和服务器端传输数据，服务器为了提高系统运行性能开辟一个写的缓冲区来处理它， 这个参数设置如果设置的大了，将会对系统的内存有一定的要求，直接影响系统的性能。
	hbase.master.meta.thread.rescanfrequency&#160; 
	描述：多长时间 HMaster对系统表 root 和 meta 扫描一次，这个参数可以设置的长一些，降低系统的能耗。
	hbase.regionserver.handler.count&#160; 
	描述：由于HBase/Hadoop的Server是采用Multiplexed, non-blocking I/O方式而设计的，所以它可以透过一个Thread来完成处理，但是由于处理Client端所呼叫的方法是Blocking I/O，所以它的设计会将Client所传递过来的物件先放置在Queue，并在启动Server时就先产生一堆Handler(Thread)，该Handler会透过Polling的方式来取得该物件并执行对应的方法，默认为25，根据实际场景可以设置大一些。
	&#160;
	hbase.regionserver.thread.splitcompactcheckfrequency 
	描述：这个参数是表示多久去RegionServer服务器运行一次split/compaction的时间间隔，当然split之前会先进行一个compact操作.这个compact操作可能是minor compact也可能是major [...]]]></description>
		<link>http://www.javabloger.com/article/hbase-performance-hbase-optimized.html?source=rss</link>
			</item>
	<item>
		<title>HBase入门篇2-Java操作HBase例子</title>
		<description><![CDATA[&#160;&#160;&#160;&#160; 本篇文章讲述用HBase Shell命令 和 HBase Java API 对HBase 服务器 进行操作。在此之前需要对HBase的总体上有个大概的了解。比如说HBase服务器内部由哪些主要部件构成？HBase的内部工作原理是什么？我想学习任何一项知识、技术的态度不能只是知道如何使用，对产品的内部构建一点都不去关心，那样出了问题，很难让你很快的找到答案，甚至我们希望最后能对该项技术的领悟出自己的心得，为我所用，借鉴该项技术其中的设计思想创造出自己的解决方案，更灵活的去应对多变的计算场景与架构设计。以我目前的对HBase的了解还不够深入，将来不断的学习，我会把我所知道的点滴分享到这个Blog上。
	&#160;&#160;&#160;&#160; 先来看一下读取一行记录HBase是如何进行工作的，首先HBase Client端会连接Zookeeper Qurom(从下面的代码也能看出来，例如：HBASE_CONFIG.set(&#34;hbase.zookeeper.quorum&#34;, &#34;192.168.50.216&#34;) )。通过Zookeeper组件Client能获知哪个Server管理-ROOT- Region。那么Client就去访问管理-ROOT-的Server，在META中记录了HBase中所有表信息，(你可以使用&#160; scan &#39;.META.&#39; 命令列出你创建的所有表的详细信息),从而获取Region分布的信息。一旦Client获取了这一行的位置信息，比如这一行属于哪个Region，Client将会缓存这个信息并直接访问HRegionServer。久而久之Client缓存的信息渐渐增多，即使不访问.META.表也能知道去访问哪个HRegionServer。HBase中包含两种基本类型的文件，一种用于存储WAL的log，另一种用于存储具体的数据，这些数据都通过DFS Client和分布式的文件系统HDFS进行交互实现存储。
如图所示：

	
	
查看大图请点击这里
	
再来看看HBase的一些内存实现原理： &#160;&#160; 
	&#160;&#160;&#160; * HMaster&#8212; HBase中仅有一个Master server。
	&#160;&#160;&#160; * HRegionServer&#8212;负责多个HRegion使之能向client端提供服务，在HBase cluster中会存在多个HRegionServer。
	&#160;&#160;&#160; * ServerManager&#8212;负责管理Region server信息，如每个Region server的HServerInfo(这个对象包含HServerAddress和startCode),已load Region个数，死亡的Region server列表
	&#160;&#160;&#160; * RegionManager&#8212;负责将region分配到region server的具体工作，还监视root和meta 这2个系统级的region状态。
	&#160;&#160;&#160; * RootScanner&#8212;定期扫描root region，以发现没有分配的meta region。
	&#160;&#160;&#160; * MetaScanner&#8212;定期扫描meta region,以发现没有分配的user region。
	HBase基本命令
	下面我们再看看看HBase的一些基本操作命令，我列出了几个常用的HBase Shell命令，如下：



名称
				
命令表达式
				


创建表
create &#39;表名称&#39;, &#39;列名称1&#39;,&#39;列名称2&#39;,&#39;列名称N&#39;


添加记录&#160;&#160;&#160; &#160;&#160;
put &#39;表名称&#39;, &#39;行名称&#39;, &#39;列名称:&#39;, &#39;值&#39;


查看记录
get [...]]]></description>
		<link>http://www.javabloger.com/article/apache-hbase-shell-and-java-api-html.html?source=rss</link>
			</item>
	<item>
		<title>HBase入门篇</title>
		<description><![CDATA[HBase是什么？ 
	HBase是Apache Hadoop中的一个子项目，Hbase依托于Hadoop的HDFS作为最基本存储基础单元，通过使用hadoop的DFS工具就可以看到这些这些数据 存储文件夹的结构,还可以通过Map/Reduce的框架(算法)对HBase进行操作，如右侧的图所示：
	
	HBase在产品中还包含了Jetty，在HBase启动时采用嵌入式的方式来启动Jetty，因此可以通过web界面对HBase进行管理和查看当前运行的一些状态，非常轻巧。
为什么采用HBase？
	HBase 不同于一般的关系数据库,它是一个适合于非结构化数据存储的数据库.所谓非结构化数据存储就是说HBase是基于列的而不是基于行的模式，这样方面读写你的大数据内容。
	HBase是介于Map Entry(key &#38; value)和DB Row之间的一种数据存储方式。就点有点类似于现在流行的Memcache，但不仅仅是简单的一个key对应一个 value，你很可能需要存储多个属性的数据结构，但没有传统数据库表中那么多的关联关系，这就是所谓的松散数据。
	简单来说，你在HBase中的表创建的可以看做是一张很大的表，而这个表的属性可以根据需求去动态增加，在HBase中没有表与表之间关联查询。你只需要 告诉你的数据存储到Hbase的那个column families 就可以了，不需要指定它的具体类型：char,varchar,int,tinyint,text等等。但是你需要注意HBase中不包含事务此类的功 能。
	Apache HBase 和Google Bigtable 有非常相似的地方，一个数据行拥有一个可选择的键和任意数量的列。表是疏松的存储的，因此用户可以给行定义各种不同的列，对于这样的功能在大项目中非常实用，可以简化设计和升级的成本。
如何运行HBase？
	从 Apache的HBase的镜像网站上下载一个稳定版本的HBase http://mirrors.devlib.org/apache/hbase/stable/hbase-0.20.6.tar.gz， 下载完成后，对其进行解压缩。确定你的机器中已经正确的安装了Java SDK、SSH，否则将无法正常运行。
	$ cd /work/hbase
	进入此目录
	$ vim conf/hbase-env.sh
	export JAVA_HOME=/JDK_PATH
	编辑 conf/hbase-env.sh 文件,将JAVA_HOME修改为你的JDK安装目录
	$ vim conf/regionservers
	输入你的所有HBase服务器名,localhost,或者是ip地址
	$ bin/start-hbase.sh
	启动hbase, 中间需要你输入两次密码，也可以进行设置不需要输入密码，启动成功，如图所示：
	
$ bin/hbase rest start
	启动hbase REST服务后就可以通过对uri: http://localhost:60050/api/ 的通用REST操作(GET/POST/PUT/DELETE)实现对hbase的REST形式数据操作.
	也可以输入以下指令进入HQL指令模式
	$ bin/hbase shell
	$ bin/stop-hbase.sh
	关闭HBase服务
启动时存在的问题
	由于linux系统的主机名配置不正确，在运行HBase服务器中可能存在的问题，如图所示：
	
	2010-11-05 11:10:20,189 ERROR org.apache.hadoop.hbase.master.HMaster: Can not start master
	java.net.UnknownHostException: ubuntu-server216: ubuntu-server216
	表示你的主机名不正确，你可以先查看一下 /etc/hosts/中名称是什么，再用 hostname 命令进行修改， hostname [...]]]></description>
		<link>http://www.javabloger.com/article/apache-hbase-shell-and-install-key-value.html?source=rss</link>
			</item>
	<item>
		<title>关于memcache client CPU占用率过高的问题排查和解决</title>
		<description><![CDATA[现象： 
	&#160;&#160;&#160; 在 手机浏览器的网页代理(类似 UCWeb) 项目试运行的这段日子里，客户抱怨服务器在使用一段时间后会越来越慢，导致网页抓取和转换的运行的非常慢，到系统里面一查CPU的资源使用情况，被占用了90%以上。客户提供的硬件 可是 16G的内存 和 8核cpu ，这明显是代码 太不给力了。
&#160;
排查：
	&#160;&#160; &#160;首先想到的是 代码流程中分块、排序和频繁的数据库操作 导致cpu占用过高，但是使用jmeter渗透测试后发现 存在缓存的流程也是不给力，于是将不相干代码剥离，最后定位到一句代码
	&#160;&#160; &#160;&#160;&#160; &#160;CacheObject cacheObject = cacheManager.get(key); &#160;
	&#160;&#160; &#160;这句代码 核心是调用memcached 客户端的Memcache 的get方法于是精确定位到问题所在：Memcache 在取元素出的问题！！！
&#160;
定位：
	&#160;&#160; 1.一开始偷个懒 检查版本 server端为最新1.4.5版本 客户端为whalin 1.xx 版本 我觉得是客户端版本过老（依赖于jdk 1.4），所以切换客户端为最新的2.5.1 whalin以及net.spy版本的客户端 依然不给力。
	&#160;&#160; 2.于是怀疑是memcached 分布式导致，但是现在是单一memcached server环境，又怀疑是网络延迟，把memcached server移到本地测试，不给力啊！！！
	&#160;&#160; 3.继续排查，老老实实跟踪代码，下面简单介绍 get时 客户端做的事：
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; // get SockIO obj using cache key
	&#160;&#160;&#160; SockIOPool.SockIO sock = pool.getSock(key, [...]]]></description>
		<link>http://www.javabloger.com/article/about-memcache-client-cpu.html?source=rss</link>
			</item>
	<item>
		<title>上下班路途中的思绪</title>
		<description><![CDATA[&#160;&#160; 公司扩大规模后搬去城郊，上班每天坐公车有一个小时的路程，久而久之让我养成了一个习惯，经常在公车上想一些杂七杂八的问题，并且用手机里的记事本记录下来，这个blog上的一些文章就是在公车上完成的，例如：push mail的百万级架构。
	&#160;&#160; 最近公司和自己服务的一些项目都算是告以段落，暂且不算很忙，让我有空去在思考的几个问题的缘由：
	&#160;&#160;&#160; 例如：
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; a.客户对要实施的项目没有给出明确的需求和项目规划，
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; b.付款的态度一拖再拖，找出各式各样的理由，放在你的面前，
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; c.故意找茬，把合同范围里面的功能进行放大/细分，希望我们做到不可能几乎完成的程度，
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; d.你跟他的解释他一该不听，并且强调你要满足他的愿望和意图。
	以上4点，是我接触到的客户一些共同之处，
	&#160;&#160; 这些看起来都是客户的问题，是客户在刁难我们，是客户在跟我们打太极，在客户在跟我们胡搅蛮缠，等等 我们的一些抱怨。
	&#160;&#160; 可是并不能说我们一点问题没有，我和公司内外的同事时常会讨论这些事情，也发生过一些争执。但是我依然坚持自己的观点&#8220;首先要检查自身的问题，先不要说自己没有问题，都是客户的问题。&#8221; 
	&#160;&#160; 最终大家希望的是结果，而是不断的在给自己去解释，那样对事情没有任何帮助。对于这样的现象首先必须学会认真的检讨自己，去好好反思&#8230;&#8230;&#8230;&#8230;&#8230;
	&#160;&#160; 我们真的从合同签订到产品验收整个过程做的那么专业吗？
	&#160;&#160; 我们真的把开发、测试、发布、验收 等 工作做的那么细致吗？
	&#160;&#160; 我们真的做了最大的努力、最后的尝试吗？
	&#160;&#160; 我们真的把产品(项目)上的问题考虑的那么细致吗？
	&#160;&#160; 我们真的把客户的需求理解的非常非常透彻，想到了实际应用中客户没有想到的每个问题吗？
	&#160;&#160; 等等 。。。。。。
	&#160;&#160; 反省过后，我给自己的答案是，跟国际化专业水准的顾问型公司相比还相差的很多，还有很多地方需要弥补。但有同事跟我反驳说因为我们的资源、资金有限造成一些工作无法开展，但是我提出不同的观点。就举一个争执过程中例子，我们的顾问团队中目前缺乏高级测试工程师，如果请非常优秀的高级测试工程师，这非常好，但对我们目前的状况不太实际，资金有限。
	&#160; 如果请一般的测试工程师，不能给我们带来很多帮助，没有太大的实际意义。不能作为没有把测试工作没有做到位的理由，我们应该换个角度去思考一下，比如如何提高自动化测试的水平，如何才用自动化测试的手段来帮助我们实现目标，降低开发成本。
	&#160;&#160; 凡事都去找个理由，不能去严格的去要求自己，我们将永远不会强大起来，永远被挨打，永远被落后。
	&#160;&#160; 
	&#160;&#160;&#160; 我记得有这样的一句话：
	&#160;&#160;&#160; &#160;&#160;&#160; &#8220;如果一只鸡与一只火鸡相遇，火鸡会认为自己比鸡大得多；而鸡则会认为，咱们的个头差不了多少。
	　　&#160;&#160; &#160; 如果是一只鸡与鸵鸟相遇，鸡一般都会承认对方的个头确实比自己大。&#8221;&#160;&#160;&#160;&#160; &#8212;柳传志
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 
	　　我对句话的领悟是：&#8220;如果要想获得优势，需要比他们高出许多许多。&#8221; 我说的他们是说，在客户视力范围中可以到认识到的所有服务提供商，只有做到那样才会让客户真正的无话可说，只有这样才能让我们获得 认可、尊重、财富。
&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/thoughts-along-the-way-to-work.html?source=rss</link>
			</item>
	<item>
		<title>lucene的分布式搜索-入门篇</title>
		<description><![CDATA[&#160;我的废话:
	&#160;&#160;&#160;&#160; 前些日子客户对以前网站搜索功能不太满意，因为用户输入关键字进行查询时要再选择对应的分类栏目，用户体验不是很到位。所以找我们对他的网站提供全文检索的功能，跟搜索引擎类似输入一组关键字就可以就找到结果，无需选择分类的栏目。
	&#160;&#160;&#160;&#160; 对这样的要求第一个想到的就是Apache Lucene，加上一个开源的中文分词包，整一套分词表 很好解决这个需求，但如果把这个需求深入的去考虑，特别是网站随着业务的发展越做越大的时候，用户数据和请求量上来的时候，事情并非那么简单了，以下是我们想到的几个主要的问题和瓶颈：
	&#160;&#160;&#160; 1.如果搜索的服务器和网站提供内容的服务器放在一台机器上压力将会很大，为了不在性能上相互影响，需要进行分离，
	&#160;&#160;&#160; 2.搜索的压力如果集中在一台机器上，无法解决瞬间的压力，也不便于将来的扩展，需要对搜索的计算进行压力分载，
	&#160;&#160;&#160; 3.失效转发是必然的，无需解释，需要解决，
	&#160;&#160;&#160; 4.系统数据量的增长导致索引文件也不断的增大，如果保存在一个索引文件中，操作和维护起来很麻烦，
	&#160;&#160;&#160; 5.做到索引库和数据库的内容实时更新，并且对全文索引的读/写进行分离。
	系统描述:
	&#160;&#160; 1.用户的请求通过负载均衡设备进行分发到App Server的集群上，负载均衡设备分载大量的用户搜索请求，App Server是一组Web容器，例如GlassFish、Tomcat、Jetty.
	&#160; 2.每个Web容器中部署相同的应用程序，App Server的应用程序中包含Lucene的RMI 客户端和一个监听请求&#160; 删除、添加、更新的监听器。
	3.App Server中Lucene的客户端通过RMI协议对分布式的Lucene Server端进行远程调用，得到查询结果后返回给App Server的Lucene的RMI 客户端，Search Server不仅是一个集群环境，还可以针对业务要求对Search Server进行分组。
	4.网络存储设备上部署了切分过索引文件，这样Lucene RMI Server端加载/读取载网络存储设备上的索引文件效率将会比没有切分以前效率要高，并且可以提高容错能力。
	5.当用户更新数据时，可以调用 App Server的 Action Listener服务，根据lucene的规则可以对索引文件同时读，不可以同时写入的原则，所以将所有的更新操作请求放入一个队列中，队列可以用JMS实现，也可以用java/util的Queue来实现。这样依次向索引文件进行操作。
	&#160;
	
	查看大图请点这里

	三、代码实现
	和客户有保密协议，在此不方便透露代码，只将最初的demo/test示例和demo代码运行的方法写在blog上。
	示例中一共4个Java程序，分别是：
	&#160;&#160;&#160; &#183;IndexTools.java(工具类)，
	&#160;&#160;&#160; &#183;SearchServerA.java/SearchServerB.java (2个服务器端程序)，
	&#160;&#160; &#183; SearchClient.java (请求的客户端程序)
	运行方法
	&#160;&#160;&#160; copy到eclipse中，客户端和服务器启动都通过mian方法，所以可以在eclipse中直接运行。运行此demo需要2个jar包，分别是lucene-core-2.9.3.jar 和contrib\remote目录下的 lucene-remote-2.9.3.jar。
	&#160;&#160;&#160; 先运行 SearchServerA 和SearchServerB 2个服务器端程序 将会自动在你的 c 盘下创建一个index文件夹，里面包含 a、b 这2个目录，目录中就是索引文件。

	服务端代码示例，
	&#160;&#160;&#160; private static final String indexdir = &#34;c:/index/a&#34;;&#160;&#160;&#160; // [...]]]></description>
		<link>http://www.javabloger.com/article/distributed-lucene-cluster.html?source=rss</link>
			</item>
	<item>
		<title>LinkedIn的线上搜索 &#8212; 分布式搜索相关</title>
		<description><![CDATA[我的废话：
	&#160;&#160; 某个项目缘故对分布式搜索的方式和技术的话题开始高度关注，看了不少资料，如 Apache Solr 和 Katta 。好东西大家应该分享， 最近看到LinkedIn 推出的新产品 LinkedIn Signal ，该产品在架构设计上和分布式搜索有着紧密的联系，LinkedIn搜索引擎架构师王坚 (John Wang) 在团队的blog上公布了一些产品内幕，这一资料让我得到了很多启发。
	如图所示：
	
	&#160;&#160;&#160; * Zoie - Realtime indexing/search system.&#160; 
	&#160;&#160;&#160; * Bobo - Faceted Search Engine&#160;&#160; 
	&#160;&#160;&#160; * Sensei - distributed realtime searchable database with dynamic clustering. Leverages Zoie and Bobo.
	以上几个东东 是LinkedIn 搜索团队自己开发的，来满足用户线上的搜索需求。
	整篇详细内容如下：
	http://sna-projects.com/blog/2010/10/linkedin-signal-a-look-under-the-hood

	值得借鉴的几点:
	&#160;&#160;&#160; * 对于线上搜索的前端展现策略，结构的设计不可忽视 
	&#160;&#160;&#160; * 如何利用多进程并行计算来提高计算效率,
	&#160;&#160;&#160; * 对大索引文件sharding 的存储策略，
	&#160;&#160;&#160; * 索引文件分布在不同集群机器的查询策略，
	&#160;&#160;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/lucene-cluster-zoie-bobo-sensei.html?source=rss</link>
			</item>
	<item>
		<title>NanJing AMTeam的一次技术沙龙(Java&amp;JEE)</title>
		<description><![CDATA[&#160;&#160; 今天公司在长白街的咖啡店组织了一次技术沙龙讨论，也可以说是一次技术经验交流会，把技术分享做为主题，提供一个畅所欲言的氛围，公司也是第一次出经费举办这样的技术沙龙，但组织者可能准备的不算充分，毕竟是头一次吧，有些想来的同事没赶上，今天讨论的气氛比较活跃，时间也比较长从13：30到18：00 。中间做了很多经验分享的互动环节，讲到了很多在项目中具体实践和失败的教训。
	讨论了如下内容：
	&#160;&#160;&#160; 1.DDD(Domain-driven design) 和 TDD(Test-driven design) 在项目中的一些心得。ps:大家对TDD的抱怨还是比较大，但有同学提出我们回去以后还是需要进一步反思，大家也表示赞同。
	&#160;&#160;&#160; 2.Java 对本地文件系统和分布式文件系统中对文件的操作，主要讲解 各种分布式文件系统的实践和Java文件锁的机制。
	&#160;&#160;&#160; 
	&#160;&#160;&#160; 3.关于Memcached 的话题比较多，一共3个同学从不同 角度进行技术分享，1、Memcached客户端实现的连接池深入解析，2、如何提高缓存的命中率 3、多年以来在项目中使用缓存的演变过程。
	&#160;&#160;&#160; 4.REST 与 传统Web模式的比较，1.从代码和实际开发的角度&#160; 2.提高系统架构的灵活性&#160; 3.搜索引擎SEO与REST 。 从多个角度 探讨REST的一些实践
	&#160;
	&#160;&#160;&#160; 5. 最后还分享了经久不衰的Gof23话题， 几乎到场的每个同学从多个方面谈到了对Gof23 实战经验和一些心得。
	&#160;&#160;&#160; 
	留一张照片做纪念&#160;&#160;  
	
	&#160;
我的废话：
&#160;&#160; 虽然是公司组织的活动，但是我们希望公司以外有兴趣的朋友，同样可以加入到我们中间来和我们交流你的最佳实践，与我们分享AMTeam提供的美食和啤酒。
	&#160;&#160; 下次的地方可能订在宝来纳。

	&#8211;end&#8211;
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/nanjing-java-salon.html?source=rss</link>
			</item>
	<item>
		<title>Glassfishv3中的EJB3集群</title>
		<description><![CDATA[&#160;&#160; GlassFishv3.0虽然支持EJB/EJB3 分布式计算，但GlassFishv3.0不支持EJB/EJB3集群，GlassFishv3.0的集群是通过mod_jk完成,也就说是GlassFishv3.0只能支持Web集群。对于High Availability、Load Balancer Plugin和Centralized Administration of Load Balancer Plugin Configuration都不支持，如果需要使用EJB集群功能 还必须选择GlassFishv2。GlassFish的官方网站上提供了v2和v3版本区别的列表，如图所示：
	
	&#160;原本在GlassFishv2中集群的方式是GlassFish通过管理节点和代理节点先建立内部通讯，如下图所示，
	&#160; 1.在图中上方先建立一个Load Balanceing Tier 保持每个节点之间的通讯，
	&#160; 2.在图的左边有一个竖着的圆柱形Management是对集群中的每个节点进行配置、监控、管理的模块，
	&#160; 3.下方HA Application State Repository用来存储集群节点的会话，如:HTTP session, stateful EJB session和 single sign-on(SSO) 。
这样在GlassFishv2的集群中无论是Http(s)、JMS、RMI/IIOP协议对GlassFish集群进行访问都可以支持集群。如图所示：
	
	&#160;&#160; 在Glassfish的官方网站上已经明确说明如果你需要集群，高可用，以及支持Java EE 5规范，你可以选择V2。如果你需要领先的web应用技术，web服务和脚本支持，选择V3。
	摘录文字：&#8220;
	Both GlassFish Server v2 and v3 Prelude are fully supported, production-ready distributions while v3 Preview is the most recent version of the GlassFish v3 [...]]]></description>
		<link>http://www.javabloger.com/article/glassfishv3-ejb3-clustering.html?source=rss</link>
			</item>
	<item>
		<title>JMS集群OpenMQ的那些事</title>
		<description><![CDATA[我的废话:
	JMS、OpenMQ 这2个词不断的在我的空间里出现，因为我们对于JMS服务器的重视程度很高，JMS在整个系统中的角色是系统组件之间通讯的桥梁，我们利用JMS服务器构建 &#8220;低耦合，高内聚&#8221;的重要手段之一，曾经我们想过采用http、ejb来实现，但是这2个手段无法满足以下4个需求：
	&#160;&#160;&#160; 1.不停机,不改变集群中任何节点的状态，可以对集群中的节点任意添加，进行压力分载，
	&#160;&#160;&#160; 2.发出一个请求，集群中的所有应用程序节点都能接收相同数量的请求，
	&#160;&#160;&#160; 3.通信中组件的接收端失效，当生效后再运行时能继续接收到上次失效前的请求，
	&#160;&#160;&#160; 4.请求中有多种不同的类型，下面的集群节点可以按照不同的类型接收，可以动态的指定集群节点中的机器完成不同的任务。
	经过多番比较最后决定采用JMS作为系统中组件与组件通讯的重要手段。

	废话少说，进入正题，介绍在实践中使用JMS的一些经验，和大家分享一下：
	失效转发
	有2台Sun的OpenMQ服务器集群后， 并不是一个work，另外一个standby，如果你认为是这样，那么只是一些表面的现象。我们可以做一个测试，如果你向其中一个jms服务器发送消息Topic或者是Queue类型的消息，那么你也可以在另外一台服务器上接收到消息。说明他们之间在集群后内部是完全相通的，这样集群中无论其中任何一个JMS的服务器down机消息都会失效转发到另外一台上，因为当你向其中一台发送消息的时候JMS集群内部就完成了消息copy。
	如图所示：
	
	BWT:如果你测试在JMS失效转发的过程中是否生效，那么请注意，如果你发送的是大对象(2M以上的数据)会导致失效转发失败，因为默认反复尝试的时间间隔是5000毫秒，你需要提高imqReconnectInterval 的值(毫秒)作为时间间隔反复尝试连接每个地址的之间时间间隔的长短。
	压力分载
	如果你有2台以上的JMS服务器作为集群的节点，首先你需要在你的发送端和接收端的主机地址中写上这些JMS服务器的ip地址，其次还需要注意，在发送端和接收端的连接属性中设置imqAddressListBehavior 指定了尝试连接指定地址的顺序。如果将此属性设置为字符串 PRIORITY，将按地址在地址列表中的显示顺序尝试连接。如果属性值为 RANDOM，将按随机顺序尝试连接地址；这种方式非常有用，例如，当许多 Message Queue 客户端共享同一个连接工厂对象时，这种方式有助于防止所有客户端尝试连接到同一个代理地址。
	也就是说如果你不配置，那么发送端的压力始终只会指向一台，就是你写在在代理地址列表 (imqAddressList ) 中的第一个主机。
	如图所示：
	

	相关文章：
	JMS与JMX  
	重谈GlassFish服务器优化  
	OpenMQ命令  
	GlassFish OpenMQ JDBC  
	Spring集成 JMS OpenMQ  
	百万级 大型J2EE Push Mail 项目后记 3  
	GlassFish JMS 集群
	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/openmq-jms-clustering.html?source=rss</link>
			</item>
	<item>
		<title>2010国庆期间</title>
		<description><![CDATA[

	点击这里查看更多相片
&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/2010-livefilestore.html?source=rss</link>
			</item>
	<item>
		<title>OpenMQ中的JMS与JMX</title>
		<description><![CDATA[
&#160;
我的废话:
		为了能够满足强大的Java计算环境与分布式系统中管理的问题，Sun公司对Java基础类库进行了扩充开发了专用的Java管理扩展类库
		(Java Management Extensions)。利用JMX的标准可以对JEE服务器的资源进行性能监控，管理和统计各类应用服务器运行时的信息。
		JMX中有很多内容，本文只针对如何操作JMS服务器 OpenMQ产品进行阐述，讨论JMX层次与架构的相关话题暂时不是本文的重点。

OpenMQ提供了一套非常完备的JMX MBeans管理接口，使用MBeans可以对OpenMQ服务器进行监控就像我们通常使用OpenMQ中的命令imqcmd一样方便，还记得JDK中的JConsole工具吗？可以对Java JDK 运行的状态进行监控和管理。在之前的文章里我提到可以通过imqcmd命令对OpenMQJMS服务器进行管理监控，但客户提出要一个web界面下管理多台集群下的JMS服务器工具，并且还需要和现有的系统管理工具进行集成，此时还不得不去使用JMX MBeans对OpenMQ JMS服务器进行管理监控，因为我们找不到比这个更好的办法。
		可以使用JEE规范中的JMX协议进行管理OpenMQ中的集群管理节点(managing brokers)、服务(admin/jms)、消息队列(destinations), 接收者(consumers), 生产者(producers)，还可以JMS服务器监控连接状态，查看发送的消息内容。
		我们可以通过OpenMQ提供的imqjmx.jar API 编写代码调用JMX对OpenMQ服务器进行性能监控，在这个基础上还可以对JMS服务器的配置进行优化，还可以写一个OpenMQ JMX 的客户端对服务器进行自动化的监控和自动维护，例如，发现某个消息队列堵塞消息可以立刻通知管理员，或者发现堵塞消息后可以采用其他方式将消息拿下来再次发送一遍，使用这样的方式可以比原来的imqcmd命令对JMS服务器进行管理和监控更进一步。
		下面我们来看看通过OpenMQ提供的API结合下面的Java代码可以将正在运行的JMS服务器停止，代码如下：
		AdminConnectionFactory&#160; acf = new AdminConnectionFactory();&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; //#1
		acf.setProperty(AdminConnectionConfiguration.imqAddress, &#34;192.168.1.1:7677&#34;);&#160;&#160;&#160; //#2
		JMXConnector&#160; jmxc = acf.createConnection(&#34;admin&#34;, &#34;admin&#34;);&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; //#3
		MBeanServerConnection&#160; mbsc = jmxc.getMBeanServerConnection();&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; //#4
		ObjectName&#160; serviceConfigName = MQObjectName.createServiceConfig(&#34;jms&#34;); &#160; &#160; &#160; &#160; &#160;&#160; //#5
		mbsc.invoke(serviceConfigName, ServiceOperations.PAUSE, null, null);&#160; &#160; &#160; &#160; &#160; &#160; &#160; &#160; &#160; &#160; &#160; &#160; [...]]]></description>
		<link>http://www.javabloger.com/article/glassfish-jms-server-openmq-management-using-jmx.html?source=rss</link>
			</item>
	<item>
		<title>最近的这些事,看看图,留些字</title>
		<description><![CDATA[今天在想最近忙了哪些事情，这让我想到电影中的一句台词

跟工作有关：
	1、JMS的压力测试，测出生产环境中JMS服务器吞吐量和并发承载能力；
	2、Memcached的 关于失效转发 单点问题 有点小收获； 
	3、重新设计任务调度器的方案；
	4、在写一个介绍移动计算方面的PPT有很多页，花了点力气 摘要如图；
	
	
	&#160;
跟生活有关：
	跟老婆外出兜风，很High，很Happy。
	
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/java-ppt.html?source=rss</link>
			</item>
	<item>
		<title>JEE应用服务器程序批量+远程部署- glassfish or tomcat</title>
		<description><![CDATA[我们知道 Google 多数都是采用廉价的机器来构建这样的全球化大型系统，里面肯定少不了分布式和集群计算的方式，如果要更新其中的某一套系统，那么就需要更新很多集群节点中的计算机，Google是如何做到在最短时间做出最快响应的喃? 也许我们暂时不知道Google是怎么对大规模生产环境进行发布的，但是至少有一点我敢肯定，那一定是采用自动化和半自动化的方式进行批量部署。
	现在我们生成环境的机器和测试环境的机器越来越多，导致我们的重复劳动就越来越多，隐含发生错误的机率也越来越多。我们希望有一个工具输入一个命令就可以关闭 每台机器或者每个分组机器上的应用，再输入一下就可以全部启动，当我们需要部署不同应用到不同的到大量的计算机上时可以全自动的也可以是人工输入命令半自动去完成。 对于这样具体的要求我们想自己开发一套适合我们使用的工具。
	有人肯定会说为什么这样折腾？不去使用 hudson 这样专业的持续集成工具，而要自己去创造轮子？以下是我们给出的观点；
	第一我们认为hudson那样的工具虽然全面，但针对性不强，如果为了满足我们一些具体的功能需要进行量身改造的话可能需要投入的成本非常大。就好比有一个造零件的机器什么零件都能造，这样的机器设备针对某种产品生产起来还是用一定的局限性，相对我们自己先造一个机器设备，这个设备专门制造我们需要的零件，那么这样的机器工作效率肯定快，而且好用，造出来的零件也肯定很适用。
	第二谁都无法保证在一些繁杂的编译、打包、发布过程中不会出错，加上很多台服务器的生产环境需要发布不同的应用程序和不同的版本，遇到问题又要能快速回退，回退到某个稳定的版本，这样工作需要99.9%的保证不出问题，而且完全依靠人工手动是不现实的。
	第三为了提高生产力，节约人力成本，繁杂的工作交给一个人在短时间完成不出错要求未免有点苛刻了，我们希望任何一个懂点liunx知识的人都能完成这个复杂又重复的工作，在短时间内能发布完成在不同服务器上的不同应用程序。
	为了实现这个目标我们才产生了这样的想法，再加上我这个人天生就喜欢没事折腾，就去实现了这个想法。
	ps：这个玩意只能适合内部使用，但不会只适合我们某一个项目，而不能适应其他项目，设计工具的时候我们还考虑到了这个工具在公司内部的一些通用性。我们需要的是一个可插拔、灵活性强的工具，需要对整个打包，发布的过程做到 可选项和必选项，输入不同的命令产生不同的结果，并且可以做到单元功能扩展。
	整体架构 / 过程如下：
	&#160;&#160; &#160;1、从snv服务器下载源码到发布的机器上 ，
	&#160;&#160; &#160;2、通过mvn、ant 工具在发布机器上进行打包，
	&#160;&#160; &#160;3、对当前版本进行备份，
	&#160;&#160; &#160;4、开发环境上传远程生产服务器，
	&#160;&#160; &#160;5、分发到每个集群的应用服务器上，
	&#160;&#160; &#160;6、开始部署应用程序，
	&#160;&#160; &#160;7、重启应用、应用服务器 (可选)
	系统架构 如图所示1：
	

	大致流程 如图所示2：
	

	我的废话：
	目前我们正在对这个工具进行不断的完善，并且希望将来可以在整个公司推广，给更多的项目使用，得到更多的需求，扩充工具的功能，逐步实现通用化。
	&#8211;end&#8211;
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/jee-app-server-remote-delpoy-glassfish-or-tomcat.html?source=rss</link>
			</item>
	<item>
		<title>高并发中的卡死状态 -HashMap</title>
		<description><![CDATA[场景
	http servlet 异步请求原先是30秒，现在挂起的时间设置为0，进来就出去，没有等待时间，
	&#160;&#160;&#160;&#160; 场景一：发起30000个挂起请求，中间间隔5秒钟， 测试中CPU 使用率 75%，测试完毕CPU使用率 60%-75%&#160; ，open/active connections&#160; 当前活动数量 12000，这个是不正常的
	&#160;&#160;&#160;&#160;&#160; &#160;
	&#160;&#160; &#160;场景二：发起12000-15000个挂起请求， 中间间隔10秒钟，测试中CPU 使用率 75%，测试完毕CPU使用率 0%-1% 和 open/active connections 参数一切正常，
	&#160;&#160;&#160;&#160;&#160; &#160;
	&#160;&#160; &#160;场景三：发起12000-15000个挂起请求， 中间间隔2秒钟，测试中CPU 使用率 75%，测试完毕CPU使用率 60%-75% 和 open/active connections 当前活动数量 5000多个，这个也是不正常的
	&#160;&#160; &#160;
	&#160;&#160; &#160;场景四： 把GlassFish中的现在的应用程序去掉，写一个非常简单的http请求，再做 30000个并发请求，同样的环境中没有任何问题发生，此时一切正常，唯一不同的就是程序不同，可以90%的将问题定位到我们自己的程序上了。
	&#160;&#160; &#160;
	上述open/active connections是指用查看GlassFish 中活动的当前 http活动连接数&#160; 可以使用命令进行查看当前的http上连接的活动状态
	asadmin get &#8211;monitor=true &#34;server.network.http-listener-1.*&#34; &#124;grep countopenconnections-count
如图所示：

	
查看大图请点击这里
	通过上述的测试过程，我们还可以发现一个不同的地方，那就是对现有的应用程序发起请求是不是并发请求，例如 上述的场景二和场景三，如果是并发请求，必死无疑，但是 如果还是一样的并发数量但是请求的间隔时间长了，例如30000个请求中间发起间隔10秒说明不是并发请求。Ok，问题到这一步，可以确定是我们的程序能否能支持大量并发的问题了。
	经过反复检查代码以后发现原来是程序中使用 HashMap 的问题，换成 ConcurrentHashMap 来代替 HashMap 后一切又正常了，因为
	HashMap并不是线程安全的，如果你的单例类没有做代码同步或对象锁的控制，而ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术，它使用了多个锁来控制对hash表的不同部分进行的修改。 [...]]]></description>
		<link>http://www.javabloger.com/article/concurrenthashmap-stuck-in-java-high-concurrency.html?source=rss</link>
			</item>
	<item>
		<title>关于开发中的一些感受</title>
		<description><![CDATA[&#160;&#160; 经常采用Java语言和一些开源技术为客户构建一些中、小型的web项目，目前来说对与我们团队承接的每一笔软件项目都是赚钱的，但关键的是如何缩短开发周期，确保产品质量，并提前交付获得更高的价值，所以我们在开发的过程中尽可能的使用一些简洁的方法。
	例如：web层使用spring3 web框架，操作数据库那层使用 Jenkov 的 mrpersister 和 Apache 的 dbutils，将这2个框架进行组合使用，自己再对这2个框架薄薄的封装一个抽象类，满足了我们的期望，可再次缩短交付的时间。
	&#160;&#160; 这样就不用管web层传过来的是多少个参数反正都是一个对象，直接传入DAL层，而每个DAL层中的方法写2-3行代码即可，除了根据不同的业务逻辑写查询的SQL语句，在开发上基本没什么&#8220;重活&#8221;了。反之，如果使用 iBatis 或者 Hibernate 、Struts 框架 xml和java都将需要维护，无形中加大了我们开发的成本，延长交付时间。
	&#160;
	在小团队开发中这种框架我认为是不错的选择，但随着开发队伍的壮大，加上客户对项目二期新需求的提出，其他客户的新项目到来。一下 人多了，口杂，事情多看，任务多，计划多看，变数多，忽然之间有点乱了。此时貌似不如团队成员人少的时候来的进度快，大家商讨几次之后还算一切都平静了下来。
	&#160; 其中我发现一种现象，例如：没有iBatis 中 XML的限定后，SQL语句可以写在com\aswish\common\sql目录下 再给DAL里面的方法引用，也可以直接把SQL语句写在DAL的方法里面，另外，对于打SQL印日志可以通过Log4J打印SQL，还有成员通过System.out.println打印，还有人偷懒不打印SQL日志，有的成员在每个Action方法里面都打印日志 ，有的人觉得麻烦就不打印，等等这些小问题，小细节，但排错的时候就不一样了通过打印日志能很快的找出原因。还有，对于DAL层程序方法调用上有的新成员开始的时候不习惯我们的这种开发框架，按照自己的习惯来导致最后帮他排错的时候也费了一些力气。使用这样山寨框架灵活性很强，但是导致了开发上一致性比较差，最后修复Bug的时候降低了工作效率。记得在《淘宝网架构师岳旭强的年度展望》http://www.infoq.com/cn/articles/yuexuqiang-share-outlook&#160;&#160; 一文中提到 &#8220;有一个故事，在数据层的前期版本，为了做到透明的路由，曾经采用无SQL的方式，所有的数据库访问都是写代码来做。上线后发现一个非常痛苦的问题，无法和SQL对应，排错非常难。曾经一次DBA发现数据库上一个查询耗费太多资源，把优化后的SQL给开发人员改进，开发人员好几天没找到具体是哪个查询。&#8221;&#160; 似乎他们也遇到了和我们相似的问题。
	&#160;&#160; 项目现在已经交付给客户了，也算是非常非常，再次 再次的体会到 为什么很多大型项目需要 Spring Struts Hibernat 这样的组合，至于Spring的配置文件具体怎么使用我现在都统统还给了Rod Johnson 大叔，但深刻的明白了大规模开发中一致性非常的重要，也许这样的框架并不能给行效率上带来多大的提高，但是在规范上可以进行统一。总结这次的教训，将来还需要整理出一套具有一定规范性的ORM山寨版框架，会想些办法在山寨框架中去制约在编码开发上一致性。没有最好的框架，但适用的才是最好的。所以不是不敢这样继续折腾下去了，而是在想下面该怎么接着折腾，呵呵。
	BTW：
	大家都是在业余时间折腾这些项目，工作时间基本上晚上所以面对面沟通比较困难，在网上交流又不大方便，也是我们面临的问题。
	上述这的过程是值得去反思的，需要不断总结一切导致挫折的因素，那是今后的财富之一。
&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/consistency-of-experience-on-the-development.html?source=rss</link>
			</item>
	<item>
		<title>Web服务器性能优化&#8211;又一次实施的案例后记</title>
		<description><![CDATA[记实&#160;
&#160;&#160; 感谢 Y兄，不管如何都 真的要感谢您和您的团队给我发挥一些雕虫小技的机会，如果没有您们这样的环境， 也不会让我有这样的机会和一些经验、教训 积累。
场景
&#160;&#160;&#160;&#160;&#160; 企业中4000多用户的OA系统，系统最高并发200-300，但每到高峰期，特别是星期一上午，就像来那个什么似的，出现&#8220;503 Service Temporarily&#8221; 错误 ，当我听到电话里的Y兄跟我说道这样的现象，并且后台程序无时错误抛出时，我的第一反应就是 Tomcat 和 Apache的通信处了状况。
&#160;&#160;&#160;&#160;&#160; 兄台多处寻医，但是众人分说，多数人坚持说，是Java应用程序的因素导致系统 503错误。但没有采用Apache+Tomcat 以前一切正常，没出现的503现象。
教训
&#160;&#160;&#160;&#160; 1、这样非常广义的503错误信息，适合采用 &#8220;排除法&#8221;，一层一层的剥离 有可能存在的因素。
	&#160;&#160;&#160;&#160; 2、使用的产品必须彻底明白每个参数的具体作用，不然你遇到问题时候根本无法应对。
	&#160;&#160;&#160;&#160; 3、这样非常扰人的 &#8220;big aunt&#8221; 问题 必须有耐心，要有对其一查到底的决心！
	&#160;&#160;&#160;&#160; 4、互联网中的资料，今后要求Team中的兄弟们 必须100%理解后再去抄袭，不然 把你一脚踢到楼下出去；当然这是开玩笑的话，这是打造一个精良技术团队的信念，否则遇到问题时根本无从下手。
过程
	
&#160;&#160;&#160;&#160; 1、用户的生产环境是不可能让我随意倒腾的，只有在自己的机器上先想尽一切办法重现这样的错误。
	&#160;&#160;&#160;&#160; 2、仔细的阅读Apache web服务器和Tomcat的使用手册 找出关键性的配置参数。
	&#160;&#160;&#160;&#160; 3、经过一番推理加上本地环境的反复证明 Apache中的 max和smax(soft max) 配置参数，Tomcat中ajp的 MaxThread参数 都是非常有意义的。
	&#160;&#160;&#160; 4、这几个参数需要根据生产环境，机器配置来界定 到底需要配置多少，这样才能充分发挥机器硬件的资源。也许会和网上所说的解释不会完全一样，但是是我的理解：Apache中的配置参数就像是系统的嘴巴能吃多少请求数，tomcat中的配置参数就像是系统的胃，给你很多的食物就看你能不能消化，所以Apache中的配置和Tomcat中的配置都息息相关的，需要同时关注。
	&#160;&#160;&#160; 5、读了这份资料后，感受颇深，如果你遇到一些需要深刻理解Apache 转发Tomcat 的配置参数，绝对是必备的良药，值得收藏一下。 地址：http://httpd.apache.org/docs/2.2/mod/mod_proxy.html#proxypass (官方文档) 。
&#160;废话
	
&#160;&#160;&#160;&#160;&#160;&#160; 专家+新手=快速入门，上手工作。
	&#160;&#160;&#160;&#160;&#160;&#160; 专家+专家=关键模块，解决关键性难题。其实 团队中的 工作模式 也是需要优化的，不同问题，不同人群对待，人力资源最大化。
	&#160;
&#8211;end&#8211;

	&#160;
]]></description>
		<link>http://www.javabloger.com/article/another-case-of-the-postscript.html?source=rss</link>
			</item>
	<item>
		<title>J2ee集群中的日志监控</title>
		<description><![CDATA[&#160;&#160; 项目快要接近尾声了，可是事情还是一样的多，目前关注的侧重点与开发阶段不同，对现在系统的性能和稳定性提出了很多要求，在提高性能和稳定性的同时还需要做到监控系统运行中的每笔业务异常状态，以及目前我们认为将会导致用户不良体验的异常的现象需要立刻发邮件，发短信 报警，并且跟踪业务运行状态，甚至还需要知道具体发生异常的是那个用户账户，是什么原因导致的，这样便于我们追溯问题和对系统的监控严格把关。
	同学们，要知道不是说把每个机器上的日志用SMTP或者Socket、SNMP 等方式发送出去就ok了，还需要满足以下&#8220;BT&#8221;的条件：
	&#160;&#160;&#160; 1、对自定义的错误信息发出报警信息，不是所有错误、异常 信息都发出报警，
	&#160;&#160;&#160; 2、需要知道是哪台服务器上发出的异常信息，甚至还需要知道具体调用的程序和方法名称，
	&#160;&#160;&#160; 3、不同时间段 针对 不同用户账号批量进行监控，在这时间段中 只有这些账号发出错误和异常才发出报警，
	&#160;&#160;&#160; 4、再多的用户账户加入系统中进行监控，需要有实时性，发现异常立刻报警，而且不能因为此项功能给系统带来过大的负载，
	&#160;&#160;&#160; 5、规定内容，规定次数、规定时间、规定人员名单&#160; 发送警报，不然垃圾短信和邮件过多，
	&#160;&#160;&#160; 6、需要能采用简单，简单，再简单的 方法，不能设计的太复杂，我们不想投入过多的人力和时间折腾这玩儿意，
	&#160;&#160;&#160; 7、监控逻辑有变化 随时可以做出调整，系统需要在短时间内做出响应，
	&#160;&#160;&#160; 8、满足可扩展性，伸缩性&#160; 现在是40台应用服务器，将来到120台&#160; more and more 服务器，需要能应付自如，
	&#160;&#160;&#160; 9、对现有的代码架构作出最小的改动，来满足以上所有需求。
	监控场景，例如：
	1、用户与服务器端数据同步，由于我方服务器端连接Yahoo、Google 等 SP服务器出现网络链接异常。
	2、集群中任意一台JMS发送端向JMS服务器端发送消息失败2次开始报警，等等触发报警条件，同学们，有些内容不方便在这里具体透露了。
	经过我们的一番讨论有以下一些方案可以拿出来参考，
	&#160;&#160;&#160; 1、纯净的linux shel l + SNMP + nagios，不使用半点java 技术来实现，例如：http://sery.blog.51cto.com/10037/287923
	&#160;&#160;&#160; &#160;&#160;&#160; 理由：某位同学给出的理由是 使用C或者Shell 更靠近操作系统，这样靠谱些，我们似乎也不能完全否认这样的说法。
	&#160;&#160;&#160; &#160;&#160;&#160; 缺点：需要涉及到的部件过多，就会增加系统中存在的不稳定因素。
	&#160;&#160;&#160; 2、Java Log4J + nagios ，将nagios 作为服务端，采用 Log4J 最为客户端，每个应用程序的 Log4J 客户端向nagios发送日志，例如：http://sourceforge.net/projects/nagiosappender/ 
	&#160;&#160;&#160; &#160;&#160;&#160; 理由：利用现有的资源，再多走一小步，就可以实现基本功能。
	&#160;&#160;&#160; &#160;&#160;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/j2ee-cluster-log-monitoring.html?source=rss</link>
			</item>
	<item>
		<title>近期项目感言</title>
		<description><![CDATA[在项目中与一国外客户进行接触，这次需要实施的Case是一个基于android平台的智能化人机交互系统，当然这个庞大的系统少不了后端运算的支持，后端计算并且采用了云计算的概念，所以还是少不了J2EE的支持。
在过程中我慢慢的体会到移动计算的市场将会越来越大，越来越丰富。并且智能手机、平板电脑、智能家电、人机交互车载系统的时代已经开启，新的游戏规则被触发，终端用户的操作系统不在是被微软一家独揽。例如 dell现在选择google的android作为自己产品线的平台，云计算逐渐将会更加普及更加密布。
我想所有的javaer开发者们借助云计算的概念和android这样开放式的平台可以飞的更高，可以发开的空间将会更大。
BTW：
	真实的人类社会在进步，我想虚拟化的网络社会也会在进步，不知道第二代sns的时代何时到来，也许还会到来更多的市场机遇。
&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/recent-projects-testimonials.html?source=rss</link>
			</item>
	<item>
		<title>找 lucene 盟友,火拼一项目</title>
		<description><![CDATA[自己朋友(客户)的老系统需要改造，要求对lucene 源码、整个实现机制，包括 lucene 内部架构，对切词、分词 技术 有充分的了解。

	并能帮忙我们实现lucene 部分具体的编码工作，和原有的ORM 层对接，实现数据库和索引库同步，压力比较大，工期1-2月，酬劳5位数以上。
联系方式：njthnet # gmail.com
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/find-lucene-javaer.html?source=rss</link>
			</item>
	<item>
		<title>OpenMQ命令</title>
		<description><![CDATA[整理了一些查看OpenMQ JMS Server的 命令，仅供自己参考，学的东西太多，怕忘，先放这里记着。
首先创建一个pasword的文件，这样就不需要每次都 输入密码了，怎么创建，password文件里面的内容，自己看看OpenMQ imqcmd里面的命令也就知道了，这里就不多说了。
	
查看当前service的运行状态，默认名称是jms
	/opt/mq/bin/imqcmd -u admin -passfile pass -b 127.0.0.1:7677 -t q -n jms&#160; query svc
	不断的跳动，显示状态
	/opt/mq/bin/imqcmd -b 127.0.0.1:7677 -t q -n imagent&#160; metrics dst
	同上
	imqcmd -b 127.0.0.1:7677 metrics bkr&#160; -m rts&#160; -int 1&#160; -u admin -passfile pass
	查看整个服务器的运行属性
	imqcmd -u admin -passfile pass -b 127.0.0.1:7677 query bkr&#160; 
	查看消息队列中的消息
	/opt/mq/bin/imqcmd&#160; -u admin -passfile pass -b 127.0.0.1:7677 list msg [...]]]></description>
		<link>http://www.javabloger.com/article/openmq-imqcmd.html?source=rss</link>
			</item>
	<item>
		<title>重谈GlassFish服务器优化</title>
		<description><![CDATA[Glassfish 优化参数对与我们的团队来说真是&#34;老歌老调，老调重弹啊&#34;，不过最近又有一些小小的新发现，废话少说，切入正题。
JVM部分
SUN官方对GlassFish的JVM内存分配 给出了足够详细的定义，并且明确指出&#160; 32位、64位 每种不同的操作系统内存分配多少，并不是你的服务器内存多，就可以分配的越多越好，我们后期经过一番压力测试，发现果然如此，将分配到8G，还不如3G的效果好，也就说当JVM的heap size设置过大时，thread的创建数量便会减少,JVM的堆和进程所需的栈都会消耗进程地址空间(address space)，而地址空间则取决于操作系统.。 
同学们，这个又是一次教训啊，任何事情不可以想当然的去干，还是需要根据约定的规范来，此外还建议需要打开以下参数，
&#160;&#160;&#160;&#160; &#60;jvm-options&#62;-Dcom.sun.enterprise.server.ss.ASQuickStartup=false&#60;/jvm-options&#62;
	&#160;&#160;&#160;&#160; &#60;jvm-options&#62;-XX:+AggressiveHeap&#60;/jvm-options&#62;
	&#160;&#160;&#160;&#160; &#60;jvm-options&#62;-XX:ParallelGCThreads=16&#60;/jvm-options&#62;
	&#160;&#160;&#160;&#160; &#60;jvm-options&#62;-server &#60;/jvm-options&#62;
	&#160;&#160; &#160; &#60;jvm-options&#62;-Dsun.rmi.dgc.client.gcInterval=3600000 &#60;/jvm-options&#62;
	&#160; &#160;&#160; &#60;jvm-options&#62;-XX:+DisableExplicitGC &#60;/jvm-options&#62;
Sun官方建议的配置参数，如下：

另外对于JVM最大可以配置多大的说法，我可以给出我的2个观点：
	1、一种比较笨的办法一个一个的去尝试， java -Xmx2000m -XX:MaxPermSize=120m -version ，把里面的数据一步一步加大，直到找到一个稳定的参数位置。
	2、还有一种简单直接的方式，根据理论来，在标准Linux内核对于物理内存的管理采用1:3的分配比例，即物理 内存的1/4为内核空间(kernel space)，剩下的3/4为用户进程空间（user space），说白了，操作系统自己要用去1/4的内存，因此，在一台4G内存的服务器上，用户进程可使用的内存最大也就是3G。
	&#160;
thread部分
	max-thread-pool-size=&#34;32&#34;建议一般设置为 32，太大将会导致 GlassFish一启动的时候就报 Too Many Open File 的现象
HTTP acceptor threads&#160; 这个参数设置起来跟你服务器上的CPU个数有关，一般是默认的状态为1。
	http部分
	max-connections=&#34;10240&#34;&#160; 这个参数对Keep Alive的 Http场景特别有用，而且越大越好，10000以上都可以。

	其他相关配置以前的文章都有介绍，更多的资料还是参考SUN官方的GlassFish优化手册，http://dlc.sun.com/pdf/819-3681/819-3681.pdf&#160; 官方手册
&#160;
&#8211;end&#8211;

	&#160;
]]></description>
		<link>http://www.javabloger.com/article/glassfish-performance-tuning-tips.html?source=rss</link>
			</item>
	<item>
		<title>MySQL JDBC中autoReconnectForPools的用途</title>
		<description><![CDATA[有一个这样的场景，2台mysql数据库同步，正常的情况下一般只会连接其中的一台，如果其中一台down掉以后，应用程序能自动连接到另外一台，这样的场景和我上一篇文章描述的有所不同，详见:《MySQL JDBC 集群》一文，前面提到的是轮询访问，现在是一直访问一台，直到另外一台down机以后将会自动切换到另外一台上去，当然实现这样的场景你的应用程序必须使用JDBC的数据库连接池才会有效。
其实MySQL关于集群 的 JDBC参数还有很多，下面这些参数是我从MySQL官方网站上杂录的一部分，提供大家参考，
High Availability and Clustering.&#160;









Property Name
Definition
Default Value
Since Version


autoReconnect
Should the driver try to re-establish stale and/or dead connections? If enabled the driver will throw an exception for a queries issued on a stale or dead connection, which belong to the current transaction, but will attempt reconnect before the next query issued on the [...]]]></description>
		<link>http://www.javabloger.com/article/mysql-jdbc-autoreconnectforpools.html?source=rss</link>
			</item>
	<item>
		<title>公司招聘(长期有效)</title>
		<description><![CDATA[要求：
	1、Java基础良好，无需懂任何Java框架技术，
	2、Linux基础良好，无需了解所有Linux应用服务器，略懂MySQL
	3、能吃苦，不浮躁。
	4、工作一年或者应届毕业生

	工作地点：南京
	工作时间：每日7小时、每周五天工作时间
	公司规模：1000人左右
	薪水：3000-5000
	机会：国外项目有出国出差的机会、每年四次加薪机会

	福利：
	1、每年2次国内旅游，
	2、季度一次项目奖金、
	3、每天提供免费早餐、免费晚餐和午餐补贴、
	4、提供交通补助，
	5、每年一次体检、
	6、每月购买专业图书可按比例报销、
	7、季度吃喝腐败，户外互动一次、
	8、每月有1天可不来上班，不扣工资，时间自由支配，
	9、每周星期三可参加户外体育锻炼，
	10、每季度公司支付费用给部门进行技术培训，强化员工专业技术水平。
	联系方式：njthnet#gmail.com
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/java-linux-student.html?source=rss</link>
			</item>
	<item>
		<title>百万级 大型J2EE Push Mail 项目后记 3</title>
		<description><![CDATA[自从1998年 Google 利用廉价的互联网计算机，以最快的速度提供最精确的搜索结果， 这一创新技术成功地缩短了响应时间，提高了可扩展性，并降低了成本。是当今众多公司一直在效仿的技术。在这一项目中完全采用低廉的硬件投入，期望能通过软件的手段、利用分布式计算、集群技术 达到高效的计算，并且能加强系统的可扩展性，提高系统软硬件资源的使用率， 降低系统运行中瞬间的瓶颈。
通过这个项目让我们充分的认识到一个用户的系统 例如：单用户的 OutLook 和 一个百万级的系统的是截然不同的，系统中仅有100条数据和100w条数据的系统更是截然不同的，从100w条数据上升到上亿条数据那样的系统更会让人感受到无论从代码结构、数据库设计还是从系统架构都是完全不同的设计。
客户端环境
	&#160;&#160;&#160; MKT&#160;&#160;&#160; SDK
	&#160;&#160;&#160; C&#160;&#160;&#160; &#160;&#160;&#160; 语言开发环境&#160;&#160;&#160; 
	服务器端环境&#160;&#160;&#160;&#160;&#160; 
	&#160;&#160;&#160; Apache2&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; Web服务器
	&#160;&#160;&#160; mod_proxy&#160;&#160;&#160; &#160;&#160;&#160; Web负载均衡模块&#160;&#160;&#160; 
	&#160;&#160;&#160; HAProxy&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; 前端、数据库负载分载(后期使用)
	&#160;&#160;&#160; Java EE1.5&#160;&#160;&#160; &#160;&#160;&#160; 语言开发环境
	&#160;&#160;&#160; Jboss 4.0.5 GA&#160;&#160;&#160; 应用服务器
	&#160;&#160;&#160; Jboss MQ&#160;&#160;&#160; &#160;&#160;&#160; JMS服务器
	&#160;&#160;&#160; MySQL&#160; 5.1.4&#160;&#160;&#160; &#160;&#160;&#160; 数据库服务器
	&#160;&#160;&#160; EJB 3.0&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; Java 开发API 工具
	&#160;&#160;&#160; iBATIS&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; Java 开发API [...]]]></description>
		<link>http://www.javabloger.com/article/push-mail-architecture.html?source=rss</link>
			</item>
	<item>
		<title>Spring+Webwork整合 NoSuchMethodError 错误</title>
		<description><![CDATA[Spring+Webwork整合也是一个不错的选择，但是当你出现这个错误的时候，也许你以后花了很久还没有找到问题的根源，因为你肯本不会想到是webwork的源代码出了问题，出错的效果如下列所示：&#160;&#160;&#160;&#160; 
	&#160;
	严重: Exception starting filter webwork
	java.lang.NoSuchMethodError: com.opensymphony.webwork.spring.WebWorkSpringObjectFactory.setUseClassCache(Z)V
	at com.opensymphony.webwork.spring.WebWorkSpringObjectFactory.init(WebWorkSpringObjectFactory.java:63)
	at com.opensymphony.webwork.dispatcher.DispatcherUtils.init(DispatcherUtils.java:149)
	at com.opensymphony.webwork.dispatcher.DispatcherUtils.&#60;init&#62;(DispatcherUtils.java:83)
	at com.opensymphony.webwork.dispatcher.DispatcherUtils.initialize(DispatcherUtils.java:64)
	at com.opensymphony.webwork.dispatcher.FilterDispatcher.init(FilterDispatcher.java:130)
	at org.apache.catalina.core.ApplicationFilterConfig.getFilter(ApplicationFilterConfig.java:275)
	at org.apache.catalina.core.ApplicationFilterConfig.setFilterDef(ApplicationFilterConfig.java:397)
	at org.apache.catalina.core.ApplicationFilterConfig.&#60;init&#62;(ApplicationFilterConfig.java:108)
	at org.apache.catalina.core.StandardContext.filterStart(StandardContext.java:3709)
	at org.apache.catalina.core.StandardContext.start(StandardContext.java:4356)
	at org.apache.catalina.core.ContainerBase.addChildInternal(ContainerBase.java:791)

查看大图请点击这里
	
解决方法：
	
删除 &#160; xwork.jar (webwork-2.2.x 版本) 中 的 com/opensymphony/xwork/spring/SpringObjectFactory.class 程序
然后在你的工程中再新建一个SpringObjectFactory.java ，可以从这里下载 &#160; 要替换的程序，可以不放在xwork.jar中，直接在工程中 编译后和以前一样运行，现在你可以继续使用Spring+Webwork ，世界又恢复平静 。
	&#160;
	口水：
	最近每天事情很多，很想再把 push mail 的第三部写完，主要想说 EJB 、JMS集群、数据库散列。
]]></description>
		<link>http://www.javabloger.com/article/setuseclasscache.html?source=rss</link>
			</item>
	<item>
		<title>MySQL JDBC 集群</title>
		<description><![CDATA[如果按照网上大部分提供的资料，写成这样 url = jdbc:mysql://127.0.0.1,192.168.20.211/dbName ，仅仅只是用逗号分隔开，那是肯定不行的，当写在jdbc url地址中前一台的数据库(127.0.0.1)down掉以后，就算你重新启动还是会出现org.apache.jasper.JasperException: java.lang.NullPointerException 空指针异常，如图所示
	
	查看大图请点击这里
采用较新版本的 mysql-connector-java-5.1.6.jar&#160; MySQL JDBC 驱动，再将url写成这样url=jdbc:mysql:loadbalance://127.0.0.1,192.168.20.249/dbName 
	会将访问的压力分载到 127.0.0.1,192.168.20.211 2个机器上，还可以加上roundRobinLoadBalance=true参数，使用roundRobin算法，若是其中一台机器down掉以后，将会自动将不能访问的数据库服务器 踢除，如果还原后将继续进行压力分载。
	测试方案：
	1、你可以找2台数据库，保证这2台数据库的用户名和密码一致，然后建立2张同样的表，里面插入不同的数据，再通过web程序调用，你不断的刷新页面你将会看见 显示不同的数据，这样就说明 压力被分载到不同的数据库服务器上了。
	&#160;
	2、再将关闭其中一台服务器，看看是不是会 剔除 被关闭的那台机器直接访问目前活动的那台。
	3、如果再恢复，MySQL JDBC 驱动将会帮你 继续分载压力，呵呵。
	口水：
	Mysql JDBC 驱动的版本也非常的重要 ，建议使用 mysql-connector-java-5.1.6.jar 或者以上的版本。

	&#8211;end&#8211;
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/jdbc-mysql-loadbalance.html?source=rss</link>
			</item>
	<item>
		<title>百万级 J2EE Push Mail 项目后记2</title>
		<description><![CDATA[上一篇文章&#60;百万级 J2EE Push Mail 项目后记&#62; 说到了该项目的一些基本概况，这篇日志将讲述一些在开发过程中的与其他团队发生的故事。
这个 Push Mail 项目留给我最深的影响就是给我们团队来了丰厚的利润，客户他是一个美籍印度佬，就是我们常说的那种有钱人，做事爽快、干脆，也是全球移动领域具有影响的专家，因此他要求我们提供的服务必须是具有一个国际化专业水准的团队(International&#160; Corporate)。所谓专业化的主要需要体现在 1执行规范、2执行效率、3执行细节 这3个重要的环节上。

	在项目实施过程中除了搞J2EE 的开发者， TA、QA 、SA、DBA&#160; 一个也不能少。
	1、TA 小组根据制定的项目执行规范监管我们每个开发成员 在每个stage和里程碑的执行力，从需求分析的文档编写规范一直到最后的项目交付，他们才算结束使命。
2、QA 测试团队在我们需求和概要设计 就开始对jboss和mysql其他几项技术学习，其中测试人员与我们一同参与需求分析，这样将来他们才知道该如何配合我们做各种测试，进行深入的测试，而不是我们在引导他们在测试，他们100%能知晓业务 并且制定出不同的测试计划。并不是依靠我们自己测试或者我们在指导他们测试，那样运动员和裁判员都是同一人，那样肯定出问题。
3、SA 的压力最大 需要对系统整体的架构进行设计这个都是分内的事情，更重要的 在真实生产的环境遇到致命性错误，可以回退或者拿出现成的备份方案，把问题在短时间内化解。
4、DBA&#160; 需要从高往低的系统架构层次进行对数据库设计与整体规划，必须根据客户需求设计出具有远景的 方案，不是一成不变，更不是所谓&#8220;一步到位&#8221;的规划设计，是根据预计的数据增长 进行实施规划的不同方案。
5、开发者们需要对每个业务模块都要详细了解。因为我们需要降低风险 开发者们如果出现有人家里有事或者生病 任何一个成员都可以替代，不会出现我今天不来上班，导致项目进度拖慢一天的现象。
	在产品在设计开发到发布的过程中，我们分为四个阶段&#160; prototype、demo、stage、producting。
prototype 是一个原型，主要完成核心的部分，完成核心的功能和业务逻辑，开发团队内部评估使用。
demo 阶段是将产品的主要部分演示给客户看，让客户确认主体的方向。
stage 根据项目计划分为多个不同的stage版本，每个stage阶段的版本都会在stage服务器上由我们 测试人员先测试5-7天，再发布到真实的生产环境中。客户对这样的流程要求的非常的严格。因此 stage 服务器的配置和数量与 producting 环境是100%相同的，没有他们的邮件确认我们是不能擅自发布到 producting 环境中的，如果 producting 环境出现问题，必须在短时间内能回归到上一个稳定版本的状态 。 后期会在 stage 和 producting 服务器上轮回 ，fix &#8211;&#62; testing &#8212;&#62; release。
我们当时使用SVN和Trac，值得一提的是Trac这个东西，客户有任何需求变更 通过 Trac [...]]]></description>
		<link>http://www.javabloger.com/article/j2ee-push-mail-of-team.html?source=rss</link>
			</item>
	<item>
		<title>百万级 J2EE Push Mail 项目后记</title>
		<description><![CDATA[昨天一个新同事向我问起了Push Mail的解决方案的整体架构和思路，滔滔不绝的讲完以后，勾起了我不少的回忆。那是在3年前发生的事情，当时这个客户(美国人)的需求就是一句话：&#8220;我要做一个Push Mail全套解决方案。&#8221; 就是这句话我们写了厚厚的一份英文需求文档。从需求分析到最后交付我们将尽用了2年左右的时间，从 系统架构、程序发开、再到系统重构、这样的经历依然 历历在目。
项目当时就我们5个人在做，可以说这5个人都是百里挑一的人选，但我们需要面对以下挑战：
	1、虽然都是搞J2EE的老手，都没有接触过Push Mail这样的国外项目，所以对业务的精髓不能完全吃透，导致理解需求比较吃力。
	2、在3个月内完成演示版本，证明业务可行性；9个月内构建完全产品化的系统。
	3、系统需要支持大并发，海量数据，系统必须达到很高性能指标。
	4、提供7X24及时服务，在第一时间解决任何技术问题。(有时差，客户在睡觉我们在工作，客户在工作，我们不能睡觉还在工作。)
	5、对J2EE以外的技术只有1-2人了解。比如：分布式计算、应用服务器,数据库集群技术 和 大型系统的数据、文件 存储方案。
但是再我们所有成员的不断努力下，这些困难都被我们一一解决。
项目里面牵涉打了J2EE 领域多项技术，也算是一个难点吧，因为下列技术跨度都比较大，例如：
	1、Servlet (协议请求、回送)
	2、XML (协议解析)
	3、JavaMail (邮件收发)
	4、EJB (分布式计算)
	5、ibatis(数据库操作)
	6、JMS/MDB (采用分布架构中的内部通讯方式)
	7、多线程和线程池 (多任务提取邮件)
	8、还有很多 J2EE规范以外的技术， 例如：httpclient 网页抓取、html 解析、Office附件处理、图片压缩 、加密/解密 等等。
客户全部选择了将服务器部署在Amazon云环境上，大约总共有40几台。其中数据库采用了MySQL服务器，我们运用分库+同步技术来解决大规模存储和查询，应用服务器我们采用了Jboss。 MQ服务器采用的是Jboss的MQ。前端采用Apache和CDN做请求压力分载。操作系统采用64位的 Ubuntu 8。
&#160;
口水：
	1、可能还会打算再写一篇关于所有内幕技术的详细介绍的一篇文章，讲述大型 Push Mail的解决方案和如何运用J2EE技术的，以及遇到的性能瓶颈和一些致命错误。
	2、上述文字的不牵涉到任何公司，任何技术团队的机要信息。纯属虚构，如有雷同，纯属巧合。
&#160;
&#8211;end&#8211;
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/j2ee-push-mail-project-story.html?source=rss</link>
			</item>
	<item>
		<title>GlassFishv3 设置虚拟主机</title>
		<description><![CDATA[GlassFishv3 设置虚拟主机网上很多人说采用 Apache 或者 Nginx 作为前端机器，需要配置2个应用服务器才行。
	其实事情没有那么复杂，glassFishv3下实现 虚拟主机 功能&#160; 2-3个步骤即可搞定，首先确保 GlassFishv3已经启动, 然后上传你的web war工程.比如：2个不同的域名访问到同一个服务器，然后经过GlassFish的虚拟服务器解析，给客户端/访问者回应不同的站点内容。
	最终效果:
	client&#8212;-&#62;ddns.javabloger.com&#8212;&#62; 显示ddns&#160;&#160; 站点内容 &#8212;-&#62; 调用 Serv1服务器下ddns.war 应用程序 
	client&#8212;&#62;home.javabloger.com&#8212;&#62; 显示home 站点内容 &#8212;-&#62; 调用&#160; Serv1服务器下home.war 应用程序 

	输入以下命令后，不重启GlassFish 配置也可以生效，除非意外情况需要重启。
	命令介绍
	asadmin create-virtual-server &#8211;hosts ddns.javabloger.com &#8211;httplisteners http-listener-1 vs1
	说明:创建一个虚拟主机别名为 vs1，虚拟主机指向的站点域名是 ddns.javabloger.com，使用GlassFish 服务器中 http-listener-1 监听器
	asadmin deploydir &#8211;name vs1 &#8211;contextroot /&#160; &#8211;virtualservers vs1 /sa1/ftp/ddns.war
	说明: 部署 /sa1/ftp/ddns.war war程序到 虚拟主机 vs1中，&#8211;contextroot /&#160; 表示 用户访问的ddns.javabloger.com站点目录&#160; /
	命令介绍
	asadmin [...]]]></description>
		<link>http://www.javabloger.com/article/glassfish-virtualhost.html?source=rss</link>
			</item>
	<item>
		<title>Spring集成 JMS OpenMQ</title>
		<description><![CDATA[前端时间采用JMS API 直接访问 OpenMQ JMS服务器会出现一个现象，当JMS服务器down掉以后或者重启以后，JMS的接收端将无法工作，如果将程序改成MDB的方式将违背了我们的初衷，所以采用一个相对折中的办法，采用Spring整合JMS OpenMQ。
不仅可以解决我们现在存在的问题，并且有以下优势：
1、占用资源资源少，对硬件配置要求低
	2、部署简单、灵活，不限制于某种特定的J2EE容器
	3、依托微容器管理扩展性强
代码如下：
连接器
	
package com.javabloger.jms;
	import java.util.Enumeration;
	import java.util.Properties;
	import javax.jms.XAConnectionFactory;
	public class OpenMqConnectionFactory {
	&#160;&#160;&#160; 
	&#160;&#160;&#160; private Properties props;
	&#160;&#160;&#160; public void setProperties(Properties props) {
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; this.props = props;
	&#160;&#160;&#160; }
	&#160;&#160;&#160; public XAConnectionFactory createConnectionFactory(){
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; com.sun.messaging.XAConnectionFactory cf =
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; new com.sun.messaging.XAConnectionFactory();
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; try{
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; Enumeration&#60;?&#62; keys = props.propertyNames();
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; while (keys.hasMoreElements()) {
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; String name = (String)keys.nextElement();
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; String value = props.getProperty(name);
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; cf.setProperty(name, value);
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; }
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; } catch [...]]]></description>
		<link>http://www.javabloger.com/article/spring-jms-openmq.html?source=rss</link>
			</item>
	<item>
		<title>Google趋势告诉我们南京人最爱吃龙虾</title>
		<description><![CDATA[Google 趋势(Google Trends)对于SEOer来说是一个相当重要的工具，他可以让你宏观的去看待关键字和google搜索引擎之间的关系和所蕴含着一定的商业价值。我们就拿生活中的一些名词为例 输入在Google趋势(Google Trends)中 输入&#8220;龙虾&#8221;、&#8220;回锅肉&#8221;、&#8220;美食&#8221; 将会显示如下内容，如图所示：
龙虾 (南京排在第一个)
	
	查看大图请点击这里
美食(南京排在上海前面)

	查看大图请点击这里
	
回锅肉 (四川省排在第一是必然的)
	
	
查看大图请点击这里
&#160;
我的废话：
	1、Google趋势的趋势图形有点跟股市的趋势图表相似，如果我们能通过一些历史数据推测出下一个波段某个关键词的高点，那么你就能把握一定的商机，就像你购买一支赚钱的&#8220;潜力股&#8221;一样。
2、也可以根据现在的关键字走势，决定你网站的关键词的中心和SEO软文的编写方向。
3、你可以通过google趋势提供的信息，将地区、时间、关键词 分为3个维度，去度量你网络营销的方向和重点。例如：我们现在查看 &#8220;龙虾&#8221;关键字在2007、2008、2009年的入夏时候被命中率最高，但频率逐年降低，动动脑筋，看看你能想到那些商机？
&#160;
关于Google趋势
	&#160;&#160; Google 趋势会分析一部分 Google 网络搜索以计算用户输入的字词被搜索的次数，并将其与 Google 上随时间推移的搜索总量相比较。然后Google会用图表向用户显示搜索的趋势和全球所有用户的结果，将按线性比例绘制的搜索量图表。Google 趋势产生的数据可能会因众多原因（包括数据采样问题以及所采用的各种近似算法）而不甚准确。Google目前每天对 Google 趋势提供的信息更新一次；热门趋势数据会每小时更新一次。 
	&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/google-trends-tells-us-about-nanjing-people.html?source=rss</link>
			</item>
	<item>
		<title>Spring3 REST 上传多个文件</title>
		<description><![CDATA[前端时间讲述了在spring3下如何上传文件的例子(Spring3文件上传,提速你的Web开发)，现在又需要使用Spring3对多个文件在REST(MVC)中进行上传，经过一番研究，将整理的内容归档如下， 废话少说看2段代码
jsp / html的 上传界面
&#60;html&#62;
	&#60;FORM enctype=&#34;multipart/form-data&#34;&#160; METHOD=&#34;POST&#34; ACTION=&#34;image/upload2&#34;&#62;
	&#160;&#160;&#160; &#60;input type=&#34;file&#34; name=&#34;file&#34; /&#62;&#60;br&#62;
	&#160;&#160;&#160; &#60;input type=&#34;file&#34; name=&#34;file&#34; /&#62;&#60;br&#62; 
	&#160;&#160;&#160; &#60;input type=&#34;text&#34; name=&#34;text&#34; value=&#34;text&#34;&#62;&#60;br&#62; 
	&#160;&#160;&#160; &#60;INPUT TYPE=&#34;submit&#34;&#62; 
	&#60;/FORM&#62;
	&#60;/html&#62;
主要action java的代码
/**
	&#160;&#160;&#160; ** 上传单多文档
	&#160;&#160;&#160; */
	&#160;&#160;&#160; @RequestMapping(value = &#34;/upload2&#34;)
	&#160;&#160;&#160; &#160;public String upload2(
	&#160;&#160;&#160; &#160;&#160;&#160; MultipartHttpServletRequest request ,
	&#160;&#160;&#160; &#160;&#160;&#160; @RequestParam(&#34;text&#34;) String text&#160;&#160;&#160; // 页面上的控件值
	&#160;&#160;&#160; &#160;&#160;&#160; ) throws Exception {
	&#160;&#160;&#160; &#160; String path=UploadController.class.getResource(&#34;/&#34;).getPath().split(&#34;WEB-INF&#34;)[0]+&#34;upload/images/&#34;;&#160;&#160; // 获取站点下的绝对磁盘路径
	&#160;&#160;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/spring3-rest-multiparthttpservletrequest.html?source=rss</link>
			</item>
	<item>
		<title>从顾问咨询到实施过程中的这些日子</title>
		<description><![CDATA[&#160;&#160; 这些日子里我们不断的在认识新的朋友，也不断的在学习新知识，这些朋友中有很多都是我们目前在服务的客户，学到的新知识并不局限于Java 或者 软件领域。
&#160; 这些客户让我们了解到例如： 外贸服装，娱乐餐饮，教育培训 ，家用电器 等等 这些行内的故事和业务知识，我们需要感谢这些客户，因为他们弥补了我们生命中空白的知识领域。 
	&#160;&#160;&#160; 在整个项目实施过程中我们渐渐的积累了很多经验，知道什么是客户关心的，什么是客户最需要，什么是客户最担心的，什么是我们最紧急需要完成的，等等。
	在整个项目的开发过程中每个成员彼此有过分歧，有过种种困难，但没有人因此而离开，因为艰辛过程让我们团结的更紧密。在整个实施的过程中让我看见我们的每个成员，更像是一群在沙场上奋不顾身的战士，他们知道绝不能因为自己的个人因素影响到整个团队的收入回报。
	&#160;&#160; 这短暂的半年中我们所遇到的每个客户的需求都不同，每个客户涉及的行业也不同，但是他们对于我们来说的共同之处是，都迫切的需要我们对他们进行服务。
&#160;&#160; 在最近与客户的谈话中了解到我们的报价并不是最低廉的，但是因为2个主要原因客户最终都选择了我们。
	&#160;&#160;&#160; 1.我们赢的不是其他的对手，而是客户，我们明白客户不是需要我们写的代码，而且通过我们实施的IT技术能给他们带来更多的回报。
	&#160;&#160;&#160; 2.来自客户对我们的信任，因为我们表达方式直接，很容易让人接受。拿出的方案明了，令客户感受到我们的专业。
	&#160;&#160; 我们期待能与更多的客户合作，与客户共同成长。
	&#160;&#160; 令人高兴的事情还包括，团队成员的人数也在不断的增加，在此我代表团队所有成员期待更多的新成员能够加盟。
&#160;
BTW:感谢我的太太，为我付出的忍耐。

	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/implementation-of-these-days.html?source=rss</link>
			</item>
	<item>
		<title>修改源码提高JavaMail比较新邮件效率</title>
		<description><![CDATA[在JavaMail API 里还是一封封的去比较邮件，如果连接上服务器可以发一个命令就可以获得所有的邮件头列表是多么好的事情，可惜Javamail暂时没有提供这样的功能，我们只能自己丰衣足食了。把 POP 的UIDL 命令写在 JavaMail&#160; API 里进行调用。
你可以先看一下原先的方法最古老的方法，详见：《JavaMail议判断新邮件的思路》
其中
	for (int i = 0; i &#60; messages.length; i++,j&#8211;) 
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; System.out.println(inbox.getUID(messages[i]));&#160;&#160;&#160;&#160;&#160;&#160;&#160;
	} 
	这段代码我们就能看见需要一封一封的进行获得邮件UID，而我们下面提出的方法要比这样的效率高很多。
	你可以下载JavaMail的源代码，修改JavaMail 源代码 com.sun.mail.pop3.Protocol 和 POP3Folder 2个程序，在代码中添加如下部分
	&#160;================================Protocol.java===================================================
	&#160;&#160; &#160;public ArrayList&#60;String&#62; extendCommand(String cmd) throws IOException {
	&#160;&#160; &#160;&#160;&#160; &#160;log.info(&#34;extendCommand &#8230;&#8230;&#8230;&#8230;&#8230;.&#34;);
	&#160;&#160; &#160;&#160;&#160; &#160;ArrayList&#60;String&#62; msgID = new ArrayList&#60;String&#62;();
	&#160;&#160; &#160;&#160;&#160; &#160;if (socket == null)
	&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; &#160;throw new IOException(&#34;Folder is closed&#34;); // &#160;
	&#160;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/javamail-compare-new-email.html?source=rss</link>
			</item>
	<item>
		<title>集群环境中系统报警与自动修复</title>
		<description><![CDATA[Nagios 在大型集群环境中主要担任监控与报警的任务，可以监控系统的内存，CPU，磁盘运行状态，还可以监控系统中运行的服务 例如：JVM、Oracle、MySQL 、Jboss 、Apache&#160; 的使用状态，对于一些特殊的软件还可以编写各种脚本来进行监控和报警，整体系统架构 如图所示：

除了邮件报警以外还可以通过短信报警，例如中国移动的 &#8220;飞信&#8221; 进行短信报警(免费)，或者采用GSM手机，下图中一台在局域网中的Nagio监控服务器对网络设备和linux主机进行监控，如果发送异常状态立即将管理员的手机发送报警短信， 如图所示：
	
&#160;
Nagios的可扩性非常强大，更强大的功能是Nagios还可以对通过脚本对出现故障的应用服务进行自动修复。
实现原理其实不算很难，Nagios本身发邮件也是通过调用命令/脚本来实现的，那么在发送邮件的同时，把远程登录，并且修复的脚本和发送邮件部分的脚本捆绑在一起，即可实现。
&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/nagios-linux-cluster-auto-fix.html?source=rss</link>
			</item>
	<item>
		<title>GlassFishV3出现 CLOSE_WAIT与can&#8217;t identify protocol</title>
		<description><![CDATA[&#160;
	如果反复检查你的代码都没有问题，那么问题主要是由于GlassFishV3 中glassfish-grizzly 导致的现象，glassfish-grizzly是将apache的catalina.jar进行再次包装成web-core.jar程序。
	解决问题方法：
	1,执行$install_dir/bin/pkg image-update&#160; &#160;
	将glassfish进行升级，并且重启，切记如果GlassFish在运行业务时，请不要运行这个命令，因为将会导致整个系统的正常运行。
	2,在 domain.xml 文件 的jvm 配置项中加入 
	&#60;jvm-options&#62;-Dcom.sun.enterprise.server.ss.ASQuickStartup=false&#60;/jvm-options&#62;
	保存，并且重启。
	&#160;

	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/glassfishv3-close_wait-cant-identify-protocol.html?source=rss</link>
			</item>
	<item>
		<title>JavaBloger 网站的android客户端</title>
		<description><![CDATA[最近事情比较多，公司的项目已经让人忙的天昏地暗，但还是抽了点时间学习了一下android方面的知识。
为雇主和自己的客户们提供更好的服务，为提供一整套的 &#8220;移动云计算&#8221;的解决方案打下基础。
	忙里偷闲，折腾了一个客户端，别看这个客户端功能和式样单一，至少对我来说比较重要，可以让我在新领域中(mobile)开辟更多的机会。
	客户端与服务器端通信采用自定义的XML，客户端 &#8220;离线阅读器&#8221; 从Javabloger 网站下载所有文章列表(xml)后，根据手机上的文章标题用户可以查看需要阅读的文章，当点击具体文章的时候才从网站下载更多的数据&#160; 某篇文章的详细内容。
	一共分为4个主要功能：1文章下载，2文章查看，3文章搜索&#160; 4帮助与其他 。
	如图所示：
	主界面
	
	搜索
	
	搜索结果
	
	文章列表
	
	文章内容
	
	下载更新&#160;&#160;&#160; 
	
	&#160;
你还可以下载此客户端程序，在你的android手机里运行 ，下载地址。
&#8211;end&#8211;

	&#160;
]]></description>
		<link>http://www.javabloger.com/article/javabloger-android-client.html?source=rss</link>
			</item>
	<item>
		<title>ganglia多点系统监控实践 (二)</title>
		<description><![CDATA[在上一篇文章中讲述了ganglia的系统架构和工作原理，现在介绍一下在RedHat CentOS中对J2EE系统运行状态监控的
	2句口水：
	1.如果是在安装多次失败或者正在寻求一个简单有效安装 ganglia 的方法，当你能看见这篇文章的时候你非常幸运了，因为这是作者经过多次失败的经验的总结，得出的最佳的安装方法了。
	2.本文还讲述对ganglia 集群分组的配置方法。

	一、实现原理

Gmond 代理- 收集、度量每个服务器的信息
gmetad 管理 &#8211; 度量agent 对一个或多个具体的任务导向的服务器上安装
Apache web serv &#8211; 展示服务器度量的信息
Multicast 多播 &#8211; 所有gmond节点都能够听和报告整个群集状态
故障转移 &#8211; gmetad的有能力的群集节点切换公制数据是调查
重量轻- 低开销度量收集和运输
可以运行在 windows、Linux、FreeBSD、Solaris 等不同的操作系统平台

如图所示：

	查看大图请点击这里
二、安装、配置
ganglia 主要配置文件
	/ect/gmond.conf
	/etc/gmetad.conf
	/usr/local/apache/htdocs/ganglia/conf.php
	第一步：
	// 1.安装所有需要的软件
	rpm -Uvh http://download.fedora.redhat.com/pub/epel/5/i386/epel-release-5-3.noarch.rpm
	yum install rrdtool ganglia ganglia-gmetad ganglia-gmond ganglia-web httpd php apr apr-util
	第二步： //配置代理节点&#160; 
	&#160;//1配置代理节点&#160; 
	cluster {
	&#160; name = &#34;cluster1&#34;&#160;&#160;&#160; // 
	&#160; owner = &#34;owner1&#34;
	&#160; latlong = &#34;unspecified&#34;
	&#160; url = &#34;unspecified&#34;
	}
	udp_send_channel [...]]]></description>
		<link>http://www.javabloger.com/article/j2ee-linux-ganglia-rrdtool-java-mysql-2.html?source=rss</link>
			</item>
	<item>
		<title>最近的那点事</title>
		<description><![CDATA[项目中不断的、不断的、不断的、不断的 出现各种技术问题，
	&#8220;为什么还是慢？&#8221; &#8220;为什么不稳定？&#8221;&#160; &#8220;为什么不能坚持到xx分钟以后就down？&#8221; &#8220;为什么不能访问了？&#8221;&#160; &#8220;为什么又不显示日志了？&#8221;
	客户的抱怨，我们技术团队承受着非常大的压力,
	客户的迫切，我们必须在非常短暂的时间内完成任务，
	客户的心情，我们必须去换位思考，他的成功也是我们的成功，
	客户的满意，我们感受到了成就感和喜悦。

	我们无奈，但始终没有放弃，
	我们疲倦，但从来没有趴下，
	我们喜悦，但不会忘记经历，
	我们欢笑，但不会忘记背后为我们默默支持的亲人。
	结果总是好的，因为我们从来没有放弃过了，因为我们的这份诚恳也打动了客户。

	&#160;口水：
	&#160;&#160;&#160; 在不牵涉到公司任何技术机密的前提下，我会在写一些技术分享，提供大家参考。
&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/some-time.html?source=rss</link>
			</item>
	<item>
		<title>喜欢这部电影中的所有男性演员</title>
		<description><![CDATA[
	
	
	
	
	

	ps:我最近真的太忙了，但跟看电影无关。 

	&#8211;end&#8211; 
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/love-mans.html?source=rss</link>
			</item>
	<item>
		<title>集群下的ganglia多点系统监控 (一)</title>
		<description><![CDATA[ganglia介绍
	ganglia 是 UC Berkeley (伯克利 大学)发起的一个开源监视项目，用于测量数以千计计算机的节点。每台计算机都运行一个收集和发送度量数据，可以监控CPU速度、内存使用状态，还可以和其他第三方的插件结合使用，可以监控系统中更多内容，比如：Java、MySQL 等等。用户通过一个浏览器便可纵观全局上千台服务器各种运行状态。
	如图所示：
	
	系统架构
	便于读者对整个系统有个宏观认识,先来看一下ganglia 整个系统架构。
	
	在图中我们可以看出 
	1.管理节点(gmetad) 向代理节点(gmond) 发送请求信号，
	2.gmond服务开始收集机器运行状态，将收集数据变成XML报文回送给gmetad 管理节点。
系统构成
	gmetad:&#160; 收集各结点的数据并保存到数据库中
	gmond:&#160;&#160; 收集本地机器的信息，并发送数据
	rrdtool:&#160;&#160;&#160; Round Robin Database Tool是一个强大的绘图的引擎，很多工具例如MRTG都可以调用rrdtool绘图。
	apache:&#160; web服务器
	php:&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; 执行环境，webfrontend使用php开发
	1台监控服务器
	n台被监控机
	工作原理
	ganglia是一个 C/B + B/S 结合的系统，整个工作过程如图所示：
	
	1.管理节点通过gmetad.conf 配置文件中的代理节点主机列表地址和代理节点相互通信，大概三分钟轮询一次。
	2.管理节点收集每个代理节点的机器运行信息，这些信息是通过XML协议进行传输。
	3.管理节点收集到代理节点的XML协议后，解析成管理节点需要的数据格式。
	4.再通过管理节点的 PHP 程序 调用 rrdtool 工具，将数据转换成图形。
	5.当用户在浏览器上输入管理节点的 url地址 就可以看见图形化的数据了。

	稍后将介绍 ganglia在linux 的安装与配置。

	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/j2ee-linux-ganglia-rrdtool-java-mysql-1.html?source=rss</link>
			</item>
	<item>
		<title>J2EE集群性能优化点滴(ngixn+servlet server+memcache)</title>
		<description><![CDATA[&#160;废话少说，进入正题。
清单:
	&#160; jar包 5个 
	&#160; jsp测试页面 1个
	&#160; Nginx 配置文件1个
	&#160; Tomcat Server.xml 配置文件 2个
	前置条件，需要安装以下软件：
	&#160; Tomcat 服务器&#160; 2台+
	&#160; Nginx 服务器&#160;&#160;&#160; 1台
	&#160; Memcached&#160;&#160;&#160;&#160;&#160; 1台
	&#160; JDK1.5+
	&#160; IE/Firefox 浏览器
	一、下载下列几个 Jar包
	http://memcached-session-manager.googlecode.com/files/memcached-session-manager-1.3.0.jar
	http://memcached-session-manager.googlecode.com/files/msm-javolution-serializer-jodatime-1.3.0.jar
	http://memcached-session-manager.googlecode.com/files/msm-javolution-serializer-cglib-1.3.0.jar
	http://spymemcached.googlecode.com/files/memcached-2.4.2.jar
	http://memcached-session-manager.googlecode.com/files/javolution-5.4.3.1.jar
	将以下几个Jar包Copy到 $TOMCAT_HOME/lib目下，每个Tomcat节点都需要有。
	二、配置Tomcat的Server.xml配置文件，样本可以点击这里下载，主要内容如下：
	http://www.javabloger.com/images/2010-05/webcluster/server.xml.txt
	&#160;&#60;Context docBase=&#34;D:\webapp&#34; path=&#34;&#34; reloadable=&#34;true&#34; &#62;&#160; 
	&#160;&#60;Manager className=&#34;de.javakaffee.web.msm.MemcachedBackupSessionManager&#34;&#160; 
	&#160;&#160;&#160;&#160; memcachedNodes=&#34;n1:localhost:11211&#34;&#160; 
	&#160;&#160;&#160;&#160; requestUriIgnorePattern=&#34;.*\.(png&#124;gif&#124;jpg&#124;css&#124;js)$&#34;&#160; 
	&#160;&#160;&#160;&#160; sessionBackupAsync=&#34;false&#34;&#160; 
	&#160;&#160;&#160;&#160; sessionBackupTimeout=&#34;100&#34;&#160; 
	&#160;&#160;&#160;&#160; transcoderFactoryClass=&#34;de.javakaffee.web.msm.serializer.javolution.JavolutionTranscoderFactory&#34;&#160; 
	&#160;&#160;&#160;&#160; copyCollectionsForSerialization=&#34;false&#34;&#160; 
	&#160;&#160;&#160;&#160; /&#62;&#160; 
	&#160;&#60;/Context&#62; 
	每个Tomcat的节点都需要修改。
	三、前端分发的Ngixn的配置文件也需要修改，样本可以点击这里下载，主要内容如下：
	http://www.javabloger.com/images/2010-05/webcluster/nginx.conf.txt
	#gzip&#160; on;&#160; 
	&#160;&#160;&#160;&#160;&#160; upstream&#160; www.docyeah.com&#160;&#160; {&#160; 
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; server&#160;&#160; 192.168.1.103:81;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/ngixn-j2ee-tomcat-memcache-session-share.html?source=rss</link>
			</item>
	<item>
		<title>一个J2EE集群下山寨架构</title>
		<description><![CDATA[我的废话：1.生命在于折腾，作为技术实践的目标是采用更廉价的成本，带来更高的计算能力。2.本文纯属口水，无牵涉到我现在的雇主和将来雇主公司的技术内幕话题，纯粹个人观点。
	&#160;
	目前我们通常的手段把集群的服务器最前端放置一台Apache或者Ngixn作为一个负载均衡策略的机器，但是经过前段时间的压力测试测试，发现最后的瓶颈落在了2个话题上：
	1、网络的带宽 
	2、前置的Apache或者Ngixn
出现这样的问题，针对第二点，让我有了新的想法。
	口水一下：网上传说中 Ngixn 比 Apache强N多倍，但是经过我的多次反复压力测试，并非如此，并没有传说中的那么大的差距，所以我需要告诉大家一下。(很多时候还是需要自己去做论证)。 
	&#160; 
	现在我想到的一个新的解决方案，也是一个山寨方案，因为光是采用LVS对session不好管理，大家不要我笑啊，有问题尽管抛砖，呵呵。
	不用Apache或者Ngixn当前置机器，改成iptables+ipvsadm+heartbeat&#160; 等技术组合成一套ip轮询策略(可集群)，并进行负载均衡。
	&#160;
	以前用Apache在最前端的 http上做转发和session管理，现在我将转发改成tcp/ip协议，从理论上来说将会比原来的效率高很多，而且对机器的配置要求也会低很多，这样说明最前端的设备将会能支持更多的并发请求，而且将来我们满足更多的广泛应用，比如：针对我们将来遇到的项目，可以支持 imap(Qmail/Postfix) 邮件服务器集群方案，MySQL N+1负载均衡的廉价解决方案，这为我们将来在非web应用层上做大规模集群、负载均衡 计算打下基础。
	&#160;
	当然，我们还可以采用HA-Proxy的方案，针对邮件服务器集群和MySQL负载均衡也是很不错的解决，并且现在已经能在公司的pc机器上跑起来，那么为什么要需要采用上面我说的那种方案，因为iptables+IP策略比HA-Proxy更靠近底层协议，更直接，会带来更高的效率。
	&#160;
	下面再来介绍一下这个方案：
	1.首先最前端将会有2个机器采用heartbeat 技术做集群(双机备份)，防止其中一台机器down掉
	2.在最前端采用iptables+ipvsadm做 TCP/IP的转发策略发送到指定的机器，对外提供一个虚拟的ip地址，如果其中一台机器down掉，ipvsadm将会自动踢出，复活后自动加入。
	3.J2EE/Servlet 服务器如果接受到转发的请求中包含session会话，将通过容器中自己开发的Servlet 过滤器程序进行管理，放入最后端的存储服务器 MySQL的内存表或者Memcached、MongoDB 等，总之基于内存存储的服务器。
	4.最后端的存储服务器将会做双机备份，防止用户的session数据丢失。
	&#160;
	整个架构如图所示：
	&#160; 
查看大图请点击这里
	&#160; 
	&#8211;end&#8211;
&#160;
]]></description>
		<link>http://www.javabloger.com/article/j2ee-jiqun.html?source=rss</link>
			</item>
	<item>
		<title>MongoDB 客户端工具,不断收集ing(图)</title>
		<description><![CDATA[NoSQL的运动不止，MongoDB 作为其中的主力军发展迅猛，但是图形化工具少见，我在此做了一个简单的收集，如果将来有新发现将会不断更新。
	mongodbHUB 在mac和Windows都有本版
	开源地址: http://github.com/bububa/MongoHub-Mac
	下载地址: http://github.com/downloads/bububa/MongoHub-Mac/MongoHub.zip
	另外还有之前用Titanium Desktop做的，用Win或Linux的可以试试。
	http://github.com/bububa/MongoHub
	windows 下载地址：
	http://cloud2.appcelerator.net/win32_win32/1bdd2f931d52d518c0b25b31c1f30182/9092b680-4ec3-4538-91ec-b937e644eb79/MongoHub.exe
	如图所示：
	
	在看一个B/S基于php的 phpmoadmin
	下载地址：
	http://code.google.com/p/phpmoadmin-mongodb-admin-tool-for-php/
	如图所示：
	
	还有一个是根据CouchDB进行改写的
	下载地址：
	http://github.com/sbellity/futon4mongo
	如图所示：
	
	mongo3是基于MongoDB 集群管理工具
	下载地址：
	http://www.mongo3.com/
	如图所示：
	
	&#160;
RockMongo 是一个PHP5写的MongoDB管理工具。
	支持中文极好，运行速度快，安装简单，还可以查看 GridFS 分块

点击 http://code.google.com/p/rock-php/downloads/list 下载最新的版本.

	MongoDB Java ORM 的设想
	mongodb 入门 介绍  
	MongoDB 集群
	MongoDB 主(Master)/从(Slave)数据同步 
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/mongodb-gui-win-linux-mac.html?source=rss</link>
			</item>
	<item>
		<title>Spring3 REST中的@</title>
		<description><![CDATA[&#160;@RequestMapping @RequestParam @PathVariable @ModelAttributes @SessionAttributes @CookieValue @RequestHeader 都是Spring MVC REST中的注释方法，这几种注释方法的用法如下：
	1#Controller 示例
	URL示例： POST /users/query?userId=1234
	@Controller
	public class&#160; JavaBlogerController {
	&#160;&#160;&#160; @Autowired
	&#160;&#160;&#160; JavaBlogerService serviceLayer;
	&#160;&#160;&#160; @RequestMapping
	&#160;&#160;&#160; public String delete(@RequestParam String userId ){
	&#160;&#160;&#160; serviceLayer.query (userId);
	&#160;&#160;&#160; return &#34;redirect:list&#34;;
	&#160;&#160;&#160; }
	}
	2#CookieValue 示例
	@RequestMapping (&#34;/userList&#34;)
	&#160;&#160;&#160; public String delete(@CookieValue(&#34;JSESSIONID&#34;) String sessionId ){
	&#160;&#160;&#160; &#160;
	&#160;&#160;&#160; }
	注释表明，CookieValue方法的参数可以绑定到HTTP的Cookie。支持在Servlet和Portlet环境注明处理方法。
	
	3#RequestHeader示例
	显示结果
	User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.0.11)
	Gecko/2009060215 Firefox/3.0.11 (.NET CLR 3.5.30729)
	Accept-Language: en-gb,en;q=0.5
	Accept-Encoding: gzip,deflate
	Keep-Alive: [...]]]></description>
		<link>http://www.javabloger.com/article/spring3-rest-annotation.html?source=rss</link>
			</item>
	<item>
		<title>Spring3 REST实现html伪静态分页效果</title>
		<description><![CDATA[废话1句：
	需要知道伪静态页面对与一个网站的作用与好处,详见这篇文章&#8220;搜索引擎与网站开发优化&#8221;。
广告1段：
	我用Spring3在Google App Engine上发布带分页的例子，http://spring3-rest.appspot.com/demo.html ， 稍后提供源码。
	


以下是正文
	

	当Spring3 REST 程序运行在Eclipse中 在控制台上打印出以下这些信息
	org.springframework.web.servlet.handler.AbstractUrlHandlerMapping.registerHandler(AbstractUrlHandlerMapping.java:410) Mapped URL path [/business/query] onto handler [com.aswish.web.action.BusinessController@27982]&#160; 
	&#160;2010-05-24 09:41:53,943 INFO&#160;&#160; org.springframework.web.servlet.handler.AbstractUrlHandlerMapping.registerHandler(AbstractUrlHandlerMapping.java:410) Mapped URL path [/business/query.*] onto handler [com.aswish.web.action.BusinessController@27982]&#160; 
	&#160;2010-05-24 09:41:53,943 INFO&#160;&#160; org.springframework.web.servlet.handler.AbstractUrlHandlerMapping.registerHandler(AbstractUrlHandlerMapping.java:410) Mapped URL path [/business/query/] onto handler [com.aswish.web.action.BusinessController@27982]&#160; 
这说明可以采用任 何 一个URL进行访问 /business/query &#160;这个链接，例如：
	Accept:&#160; /business/query.xml
	Accept:&#160; /business/query.json
	Accept:&#160; /business/query.htm
	Accept:&#160;/business/query.html
	
看看这个图上的展示的效果，页面上展示的数据是动态的并且是带分页的，让人看起来却是一个静态的页面，另外值得一提的是采用这样的方式进行开发，并没有增加成本，反而比以前更显得简单。
	
	&#160;
以上代码示例可以参考另外一篇文章：
	Spring3 REST MVC框架,提速你的Web开发
口水2下：
我们来看一下 javaworld.com对伪静态页面的处理，有些文章需要进行分页的时候看起来就不是很友好，后面多了一个page=2， 
	示例：http://www.javaworld.com/javaworld/jw-05-2009/jw-05-troubleshooting- oc4j-and-weblogic.html?page=2
在网上看见一个老外也在Google App Engine 上玩Spring3，我跟他的玩法不一样，不过他介绍的具体过程比较详细，呵呵
http://ice09.wordpress.com/2010/03/15/spring-3-rest-xml-running-on-the-google-app-engine/
&#8211;end&#8211;
	源代码示例
	
]]></description>
		<link>http://www.javabloger.com/article/spring3-rest-java-on-google.html?source=rss</link>
			</item>
	<item>
		<title>Spring3 REST 中文乱码</title>
		<description><![CDATA[在项目进行中遇到了常见的乱码问题，但用常见的解决手段无法解决，最后没修改代码，也没添加servlet过滤器，修改Web容器 Tomcat下的server.xml配置文件，修改内容为：

	&#160;
	在Connector port=&#34;8080&#34;节点中 添加&#160; URIEncoding=&#34;UTF-8&#34;&#160; 配置选项 世界又恢复了平静。
BTW:
	如果你是在Eclipse开发环境下运行web容器产生的乱码现象,那么请找到 x:\workspace\.metadata\.plugins\org.eclipse.wst.server.core 目录，修改里面的server.xml文件。
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/spring3-rest-utf-8-iso8859.html?source=rss</link>
			</item>
	<item>
		<title>Java对MongoDB文件的存取操作</title>
		<description><![CDATA[MongoDB一直被大家关注，传说中的文档数据库到底比现在每天使用MySQL强在哪里？这一切都需要用数据来说话，
	废话少说，先看一段代码，请忽略我代码编写的技巧和严谨程度，谢谢。
	package com.cn.javabloger;
	import java.io.File;
	import java.io.IOException;
	import java.util.Date;
	import java.util.List;
	import com.mongodb.DB;
	import com.mongodb.Mongo;
	import com.mongodb.gridfs.GridFS;
	import com.mongodb.gridfs.GridFSDBFile;
	import com.mongodb.gridfs.GridFSFile;
	public class MongoDBFileTest {
	&#160;&#160; &#160;static DB imgDB=null; 
	&#160;&#160; &#160;static GridFS gridFS=null; 
	&#160;&#160; &#160;
	&#160;&#160; &#160;public static void main(String[] args) throws&#160; Exception {
	&#160;&#160; &#160;&#160;&#160; &#160;&#160; long start=System.currentTimeMillis();
	&#160;&#160; &#160;&#160;&#160; &#160;&#160; Mongo mongo = new Mongo(&#34;192.168.50.215&#34;, 27017);&#160;&#160; //数据库地址，端口号
	&#160;&#160; &#160;&#160;&#160; &#160;&#160; imgDB = mongo.getDB(&#34;imgs&#34;);&#160; // 数据库名称
	&#160;&#160; &#160;&#160;&#160; &#160;&#160; gridFS = [...]]]></description>
		<link>http://www.javabloger.com/article/mongodb-gridfs-gridfsdbfile.html?source=rss</link>
			</item>
	<item>
		<title>我爱折腾之Android HelloWorld</title>
		<description><![CDATA[项目中需要对Android的熟悉和了解，需要搭建开发环境做一些项目调研和评估，
经过一番确认和评估，先确定了开发环境和SDK，
我们将采用：Eclipse&#160;&#160; Classic 3.5.2、ADT 0.9.6、Android&#160; SDK 2.1
如果有同学不想&#8220;翻墙&#8221;，也可以从这里下载 ： Android SDK2.1(428MB) 、ADT-0.9.6(7.11MB)。
闲着也是闲着。折腾也是折腾。
写了几个Android 测试例子，再用PC上的Android模拟器打开自己的站点，
效果如图所示：
	截图1&#160;&#160;&#160; 在模拟器中打开 google
	
截图2 打开自己的网站
截图3 最简单的一个程序，HelloWorld
口水：
	&#160;&#160; 联想和联通，移动和华为的类似商业合作，将会导致中国 Android的市场越来越大。
	&#160;&#160; 这个道理就像是 电脑和网络没有普及的时候，很多人还不需要所谓的企业软件，当越来愈多的电脑、网络 等等，普及起来了，需要软件的人也就越来越多了。
	&#160;&#160; Android的应用程也序一样如此，如果越来越多的人使用 Android 那么就会有越来越多的人需要Android的应用，甚至将来还需要个性化的 Android 手机应用。
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/android-helloworld.html?source=rss</link>
			</item>
	<item>
		<title>Dell Server R210开箱记</title>
		<description><![CDATA[
点击这里查看更多图片
	
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/dell-r210-install-ubuntu.html?source=rss</link>
			</item>
	<item>
		<title>MongoDB与Log4J的日志集中化管理</title>
		<description><![CDATA[客户跟我们合作快一年了，随着业务的增长，机器也在增长，刚刚开始的时候没有人去关注在多台机器上怎么查看日志，因为刚刚开始的时候才有2台应用服务器，现在光是GlassFish(web app) 就有25台，还有JMS的服务器/消息收发 12台，现在30几台机器光是查看日志就能忙死，就好比你电脑中打开了30个窗口，需要一个一个查看，你说能不杯具吗？
	现在有 30几台机器，将来也许还会更多，但我们需要查看Java程序在每台机器上运行的情况，如果还跟以前一样的方式似乎不太可行了，需要想想其他办法。
	所以设想出3种方案：
	&#160;&#160;&#160; 1.通过Log4J&#160; JDBC插件直接写入 数据库，
	&#160;&#160;&#160; 2.通过Log4J&#160; JMS&#160; 插件先向JMS服务器发送消息，JMS服务器接收到消息以后，再向数据库写入
	&#160;&#160;&#160; 3.通过改装后的 Log4J MongoDB插件 向 MongoDB数据库写入
	这样，我们只需要查看一台机器上的log数据就可以知道每台机器的运行状态，将来需要对日志进行分析的话还可以进行二次开发，并且操作方便，可扩展性强。
	所以最后选择了第三种向MongoDB写入，从以往大量的测试和经验中得到的实践告诉我们MongoDB和MySQL在执行大量的插入数据的过程中MongoDB更有效。
	目前采用了这样的技术架构，如图所示：
	
	查看大图请点击这里

	下载测试代码，请点击这里
	相关文章：
	MongoDB 客户端工具,不断收集ing(图)
	MongoDB Java ORM 的设想
	mongodb 入门 介绍  
	MongoDB 集群
	MongoDB 主(Master)/从(Slave)数据同步  
	&#160;
口水：
	这个想法和实践要感谢 Jozef Sevcik 先生和他的开源项目给我带来的灵感，我上面提供的代码例子也发送给Jozef Sevcik 先生的邮箱了，并且很快得到了他的回复，他在来信中说道：
Hello H.E,
	I&#39;m sorry for delayed response.
	Thank you for your contribution, I&#39;m glad to see people using the project are contributing code back, great [...]]]></description>
		<link>http://www.javabloger.com/article/mongodb-log4j.html?source=rss</link>
			</item>
	<item>
		<title>给Feed用来验证的(测试)</title>
		<description><![CDATA[验证码 f9c05e77

	&#160;
]]></description>
		<link>http://www.javabloger.com/article/%e7%bb%99feedsky%e7%94%a8%e6%9d%a5%e9%aa%8c%e8%af%81%e7%9a%84.html?source=rss</link>
			</item>
	<item>
		<title>Spring3无法显示css/js/jpg/gif</title>
		<description><![CDATA[项目中正在使用着Spring3 REST带来的快活，忽然一条很不和谐的错误信息出现，如下所示：
	&#160;2010-05-07 09:07:43,275 WARN&#160;&#160; org.springframework.web.servlet.DispatcherServlet.noHandlerFound(DispatcherServlet.java:962) No mapping found for HTTP request with URI [/Spring3/css/mSelect.js] in DispatcherServlet with name &#39;springmvc&#39;&#160; 
	&#160;2010-05-07 09:07:43,275 WARN&#160;&#160; org.springframework.web.servlet.DispatcherServlet.noHandlerFound(DispatcherServlet.java:962) No mapping found for HTTP request with URI [/Spring3/css/style_index.css] in DispatcherServlet with name &#39;springmvc&#39;&#160; 
	这说明在web工程中的css、js、gif、jpg 等都无法显示出来，都是因为下面这段配置导致的
	&#160;&#60;servlet-mapping&#62;&#160;&#160; 
	&#160;&#160;&#160;&#160; &#60;servlet-name&#62;springmvc&#60;/servlet-name&#62;&#160;&#160; 
	&#160;&#160;&#160;&#160; &#60;url-pattern&#62;/&#60;/url-pattern&#62;&#160;&#160; 
	&#160;&#60;/servlet-mapping&#62;&#160;&#160; 
	
	换成这样一点问题都没有，虽然没有问题，不是我们期望的结果，多了后缀 .do。
	&#160;&#60;servlet-mapping&#62;&#160;&#160; 
	&#160;&#160;&#160;&#160; &#60;servlet-name&#62;springmvc&#60;/servlet-name&#62;&#160;&#160; 
	&#160;&#160;&#160;&#160; &#60;url-pattern&#62;*.do&#60;/url-pattern&#62;&#160;&#160; 
	&#160;&#60;/servlet-mapping&#62;&#160;&#160; 
	这说明要将那些不能显示的 css/js/jpg/gif 文件排除在过滤器以外不经过过滤器，不然Spring3的过滤器会认为你没有将这个url进行映射，在网上找了很多资料都没有非常针对性的答案，于是经过几番折腾，总算搞定，加上以下配置在web.xml中，将默认的过滤器选项激活，世界又恢复平静，css、js、gif、jpg 等一切显示正常。
	&#160;&#160;&#160;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/no-mapping-found-for-http-request-with-uri.html?source=rss</link>
			</item>
	<item>
		<title>中小型网站Spring3 OSCache mrpersister dbcp dbutils 整合</title>
		<description><![CDATA[近期采用spring3/apache dbutils/mrpersister/dbcp做一个Web项目，数据库依然采用MySQL，不过这次打算加上XtraDB引擎。项目不算很大，大约在一年能支持50w左右的用户，并发至少5k以上。
	先说说Spring3，自从入手就爱不释手了，那个方便啊真的是没话说了，action的零配置文件，让人快活，经过ab的压力测试，效率也不低于strust2。
	mrpersister是我很多年以前偶然接触到的一根ORM框架，是我在寻找Java webmail的时候发现的，还记得那个Java Webmail的名字叫做Claros Webmail，我记得在Hibernate非常盛行的年代里，由于Hibernate等众多ORM需要大量的XML我对其极度的不满，mrpersister的出现那一刻让我坚决的放弃Hibernate。
	Apache dbutils 非常的灵活，但是封装的还不够，有很多需要手工操作的地方，但是这样也有这样的好处，当你涉及到相对复杂一点SQL查询的时候，dbutils的出现起到了很大的帮助，因为他毕竟不是什么ORM工具，只是很灵巧的对JDBC进行了封装，非常灵活，适用于操作查询。
	dbcp就不用说了，但是我需要声明一点，很多人说dbcp跟C3p0相比怎么怎么的不好，从来没有发觉有什么不好，只是很多时候听见身边不少同事向我抱怨使用C3p0总是有各式各样的问题，基本上开源的数据库连接池我都使用过，而且做过一个论证和研究，C3P0的确做工精细，考虑的东西比较全面，但是我个人认为这反而带来了不少学习的曲线，因为东西越多，如果不能掌握，反而是一个资源浪费。
	至于整体风格还是采用REST架构，因为做的是一个纵向的门户网站，需要对搜索引擎友好，如果将.jsp完全的暴露在url地址栏中，是一件很不友好的事情。
	在第一期的项目中不打算使用自动生成静态页面的技术，直接查询数据库，最多在页面上加入oscache进行页面上的分块局部缓存。
	整体的软件架构如图所示：
	
	这个项目一共3个开发人员，2个美工，一个系统工程师，一个系统架构师(身兼3职，了解我的人都应该知道哪3职，呵呵 )，但我们并没有以软件工程师的身份为客户进行服务，而是顾问的身份出现，因为我们知道光是软件本身好是没用的，客户需要的不仅仅是软件，需要的是怎么通过软件获得更多的商业价值，这也是我们与其他几位竞争对手进行比较的优势所在。
	的确第一期在技术实施上和编码上基本没有什么难度，因为都是使用我们成熟并熟悉的技术，使用就连linux下的磁盘阵列也是服务器供应商帮我们做好了。但是这个项目也有他的难点，主要问题在于，客户需要将来对系统进行扩容，在一年以后又新的商业规划需要支持更多的用户，但是目前我们的工期只有2个月，现在技术架构和将来的可扩展是目前这个项目最大的挑战，第一期工程投入的时间，精力有限，所以不太容许我们在设计上过多的去迁就将来的架构，但是也不能不去考虑，两难，所以做到两全其美真的是有点耗费脑细胞。
	先写到这里，有空在说，我们对怎么权衡 对现在项目进行开发并且设计将来的可扩展性的，再这里需要感谢包子和如一 两位同学，没有他们也不可能让这个项目一直在顺利的进行中。
	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/spring3-dbutils-mrpersister-dbcp-oscache.html?source=rss</link>
			</item>
	<item>
		<title>GlassFish v3 优化经验分享</title>
		<description><![CDATA[配置GlassFish v3中的JVM参数( Include 64-bit JVM),在GlassFish运行的过程中将会带来不同的性能体验，设置GlassFish中的JVM参数只是优化GlassFish中的一部分工作，今天先来说说需要GlassFish中的哪些JVM可以对性能有所提高，普遍的、多见的这里就不一一介绍了，呵呵。
	
&#160;
1、在 将:-Xmx512 和 -client 这2个参数&#160; 修改
	为这几个参数 -server ,-XX:+AggressiveHeap, -Xmx2048m, -Xms2048m, -Xss128k, -XX:+DisableExplicitGC，不要写在一行中要分开写成几行，另外，如果在64位的JMV中你的内存使用范围需要设置到&#160; -Xmx4096m -Xms4096m 才会起到效果，也就是64位的运行环境说需要设置超过4个G的大小才会得到效果，在windows 32位的环境下，一般 1.4G 到 1.6G是一个比较稳健的值，2G是一个极限。而在Solaris的SPARC CPU环境下尽量控制在1400M范围以内。
&#160;
2、如果在多个CPU上运行GlassFish V3，还需要添加这2个参数，增大并行运算的处理能力：
	-XX:ParallelGCThreads=N&#160;&#160; (其中N为CPU的数量，如果N&#62;8 ，N=CPU数x2) 
	-XX:+UseParallelOldGC
-XX:LargePageSizeInBytes=256m
&#160;
3、如果你使用的是JDK版本6u16或者更高的64位的JVM环境则需要加入：
	-XX:+UseCompressedOops 参数 .
另外,需要注意设置Java堆的最大值跟你的操作系统系统有一定的关系，linux/solairs/windows 、32位或者64位的环境需要设置的参数都不一样，所以应该根据具体的操作系统环境设置不同的参数。
&#160;
&#160;Stroy：
	为什么GlassFish应用程序运行缓慢？
	在项目中我们遇到了一个很奇怪的现象，GlassFish v3 +JVM 64运行在RedHat CentOS 64位的操作系统中，启动时运行20分钟内一切正常，但是2-3个小时以后打开web应用非常慢，再过一会出现404 无法打开页面，但是4848端口的管理界面运行的非常正常，经过多次摸索，最后换上32位的JDK，一切运行正常，并且GlassFish v3是在一个没有优化的初始状态。
	如果上述方法不解决性能问题，请阅读更多的调整参数资料，你可以尝试去看Java HotSpot虚拟机的选项。还可以利用一些工具，如 jstat(Java虚拟机的统计监测工具) 和hprof(堆/ CPU剖析工具)，可以帮助诊断应用性能问题。
&#160;


口水：
			GlassFish v3&#160; GA目前已经在业内逐渐获得巨大的市场，GlassFish v3并且全面支持 Java EE6 、NIO、Servlet3.0 、http异步操作和OSGI微框架 等多项令人兴奋的新技术。

			此外，GlassFish v3 和GlassFish v2 版本差别还是比较大的，V2与V3版本相比其中的Grizzly Web [...]]]></description>
		<link>http://www.javabloger.com/article/glassfish-v3-jvm-configuring-and-64-bit-jvm.html?source=rss</link>
			</item>
	<item>
		<title>Apache Cassandra在Windows下安装、运行</title>
		<description><![CDATA[大名鼎鼎的Apache Cassandra是Java写的NoSQL数据库，所以可夸平台是必然性，在Windows XP下运行绝对不是问题，只需要：
	&#160; 1.下载、安装 Sun Java JDK 6.0+，
	&#160; 2.下载、解压 Cassandra后可直接运行，下载地址 点击这里，
	&#160; 3.在CMD窗口下输入 set CASSANDRA_HOME=x:\you_cassandra_dir，或者在Windows系统中设置环境变量，如果不设置将会提示如下错误信息：
	Exception in thread &#34;main&#34; java.lang.NoClassDefFoundError: org/apache/cassandra/
	cli/CliMain Caused by: java.lang.ClassNotFoundException: org.apache.cassandra.cli.CliMain。所以切记，运行Cassandra必须先设置一下系统环境变量。
	&#160; 4.双击 bin\cassandra.bat启动服务器端，服务器端启动效果如图所示：
	
5.双击bin\cassandra-cli.bat运行，进入客户端程序，输入 connect localhost/9160 命令连接服务器，查看keyspaces，再查看具体keyspace详细信息，运行效果如图所示：
	
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/apache-cassandra-install-on-windows.html?source=rss</link>
			</item>
	<item>
		<title>Spring3文件上传,提速你的Web开发</title>
		<description><![CDATA[Spring1 推出的时候可以说是不小的颠覆了J2EE 的开发，彻底把EJB打败，将J2EE开发进行简化，
	Spring2 推出以后完美的与多种开源框架与服务器的结合，让你对其拥抱的更紧，Spring变成了一个工具箱，一应俱全，
	Spring3 推出以后让开发真正的得到简单化，并且Spring3支持REST风格，采用Spring3进行开发，简单的有点过分了。
	如果说我在吹嘘，那么1行有效的代码就可以完成B/S模式的文件上传，呵呵。废话少说，先看代码：
	清单1：
	springmvc-servlet.xml
	在springmvc-servlet.xml文件中添加以下代码：
	&#160;&#160;&#160; &#60;bean id=&#34;multipartResolver&#34; 
	&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; class=&#34;org.springframework.web.multipart.commons.CommonsMultipartResolver&#34;&#62;
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#60;!&#8211; 设置上传文件大小的参数 &#8211;&#62;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#60;property name=&#34;maxUploadSize&#34; value=&#34;1000000&#34;/&#62;
	&#160;&#160;&#160;&#160;&#160;&#160; &#60;/bean&#62;
	
	清单2：
	web.xml
	在web.xml文件中添加以下代码：
	&#160;&#160; &#60;servlet&#62;&#160;&#160; 
	&#160;&#160;&#160;&#160;&#160; &#60;servlet-name&#62;springmvc&#60;/servlet-name&#62;&#160;&#160; 
	&#160;&#160;&#160;&#160;&#160; &#60;servlet-class&#62;org.springframework.web.servlet.DispatcherServlet&#60;/servlet-class&#62;&#160;&#160; 
	&#160;&#160;&#160;&#160;&#160; &#60;load-on-startup&#62;2&#60;/load-on-startup&#62;&#160;&#160; 
	&#160;&#160; &#60;/servlet&#62;&#160;&#160; 
	&#160;&#60;servlet-mapping&#62;&#160;&#160; 
	&#160;&#160;&#160;&#160; &#60;servlet-name&#62;springmvc&#60;/servlet-name&#62;&#160;&#160; 
	&#160;&#160;&#160;&#160; &#60;url-pattern&#62;/&#60;/url-pattern&#62;&#160;&#160; 
	&#160;&#60;/servlet-mapping&#62;&#160;&#160; 
	清单3
	upload.html
	建立一个普通的html文件，加入以下代码：
	&#60;form method=&#34;post&#34; action=&#34;/SpringREST/image/imageUpload&#34; enctype=&#34;multipart/form-data&#34;&#62;
	&#160;&#160;&#160; &#60;input type=&#34;file&#34; name=&#34;file&#34; /&#62;
	&#160;&#160;&#160; &#60;input type=&#34;submit&#34;&#160; value=&#34;upload&#34;/&#62;
	&#60;/form&#62;
	清单4
	ImageController.java
	package com.javabloger.springrest.action;
	import java.io.FileOutputStream;
	import javax.servlet.http.HttpServletRequest;
	import javax.servlet.http.HttpServletResponse;
	import org.springframework.stereotype.Controller;
	import org.springframework.web.bind.annotation.RequestMapping;
	import org.springframework.web.bind.annotation.RequestMethod;
	import org.springframework.web.bind.annotation.RequestParam;
	import org.springframework.web.multipart.MultipartFile;
	import com.javabloger.springrest.dao.ImageDAO;
	@Controller
	@RequestMapping(&#34;/image&#34;)&#160;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/spring-3-file-upload-example.html?source=rss</link>
			</item>
	<item>
		<title>MySQL插件XtraDB</title>
		<description><![CDATA[在J2EE企业应用中，不仅仅需要考虑到系统的架构与设计，还需要关注存储系列的话题，存储包括硬件和软件，话题中数据库也算存储系列当中的重点。当前对与MySQL的使用越来越广泛，对MySQL的期望和要求也越来越多。记得在前几天我写过一篇文章，关于一个德国网站的 架构，他们正在考虑将现在使用的MySQL引擎换掉，采用XtraDB数据库引擎，详见： 德国SNS交友/视频网站Poppen.de的技术架构分享。
最近看一个老外在Dell PowerEdge R900机器上做的MySQL测试，使用MySQL 5.1.42，分别采用3种不同的引擎进行比较，分别是MySQL自带的InnoDB,InnoDB-plugin 1.0.6、 XtraDB 1.0.6-9 ，测试数据90GB+索引。
	Dell PowerEdge R900的机器配置如下：
	&#160;&#160;&#160; * 4 QuadCore Intel(R) Xeon(R) CPU E7320 @ 2.13GHz (16 cores in total)
	&#160;&#160;&#160; * 32GB of RAM
	&#160;&#160;&#160; * RAID10 on 8 disks 2.5/15K RPMS
	&#160;&#160;&#160; * FusionIO 160GB SLC
	&#160;&#160;&#160; * FusionIO 320GB MLC
	测试环境的InnoDB数据文件建立在FusionIO存储设备上，采用160GB SLC卡 和 320GB MLC卡配置的软RAID0 存储，而InnoDB 日志和 MySQL系统表建立在 RAID10 设备上,测试环境中的my.cnf配置文件清单如下：
	* InnoDB
	innodb_buffer_pool_size=26G
	innodb_data_file_path=ibdata1:10M:autoextend
	innodb_file_per_table=1
	innodb_flush_log_at_trx_commit=0
	innodb_log_buffer_size=8M
	innodb_log_files_in_group=3
	innodb_log_file_size=512M
	innodb_thread_concurrency=0
	innodb_flush_method = [...]]]></description>
		<link>http://www.javabloger.com/article/xtradb-mysql.html?source=rss</link>
			</item>
	<item>
		<title>Spring3 REST MVC框架,提速你的Web开发</title>
		<description><![CDATA[最近在Java web 项目中需要采用非常简单的REST框架，Struts2、webwork、JSF 经过一番比较，最后选择了Spring3，理由只有一个 &#8220;简单，好用，并满足需要&#8221;。很久以前就Rod Johnson大叔说 Spring3 全面支持REST风格的Web服务，&#34;We&#39;re really seeing extensive interest and growth in REST, and it will have comprehensive support for RESTful Web services,&#34; said Johnson，今天亲自尝试了一下，真有点相识恨晚的感觉，如果在这次项目运用没有太大的问题，将来在其他项目会大量运用。
	工作原理如图所示：
	
	*根据HTTP请求的URL，调用相应的DispatcherServlet控制器。
	*提供一个视图是作为HTTP响应发送。
页面上最终运行效果，如图所示：
	
	主要代码：
	
	清单1：TopicController
	package com.javabloger.springrest.action;
	import javax.servlet.http.HttpServletRequest;
	import javax.servlet.http.HttpServletResponse;
	import org.springframework.stereotype.Controller;
	import org.springframework.web.bind.annotation.PathVariable;
	import org.springframework.web.bind.annotation.RequestMapping;
	import org.springframework.web.bind.annotation.RequestMethod;
	@Controller
	@RequestMapping(&#34;/topic&#34;)&#160; //url映射的名称
	public class TopicController {
	&#160;&#160;&#160; @RequestMapping(value = &#34;/{id}&#34;,method=RequestMethod.GET)
	&#160;&#160;&#160; public String helloWorld(
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; @PathVariable Long id, 
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; HttpServletRequest request,
	&#160;&#160;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/spring3-rest-mvc-example.html?source=rss</link>
			</item>
	<item>
		<title>德国SNS交友/视频网站Poppen.de的技术架构分享</title>
		<description><![CDATA[Poppen.de是一个德国的 交友/ 聊天/ 视频 的SNS网站, 部分内容NSFW，网站采用了很多我们熟悉的技术，像Nginx ，MySQL，CouchDB，Erlang，Memcached的，RabbitMQ(消息服务器)，采用了Graphite作为网站的系统监控，Red5作为视频服务，Tsung作为压力测试工具，选择的技术种类较多，还采用PHP和Erlang 2种程序语言作为不同功能的开发。
	关于 Poppen.de 的资料统计数据
	&#160;&#160;&#160; *&#160; 2 000 000 用户数
	&#160;&#160;&#160; *&#160; 20.000并发用户数
	&#160;&#160;&#160; *&#160; 300.000条私人讯息/每天
	&#160;&#160;&#160; *&#160; 250.000登录/每天
	功能概要
	&#160;&#160;&#160; * 用户在线搜索其他用户；
	&#160;&#160;&#160; * 站内对方写私人消息；
	&#160;&#160;&#160; * 用户上传图片和视频；
	&#160;&#160;&#160; * 用户与用户之间的在线视频聊天。
	&#160;Poppen.de整个网站的技术团队有 11个人开发人员，2个界面设计师和两个系统管理员。
	H.E的口水1：
	Poppen.de 是德国的成人交友/约会网站，小朋友不要随便上哦，网站里的内容很开放，有很多怪叔叔(Gay)，呵呵。与Facebook这样巨头网站相比算是一个小型网站了，但是通过Poppen.de网站这次对外的技术信息分享，可以看出网站有个不错的技术架构，让我们可以从中得到很多值得学习与借鉴的内容。 
	H.E的口水2：
	NSFW这个英文缩写常常出现在Blog中，表示某个站点含有露点或者极度暴力的内容，如果你在上班的时候打开这个网站你的同事经过你身边的时候估计会让你很尴尬，呵呵。所以在我朝廷的大局域网内是无法打开这个站点，如果一定要满足自己的好奇心，你可以动动脑筋看看有什么办法。看看我Fang Qiang后的截图，如图所示：
	
	查看大图请点击这里
	系统架构描述：
	* Web 层服务器
	采用Ngixn作为Web App 服务器，2台机器在前端作为www的请求，在高峰的时候每分钟能够处理150.000个用户的请求，并且结合Memcached一起使用，用来缓存一些用户的资料信息。
	另外3台Ngixn 服务器作为图片服务器的请求 例如:img.bilder.poppen.de (image servers),每分钟处理用户80.000请求,用户通过这3台服务器进行图片的读、写操作，只使用每台服务器的本地缓存，并不通过Memcached服务器，并且将用户上传的图片信息存放在中央式的文件系统中，估计这样目的是为了减轻主要储存设备的负荷。网站已经这样使用了4年，一共5台Ngixn服务器，每台配置普通32位CPU、3GB RAM 内存。
	* 语言环境
	使用 PHP的5.3 版本 为程序语言运行环境，整个网站使用28台机器作为PHP Ap 服务器，每台机器配置6G内存。每个机器运行运行100个worker processes， 将运行环境的可选PHP缓存(Alternative PHP Cache, APC)打开, 据说网站透露这样可以提高性能，能够减少 [...]]]></description>
		<link>http://www.javabloger.com/article/couchdb-erlang-rabbitmq-red5-linux-poppen-architecture.html?source=rss</link>
			</item>
	<item>
		<title>第二期 “迷你书”(PDF) &#8211;架构！</title>
		<description><![CDATA[读物封面：
	
内容提要：
	冬去春来，阳光三月天，南京的春天已经能感受着丝丝暖意，Javabloger.com也迎来第二期&#8220;迷你书&#8221;的发布，本期以系统架构话题为主，将介绍大型网站使用的Web服务器端，以及美国最大的SNS社区MySpace对新产品的&#8220;云测试&#8221;部署架构，一些使用GlassFish和Memcached的技巧，网站实时在线备份的经验分享 等。
	回顾2009
	&#160;&#160; &#160;主要精力放在系统架构设计、敏捷开发的学习与研究，和对开源项目MySQLOA的开发。Javabloger.com网站也在孵化当中，将略懂的一些知识与经验进行与大家分享，已与金陵软件工作室紧密协作，开始接洽SEO、企业、门户网站的应用开发。
	展望2010
	&#160;&#160; &#160;把握八个字：&#8220;主动、积累、分享、反思&#8221;继续前进。Javabloger.com将会分享更多有价值的内容和经验给大家，同时还会以正式与非正式的，自己圈子内圈子外的，计划性的进行专项专题技术讲解，目前虽然站点没有大量内容，但坚持内容原创的精神，因为Javabloger.com在遵循基本生存法则&#8212;内容为王。
下载地址: 
	http://javabloger-mini-books.googlecode.com/files/JavaBloger-mini_book-2010-4.pdf
	
其他资源:
	http://code.google.com/p/javabloger-mini-books/downloads/list
	
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/pdf-mini-book-2.html?source=rss</link>
			</item>
	<item>
		<title>搜索引擎优化(SEO)与网站开发优化</title>
		<description><![CDATA[对很多Java web、J2EE开发者来说&#8220;SEO搜索引擎优化&#8221;还是一个比较陌生的话题。他们中有的人并不知道有SEO&#8211;搜索引擎优化这一说法的存在，如何运用巧妙的手段提高网站的搜索排名和网站的点击率，更别说意识到了&#8220;SEO 搜索引擎优化&#8221;对与网站开发的关联性和重要性了。
	为什么对SEO比较陌生？
	首先需要声明SEO对于当今而言已经再不是什么新兴产物，从SEO的起源迄今已有10年上下，之所以很多开发者对SEO仍然陌生，本人大致分为以下几点：
	1.&#160;&#160; &#160;企业对SEO的意识与重视程度。
	2.&#160;&#160; &#160;开发者对SEO研究兴趣与非工作范围的知识视野。
	3.&#160;&#160; &#160;SEO在社会传统媒体中达到的认知、认同度。
	SEO是什么？
	http://zh.wikipedia.org/wiki/Seo 虽然这个链接中的解释已经比较到位了， 但是我个人还是浅显的认为：&#8220;SEO是在网络上对消费心理学的运用，SEO一部分是给搜索引擎机器看的，另一部分是给人看的，当然是先给机器看的，再给人看的，人能看见你网站内容往往很多时候是先通过搜索引擎。也就是说你的网站既要符合搜索引擎的收录原则，还要注重网站的用户体验。高质量的经营性网站两者缺一不可，SEO只是营销手段中的一种，所以最终企业的决策者需要看到通过SEO的收益。&#8221;
	SEO为什么非常重要？
	开发者们构建的Web系统可以看做他们是在建造一所房子，企业的决策者将决定让这个房子用来具体干什么，很顺利，没多久房子盖好了，决策者现在将这所房子作为一个旅馆进行营业，里面的设施样样俱全，可一个月后还是无人问津。很多刚刚起步经营性的网站也同样会同样的问题，每日的访问人数地到了极点，对于这类网站的决策者来说是一件非常困扰的事情。如果决策者和开发者们能在构建的时候就能考虑到如何在网站内留下大量的SEO可扩展性，就不会等网站做好一个月以后也无人问津了。这样是多大的一笔损失啊。
	网站进行SEO优化以后会怎么样？
	很多人通过搜索引擎的搜索结果登陆你的网站，因为他输入的关键字和你网站里面的主要内容相匹配。如果你网站对于搜索引擎来说命中率越高，你网站的访问者就越多。可想而知网站对搜索引擎的友好程度是非常重要的。
	Web网站开发的SEO手段：
	1、&#160;&#160; &#160;将动态网页，进行静态化，如果是才可以Java Web开发可以采用 Freemaker技术，或者是伪静态页面。
	2、&#160;&#160; &#160;正确的使用缓存，提高网站的访问速度，让搜索引擎认为你的网络服务质量较佳，这样比较容易对网站收录。
	3、&#160;&#160; &#160;网站的静态页面的url地址、名称，需要跟网页提要有关。例如本篇文章的链接中包含 java和seo这2个关键字。
	4、&#160;&#160; &#160;网站Title、Meta根据页面主要内容进行动态加载，正确使用heading标签。 
	5、&#160;&#160; &#160;网站Title、Meta根据页面不仅仅需要根据内容动态加载，还需要建立分词表一起加载。
	6、&#160;&#160; &#160;图片显示多用ALT标记，少用图片中高、宽属性，图片文件名最好也好和图片主题一致。
	7、&#160;&#160; &#160;连接上动态加上 Title属性，例如：&#60;a href=&#34;http://www.javabloger.com/article/mongodb-java-orm.html&#34; title=&#34;MongoDB Java ORM 的设想&#34;&#62;MongoDB Java ORM 的设想&#60;/a&#62;
	8、&#160;&#160; &#160;CSS、JavaScript代码尽量放在底部，不要过多的把Javascript写入在页面中，搜索引擎会认为这样的网页不友好。
	9、&#160;&#160; &#160;页面的排版层次尽量简洁、清晰，网页结果层次复杂，不容易被搜索引擎收录，搜索引擎虽然是机器，还是站在人性化的立场考虑。
	10、&#160;&#160; &#160;内部链接的使用，具体使用技巧请查阅：http://www.njlanesoft.com/record/seo-internal-links.html
	11、&#160;&#160; &#160;注意每个网页文件最终生成的大小。
	12、&#160;&#160; &#160;合理的采用连接分类(category/tag)和站点导航这样对SEO会比较友好。
	13、&#160;&#160; &#160;在网站中建立正确的网站地图，例如：http://www.javabloger.com/sitemap.xml。
	14、&#160;&#160; &#160;建立站点下的rebots.txt文件，让搜索引擎知道该怎么走。
	15、&#160;&#160; &#160;建立RSS信息订阅频道，读者可以通过多种方式访问你网站的最新信息。
	16、&#160;&#160; &#160;将访问者、客户的信息进行统计、分析、挖掘，提高将来商业决策的执行力度。

	另外，对于SEO的手段而言没有绝对的好与坏，因为SEO本身不存在任何标准，并且一旦变化排名规则，大家都需要重新洗牌。

	&#8211;end&#8211;
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/seo-java-j2ee-web-development.html?source=rss</link>
			</item>
	<item>
		<title>MongoDB Java ORM 的设想</title>
		<description><![CDATA[搞技术的手艺人都有个习惯，没事喜欢瞎折腾。我也不例外，懂点Java、ORM 之类的技术，最近又有点迷上了MongoDB，目前对MongoDB了解的还不算太多，但兴趣到挺大。有句俗语：瘾大水平低。通常是指某人某项技艺不高，但偏偏喜欢耍弄这项自己不精的技艺。这句话对我现在挺适合。
	why
	ORM给众多的Javaer留下了很多美好的印象，原因只有一个&#8220;方便&#8221;，口水：虽然Hibernate也是ORM，但使用起来并不方便。
	打算自己写个类里面封装一套CRUD的方法，用这个类去调用 BasicDBObject ，DBCursor 等一些MongoDB Java API 里面的类。 现在的想法暂且不是很完美，但是可以简化一些web应用的开发，说一个场景：用户输入表单信息，将输入的表单信息，通过action层转换成表单对象，对象传入Service层操作具体的业务逻辑，再传入底层通过API操作MongoDB，这是一个常见的场景。
	但是如果一个表单上有很多字段，那么对象到了操作MongoDB的时候将需要手工取出来，在一个个的put进去，一个页面上有20、30个字段需要存入，这么一来一旦这样的场景多了，我会崩溃的。如果还要来输入的数据从MongoDB中在get出来，还要一个个的取，我会更加崩溃。。。。。。。这样的假象让我不得不去折腾一下了。
	场景如图所示：
	
	注释:用户通过HTML/JSP前端页面提交参数，Action层将参数转换成对象传到 Service层，Service层再 传 对象 到DAO层，DAO层 把对象转换成参数 调用API ,到了调用底层API的时候需要一个个get/put参数，如果一多就是个悲剧啊。
	how
	就因为这样让我想到折腾可以进行的办法，通过通过java反射加上SDK中注释的功能，这样可以灵活的操作，废话少说，进行介绍具体怎么反射和采用注释的折腾过程，主要思路如下：
	1.主要实现程序&#160; MyMongoDBORMImpl 
	class MyMongoDBORMImpl {
	&#160;&#160;&#160;&#160; // 添加数据
	&#160;&#160;&#160; public&#160; void addObject(Object clazz) {&#160;&#160; &#160; //传入 new 对象,获得表名和对象实例化参数
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; Map&#60;?, ?&#62;&#160; map= MappingTools.copyABeanToMap(clazz );&#160; //调用自己写的 映射工具
	&#160;&#160;&#160; &#160;&#160;&#160; System.out.println(map&#160; );
	&#160;&#160;&#160; &#160;&#160;&#160; Iterator&#60;?&#62; val=map.values().iterator();&#160; // 通过反射得到 new 对象中的值
	&#160;&#160;&#160; &#160;&#160;&#160; Iterator&#60;?&#62; key=map.keySet().iterator(); // 通过反射得到 new 对象中的属性
	&#160;&#160;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/mongodb-java-orm.html?source=rss</link>
			</item>
	<item>
		<title>mongodb 入门 介绍</title>
		<description><![CDATA[最近在研究mongodb，看了很多资料，在此通过一个pdf文件进行学习总结。
这个pdf 里讲述了哪些用户/门户网站 使用 mongodb产品，以及 mongodb 的一些基本原则/原理.
封面：
	
	&#160;
下载地址： http://code.google.com/p/javabloger-mini-books/
	
话外音：&#160; 第2期&#8220;迷你书&#8221;正在整理ing，本期专题将为&#160; &#8220;Architecture/架构&#8221; 。
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/about-mongodb-pdf-ppt.html?source=rss</link>
			</item>
	<item>
		<title>时光流逝</title>
		<description><![CDATA[以下是2010年留下的照片；
	在2010中我似乎不再去喜欢ps照片，也许是要做的事情太多，没有时间也没有那个心思。
这样可以让照片留下一些真实，不在乎给谁看，只在乎能记载时光流逝的岁月。

	详见：http://www.javabloger.com/2010-4-3
	&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/2010-4-3.html?source=rss</link>
			</item>
	<item>
		<title>GlassFish OpenMQ JDBC</title>
		<description><![CDATA[OpenMQ是一个开源的消息中间件，类似IBM的 WebSphere MQ(MQSeries)，现在被集成到GlassFish和OpenESB的高质量且开放源代码的 JMS应用中，网上关于OpenMQ 配置成JDBC存储方式的中文文章比较少，而且官方英文文档讲述的也不够直观，所以Javabloger在此写一篇关于OpenMQ 是怎么配置成JDBC存储方式的。
1.修改 x:\glassfish\domains\domainEE\imq\instances\imqbroker\props路径下的config.properties文件
内容如下：
&#160; imq.instanceconfig.version=300
	&#160; imq.persist.jdbc.mysql.user=root
	&#160; imq.persist.jdbc.password=www.javabloger.com
	&#160; imq.persist.jdbc.dbVendor=mysql
	&#160; imq.brokerid=_broker
	&#160; imq.persist.jdbc.mysql.property.url=jdbc\:mysql\://127.0.0.1/test
	&#160; imq.persist.jdbc.mysql.needpassword=true
	&#160; imq.jms.max_threads=1000
	&#160; imq.persist.store=jdbc
	&#160; imq.message.expiration.interval=90
	
2.复制JDBC驱动到指定目录下
将JDBC驱动复制到 D:\glassfish\domains\domainEE\lib\ext 目录下
3.启动 Sun OpenMQ JMS 服务
运行 x:\glassfish\imq\bin\imqbrokerd.exe
4.运行成功，如图所示：

相关文章：
大型系统中使用JMS优化技巧&#8211;Sun OpenMQ  
	Sun OpenMQ Topic消息收/发 &#8212;Tips  
	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/glassfish-openmq-jdbc.html?source=rss</link>
			</item>
	<item>
		<title>Memcached集群/分布式的单点故障</title>
		<description><![CDATA[口水：Memcached在2009风靡全球，现在对Memcached态度大家各自褒贬不一，话不多说进入正题。
我看到过这样一段文字
	&#8220;
	memcached如何处理容错的？
	不处理！:) 在memcached节点失效的情况下，集群没有必要做任何容错处理。如果发生了节点失效，应对的措施完全取决于用户。节点失效时，下面列出几种方案供您选择：
	* 忽略它！ 在失效节点被恢复或替换之前，还有很多其他节点可以应对节点失效带来的影响。
	* 把失效的节点从节点列表中移除。做这个操作千万要小心！在默认情况下（余数式哈希算法），客户端添加或移除节点，会导致所有的缓存数据不可用！因为哈希参照的节点列表变化了，大部分key会因为哈希值的改变而被映射到（与原来）不同的节点上。
	* 启动热备节点，接管失效节点所占用的IP。这样可以防止哈希紊乱（hashing chaos）。
	&#8221;
	&#160; 同学们，根据上面的说法，memcached其中一个节点失效以后，memcached本身是没有任何策略维持失效转发的，这对于大型系统是一个无法接受的事实。
	&#160;&#160;&#160; Memcached分布式每个服务器端本身没有相互相连的关系，数据分布是由客户端来维持的，也可以说Memcached还没有为集群提供真的高可用方案，因为从集群的定义上来说需要满足：1.压力分载 2.失效转发。
&#160;&#160; 在项目组中lianjie.you同学问我如果在分布式中的其中一台Memcached节点down掉了，应该如何解决？我当时愣住了，一时之间还不能给出任何完整的答案。
&#160;&#160; 今早在座公车来上班的路上用手机上网Google了一下，发现原来在网上有很多人与我们有相同的问题，我Google的关键字是&#8220;Memcached 单点&#8221;&#160; 、&#8220;Memcached 单点故障&#8221;。给出的搜索结果都不算让人满意，我才打算写一篇关于解决集群中Memcached单点故障的文章。Javabloger只向大家提供2种解决思路，暂时不提供具体代码。
	&#160; 现象描述：
	&#160;&#160;&#160; 在客户端连接的部分写入多个服务器端的ip地址，客户端将会自动的把缓存数据分布的放在每个不同的机器上，如图所示：
	
	查看大图请点击这里
	现象后果：
	&#160;&#160;&#160; 如果其中一个缓存节点的机器down机，那么客户端存入的缓存数据将会丢失一部分，就是图中红色字体描述的&#8220;Losed 33% Cache Data&#8221;，也就是说那部分数据彻底没有了！如果是用户的关键性信息那么就玩大了，如图所示：
	 查看大图请点击这里
	解决方案1：本地备份缓存
	&#160;&#160;&#160; 在本地放一份缓存，同时也在分布式Memcached上放一份缓存，如果当其中一台节点当机了，客户端程序直接读取本地的缓存，本地客户端维护一个HashMap即可，这样的方案虽然很简陋，但是可以满足一部分场景的需要，当你很急需的时候可以作为临时方案暂时替代一下。
	解决方案2：采用缓存代理服务器
	&#160;&#160;&#160; 采用 Magent 缓存代理，防止单点现象，缓存代理也可以做备份，通过客户端连接到缓存代理服务器，缓存代理服务器连接缓存服务器，缓存代理服务器可以连接多台Memcached机器可以将每台Memcached机器进行数据同步。这样的架构比较完善了，如果其中一台缓存代理服务器down机，系统依然可以继续工作，如果其中一台Memcached机器down掉，数据不会丢失并且可以保证数据的完整性，以上描述的系统架构如图所示：
	
	查看大图请点击这里
	还是那句话：没有任何架构是最完美的，只是最合适的，任何架构都不可能一步到位，都是经过一步一步演变过来的。
&#8211;end&#8211;
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/memcached-cluster-error-msag.html?source=rss</link>
			</item>
	<item>
		<title>MongoDB 集群</title>
		<description><![CDATA[MongoDB 集群中包含一个自动分片模块 (&#34;mongos&#34;). 自动分片可以用于构建一个大规模的可扩展的数据库集群,这个集群可以并入动态增加的机器。自动建立一个水平扩展的数据库集群系统，将数据库分表存储在sharding的各个节点上。在一个mongodb的集群中包括一些shards(mongod进程)，mongos的路由进程，一个或多个config服务器。sharding是一种对大规模数据存储的一种策略，关于sharding的详细信息可以查看这里。也许有人会问，为什么需要做这种策略，因为在一个大型系统中最后的瓶颈会落在网络的带宽和磁盘的读写上，如果将数据分布在多个机器上的多个磁盘上，将会系统数据的处理能有所提高。
MongoDB 集群的结构：
	下图中Shard是指每个节点的shard有一个或更多的服务器和存储数据的mongod进程，而mongod是MongoDB数据的核心进程。
每台机器上的mongod从配置获取服务器(元数据metadata )，然后，当收到客户端请求时，它请求路由到相应的服务器组和编译结果发送回客户端。
mongos进行可以被看作是一个路由和协调的过程，因为他可以使得每个单一的各个节点组成一个集群系统。 另外还需要强调一点mongos进程没有持久状态，每个实例都需要一定的数据存储的内存空间。
换而言之，所谓MongoDB 集群也就是 MongoDB做了一个数据库路由的策略，而且保证跨库操作的数据库事务，而MongoDB 集群中的关键部分Sharding不是一门新技术，而是一种策略，关键还是看应用场景和案例提供的可用性，因为Sharding不仅仅是MongoDB 集群中所提到的分布在不同的机器上，还可以分表，分区，分数据，等等。

MongoDB 集群的工作原理：
其中有一个服务器上存储着集群的metadata信息，包括每个服务器，每个shard的基本信息和chunk信息Config Server 主要存储的是chunk信息。每一个config服务器都复制了完整的chunk信息，就是下图中左边黄色的部分。
如果客户端对集群的MongoDB插入一条数据，客户端并不知道刚刚插入的数据被分配到具体哪个MongoDB节点上了，因为当一条数据被传入 MongoDB集群中通过mongos路由，所以我们并感觉不到是数据存放在哪个shard的 chunk上，但是通过后台的Sharding的管理命令可以看到插入的数据存放在哪个节点上。

配置MongoDB集群
	
模拟2个shard服务、一个config服务、一个mongos process,全部运行在一个测试的服务器上，具体配置步骤如下：
	口水： &#8211;shardsvr 是表示以sharding模式启动Mongodb服务器，Mongodb数据同步方式参见我写的另外一篇文章&#8220;MongoDB 主(Master)/从(Slave)数据同步  &#8221;
	$ mkdir /data/db/a
	$ mkdir /data/db/b
	$ mkdir /data/db/config
	$ ./mongod &#8211;shardsvr &#8211;dbpath /data/db/a &#8211;port 10000 &#62; /tmp/sharda.log &#38;
	$ cat /tmp/sharda.log
	$ ./mongod &#8211;shardsvr &#8211;dbpath /data/db/b &#8211;port 10001 &#62; /tmp/shardb.log &#38;
	$ cat /tmp/shardb.log
	$ ./mongod &#8211;configsvr &#8211;dbpath /data/db/config &#8211;port [...]]]></description>
		<link>http://www.javabloger.com/article/mongodb-cluster.html?source=rss</link>
			</item>
	<item>
		<title>大型系统中使用JMS优化技巧&#8211;Sun OpenMQ</title>
		<description><![CDATA[我们先来看看在Sun OpenMQ系统中 一个持久、可靠的方式传送消息的步骤是怎么样的，如图所示：

查看大图请点击这里
	
在传送过程中，系统处理JMS消息分为以下两类：
	&#160; ■ 有效负荷消息，由生成方发送给使用方的消息。
	&#160; ■ 控制消息，代理与客户端运行时环境之间传送的私有消息，用于确保有效负荷消息成功传送和控制跨连接的消息流。
	详细流程如下：
	消息生成
	&#160;&#160;&#160; 1. 客户端运行时环境通过连接将消息从消息生成方传送到代理。
	消息处理和路由
	&#160;&#160;&#160; 2. 代理从连接中读取消息并将此消息放入相应的目的地中。
	&#160;&#160;&#160; 3. 代理将（持久性）消息放入数据存储库中。
	&#160;&#160;&#160; 4. 代理向消息生成方的客户端运行时环境确认已收到消息。
	&#160;&#160;&#160; 5. 代理确定消息的路由。
	&#160;&#160;&#160; 6. 代理将消息从目的地写入适当的连接，并使用使用方的唯一标识符标记该消息。
	消息使用
	&#160;&#160;&#160; 7. 消息使用方的客户端运行时环境将消息从连接传送到消息使用方。
	&#160;&#160;&#160; 8. 消息使用方的客户端运行时环境向代理确认消息已使用。
	消息生命周期结束
	&#160;&#160;&#160; 9. 代理处理客户端确认，并在收到所有确认后删除（持久性）消息。
	&#160;&#160;&#160; 10. 代理向使用方的客户端运行时环境确认，告知客户端确认已得到处理。
	如果管理员删除目的地中的消息，或者管理员删除或重新定义长期订阅，导致主题目的地中的消息未被传送即被删除，则代理可以在消息被使用前将它丢弃。在其他情况下，您可能希望代理将消息存储在称为停用消息队列的特殊目的地中，而不是将它们丢弃。在以下情况，消息会被放入停用消息队列中：消息过期时、消息因内存限制而被删除时，以及因客户端引发异常而导致传送失败时。通过将消息存储在停用消息队列中，您可以解决系统问题并在某些情况下恢复消息。
	以下是针对JMS应用中的一些优化策略，H.E.在这里分为几点向大家进行介绍：
	1.收发消息的属性
	在接收端和发送端可以设置消息发送和接收的属性，对于消息发送时还需要注意客户端的消息确认模式一共有3种客户机确认模式：
	■ 在AUTO_ACKNOWLEDGE 模式下开销最大，可以保证消息逐条传送的可靠性，会话自动确认客户端使用的每条消息。会话线程会被阻止，以等待代理确认它已处理了每个已使用消息的客户端确认；
	■ 在CLIENT_ACKNOWLEDGE 模式下，在一条或多条消息被使用后，客户端通过调用消息对象的acknowledge() 方法来显式确认。这样该会话就确认了自上次调用该方法后使用的所有消息。会话线程会被阻止，以等待代理确认它已处理了客户端确认。Message Queue 提供使客户端可仅仅确认收到一条消息的方法，从而扩展了该模式。因此需要的带宽开销较小；
	■ 在DUPS_OK_ACKNOWLEDGE 模式下，会话在使用了十条消息后进行确认。会话线程不会因等待代理确认而被阻止，因为在该模式下代理确认不是必需的。虽然该模式可保证不会丢失消息，但并不能保证不会收到重复的消息，因此名称为：DUPS_OK。
	对于更关心性能而不是可靠性的客户端，Message Queue 服务通过提供NO_ACKNOWLEDGE模式来扩展JMS API。在该模式下，代理不跟踪客户端确认，所以不保证使用方客户端已成功处理了消息。对于发送至非长期订户的非持久性消息，选择该模式可提高性能。
	如果你有大量的消息需要进行发送，可以采用DUPS_OK_ACKNOWLEDGE模式，因为他是最快的。
	代码示例
	connection = connectionFactory.createTopicConnection();
	session=connection.createSession(false, Session.DUPS_OK_ACKNOWLEDGE);&#160;
2.慎用消息压缩
	消息的大小对消息的效率是有影响的，跟Http/Gzip的道理一样，减少网络的负载，但是并不能提升你的运行效率，反而会将你的接收响应时间延时。以下是消息压缩的代码示例：
	1.发送压缩消息的代码示例：
	&#160; for (int i=0;i&#60;10000;i++){&#160; //循环1W次发送消息
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#160;&#160;&#160; &#160;Javabloger_Msg msg=new Javabloger_Msg ();&#160;&#160; // 自定义的对象，进行实例化
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#160;&#160;&#160; &#160;msg.setTime( [...]]]></description>
		<link>http://www.javabloger.com/article/sun-openmq-jms-large-scale-systems.html?source=rss</link>
			</item>
	<item>
		<title>感悟</title>
		<description><![CDATA[要学会不断的主动、积累、分享、反思，是我当前职业生涯座右铭，牢记这个八个字，常说，常做，需要为这个八个字的付出实际行动，迈向另一个目标的起点。
	&#160;&#160;&#160;&#160; 主动&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;
	&#160;&#160;&#160;&#160; 积累&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;.
	&#160;&#160;&#160;&#160; 分享&#8230;&#8230;&#8230;&#8230;.. 
	&#160;&#160;&#160;&#160; 反思&#8230;&#8230;&#8230;. 
	以上观点内容将来再填写， 说起来会更生动，更具体。 
	不管遇到任何瓶颈和困难的时候不要怀疑自己的能力，请相信自己的潜能是无限的，因为通常把不可能变成有可能的人才是有用的人。
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/j2ee-corporate-advisory.html?source=rss</link>
			</item>
	<item>
		<title>Sun OpenMQ Topic消息收/发 —Tips</title>
		<description><![CDATA[Story1
	现象
	项目需要采用JMS 消息中间件OpenMQ 来发送、接收一对多消息。前期需要进行对性能进行模拟测试，开始测试时发送端没有问题循环1000次发送Topic消息顺利结束，但是Topic接收端表现异常，间隔50个一次的接收消息进行处理，如果把1000个消息处理完成大概需要30分钟，更别说下面还要启用100个线程发送1000次了。
	环境
	3台JMS 消息中间件OpenMQ集群，Linux
	1台消息发送端，Windows
	1台消息接收端,&#160; Windows
	如图所示：
	&#160;
	查看大图请点击这里
	
	代码
	发送端代码 (下载url)&#160; 
	接收端代码 (下载url)
	需要的Jar包
	
	经过几番测试，猜测问题多数是由于接收端与服务器端连接的配置而导致的，仔细检查发现多写了几行代码，接收端验证的部分，也就是说对于JMS的消息收发加上验证是对效率有影响的，去掉用户名、密码验证一切正常。
	Story2
	100个线程同时发送100个消息，一共10w个消息，运行到一半的时候出现
	[29/Mar/2010:03:34:07 EDT] [B1089]: In low memory condition, Broker is attempting to free up resources
	[29/Mar/2010:03:34:07 EDT] [B1088]: Entering Memory State YELLOW from previous state GREEN&#160; &#8211; allocated memory is 151214K, 80% of total memory used
	显然在说内存不够。经过google以后证明我的想法是正确的，参考文档：
	http://docs.sun.com/app/docs/doc/819-4467/6n6k98bq2?l=zh_tw&#38;a=view#aeokn
	http://docs.sun.com/app/docs/doc/819-4467/6n6k98bqa?l=zh_tw&#38;a=view
	加大运行内存，命令如下：
	nohup imqbrokerd -tty -name myBroker -port 6769 -cluster 172.16.2.214:6769,172.16.2.215:6769 -D&#34;imq.cluster.masterbroker=172.16.2.215:6769&#34; -vmargs &#34;-Xms256m -Xmx1024m&#34; &#38;
话外音
	1.可以用imqcmd metrics [...]]]></description>
		<link>http://www.javabloger.com/article/sun-glassfish-openmq-topic.html?source=rss</link>
			</item>
	<item>
		<title>MongoDB主(Master)/从(Slave)数据同步</title>
		<description><![CDATA[您需要启动的两个MongoDB文档数据库，一个是以主模式启动，另一个属于从模式启动。因此，主服务器进程将创建一个local.oplog，将通过这个&#8220;交易记录&#8221;同步到Slave服务器中。
	主服务器：172.16.2.213 /Linux
	从服务器：172.16.2.19 /WinXP
	进入mongodb数据库服务器目录，启动Master数据库服务器，指定数据存放路径为 /var/masterdb/，指定端口为556600
	启动命令：
	bin/mongod &#8211;master &#8211;dbpath=/var/data/ &#8211;port=556600 &#38;
	启动slave从数据库服务器，指定数据存放路径为 /var/slavedb/,主数据库地址为172.16.2.213:556600，每隔10秒同步一次
	启动命令：
	bin/mongod &#8211;slave &#8211;source=172.16.2.213:556600&#160; &#8211;dbpath=/var/slavedb/ &#8211;port=556611 &#8211;slavedelay 10 &#38;
	登陆slave从数据库服务器，在slave上添加主机信息：
	D:\mongodb\bin&#62;mongo 172.16.2.19:556611
	出现以下信息表示登陆成功:
	&#160;&#160; &#160;MongoDB shell version: 1.4.0
	&#160;&#160; &#160;url: 172.16.2.19:556611
	&#160;&#160; &#160;connecting to: 172.16.2.19:556611/test
	&#160;&#160; &#160;type &#34;exit&#34; to exit
	&#160;&#160; &#160;type &#34;help&#34; for help
	加入主机:
	&#160;&#160; &#160;db.sources.insert( { host:172.16.2.213 } );
	在slave从数据库服务器上查看是否和主机连接配置正确
	db.printSlaveReplicationInfo();
	如果成功将会出现以下信息
	&#160;&#160; &#160;source:&#160;&#160; 172.16.2.213:556600
	&#160;&#160; &#160;syncedTo: Fri Mar 26 2010 12:55:19 GMT+0800
	&#160;&#160; &#160;&#160;&#160; &#160; = -10secs ago (0hrs)
	&#160;&#160; &#160;&#62;
	主从两者之间的关系，如图所示：
	
查看大图请点击这里
	

	相关文章：
	Java操作 [...]]]></description>
		<link>http://www.javabloger.com/article/mongodb-master-slave-replication.html?source=rss</link>
			</item>
	<item>
		<title>GlassFish优化技巧 -GlassFish HTTP/1.1 GZIP</title>
		<description><![CDATA[GlassfishV3现在支持HTTP/1.1 GZIP压缩 ，经过HTTP Gzip压缩可以大大提高浏览网站的速度，它的原理是，在客户端请求网页后，从服务器端将网页文件压缩，再下载到客户端，由客户端的浏览器负责解压缩并浏 览。相对于普通的浏览过程HTML ,CSS,Javascript , Text ，它可以节省40%左右的流量。更为重要的是，它可以对动态生成的，包括CGI、PHP , JSP , ASP , Servlet,SHTML等输出的网页也能进行压缩，工作原理如图所示：
	图1没有使用Gzip，客户端发出1kb的请求，从服务器端获得100kb的数据结果，如果用户访问量大对网络带宽资源肯定会有影响。
	
	图2使用Gzip后，客户端发出1kb的请求，从服务器端获得10kb的压缩数据结果，节省网络带宽传输。
	
	&#160;&#160; &#160; 
	您可以启用HTTP压缩采用了两个方法：
	1.最快的方法是编辑 ${glassfish.home}/domains/domain/config/domain.xml文件，在http-listener节点中添加： 
	&#160;&#160;&#160; &#60;http-listener&#62;
	&#160;&#160;&#160; &#160;&#8230;&#8230;&#8230;&#8230;.
	&#160;&#160;&#160; &#160;&#8230;&#8230;&#8230;.
	&#160;&#160;&#160; &#160;&#8230;&#8230;.
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#60;property name=&#34;compression&#34; value=&#34;on&#34;/&#62;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#60;property name=&#34;compressableMimeType&#34; value=&#34;text/html,text/xml,text/plain&#34;/&#62;
	&#160;&#160;&#160; &#60;/http-listener&#62; 
	2.或者可以通过Admin-GUI图形化界面进行配置管理，如图所示：
	
配置参数说明：
	compressableMimeType:表示 HTTP 压缩那些可能使用类型的列表，默认值是text/html,text/xml,text/plain。
	compression:参 数中off表示&#8220;关闭&#8221; (禁用压缩)，参数中on表示&#8220;开启&#8221; (允许压缩，这会导致文本压缩数据)，参数中force表示&#8220;强制&#8221;(在任何情况下都使用压缩)。
	noCompressionUserAgents:表示哪些类型的数据是不使用HTTP压缩的，该值默认值为空字符串。
	minCompressionSize:压缩时的最小值。

	相关文章:
	 Glassfish(EJB) 与Quartz Job Scheduler整合  
	GlassFish 性能优化  
	GlassFish JMS 集群  
	GlassFish 文档  
	GlassFish 数据库连接池的配置步骤(图解)  
	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/glassfish-gzip.html?source=rss</link>
			</item>
	<item>
		<title>Java操作MongoDB NoSQL数据库</title>
		<description><![CDATA[一、介绍
	MongoDB是一个&#8220;绿色&#8221;免安装直接解压(unzip)即可运行的高性能，开源，无 关系型(NoSQL)的文档型数据库，它在许多场景下可用于替代传统的关系型数据库或键(key)/值(value)存储方式。Mongo使用C++开 发，提供了以下功能：&#160;&#160;&#160; 
	&#160;&#160;&#160; * 面向集合的存储：适合存储对象及JSON形式的数据。
	&#160;&#160;&#160; * 动态查询：Mongo支持丰富的查询表达式。查询指令使用JSON形式的标记，可轻易查询文档中内嵌的对象及数组。
	&#160;&#160;&#160; * 完整的索引支持：包括文档内嵌对象及数组。Mongo的查询优化器会分析查询表达式，并生成一个高效的查询计划。
	&#160;&#160;&#160; * 查询监视：Mongo包含一个监视工具用于分析数据库操作的性能。
	&#160;&#160;&#160; * 复制及自动故障转移：Mongo数据库支持服务器之间的数据复制，支持主-从模式及服务器之间的相互复制。复制的主要目标是提供冗余及自动故障转移。
	&#160;&#160;&#160; * 高效的传统存储方式：支持二进制数据及大型对象（如照片或图片）。
	&#160;&#160;&#160; * 自动分片以支持云级别的伸缩性（处于早期alpha阶段）：自动分片功能支持水平的数据库集群，可动态添加额外的机器。
	二、场 景
	MongoDB的主要目标是在键/值存储方式以及对传统的RDBMS系统架起一座桥梁，集两者的优势于一身，Mongo 适合用于以下场景：
	&#160;&#160;&#160; * 网站数据：Mongo非常适合实时的插入，更新与查询，并具备网站实时数据存储所需的复制及高度伸缩性。
	&#160;&#160;&#160; * 缓存：由于性能很高，Mongo也适合作为信息基础设施的缓存层。在系统重启之后，由Mongo搭建的持久化缓存层可以避免下层的数据源过载。
	&#160;&#160;&#160; * 大尺寸，低价值的数据：使用传统的关系型数据库存储一些数据时可能会比较昂贵，在此之前，很多时候程序员往往会选择传统的文件进行存储。
	&#160;&#160;&#160; * 高伸缩性的场景：Mongo非常适合由数十或数百台服务器组成的数据库。Mongo的路线图中已经包含对MapReduce引擎的内置支持。
	&#160;&#160;&#160; * 用于对象及JSON数据支持的非常友好，Mongo的BSON数据格式非常适合文档化格式的存储及查询。
三、准备
	1.下载MongoDB的最新版列表 http://www.mongodb.org/display/DOCS/Downloads ，
	&#160;&#160; 下载需要的Jar 驱动包 http://github.com/mongodb/mongo-java-driver/downloads 。
2.解压缩刚刚下载的 mongodb-linux-i686-1.2.4.tgz 文件。
3.复制解压好的 mongodb 目录，到自己指定的目录下。
4. 创建一个数据文件目录 mkdir -p&#160; /var/lib/mongodb/
5.运行 Mongodb服务 &#8220;./mongod &#8211;dbpath /var/lib/mongodb/ &#8211;logpath /var/log/mongodb.log&#8221;
	指定数据文件存放的目录，并且指定数据日志文件输入的目录，出现 Thu Mar 25 22:18:52 waiting [...]]]></description>
		<link>http://www.javabloger.com/article/mongodb-java.html?source=rss</link>
			</item>
	<item>
		<title>FireFox告诉我们google退出，百度从这里开始</title>
		<description><![CDATA[今天回家开机上网晚上9时，打开火狐浏览器居然弹出百度的搜索登陆界面，google在中国的退出居然产生了这样的连带效果，一时之间还真让人无法应接，如图所示：

我们知道Mozilla Firefox和Google有交易，Firefox的搜索栏缺省使用Google的搜索服务，Google对Firefox提供资金支持。虽然 Mozilla是一个非盈利组织，员工也要吃饭，开发也要买设备，没收入是不行的，而搜索量能够给Google带来广告收入，所以双方自然一拍即合。难道这次 Firefox和百度也有了交易？！笑吧，百度真的开始笑了，随之而来的一些霸王条约。最后我们上网是否真的要在一个蔽塞的大局域网中？
BTW：另外，通过这件事还知道Firefox除了号称 火狐 之外还有一个真正的中国名字 北京谋智网络技术有限公司。
]]></description>
		<link>http://www.javabloger.com/article/google-out-baidu-in-by-firefox.html?source=rss</link>
			</item>
	<item>
		<title>大型视频网站 Justin.tv的架构设计</title>
		<description><![CDATA[
* 每月3000万独立访问者，每月新增注册用户有30w， 每秒钟有近2000个视频上传。
* 整个网站大约200视频服务器，每发送视频1Gbps的能力，大约每周存储100TB的文件。
* 并且在全国建立了4个数据中心，采用Map/Reduce策略对视频存储。
* 并且每个在线观看视频的用户还可以直接在线聊天，虽然提高了用户的体验，但是再次加大了网站的负载和设计的难度。
	对于这样的高流量、大文件存储是视频网站与其他门户网站的不同之处，对于Justin.tv来说如果所有的视频存储在磁盘上，Live的视频将不能给用户得到流畅的体验，所以它需要与传统类型的网站具有完全不同的架构。
	领跑者&#160; CEO Michael&#160; 
	
	领跑者&#160; 创始人之一 Justin
	
	这个网站也是用他名字来命名的，另外这个网站对中文支持的很不错，这个家伙是不是有点中国血统？
	平台
	&#160;&#160; 1. Twice &#8211; 前端基于python开发web缓存. (http://code.google.com/p/twicecache/) 未公布源码
	&#160;&#160; 2. XFS &#8211; 分布式文件系统.
	&#160;&#160; 3. HAProxy &#8211; 软件负责均衡.
	&#160;&#160; 4. LVS &#8211; 传统的Linux虚拟服务器.
	&#160;&#160; 5. Ruby on Rails &#8211; 应用服务器
	&#160;&#160; 6. Nginx &#8211; web 服务器
	&#160;&#160; 7. PostgreSQL &#8211; 数据库服务器.
	&#160;&#160; 8. MongoDB &#8211; NoSql数据库，用网站于内部分析工具.
	&#160;&#160; 9. MemcachedDB &#8211; 数据库缓存.
	&#160; 10. Syslog-ng &#8211; [...]]]></description>
		<link>http://www.javabloger.com/article/justin-tv-architecture-2.html?source=rss</link>
			</item>
	<item>
		<title>敏捷的优势</title>
		<description><![CDATA[敏捷的优势并不是运行的速度提高了，而是团队运作效率提高了，投入的总成本降低了，可持续性的资源更多了，客户的抱怨更少了，这些现象足以说明敏捷 开发比传统技术更为成功，是因为：
	&#160;&#160;&#160; * 每个成员之间不断的沟通，所以敏捷的团队比传统团队更为高效。
	&#160;&#160;&#160; * 采用TDD测试驱动开发，所以敏捷的项目比传统方法开发的产品质量更高。
	&#160;&#160;&#160; * 不断的获得信息反馈，所以敏捷的项目产出能让业务干系人更加满意。
	&#160;&#160;&#160; * 可以及早的发现错误，所以敏捷的项目比传统开发项目成本更低。
从 敏捷开发的整理流程可以看出持续性和迭代性很强，如图所示：

从上图很明显的可以看出敏捷的2个特点：
1.频繁的对客户进行交付
	&#160;&#160;&#160; 每次以不同的小版本进行交 付，可以按照数周而不是数月的间隔频繁地交付可工作的软件。如果您的应用程序是 Web 应用程序，您可能希望频繁推出更新以添加新功能，或者在获得客户的反馈时改进该应用程序。您不必担心繁重的版本控制任务，或者维护文件以跟踪哪个客户端具 有哪个版本。
	&#160;&#160;&#160; 如果版本发布涉及到客户端的更改或工作，您可能不希望频繁地做出更新。此外，频繁的迭代也许是个好主意，因为您知道自己可以在数周而不是数月内实现和发布 更改。这就是敏捷的优势，发开/设计-&#62;反馈&#8211;&#62;修改&#8211;&#62;发开/设计。
	2.亲密无间的协作与沟通
	&#160;&#160; 业务人员和软件开发人员应该每天就解决方案交换意见并展开协作。后期需求更改可能来自于业务人员，并且开发人员 应该实现那些需求。如果流程允许需求变更，则日常协作是必需的。
	&#160;&#160;&#160; 对于实现接口或规范的应用程序，需求应该与指定的权威机构发布的规范文档相同。对该文档的更改不只是大事，这种更改根本就不应该出现。
相关文章：
	&#160;&#160;实施敏捷的要素
	&#160;&#160;每日项目例会的必要性
	&#160;&#160;微软、SUN公司 测试工作
	&#160;&#160;理想的敏捷工作环境与氛围
	&#160;&#160;驱动测试开发
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/cost-of-agile.html?source=rss</link>
			</item>
	<item>
		<title>Google是怎么使用Java的</title>
		<description><![CDATA[Google公司只招收3种程序员 C++、Python、Java，所以很多从事Java和Java Web 方面开发的朋友会很关心Google公司是怎么使用Java语言的。
	Google首席Java架構師Joshua Bloch與Google專任工程師兼Java講師Neal Gafter他们2位是怎么说的，首先来介绍一下
	Joshua Bloch
	
	Google首席架構師，是《Effective Java》、《Java Puzzlers》作者，语录：&#8220;当你要建立一个像Google这样规模的搜寻服务，你可以想像会有多少问题，但是我们就是要持续的让服务运作下去，尽量让系统可以 自动修复，不要造成延迟。&#8221;
	Neal Gafter
	
	Google專任工程師兼 Java讲师，《Java Puzzlers》的作者,语录：&#8220;使用AJAX撰写应用程式，会比用Java用户端技术撰写应用程式花上更多力气，因为可携性不会是免费奉送的。&#8221;
详细内容请浏览：
	http://www.ithome.com.tw/itadm/article.php?c=39042&#38;s=1
	http://www.ithome.com.tw/itadm/article.php?c=39042&#38;s=2
	http://www.ithome.com.tw/itadm/article.php?c=39042&#38;s=3
	
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/java-on-google.html?source=rss</link>
			</item>
	<item>
		<title>软件设计方案&#8211;需求文档前传</title>
		<description><![CDATA[怎么写软件设计方案]]></description>
		<link>http://www.javabloger.com/article/%e6%80%8e%e4%b9%88%e5%86%99%e8%bd%af%e4%bb%b6%e8%ae%be%e8%ae%a1%e6%96%b9%e6%a1%88.html?source=rss</link>
			</item>
	<item>
		<title>Google Analytics(谷歌分析) 架构与原理</title>
		<description><![CDATA[Google Analytics(Google分析)是Google的一款免费的网站分析服务，Google&#160; Analytics最早是由一些工程师设计的，后来被Google收购，现在被广受好评。对于Google Analytics的用户目前在国内的用户已经数以万计，本站 www.javabloger.com也使用Google Analytics工具对网站的访问趋势进行分析。Google Analytics功能非常强大，只要在网站的页面上加入一段代码，就可以提供的丰富详尽的图表式报告。
Google Analytics的采集功能是采用AJAX技术来实现，还可以对google共享你的分析数据，并且还可以设置系统提醒功能。
	整体架构如图所示： 
	
查看大图请点击这里
	

	使用Google Analytics我们知道首先需要在你的网站中加入根据代码，下面我们来看看嵌入在网站中跟踪代码如何工作的
	谷歌分析跟踪代码(Google Analytics Tracking Code&#160; GATC) 检索的网页数据如下：
	&#160;&#160; 1&#160;&#160;&#160; 浏览器请求的网页包含跟踪代码。
	&#160;&#160; 2&#160;&#160;&#160; GATC创建并初始化一个对象的属性与网络相关的跟踪ID在代码中。
	&#160;&#160; 3&#160;&#160;&#160; GATC执行你自定义任何跟踪方法。
	&#160;&#160; 4&#160;&#160;&#160; 跟踪代码初始化和管理以下信息：
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; *跟踪检索查看是否包括广告系列。
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; *收集从HTTP请求的信息到Google&#160; GATC中介 的各种用户信息。
	&#160;&#160; 5&#160;&#160;&#160; 将访问者HTTP请求包含GATC跟踪信息收集到参数名单。
	如图所示：

	以上详细过程还可以参考Google的官方资料：http://www.google.com/support/googleanalytics/bin/answer.py?hl=cn&#38;answer=55540
	&#160;&#160;&#160;&#160; 和
	Google分析工具的官方帮助中心：http://www.google.com/support/googleanalytics/
H.E的口水：
	1.不同的用户来源需要进行时间差计算，是不是就是因为这个所以在Google分析工具里面只给使用太平洋的时间。
	2.老调重弹，Google对于大数据量存储和大规模并发访问的策略做的的确是很棒。再次引发了我对Google架构的探索，在此插入一个技术类型的小广告(图片)，如图所示google 的搜索引擎部分的架构图：

	3.从Google 分析工具的报告版面上来看，GATC的数据收集的非常详细，能做到比较全面而不占用资源，对用户透明，不容易。
当你使用Google Analytics分析时需要你创建 Google Analytics的用户&#8220;网站配置文件&#8221; ，创建&#8220;网站配置文件&#8221;的目的是为了方便网站多个管理员从各种对网站不同的关注角度对网站的访问进行分析，每个用户之间的分析数据也是私密性的，尽管它可能需要几分钟额外设立一个新的帐户配置文件，它通常是值得的，因为它可以帮助访问安全性和数据完整性，确保能给你更准确和有用的信息。。
	如图所示：
	&#160; 
	当你在网站内创建完成&#8220;网站配置文件&#8221; ，接下来我们再来看看 访问用户、网站管理员、GA(Google Analytics) 大致是怎么样的工作过程。
	&#160;&#160; 1.访问者访问网站
	&#160;&#160; 2.触发到 GATC 代码，根据GATC采集用户信息，放入Google Analytics 日志
	&#160;&#160; 3.通过你创建的过滤器对需要进行过滤的数据进行筛选。
	&#160;&#160; 4.将采用和过滤后的信息放入Google Analytics 的数据库中
	&#160;&#160; 5.管理者通过Google Analytics 的界面查看分析数据
	整体工作流程如图所示：
	

	根据你的不同过滤条件可以对网站的访问者统计的数据进行过滤，如图所示：


	具体使用 Google [...]]]></description>
		<link>http://www.javabloger.com/article/google-analytics-architecture.html?source=rss</link>
			</item>
	<item>
		<title>3句话，给自己 &#8211; Making Others Great</title>
		<description><![CDATA[1.帮助别人成功，自己也成功了。BTW：有能力的人需要有这样的觉悟。
	2.快乐是因为你正在追求正确的东西，痛苦说明你在追求错误。
	3. 简单、勤奋 是每个人都需要 和 努力的要素。
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/making-others-great.html?source=rss</link>
			</item>
	<item>
		<title>本站与豆瓣9点已关联</title>
		<description><![CDATA[已经与豆瓣的9点已关联
	http://9.douban.com/subject/9352912/
	doubanclaim3b9901ccbe288296
	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/douban-connection.html?source=rss</link>
			</item>
	<item>
		<title>大型网站的web服务器</title>
		<description><![CDATA[在网上闲逛的时候看到了一篇文章，http://blog.csdn.net/wzwfly/archive/2007/05/10/1603691.aspx 这篇文章虽然转载的，是发表于 @ 2007年05月10日　21:46:00 ， 凭我的个人直觉 google、Alibaba.com、Baidu.com、douban.com 这些非常活跃的家伙不会原地不动的。
	所以 H.E.打算用工具探测了一下，结果果然不出所料。
	Google&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; Web服务器:&#160; Google Web Server&#160; &#8211;GWS是根据Apache内核进行二次开发的
	Apache.org&#160;&#160;&#160; &#160;Web服务器:&#160; Apache/2.2.8 (Unix)&#160;&#160; 运行在 PHP/5.2.10环境中，目前Apache上推荐下载的最新版本是 httpd-2.2.15.tar.gz
	Yahoo&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; &#160; Web服务器:&#160; YTS/1.17.23.1&#160; YTS是自己的开发的，参见Yahooz在开源大会上公布的资料(Pdf 资料)
	alex.com&#160;&#160;&#160; &#160;&#160;&#160; &#160;Web服务器:&#160;&#160; Apache/2.0.55 (FreeBSD)&#160;&#160;&#160; 运行在 PHP/5.1.2环境中
	Microsoft&#160;&#160;&#160; &#160;&#160;&#160; &#160;Web服务器:&#160;&#160; Microsoft-IIS/7.5&#160;&#160; 也算是自己研制的吧
	eBay.com&#160;&#160;&#160; &#160;&#160;&#160; Web服务器: &#160;Apache-Coyote/1.1 也就是 Tomcat 
	Alibaba.com&#160;&#160;&#160; Web服务器: &#160;Apache/2.2.15 ，应用服务器：JBoss-4.0.5.GA ， JK模块：mod_jk/1.2.28
	Baidu.com&#160;&#160;&#160; &#160; &#160;Web服务器: &#160; BWS/1.0&#160; 看见这个信息从屏幕上出现我不得不佩服我们中国人的山寨意识，同时也表示深深的无语
	Sina.com.cn&#160;&#160;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/top-20-web-stie-web-server.html?source=rss</link>
			</item>
	<item>
		<title>Java对XML节点的修改、添加、删除 &#8211;By Xstream框架</title>
		<description><![CDATA[在J2EE、Java项目中对xml操作是一项非常常见的事情，在我认识了XStream以后，才彻底明白XML模型对象的概念，使用XStream让我XML的设计不由自主更符合OO的风格。另外，除了在设计上得到的体验，还在实际操作中得到了便捷的体验。
	简单来说，我在IBM的Java开发园地上看过一些操作XML经典的文章被广为流传，但是无论是采用DOM4J还是JDOM对XML文件中的节点或者整个文件的进行 修改、添加、删除 都没有XStream 简单、方便。
	下面来看一下 XStream 官方网站上的例子，网站地址：&#160;&#160;&#160; &#160;http://xstream.codehaus.org/tutorial.html。
	官方网站上的例子只是提供了一个例子，并没有说明如何对 XML节点进行修改、添加、删除，XStream 官方网站上只是给出了一个从对象到XML，从XML到对象的例子。
Javabloger的作者H.E.通过实践发现采用 XStream可以很简单的对XML节点进行 修改、添加、删除，比传统的XML框架简单很多倍，用过一次的人都不会忘记，因为实在是太方便了。
	&#160;
	修改XML节点代码示例如下：
	&#160;&#160;&#160; 
	&#160;&#160;&#160; public void upDateMySQLRecentHost(String&#160; HostID)&#160; throws&#160; Exception {
	&#160;&#160;&#160; &#160;&#160;&#160; List &#60;RecentHost&#62; list=null;
	&#160;&#160;&#160; &#160;&#160;&#160; try {
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; list=getMySQLRecentHost();&#160;&#160;&#160; // 1. 先通过 XStream读取XML文件，变成List集合里面包含节点对象。
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; for (int i=0;i&#60;list.size();i++){&#160;&#160;&#160;&#160;&#160;&#160;&#160; //&#160; 2. 遍历整个 List 对象集合
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; if (list.get(i).getId().equals(HostID )){&#160;&#160;&#160;&#160;&#160;&#160;&#160; // 3. 比较 [...]]]></description>
		<link>http://www.javabloger.com/article/java-xml-node-add-delete-update.html?source=rss</link>
			</item>
	<item>
		<title>大型JavaMail网站Mailinator架构(Linux+Tomcat+Java)</title>
		<description><![CDATA[采用Javamail和Java技术构建的Mailinator很有趣是一个免费、不需要进行注册就可以收邮件的平台，称之为&#8220;一次性电子邮件服务&#8221;。你在一个网站注册时并不想提交你的邮件地址，因为你担心将来会受到垃圾邮件的骚扰，但你此时又必须在这个网站上注册输入你的邮件地址。
此时你可以使用Mailinator来为你服务。但 Mailinator 他不是垃圾邮件制造器。比如：发送邮件到javabloger@Mailinator.com，该邮箱就会自动创建。
	访问Mailinator网站 输入你的邮箱就能进入浏览邮件了，注意：Mailinator只是个临时邮箱，作用就是防止垃圾邮件对你的骚扰，一次只能保持10封邮件，不支持附件，单个邮件限120K以内，任何人都可以浏览，不要用来存在重要的邮件。
	登陆网址：http://mailinator.com&#160; 经过测试对中文支持的非常友好，如图所示：
	
查看大图请点击这里
	下面我们来看看这个替身英雄
	系统平台
	&#160;&#160; &#160;操作系统：Linux 
	&#160;&#160; &#160;应用服务：Tomcat
	&#160;&#160; &#160;语言环境：Java
	统计资料 
	&#160;&#160; &#160;2005年 28068.0万封
	&#160;&#160; &#160;2006年 450740000 封
	&#160;&#160; &#160;2007年将处理，估计为1.29亿封。峰值速度650万封电子邮件/日， 4513/分钟 ，75/秒。
	&#160;&#160; &#160;开始是Mailinator 运行在AMD 2GHz的Athlon处理器，1GB内存 ，普通80G IDE 硬盘 。
	&#160;&#160;&#160; 即使是在不断的攻击和垃圾邮件高峰负荷，Mailinator无人值守运行几个月，也很少有邮件丢失。
	Mailinator 老的架构
	&#160;&#160; &#160; 收到邮件保存在磁盘上。
	&#160;&#160; &#160; 然后采用Java 去读取磁盘上邮箱中的邮件。
	&#160;&#160; &#160; 然后，系统把所有电子邮件加载到内存中。
	&#160;&#160; &#160; 但是，一旦内存中达到 20,000电子邮件对机器运行就产生了很大的瓶颈。。。。。。。。。。。
	Mailinator 新的架构
	&#160;&#160; &#160;采用了 DOM 和 AOP技术，使用XML对数据进行归档整理，运行AOP便于对将来的扁平扩展。
	&#160;&#160; &#160;接收电子邮件后，解析解析邮件，进行DOM后并将其数据存储到内存中。尽量减轻磁盘负载。
	&#160;&#160; &#160;采用了多种过滤手段，每封邮件通过过滤后，并存储在RAM中。
	&#160;&#160; &#160;&#160;&#160; &#160;比如：过多的邮件从一个IP发出进行屏蔽
	&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160;&#160; 超过120k的电子邮件直接过滤，这样可节省内存。
	&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160;&#160; 每个收件箱仅限于10电子邮件。
	&#160;&#160; &#160;电子邮件被写入磁盘时，系统性能已经下降，因此在轮询启动时加载信息，将2个工作交错开来，减少瓶颈。
	&#160;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/javamail-web-site-mailinator.html?source=rss</link>
			</item>
	<item>
		<title>Linux下OpenMQ集群的启动异常</title>
		<description><![CDATA[今天需要部署2台 Sun OpenMQ集群在的真实生产环境中，同事GuoHai.Yang在部署的过程中遇到一些小问题，之后解决了，现在拿来和大家分享一下。
首先和往常一样先从GlassFishV3目录下Copy MQ出来到另外一台机器上让OpenMQ JSM消息服务独立运行，远程copy完成，然后键入命令
	nohup /opt/mq/bin/imqbrokerd -tty -name myBroker -port 6000 -cluster 10.101.101.223:6000,101.101.224:6000 -D&#34;imq.cluster.masterbroker=10.101.101.223:6000&#34; &#38;
	&#160;&#160;&#160; 现如下错误异常信息：
	&#34;Invalid broker address for this broker to run in cluster: Loopback IP address is not allowed in broker address mq://127.0.0.1:6000/?instName=myBroker&#38;brokerSessionUID=7340910598241782272 for cluster&#34;
	分析了一下异常的信息，开始动手：
	1.查看linux主机名
	&#160;&#160;&#160; 键入 hostname 命令
	2.修改 /etc/hosts文件
	&#160;&#160;&#160; ip (按下tab键)&#160; 主机名&#160; 写入你的ip地址和主机，这一步非常重要，因为问题就是没有指定主机名导致的启动错误。
	3.你可以重启，也可以不重启
	&#160;&#160;&#160; source /etc/hosts
	4.启动 OpenMQ服务
	&#160;&#160;&#160; nohup /opt/mq/bin/imqbrokerd -tty -name myBroker -port 6000 [...]]]></description>
		<link>http://www.javabloger.com/article/linux-openmq-cluster-execption.html?source=rss</link>
			</item>
	<item>
		<title>需求文档中的要素</title>
		<description><![CDATA[软件开发中的需求文档不仅仅需要文字描述，还需要用图形来形象的描述，因为你的需求文档阅者的比重客户占55%以上，最主要的读者对象是客户.
如果是一大堆文字看的人眼花缭乱还需要去理解，显然不够直观。反之简明扼要的图形更容易让人理解，降低读者对文章理解的二义性，提高大家的可沟通性。
	我们最常使用的手段用3种图来表达：
	&#160;&#160; &#160;1.用例图 (User Case)&#160; 可以让大家知道系统中每个功能的 前置(前提)条件，边界，主要的异常状态，有几个角色在里面。
	&#160;&#160; &#160;&#160;&#160;&#160; 
	&#160;&#160; &#160;
	&#160;&#160; &#160;2.数据流程图 (DFD)&#160; 系统中每个功能模块中 输入/输出的数据是什么跑的，如果能跑通，说明逻辑上不会有太大的问题。
&#160;
 查看大图请点击这里

	&#160;&#160; &#160;3.模块展示图(Molde WBS)&#160; 从整个系统，到各个功能模块是怎么划分的，这项设计可以牵涉到可用性和可伸缩性。

	 查看大图请点击这里

	我们做一个比方，如果是一篇英文的文档需要你去阅读，很多文字，英文能力一般的人会比较吃力，但是删掉这个文章里面的很多文字，换成几幅图，就算你的英文水平很烂，我想一般人也能明白这个文章是在说什么了吧，这样说是不是能明白图的作用了？
	另外，在编写需求文档的时候，并不是1-2个Leader在忙，而且整个团队在忙，测试也需要早早的加入，还有那个叫DBA 和 SysAdmin家伙，自从我们推广了敏捷后，每次需求编写、讨论的时候他们也没有脱离我们半步。至少我经历过非常顺利交付的项目他们都是和开发团队一起讨论、编写。
	切记，只要你的客户还存在你的联系人名单上，需求文档对每个成员来说，就不会是一项被完成的工作。
相关文章：
	敏捷的态度  
	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/requirements-document-key.html?source=rss</link>
			</item>
	<item>
		<title>Glassfish(EJB)与Quartz Job Scheduler整合</title>
		<description><![CDATA[废话少说，步骤如下：
1.创建quartz.properties文件放入你的 ${AS_INSTALL}/domains/domain1/config目录下
	2.创建 Quartz Scheduler 的 JNDI Factory程序，例子如下：
	&#8230;
	public class SchedulerFactory implements javax.naming.spi.ObjectFactory {
	private static Logger log = Logger.getLogger(SchedulerFactory.class.getName());
	private static Scheduler scheduler;
	static {
	try {
	StdSchedulerFactory factory = new StdSchedulerFactory(&#34;quartz.properties&#34;);
	scheduler = factory.getScheduler();
	scheduler.start();
	} catch (SchedulerException se) {
	log.severe(&#34;Cannot initialize job scheduler : \n&#34;+se.getMessage());
	scheduler = null;
	}
	}
	public SchedulerFactory() { ; } // Need to have public no-argument constructor
	public static Scheduler getInstance() {
	return scheduler;
	}
	public [...]]]></description>
		<link>http://www.javabloger.com/article/glassfish-quartz-ejb.html?source=rss</link>
			</item>
	<item>
		<title>WOA面向Web的架构 离我们有多远?</title>
		<description><![CDATA[近日有人聊起：&#8220;WOA是什么？&#8221;又有人说：&#8220;WOA纯粹噱头,如今发明这么多概念干什么？&#8221; 我今天在 《Web2.0 Architectures》那本书 
作者 Dion Hinchcliffe&#160; 主页上看到 &#8220;Unboxing Web-Oriented Architecture: The 6 Aspects Of An Emergent Architectural Style&#8221; 一文，地址：http://hinchcliffe.org/archive/2009/06/06/16901.aspx 。
	&#160;
文中不断的提出WOA的概念，还打出了一个副标题：&#8220;WOA as a complete REST architecture&#8221;，真是火上加油啊，REST和WOA都是新兴概念，可惜都不是什么特别的新技术。
&#160;
下面我们来看看 所谓的WOA架构，如图所示：

查看大图请点击这里
	
现在REST技术风格它将是未来的 Internet 采用的主流架构，你会发现REST本身似乎就是关于在Internet上将数据资源从一处移到另一处，而不是构造一个完整的应用。 &#8220;换而言之，WOA远比REST更多，而REST是WOA的基本架构风格。&#8221;
Hinchcliffe将WOA分为两部分来定义：核心部分包括REST，URL，SSL以及XML；还有一个&#8220;WOA完全版&#8221;包括了协议以及接口 (例如，BitTorrent)，身份以及安全(例如，OpenID)，分发与组件(例如，Open API)，以及数据格式与描述(例如，ATOM)。这些内容以六个层次组织成了WOA栈(包括示例用的技术)：
&#160;&#160;&#160; &#183; Distribution &#8211;分发(HTTP, feeds)
	&#160;&#160;&#160; &#183; Composition &#8211;组合(Hypermedia, Mashups)
	&#160;&#160;&#160; &#183; Security &#8211;安全(OpenID, SSL)
	&#160;&#160;&#160; &#183; Data Portability &#8211;数据兼容性(XML, RDF)
	&#160;&#160;&#160; &#183; Data Representation &#8211;数据表示(ATOM, JSON)
	&#160;&#160;&#160; &#183; [...]]]></description>
		<link>http://www.javabloger.com/article/about-woa.html?source=rss</link>
			</item>
	<item>
		<title>大型J2EE项目中的Web容器集群&#8211;Nginx+Glasshfish+Memcached+ServletFilter</title>
		<description><![CDATA[这个标题可能让你看不明白，因为他来自H.E. 山寨 方法，或者说我这种方式将时下比较流行的几个东东进行了DIY整合。
	先看看图，暂且告别一下文字：
	
查看大图请点击这里
	
还没有看懂没有关系，听我慢慢的口水：
	系统环境：
	&#160;&#160;&#160; 1. 操作系统linux
	&#160;&#160;&#160; 2. web服务器Nginx
	&#160;&#160;&#160; 3.Jsp/Servlet 服务器 GlassFish，当然Tomcat/Jboss也可以。
	&#160;&#160;&#160; 4.session存储 Memcached
	&#160;&#160;&#160; 5.自己写的Servlet Filter 读/写 session ，以上图中架构由这5个部分组成。
	压力分载
	&#160;&#160;&#160; 由web服务器Nginx完成，&#160; 在 Nginx服务器的 conf/nginx.conf 文件里面加入这个配置
	&#160;&#160;&#160; &#160; &#160; #upstream backend {
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; #&#160; server 192.168.10.2:8080 weight=1;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; #&#160; server 192.168.10.3:8080 weight=1;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; #&#160; server 192.168.10.4:8080 weight=1;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; #} 
	&#160;&#160;&#160; 
	&#160;&#160;&#160; 你第一次请求Nginx将去指向192.168.10.2 ，第二次请求将去指向192.168.10.3，第三次请求将去指向192.168.10.4，第四次请求将去指向192.168.10.2，第五次请求将去指向192.168.10.3，以此类推。 如果同时有100个请求，2台机器上有33个请求，另外一台机器上有34个请求。这样简单的就实现了压力分载功能。
	失效转发
	&#160;&#160;&#160; 通过每台机器上 Servlet Filter 组件 向中央缓存 Memcached写入，就算你的Jsp/Servlet 容器器down掉你的用户session还在 Memcached中，而最前端的 Nginx服务器会做出判断哪些机器还活着，如果其中一台机器down掉，剩下的2台机器继续平均分配负载。
	优势：
	&#160;&#160;&#160; 1.比传统Apache的整合方式简单了10倍！更加灵活和简单,修改Nginx服务器中不到30行的配置文件就可以搞定压力分载全部功能。
	&#160;&#160;&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/nginx_glasshfish_memcached_servlet-filter.html?source=rss</link>
			</item>
	<item>
		<title>大型网站百万级高并发测试&#8211;MySpace云测试CloudTest™</title>
		<description><![CDATA[2009年12月MySpace在新西兰对用户推出了音乐和视频的服务功能，这些新功能包括能够观看音乐录像，艺术家的视频搜索，创建收藏夹列表，等等。因为MySpace网站在任何国家每日的访问量是巨大的，这些新功能将会带来很大用户访问量 会导致服务器的运行负载加大，为了到达更高的可用性，需要对其的新功能进行云测试 ，来模拟百万级的用户并发访问量。
什么是云测试？
	云测试是基于云计算的一种新型测试方案。服务商提供多种平台，多种浏览器的平台，一般的用户在本地用Selenium把自动化测试脚本编写好，然后上传到他们网站，然后就可以在他们的平台上运行Selenium脚本了。
	MySpace网站的视频新的功能预计将会有100万的并发用户，更重要的前提条件是100w&#39;同时&#39; 访问全功能。
以下是这是在测试过程中生成负载的前提条件：
	&#160;&#160;&#160; *百万虚拟用户并发
	&#160;&#160;&#160; *测试功能包括 音乐、视频搜索，评价影片，将影片新增至我的最爱，等等。
	&#160;&#160;&#160; *每秒钟数据传输 16 gbit
	&#160;&#160;&#160; *每小时超过6TB的数据传输
	&#160;&#160;&#160; *每秒超过77,000的点击次数，不包括实时交通点击
	&#160;&#160;&#160; *采用亚马逊EC2的800来生成负载 
	MySpace云测试环境 CloudTest&#8482;对外公布的资料
	测试环境
	&#160;&#160;&#160; * 7.5 GB内存
	&#160;&#160;&#160; * 4 EC2上计算单位
	&#160;&#160;&#160; * 850 GB的实例存储(2 &#215; 420 GB加10 GB的根分区)
	&#160;&#160;&#160; * CPU 64位平台
	&#160;&#160;&#160; * Linux 操作系统 Fedora Core 8
	PS：组成一个测试云 ，就是下图中有黄色小闪电的部分。
&#160;&#160;&#160; 后端由2个超大的EC2阵列 组成测试控制器实例，并将结果集中到数据库
	&#160;&#160;&#160; * 15 GB内存
	&#160;&#160;&#160; * 8 个EC2上计算单元(每个EC2单元上有4个虚拟计算单元，一个有2组)
	&#160;&#160;&#160; * 1,690 GB的实例存储(4 &#215; 420 GB加10 GB的根分区)
	&#160;&#160;&#160; * CPU [...]]]></description>
		<link>http://www.javabloger.com/article/myspace-cloudtest.html?source=rss</link>
			</item>
	<item>
		<title>多台服务器数据实时备份</title>
		<description><![CDATA[从商业软、硬件上采用Symantec的产品无可非议，例如，
Symantec Veritas Replication Exec
	Symantec NetBackup
	Symantec Backup Exec
	Symantec Veritas Volume Replicator 完全可以满足你的任何需求。 但是还是需要考虑到成本问题。

多台(3台以上)服务器数据采用软件手段实时备份的个人见解如下：
如果从软件自主架构的角度上考虑，是非常廉价的手段，但是需要有一定技术能力，实时备份的 实时是什么样子的场景，需要备份的内容是多大，都需要有一个明确的说法。
	没有任何 IT技术体系、架构能达一步到位效果和最佳实践。
	没有任何 IT技术体系、架构是不根据需求来的。
	比如，你是需要对数据库实时备份，可以通过数据库同步的手段，mysql，msSQL，oracle都有各种手段，每个厂家都各自的看家本领，可以一一去google资料。BTW:mysql多台同步最好采用6.0以上linux的版本，使用集群功能。
	比如，你是需要对服务器里面的html页面文件做实时备份，可以采用Rsync，详见：http://zh.wikipedia.org/wiki/Rsync，当然前提是你的系统是linux/unix。
	比如，你是要对多台机器之间整个磁盘，做分布式的数据同步，可以采用DRDB 或者 gluster
	详见 http://www.google.cn/search?q=glusterfs&#38;ie=utf-8&#38;oe=utf-8&#38;aq=t&#38;rls=org.mozilla:zh-CN:official&#38;client=firefox-a
	和
	http://www.drbd.org&#160; 前提条件也需要你的系统是非windows的平台，我在邮件系统下有过这样的实践。
	比如，你是需要对每台服务器里面的缓存做实时备份和同步的话，可以采用Memcached的，详见 http://memcached.org ，平台可以是windows。

	看你需要对什么层面做实时备份，具体针对到什么内容，涉及到现在的架构体系，和可用性，和将来的可伸缩性。

	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/the-server-side-data-backup.html?source=rss</link>
			</item>
	<item>
		<title>为什么使用Java NIO</title>
		<description><![CDATA[Java中普通的I/O功能&#160; 一般体现在 1.文件读写、2.网络传输、3.字节流输入/输出&#160; 应用场景。而Java中的 NIO 提高了原有I/O的性能。
Java的NIO包含以下特性：
	&#160; 1.内存映射到文件
	&#160; 2.文件锁定
	&#160; 3.字符集编码和锁码
	&#160; 4.非阻塞的输入/输出
&#160;Java的NIO目前运用最广泛的在Apache的Tomcat6中，1.减少了服务器在瞬间达到峰值的现象，2.减少了服务器线程不必要的开销。
	ps: 1.Tomcat5.X的版本中还不支持NIO。2.Tomcat 6中默认的配置并不支持NIO，需要进行配置，详见我写的另外一篇文章&#8220;给正在使用Tomcat6的朋友说几句废话(优化)&#8221; ，原文地址： http://www.javabloger.com/article/performance_tomcat_about_nio.html
从下面2图中就可以看出Java中普通的I/O和Java中NIO的区别
Java传统I/O在socket编程中的应用场景,如图所示：

一个socket连接对应一个输入/输出通道，一个输入/输出通道在对应一个线程，这样有多个请求，就需要开辟多个线程，这样对CPU的负担大大的提高。关系是一对一的。
Java NIO 在socket编程中的应用场景,如图所示：

在上图中我们能看到中间有类叫做Selector 
	1.当socket服务端启动后对每个socketchannel进行建立关系。
	2.这时只需要把探知的socketchannel告诉Selector。
	3.当有事件发生时，会通知传回一组SelectionKey,读取这些Key,就会获得我们刚刚注册过的socketchannel。
	4.原先已经建立好的Channel中读取数据。
	5.最后可以接收到的这些数据进行处理。
所以我们能看出不必像原先那样开大量的线程，然后让线程傻傻的等待。而NIO不必，通道已经由一个线程建立好了，有事就说话，说了就去做，而且在一个线程中建立了多个通道，可以同时做很多事情，不会像原先那样开辟多个线程，耗费CPU资源，关系是1对多的。
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/why-use-java-nio.html?source=rss</link>
			</item>
	<item>
		<title>JavaBloger网站的方向</title>
		<description><![CDATA[对于JavaBloger网站的发展方向，分为网上和网下。
网上：
	1.原创技术文章：主要针对 技术经验分享、企业级系统架构设计、敏捷开发。
	2.开源项目：目前以 MySQLOA 为主，等书搞定后将继续发布V1.2的新版本。
	3.迷你书：精美的电子小册子，主要进行归档和离线阅读，提高用户体验。
=========================================================================================================
网下：
	1.推广与培训：正式与非正式的，自己圈子内圈子外的，计划性的进行专项专题技术讲解。
	2.项目咨询与顾问：目前主要为 金陵软件工作室 和 朋友圈子内 的项目提供技术服务，完全采用正规的开发方式提供服务，非作坊式。
	3.参加大型社区技术活动：以网友发起的技术类话题的版聚。
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/javabloger-redirect.html?source=rss</link>
			</item>
	<item>
		<title>理想的敏捷工作环境与氛围</title>
		<description><![CDATA[请问您在办公室里有戴上耳机专心工作的习惯吗？
您很喜欢音乐？还是怕在Open的办公环境里受人打扰？
如果您现在在办公室里面阅读我写的这些文字，我建议你现在立刻脱下耳机，谢谢合作。
因为往往你的灵感就来自于别人口中一句不经意话。
	&#160;

&#160;
以上是我的废话，与标题无关，下面才是正文：

	1.5-9个人用电脑围成的&#8220;小圈子&#8221;，周围有各种提示的标语，如：&#8220;请记得每天积极与同伴沟通。&#8221;，&#8221; 说话时请将嗓门的音量调小一点。&#8220;
2.大大的黑板放在公共区域，可以用多种水笔发挥你的才华。
3.绝对 绝对 安静，绝对 绝对 私人的地方，但是可以让别人能找的到你。
4.良好的灯光、最好有窗户，能闻道清新的空气、墙角边的植物、简约合适的装潢。
5.可持续性的奖励杰出贡献者制度，并且能和直接利益挂钩。
6.项目进度表，在每个项目参与者都能看见的地方，也许是大黑板上，或者大白板上，或者是在每个成员的邮件中。
7.对信息反馈系统的建设，对成员与成员之间的，对成员与Leader之间的，对客户与团队之间的 都要一一建立。
8.办公室免费提供的雨伞，和一些订快餐、出租车公司的电话号码。
9.吃的，喝的，简单的食物，如果因为种种条件不能提供食物，那冰箱一定是的必须的了。

	
	以上观点来次于敏捷的核心思想：&#8220;沟通、简单、反馈、勇气&#8221;。
ps：营造理想工作环境发挥员工创新潜能 &#8211;来次于Intel公司
	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/great-agile-workspace.html?source=rss</link>
			</item>
	<item>
		<title>怎么写设计文档&#8211;概要设计</title>
		<description><![CDATA[在需求分析进行完成之后 项目进入设计阶段。在设计阶段需要编写设计文档。
开发过程中的设计文档 分为：&#160; 概要设计 和 详细设计 2个部分。
概要设计 是将杂系统按功能进行 模块划分、建立层次结构及调用关系、包括数据特征描述 ,以及界面等。 
	概要设计 是由架构师和每个开发者共同完成的，主要阅读者是客户和测试人员，其次是开发者和架构师。 
	详细设计 是由每个开发者根据 概要设计 文档共同完成的，主要阅读者是开发者们，其次是架构师和测试人员，再次是客户。
	对于任何设计文档，需要项目小组内每个成员的参与编写，另外，需要交叉式的相互评审，还需要有评审结果，成员根据评审结果进行修改，将修改过的文档打给客户，等待客户的评审。
	
如果客户有意见或者建议，将继续修改，修改完成，继续小组评审，依次循环的工作，直到双方不再提出任何的疑问，才能进入下一个阶段，如果概要设计完成，将进入详细设计，如果详细设计完成，才能进入正式编码阶段。
	
	&#160;点击这里下载 H.E. 整理的 &#8220;概要设计.doc&#8221; 文档模板。
	

	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/how-to-write-design-documents-summary-design.html?source=rss</link>
			</item>
	<item>
		<title>谈谈大型J2EE系统架构</title>
		<description><![CDATA[为了应对大型J2EE系统中 可靠性、可伸缩性、可用性的要求，我们会采用集群技术、分布式技术、存储环境 来满足大型系统的运行要求。
	集群技术是由多台服务器采用松散组合方式的构成，比如：Google、LinkedIn、Digg。虽然这些系统中使用到集群的技术，有很多台计算机构建了系统的N层架构，但是对于用户来说透明的，用户并不知道有多少台服务器给他们提供服务，用户也不知道是哪台服务器为他们的请求作出服务。 
	尽管在用户高并发访问量的状态下系统出现故障的现象是很低的，因为系统中的每个环节都做了压力分载和失效转发。
	在大型J2EE项目中，比如：有100个用户同时发出访问请求，经过负载均衡策略后，10台机器上只应对10个用户的请求。再比如说有100个人去到火车站买票，只有一个售票窗口工作效率会很低，如果开10个售票窗口，再通过火车站售票大厅的广播告诉每个进来买票的人，有10个窗口可以提供服务，那么工作效率会明显上升，这就是集群技术特点之一&#8212;压力分载。
	在复杂的系统中环境中，上百台机器不可能每小时 每台机器都在正常运行，出现不可预先的故障是难免的，但是对于出现故障后，能否还能保证系统的正常运行，特别是运行关键性任务的机器，绝对不能出现系统瘫痪的状态，所以需要系统中可以做到失效转发。
	比如：用户发出了请求，服务器端已经应答，并且准备回送请求结果，此时硬件出现了故障，不影响用户的业务操作，只是多了一个小插曲，用户需要再请求一次，业务流程将继续进行下去。因为本来失效down机 机器上的用户请求信息在另外一台机器上也同样存在，这就是集群技术特点之一&#8212;失效转发。
	所谓存储环境，不仅仅是我们经常使用到的数据库系统，还有文件系统和缓存。系统中的数据有可能是文字信息，还有可能是图片和文件。 
	文字信息我们建议保存在数据中，对于图片和文件数据，我们不建议保存在数据库中，因为将二进制文件保存在数据库中对数据库系统的开销是非常大的。因为在数据库系统中读取文件，是将二进制数据读取在内存中再展示给用户。跟保存在数据库 blob字段&#160; 比较 还是直接通过文件系统存放在磁盘上比较好， 因为给系统带来的压力比较小。
	大型J2EE项目中，缓存的作用主要是降低系统每个环节上的运行压力，提供运行效率。对于大型系统中我们建议您使用类似 Memcached 的可集中、可集群 的缓存系统，因为在大型系统中缓存同步是非常头痛的事情。另外还需要注意缓存的使用，在整个系统中缓存无处不在，自己写的、网络设备上的，CPU上的，硬盘上、应用服务器上，等等，妥善的使用好缓存是一个比较深入的话题，所以尽量将缓存集中管理。
	参考文献：
	http://www.theserverside.com/tt/articles/article.tss?l=J2EEClustering 
	http://www.javaworld.com/jw-02-2001/jw-0223-extremescale.html
	http://java.sun.com/developer/technicalArticles/J2EE/applications
&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/j2ee-clustering-architecture.html?source=rss</link>
			</item>
	<item>
		<title>Null与Java垃圾回收</title>
		<description><![CDATA[你可以这样赋值
	String&#160; blogname=&#34;www.javabloger.com&#34;;


你也可以这样赋值
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; String&#160; blogname=null;&#160;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; blogname=&#34;www.javabloger.com&#34;;

在运行的结果上没有任何区别，但是你可以通过将对 象的变量初始化赋为null值，来提示垃圾收集线程收集该对象。在对该对象 blogname被其他对象监听时除外。
另外，建议将赋Null值的对象写在try的上面。
	
&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/java-null.html?source=rss</link>
			</item>
	<item>
		<title>Javabloger的 “迷你书”(PDF) 出炉啦！</title>
		<description><![CDATA[时间过的真快，Javabloger网站是2010年1月份启动的，目前已经是2月末了。一个月内，已有全国34个城市600多次的独立访问者。
	在2010年2月迎来了 JavaBloger 首次电子&#8220;迷你书&#8221; 的发布。
	&#160;&#160;&#160; 
	JavaBloger 发布电子&#8220;迷你书&#8221;的目的是为了能让用户得到更好的阅读体验，网站对专题的归档处理，并发布成小册子，用户可以在离线的状态阅读本站有价值的内容。
	本次&#8220;迷你书&#8221;的发布，以&#8220;性能优化&#8221;为专题，主要讲述在Java开发中的一些优化小技巧。
	&#160;
点击此处下载 。
如果您的电脑中暂时没有安装PDF软件，请点击这里直接在线阅读。
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/pdf-mini-book.html?source=rss</link>
			</item>
	<item>
		<title>Java图像压缩优化</title>
		<description><![CDATA[大名鼎鼎的 Flick 网站 采用 ImageMagick&#160; 做图像的压缩处理。虽然Flick网站采用的是PHP语言，千万别认为ImageMagick只能支持PHP, ImageMagick 对于Java语言也有支持。
	因为前段时间有过项目需要，所以需要对Java图形压缩处理有过一段日子的研究，客户需要在系统中要求将3M大小的图像进行压缩处理，并且不能有任何图像质量上的损耗。
我们刚刚开始采用的是Java传统的图像压缩处理方法。很遗憾，如果将压缩的比例调大了，图像显示的质量明显有所下降，如果保证了图像压缩处理的质量，那么基本上文件大小和没有压缩过的没有任何区别。
	同学们 这是杯具啊，在这个项目中如果我们对 图像压缩处理的不好 将会影响客户对项目的整体印象分，不论你的页面，还是SQL语句 的响应多么的快，客户一点都不关注。连我们一共 有2家公司同时在竞标，当时我们需要做到让客户101%的满意度，才能得标，可想而知，压力非常的大啊。
	每天都被这个问题困扰，成为每日会议中必谈的话题，经过我们的奇思妙想，决定采用 ImageMagick 对图像进行压缩。一位同事机器上 测试代码 被运行成功后，我们看见了测试的结果，顿时感觉脖子上的绳索消失了，大家非常非常的开心，那一刻，每个同事脸上喜悦的表情，我记忆犹新。
	文本不在此处详细的介绍如何使用ImageMagick对图像进行压缩，因为你可以去google具体的代码内容或者可以参考以下内容：
	参考地址：
	ImageMagick中文网站
	&#160;
	Java环境下Imagemagick中文图片处理问题非完美解决方案
	使用Jmagick压缩高质量图片
&#8211;end&#8211;
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/java-image-compression-optimization.html?source=rss</link>
			</item>
	<item>
		<title>优化Ibatis中的配置参数</title>
		<description><![CDATA[根据Ibatis手册上配置参数说明：




参数名称


参数说明




cacheModelsEnabled


是否启动ibatis中的缓存功能。




enhancementEnabled


是否需要POJO启动Java字节码增强功能，可以提升getter/setter的调用效能避免Java反射所带来的性能开销。




lazyLoadingEnabled


是否同时Lazy Loading带来极大的性能提升。




useStatementNamespaces


是否使用 domain xml 文件中 namespace 别名配置。




maxRequests


最大并发请求数(Statemetn数)。




maxTransactions


最大并发事务数




maxSessions


最大Session数，当前最大允许的并发 SqlMapCliect数




maxSessions


须界于 maxTransactions和maxRequests之间进行配置




根据自己的多次实践证明，发现这些配置参数的选择与数值将对系统的影响是很大的。
经过多次摸索，按照以下配置参数进行配置可以将ibatis的性能进行提升。仅供参数，还需要根据您自己的实 际情况来界定。
具体配置参数如下：
&#60;sqlMapConfig&#62;

&#60;settings cacheModelsEnabled=&#34;true&#34; 
&#160;&#160;&#160;&#160;&#160;&#160; &#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; lazyLoadingEnabled=&#34;true&#34;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#160;&#160;&#160;&#160;&#160; enhancementEnabled=&#34;true&#34;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#160;&#160;&#160;&#160;&#160; errorTracingEnabled=&#34;true&#34; 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#160;&#160;&#160;&#160;&#160; maxSessions=&#34;1024&#34; 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#160;&#160;&#160;&#160;&#160; maxTransactions=&#34;512&#34;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#160; &#160;&#160;&#160;&#160;maxRequests=&#34;2048&#34;
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; &#160;&#160;&#160;&#160;&#160; useStatementNamespaces=&#34;true&#34;&#160;/&#62;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/optimization-ibatis-parameters.html?source=rss</link>
			</item>
	<item>
		<title>GlassFish性能优化</title>
		<description><![CDATA[我的废话：
	任何优化都是建立在应用场景的需求上，有许多因素要考虑，如应用程序的类型，系统，Java版本，系统的硬件架构，系统环境的部署架构，用户并发数量，预期的响应时间和网络带宽，还需要根据你系统最大吞吐量、平均每秒完成的交易数量，等内在、外在的因素。所以没有绝对的最佳优化方案，都是根据实际的系统运行情况、测试报告 得出分析数据，才能知道具体需要优化的方向和需要优化的侧重点。
	本文提到的GlassFish性能优化最终目的是让一个运行在GlassFish中的应用系统能支持的最大用户数同时在一个理想的响应时间内完成各项任务。


	Sun公司推出的GlassFish v2应用服务器是一个高性能的应用服务器。本文将指导一些刚刚接触GlassFish的朋友如何调整、优化GlassFish应用服务器。
下面将按照几个部分介绍，实现您的应用程序在GlassFish服务器上运行的更高的性能。

	1.Java的版本
	让你的GlassFish服务器，运行在最佳的JDK环境中，不是需要最新的JDK版本，而且最佳的。经过H.E.的简单测试，建议采用SUN JEE6.0 版本。
	2.JVM运行模式
	注意你的JVM运行模式，一般都是在Server的状态下，但是你也需要注意一下，因为，在开发环境下(一般使用的是client JVM) 调试将要在Server JVM上运行的java程序时，最少指定jvm为server&#160; jvm，这样可以更早地发现问题，具体说明见SUN的描述 
	http://java.sun.com/docs/hotspot/HotSpotFAQ.html
	或者可以看看一个国外论坛的帖子
	http://www.coderanch.com/t/385923/Java-General/java/JVM-Server-Mode-vs-Client
	3.Java Heap Size
	关于这个话题这个就不多说了，如果服务器内存为2G，可以调整堆内存为-Xms1024m, -Xmx1024m。还可以去参考我写的另外一篇文章&#8220;谈谈Java虚拟机优化与垃圾回收&#8221;， 但是值得一提的是，windows xp的内存最大使用范围是3个G，如果你在windows上做优化测试，需要注意一下这点。

	4.HTTP线程数
	为了提高并发连接数，需要增大线程数，默认的最大线程数一般比较小，但此值不是设的越大越好，应该恰到好处的去设置它，太小了，执行队列中将会积累很多待处理的任务，太大了，则会消耗大量的系统资源从而影响整体的性能。在产品模式下默认为25个执行线程。可以根据需要设置你最佳的数目。这个可以在GlassFish控制台里面进行设置。可以以25*CPU个数为基准进行调整。2颗CPU就是100个。
	5.HTTP文件缓存
	如果您的应用程序包含静态文件，建议启用HTTP文件缓存来优化性能。 小文件的内容读取到JVM堆在媒体上的文件是内存映射到GlassFish上的。还要求必须是一个静态资源，自定义Servlet或者动态页面不会被缓存。另外，以避免从每个请求都被文件系统缓存。可分为基于用户定义的大小限制为小，中和大。可以在 &#8220;配置&#62; YOURSERVER-config&#62; HTTP 服务&#8221;配置里修改。
	6.web.xml
	检查你的web.xml文件，例如 development=true/false, genStrAsCharArray=true/false。虽然不是关键点，但这个开发和运行模式的区别。 
	7.JDBC 连接池
	一般按照我们的经验，建议设置的参数值与HTTP请求处理线程的数量相同。下面，我们以MySQL为例，设置 statement 的缓存如下：
	&#60;property name=&#34;cachePrepStmts&#34; value=&#34;true&#34;/&#62;
	&#60;property name=&#34;prepStmtCacheSize&#34; value=&#34;512&#34;/&#62;
	&#60;property name=&#34;useServerPreparedStmts&#34; value=&#34;false&#34; /&#62;
	
	8.日志
	关闭你认为可以忽略的输出日志，日志的输出是对系统I/O的一种消耗，所以因为合理的去使用GlassFish中输出的日志。可以在&#8220;配置&#62; YourSERVER-config&#62; 诊断服务&#8221;中关闭你认为可以忽略的选项。
9.Keep Alive
	提高Keep Alive的连接数量，对AJAX站点来说这点很重要，很多页面刷新需要经常请求服务器处理，提高Keep Alive连接数目可以复用打开的连接，减少请求的时间。
10.DNS查找
	如果你是在没有域名的环境中运行你的应用服务，你需要关闭DNS查找设置，&#8220;配置&#62; YOURSERVER-config&#62; HTTP 服务&#8211;DNS 查找&#8221;中进行修改。
11.部署
	如果你发布的是一个Web的应用程序，并且其中包含JSP页面，你可以选择&#8220;应用程序&#62; Web 应用程序-预编译 JSP:已启用&#8221;打钩，这样就不会第一次访问JSP页面的时候感觉速度慢了,因为GlassFish服务器已经帮你预编译过了。
相关文章
	GlassFish 优化技巧 -GlassFish HTTP/1.1 GZIP  
	Glassfish(EJB) 与Quartz Job Scheduler整合  [...]]]></description>
		<link>http://www.javabloger.com/article/optimize-glassfish-performance.html?source=rss</link>
			</item>
	<item>
		<title>一封邮件</title>
		<description><![CDATA[今天在公司的邮箱里收到一份邮件 标题是：&#8220;天才的创新&#8221;，内容是：&#8220;看看什么是天才的创新和实践 http://www.ted.com/talks/lang/chi_hans/pranav_mistry_the_thrilling_potential_of_sixthsense_technology.html&#8221; 当我看见连接中包含&#8220;sixthsense_technology&#8221;一词的时候我就已经知道是什么内容了。但是还是点击进去又观赏了一遍。

	看完以后，心里不仅仅在向这位pranav mistry 同学致敬。还想到了电影《霸王别姬》中的台词与场景，儿时的程蝶衣和段小楼从戏班子中偷跑出来在庙会上看大戏，在台上名角演绎非凡，台下观众偏偏喝彩，程蝶衣却在落泪不止，口中念道：&#8220;小癞子，他们怎么成的角啊&#8230;&#8230;.得挨多少打啊？！？得挨多少打啊？？我什么时候才能成角啊？&#8230;&#8230;.. 呜&#8230;呜&#8230;. &#8221; 哇哇大哭。

	观此视频，心情与其一样，台下看台上戏，心中另有感慨。
	&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/email-about-pranav_mistry_the_thrilling_potential_of_sixthsense_technology.html?source=rss</link>
			</item>
	<item>
		<title>休息一下，插播2条关于腾讯的事儿 :)</title>
		<description><![CDATA[Case1:
	看看你的办公环境在看看 腾讯用户体验室的办公环境吧。如图：
&#62;&#62;&#62;&#62;&#62;点击这里查看更多照片 &#60;&#60;&#60;&#60;&#60;
	Case2:
	现在网上流传着 &#8220;一直在模仿，從未被起訴&#8221;的话，说的是谁？
	如图：


	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/about-qq-case.html?source=rss</link>
			</item>
	<item>
		<title>Java与Ajax</title>
		<description><![CDATA[今天在世界上很多人都在使用Flickr相册保存/共享自己的照片、使用Gmail收发电子邮件、使用Google Maps查看地图信息、Google 搜索的输入提示框。这些伟大的项目服务于世界上的很多人，但是在这些伟大的项目背后使用着一个非常关键的技术，那就是 Ajax。
	Ajax是运行在Web上的，用一些稍专业一点的词语修饰他可以称作富Internet客户端。Ajax使用JavaScript技术、HTML网页可以异步调用生成它的服务器上的服务并可以获取返回的XML文档形式的结果。JavaScript再使用这个XML文档更新或改动本网页的文档对象模型(DOM)、名词AJAX就是近年来出现的用与描述这种交互模式的新名词。 
	浏览器的功能很单一与传统的客户端程序相比相对落后，Ajax出现后，加强了Web应用上很多功能，弥补了这一缺憾。你可以使用Ajax技术高效的创建动态网页、并可以跑在大多数主流浏览器上。可以使你的Web应用程序更丰富更具交互性就象桌面应用一样的技术，但是我们也不得不去承认使用Ajax技术对客户端机器的资源消耗的确是大于简单的Html或者简单的动态页面。 
	
AJAX交互剖析：
	来看一个AJAX使能的J2EE应用：名为ValidateServlet的Servlet验证表单数据、但是要求不能对整个页面刷新。步骤如下： 
	&#160;&#160;&#160; 1、客户端事件发生。 
	&#160;&#160;&#160; 2、一个XMLHttpRequest对象被创建并配置。 
	&#160;&#160;&#160; 3、XMLHttpRequest对象发出请求。 
	&#160;&#160;&#160; 4、请求被ValidateServlet处理。 
	&#160;&#160;&#160; 5、ValidateServlet返回一个包含结果的XML文档。 
	&#160;&#160;&#160; 6、XMLHttpRequest对象调用callback()函数并处理结果。 
	&#160;&#160;&#160; 7、HTML文档对象被更新。
	
如图所示：

	查看大图请点击这里

	
待续未完，下面介绍几个Java的Ajax框架，主要是介绍Java和Ajax是怎么在一起工作的。
]]></description>
		<link>http://www.javabloger.com/article/ajax-java.html?source=rss</link>
			</item>
	<item>
		<title>Java Copy文件的性能</title>
		<description><![CDATA[采用java nio里面的FileChannel，非堵塞I/O的文件管道模式，是java 对稍大文件copy 运行效率最高的方式.
	
	如果只是Copy一个小文件或者运行的频率比较低，非NIO方式和NIO方式差不了多少。
&#160; 代码如下：
&#160; public static void copyFile(String fileFromPath, String fileToPath)&#160; {
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; try {
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160;&#160;&#160;&#160;&#160; // 读取文件创建一个管道
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; java.nio.channels.FileChannel srcChannel = new java.io.FileInputStream(fileFromPath).getChannel();
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160;&#160;&#160;&#160;&#160; 
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160;&#160;&#160;&#160;&#160; // 在管道上创建一个输出的目标地址
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; java.nio.channels.FileChannel dstChannel = new java.io.FileOutputStream(fileToPath).getChannel();
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160;&#160;&#160;&#160;&#160; 
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160;&#160;&#160;&#160;&#160; // 进行文件复制
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160;&#160;&#160;&#160;&#160; dstChannel.transferFrom(srcChannel, 0, [...]]]></description>
		<link>http://www.javabloger.com/article/java-copy-file-performance.html?source=rss</link>
			</item>
	<item>
		<title>J2ee企业顾问的职责</title>
		<description><![CDATA[J2ee企业顾问(J2ee Enterprise Consulting)的职责(开场白)：
	&#160;&#160;&#160; 领导&#8212;&#8212;业务和技术之间的桥梁
	&#160;&#160;&#160; 预见&#8212;&#8212;判断关键趋势的洞察能力
	&#160;&#160;&#160; 制定战略&#8212;&#8212;塑造需求并进行同步
	&#160;&#160;&#160; 组织&#8212;&#8212;协调小型信息系统开发
	&#160;&#160;&#160; 交付&#8212;&#8212;提供成本有效和及时的服务
	顾问，一词在古汉语中是指供皇权地位的君主咨询的侍从之臣，这些丞相具有某方面的专门知识、长期储备的咨询人员，称之为顾问。顾问是一个专家，是一个可以帮助人们解决专业问题的人，解决某个专业领域疑难杂症的人物。
	作为J2EE企业顾问不可能是单项技术专家，他还需要掌握更多更广阔的知识领域，因为J2EE应用只是企业信息生产环境中的一部分，而不是企业信息生产环境的全部。
	一般来讲，作为J2EE技术带头人，你要对J2EE技术是比较精通得，需要有让人信服你得本领。无论是在2-3个月完成的小项目，还是百人团队奋战2-3年的大型项目，能给出正确的实施方向和可靠的技术架构。
	作为J2EE企业顾问不单纯只是关注于Java方面的技术，还需要对数据库，linux/Unix/Windows操作系统，网络设备，服务器硬件和团队管理和客户沟通有非常丰富的经验，需要对你服务的企业内部信息有个详细的了解，你对需要结合市场环境、方向 和 企业核心价值、竞争优势，在技术实施、执行上 给出完整、正确的议案，还需要具有良好的心态和出色的人格魅力。
	作为J2EE企业顾问要有过硬得技术，那么你就必须具备最基本的素质就是刻苦的钻研精神。特别是软件行业，J2EE企业顾问必须是一个在技术上的高手，因为软件公司、互联网公司技术本身就是公司的核心业务、核心价值，要成为技术高手，就像练功一样，天天练，天天学，你必须意识到在你生命中做J2EE企业顾问的每一天你的呼吸和你每天取得的进步是同步的。
	作为J2EE企业顾问必须要深刻的体会到 &#8220;人前显贵，人后受罪&#8221;的说法，技术的积累与学习需要你有足够的耐心和毅力，在技术领域是来不得半点的虚假和浮躁，你可以去忽悠任何人，但是你绝对不可能忽悠的过计算机和程序。
	作为J2EE企业顾问不管任何面对的是成功还是失败需要你有 &#8220;胜不骄，败不馁&#8221;的心态，我们反对&#8220;生活安逸&#8221;的态度，需要有常常不断的有否定自己的习惯，因为我们需要在下一个阶段更加成功。
	作为J2EE企业顾问在生产过程中一个问题花去你1分钟的时间就可以解决，但是为了解决这个问题很可能需要你有10年的技术积累经验。
	&#160;
	作为J2EE企业顾问必须意识到人的成败因素是最大的，所以尽量在人事方面简单化，将主要精力放在技术指导和团队成员的沟通和交流上，同时需要你注意讲话的语速和语气，在任何交流的过程中你可以不同意他的观点，但是需要你绝对的尊重对方说话的权利。
	作为J2EE企业顾问你必须意识到自己不是全能的人才，一场成功演奏会少不了指挥家和管弦乐队，没有人相信一个人可以充当指挥家和管弦乐队的角色。遇到不懂、不通的问题需要虚心请教。
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/j2ee-adviser.html?source=rss</link>
			</item>
	<item>
		<title>Struts 与 WebWork的传说</title>
		<description><![CDATA[Apache 组织推出的Struts1是一个开源Web框架,借于J2EE MVC的经典设计模式，Struts1使用于Java Web应用程序开发,在业内独鳌了多年，扬名千里，受到无数国内、国外开发者的追捧，运用在无数个大大小小的项目中。 
	Webwork的OpenSymphony组织推出的一个Web开源框架，但是 Webwork1.x版本结束后不就，在Webwork2.0项目开始启动的时候就被 Apache的Struts小组盯上了。在2007年 Struts2和WebWork2个开源项目合并,Webwork团队和Struts团队对Struts2框架共同开发。最后在 2007年6月11日 18:19&#160; Apache的官方网站上发布了第一个Struts2的版本。而Webwork的官方网站上最后一次版本发布时间是July 21, 2007，此后在Webwork的站点上再也没有看见任何更新。
Webwork 的友好程度也相当的不错，可以和Spring 和 OSCache 等框架无缝的紧 密结合，这样有2大好处，1.可以和其他流行的框架结合，不会导致使用webwork与其他框架产生冲突。2.规范性更加强烈，并且提高开发效率，采用 Webwork框架已经可以节约开发成本了，如果能再结合其他框架进行适当的整合使用，那么开发成本将会更低。
	换句话说：WebWork 的实力不比Struts差，但是名气远远不及Struts，而且WebWork最强的对手也是Struts，WebWork 经过两年的努力，最后妥协向Struts靠拢。因为在MVC开发框架上的市场中 Struts占有很大，但匮乏新鲜的元素，恰巧Webwork推出了模型驱动和web框架中的拦截器的概念，所以Struts非常迫切的希望Webwork能归属自己。

	目前在Apache Struts官方网站上的这个图标，足以说明一切， Webwork+Struts= Struts2&#160; ，Webwork项目因此而结束。
	
	WebWork1/2和Struts1/2我都用过，从配置的角度上讲，Struts2比WebWork2的废话多了一些，没有WebWork表现的那么精炼，但这不是重点，因为，Struts2 框架依然保持他的经典风范非常容易扩展,因为Struts2框架中每个类是基于接口、依然保持对任何规模的企业Web应用开发的优雅性。
	在J2EE企业应用的系统架构中Struts2 是一个非常优雅和灵活的前端控制器。另外，Struts 2还以许多技术标准为基础：如Java过滤器，JavaBean，ResourceBundles，XML等，符合传统规范，更容易被融入J2EE企业应用中。
	&#160;
经过变迁， Struts1与 Struts2(Webwork)有很大变化，给我印象最深刻的就是：不用自己在写FormBean 一遍又一遍继承 ActionForm 直接使用Pojo，方便了很多。下图说明了 Struts1与 Struts2主要的变化，如图所示：
	使用 Struts2 的基本要求 ：
	Servlet API 2.4，JSP API 2.0 和 Java 5。
	Struts2请求的生命周期:
	1.用户发送的请求：用户使用Web浏览器对服务器的某些资源发出Http请求 。请求资源的
	&#160;2.FilterDispatcher确定适当的行动：FilterDispatcher观察用户Http请求，然后确定配置中对应的Action层，最终过滤器分发器(FilterDispatcher)决定了Action的调用。 
	&#160;3.拦截器应用于：如工作流程，共同验证功能，文件上传等 ， 自动适用于要求。
	&#160;4.执行Action：然后 ， 操作方法执行等相关执行储存或从数据库中检索数据操作数据库。
	&#160;5.执行完毕，对应Action和配置中的Result结果 。
	&#160;
	&#160;6.返回的请求：通过相反的顺序 拦截器拦截过后，请求返回。 
	&#160;
	&#160;7. [...]]]></description>
		<link>http://www.javabloger.com/article/struts-webwork.html?source=rss</link>
			</item>
	<item>
		<title>J2ee企业顾问和javabloger.com</title>
		<description><![CDATA[今天无意之中在Google上输入关键字&#34;J2ee企业顾问&#34; 在搜索结果中居然发现javabloger现在排名第一，难道现在google 网页抓取后的pr排名主要根据网页Title内容判定的因素最大？
如图所示：
	
	查看大图请点击这里
	
javabloger这个域名是今年1月份才注册的，居然上升的这么快出乎意料之外。
如图所示：
	
javabloger目前不连本篇文章一共37篇，现在被百度和google收录的状态也比较良好。
如图所示：
	
	查看大图请点击这里
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/j2ee-corporate-advisory-on-google.html?source=rss</link>
			</item>
	<item>
		<title>哪些大型网站采用J2EE架构</title>
		<description><![CDATA[国外基于J2EE的平台有：
	&#160;&#160;&#160; eBay、GMail、Amazon、hi5.com 和 Google AdWords 
	国内基于J2EE的平台有：
	&#160;&#160;&#160; 猫扑、网易邮箱、中国移动门户网站、淘宝、支付宝 和 易趣 、ChinaRen 、搜狐/新浪/网易的部分频道&#160; 都是采用J2EE技术构建。
	但是从下面2个角度上来看Java J2EE类型的网站不得不承认，需要付出的成本将高于PHP、Perl类型的网站.
	从技术的角度看：
	&#160;&#160;&#160; * 用Php / Perl 开发快且简单，而J2EE相对复杂
	&#160;&#160;&#160; * 作为Web网站开发LAMP稳定且流行，而J2EE条条框框规范太多。
	&#160;&#160;&#160; * Php / Perl 对Web系统来说几乎没有要求，J2EE需要应用服务器。
	&#160;&#160;&#160; * 从短期看，轻量级Web语言（Php/Perl）应对变化更加灵活（当然从长期看任何改变的花销都非常高）。
	&#160;&#160;&#160; * 运行J2EE的机器配置性能相对要比Php / Perl高。
	从财务的角度看：
	&#160;&#160;&#160; * Perl / Php开发成本比J2EE 便宜
	&#160;&#160;&#160; * Perl / Php学习曲线比J2EE上市时间更短
	&#160;&#160;&#160; * Perl / Php托管服务器要比J2EE 便宜
无论从技术使用者还是财务的角度来看J2EE，相比其他架构而言J2EE的门槛相对要高，需要开发者掌握的技能和开发环境的条件要高于现在流行 的脚本语言架构。
	但是从另外2个角度上来看 J2EE ：
	&#160;&#160;&#160; 1.纯粹的商业、企业应用 ，例如：银行支付交易、电信计费。J2EE有着不可动摇的地位。
	&#160;&#160;&#160; 2.金融公司有大量预算并倾向于扩展硬件，而Web公司倾向于扩展软件。 
	&#160;&#160;&#160; 
	我们希望能看到更多的最佳实践方法，如果能将PHP和Java进行完美的结合相互发挥自己的优势所在将是一件令人愉快的事情。请参见以前提到过的文章 &#8220;Java+PHP=混血新宠儿&#8221; 地址：&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/what-large-web-site-using-j2ee-architecture.html?source=rss</link>
			</item>
	<item>
		<title>J2ee核心模式&#8211;微架构</title>
		<description><![CDATA[介绍
	Sun公司在Java语言出来不久后，Sun公司的成员们就开始面向全世界的用户收集各种案例，进行归纳，通过不断的收集和总结在几年以后将收集、归纳的结果通过技术性大会反馈给用户，首次是在2001年，才对外公布了收集的结果，也就是现在的J2EE核心设计，吸取业界的宝贵经验，让开发者们进行借鉴，目的是为了提高你采用J2EE技术对的软件设计、系统架构的实践能力。
	作为一个有求知欲望的软件开发者来说光是单一的掌握Java/J2EE API是远远不够，所以在J2EE核心设计模式中，主要讲述使用：Servlet、JSP、EJB、JMS 、JDBC、JNDI这几种技术规范对系统进行构建的经验。并且强调每种模式在系统中并不是独立存在的，而是相互关联的。让开发者们合理的使用技术规范，并且可以借鉴大量的前人经验。
	J2EE Core Patterns主要讲述使用J2EE技术应该对系统如何进行设计，让使用者懂得如何使用J2EE技术得到最佳的实践手段，如何避讳系统设计时的不当，并且让开发者知道如何改善已存在的系统中的设计不佳实践。
	J2EE Core Patterns 是Sun 公司对企业应用提出解决方案，不是某种技术，是一种方法，所谓的方法是借鉴前人的成功案例得出的结论。J2EE核心模式与Gof23设计模式本质相同都是在业务场景中去简化设计，将复用最大化，将重构的成本最小化。
	在软件的设计中J2EE Core Patterns只是其中的一种，看待任何一种单一的从代码的角度上去看待模式是错误的，应该从业务的需求上去看待模式。J2EE核心设计模式的侧重点是从系统架构的角度上看待设计模式。而Gof23侧重点的是从代码的角度去看待设计模式。2者虽然角度不同，但却是本质相同。
	J2EE核心设计模式以及其他软件设计模式的特性分为几下几种：

来源于前人经验的分享。
通过结构化的记录进行积累。
某种模式出现的意义是为了避免重新设计，少走弯路。
对于相同部分的设计进行不同程度的抽象。
可以经过不断的完善进行重新的组合。
多个模式可以在同一系统中进行使用。
让系统设计更简单，降低复杂度。
让系统可以达到最大化的复用。


	&#160;&#160; 目的
	借鉴J2EE核心设计模式可以对普片的问题提供通用的解决办法，在某一个领域模式经过实践证明是解决让你少走弯路的一种手段。如果你已经将J2EE核心设计模式作为你项目设计的范本，因为使用了规范化的设计，在系统中使用J2EE核心设计模式的好处大致可以归纳为以下几点：

权衡项目中已经证实的解决方案。
成员之间的更加容易沟通达成共识。
对系统的设计起到一定程度的规范性。

&#160;&#160; 场景
	任何设计模式，包括Sun提出的J2EE核心设计模式，还是4人帮提出的gof23的设计模式只能作为开发中的一种手段和工具，还需要开发者自己对系统、对需求、对业务场景有详细的了解，所以在使用J2EE核心设计模式之前有些前提条件，例如：

确定当前的应用场景。
确定运行当前的业务场景的前提条件。
界定系统中每个用户角色的权限范围。
与上层模块，上层系统的关联性关系。

另外，不管在任何情况下使用J2EE核心设计模式有一个规则，这个规则由三部分组成，分为： 特定环境、特定系统作用，以及特定软件配置之间的关系。

	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/core-j2ee-patterns-micr_architecture.html?source=rss</link>
			</item>
	<item>
		<title>J2EE规范的价值观</title>
		<description><![CDATA[再先进的Java框架也不可能脱离J2EE的规范。我们推崇对技术理论性研究，而不是停留在一行行的代码上层次上，需要知道专项技术其所依然，才能知道其必然性。在企业应用中的任何技术只是实现商业价值链的一种手段，技术并不是最终价值的体现目标。软件只是帮助企业/机构提高生产力的一种手段，软件最终将数据转换成有价值的信息为企业、机构生产环境去驱动他们在社会中的竞争力、响应能力、核心价值。下图中表现了 软件、企业/机构、社会之间的关系，同时也说明了软件产品的真正作用和软件产品存在的真正意义。

	
查看大图请点击这里
	

	任何先进的技术都不是企业应用中的救命稻草，采用再先进的技术不能合理的运用，对于任何一个项目来说也是徒劳的，也不能体现先进技术的魅力。开着一辆最高时速300马力的保时捷跑车，而没有良好的驾驶技巧，不可能将跑车的动力完全发挥。采用任何一种技术手段不能做到80%以上的深入了解，最终适得其反，成为项目实施过程中的累赘，任何先进的技术都是人在操作和使用的，所以系统在采用J2EE领域中的每一项技术的时候，团队中都需要有一个&#8220;专家&#8221;级别的角色，来确保项目使用的每项技术得当。
	J2EE架构(技术)并不是针对每一个企业应用开发都是最佳的选择，任何一种技术、计算机语言都不可能100%解决业务中的所有问题，只有采用合适的技术使用的恰到好处才是关键，如果拿将军的大刀去切一颗青菜，大材小用，未必妥当。所以你应该仔细考虑后决定是否使用J2EE或者选择其他的技术途径，可以从如下几个角度去鉴别是否需要采用J2EE架构进行开发：
	1.&#160;&#160;&#160; 系统中有多个分布式的数据库系统，并且需要采用到分布式事务(JTA/XA)。
	2.&#160;&#160;&#160; 系统中采用多层分布式应用模型， 应用程序需要逻辑划分为组件分布在多台计算机上进行计算。
	3.&#160;&#160;&#160; 系统中有 本地、远程客户端程序、本地、远程服务器端程序、Web程序 并且在不同物理位置，之间需要进行高效的通信。
	4.&#160;&#160;&#160; 系统中的组件需要支持 压力分载和单点失效，能承载大型的并行、并发计算。
	5.&#160;&#160;&#160; 系统中需要与第三方的平台不间断、高频率进行交互计算。
	6.&#160;&#160;&#160; 系统中需要采用Web 浏览器作为客户端对大型数据进行展示。
	7.&#160;&#160;&#160; 系统需要利用标准化可靠的软件架构减少未来的成本，确保应用程序生命周期。
	8.&#160;&#160;&#160; 开发完成可以最小化部署，可以部署到不同厂家的应用服务器上，不会受一个厂家的牵制。

	以上一共8点，只要满足以上任何4点，才需要去考虑系统中是否去使用J2EE架构。
	&#160;
&#8211;end&#8212;
]]></description>
		<link>http://www.javabloger.com/article/j2ee-specification-value.html?source=rss</link>
			</item>
	<item>
		<title>The Art of Scalability.pdf&#8211;书籍下载</title>
		<description><![CDATA[《The Art of Scalability》&#160; 2010年出版，是一本讲述关于系统架构的书籍，此书分为4个部分 ：
&#160;&#160;&#160;&#160;&#160;&#160;&#160; 第一部分 介绍 人员和管理之间的话题。
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 第二部分 介绍可扩展性，各方面的连续性，危机和突发事件管理规划。
	&#160;&#160;&#160;&#160;&#160; &#160; 第三部分 架构设计可扩展的解决方案。
	&#160;&#160;&#160;&#160;&#160; &#160; 第四部分 解决存在风险手段。
&#160;&#160;&#160;&#160;&#160;&#160; 
&#34;The Art of Scalability.pdf&#34; 下载地址(Download)：点击这里(Here)
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/the-art-of-scalability.html?source=rss</link>
			</item>
	<item>
		<title>网站国际化&#8211;Google Translate</title>
		<description><![CDATA[以前只是知道本站左侧栏的google翻译有国际化的功能，比如使用某国操作系统或者某国语言的浏览器，将会显示将对应语言的&#8220;请选择语言&#8221;的文字，但是你使用Google Translate加入自己的站点后，如果是你设置中非作者国家语言的访问者会在最上方显示是否需要翻译成某国的语言，我觉得这样做的真的挺好的，虽然站点里面被翻译的比较烂， 但是至少这样看起来真的比较友好。

查看大图请点击这里
	
话外音：google国际化不完全是根据ip地址来判定，当前用户的语言环境。
&#8211;end&#8211;
The Art of Scalability
	
]]></description>
		<link>http://www.javabloger.com/article/google-translate.html?source=rss</link>
			</item>
	<item>
		<title>接口与抽象</title>
		<description><![CDATA[温故而知新
	接口(interface) 中只允许 ：public 成员访问权限, 而 private、protect 不可声明。
	抽象类(abstract) 中抽象方法只允许：public 、protect 成员访问权限, 而private 不可声明。
	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/java-abstract-interface.html?source=rss</link>
			</item>
	<item>
		<title>微软开发框架-MSF</title>
		<description><![CDATA[我在好几年前通过某次技术大会得知，微软的研发团队整体开发模式是基于微软自创的一条套路，简称 MSF (Microsoft Solutions Framework )，顾名思义：Microsoft 解决方案框架 。
	执行MSF的前提，即任何技术项目都必须达到特定的关键质量目标才能被认为是成功的项目。但，每一个目标的达成，都需要相关的、不同领域的知识和技能的综合运用。MSF把不同领域的知识和技能分别分配到不同的角色中去，每个角色都具有满足项目成功的标准。如果任何一个角色无法实现其目标，这都会危及到整个项目。因此，MSF小组模型中的每一个角色都认为是同等重要的，重要的决定都要共同作出。
	MSF 团队模型并不能保证项目一定成功。除了团队结构之外，有着更多因素决定着一个项目的成功与失败。不过小组结构仍然是很重要的。
	MSF 组队模型是防止&#8220;不良的团队结构会削弱成员的努力、增加开发时间、降低质量、使士气低迷、增大周转期间&#8221;这样的问题的。恰当的团队结构是成功的基石，贯彻MSF模型并且运用MSF的原则能够帮助团队，使之更加有效，因而取得成功。
	我们再来看看在MSF是怎样界定开发与业务之间的关系，如图所示：
	
	查看大图请点击这里
	有一个重要的地方需要强调：当负责外部协调的各种角色能够提供信息的输入并提供项目的建议的时候，不要让单个的成员或单个角色拥有修改项目功能、计划以及资源的优先级和权限。因为这些改变都是项目客户的特权，并由项目团队来负责执行。
	看看微软在开发Windows 2000时的各个角色的人员数安排，开发的人数只占据总人数的20%都不到,如图所示：
	
	查看大图请点击这里
	根据MSF中的定义 &#8220;开发人员&#8221;和&#8220;测试人员&#8221;的人数比例为1：2。下面是微软提供的另一个例子，如图所示：
	
	查看大图请点击这里
	参考资料，可以阅读我以前提到一篇&#8220;谈谈我知道的微软、SUN公司 测试工作&#8221;：http://www.javabloger.com/article/microsoft_and_sun_testing_process.html
&#8211;待续&#8211;
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/microsoft-solutions-framework.html?source=rss</link>
			</item>
	<item>
		<title>敏捷的态度</title>
		<description><![CDATA[一个杰出的开发者必须打消任何个人英雄主义的想法，因为这让你不能在项目中与他人保持同样的等级，会让你孤立，让你难以去接受别人给你的意见与忠告，同时违背了敏捷态度的初衷。
	一共成功的管理者必须打消任何成员都是一个&#8220;组件&#8221;可以任意调配的想法，因为让你失去对成员之间信任，失去他们对你的归属感。
	&#160;

	

	上图中，虽然右项也很有价值，但是我们认为左项更有价值。

	# 个体和交互 胜过 过程和工具
	我的废话：成功的项目中，缺少不了一批出色的成员，出色的成员少不了正确的工作态度和过硬的技能。
	一个优秀的成员(开发成员)往往未必是一个技术水平高超的人，但一定是与成员合作/沟通、与客户合作/沟通有出色表现的人。
	接纳项目以后，千万别忙着搭建环境、设计系统架构，应该先组建团队，然后在去搭建环境，项目的系统架构与采用的关键技术需要经过所有成员的讨论和评审，最后才能通过定案。
	在以往的面试过程中，我问一位面试者为什么项目中需要采用Hibernate框架，回答道：项目经理让我们用的。我将立刻换入另外一个话题中。
	# 可以工作的软件 胜过 面面俱到的文档
	我的废话：执行软件项目没有任何文档是一件很可怕，很可疑的事情，但是过多，过盛的文档将比没有文档更加可怕，因为你将需要付出代码与文档同步的代价，实践告诉我们大多数团队往往很难确保文档与代码的一致性，如果代码与文档之间失去同步性，那就成了一堆复杂的谎言。
	在代码中能看见无处不在的注释说明，甚至能渗透到程序中的每个函数与方法，将会降低将来系统重构的成本。如果再加上，一份 剪短紧要 图文并茂的文档长期活跃在每个成员的邮件中，他价值大于沉睡于服务器中面面俱到的文档。
	# 客户合作(协同)&#160; 胜过&#160; 合同谈判
	我的废话：闭门造车，出门不合 这样的现象辙说明了产品根本无法满足客户的需求，软件开发在过程会遇到种种现象与问题。有些问题就连客户都无法预计。在开发期间需要你紧密的和客户保持反顾，把每个阶段完成的工作发布出去给客户进行演示，并且聆听客户的建议。开发团队和客户的协同工作才是最好的合同。
	时时刻刻要让客户知道你在为他忙什么？通过沟通与反顾，你可以尽快的调整项目计划的优先级别。总比等到项目验收的时候让客户说出种种对产品抱怨，让你的团队去返工要好的多吧。记住，你的客户就是敏捷团队中的一员 ！
	# 相应变化 胜过 遵循计划
	我的废话：客户的实际生产服务器和在开发人员机器、公司内部测试服务器上运行的代码都是相同的，但是产生的效果是截然不同的。这将导致客户会对现在的成品提出新的需求。
	响应变化和新需求的能力往往会导致这个项目的成败， 应该从2个方面去考虑：
	1、对于项目上线后遇到的风险有哪些补救的措施，一般经验告诉我们至少要列出10条不同种类的措施，如果你不能列出10条以上，那么说明你将遇到的风险更大。
	2、还应该知道在将来的：1-3个星期内，2个月内还可以实现客户的哪些需求，至于1年可以粗略的估计一下就可以了。需要和客户一同瞻望一下远景，分为 短期，中期，长期。
话外音：软件复杂度有三个主要因素：业务、技术和人员。
	&#8211;end&#8211;
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/agile-approach.html?source=rss</link>
			</item>
	<item>
		<title>google整合Gmail发布Buzz</title>
		<description><![CDATA[今天打开gmail，忽然弹出来这个页面，http://www.google.com/buzz 。Buzz？是什么东东？进去看看再说，从url地址上来看是google 的网址，应该不会是病毒。
进去折腾了一会，还挺简单的，你在上上面唧唧哇哇的，大家都能看见，也能回复，基本上跟digg没有什么区别，页面样式看起来很顺眼。还可以和自己的网站google以外的产品结合起来，也可以关闭。如图：

查看大图请点击这里
	
另外有一点值得注意，如果你是在Google的Gphone/HTC上使用Buzz 移动用户，还可以显示你当前说话的位置。如图所示：

查看大图请点击这里
	
看样子 google 这次搞个buzz 出来 是想大搞一番 SNS了，居然和gmail捆绑在一起，看出来google对此产品的重视程度很高，虽然之前的Orkut 和 Jaiku 也是 SNS 产品 都比较失败，是不是因为不是自己的孩子，都是收购来的？
据说，这次Google Buzz 还开放API 地址： http://code.google.com/apis/buzz/ &#160; 从这个api的页面上来看还不是第3方的，看来google这次真的很重视，支持该项目的力度挺大的。
以下是 google buzz 的视频介绍(英语)：

口水：目前 buzz 图片上传功能只能从google相册里面选择，上传自己本机图片暂时还不行，不知道是不是因为在国内的原因。
	
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/google-gmail-buzz.html?source=rss</link>
			</item>
	<item>
		<title>实施敏捷的要素</title>
		<description><![CDATA[感想太多，吐点废话 {不断更新ing} ：
&#160;&#160;&#160;&#160; # 简单&#8212;&#8212;尽可能减少工作量的艺术至关重要，团队要定期总结如何更有效，相应调整自己的行为。
	&#160;&#160;&#160;&#160; #实施敏捷开发并不是需要依靠大量的文档，而是需要团队领导者有足够的能力和个人魅力，每个成员之间的默契和规范化作业。
	&#160;&#160;&#160;&#160; #项目分为阶段性的频繁的交付给客户审阅，最终产品质量的就越高。
	&#160;&#160;&#160;&#160; #成功的项目需要有序，频繁的得到用户反馈，把需求告诉开发者几月就有你需要的产品听起来很诱人，但最终以劣质和失败告终。
	&#160;&#160;&#160; 
	&#160;&#160;&#160;&#160; #需要充分的认识到软件是有生命的产品，需要你不断的进行维护和重构。
	&#160;&#160;&#160;&#160; #项目的计划/进度表就是你项目的命脉，优先级、难易级、时间段 都是你项目计划表的关键要素。
&#160;&#160;&#160;&#160; #每个人每台机器相同配置，相同开发环境，需要这样，但不是重点，重点是要在任何环境中尽量的缩短项目组每个成员的差距。
	&#160;&#160;&#160;&#160; #每周五下班前的技术session，每个成员都会踊跃发言，抛出任何技术话题讨论。让你对问题了解的更加深刻，
	&#160;&#160;&#160;&#160;&#160; 创新，经验，积累永远是技术session的主题。
	&#160;&#160;&#160;&#160; #PM和分析师在背后付出的需求分析、客户交流等工作，帮助开发人员挡一切不该有的干扰。
	&#160;&#160;&#160;&#160; #每日的站立会议之后，紧跟的就是项目经理 与客户之间的信息反馈和 团队成员沟通。
	&#160;&#160;&#160;&#160; #千万别吝啬你口中对他人的赞扬；也别犹豫你对问题的指正与帮助，需要你冷静与包容的面对。
&#160;&#160;&#160;&#160; # 在开发小组中最有效率也最有效果的信息传达方式是面对面的交谈。
	&#160;&#160;&#160;&#160; # 任何良好的建议与意见被采纳前，需要有一套监督和推广的计划，才能确保建议被采纳后的可持续性。
	&#160; &#160;&#160; # 对卓越技术与良好工作方式的不断追求将有助于提高敏捷性。
	&#160;


	大师 Artem Marchenko有如下建议：
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 为了更加公平，不许打字&#8212;&#8212;在笔记本电脑上做记录，他们就获得了本不应获得的。
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 如果团队在向Scrum Master汇报，那么Scrum Master就应该移开眼光，不与团队成员对视，甚至可以转过身去。
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/implement-agile.html?source=rss</link>
			</item>
	<item>
		<title>Tomcat 中的 Session</title>
		<description><![CDATA[废话少说，先来看看保存session的4种方案
	1.在Web容器的内存中，最常见，最原始的，纯天然，无人工的。
	2.跟上面第一种差不多，只是保存在文件里了，如果忽然down机，下次重启session还在。
	3.通过java JDBC保存在数据库里面。
	4.通过中央式缓存 Memcached 集中管理。
	1、2就不讨论了，说一下3、4 各有优势
	第3点的优势：每台机器连接相同的数据库 session 将集中被管理起来，不会在每个Tomcat之间互相大量复制，减少系统的整个运行压力，另外，在持久化的过程中使用的是 org.apache.catalina.session.JDBCStore对象 Tomcat 下 catalina.jar的一部分，不需要另外引入其他api，并且session数据一直保存在数据库中，而第4点 Memcached 重启 里面的回话也就销毁，需要另外引入API，但是从执行效率上看大于第3种。
	所以可以根据你的需要选择不同的方案。

	查找了网上N多资料，都是互相抄袭并且非常严重！！连错的地方都一起抄过来，我为国人感到可耻！最后还是从一个日本blog上看见了一篇日志得到了启发。
	查看地址：http://d.hatena.ne.jp/stdcall/20070102/1167688088
	以下是测试程序。环境：tomcat5.5 / MySQL ===
	========================Server.xml =============================
	&#60;Context docBase=&#34;SMBMySQLOA&#34;
	&#160;&#160;&#160; path=&#34;/test&#34;
	&#160;&#160;&#160; reloadable=&#34;true&#34;
	&#160;&#160;&#160; source=&#34;org.eclipse.jst.j2ee.server:test&#34;
	&#160;&#160;&#160; backgroundProcessorDelay=&#34;1&#34; &#62;
	&#160; &#60;Manager className=&#34;org.apache.catalina.session.PersistentManager&#34;
	&#160;&#160;&#160;&#160;&#160; distributable=&#34;true&#34;
	&#160;&#160;&#160;&#160;&#160; duplicates=&#34;-1&#34;
	&#160;&#160;&#160;&#160;&#160; saveOnRestart=&#34;true&#34;
	&#160;&#160;&#160;&#160;&#160; maxActive=&#34;-1&#34;
	&#160;&#160;&#160;&#160;&#160; maxActiveSessions=&#34;0&#34;
	&#160;&#160;&#160;&#160;&#160; minIdleSwap=&#34;-1&#34;
	&#160;&#160;&#160;&#160;&#160; maxIdleSwap=&#34;-1&#34;
	&#160;&#160;&#160;&#160;&#160; maxIdleBackup=&#34;-1&#34;
	&#160;&#160;&#160;&#160;&#160; maxInactiveInterval=&#34;-1&#34; 
	&#160;&#160;&#160;&#160;&#160; sessionCounter=&#34;-1&#34; &#62;
	&#160;&#160;&#160; &#60;Store className=&#34;org.apache.catalina.session.JDBCStore&#34;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; checkInterval=&#34;1&#34;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; connectionURL=&#34;jdbc:mysql://172.16.2.211/test?user=root1&#38;amp;password=123456&#34;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; driverName=&#34;com.mysql.jdbc.Driver&#34;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; sessionAppCol=&#34;app_name&#34;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; sessionDataCol=&#34;session_data&#34;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; sessionIdCol=&#34;session_id&#34;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; sessionLastAccessedCol=&#34;last_access&#34;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; sessionMaxInactiveCol=&#34;max_inactive&#34;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; sessionTable=&#34;tomcat_sessions&#34;
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; sessionValidCol=&#34;valid_session&#34; /&#62;
	&#160; &#60;/Manager&#62;
	&#60;/Context&#62;
	&#160;&#60;/Host&#62;
	========================MySQL 建表语句 =============================
	CREATE TABLE [...]]]></description>
		<link>http://www.javabloger.com/article/tomcat-session.html?source=rss</link>
			</item>
	<item>
		<title>谈谈 驱动测试开发</title>
		<description><![CDATA[&#160;&#160;&#160; 设想把编程看成是转动曲柄从井里提一桶水上来的过程。如果水桶比较小，那么仅需一个能自由转动的曲柄就可以了。如果水桶比较大而且装满水，那么还没等水桶全部被提上来你就会很累了。你需要一个防倒转的装置，以保证每转一次可以休息一会儿。水桶越重，防倒转的棘齿相距越近。
	　　
	&#160;&#160;&#160; 测试驱动开发中的测试程序就是防倒转装置上的棘齿。一旦我们的某个测试程序能工作了，你就知道，它从现在开始并且以后永远都可以工作了。相比于测试程序没有通过，你距离让所有的测试程序都工作又近了一步。现在我们的工作是让下一个测试程序工作，然后再下一个，就这样一直进行。分析表明，要编程解决的问题越难，每次测试所覆盖的范围就应该越小。
	&#160;&#160;&#160;&#160; 上文摘自《Test-driven developmen》&#160; 查看书籍:http://www.douban.com/subject/1230036/
==========================================================================================
	我的一句废话：
	TDD的指导思想是让你 通过测试 对你的项目中任务的风险进行分析，推动整个开发的进行。而不只是单纯的测试工作。
	==========================================================================================
	我有3个关于实施中问题：
	&#160;&#160;&#160; 1.什么样的项目合适敏捷中的 TDD (测试驱动开发)
	&#160;&#160;&#160; &#160;&#160;&#160; 有人说，任何项目都适合，TDD是一种弹性的方法。
	&#160;&#160;&#160; &#160;&#160;&#160; 又有人说，并不是任何项目都适合，大项目更适合，小项目反而实践到最后让你想放弃。
	&#160;&#160;&#160; &#160;&#160;&#160; 再有人说，如果说大项目适合，小项目就不适合？请问你界定项目大小的标准是什么？说清楚了，再说谁跟谁到底是不是合适。
	&#160;&#160;&#160; 2.很多人没有这样的习惯，如何让他们养成这样的好习惯，一个公司上千人，一个部门上百人？怎么去推广？
	&#160;&#160;&#160; &#160;&#160;&#160; 有人说，写着程序自动去检测他项目里面写的代码，发现没有按照规范去测试代码，就自动删除他的项目代码，并且报告项目经理。
	&#160;&#160;&#160; &#160;&#160;&#160; 又有人说了，ok，我写，但是我测试的输入和输出标准是我自己定的，运动员和裁判员都是我，这样合理吗？
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 再有人说了，任何管理手段都不能100%依靠工具，还需要人的干预，但又有什么办法一劳永逸并且让TDD手段一直被持续下去？
	&#160;&#160;&#160; 3.当程序在每个人开发人员手里，并非完全由项目管理者掌控，测试覆盖的范围、粒度应该是多大？
	&#160;&#160;&#160; &#160;&#160;&#160; 有人说，我可以认认真真的去测试，但是我的测试到最后才让我发现并不符合适当的粒度，精力白白浪费了怎么办？
	&#160;&#160;&#160; &#160;&#160;&#160; 又有人说，你可以去先写文档具体到描述什么条件时以什么参数调用什么方法时会有什么返回值，先写文档再写代码的过程。
	&#160;&#160;&#160; &#160;&#160;&#160; 再有人说，在我们上百人的公司里不会有人接受让程序员先写测试文档的，你的想法很好，但是很难推广。。。。。
	上述所说，绝对不是空谈，正是很多公司想采用敏捷，想采用TDD，在实践的过程中遇到的一些冲突和常见问题。
	先写到这里，有时间在继续写下去。
	&#8211;end&#8211;
	&#160;
]]></description>
		<link>http://www.javabloger.com/article/test-driven-development-kent_beck.html?source=rss</link>
			</item>
	<item>
		<title>Google Apps 用于 javabloger.com &#8211; 标准版</title>
		<description><![CDATA[和自己的域名绑定在一起 搞了一个Google Apps，感觉不错：

查看大图请点击这里
	
1.可以将自己的邮件域(MX) 和Google Apps捆绑,不用自己提供邮件服务器，可以借用Google Gmail的服务，可以在web和outlook上的邮件收发。以后各位可以发这个邮件(njthnet＠javabloger.com)地址到我的邮箱，我可以用Gmail打开。发送到原来的邮箱也可以，我相互做了pop 绑定，无论发哪个我都能收到。登陆地址：mail.javabloger.com
看图：

	查看大图请点击这里
2.可以有自己的在线办公平台 域名是 http://docs.javabloger.com 

	3.有自己的行事历 域名是 http://calendar.javabloger.com ，有G1、S60 手机的朋友还可以和自己的手机设置同步。
&#160;
可以参考这个地方进行体验Google Apps 的服务 http://s9011514.googlepages.com/apply_google_apps.htm
2句废话：
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 1.选择国家的时候不用选中国，Google会提示 &#8220;你所在的国家不支持这项服务&#8221;。
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 2.你必须有一个合法的域名。
	
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/google_apps.html?source=rss</link>
			</item>
	<item>
		<title>GlassFish JMS 集群</title>
		<description><![CDATA[Story
	最近项目中一直在使用GlassFish作为应用服务器,使用到 GlassFish中JMS/MDB(消息驱动Bean)的部分，项目对JMS服务的要求比较高不仅仅需要在单台服务器上运行，还需要在集群环境运行JMS服务。
	查阅大量资料，网上N多讲的都是Jboss的JMS集群，很少有简述GlassFish集群JMS的，无意找到了一篇印度阿三的写的文章,经过反复推敲，证明这样的实施方案虽然是SUN公司比较推崇的，实施起来成本比较大，将来需要投入的维护成本也不小。印度阿三提出的做法给人感觉：要吃块牛肉而已，现在牵头牛过来给我了。请看原文 。
	将此方法放弃，直接使用OpenMQ JMS服务，OpenMQ也是SUN的产品，只不过现在和GlassFish整合包含在GlassFish里面，也可以独立使用。
	在项目测试环境中运行了OpenMQ 的集群，没有用GlassFish里面提供的MDB解决方案，欢快的使用着OpenMQ JMS 集群功能，2台机器上的JMS 队列也在欢快的 进行消息同步。
	&#160;不久后问题来了。。。。。
	&#160;
	OpenMQ和我们自己写的客户端程序建立的是socket 连接，也就是说服务端OpenMQ JMS服务一旦down掉，那么JMS客户端程序就跟白痴一样还在等待接收消息，却不知道OpenMQ JMS服务端已经down掉了。系统中没有体验到失效转发。
	项目组的一位仁兄 写了一个程序 通过轮询检测 我们自己写的JMS客户端程序 是否抛出异常判定 OpenMQ JMS服务端是否还活着。
	嗯，这位仁兄的方法果然有效 原先我们自己写的客户度程序不是呆子了，智能了一些，知道服务端down掉以后该做什么。
	这样的方法虽然达到了效果，但是比较简陋，性能上有种说不出的痛。不知道将来会出现什么问题，还是需要依靠自己去解决，会有一定程度的风险。
	How
	接下来的几天，我google到一份讲述 J2EE服务器原理的书籍，通过理论上的知识让我知道，通过J2EE容器发送JMS消息，跟写通过容器中JNDI整合JDBC方式向数据库做操作一样。首先要查找数据源，建立数据库连接。JMS程序也是一样。可以通过API调用JMS服务器直接操作，也可以通过容器JDNI的方式操作。和JDBC的区别就是分为 发送着/接受者(Queue)，发送者/订阅者(Topic)。
	那么换个思维方式，也就是说在GlassFish中配置一个JNDI作为一个别名，实际服务器的目标地址可以配置成本地/远程 JMS服务器，可以是一个也可以是多个服务器。很多事情就可以交给GlassFish容器帮我们去做了，比如：超时重连，切换失效主机，事务等。这样可以对项目进行重新架构，详见下图：

	
查看大图请点击这里
	
说明：
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 1.客户端收/发程序&#8211;&#62;部署在容器中&#8211;&#62;容器JNDI&#8212;&#62;JMS Server&#8212;&#62;Message Queue&#8212;&#62;Message 。
	&#160;&#160;&#160; &#160;&#160;&#160; 2.发送者向JMS服务器中的消息队列发送100个消息 ，通过JMS集群 接收端如果有2台服务器每台服务器会接收50个，有4台每台接收25个，以此类推，这样达到了压力分载的效果。
	&#160;&#160;&#160; &#160;&#160;&#160; 3.无论在发送端还是在接收端任意一台服务器Down掉，JMS集群服务器会自动分配负载。

	拓展话题：1.JMS与EJB中MDB的关系到底是什么？ 2.SUN公司推出的JMS1.0 和JMS1.1在功能上、标准上有什么区别？
	口水：&#8220;没有100%最佳的实践方案，往往最佳实践就是最折中的一种方法。&#8221;
	&#160;
	参考资料：http://www.novell.com/documentation/extend52/Docs/help/MP/jms/admin/clustering.html
	参考资料：http://www.wnetw.net/jclub/technology/read.jsp?itemid=762
	参考资料：http://today.java.net/article/2008/01/18/jms-messaging-using-glassfish
	参考资料：http://developers.sun.com.cn/Java/jms-messaging-using-glassfish.html
相关文章
	大型系统中使用JMS优化技巧&#8211;Sun OpenMQ  
	GlassFish 优化技巧 -GlassFish HTTP/1.1 GZIP  
	Glassfish(EJB) 与Quartz Job Scheduler整合  
	GlassFish 文档  
	GlassFish 数据库连接池的配置步骤(图解) 
	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/jms-service-availability-glassfish.html?source=rss</link>
			</item>
	<item>
		<title>GlassFish 文档</title>
		<description><![CDATA[在这里我整理了一批关于Sun  GlassFish v2/Sun Java System Application Server 9.1.的有效资源/文档
	1. GlassFish Tell me, Show me page: 看图说话，将指导你完成基本操作，是新手的理想选择。
	2. What&#39;s New with the Admin Console: 一个很好的描述 GlassFish 管理界面/管理工具的地方
	
	3. 在GlassFish的管理控制台里面的帮助，虽然说的比较抽象，但是有时候对于一个初学者来说还是可以解决一些棘手的问题。
	4. High-Availability guide: 详细的介绍GlassFish 的集群功能/负载均衡, HADB 配置。
	5. How to Run Glassfish with Apache:&#160; 介绍GlassFish j2ee 应用服务器 和Apache Web服务器如何整合(Refer) 。
	6. Usage Profiles in GlassFish: 详细的介绍GlassFish用户配置上的细节(Refer)。
	7. Developer&#39;s guide and the Deployment guide: [...]]]></description>
		<link>http://www.javabloger.com/article/glassfish_docs_source.html?source=rss</link>
			</item>
	<item>
		<title>手机上写wordpress日志</title>
		<description><![CDATA[测试：这是从我手机上发出的一篇日志,提醒自己现在需要对j2ee容器开始深入学习了。
&#8211;end&#8211; 
]]></description>
		<link>http://www.javabloger.com/article/test_from_handset_to_wordpress.html?source=rss</link>
			</item>
	<item>
		<title>Java+PHP整合=混血新宠儿</title>
		<description><![CDATA[在2009年互联网上大谈各种系统技术架构，我们看见了很多国内、国外大型网站采用了其他语言和Java(Jee)结合的方式进行工作，其中由我们熟悉的有 手机之家 和 Digg 都是采用PHP和Java混合的方式进行协同工作。<br /><img alt="http://www.javabloger.com/images/article_pic/php_and_java/3.png" height="241" src="http://www.javabloger.com/images/article_pic/php_and_java/3.png" style="width: 478px; height: 241px;" width="478" />]]></description>
		<link>http://www.javabloger.com/article/java_and_php_mixed.html?source=rss</link>
			</item>
	<item>
		<title>Jboss新年发新版本</title>
		<description><![CDATA[Jboss新年发新版本，Facebook在折腾PHP.Java 6也浮出水面了.]]></description>
		<link>http://www.javabloger.com/article/jboss_6-0-0_m1_version.html?source=rss</link>
			</item>
	<item>
		<title>给正在使用Tomcat6的朋友说几句废话(优化)</title>
		<description><![CDATA[很抱歉，在tomcat6在默认的配置选项中是没有把NIO功能打开。所以很多正在使用Tomcat6的朋友们本以为能快活的使用上NIO。]]></description>
		<link>http://www.javabloger.com/article/performance_tomcat_about_nio.html?source=rss</link>
			</item>
	<item>
		<title>谈谈 Digg</title>
		<description><![CDATA[现在每天有2.30亿的超大网络访问的流量。目前Digg已经是全美第24位大众网站了，<strong>29岁的罗斯成为了一个身价6000万美元的富翁</strong>]]></description>
		<link>http://www.javabloger.com/article/digg_architecture_overview.html?source=rss</link>
			</item>
	<item>
		<title>xml在企业应用中的用途</title>
		<description><![CDATA[xml 是简单、易用、多态、可扩展 的标记语言，在企业应用中范围广泛，可以运用在不同环境、不同的场景下，如图所示：

	
	查看大图请点击这里

	企业应用中涉及到的xml运用场景包括：
	&#160;&#160; &#160;1、 配置文件
	&#160;&#160; &#160;&#160;&#160; &#160;在系统中会采用xml作为系统配置信息，不必把配置信息存放在数据库中，采用xml简单化的做到了数据共享和数据存储。
	&#160;&#160; &#160;2、通信协议
	&#160;&#160; &#160;&#160;&#160; &#160; 采用XML定义的通讯协议文件，可以在网络上轻松地交换原本不兼容的数据。比如：把服务器端的电子邮件包裹附件内容完整的展示在用户的移动终端上，中间的数据传输工作是一个比较复杂的事情，因为电子邮件的格式、邮件附件格式种类众多，但是以 XML 格式交换数据降低了复杂性，可以轻松地在不同的系统之间交换数据。
	&#160;&#160; &#160;3、数据转换
	&#160;&#160;&#160;&#160;&#160;&#160;&#160; 越来越多的数据格式出现，但是XML 可以将您的数据格式进行转换，让你的PDF，MS word，TXT各种不同的文档更可用，用不同的应用程序都能够访问您的不同的数据，遵循xml格式标准进行转换成XML格式的文件，您的数据可供各种阅读设备使用：例如：手持的计算机、语音设备、新闻阅读器等。
	&#160;&#160; &#160;4、跨平台数据传输
	&#160;&#160; &#160;&#160;&#160; &#160;由于格式统一，XML可以在不兼容的系统间轻松地交换数据。可以通过各种应用程序在不同的操作系统下读取数据。

	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/enterprise_xml_application.html?source=rss</link>
			</item>
	<item>
		<title>SQL语句查询优化测试</title>
		<description><![CDATA[以前的做SMB CRM 项目时写笔记,现在拿出来给大家读，希望能与大家一起交流、分享经验。

	&#160;&#160; &#160;有没有 想过 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; select id,name,phone from customer_buyercustomer order by id desc limit 0,20
	&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; 和 &#160;
	&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; select id,name,phone from customer_buyercustomer limit 100000,20
	&#160;&#160; &#160;&#160;&#160; &#160; &#160; &#160; &#160; &#160; &#160; &#160; &#160; &#160; &#160; &#160; &#160; &#160; &#160;&#160; 和
	&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160;&#160; (select id ,username from crm_users limit 100000,20)&#160; [...]]]></description>
		<link>http://www.javabloger.com/article/optimizing_sql_query_speed.html?source=rss</link>
			</item>
	<item>
		<title>谈谈我知道的微软、SUN公司 测试工作</title>
		<description><![CDATA[TestCase编写，功能/性能测试，集成测试，最终release。每个公司都大致相同，在微软、SUN这样传奇而出色的公司里，他们是怎样进行测试的？有2个话题非常值得我们去关注： 确保执行流程 、提早介入。
微软、SUN公司拥有了长期的有效经验积累，有很多良好的工作方式，但并不适用于每个公司，因为需要你与他们一样拥有一流的人才与环境。
	比如说：微软Windows2000 的开发团队，有900个开发人员，1800个测试人员，1800人中有还有 不同身份的人，甚至还有老弱病残者。所以并不是每个公司都可以去模仿的，如图所示：

	查看大图请点击这里
	但对于第二个话题 提早介入我个人认为是 90%公司的测试团队可以去做到的，至少你需要有这样的意识。比如：在SUN公司的GlassFish开发小组他们的测试团队会早早的介入开发团队。
	&#160;&#160;&#160; &#183;开发团队在进行需求分析，测试小组会一起参与，可以更深入了解应该如何去测试。
	&#160;&#160;&#160; &#183;开发团队遇到了新的技术需要学习和公关，测试人员也同样在学习，并且与开发人员一起沟通关于新技术的话题。
	SUN公司的这样的模式值得去借鉴，这样可以知道对于产品每项功能的测试指标。如果让开发人员提出测试指标&#8220;裁判员与运动员将是一个人&#8221;，如果到开发完成让测试人员自己提出测试指标将无从下手。
	我非常欣赏这样的模式，是我们目前大部分软件公司可以去借鉴的。
	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/microsoft_and_sun_testing_process.html?source=rss</link>
			</item>
	<item>
		<title>对REST浅浅的认识</title>
		<description><![CDATA[REST里面没有包含什么新的技术，还是RPC风格，跟WebService看起来差不多，但请求的url好像有点不同。没有带参数的问号了。看起来清爽了一些。
	大家可以看看www.douban.com(豆瓣网) 几乎每个url地址都没有问号。
	通常是 http://www.douban.com?people=someone/&#160; 现在是 http://www.douban.com/people/someone。问号没了。
	别小看这样的改变，对在整体架构上带来了很大的改变，并且在REST的架构中提倡你使用缓存。
	架构：

查看大图请点击这里
	&#160;&#160; &#160;
	原理：
	&#160;&#160; &#160;&#183;分析url的请求路径，中间通过转发，让客户端请求直接访问对应的各个应用层模块。
	优势：
	&#160;&#160; &#160;&#183;简单的url路径带来了极强的后端的伸缩性。
	&#160;&#160; &#160;&#183;对前端的展示没有任何限制，B/S 、C/S架构都可以，甚至asp,php都可以，提高了可扩展性。
	&#160;&#160; &#160;&#183;统一了对外部的请求访问。
	劣势：
	&#160;&#160; &#160;&#183; 客户端、展示层&#160;&#160; 需要对通讯协议(JSON/XML/自定义参数)其进行解析，加大了原先的工作量。
	&#160;&#160; &#160;&#183; 中间多了一个专门针对url转发的工作
	&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/how_about_rest_architecture.html?source=rss</link>
			</item>
	<item>
		<title>什么是物联网</title>
		<description><![CDATA[看看百度百科上是怎么说物联网的，我个人觉得：“不是全新的技术，目前还是一个概念，但的确是一个Good Idea。很类似传说中的Web2.0那鼓劲]]></description>
		<link>http://www.javabloger.com/article/the_internet_of_things.html?source=rss</link>
			</item>
	<item>
		<title>说说每日项目例会的必要性</title>
		<description><![CDATA[关键字：每日 、简短、记录、客户、积累、持续化<br />
每个公司都会开会，大大小小会目的不同，在项目开发中同样也需要开会，根据经历我的项目经验在此分享一下，所谓有效的项目会议是如何进行。]]></description>
		<link>http://www.javabloger.com/article/talk-about-project-dailymeeting.html?source=rss</link>
			</item>
	<item>
		<title>GlassFish 数据库连接池的配置步骤(图解)</title>
		<description><![CDATA[项目中用了GlassFish有一段日子了，GlassFish的Admin-GUI 做的还是不错的，比较直观，废话少说进入正题，配置GlassFish的连接池点了10几下鼠标就可搞定了，详见下图：]]></description>
		<link>http://www.javabloger.com/article/setup-j2ee-server-glassfish-by-jdbc-pool.html?source=rss</link>
			</item>
	<item>
		<title>Java web开发中文乱码问题</title>
		<description><![CDATA[昨日一同事喊我去他的机子上救火，告诉我折腾了半天，还是存在中文乱码问题。15分钟后找到了问题的原因。

	&#160;&#160;&#160; 现象:url = jdbc:mysql://127.0.0.1/test?useUnicode=true&#38;amp;characterEncoding=UTF-8，这段代码出现在配置文件(database.properties)中。
	&#160;&#160;&#160; 
	&#160;&#160;&#160; 分析:上述是原先写的，问题就在&#38;amp; xml/html转译符上,在xml/html里面需要写成转义符，但是在纯文本的模式下写成那样就不对了，将导致配置参数无效，原来问题出在一个标点符号上。
&#160;&#160;&#160;&#160;&#160; 去掉amp; 写成 url = jdbc:mysql://127.0.0.1/test?useUnicode=true&#38;characterEncoding=UTF-8，即可。

	收工以前，做了五分钟的科普向同事们总结了一下,一般导致中文乱码问题7点因素:
	&#160;&#160;&#160; 1.数据库使用的字符集&#160; 
	&#160;&#160;&#160; 2.数据库表使用的字符集
	&#160;&#160;&#160; 3.html、JSP 页面上的编码
	&#160;&#160;&#160; 4.使用的JDBC&#160; url连接是否正确
	&#160;&#160;&#160; 5.web服务器端 应用服务器 和 操作系统 设置的字符集是否和你需要的匹配
	&#160;&#160;&#160; 6.你的IDE开发环境(Eclipse)工程使用的字符集是否匹配
	&#160;&#160;&#160; 7.检查你的工程的web.xml文件是否在使用关于字符编码的过滤器
	以上几点原因都是导致产生中午乱码的因素，如果你的项目中出现了中文乱码不妨可以按照上述思路试试。

	&#160;&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/java-web-development-zhongwen-luanma-problem.html?source=rss</link>
			</item>
	<item>
		<title>有了JSP为什么还需要Servlet？</title>
		<description><![CDATA[虽然JSP和Servlet没有本质上的区别，JSP最终会由容器编译成Servlet，使用JSP作为前端页面展示比较方便，但JSP不能完全替代Servlet。因为Servlet具有独特的特性，例如： 监听器、过滤器 。因此JSP无法替代Servlet。
	&#160;如果对 监听器、过滤器 不熟悉可以去百度查阅，就不在此详细介绍了，本文不具体介绍使用方法，具体方法搜索引擎会告诉你，可以去查阅。

	使用监听器&#160;&#160;&#160; 
	&#160;&#160;&#160; &#160;&#160;&#160; When (场景)
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; 通常在当web服务器启动并且没有任何外部访问的时候，需要让程序能自动运行，可以采用监听器实现。
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; 还可以监听web工程中的回话(session)、属性(attribute), 并且对监听到的 回话(session)、属性(attribute)进行 添加、删除、修改操作。
	&#160;&#160;&#160; &#160;&#160;&#160; How&#160;&#160; (实现)
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; 需要在web工程中配置 web.xml文件，并且Servlet监听器程序需要实现 javax.servlet.ServletContextListener 接口。
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; 注意：Servlet总共有8个监听器,HttpSessionBindingListener接口是唯一不需要再web.xml中设定的Listener
	
	使用过滤器 
	&#160;&#160;&#160; &#160;&#160;&#160; When (场景)
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; web工程进行统一的 格式化编码，验证用户回话、身份、数据加密、压缩，可以采用过滤器实现。
	
	&#160;&#160;&#160; &#160;&#160;&#160; How&#160;&#160; (实现)
	&#160;&#160;&#160; &#160;&#160;&#160; &#160;&#160;&#160; 需要在web工程中配置 web.xml文件，Servlet过滤器类都必须实现javax.servlet.Filter接口。
	&#160;
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/why_need_java_servlet.html?source=rss</link>
			</item>
	<item>
		<title>谈谈Java虚拟机优化与垃圾回收</title>
		<description><![CDATA[&#160;&#160; 对于JVM的原理就不多说了，去google一下或者在 互联网百科全书 上搜索一下也能找到非常好的介绍，那么我们先谈谈JVM中的参数设置，别小看这些将要设置的参数，他将决定了JVM的处理能行，但也不是设的越大越好，不然JVM的垃圾收集器工作的太频繁反而降低了性能，而是需要有个折中的设置，&#160; 你可以设置 -Xmn （最小），-的XMS（初期）和- Xmx（最大）对堆大小参数进行调整，前提是你需要对机器的性能和配置有一定的了解，特别需要对机器的内存大小进行关注。&#160; &#8220;堆&#8221;细分为在JVM的生命周期中使用的若干组成部分。这里有一个快速分类：

&#160;&#160;&#160; 堆分为两个领域：新一代和老一代。在新一代的空间中有一个叫Eden的空间，主要是用来存放新生的对象，还有两个Survivor Spaces（from,to）, 它们用来存放每次垃圾回收后存活下来的对象。在Old Generation中，主要存放应用程序中生命周期长的内存对象，还有个Permanent Generation，主要用来放JVM自己的反射对象，比如类对象和方法对象等。

当一个URL被访问时，内存申请过程如下：

JVM会试图为相关Java对象在Eden中初始化一块内存区域


当Eden空间足够时，内存申请结束。否则到下一步


JVM试图释放在Eden中所有不活跃的对象（这属于1或更高级的垃圾回收）, 释放后若Eden空间仍然不足以放入新对象，则试图将部分Eden中活跃对象放入Survivor区Survivor区被用来作为Eden及OLD的中间 交换区域，当OLD区空间足够时，Survivor区的对象会被移到Old区，否则会被保留在Survivor区


当OLD区空间不够时，JVM会在OLD区进行完全的垃圾收集（0级）


完全垃圾收集后，若Survivor及OLD区仍然无法存放从Eden复制过来的部分对象，导致JVM无法在Eden区为新对象创建内存区域，则出现&#8221;out of memory错误&#8221;


	&#8211;end&#8211; 
]]></description>
		<link>http://www.javabloger.com/article/java_virtual_machine_optimization.html?source=rss</link>
			</item>
	<item>
		<title>关于wordpress优化</title>
		<description><![CDATA[最近搞了这个wordpress空间，做了点优化，顺便写了总结，废话少说，入正题
	&#160; 1、静态化
	&#160; &#160; &#160; &#160; &#183;对于 google、baidu搜索引擎来说他们最喜欢静态的html、htm页面了，将网站里的文章生成静态的html是非常有必要的。&#183;读者查看站点的时候无需读取数据库，大大的提高了访问效率。建议采用cos-html-cache工具将站点静态化。

	&#160;&#160;&#160; &#183;将管理界面里的&#8220;固定链接设置&#8221;改成 &#8220;自定义结构&#34;&#160; 选项 对应值&#8220;/%postname%.html&#8221;
	&#160;&#160;&#160; &#183;写2个php文件放在2处 ，1你的默认站点下 文件名&#8220;404.php&#8221; 2你使用的模板目录里面文件名&#8220;wp-404-handler.php&#8221;
	2、标记
	&#160;&#160;&#160; &#183;页面 title 、meta 写入 站点相关的关键字
	3、抓取
	&#160;&#160;&#160; &#183;放入robots.txt到站点跟目录下，让google、baidu搜索引擎的蜘蛛、机器人 知道怎么去抓取你的站点。
4、修改
	&#160;&#183;修改你模板里面的&#8220;header.php&#8221; 和 &#8220;footer.php&#8221;2个文件，将php读取信息的部分替换成html代码，把代码部分的内容写死。
5、首页
	&#160;&#183;建议采用cos-html-cache工具将站点静态化以后，首页也会静态化，进入你的虚拟主机管理页面，将默认页面设置为&#8220;index.html,index.php&#8221;,切记把index.html放在index.php前面，并且设置把其他默认页面删除。这样访问者打开站点读取就是你设置的静态页面，速度明显提高了很多。

	&#160;
]]></description>
		<link>http://www.javabloger.com/article/about_wordpress_optimization.html?source=rss</link>
			</item>
	<item>
		<title>什么是传说中的 OO、OOP、OOD、OOAD</title>
		<description><![CDATA[先从面向对象分析法 (OOAD)开始说起，嗨，你现在在看什么？一台显示器？我写这个的这个文章？本书上的第xx页？还是一个对象？显示器上有什么？我说的&#8220;什么&#8221;是说对象的属性？为什么这样说？因为我们需要把对象进行抽象出来，什么需要抽象出来？因为抽象出来以后我们可以进行复用。面向对象设计的道理就是这么简单。我们可以把世界上任何一个东西看做是一个对象。而OO、OOP、OOD、OOAD思想是不局限于任何一种计算机语言本身的，可以实践在任何一种语言里，面向对象设计是一种方法论，而不是某种特定的技术。
	说到 OO、OOP、OOD、OOAD 不能不提到一个词 &#8220;类&#8221;(Class)，对这词我们应该怎么去理解？ 在讨论这个问题之前，建议先去看看&#8220;类&#8221;这词在英语字典里面是什么解释的，原意应该是指&#8220;种类、把什么分类&#8221;。
	ok，话再说回来，这篇文章可能会出现在你的显示器上，可能会出现你看的书本里，但是文字的内容是一样的，可以把现在讲述&#8220;面向对象分析法&#8221;这个文章给抽象出来作为一个对象，把书也抽象出来作为一个对象，把显示器也抽象出来作为一个对象，现在看起来我们有了4个对象，1显示器2书3文章4最终显示的结果。每个对象里面有属性，1可以把最终显示的结果的属性定义为显示载体和现实内容，2可以把显示器的属性定义为屏幕、3可以把书的属性定义为纸张、4把文章的属性定义为标题和文章的内容。这样我们可以想象一下文章的内容、标题对于显示器和书本的上显示的结果都是一样的，文章的内容可以出现在任何一个地方。
	分析完以后我们在设计的程序的时不必采用传统的方式进行设计，如果在使用过程式的方式设计程序：显示器上要出现文章的内容，需要把显示器和显示器上出现的内容全部按照过程式的方式呈现出来，要设计显示器和文章，他们是一个整体，那么书上再出现同样的内容的时候，还需要重新设计一边书和文章里面具体显示的内容，如果使用面向对象的设计方式：最终显示的结果对于用户来说都是一样的，可以抽象成一个高级的对象，只需要设计书是什么样的，显示器是什么的就可以了，不必重复设计文章的内容。
	如果将来还需要用打印机把这个文章打印出来在一张A4纸上的时候，只需要设计一下是什么打印机就可以，不必再去考虑什么样子的文章，只需要把文章这个对象放入打印机里面，出来的就是你需要的结果。这就是面向对象设计的好处，进行合理的抽象以后，我们可以进行复用，现在我们可以看到不会因为你是否使用显示器对象、书对象或者打印机对象需要显示这篇的时候，牵涉到你需要重新设计一边具体显示的内容，如图:

&#160;
&#160;
]]></description>
		<link>http://www.javabloger.com/article/what_is_the_legend_oo_topic.html?source=rss</link>
			</item>
	<item>
		<title>说说为什么使用Java框架的道理</title>
		<description><![CDATA[
	what
	如今，&#8220;J2EE框架&#8221;一词如雷贯耳，那么什么J2EE是框架？框架，即FrameWork。其实就是某种应用的半成品，就是一组零件，供你选用完成你自己的系统。简单说就是使用前人提供的工具，来做你需要做的事情，比如：木匠在做家具的时候不需要去考虑去把木材从森林里面砍伐回来，再到工厂里面进行加工，他只要从市场里面买来现成的木料即可，木匠只管做家具。而除了做家具以外的砍树伐木事情木匠不必操心，他只管拿木材来用。上述说的木材市场中的木料就是好比框架，他并不是直接能用的家具，需要进行加工，反之，在古代很多木匠都需要自己去砍伐木料回来自己加工，很辛苦，而且降低了整体的工作效率。
	对于一个有经验的木匠他会知道什么样木材的用在什么地方，把哪些不同类型的木材拼一起会成为一个外观好看并且坚固耐用的桌子，成本低，经济实惠。而一个有 经验的软件工程师，他会知道在什么场景，什么功能需求下运行什么样框架技术最适合，什么框架与什么框架技术相互组合以后能发挥他更好的性能，使用框架产品 后让系统更出色。
	我们并不是在说与软件开发企业应用无关的话题，前人告诉我们大多数的科学理论都是来自于我们的日常生活，做这样的比喻是希望读者能明白，使用任何框架并不 会让你的系统更出色，更稳定，只是简化了你的工作，规范了你的工作，锦上添花而已，对于企业来说用不用某种Java框架技术并不是企业应用成败的关键因 素，对于个人来说会不会使用某种框架技术更不是衡量软件工程师能力的强弱的标准。
	&#160;
why
	为什么要用框架？ 因为软件系统发展到今天已经很复杂了，特别是服务器端软件，设计到的知识，内容，问题太多。在某些方面使用别人成熟的框架，就相当于让别人帮你完成一些基 础工作，你只需要集中精力完成系统的业务逻辑设计。而且框架一般是成熟，稳健的，他可以处理系统很多细节问题，比如，事物处理，安全性，数据流控制等问 题。
	还有框架一般都经过很多人使用，所以结构很好，所以扩展性也很好，而且它是不断升级的，你可以直接享受别人升级代码带来的好处。框架一般处在低层应 用平台（如J2EE）和高层业务逻辑之间的中间层。因为某种框架用的人多，而且项目比较大，采用以后熟悉该框架技术的人可以马上和开发团队紧密结合，&#8220;规 范&#8221;
when
	如果你想提高你系统的性能，可能会考虑到使用缓存技术，那么不采用任何Cache框架的前提下你自己就得去想用Java API里面的什么方法可以去实现。&#8220;哦，可以用 静态变量的 HashMap&#8221;。接着去编码，去测试，运用到项目中运行了一段时间，发现了一个问题，需要将在多台机器上运行自己写的缓存程序，会考虑到缓存同步的问题，继续修改，继续测试，继续使用，但是没有多久发现还是不稳定，每台机器上缓存并不是想象那样在同步着。此时，再回头看看Day Line、项目的时间表、完成进度&#8230;&#8230;.还有很多任务没有完成，下个星期就要上线了，很多时间都放在非关键性的技术研究上了。
	从上述这个案例来看，对于想提高运行的性能并改良是一个很好的想法，但人的精力是有限的，而竞争是激烈的，需要有强大的系统性能，又需要能按期完 成，又需要节省人力成本，怎么办？使用一些现成的Java缓存框架技术，这些框架由专业的团队完成，这些团队的主要任务就是做出杰出的Java缓存框架， 产品并且经过严格测试与成功案例。如果直接采用可以解决上述所说的一部分问题，比如：可以提高系统的性能和节省人力成本，这就是为什么需要使用框架的道 理之一。
	去面试的时候面试官会问面试者会不会使用某种框架技术，我对于这样问题本意的理解就是：&#8220;他希望你能很快的融入公司的开发团队，无需对你进行更多的技术培训，另外，他们希望你会使用这样的框架技术，可以提高开发中的工作效率，降低时间上的成本，让我的精力放在关键性的任务上。&#8221;同样我在做面试官的时候也希望别人这样理解我的意图，而并非是希望面试者能对某种框架技术能使出少见的绝招，让我认为他是一个技术上&#8220;厉害&#8221;的角色。
]]></description>
		<link>http://www.javabloger.com/article/why_use_j2ee_framework.html?source=rss</link>
			</item>
	<item>
		<title>MySQL数据库优化工具 –MySQLOA (第一部分 项目开发与管理)</title>
		<description><![CDATA[MySQLOA 开源项目完成有一段时间了，一直找着理由没有去写文章，现在来写一篇日志介绍一下这个项目是怎么开发的。
在开发这个项目的时候，先构思了一下，然后找了一张纸随便写写画画，脑子里面大概有了一点思路。然后确定里程碑，将每个里程碑(Milestone)在切分成几十个，几百个小任务，也就是人们常说的WBS(Work BreakDown Struature)工作任务分解， 简单来说就是将工程项目的各项目内容按其相关关系逐层进行分解，直到工作内容单一、便于组织管理的单项工作为止，被分解的每个小任务的计划完成时间不超过 3天每3天一个阶段，每天至少有3个开发任务并行。阶段性任务完成采用Junit4 进行单元测试测试。每3个任务一次单元测试，每天开发一部分就测试一部分。从页面逻辑和功能、性能3个角度进行测试，这样保证整个项目不会有太大偏差，并能预估出来每个阶段的完成时间，监控项目进度。如图所示：

任何项目管理手段与技术解决方案都不可能原版照抄书本，适合自己的才是最好的，MySQLOA是一个人在做，没有其他团队合作成员，所以没有敏捷中提到的Team Work一词，但是一个人的项目也有一个人项目的特点，节省了沟通上的成本，相对，思维上也有一定的局限性，Ok，这个是风险 &#8220;思维上的局限性&#8221;，为了避讳这个风险在空闲的时间里去找其他同事，朋友，聊聊这个项目，这样的方法没有错！果然有让我一定的收获，项目里面一些重要功能就是在&#8220;闲聊&#8221;中产生的。记住当你识别到风险的时候，你就要想方设法的去击破与绕开他。如果你没有这个意识等到风险多了，就像地雷一样，一不小心就会让你粉身碎骨。
在编写项目代码的时候虽然规划好了采用自己的山寨Web框架，可是最开始的时候并没有进行对山寨Web框架的设计，因为这个不是项目的重要部分，最初重要的是要把测试版本的全功能实现，在发布第一个正式版的时候山寨的Web框架这才是列入考虑范围当中的工作。
要知道执行一个项目就像人每天的生活一样，我们可以做一个假设，你每天不吃饭行不行？不行！ 你每天不睡觉行不行，不行！你每天回家晚餐不吃鱼行不行，这个是可以的。&#160; 那么你每天不起床不洗脸行不行，好像可以吧，但是有点不卫生。那么你每天不读莎士比亚的文章去读海明威的书可以吗？不好意思，我从不看这些。&#160; 我们从这个生活现象能看出，有个等级的界线和不能确定的因素和更高的追求。
在项目无论你是架构师，工程师，初级程序员都需要识别在项目环节或者每个任务是不能删减的工作 因为这才是重点、关键，而对于可有可无的部分可以放到下一步去做，目前只做设计、构思目前不急着去实现。另外，对于不能确定的部分可以先做一些尝试，对这些尝试的投入需要画一个&#8220;圈&#8221;投入的成本不能超过一定的范围，这样才能确保项目顺利的进行下去。对于项目(产品)优化和深入的部分，我们需要满足所有需求以后再去实现，不然为时过早。
就像人的生活一样，先要解决自己的温饱问题，其次再去考虑生活中的附加部分，如果每天的菜中 没有鱼吃还是能生存下去的。对于不能确定的部分，先做一些尝试如果行不通并且遭到大伙的反感就要考虑一下是否应该换一种方式的，需要思量，千万不要一意孤 行，这样会失去的更多。对于思想上的精神食粮人类只有吃、饱穿暖了以后才去考虑，对于一个项目也是一样，如图所示：
 
人的需求阶层与项目一样，满足锦上添花的部分时，先满足基本层次的需求，这样才能生存。
待续，未完。。。。
参考微软采用敏捷的方法： http://book.51cto.com/art/200909/152315.htm
]]></description>
		<link>http://www.javabloger.com/article/project_development_and_management.html?source=rss</link>
			</item>
	<item>
		<title>MySQL数据库优化工具 –MySQLOA (第二部分 系统架构与代码架构)</title>
		<description><![CDATA[
整个系统除了Xstream采用都是最原始的技术，也就是说没有借用其他框架了，下图说明了整个系统软件运行环境和系统中使用到的技术与工具。如图所示：

MySQLOA 可以连接查看本身和远程的数据库运行环境，如图所示： 

查看大图请点击这里
整个代码架构依旧是经典的MVC模式、三层架构，根据需求设计Pojo，业务逻辑操作分为2大部分：1、JDBC操作MySQL 2、操作 XML 模型对象，

在访问XML模型对象上加上一层Cache这样不会每次操作XML文件，从内存读取可以提高用户体验。
采用纯 JDBC 对MySQL进行操作，大部分执行的SQL是MySQL&#160; Show 命令。
通过 Pojo 模型对象，贯穿整个系统，在数据层、业务层、表现层 传值。
中间依靠Servlet和自己写的山寨Web框架控制页面转发，并传值给HTML/JSP页面。
最后在显示层用Flash图表，HTML/JSP页面上把具体的内容显示出来。


功能内部数据流程介绍：
用户浏览器、1页面 、 2Servlet控制器传值+页面跳转、3XML解析+JDBC执行MySQL命令、 MySQL数据库

查看大图请点击这里
待续.
&#160;

]]></description>
		<link>http://www.javabloger.com/article/system_architecture_and_code_structure.html?source=rss</link>
			</item>
	<item>
		<title>有的人</title>
		<description><![CDATA[有的人一面就是一生，有的人却不如不见，有的人不能不见，有的人想见但不如不见，有的人一生不必再去相见，有的人让你想见又不想去见，有的人可以一直和你相见，有的人就是躲着你不见，有的人跑来就是要和你相见一面，有的人见了一面改变了你的一面，有的人他想离开你才会和你相见，有的人他不想离开你才会和你相见，有的人相逢未必和你相见，有的人每天让你对他视而不见，有的人每天对你也视而不见，有的人在等你去见他一面，有的人一生就是一面。。。。。。。。。。
&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/someone_someface.html?source=rss</link>
			</item>
	<item>
		<title>创作共用版权协议</title>
		<description><![CDATA[本博客空间所有随笔及文章均采用Creative Commons 组织的协议(最新版本)，使用&#8220;创作共用（CC）&#8221;名称来支持Creative Commons 版权协议。
	&#8220;创作共用&#8221;体现两个方面的含义：
	&#160;&#160; &#8220;创作&#8221; 是缘自于创作者的行为，并产生作品为结果，创作者有权利要求自己的作品所附加的各种权利。
	&#160;&#160;&#160; 在传统的&#8220;保留所有权利&#8221;的版权体系中，创作者的权利被错误地变成了&#8220;封闭&#8221;和&#8220;不传播&#8221;。在互联网时代，
	&#160;&#160;&#160; &#8220;保留部分权利&#8221;已经成为一种更有利于创作者的趋势。
	&#160;&#160; &#8220;共用&#8221; 体现了人们愿意将作品给更多人使用的愿望，这种共同使用的前提是尊重创作者所选择的权利要求。
	&#160;&#160;&#160;&#160; 我们把愿意共用的精神称为&#8220;分享主义&#8221;(Sharism)，分享主义的前提是尊重创作者的权利，
	&#160;&#160;&#160;&#160; 而不是随意剥夺变成&#8220;公有&#8221;。
	署名 &#183;&#160; 非商业用途 &#183; 保持一致
	你可以免费:
	&#160;&#160;&#160; * 拷贝、分发、呈现和表演当前作品
	&#160;&#160;&#160; * 制作派生作品
	但是必须基于以下条款:
	by &#160;&#160;&#160; 署名。你必须明确标明作者的名字。.
	nc &#160;&#160;&#160; 非商业用途。 你不可将当前作品用于商业目的。
	sa &#160;&#160;&#160; 保持一致。如果你基于当前作品更改、变换或构造新作品，你应当按照与当前协议完全相同的协议分发最终作品。
	&#160;&#160;&#160; * 对于任何二次使用或分发，你必须让其他人明确当前作品的授权条款。
	&#160;&#160;&#160; * 在得到作者的明确允许下，这里的某些条款可以放弃。
	此约定是&#160; 法律文本 (完整的协议)&#160; 的简单易读概要
	&#160;&#160;&#160; 这里的内容不是协议本身，只是一份简单的参考说明，帮助你理解完整的法律文本（完整的协议）。这是一份普通人可以理解的主要条款表达方式。可以认为是一份法律文本的用户友好界面。这里的约定本身并没有法律意义，内容不会出现在真正的许可协议中。 &#8220;创作共用&#8221;组织不是一家法律事务所，不对外提供法律服务。分发、呈现或者链接到这个共用约定不代表建立&#8221;律师&#8212;客户&#8221;这样的关系。
	&#8211;end&#8211;
]]></description>
		<link>http://www.javabloger.com/article/creative-commons.html?source=rss</link>
			</item>
	<item>
		<title>北京`咖啡店`小酒馆`pizza工厂</title>
		<description><![CDATA[走在北京异乡陌生的街头, 往事会在微风中飘散, 才懂得人生的所有快乐和忧伤,
	就在最深处的心坎, 也许是黄昏绚烂的夕阳, 浮现每个孤单夜晚, 
	美丽的后海, 美丽的夜, 美丽的霓虹, 美丽的时光, 美丽的回忆&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;.. 
在咖啡店的小角落&#8230;&#8230;&#8230;&#8230;.我还是研究着我的程序代码. 
	
在pizza 工厂里面体验了新鲜的pizza的味道&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;..我的154Rmb Over了 

pizza工厂里的气氛好好&#8230;&#8230;&#8230;&#8230;

什么什么沙拉的,名字忘记了&#8230;&#8230;&#8230;啊哈哈哈 

小酒店里的 喜力啤酒&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;.我喜欢喜力.有喜力我就不选百威了

一个人潇洒&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;&#8230;..的穿梭在北京的我&#8230;.&#160; 呵呵,我喜欢&#8230;&#8230;.滋润&#8230;.
]]></description>
		<link>http://www.javabloger.com/article/beijing_cafe_bistro_pizza-factory.html?source=rss</link>
			</item>
</channel>
</rss>

