• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

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);
 }
});

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

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

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

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

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

常常看到论坛上有人讨论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也能过日子 。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

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();           
    }     
       
}       

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

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的公司要关门了。

• 搜狐网站诚聘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++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

      简单来说，个性化主页就是结合了各种小模块和网络信息的个人主页。与传统网站的区别是：用户可以非常自由地控制其内容（通过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++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.charset.Charset;

import org.apache.mina.common.ByteBuffer;
import org.apache.mina.common.IoAcceptor;
import org.apache.mina.common.SimpleByteBufferAllocator;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
import org.apache.mina.transport.socket.nio.SocketAcceptor;
import org.apache.mina.transport.socket.nio.SocketAcceptorConfig;

/**
 * @author ahuaxuan(aaron zhang)
 * @since 2008-7-21
 * @version $Id$
 */
public class MinaServer {

	private static final int PORT = 11211;
	
	public static void main(String[] args) throws IOException {
		// code will go here next
		ByteBuffer.setUseDirectBuffers(false);
		ByteBuffer.setAllocator(new SimpleByteBufferAllocator());

		IoAcceptor acceptor = new SocketAcceptor();

		SocketAcceptorConfig cfg = new SocketAcceptorConfig();
//		cfg.getFilterChain().addLast("logger", new LoggingFilter());
		cfg.getFilterChain().addLast(
				"codec",
				new ProtocolCodecFilter(new TextLineCodecFactory(Charset
						.forName("UTF-8"))));

		 acceptor.bind(new InetSocketAddress(PORT), new ServerHandler(), cfg);

		 System.out.println("------------ Mina Server start up -----------");
	}

}

public void messageReceived(IoSession session, Object msg) throws Exception {
		String str = msg.toString();
		String[] parts = str.split(" ");
		if (parts != null && "get".equals(parts[0])) {
			
			StringBuilder sb = new StringBuilder();
			sb.append("VALUE").append(" key ");
			sb.append("1").append(" ");
			sb.append(str.length()).append(" \r\n ");
			sb.append(str + "\r\n").append("");

			//看看这里吧
			session.write(sb.toString());
			session.write("END\r\n");

			System.out.println("Message written..." + sb.toString());
		} else {
			throw new IOException("unsupportoperation");
		}

	}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

    说到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/

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘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

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘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》 中的各存储引擎的特性表

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘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[:cur