志当存高远,功到自然成!

mysql 5.1支持触发器以及自定义函数接口(UDF)的特性，如果配合libmemcache以及Memcached Functions for MySQL，就能够实现memcache的自动更新。简单记录一下安装测试步骤。

假设我们有3台memcached 服务器,server1 和server2 有3GB 的内存空间,server3 有2GB 的内存空间.
下面程序说明怎么来创建客户端.
import com.danga.MemCached.*;

public class MyClass {

// 创建一个 memcached 客户端对象

protected static MemCachedClient mcc = new MemCachedClient();

// 创建  memcached连接池

static

{  // 指定memcached服务地址 String[] servers =
{ "server1.mydomain.com:1121","server2.mydomain.com:1121",
"server3.mydomain.com:1121" };
// 指定memcached服务器负载量
Integer[]  weights    ={ 3, 3, 2 };
// 从连接池获取一个连接实例

SockIOPool pool = SockIOPool.getInstance();

// 设置服务器和服务器负载量

pool.setServers( servers );

pool.setWeights( weights );

// 设置一些基本的参数

//设置初始连接数5   最小连接数 5   最大连接数 250

//设置一个连接最大空闲时间6小时

pool.setInitConn( 5 );

pool.setMinConn( 5 );

pool.setMaxConn( 250 );

pool.setMaxIdle( 1000 * 60 * 60 * 6 );

// 设置主线程睡眠时间

// 每隔30秒醒来  然后

// 开始维护 连接数大小

pool.setMaintSleep( 30 );

// 设置tcp 相关的树形

// 关闭nagle算法

// 设置 读取 超时3秒钟  set the read timeout to 3 secs

//  不设置连接超时

pool.setNagle( false );

pool.setSocketTO( 3000 );

pool.setSocketConnectTO( 0 );

// 开始初始化 连接池

pool.initialize();

// 设置压缩模式

//如果超过64k压缩数据

mcc.setCompressEnable( true );

mcc.setCompressThreshold( 64 * 1024 );

}

public static void examples() {

mcc.set( "foo", "This is a test String" );

String bar = mcc.get( "foo" );

}

}
MemCachedClient 类 常用的方法说明

创建 client对象 设置参数:

MemCachedClient mc = new MemCachedClient();
//压缩模式
mc.setCompressEnable(true);
// 如果 cache数据 大于4 KB  就启用压缩
mc.setCompressThreshold(4096);
// 基本类型tostring方法
// 通常不需要设置
mc.setPrimitiveAsString(true);
存储一个对象:

MemCachedClient mc = new MemCachedClient();

String key   = "cacheKey1";

Object value = SomeClass.getObject();

mc.set(key, value);
用客户端hashcode 存储一个对象:


MemCachedClient mc = new MemCachedClient();

String key   = "cacheKey1";

Object value = SomeClass.getObject();

Integer hash = new Integer(45);

mc.set(key, value, hash);

set方法：在cache中存储一个指定对象

   add 和replace 方法功能差不多

  add -- 如果不存在 这个key的对象，将会存储一个对象到cache中
  replace --只有当存在指定key对象的时候 会覆盖已有对象
删除一个对象:

MemCachedClient mc = new MemCachedClient();

String key   = "cacheKey1";

mc.delete(key);
结合hashcode 删除一个对象:

MemCachedClient mc = new MemCachedClient();

String key   = "cacheKey1";

Integer hash = new Integer(45);

mc.delete(key, hashCode);
怎么cache计数，增 减计数:

MemCachedClient mc = new MemCachedClient();

String key   = "counterKey";

mc.storeCounter(key, new Integer(100));

System.out.println("counter after adding      1: " mc.incr(key));

System.out.println("counter after adding      5: " mc.incr(key, 5));

System.out.println("counter after subtracting 4: " mc.decr(key, 4));

System.out.println("counter after subtracting 1: " mc.decr(key));
利用客户端的hashcode存储计数 增减 计数:

MemCachedClient mc = new MemCachedClient();

String key   = "counterKey";

Integer hash = new Integer(45);

mc.storeCounter(key, new Integer(100), hash);

System.out.println("counter after adding      1: " mc.incr(key, 1, hash));

System.out.println("counter after adding      5: " mc.incr(key, 5, hash));

System.out.println("counter after subtracting 4: " mc.decr(key, 4, hash));

System.out.println("counter after subtracting 1: " mc.decr(key, 1, hash));
获取一个对象:

MemCachedClient mc = new MemCachedClient();

String key   = "key";

Object value = mc.get(key);
用客户端hashcode获取一个对象:

MemCachedClient mc = new MemCachedClient();

String key   = "key";

Integer hash = new Integer(45);

Object value = mc.get(key, hash);
MemCachedClient mc = new MemCachedClient();

String key   = "key";

Integer hash = new Integer(45);

Object value = mc.get(key, hash);
从cache 中获取多个对象

MemCachedClient mc = new MemCachedClient();

String[] keys      ={ "key", "key1", "key2" };Mapvalues = mc.getMulti(keys);
用客户端hashcode 从cache中获取多个对象
MemCachedClient mc = new MemCachedClient();
String[] keys      = { "key", "key1", "key2" };

Integer[] hashes   =
{ new Integer(45), new Integer(32), new Integer(44) };
Mapvalues = mc.getMulti(keys, hashes);
清空所有的对象
MemCachedClient mc = new MemCachedClient();

mc.flushAll();
得到服务器memcached的状态信息
MemCachedClient mc = new MemCachedClient();

Map stats = mc.stats();
注意点
1：Failover/Failback
当一个memcached服务器失效的时候客户端默认会failover另一个服务去.

如果失效的服务器 恢复运行，客户端会返回到原来连接的服务器.
如果你不想用这个功能 设置下面的参数
pool.setFailover( false );
pool.setFailback( false );

2：序列化

Boolean
Byte
String
Character
StringBuffer
StringBuilder
Short
Long
Double
Float
Date
java默认的类型没有实现序列化 可以设置
mcc.setPrimitiveAsString( true )替代.
Meetup.com实践过程中得出的一个经验 ，项目中model 对象implement Externalizable 实现序列化，
可以节省cache 对象的大小。从而节省网络带宽和内存空间。

一：硬架构

1 ：机房的选择：

在 选择机房的时候，根据网站用户的地域分布，可以选择网通或电信机房，但更多时候，可能双线机房才是合适的。越大的城市，机房价格越贵，从成本的角度看可以 在一些中小城市托管服务器，比如说广州的公司可以考虑把服务器托管在东莞，佛山等地，不是特别远，但是价格会便宜很多。

2 ：带宽的大小：

通常老板花钱请我们架构网站的时候，会给我们提出一些目标，诸如网站每天要能承受100 万PV 的访问量等等。这时我们要预算一下大概需要多大的带宽，计算带宽大小主要涉及两个指标（峰值流量和页面大小），我们不妨在计算前先做出必要的假设：

第一：假设峰值流量是平均流量的5 倍。
第二：假设每次访问平均的页面大小是100K 字节左右。

如果100 万PV 的访问量在一天内平均分布的话，折合到每秒大约12 次访问，如果按平均每次访问页面的大小是100K 字节左右计算的话，这12 次访 问总计大约就是1200K 字节，字节的单位是Byte ，而带宽的单位是bit ，它们之间的关系是1Byte = 8bit ，所以1200K Byte 大致就相当于9600K bit ，也就是9Mbps 的样子，实际情况中，我们的网站必须能在峰值流量时保持正常访问，所以按照假设的峰值流量算，真实带宽的需求应该在45Mbps  左右。

当然，这个结论是建立在前面提到的两点假设的基础上，如果你的实际情况和这两点假设有出入，那么结果也会有差别。

3 ：服务器的划分：

先看我们都需要哪些服务器：图片服务器，页面服务器，数据库服务器，应用服务器，日志服务器等等。

对于访问量大点的网站而言，分离单独的图片服务器和页面服务器相当必要，我们可以用lighttpd 来跑图片服务器，用apache 来跑页面服务 器，当然也可以选择别的，甚至，我们可以扩展成很多台图片服务器和很多台页面服务器，并设置相关域名，如img.domain.com 和 www.domain.com ，页面里的图片路径都使用绝对路径，如<img src="http://img.domain.com/abc.gif" /> ，然后设置DNS 轮循，达到最初级的负载均衡。当然，服务器多了就不可避免的涉及一个同步的问题，这个可以使用rsync 软件来搞定。

数据库服务器是重中之重，因为网站的瓶颈问题十有八九是出在数据库身上。现在一般的中小网站多使用MySQL 数据库，不过它的集群功能似乎还没有达 到stable 的阶段，所以这里不做评价。一般而言，使用MySQL 数据库的时候，我们应该搞一个主从（一主多从）结构，主数据库服务器使用innodb  表结构，从数据服务器使用myisam 表结构，充分发挥它们各自的优势，而且这样的主从结构分离了读写操作，降低了读操作的压力，甚至我们还可以设定一个专门的从服务器做备份服务器，方便备份。不然如果你只有一台主服务器，在大数据量的情况下，mysqldump 基本就没戏了，直接拷贝数据文件的话，还得先停止数据库服务再拷贝，否则备份文件会出错。但对于很多网站而言，即使数据库服务仅停止了一秒也是不可接受的。如果你有了一台从数据库服务器，在备份数 据的时候，可以先停止服务（slave stop ）再备份，再启动服务（slave start ）后从服务器会自动从主服务器同步数据，一切都没有影响。但是主从结构也是有致命缺点的，那就是主从结构只是降低了读操作的压力，却不能降低写操作的压力。为了适应更大的规模，可能只剩下最后这招了：横向/ 纵向分割数据库。所谓横向分割数据库，就是把不同的表保存到不同的数据库服务器上，比如说用户表保存在A 数据库服务器上，文章表保存在B 数据库服务器上，当然这样的分割是有代价的，最基本的就是你没法进行LEFT JOIN 之类的操作了。所谓纵向分割数据库，一般是指按照用户标识（user_id ）等来划分数据存储的服务器，比如说：我们有5 台数据库服务器，那么 “user_id % 5 + 1” 等于1 的就保存到1 号服务器，等于2 的就保存到2 好服务器，以此类推，纵向分隔的原则有很多种，可以视情况选择。不过和横向分割数据库一样，纵向分割 数据库也是有代价的，最基本的就是我们在进行如COUNT, SUM 等汇总操作的时候会麻烦很多。综上所述，数据库服务器的解决方案一般视情况往往是一个混合的方案，以其发挥各种方案的优势，有时候还需要借助 memcached 之类的第三方软件，以便适应更大访问量的要求。

如果有专门的应用服务器来跑PHP 脚本是最合适不过的了，那样我们的页面服务器只保存静态页面就可以了，可以给应用服务器设置一些诸如 app.domain.com 之类的域名来和页面服务器加以区别。对于应用服务器，我还是更倾向于使用prefork 模式的apache ，配上必要的 xcache 之类的PHP 缓存软件，加载模块要越少越好，除了mod_rewrite 等必要的模块，不必要的东西统统舍弃，尽量减少httpd 进程的内存消耗，而那些图片服务器，页面服务器等静态内容就可以使用lighttpd 或者tux 来搞，充分发挥各种服务器的特点。

如果条件允许，独立的日志服务器也是必要的，一般小网站的做法都是把页面服务器和日志服务器合二为一了，在凌晨访问量不大的时候cron 运行前一天 的日志计算，不过如果你使用awstats 之类的日志分析软件，对于百万级访问量而言，即使按天归档，也会消耗很多时间和服务器资源去计算，所以分离单独的日志服务器还是有好处的，这样不会影响正式服务器的工作状态。

二：软架构

1 ：框架的选择：

现在的PHP 框架有很多选择，比如：CakePHP ，Symfony ，Zend Framework 等等，至于应该使用哪一个并没有唯一的答案，要根据Team 里团队成员对各个框架的了解程度而定。很多时候，即使没有使用框架，一样能写出好的程序来，比如Flickr 据说就是用Pear+Smarty 这样的类库写出来的，所以是否用框架，用什么框架，一般不是最重要，重要的是我们的编程思想里要有框架的意识。

现在的.NET 框架有很多选择，比如：cnForums ，.text ，cs, Castle, 等等

2 ：逻辑的分层：

网站规模到了一定的程度之后，代码里各种逻辑纠缠在一起，会给维护和扩展带来巨大的障碍，这时我们的解决方式其实很简单，那就是重构，将逻辑进行分层。通常，自上而下可以分为表现层，应用层，领域层，持久层。

所 谓表现层，并不仅仅就指模板，它的范围要更广一些，所有和表现相关的逻辑都应该被纳入表现层的范畴。比如说某处的字体要显示为红色，某处的开头要空两格， 这些都属于表现层。很多时候，我们容易犯的错误就是把本属于表现层的逻辑放到了其他层面去完成，这里说一个很常见的例子：我们在列表页显示文章标题的时 候，都会设定一个最大字数，一旦标题长度超过了这个限制，就截断，并在后面显示“..” ，这就是最典型的表现层逻辑，但是实际情况，有很多程序员都是在非表现层代码里完成数据的获取和截断，然后赋值给表现层模板，这样的代码最直接的缺点就是同样一段数据，在这个页面我可能想显示前10 个字，再另一个 页面我可能想显示前15 个字，而一旦我们在程序里固化了这个字数，也就丧失了可移植性。正确的做法是应该做一个视图助手之类的程序来专门处理此类逻辑，比如说：Smarty 里的truncate 就属于这样的视图助手（不过它那个实现不适合中文）。

所谓应用层，它的主要作用是定义用户可以做什么，并把操作结果反馈给表现层。至于如何做，通常不是它的职责范围（而是领域层的职责范围），它会通过委派把如何做的工作交给领域层去处理。在使用MVC 架构的网站中，我们可以看到类似下面这样的URL ：domain.com/articles/view/123 ，其内部编码实现，一般就是一个Articles 控制器类，里面有一个view 方法，这就是一 个典型的应用层操作，因为它定义了用户可以做一个查看的动作。在MVC 架构中，有一个准则是这么说的：Rich Model Is Good 。言外之意，就是Controller 要保持“ 瘦” 一些比较好，进而说明应用层要尽量简单，不要包括涉及领域内容的逻辑。

所谓领域层，最直接的解释就是包含领域逻辑的层。它是一个软件的灵魂所在。先来看看什么叫领域逻辑，简单的说，具有明确的领域概念的逻辑就是领域逻辑，比如我们在ATM 机上取钱，过程大致是这样的：插入银联卡，输入密码，输入取款金额，确定，拿钱，然后ATM 吐出一个交易凭条。在这个过程中，银联卡 在ATM 机器里完成钱从帐户上划拨的过程就是一个领域逻辑，因为取钱在银行中是一个明确的领域概念，而ATM 机吐出一个交易凭条则不是领域逻辑，而仅是一 个应用逻辑，因为吐出交易凭条并不是银行中一个明确的领域概念，只是一种技术手段，对应的，我们取钱后不吐交易凭条，而发送一条提醒短信也是可能的，但并 不是一定如此，如果在实际情况中，我们要求取款后必须吐出交易凭条，也就是说吐出交易凭条已经和取款紧密结合，那么你也可以把吐出交易凭条看作是领域逻辑 的一部分，一切都以问题的具体情况而定。在Eric 那本经典的领域驱动设计中，把领域层分为了五种基本元素：实体，值对象，服务，工厂，仓储。具体可以参 阅书中的介绍。领域层最常犯的错误就是把本应属于领域层的逻辑泄露到了其他层次，比如说在一个CMS 系统，对热门文章的定义是这样的：每天被浏览的次数多 于1000 次，被评论的次数多于100 次，这样的文章就是热门文章。对于一个CMS 来说，热门文章这个词无疑是一个重要的领域概念，那么我们如何实现这个逻辑的设计的？你可能会给出类似下面的代码：“SELECT ... FROM ... WHERE  浏览 > 1000 AND  评论 > 100” ，没错，这是最简单的实现方式，但是这里需要注意的是“ 每天被浏览的次数多于1000 次，被评论的次数多于100 次” 这个重要的领域逻辑被隐藏到了SQL 语句中，SQL 语句显然不属于领域层的范畴，也就是说，我们的领域逻辑泄露了。

所谓持久层，就是指把我们的领域模型保存到数据库中。因为我们的程序代码是面向对象风格的，而数据库一般是关系型的数据库，所以我们需要把领域模型 碾平，才能保存到数据库中，但是在 PHP 里，直到目前还没有非常好的 ORM 出现，所以这方面的解决方案不是特别多，参考 Martin 的企业应用架构模式一   书，大致可以使用的方法有行数据入口（ Row Data Gateway ）或者表数据入口（ Table Data Gateway），或者把领域层和持久层合二为一变成活动记录（Active Record）的方式。

TOMCAT崩溃事件

http://www.blogjava.net/tedeyang/archive/2008/06/04/205740.html

今天一大早产品一部项目经理就来找我，他们的一台服务器昨天晚上tomcat服务崩溃，还不能重启服务，最后将服务器重启才OK。
我将事件过程和分析过程记录如下：

服务器：win 2000 sp4，apache 2 + tomcat 5.0 采用mod_jk级联。内存2G，硬盘剩余空间充足，CPU基本空闲。
主要应用：J2EE 1.4，JDBC（连接另一台mysql服务器）
崩溃时间： 2008-6-3 18：37：50

一.各种日志综合如下：

   1.37分45秒，操作系统事件中诺顿杀毒软件报内存过低警报
   2.37分45秒，web应用抛出JDBC连接异常：

   3.37分50秒，tomcat抛出session无法save异常：

 

二.简单分析

崩溃原因：内存不足导致资源不足，引起Tomcat的session崩溃。
  这台服务器上运行着很多应用，是什么原因引起内存不足还无法确定。
初步判断罪魁祸首可能是apache，该进程平常占用500MB内存，经常会飚到1G以上。

Apache2的配置文件中：KeepAlive=On，MaxKeepAliveRequests=100，KeepAliveTimeout=15，分析aceess.log文件可以发现每个页面触发的request数量在10个以下，点击率较低，可能使连接过多。
我建议将keepAlive设为off，增加CPU负载，降低内存消耗。

三.效果

 有待观察......

参考资料：
http://www.withend.com/post/78.html

四.结局 
时隔一天，晚上九点再次崩溃，黑暗事件重演。
这一次，我才得知原来该apache还配置有其他域名，于是调出该域名下的access.log。项目经理去了机房，在轰轰地风扇声中打电话给我，让我分析分析。
仔细看访问日志，发现原来有N多Connect 443连接，443是什么？是SSL端口！HTTPS！，Connect命令则显然是代理功能！
而且这些connect的IP来自全球各地，加拿大、美国、澳洲、新西兰、北京、上海、英国、哪都有。
看来这台服务器是被人当代理服务器用了。
怪不得半夜会死机，人家西半球那时正大白天撒欢儿呢。

问题就出在apache的配置上，由于应用众多，并且这台服务器还是其他几台web服务器的对外出口，因此apache中配置了反向代理，不过不小心把正向代理（mod_proxy模块的ProxyRequests指令）也打开了。
看看apache2.0的官方文档中mod_proxy部分，里面明明白白写着：

分布式缓存系统Memcached简介与实践

http://blog.csdn.net/hitman9099/archive/2008/09/04/2878417.aspx

 

缘起: 在数据驱动的web开发中，经常要重复从数据库中取出相同的数据，这种重复极大的增加了数据库负载。缓存是解决这个问题的好办法。但是ASP.NET中的虽然已经可以实现对页面局部进行缓存，但还是不够灵活。此时Memcached或许是你想要的。

Memcached是什么?
Memcached是由Danga Interactive开发的，高性能的，分布式的内存对象缓存系统，用于在动态应用中减少数据库负载，提升访问速度。

Memcached能缓存什么？
通过在内存里维护一个统一的巨大的hash表，Memcached能够用来存储各种格式的数据，包括图像、视频、文件以及数据库检索的结果等。

Memcached快么？

非 常快。Memcached使用了libevent（如果可以的话，在linux下使用epoll）来均衡任何数量的打开链接，使用非阻塞的网络I/O，对 内部对象实现引用计数(因此，针对多样的客户端，对象可以处在多样的状态)， 使用自己的页块分配器和哈希表， 因此虚拟内存不会产生碎片并且虚拟内存分配的时间复杂度可以保证为O(1).。

Danga Interactive为提升Danga Interactive的速度研发了Memcached。目前，LiveJournal.com每天已经在向一百万用户提供多达两千万次的页面访问。而这 些，是由一个由web服务器和数据库服务器组成的集群完成的。Memcached几乎完全放弃了任何数据都从数据库读取的方式，同时，它还缩短了用户查看 页面的速度、更好的资源分配方式，以及Memcache失效时对数据库的访问速度。

Memcached的特点
Memcached的缓存是一种分布式的，可以让不同主机上的多个用户同时访问， 因此解决了共享内存只能单机应用的局限，更不会出现使用数据库做类似事情的时候，磁盘开销和阻塞的发生。

Memcached的使用 
一 Memcached服务器端的安装 （此处将其作为系统服务安装）
下载文件：memcached 1.2.1 for Win32 binaries (Dec 23, 2006)
    1 解压缩文件到c:\memcached
   2 命令行输入 'c:\memcached\memcached.exe -d install' 
    3 命令行输入 'c:\memcached\memcached.exe -d start' ，该命令启动 Memcached ，默认监听端口为 11211
通过 memcached.exe -h 可以查看其帮助

 

一个简单的测试例子

其中在classespath下有个memcached.properties文件

内容如下：

##muti servers spilt by ,

#这里是你的memcached启动的地址
cache.servers=192.168.0.116:11211  
cache.weights=1
#memcached be used
cache.cluster=true

#set some basic pool settings       
#5 initial, 5 min, and 250 max conns       
#and set the max idle time for a conn       
#to 6 hours  6*60*60*1000
cache.initConn=5
cache.minConn=5
cache.maxConn=250
cache.maxIdle=21600000

 

 

 

 

在Windows下安装Memcached

http://www.oschina.net/docs/article/4

很多phper不知道如何在Windows下搭建Memcache的开发调试环境，最近个人也在研究Memcache，记录下自己安装搭建的过程。
其实我开始研究Memcache的时候并不知道居然还有memcached for Win32这个鸟东西，害得我在CnetOS下折腾1天才搞定，今天突然发现Windows下的Memcache进行开发调试完全没有问题，所以写篇 Memcache的文档分享给大家。

Windows下的Memcache安装：
1. 下载memcache的 windows稳定版，解压放某个盘下面，比如在c:\memcached
2. 在终端（也即cmd命令界面）下输入 ‘c:\memcached\memcached.exe -d install’ 安装
3. 再输入： ‘c:\memcached\memcached.exe -d start’ 启动。NOTE: 以后memcached将作为windows的一个服务每次开机时自动启动。这样服务器端已经安装完毕了。
4.下载php_memcache.dll， 请自己查找对应的php版本的文件
5. 在C:\winnt\php.ini 加入一行 ‘extension=php_memcache.dll’
6.重新启动Apache，然后查看一下phpinfo，如果有memcache，那么就说明安装成功！

memcached的基本设置：

-p 监听的端口
-l 连接的IP地址, 默认是本机
-d start 启动memcached服务
-d restart 重起memcached服务
-d stop|shutdown 关闭正在运行的memcached服务
-d install 安装memcached服务
-d uninstall 卸载memcached服务
-u 以的身份运行 (仅在以root运行的时候有效)
-m 最大内存使用，单位MB。默认64MB
-M 内存耗尽时返回错误，而不是删除项
-c 最大同时连接数，默认是1024
-f 块大小增长因子，默认是1.25
-n 最小分配空间，key+value+flags默认是48
-h 显示帮助

Memcache环境测试：
运行下面的php文件，如果有输出This is a test!，就表示环境搭建成功。开始领略Memcache的魅力把！
< ?php
$mem = new Memcache;
$mem->connect(”127.0.0.1″, 11211);
$mem->set(’key’, ‘This is a test!’, 0, 60);
$val = $mem->get(’key’);
echo $val;
?>

转载：http://www.blogjava.net/cnfree/archive/2008/06/12/207343.html

最近的项目需要使用报表，因为是RCP应用，所以选择了Birt，用了一下，感觉还可以，就是网上资料少了点，不过以前也研究过一些Eclipse相关技术，这些都不重要了，找了SDK版本Debug，啥研究不出来？

BIRT是一个Eclipse-based开放源代码报表系统。它主要是用在基于Java与J2EE的Web应用程序上。BIRT主要由两部分组成：一个是基于Eclipse的报表设计和一个可以加到你应用服务的运行期组件。BIRT同时也提供一个图形报表制作引擎。

官方主页：http://www.eclipse.org/birt
官方BBS支持：http://www.actuatechina.com/forum2.html

基本上来说Birt功能还是很强大的，支持时下比较流行的WebService，Ajax技术，既可用于Web，也可以用于桌面，更新也算稳定，基本上遵循Eclipse的开发步骤，一个一个大版本，同时支持脚本调用，debug开发等等。唯一不足的就是中国的国情支持得还不够完善，毕竟中国比较特殊，我以前给公司做党务报表，要按照纸质报表画，一分一毫都不能变差，那个变态呀，在电脑上画报表还是拿尺子量。

刚刚开始用，慢慢研究，看了下Birt自带的Example，的确是很强大，做得也很漂亮，自己试着创建一个报表也很简单，希望能够比较快的上手吧。

在网上找了一些资源：
http://blogger.org.cn/blog/more.asp?name=sixsun&id=13933 BIRT 中文指南
http://www.springside.org.cn/docs/reference/Birt.htm BIRT报表
http://www-128.ibm.com/developerworks/cn/opensource/os-ecl-birt/ Birt的IBM DW的中文教程
http://download.eclipse.org/birt/downloads/demos/FirstReport/MyFirstReport.html Birt Flash Demo.

 

我们公司为每一个新进来的员工指派了一个导师。这让我想起了原来听过的微软培训，现简单的归纳了几条，放上来供大家讨论。

１、首先微软的导师选择不是领导行政上指定的，而是学生选择导师。
    在这里微软强调的是：牛人才能成为导师。公司的人力资源系统有一模块会把导师的特长列出来，以及原来被选择为导师的次数，还有历界学生对其的评价。

    如果是新员工的话，基础的流程常识之类的有培训，具体到某一方面的技术的话，可以由你的上级指导你选择。

２、不是新人才能选择导师，当你换岗，换项目，反正对某个领域是新的时候，都可以选择导师

３、导师不会天天指导你，帮助你制定培训计划。因为导师的时间比你的时间宝贵的多

方法是：

　　　１）学习、提高等等的计划由你自己来完成。

　　　２）导师可以在邮件上花几分钟给你指导一下。

　　　３）导师可以在某个有空地时间找你谈谈（或你约导师），但多是你请导师吃饭的时候。这样饭也吃了，导师也当了。

４、（注意是大点）导师指导你，对他是有好处的......

　　　１）提高影响力（微软最注意的一点）　

　　　２）有了影响为，才有绩效吧。

　　　３）有了影响力，以后的新人才会选择你吧，以后的新人选择你的越多，多到你的档期安排不过来，这才更牛吧！

 

５、这对企业文化也有好处。

　　１）文化影响共享，比强制，指派更有效些。　

　　２）对新人、旧人都好，不会出现你有难，十方都会，但都不支援你的情况

　　３）不会出现研究成果，只保存在某个人的头脑里的情况。节省资源

    特别说明：这种考核对导师不考核。因为是他导的作用，不是师的作用。师的考核是看他被选择的次数，学生对他的评价。这更客观，真实。

在JAVA中，有六个不同的地方可以存储数据：
1. 寄存器（register）。这是最快的存储区，因为它位于不同于其他存储区的地方——处理器内部。但是寄存器的数量极其有限，所以寄存器由编译器根据需求进行分配。你不能直接控制，也不能在程序中感觉到寄存器存在的任何迹象。
2. 堆栈（stack）。位于通用RAM中，但通过它的“堆栈指针”可以从处理器哪里获得支持。堆栈指针若向下移动，则分配新的内存；若向上移动，则释放那些内存。这是一种快速有效的分配存储方法，仅次于寄存器。创建程序时候，JAVA编译器必须知道存储在堆栈内所有数据的确切大小和生命周期，因为它必须生成相应的代码，以便上下移动堆栈指针。这一约束限制了程序的灵活性，所以虽然某些JAVA数据存储在堆栈中——特别是对象引用，但是JAVA对象不存储其中。
3. 堆（heap）。一种通用性的内存池（也存在于RAM中），用于存放所以的JAVA对 象。堆不同于堆栈的好处是：编译器不需要知道要从堆里分配多少存储区域，也不必知道存储的数据在堆里存活多长时间。因此，在堆里分配存储有很大的灵活性。 当你需要创建一个对象的时候，只需要new写一行简单的代码，当执行这行代码时，会自动在堆里进行存储分配。当然，为这种灵活性必须要付出相应的代码。用 堆进行存储分配比用堆栈进行存储存储需要更多的时间。
4. 静态存储（static storage）。这里的“静态”是指“在固定的位置”。静态存储里存放程序运行时一直存在的数据。你可用关键字static来标识一个对象的特定元素是静态的，但JAVA对象本身从来不会存放在静态存储空间里。
5. 常量存储（constant storage）。常量值通常直接存放在程序代码内部，这样做是安全的，因为它们永远不会被改变。有时，在嵌入式系统中，常量本身会和其他部分分割离开，所以在这种情况下，可以选择将其放在ROM中
6. 非RAM存储。如果数据完全存活于程序之外，那么它可以不受程序的任何控制，在程序没有运行时也可以存在。
就速度来说，有如下关系：
    寄存器 < 堆栈 < 堆 < 其他

『上面这段话摘取之《Thinking in Java》』

在这里，主要要说下堆与堆栈的关系：

      堆：堆是heap，是所谓的动态内存，其中的内存在不需要时可以回收，以分配给新的内存请求，其内存中的数据是无序的，即先分配的和随后分配的内存并没有 什么必然的位置关系，释放时也可以没有先后顺序。一般由使用者自由分配，malloc分配的就是堆，需要手动释放。

      堆栈:就是STACK。实际上是只有一个出入口的队列，即后进先出（First     In     Last     Out），先分配的内存必定后释放。一般由，由系统自动分配，存放存放函数的参数值，局部变量等，自动清除。

还有，堆是全局的，堆栈是每个函数进入的时候分一小块，函数返回的时候就释放了，静态和全局变量，new     得到的变量，都放在堆中，局部变量放在堆栈中，所以函数返回，局部变量就全没了。

其实在实际应用中，堆栈多用来存储方法的调用。而对则用于对象的存储。

       JAVA中的基本类型，其实需要特殊对待。因为，在JAVA中，通过new创建的对象存储在“堆”中，所以用new 创建一个小的、简单的变量，如基本类型等，往往不是很有效。因此，在JAVA中，对于这些类型，采用了与C、C++相同的方法。也就是说，不用new 来创建，而是创建一个并非是“引用”的“自动”变量。这个变量拥有它的“值”，并置于堆栈中，因此更高效。