• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

animals = ['lion','tiger', 'bear']
animals.each {|animal| puts animal }

public interface OnEach<T> {
  void run(T obj);
}
public interface List<T> ... {
  void each( OnEach<T> action );
}

List<String> animals = Arrays.asList( new String[]{"lion", "tiger", "bear"} );
animals.each( new OnEach<String>() {
 public void run( String animal ) {
  System.out.println(animal);
 }
});

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛

学习Ext的过程中 完成一个数据库浏览工具——DBExplorer。基于JDBC连接各种数据库：支持sql语句执行，支持数据浏览和修改，支持LOB数据的查看、下载和修改，支持数据导出等功能。

更多细节内容可以在 http://jdbexplorer.googlecode.com 进一步了解。

其它的就不多说啦，贴几张图看看：

• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师

常常看到论坛上有人讨论PP（Pair Programming）,但是大多是纸上谈兵，书上云的过多。真正谈感受的少。 我在一家做XP的公司做了4年了，从做service到做product, 总的来说pair programming给我带来的的忧大于喜，缺点大于有点。

总的来说PP有它的优点，很多researcher也发表了论文，记得比较清楚的一片就是一个大学里面对一个班的学生分组实验，结果用PP的那组效率比较高。 但这毕竟是research, 给我们的启示是PP在某种特定的情况下的结果:

1. Pair的人必须对等 （同班同学）

2. Pair的人必须全力以赴 (同学们，老师在做实验哦，不要走神！)

3. Pair的人必须对要解决的问题有相同（或相近）的认知

而上面的3点在现实公司里却大部分情况下不能成立。1就不用说了，2，举个例子，如果有一个人生病，或是惦记的其他的事则会screw up整天的进度。3，和1相关，人的水平不同，不可能像大学那样对一个东西的认知近似。

我个人的经验是10%的pair时间是高效的pair，其余的则是浪费时间 。

另外从人性的角度来讲，pair on everything则是对人性的强奸 ，强调沟通没有错误，但是工作毕竟是工作，如果天到晚说比写花的时间更多，则有点本末倒置了。我们公司是100% pair, 任何的task，不管有没有必要，都要pair （条件允许的话）, 老板的原则是绝不让任何一个知识点停留在一个人的脑瓜里：）,一个人躺下了，另一个就能补上。 但是从现实的角度来讲，我们的产品的确出现过超过一个developer走了，结果他们经常working的那个module就会没有人能够维护了，结果需要重写。 所以从knowlege spread的角度来说，公司的benifit和情感留人+document, 比pair来的更实惠。

另外pair的确剥夺了developer的个人空间 。 以前的公司， 上网灌水，给朋友 MSN, 的小动作全都不行了：（， 也许有人会说这些的东西在公司应该禁止！ 但是现实一点，我来java eye灌水 ， 跟几个圈内的朋友msn讨论心得，是对工作有正面影响的。 而且msn的圈内朋友对于疑难问题的帮助会很大的。

而且还有一点最大的就是pair剥夺了自学的时间 ， 没有pair的时候当有东西不会的时候， 对一个问题的研究会刨根结底，但是pair的时候，如果你的partner会，他大概只会给你概括一下，如果你的partner不会，那就会是一个非常有趣的pairing session, 什么google, yahoo, 大部分情况，结果是 this is a fking task that we should never touch as we dont have corrosponding knowlege... 但是如果一个人能够静下心来把问题的来龙去脉搞清楚，把相应的prerequiste的knowlege搞清楚， 问题在得到解决的同时，自己也会得到提高。说白了当两个新手在pair的时候的确很低效，而且不利于“成长”

说了这么多， 一句话

少Pair可以怡神，多pair的确伤身， 不pair也能过日子 。

• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

package com.danga.MemCached.test;    
   
import java.util.Date;    
   
import com.danga.MemCached.MemCachedClient;    
import com.danga.MemCached.SockIOPool;    
   
   
public class Test {        
    protected static MemCachedClient mcc = new MemCachedClient();       
       
    static {       
        String[] servers ={"192.168.40.4:12000"};       
       
        Integer[] weights = { 3 };       
       
        //创建一个实例对象SockIOPool     
        SockIOPool pool = SockIOPool.getInstance();       
       
        // set the servers and the weights    
        //设置Memcached Server    
        pool.setServers( servers );       
        pool.setWeights( weights );       
       
        // 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       
        pool.setInitConn( 5 );       
        pool.setMinConn( 5 );       
        pool.setMaxConn( 250 );       
        pool.setMaxIdle( 1000 * 60 * 60 * 6 );       
       
        // set the sleep for the maint thread       
        // it will wake up every x seconds and       
        // maintain the pool size       
        pool.setMaintSleep( 30 );       
       
        // Tcp的规则就是在发送一个包之前，本地机器会等待远程主机    
                  // 对上一次发送的包的确认信息到来；这个方法就可以关闭套接字的缓存，    
                  // 以至这个包准备好了就发；    
                  pool.setNagle( false );       
        //连接建立后对超时的控制    
                  pool.setSocketTO( 3000 );    
        //连接建立时对超时的控制    
                  pool.setSocketConnectTO( 0 );       
       
        // initialize the connection pool       
        //初始化一些值并与MemcachedServer段建立连接    
                  pool.initialize();    
               
       
        // lets set some compression on for the client       
        // compress anything larger than 64k       
        mcc.setCompressEnable( true );       
        mcc.setCompressThreshold( 64 * 1024 );       
    }       
           
    public static void bulidCache(){       
        //set(key,value,Date) ,Date是一个过期时间，如果想让这个过期时间生效的话，这里传递的new Date(long date) 中参数date，需要是个大于或等于1000的值。    
        //因为java client的实现源码里是这样实现的 expiry.getTime() / 1000 ，也就是说，如果 小于1000的值，除以1000以后都是0，即永不过期    
        mcc.set( "test", "This is a test String" ,new Date(11211));   
    //十秒后过期    
              
    }       
      
    public static void output() {       
        //从cache里取值    
        String value = (String) mcc.get( "test" );       
        System.out.println(value);        
    }       
           
    public static void main(String[] args){       
        bulidCache();      
        output();           
    }     
       
}       

• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛

1 资料

• JDK5.0垃圾收集优化之--Don't Pause(花钱的年华)  
• 编写对GC友好，又不泄漏的代码(花钱的年华)  
• JVM调优总结  
• JDK 6所有选项及默认值  

2 GC日志打印

  GC调优是个很实验很伽利略的活儿，GC日志是先决的数据参考和最终验证：

-XX:+PrintGCDetails -XX:+PrintGCTimeStamps(GC发生的时间) -XX:+PrintGCApplicationStoppedTime(GC消耗了多少时间) -XX:+PrintGCApplicationConcurrentTime(GC之间运行了多少时间)

3 收集器选择

CMS收集器：暂停时间优先

   配置参数：-XX:+UseConcMarkSweepGC
   已默认无需配置的参数：-XX:+UseParNewGC(Parallel收集新生代) -XX:+CMSPermGenSweepingEnabled(CMS收集持久代) -XX:UseCMSCompactAtFullCollection(full gc时压缩年老代)

   初始效果：1g堆内存的新生代约60m，minor gc约5-20毫秒，full gc约130毫秒。

Parallel收集器：吞吐量优先

    配置参数： -XX:+UseParallelGC -XX:+UseParallelOldGC(Parallel收集年老代，从JDK6.0开始支持)

    已默认无需配置的参数： -XX:+UseAdaptiveSizePolicy(动态调整新生代大小)

    初始效果：1g堆内存的新生代约90-110m(动态调整)，minor gc约5-20毫秒，full gc有无UseParallelOldGC 参数分别为1.3/1.1秒，差别不大。

    另外-XX:MaxGCPauseMillis=100 设置minor gc的期望最大时间，JVM会以此来调整新生代的大小，但在此测试环境中对象死的太快，此参数作用不大。

4 调优实战

      Parallel收集高达1秒的暂停时间基本不可忍受，所以选择CMS收集器。

      在被压测的Mule 2.0应用里，每秒都有大约400M的海量短命对象产生：

1. 因为默认60M的新生代太小了，频繁发生minor gc，大约0.2秒就进行一次。
2. 因为CMS收集器中MaxTenuringThreshold(生代对象撑过过多少次minor gc才进入年老代的设置)默认0，存活的临时对象不经过Survivor区直接进入年老代，不久就占满年老代发生full gc。

     对这两个参数的调优，既要改善上面两种情况，又要避免新生代过大，复制次数过多造成minor gc的暂停时间过长。

1. 使用-Xmn调到1/3 总内存。观察后设置-Xmn500M，新生代实际约460m。(用-XX:NewRatio设置无效，只能用 -Xmn)。
2. 添加-XX:+PrintTenuringDistribution 参数观察各个Age的对象总大小，观察后设置-XX:MaxTenuringThreshold=5。

      优化后，大约1.1秒才发生一次minor gc，且速度依然保持在15-20ms之间。同时年老代的增长速度大大减缓，很久才发生一次full gc，

      参数定稿：

 -server -Xms1024m -Xmx1024m -Xmn500m -XX:+UseConcMarkSweepGC   -XX:MaxTenuringThreshold=5  -XX:+ExplicitGCInvokesConcurrent

      最后服务处理速度从1180 tps 上升到1380 tps，调整两个参数提升17%的性能还是笔很划算的买卖。

     另外，JDK6 Update 7自带了一个VisualVM工具，内里就是之前也有用过的Netbean Profiler，类似JConsole一样使用，可以看到线程状态，内存中对象以及方法的CPU时间等调优重要参考依据。免费捆绑啊，Sun 这样搞法，其他做Profiler的公司要关门了。

• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

 注意这里的id不要写成content，貌似是由于命名冲突的原因 
<input type="hidden" id="content1" name="content" value=""></input> 
注意这里要把上面的隐藏域的id穿给编辑器的iframe
 <iframe id="myEditor" src="/editor/editor.htm?id=content1" frameborder="0" scrolling="no" width="550" height="220"></iframe>

再附上一段js校验编辑器内容不为空的代码
var content = myEditor.getHTML().replace(/<.*?>/g,"").split(" ").join("").split(" ").join("");
if(content.length==0){
        alert('公告内容不能为空！');
        return false;
    }

class Front::EditorsController < ApplicationController
  skip_before_filter :verify_authenticity_token
  # 上传图片
  def upload_editor_image
    file = params[:imgfile]
    filename = params[:imgfile].original_filename.split('.').reverse  
    filename = Time.now.strftime("%Y%m%d%H%M%S")  + rand(10000).to_s + "." + filename[0]  
    File.open("#{File.expand_path(RAILS_ROOT)}/public/upload/editor_image/#{filename}", "wb") do |f|   
      f.write(file.read)        
    end      
    render :text => "<script>window.parent.LoadIMG('/upload/editor_image/#{filename}')</script>"
  rescue
    render :text => "<script>window.parent.alert('您上传的图片无效或者损坏！');window.parent.divProcessing.style.display='none'; </script>"
  end
  
  # 上传附件
  def upload_editor_attach
    file = params[:attach]
    filename = params[:attach].original_filename.split('.').reverse  
    filename = Time.now.strftime("%Y%m%d%H%M%S") + rand(10000).to_s + "." + filename[0]  
    File.open("#{File.expand_path(RAILS_ROOT)}/public/upload/editor_attach/#{filename}", "wb") do |f|   
      f.write(file.read)        
    end      
    render :text => "<script>window.parent.LoadAttach('/upload/editor_attach/#{filename}')</script>"
  rescue
    render :text => "<script>window.parent.alert('您上传的附件无效或者损坏！');window.parent.divProcessing.style.display='none'; </script>"
  end
  
  def download_attach
    send_file params[:path]
  rescue
    render :text => "对不起，改附件已经损坏，无法下载！"
  end
end

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛

      简单来说，个性化主页就是结合了各种小模块和网络信息的个人主页。与传统网站的区别是：用户可以非常自由地控制其内容（通过RSS，email等等），内容会更适合用户口味并且使用查看也非常方便，由于有了ajax技术，所以更像是一个桌面软件。例如http://www.netvibes.com/就提供了比较酷的个性化主页服务。
总的来说主要有以下几个特点：

1 页面中的内容是一个个小模块，其内容来自于其他站点或者服务 

2 用户可以根据自己的喜好通过拖拽随意摆放这些小模块

3 用户可以添加自己感兴趣的小模块

4  用户可以删除任意已添加的小模块

5 用户可以改变自己的页面风格以及布局。

用rails解决这些问题显得极为简洁，为了简化说明，这里不考虑用户权限，如下：

1 在主应用（也就是提供主页服务的系统）建立模块加载机制和代理转发功能（依据dlee翻译的《ajax模式与最佳实践》最后一章的MVC模式），在这里简化下就是一个user有N个page,一个page有N列，一列有N个模块。建立模型如下：

class User < ActiveRecord::Base
   has_many :pages
 end

class Page < ActiveRecord::Base
   has_many :columns
   belongs_to :user
 end

class Column < ActiveRecord::Base
   has_many :cells
   belongs_to :page
end

class Cell < ActiveRecord::Base
      belongs_to :column
end

#在后台发起向其他系统调用服务，当然可以带有一些查询参数比如username已取得和该用户相关的模块内容。
def show
    @cell = Cell.find params[:id]
     Net::HTTP.start(@cell.url,@cell.port) do |http|
        response = http.get('#{@cell.path}', 'Accept' => 'text/xml')
     end
     render :text => @response.body
 end

#其他系统处理请求并返回，返回结果可以是html/xml/rss/flash/js等等，这里暂用字符串文本代替。
def show
     render :text => "ok"
 end

其中需要说明的是：cells表中应存有name、来源URl、port、path，name表示改模块的名字，URl的作用是记录该cell的内容来自于哪个外部站点的rest服务，port指定外部站点的端口，path指定服务的路径。

2 利用rails内置的ajax功能处理拖拽，代码如下：

#为简明起见，取id为1的 page,当然也可以根据user来取page
def index 
    @page = Page.find 1
    @columns = @page.columns
end

  <%= javascript_include_tag :defaults %>

<table id="table_<%= @page.id %>" align="center">
      <tr id="tr_<%= @page.id %>">
        <% for column in @page.columns %>           
          <td id="td_<%= column.id %>" style="height:auto;word-break:break-all;vertical-align:top;">       
            <% for cell in column.cells %>            
                <div id="cell_<%= cell.id %>" class="cell">
                    正在载入……
            </div>       
            <% end %>
          </td>
        <% end %>
      </tr>
    </table>

     <% for column in @page.columns %>
        <%= sortable_element "td_#{column.id}",  
          :url => { :action => "sort" , :column_id => column.id } , 
          :dropOnEmpty => true ,   
          :tag => "div" ,
          :containment => [
           #一个页面最多可以支持4列，总之把page的所有column设置为拖拽容器即可。
       "td_#{@page.columns[0].id}" ,
          "td_#{@page.columns[1].id}" , 
          "td_#{@page.columns[2].id}" ,
          "td_#{@page.columns[3].id}"
        ] , :constraint => false %>    
      <% end %>
    <% end %>

 异步地为每个小模块加载内容

<script>
window.onload = function(){
<% for column in @page.columns %>                 
      <% for cell in column.cells %>   
                new Ajax.Updater('cell_<%= cell.id %>',
                '/Cell/show/<%= cell.id %>',
                {asynchronous:true,evalScripts:true,method:'get'});
      <% end %>
<% end %>
}
<script>

后台处理排序

def sort
    @column = Column.find params[:column_id]
    td_index = "td_" + @column.id.to_s 
    list = params[td_index] 
    list.each_with_index { |id,idx| 
      cell = Cell.find id
      cell.column = @column
      cell.row_index = idx.to_i
      cell.save
    } 
end

3 向页面添加模块，这里默认向页面的第一列添加，添加模块的div可以做成弹出的浮动div形式。

   <div>
        <% for cell in @cells %>
              <%= link_to_remote cell.name , :update => "td_#{@page.columns[0].id}" , :mothod => :get ,
:url => {:action => "add_cell" , :page_id => @page.id , :id => cell.id} ,:position => "top"  %>
         <% end %> 
  </div>

 后台代码如下：

def add_Cell
    @page = Page.find params[:page_id]
     #获取该页面的第一列，column_index表示改列的列标
    @column = Column.find :first , :conditions => ["page_id=? and column_index=?" , @page.id , 1]
      @cell = Cell.find params[:id]
      @cell.column = @column
      @cell.row_index =  0#row_index 表示该模块在一列中的位置
    @cell.save
end

 4 删除模块

#在这里简单的删除该cell记录，前台直接隐藏该cell的div再向后台发送ajax请求。
def delete_cell
    Cell.delete params[:id]
end

5 关于设置主题和列数，这个用ajax实现比较容易也比较常见，在此不做解释了。

6 这里仅提供了一个思路，很多地方可以完善和扩展，比如在现实中column和cell应为多对多的关系，这里简化为一对多，这个方案已经过简单的扩展和测试，效果还不错。

• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

    说到cas服务器，首先想到的是耶鲁大学的那款基于java的开源cas服务器，研究一段时间后发现，不是很让人满意，首先是配置过程有点麻烦，新版本的java cas server 基于spring framework，用maven部署打包，如果没有一定java功底的话，很难驾驭它。再有就是定制过程麻烦，要对源码做一些修改，这就要求对源码结构有一定的了解。另外还有一些数字证书导入导出的繁琐过程。

    那么现在就让Ruby将生活变得简单点，让RubyCAS将sso问题变得的容易些吧。之所以说RubyCAS灵巧主要有以下几个原因：

    1 安装部署简单，你甚至可以不了解ruby编程。

    2 可以不用SSL，因为很多应用，比如论坛博客社区等系统没有那么高的安全性要求，我们也不想在页面跳转时出现警告框。

    3 可以用SSL,但它的过程是非常简单的，只需安装个gem即可。

    4 定制简单，基本所有的定制在一个yml文件就搞定了。

    …………

    http://code.google.com/p/rubycas-server/wiki/QuickStart，这里有linux下配置安装的说明，那下面我就展示下windows/WEBrick平台下的安装部署测试过程。

1 安装RubyCAS，安装之前请保证你的你的机器已经装有ruby 1.8.4或更新的版本。在shell中输入：gem install rubycas-server

2 必要的配置，主要是指定cas server的端口、用户数据库以及验证策略，打开C:\ruby\lib\ruby\gems\1.8\gems\rubycas-server-0.6.0目录，新建config.yml文件，并将config.example.yml文件的内容全部拷贝进去，由于yml文件的可读性非常好，所以基本都可以理解其中的配置项，把以下3个地方的注释去掉并做如下修改：

server: webrick 
port: 443 
#ssl_cert: /path/to/your/ssl.pem 

database: adapter: mysql 
database: cas 
username: root 
password: 123456 
host: localhost 

authenticator: class: CASServer::Authenticators::SQL      
    database:cas    
    adapter: mysql 
    database: cas 
    username: root 
    password: 123456 
    server: localhost 
  user_table: users 
  username_column: username password_column: password 

3 为了能在windows下运转正常，修改一行代码，linux平台下就省去这一步。打开C:\ruby\lib\ruby\gems\1.8\gems\rubycas-server-0.6.0\lib目录中的casserver.rb文件，

找到这行：

$CONFIG_FILE ||= '/etc/rubycas-server/config.yml'

 改为：

4 以上3步基本搞定cas server所有该做的事情了，事情就那么简单，在cmd中输入rubycas-server启动cas server,访问http://localhost:443即可看到登录界面。那么下面我们编写客户端测试吧，这里我采用的是ruby做客户端，http://www.javaeye.com/topic/210994这篇文章已经介绍了ruby客户端的配置使用，在这里只要在config/environment.rb 文件中最后那段修改为：

CASClient::Frameworks::Rails::Filter.configure( :cas_base_url => http://localhost:443 ) 

http://code.google.com/p/rubycas-server/

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

声明
Spring中文参考手册得到Spring Framework开发团队的直接授权和大力的支持，其目的是在中文世界推广优秀的开源技术。本次翻译活动由满江红开放技术研究组织(http://www.redsaga.com )和Spring中文论坛(http://spring.jactiongroup.net ) 共同发起、组织。我们在此郑重宣布，本次翻译遵循原Spring Framework的授权协议，即Apache 2.0协议。在完整保留全部文本(包括本版权页)，并且不违反Apache 2.0协议的前提下，允许和鼓励任何人进行全文转载及推广，所有参与人员放弃除署名权外的一切权利。

致谢
如此庞大的项目不是一两个组织可以独立完成的，就像Spring本身一样，涵盖了Java技术的方方面面。因为有了大家的关心和支持才使此次项目能够顺利完成。有理由相信，中文开源世界必将在不久的将来展现出更广阔的发展空间，希望大家都能为推动中国软件发展奉献出自己的一份力量。

项目主页：
http://wiki.redsaga.com/confluence/display/Spring2/Spring2.5

在线版本：
HTML / HTML Single

下载地址：
PDF(593页，4.41MB) / CHM(2.08MB)

勘误表：
http://wiki.redsaga.com/confluence/pages/viewpage.action?pageId=3171

• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

这段时间在看《High Performance MySQL》，看到存储引擎这个地方感到很多细节比较陌生，所以总结小记一些

为了适应各种不同的运行环境，MYSQL提供了多种不同的存储引擎（Storage Engine ）,在应用程序开发这个层面上，开发者可以根据不同的需求选择适合的Storage Engine 方案，更为灵活的是，你可以根据每张表将要存储数据的特点，选择不同的Storage Engine,也就是说，在一个MYSQL数据库中，可以混合使用多种不同的Storage Engine

首先小瞥一下MySQL的体系结构，在最高抽象层度下，可以用Garlan & Shaw的分层结构体系来表示（左）

其中应用层为所有RDBMS用户提供用户接口，逻辑层包括了所有核心功能的实现，物理层则负责将数据存储在硬件设备上。

图中右侧更为具体的描述了逻辑层的组成，查询处理子系统、事务管理子系统、恢复管理子系统和存储管理子系统共同组成了MySQL的逻辑层。相信Storage Engine的位置是在Storage Management处，既Storage Engine属于Storage Management子系统的一部分

为了让思路更清晰一些，下面给出一幅比较全面的体系结构图（或更确切的说是流程图，只是忽略了反馈）

上面三幅图来自于一篇非官方（不保证百分百的正确）的MySQL体系结构的报告，与《High Performance MySQL》一书中给出的MySQL大体结构（下图,基本对应于Logic Layer，从第一幅图右侧可以看出MySQL logic layer同样遵从分层体系结构）还是比较吻合的。

连接上图中第二层和第三层之间的接口是并不针对任何存储引擎的单一API,.大概由20个基本的类似“启动事务，返回结果集”等函数组成。存储引擎并不处理SQL，相互之间也不通信，它们的任务只是简单的响应高层传来的请求。

存储引擎各自的一些特点

上面提到的四种存储引擎都有各自适用的环境，这取决于它们独有的一些特征。主要体现在性能、事务、并发控制、参照完整性、缓存、 故障恢复，备份及回存等几个方面


目前比较普及的存储引擎是MyISAM和InnoDB.而MyISAM又是绝大部分Web应用的首选。MyISAM与InnoDB的主要的不同点在于性能和事务控制上。

MyISAM是早期ISAM(Indexed Sequential Access Method,我现在用的MySQL5.0已经不支持ISAM了）的扩展实现，ISAM被设计为适合处理读频率远大于写频率这样一种情况，因此ISAM以及后来的MyISAM都没有考虑对事物的支持，排除了TPM，不需要事务记录，ISAM的查询效率相当可观，而且内存占用很少。MyISAM在继承了这类优点的同时，与时俱进的提供了大量实用的新特性和相关工具。例如考虑到并发控制，提供了表级锁，虽然MyISAM本身不支持容错，但可以通过myisamchk进行故障恢复。而且由于MyISAM是每张表使用各自独立的存储文件（MYD数据文件和MYI索引文件），使得备份及恢复十分方便（拷贝覆盖即可），而且还支持在线恢复。

所以如果你的应用是不需要事务，处理的只是基本的CRUD操作，那么MyISAM是不二选择

InnoDB被设计成适用于高并发读写的情况.使用MVCC(Multi-Version Concurrency Control)以及行级锁来提供遵从ACID的事务支持。InnoDB支持外键参照完整性，具备故障恢复能力。另外 InnoDB的性能其实还是不错的，特别是在处理大数据量的情况下,用官方的话说就是： InnoDB的CPU效率是其他基于磁盘的关系数据库存储引擎所不能比的。不过InnoDB的备份恢复要麻烦一点，除非你使用了4.1以后版本提供的Mulit-tablespace支持，因为InnoDB和MyISAM不同，他的数据文件并不是独立对应于每张表的。而是使用的共享表空间，简单的拷贝覆盖方法对他不适用，必须在停掉MYSQL后对进行数据恢复。使用Per-Table Tablespacesd，使其每张表对应一个独立的表空间文件，则情况要简单很多。

一般来说，如果需要事务支持，并且有较高的并发读写频率，InnoDB是不错的选择。要是并发读写频率不高的话，其实可以考虑BDB,但由于在MySQL5.1及其以后版本中，将不再提供BDB支持。这个选项也就没有了

至于Heap和BDB（Berkeley DB），相对来说，普及率不如前两种，但在有些情况下，还是挺适用的

Heap存储引擎就是将数据存储在内存中，由于没有磁盘I./O的等待，速度极快。但由于是内存存储引擎，所做的任何修改在服务器重启后都将消失。
 
Heap挺适合做测试的时候使用


BDB是MySQL第一款事务安全的存储引擎。在Berkeley DB database library的基础上建立，同样是事务安全的，但BDB的普及率显然不及InnoDB，因为大多数在MySQL中寻找支持事务的存储引擎的同时也在找支持MVCC或是行级锁定存储引擎，而BDB只支持Page-level Lock。

附上一张《High Performance MySQL》 中的各存储引擎的特性表

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

之前做了几个基于ruby,java的系统，现在想把它们整合到一起，首先遇到了单点登录问题，开始是用跨域iframe来实现，效果还行，但安全性不大高，所以还是打算上cas，方案如下:

1 安装cas3.0并配置http://liuqiang.javaeye.com/admin/blogs/210679，保证http://localhost:8080/cas能正常运行。

2 安装ruby的cas客户端：进入项目根目录，运行ruby script/plugin install http://rubycas-client.googlecode.com/svn/trunk/rubycas-client

3 打开config/environment.rb ，在该文件最后也就是等rails初始化完毕，加上 CASClient::Frameworks::Rails::Filter.configure(
    :cas_base_url => "http://localhost:8080/cas"
  )

4 在需要校验的控制器中加入 before_filter CASClient::Frameworks::Rails::Filter

5 在视图中加入登录链接：<a href="/front/sessions/login">登录</a>

6 在负责处理登录的控制器中加上 before_filter :set_current_url , CASClient::Frameworks::Rails::Filter

 
 before_filter :set_current_url ,CASClient::Frameworks::Rails::Filter

  def set_current_url
#记下来源url,因为在之后的验证过程中，来源url会丢失
    cookies[:current_url] = request.referer
  end

 def cas_login
#跳到来源url
    redirect_to cookies[:current_url]
  end
 

 
7 登录完毕后可以用session[:cas_user]将登录的用户名取出

• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师

    加载 Ajax 应用程序之后，随后它将获取较小的数据和内容片段，以避免重新呈现整个页面的开销，从而提高性能。这样做的代价是，应用程序的初始下载时间通常会较长。本文将讨论如何减少 Dojo 应用程序的初始下载时间并同时获得很好的性能。

仅获取所需的数据

    Asynchronous JavaScript and XML (Ajax) 应用程序能够提高某些 Web 应用程序的性能。加载应用程序之后，获取较小的数据和内容片段可以帮助避免重新呈现整个页面的开销。不过，这样做得的代价是，应用程序的初始下载时间通常 会比较长。

    我现在已有多年的 Dojo 应用程序使用经验。IBM® WebSphere® Application Server Feature Pack for Web 2.0 和 Project Zero 现在都包括 Dojo Toolkit 的 IBM 分发版本，提供了一些增值扩展。由于 Dojo Toolkit 的模块化特性，初始加载可能会花费相当长的时间，因为使用的每个模块可能都需要下载一些 JavaScript™、HTML 和 CSS 文件。这会在网络上带来大量额外的 IO 操作，远远超过每个模块本身的大小。

    通常，这个模块化特征是程序员所必需的，因为通过其可以方便地进行调试和编码，但编写了应用程序之后，此模块化特征就不再重要了——或不再需要了。您可以通过多种方法减少 Dojo 应用程序的初始下载时间。

使用 Dojo 构建和打包系统

    Dojo Toolkit 提供了打包和压缩技术，用于将在应用程序中使用的 Dojo 代码打包为单个文件，然后使用名为 Dojo ShrinkSafe 的压缩技术将其压缩到最小尺寸。大部分 Dojo 应用程序都应该将此技术作为其部署的一部分使用，因为此技术将极大地提高应用程序的性能（特别是初始下载时间）。您只需要为应用程序创建概要，并在其中指 定要使用哪个 Dojo 组件。清单 1 显示了一个示例。

    清单 1. 示例概要

dependencies ={

    layers:  [
        {
        name: "example.js",
        dependencies: [
			
			"dojo.*",
			"dojo.parser",
			"dijit.dijit",
			"dijit.Declaration",
			"dijit.layout.LayoutContainer",
			"dojox.layout.ContentPane",
			"dijit.Toolbar",
			"dijit.layout.AccordionContainer",
			"my.widget.Super"         
       	]
        }
    ],
	
	
    prefixes: [
        
		[ "dijit", "../dijit" ],
		[ "my", "/myWidgets"],
		[ "dojox", "../dojox" ]
    ]

};

     然后您将运行命令行构建工具，使用各种选项传入概要。Dojo 构建然后将应用程序所需的所有代码（包括 JavaScript、HTML 和 CSS）放入单个文件中，并对其进行压缩。通过使用此方法，我发现在应用程序初始下载中，IO 调用的数量可能从 200 个以上减少到 2 个或 3 个。我还发现总体大小减少了约 60%。将很快推出关于使用 Dojo 构建和打包系统的 developerWorks 教程，不过在 Dojo 网站 上提供了关于打包系统和自定义构建的更多信息。

延迟加载和缓存 Dojo 内容

可 以极大减少初始下载大小的另一个方法是，对页面的内容部分进行延迟加载，并在加载之后对其进行缓存。有时候，这样的做法会更好：不在首次访问应用程序时就 加载所需的所有东西，而仅在这个时候加载应用程序的部分内容。用户完全可能会在访问站点时从来不会访问 Web 应用程序的某些特定部分，因此下载这些不会接触的部分所消耗的时间都浪费掉了。所以，您并不需要下载应用程序中可能不会使用的部分。而且，第一印象极为重 要：如果不能快速显示初始主页，可能会让用户更快放弃使用您的程序。

通常，您会希望加载包含初始菜单的布局，然后在加载之后获取主页内容。常见 Dojo 应用程序通常由一些布局元素组成。请看清单 2：

清单 2. 布局

<body class="tundra">
	<div dojoType="dijit.layout.LayoutContainer" 
		layoutChildPriority="top-bottom" 
		id="main" 
		class="layout" >
		<div dojoType="dijit.layout.ContentPane" 
			layoutAlign="top" class="banner">
			<h2>Electronic and Movie Depot !!</h2>
		</div>
		<div dojoType="dijit.layout.ContentPane" 
			layoutAlign="top" class="menu">
			<div dojoType="dijit.Toolbar" id="mainMenuBar">
				<div dojoType="dijit.form.Button" 
					id="productListMenu" 
					onclick="showItem('productList',
						'product/product.html');">
					Shopping
				</div>
				<div dojoType="dijit.form.Button" 
					id="orderListMenu" onclick="showItem('orderPage',
						'cart/cart.html');">
					Shopping Cart
				</div>
			</div>
		</div>
		<div dojoType="dijit.layout.ContentPane" 
			class="mainArea" 
			id="center" layoutAlign="client">
			<div dojoType="dojox.layout.ContentPane" 
				executeScripts="true" id="productList" 
				style="display:none">
			</div>
			<div dojoType="dojox.layout.ContentPane" 
				executeScripts="true" 
				id="orderPage" 
				style="display:none">
			</div>
		</div>
	</div>
</body>

通过清单 2 可以了解一些事项。我创建了一个简单的方法来将 HTML 片段加载到特定的内容中。我还使用 dojox.layout.ContentPane 替代了缺省 dijit。扩展的内容窗格允许在加载区域时执行 JavaScript。通过这样，不仅可以延迟加载 HTML 内容，还可以采用延迟加载方式加载关联的逻辑。清单 3 显示了我所编写的实用方法的实现。

清单 3. 延迟加载

var loaded = new dojox.collections.Dictionary();

function hideAll()
{
	console.debug("Hiding other content");
	var ids = loaded.getKeyList();
	console.debug("Getting ID -> " + ids);
	console.debug("List is Array");
	for (var id in ids) {
		console.debug("Getting section -> " + ids[id]);
		var section = dijit.byId(ids[id]);
		console.debug("Got Section -> " + section);
		if (section) {
			console.debug("setting DOM");
			section.domNode.style.display = "none";
		}
	}
	console.debug("Content is hid");
}

function showItem(key,template)
{
	hideAll();
	console.debug("Show Item -> " + key);
	var item = dijit.byId(key);	
	console.debug(item);
	if (item) 
	{
		if(!loaded.contains(key))
		{
			item.setHref(template);
			item.refresh();
			loaded.add(key,template);
		}
		
		item.domNode.style.display ="block";
	}
}

/**
 * Load Default page
 */
dojo.addOnLoad(function loadDefault()
{
	console.debug("Loading initial state");
	showItem('productList','product/product.html');
});

    在清单 3 中调用 showItem 时，我隐藏了在主体中可能可见的任何内容。我然后进行检查，确定是否加载了 HTML。如果未加载，将下载模板，然后将其缓存在 Dojo 词典中。下次请求此页面时，将会直接显示该区域。我还使用 dojo.addOnLoad 方法加载缺省页面。

    在清单 3 中调用 showItem 时，我隐藏了在主体中可能可见的任何内容。我然后进行检查，确定是否加载了 HTML。如果未加载，将下载模板，然后将其缓存在 Dojo 词典中。下次请求此页面时，将会直接显示该区域。我还使用 dojo.addOnLoad 方法加载缺省页面。

不要全部使用 dijit

我们很可能喜欢为主要应用程序组件创建 dijit（Dojo 小部件）。例如，在清单 4 中，可以看到将应用程序处理为 Dojo dijit 的示例。

清单 4. 将应用程序处理为 dijit 可以减少下载时间

<div dojoAttachPoint = "registerId"
	dojoType="registration:RegistrationWidget" 
	style="display:none"
>
</div>
<div dojoAttachPoint = "datacenterId"
	dojoType="datacenters:DataCentersWidget"  
	inputTopic="no.show.datacenter" 
	style="display:none">
</div>

    在清单 4 中，我将每个应用程序组件都包装在 dijit 中。反过来，每个 dijit 都由子 dijit 组成。甚至可以将加载整个应用程序视为超 dijit：

<div id = "layout" dojoType="layout:EEFLayoutWidget" class="layoutDef"></div>

问题是，您忽略了延迟加载内容（或太过复杂而不能考虑这个选项），特别在构建中包括所有小部件的情况下。我发现，最好为 UI 组件（Data Grid、专用组合框、特殊文本区）创建 dijit，然后加载使用 dijit 的普通 HTML 模板。

通过遵循一些指导原则和实践，可以很容易地减少下载应用程序的时间，而且仍然能够获得 Dojo 具有的一些性能优势。

参考资料

学习

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文
  
  
• The Book of Dojo: The Package System and Custom Builds
  
  
• The Book of Dojo: DojoX Layout
  
  
• Project Zero
  
  
• IBM developerWorks Web development 专区
  
  
• IBM developerWorks WebSphere Application Server 专区
  
  

获得产品和技术

• Dojo Toolkit
  
  
• IBM WebSphere Application Server Feature Pack for Web 2.0
  
  

讨论

• Blog：Web 2.0 和中间件

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师

• 前言

  本文提到的typo版本是目前最新的5.0.3.98.1，theme_support版本是1.3.0。在typo中，我们看到了很好很花哨的换肤机制，而theme_support则是从typo中抽取出来的一个plugin，以供其他程序进行换肤操作。
  先简单介绍下typo换肤的使用。typogarden提供了typo十分丰富的皮肤，我们只需要下载喜欢的皮肤，解压，放在typo程序根目录的theme目录下即可，大致的结构图如下所示：

  然后，就可以在admin界面选择自己的皮肤。的确十分方便。但是，使用这种机制，会存在一个严重的性能问题，下面将详细分析问题的原理及其我目前所知的解决方案。

• Typo的换肤原理

  通常，我们会将程序的图片，css等与皮肤相关的文件放在网站的public目录下，在view中直接引用即可。但是从上图我们可以看到，typo将新皮肤的所有相关文件都存放在theme目录下的各个子目录下。那么typo是如何引用这些文件的呢？下面，我们随便打开某一个皮肤下面的layout文件，例如theme/typographic/layouts下面的default.html.erb文件，可以看到如下代码：

<%= stylesheet_link_tag '/stylesheets/theme/style.css', :media => 'all' %>

  你仔细搜查一下程序，绝对发现不了/stylesheets/theme目录，乱引用？当然不是，我们可以在routes.rb中发现如下的route信息：

    get.with_options(:controller => 'theme', :filename => /.*/, :conditions => {:method => :get}) do |theme|
      theme.connect 'stylesheets/theme/:filename', :action => 'stylesheets'
      theme.connect 'javascripts/theme/:filename', :action => 'javascript'
      theme.connect 'images/theme/:filename',      :action => 'images'
    end

  很经典的route配置，原来在typo中，所有对css，javascript，image的引用，不是通过直接引用public目录下的文件，而是通过一个传统的controller：ThemeController来完成的。至于ThemeContorller具体代码，这里不详细谈，因为不是本文的重点，无非就是根据当前选择的皮肤（在admin界面选择的），到相应的皮肤目录（比如：theme/typographic）下，将各个文件找到，然后通过send_file的方式发送到客户端浏览器。那执行完一次action后，controller到底应该执行怎么样的render操作呢？（通过上图，我们看到不同的view文件，在各自的theme子目录下）
  在ApplicationController中，有如下代码：

class ApplicationController < ActionController::Base
......
  def setup_themer
    # Ick!
    self.view_paths = ::ActionController::Base.view_paths.dup.unshift("#{RAILS_ROOT}/themes/#{this_blog.theme}/views")
  end
end

   大致讲下，setup_themer方法的作用是根据目前皮肤配置（this_blog.theme），将controller的view_paths设置为某一个皮肤的目录（比如：theme/typographic/views），这样，在执行render操作的时候，将使用皮肤目录下的view,layout等等（还记得前面提到的layout中引用css的方法么？重要！）。并且，将setup_themer方法设置为需要换肤的contorller的before_filter。于是，当我们执行程序的时候，就可以达到动态换肤的目的。
  大致原理如是。。。

• 性能问题的由来

  前面我讲了，这种机制会存在一个严重的性能问题，是怎么来的呢？在传统方式下，我们将css，images，js都放在public目录下，view进行引用的时候，在web服务器层面，就完成了文件的引用，发送操作。但是在typo这种机制下，每引用一个css，图片，js，web服务器会将请求route到rails，通过rails的ThemeController来处理请求，返回文件。这都还算小事，在一次request，response周期，这样一个额外操作往往占用不了多大的百分比。但是，我们知道ThemeController是rails中一个普通的Controller，它也继承自ApplicationController。通常，我们会将很多程序通用逻辑放在ApplicationController中来做，比如：验证用户合法性，处理本地化等等，而这些操作，大部分都是访问数据库。也就是说，我们通过ThemeController，仅仅想得到一个css或者图片文件，但是ApplicationController仍然会初始化，执行相应的操作（重复，无用的操作）。这就是性能问题的根源。口说无凭，下面的数据揭示了一切：
        
  上面两个性能测试是我随机访问一次typo首页得到的，我们可以看到，对css，image，js的请求，耗费了数十毫秒的操作。为什么请求一个css会耗费如此多时间呢？从下面的图中，我们可以看到原因：

  Oh~My god！我出来打个酱油而已，咋搞出个db访问占用了这么长的周期？原因就是我前面提到的，访问ThemeController的时候，ApplicationContorller偷偷摸摸的作祟着（执行了一些业务逻辑的操作，用户验证等）。具体执行的多余db操作如下图所示：

  什么show tables，select blogs，select triggers之类操作啊~我请求一个css，何必呢？
  性能问题的原因分析完毕！不要忘了，我举例的这些简单的皮肤中，只是简单的十几个css，js，images等。如果你真的使用这种机制在自己的程序中，我想，一个稍微复杂点的皮肤不止十个图片文件。加入我们要在皮肤中引用数十个此类文件，那么性能问题将是十分严重的。

• 解决方案

  目前，我找到三个解决方案处理这个性能问题。

  1. 在ApplicationController中，执行某些业务逻辑的时候，判断一下controller，如果是ThemeController，则跳过。这样做的好处是不用变动typo中换肤方法的使用，仍然将皮肤放在theme目录下即可。但是，这样做似乎“侵入性”太强，仅仅为了一个皮肤，修改业务逻辑�