作者: ray_linn  链接：http://www.javaeye.com/topic/266485  发表时间: 2008年11月13日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

IronRuby是.NET下的一个Ruby实现，此外还有Ruby.net这一开源项目，二者的主要区别是IronRuby利用了Microsoft最新推出的DLR，而ruby.net则是完全利用原有的CLR实现的，二者的比较可以参考lam John的相关文章。目前IronRuby (SVN r118) 100% 兼容于Ruby 1.5.0规格书，可以顺利运行RubySpec的所有测试与例子，因此大部分Ruby程序都可以不加修改的运行在IronRuby之上，其中包括Rails.

IronRuby的一大特点是，它是基于Microsoft的DLR，因此除了分享ruby世界的资源外，它也可充分利用.NET的庞大资源，例如LINQ，这意味着.NET中的ruby世界，别有一番天地。你可以组合ASP.NET MVC和active record，或者是rails +LINQ，或者完全不需要rails，这完全取决于你的创造力。Lam John演示了如何利用ASP.NET MVC完全实现类似Rails的架构与功能.

先来个简单的"Hello,world"级别的。首先设置routes.(ASP.NET MVC的route)

$routes.map_route "{controller}/{action}/{id}"
{ :controller='Home', :action='index', id=''}

然后与rails的程序类似，开始contoller的编写:

class HomeController < Controller
   def index
     view HomeModel.new
   end
end

和rails不一样的地方在于,其继承的父类是ASP.NET MVC的Controller类 ，而不是rails的ApplicationController.

最后在models目录下放入HomeModel.rb,我们的数据来自于内存。

class HomeModel 
  def salutation
   "Hello,World"
  end
end

然后是一个最简单的page,你可以命名成aspx，或者遵循ruby世界的规则，以rhtml为后缀，views\home\index.rhtml.

$model.saluation

这是一个最简单的MVC例子，稍后是更复杂的例子Controller它有两个action:index和list.

require "helper/contoller"
require "ProductModel"
class ProductsController < BaseController
   def index 
     model=ProductsModel.new
     @message="Hi,Mom"
     @categories=mode.get_categories
     return_view
   end

   def list
    @category=params[:id]
    model=ProductsModel.new
    @products=mode.get_products_for_category @category
    return_view
   end
end 

这里特别指出的，暂时我们用实例变量与view端通讯，但是Lam John承诺，目前只是作为原型来研究而已，以后必然会做出修改。接下里的model就更简单，它只是visual studio包装的northwind数据库的适配器，这里用到了我后面提到的"mokey patch"方法，从而将C#的GetCategory映射成ruby的get_category.

require "helpers/model"
class ProductsModel 

NorthWindDatabase是个C#的类

public class NorthWindDatabase :NorthWindResposity{
  public List GetCategories(){
    return Categories.ToList();
  }
 public Category GetCategory(String name){
   return Categories.SingleOrDefault(c =>C.CategoryName==name);
 }

 public List getProductsForCategory(String name){
   var category=GetCategory(name);
   var products= from p in Products where p.CategoryId==category.CategoryId select p;
   return products.ToList();
 }
}


如果你觉得利用Visual studio生成NorthWind的wrapper不符合你的ruby习惯，那么完全可以把ProductsModel改成ActiveRecord的实现。



view端

  <% $view_data.categories.each{|category|%>
   
 ">
       <%=category.category_name%>
   
 <%
  }
%>




这次view端是完全的asp.net
          


          
            已有 18 人发表回复，猛击->>这里<<-参与讨论
          
          



          JavaEye推荐
          

          
加入阿里巴巴，发展潜力无限
Windows7在微软WinHEC 2008上揭开神秘面纱
你想过自己的博客制作成书吗 - JavaEye推出博客自动生成电子书功能！
搜狐网站诚聘Java、PHP和C++工程师
          



          
	

作者: easyfinger  链接：http://www.javaeye.com/topic/264547  发表时间: 2008年11月09日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

 

已有 41 人发表回复，猛击->>这里<<-参与讨论


JavaEye推荐

• 加入阿里巴巴，发展潜力无限
• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

作者: ahuaxuan  链接：http://www.javaeye.com/topic/263895  发表时间: 2008年11月07日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

/**
*作者：张荣华
*日期：2008-11-07
**/

开门见山,一刀见血,让我们说说烦人的aop cache.

aop cache解释使用aop技术的cache,可以cache被代理对象的方法返回结果,还可以通过方法的参数值来控制缓存的粒度,看上去很美,用的人估计也颇多,好东西啊,面试的时候经常有人告诉我"我用过aop cache",看来是居家必备啊.不过居家必备的东西也得升个级什么滴啊,就想汽车一样,每年拉一次皮,照卖,还自夸是新一袋.aop cache要升级得先看看它烦人得地方.看看它烦人得地方先得知道它得用法,那么就先简单介绍一下它得用法:

常见步骤,2步
1,建立一个拦截器类,环绕增强或者后增强都可以,代码如下:

/**
 * @author ahuaxuan(aaron zhang) 代码原主是一个老外,不是我
 * @since 2008-5-13
 * @version $Id: MethodCacheInterceptor.java 814 2008-05-13 06:52:54Z aaron $
 */
@Component("methodCacheInterceptor")
@GlobalAutowired//这个是俺写的globalautowired,大家可以忽略
public class MethodCacheInterceptor implements MethodInterceptor {

 private Cache methodCache;

 public void setMethodCache(Cache methodCache) {
  this.methodCache = methodCache;
 }

 public Object invoke(MethodInvocation invocation) throws Throwable {
  String targetName = invocation.getThis().getClass().getName();
  String methodName = invocation.getMethod().getName();
  Object[] arguments = invocation.getArguments();
  Object result;

  String cacheKey = getCacheKey(targetName, methodName, arguments);
  Element element = methodCache.get(cacheKey);
  if (element == null) {
   result = invocation.proceed();

   element = new Element(cacheKey, (Serializable) result);
   methodCache.put(element);
  }
  return element.getValue();
 }

 private String getCacheKey(String targetName, String methodName,
   Object[] arguments) {
  StringBuffer sb = new StringBuffer();
  sb.append(targetName).append(".").append(methodName);
  if ((arguments != null) && (arguments.length != 0)) {
   for (int i = 0; i < arguments.length; i++) {
    sb.append(".").append(arguments[i]);
   }
  }

  return sb.toString();
 }

}

这段代码很简单,就是缓存某个方法的返回结果,使用的缓存组件是ehcache,ehcache的比较详细的用法ahuaxuan在http://www.javaeye.com/topic/128458这篇文章中已经有了说明.

而配置自动代理:

     
         
              
                   aaComponent
                   bbComponent
              
         
         
              
                   methodCacheInterceptor
              
         
     

Over,最简单的aop cache.使用了该aop cache之后,可以缓存方法返回结果于无形,又可以根据方法参数来控制缓存粒度, 实乃居家旅行，杀人越货的必备良药

那么接下来看看这个用法有没有什么问题,相信熟悉一点的童子一眼就看出来了:”糟了,aaComponent和bbComponent所有的方法都被拦截了”.这个代码着实让我焦虑,我很焦虑.

Ok,我改,我改正则表达式还不行吗,我可以通过正则表达式让某些特定方法名的方法才被拦截处理.好啊,正统的spring用法,于是advice变成了advisor,增强变成了增强器, 但是我怎么看着就这么扭呢,难道我要缓存一个方法的结果还非得把这个方法的名字按照某个固定的格式来取, 再着,两个get方法,一个getxxx(),一个getyyy,两个之中一个需要缓存,另外一个不需要缓存(靠,真是变态),怎么办呢?正则的方式让我很烦躁,非常烦躁.

第一种方法让我焦虑,而第二种方法让我烦躁,我应该去寻找解决焦虑和烦躁的方案.

写代码需要有灵感,也需要有很强的分析能力,我们来看看我的问题是什么:
问题重新描述:不能精确的控制某个对象的某个方法需要被缓存.
思考:如何固定这个方法的标示-------------------
hardcode方法名到methodinterceptor中
hardcode缓存标示到方法上(如果该类所有方法都需要被缓存,那么hardcode缓存标示到类上)

我选第二种.那么看看实现步骤:
1.annotation类,两个:

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodCache {

}

还有一个:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ObjectCache {

}

看上去是多么无聊的两个annotation.

2修改methodinterceptor,加上判断逻辑
如果被代理的类加了ObjectCache,那么拦截这个对象所有的方法,如果没有类上没有加ObjectCache,那么判断method上有没有加methodcache,如果加了,拦截该方法,如果没有加,直接调用目标类的方法.

于是代码变成:

public Object invoke(MethodInvocation invocation) throws Throwable {
  
  String targetName = invocation.getThis().getClass().getInterfaces()[0].getName();
  String methodName = invocation.getMethod().getName();
  Object[] arguments = invocation.getArguments();
  
  if (invocation.getThis().getClass().isAnnotationPresent(ObjectCache.class)) {
   return getResult(targetName, methodName, arguments, invocation);
  } else {
   if (invocation.getMethod().isAnnotationPresent(MethodCache.class)) {
    return getResult(targetName, methodName, arguments, invocation);
   } else {
    return invocation.proceed();
   }
  }
 }

private Object getResult(String targetName, String methodName, Object[] arguments, MethodInvocation invocation) throws Throwable {
  Object result;
  
  String cacheKey = getCacheKey(targetName, methodName, arguments);
  Element element = methodCache.get(cacheKey);
  if (element == null) {
   result = invocation.proceed();

   element = new Element(cacheKey, (Serializable) result);
   methodCache.put(element);
  }
  
  return element.getValue();
 }

Ok,试试把,现在我要拦截aaservice上所有的方法,那么我的代码如下:

@ObjectCache
public class AaService  implement xxxxxx{

}

如果我要拦截bbservice上的b1方法,代码如下:

public class BbService implement xxxxxx{

 @MethodCache
 public void bb() {
  
 }
}

好了,目的达到了,我们可以任意的指定需要要拦截某个类的全部,或者部分方法了. 可是心中好像还是很闷的慌,我很慌张,非常慌张.
有人问了:都到这个份上了还慌啥张啊.
答:它tmd什么时候过期啊.我在ehcache.xml配置的可是统一的过期时间啊.ok,想到了,改,于是俺们的annotation就长成下面这个样子了:

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodCache {
 int expire() default 0;
}

和

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ObjectCache {
 int expire() default 0;
}

再看看我们的进化过的methodInterceptor吧,大家可以详细比较一下下面这段和上面两端代码的异同之处

public Object invoke(MethodInvocation invocation) throws Throwable {
  
  String targetName = invocation.getThis().getClass().getInterfaces()[0].getName();
  String methodName = invocation.getMethod().getName();
  Object[] arguments = invocation.getArguments();
  Class[] cs = new Class[arguments.length];
  for (int k = 0; k < arguments.length; k++) {
   cs[k] = arguments[k].getClass();
  }
  
  if (invocation.getThis().getClass().getCanonicalName().contains("$Proxy")) {
   if (logger.isWarnEnabled()) {
    logger.warn("----- The object has been proxyed and method " +
      "cache interceptor can't get the target, " +
      "so the method result can't be cached which name is ------" + methodName);
   }
   
   return invocation.proceed();
  } else {
   if (invocation.getThis().getClass().isAnnotationPresent(ObjectCache.class)) {
    ObjectCache oc = invocation.getThis().getClass().getAnnotation(ObjectCache.class);
    return getResult(targetName, methodName, arguments, invocation, oc.expire());
   } else {
    
    Method[] mss = invocation.getThis().getClass().getMethods();
    Method ms = null;
    for (Method m : mss) {
     if (m.getName().equals(methodName)) {
      boolean argMatch = true;
      Class[] tmpCs = m.getParameterTypes();
      if (tmpCs.length != cs.length) {
       argMatch = false;
       continue;
      }
      for (int k = 0; k < cs.length; k++) {
       if (!cs[k].equals(tmpCs[k])) {
        argMatch = false;
        break;
       }
      }
      
      if (argMatch) {
       ms = m;
       break;
      }
     }
    }
    
    if (ms != null && ms.isAnnotationPresent(MethodCache.class)) {
     MethodCache mc = ms.getAnnotation(MethodCache.class);
     return getResult(targetName, methodName, arguments, invocation, mc.expire());
    } else {
     return invocation.proceed();
    }
   }
  }
 }
 
 private Object getResult(String targetName, String methodName, Object[] arguments,
   MethodInvocation invocation, int expire) throws Throwable {
  Object result;
  
  String cacheKey = getCacheKey(targetName, methodName, arguments);
  Element element = methodCache.get(cacheKey);
  if (element == null) {
   synchronized (this) {
    element = methodCache.get(cacheKey);
    if (element == null) {
     result = invocation.proceed();
 
     element = new Element(cacheKey, (Serializable) result);
     
     //annotation没有设expire值则使用ehcache.xml中自定义值
     if (expire > 0) {
      element.setTimeToIdle(expire);
      element.setTimeToLive(expire);
     }
     methodCache.put(element);
    }
   }
  }
  
  return element.getValue();
 }

童子们可以看到invoke方法加了一些判断(比如说类名中是否含有$Proxy),主要是防止越来越多的代理层次,如果被methodcacheinterceptor拦截到的类是一个代理类,那么ahuaxuan暂时还没有找到可以得到该代理类的目标类的方法(望知情者告之,不甚感激).

好了,好像可以告一段落了,因为现在既可以指定缓存某个类所有方法的返回结果,也可以只缓存某个类的某些方法的结果,而且还可以指定某个方法的结果被缓存多长的时间.嗯.
有童子说了:”等等,还有一个需求,我一个类中只有一个方法不需要缓存结果,其他都要缓存结果,怎么办?”
答:别烦了好吗,你就不能自己写一个@MethodNoCache吗,和@ObjectCache联合使用不就解决问题了吗.

文章最后,附上ahuaxuan的源代码,让各位见笑了.


已有 26 人发表回复，猛击->>这里<<-参与讨论


JavaEye推荐

• 加入阿里巴巴，发展潜力无限
• Windows7在微软WinHEC 2008上揭开神秘面纱
• 你想过自己的博客制作成书吗 - JavaEye推出博客自动生成电子书功能！
• 搜狐网站诚聘Java、PHP和C++工程师

作者: avidmouse  链接：http://www.javaeye.com/topic/261087  发表时间: 2008年11月02日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

   朋友们一起玩开心网很久了，买人、咬人、停车，一个字：累，为了减轻大家的负担，节约大家的时间，
    于是，有了这个插件 ------开心Quicker。

主要功能： 1.  简化【朋友买卖】、【咬人】、【争车位】这几个组件的操作。
                    2.  顺便修正了【朋友买卖】按钮显示问题，嘿嘿。

系统要求：1. firefox浏览器, 2.GreaseMonkey插件。


用法：看图。


【朋友买卖】

    1. 买：勾选要买的朋友，修改默认昵称(朋友名字的最后一个字*2)，然后点下边的【购买选中奴隶】按钮。


    2.安抚和整人： 在朋友买卖主页面【我的奴隶】链接后边，添加了两个链接【安抚所有奴隶】和【整所有奴隶】，点击分别进入安抚和整人快捷页面。
  

    安抚所有奴隶
   

    安抚成功
   

    整所有奴隶
   
 
   
【咬人】
    选要咬的好友，然后选咬的方式和部位，然后点下边的【开咬】按钮。
   
    咬人成功
   


【争车位】
    在争车位主页面【我的汽车】后边，添加了链接【乾坤大挪移】，点击开始自动换车位，并进入状态报告页面。
   

    乾坤大挪移状态
   


【说明】
    因为开心网判断访问时间的间隔，如果访问过快，则直接返回，不做处理，所以，没办法，人为给所有请求添加了延时。
    比如好友买卖，买一个好友差不多需要5秒钟，争一个车位，也差不多5秒，请大家耐心等待，呵呵。
    同时，为了区别于【系统没有响应】，给每个功能都添加简单的状态报告，成功显示蓝色，失败显示红色，最后完成后，会弹出提示窗口，选择进入主界面还是再看看状态报告。

【安装】
    因为这个插件基于GreaseMonkey，目前只支持Firefox浏览器（传闻Chrome会马上支持GreaseMonkey，拭目以待！）。
   
    1.  安装Firefox(下载地址：http://www.mozilla.org.cn/)；
    2.  安装好Firefox后，安装Firefox附加组件GreaseMonkey（下载地址：https://addons.mozilla.org/zh-CN/firefox/addon/748）;
    3. 安装好GreaseMonkey后，下载附件quicker.user.js，用Firefox打开，会自动弹出安装界面，然后安装。

    注意事项：不要修改文件名。

    希望大家不吝赐教，多提宝贵意见和改进建议！

 

更新：

2008-11-08

争车位添加了黑名单功能，自动查找贴条记录，避免停在这些好友家。

添加了停在邻居家功能。

请下载最新附件。

 

已有 40 人发表回复，猛击->>这里<<-参与讨论


JavaEye推荐

• 你想过自己的博客制作成书吗 - JavaEye推出博客自动生成电子书功能！
• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱
• 加入阿里巴巴，发展潜力无限

作者: 姜太公  链接：http://www.javaeye.com/topic/259156  发表时间: 2008年10月28日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

原文：What's New in Python 3.0

 

 

这篇文章主要介绍了相比于python2.6，python3.0的新特性。更详细的介绍请参见python3.0的文档。

 

Common Stumbling Blocks

本段简单的列出容易使人出错的变动。

• print语句被print()函数取代了，可以使用关键字参数来替代老的print特殊语法。例如：
  
  1. Old: print "The answer is", 2*2
  2. New: print("The answer is", 2*2)
  3. Old: print x,                                      # 使用逗号结尾禁止换行
  4. New: print(x, end=" ")                     # 使用空格代替换行
  5. Old: print                                         # 输出新行
  6. New: print()                                    # 输出新行
  7. Old: print >>sys.stderr, "fatal error"
  8. New: print("fatal error", file=sys.stderr)
  9. Old: print (x, y)                               # 输出repr((x, y))
  10. New: print((x, y))                           # 不同于print(x, y)!
  你可以自定义输出项之间的分隔符：
       print("There are <", 2**32, "> possibilities!", sep="")
  输出结果是：
       There are <4294967296> possibilities!
  
  注意：
  
  1. print()函数不支持老print语句的“软空格”特性，例如，在python2.x中，print "A\n", "B"会输出"A\nB\n"，而python3.0中，print("A\n", "B")会输出"A\n B\n"
  2. 学会渐渐习惯print()吧！
  3. 使用2to3源码转换工具时，所有的print语句被自动转换成print()函数调用，对大项目，这是无需争论的。
• python3.0使用字符串(strings)和bytes代替Unicode字符串和8位字符串，这意味着几乎所有使用Unicode编码和二进制数据的代码都要改动。这个改动很不错，在2.x的世界里，无数的bug都是因为编码问题。
• map()和filter()返回迭代器(iterators)
• dict方法keys(),items(),values()返回视图(同样是迭代器)而不是列表(list)
• 内建的sorted()方法和list.sort()方法不再接受表示比较函数的cmp参数，使用key参数代替。
• 1/2返回浮点数，使用1//2能得到整数。
• repr()函数对于long整数不再包含拖尾的L，所以不加判断的去除最后一个字符会导致去掉一个有用的数字。

String and Bytes

• 现在只有一种字符串:str,它的行为和实现都很像2.x的unicode串。
• basestring超类已经去掉了，2to3工具会把每个出现的basestring替换成str。
• PEP3137:新类型bytes，用来表示二进制数据和编码文本，str和bytes不能混合，需要时，必须进行显示的转换，转换方法是str.encode()(str->bytes)和bytes.decode()(bytes->str).
• 在原始字符串(raw strings)中所有反斜线都按字面量解释，不再特殊处理Unicode转义字符。
• PEP3112:bytes字面量，例如b"abc"，创建bytes实例。
• PEP3120:默认源文件编码为UTF-8
• PEP3131:可以使用非ASCII标识符(然而，除了注释中贡献者的名字之外，标准库仍然只包含ASCII)
• PEP3116:新的IO实现，API几乎100%向后兼容，二进制文件使用bytes代替strings
• 去除了StringIO和cStringIO模块，取而代之的是io.StringIO或者io.BytesIO

PEP3101：字符串格式化的新方法

• str.format方法(原文提到替代了%操作符，实际上，format方法和%的用法差别很大，各有所长)。

PEP3106:修补了dict的keys(),items(),values()方法

• 删除了dict.iterkeys(),dict.itervalues()和dict.iteritems()
• dict.keys(),dict.values()和dict.items()返回dict相关数据的引用

PEP3107:函数注解(Function Annotations)

• 注解函数参数和返回值的标准化方法

Exception Stuff

• PEP352:异常类必须继承自BaseException,它异常结构的基类。
• 移除了StandardError
• Dropping sequence behavior (slicing!) and message attribute of exception instances.
• PEP3109:抛出异常：现在必须使用raise Exception(args)而不是原来的raise Exception, args
• PEP3110:捕获异常，现在必须使用except Exception as identifier而不是原来的except Exception, identifier
• PEP3134:异常链(Exception chain)。
• 改良了一些windows不能加载模式时的异常信息，具有本地化处理。

New Class and Metaclass Stuff

• 移除了classic class
• PEP3115:新的metaclass语法
• PEP3119:抽象基类。
• PEP3129:类包装。
• PEP3141:数字抽象基类

其他的语言变化

这里列出大多数的python语言核心和内建函数的变化。

• 移除了backticks(使用repr()代替)
• 移除了<>(不等号，使用!=代替)
• as和with变成了关键字
• True,False和None变成了关键字
• PEP237:long不存在了，只有int，它和原来的long一样。不再支持以L结尾的数字字面量。移除sys.maxint，因为int现在已经是无限大了
• PEP238:int相除，返回float
• 改变了顺序操作符的行为，例如x
• 移除了__getslice__，语法a[i:j]被解释成a.__getitem__(slice(i,j))
• PEP3102:keyword-only arguments.在函数参数列表中，出现在*args之后的命名参数只能使用"关键字参数"的形式调用
• PEP3104:nonlocal声明。使用nonlocal可以声明一个外部变量(不是global变量)
• PEP3111:raw_input()改名为input()，也就是说，新的input()函数从标准输入设备(sys.stdin)读取一行并返回(不包括行结束符)，如果输入过早终止，该函数抛出EOFError，如果想使用老的input()，可以使用eval(input())代替。
• xrange()改名为range()，range()现在不是产生一个列表(list)，而是一个迭代器。
• PEP3113:移除了"元组参数拆包(tuple parameter unpacking)"。这种写法已经不行了：
  def foo(a, (b, c)):...
  现在要这样写:
  def foo(a, b_c):
        b,c = b_c
  
• PEP3114:next()重命名为__next__(),新的内建函数next()可以调用一个对象的__next__()方法。
• PEP3127:新的八进制字面量，二进制字面量和bin()函数。你应该写0o666而不是0666，oct()函数也做了响应的改动。同样，0b1010等价于10，bin(10)返回"0b1010"。0666这种写法现在是错误的。
• PEP3132:支持迭代器拆包。现在你可以这样写:
  a, b, *rest = some_seqence
  甚至象这样：
  *rest, a = stuff
  一般情况下，rest对象是list，而等号右边的对象是可迭代的
• PEP3135:新的super()。你可以不适用任何参数调用super()，正确的参数和实例会被正确选择。如果使用参数，它的行为不变，和以前一样。
• zip(),map(),filter()返回迭代器。
• 移除了string.letters和它的朋友们(string.lowcase和string.uppercase)，现在上场的是string.ascii_letters等
• 移除了apply(),callable(),exefile(),file(),reduce(),reload()
• 移除了dict.has_key()。使用in操作符进行测试
• exec语句没有了，现在是exec()函数
• 移除了__oct__()和__hex__()特殊方法。oct()和hex()方法使用__index__()
• 移除了对__members__和__methods__的支持
• nb_nonzero重命名为nb_bool,__nonzero__()重命名为__bool__()

Optimizations

• 一般情况下，python 3.0比python 2.5慢33%左右。不过仍有提升空间。

模块变动(新的，改进的和废弃的)

• 移除了cPickle模块，可以使用pickle模块代替。最终我们将会有一个透明高效的模块。
• 移除了imageop模块
• 移除了audiodev, Bastion, bsddb185, exceptions, linuxaudiodev, md5, MimeWriter, mimify, popen2, rexec, sets, sha, stringold, strop, sunaudiodev, timing和xmllib模块
• 移除了bsddb模块(单独发布，可以从http://www.jcea.es/programacion/pybsddb.htm获取)
• 移除了new模块
• os.tmpnam()和os.tmpfile()函数被移动到tmpfile模块下
• tokenize模块现在使用bytes工作。主要的入口点不再是generate_tokens，而是tokenize.tokenize()

Build and C API Changes

Python’s build process和C API的改动包括:

• PEP3118:新的Buffer API
• PEP3121:扩展模块的的Initialization & Finalization
• PEP3123:使PyObject_HEAD符合标准C

其他的改动和修复

在源码里分散一系列的改进和bug修复。changes log表明，从2.6到3.0，有XXX个改动和YYY的bug修复。

已有 10 人发表回复，猛击->>这里<<-参与讨论


JavaEye推荐

• 加入阿里巴巴，发展潜力无限
• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

作者: rubyac  链接：http://www.javaeye.com/topic/257812  发表时间: 2008年10月25日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Rails 结合flex技术组成简洁,美观的界面.





flex on rails环境,需要的安装
Installing Ruby
Installing Rails
Installing MySQL
Installing Flex

这里我们只介绍如何安装flex
方式一:
单独的安装Flex Builder 3
for windows
http://www.adobe.com/products/flex/downloads/
for linux
http://labs.adobe.com/downloads/flexbuilder_linux.html

方式二:
安装Flex3 SDK
在安装Flex SDK前,我们需要安装flashplayer9或者flashplayer10
http://www.adobe.com/shockwave/download/download.cgi?P1_Prod_Version=ShockwaveFlash
接下来我们安装者Flex3 SDK(opensource了)
http://opensource.adobe.com/wiki/display/flexsdk/Download+Flex+3
下载完成后,解压到你喜欢的地方,将flex_sdk_3文件下的bin目录加到系统环境中.

export FLEX_HOME=/Users/peterarmstrong/flex_sdk_3(你解压后文件的路径)
export PATH=$PATH:/$FLEX_HOME/bin

ubuntu用户将上面内容加入到 /home/ac/.profile文件里(这里的ac是系统的用户,重开终端生效)

windows用户设置环境变量
,新建系统变量,变量名:FLEX_HOME
            变量值:d:/Users/pererarmstong/flex_sdk_3(解压后文件的路经)
找到系统变量Path,将$FLEX_HOME$/bin,增加到path里面,重启生效

验证安装是否成功
>mxmlc -version
Version 3.1.0 build 2710
显示版本信息,恭喜你,你已经成功安装了felx.

已有 10 人发表回复，猛击->>这里<<-参与讨论


JavaEye推荐

• 加入阿里巴巴，发展潜力无限
• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

作者: fly_ever  链接：http://www.javaeye.com/topic/257832  发表时间: 2008年10月25日
声明：本文系JavaEye网站发布的原创文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

来自http://www.javalinux.it/wordpress/?p=116
个人很认同文章中的这个想法，因此翻译过来。不能保证翻译得正确，因此看原文还是更好的选择。
也希望各位能指出翻译中的错误，

     一种新的单元测试的方法意味着什么？难道说Junit或者TestNG还不够好？Junit(这里我提及到它因为它简单，但是在我的讨论中，TestNG也一样简单 from here on I’ll nominate it only for briefness,but TestNG is the same for my discussion)把测试类作为重点，并且所有的测试都是从那里开始。这意味着事实上，被测试类被认为仅仅存在于测试代码中，程序员只能通过它们使用的名字惯例来找到这些被测试类。

    在旧版本的Junit中，你设计的测试类，需要强制继承Junit框架中的类，并且将调用的方法需要用”test”开头。因此按这个惯例来命名测试类和测试方法，并把他们与被测试的类和方法“连接”起来。我想你会同意，TestNG和Junit4给了我们更多的自由，去掉这些要求。不管怎样，被测试的类和方法和我们的测试类仍然是这样逻辑的联系在一起，并且很多测试类仍然遵循那些旧的惯例。

     但是有很多更好的方式来命名类和方法！我来介绍BDD(Behaviour Driven Development)，请注意BDD不是这篇文章的重点，但是它使我这篇文章更加完美。因此，让我们先用少许文字了解BDD吧。

BDD不仅是一个新的写测试的方法，也是一个按约定的新的设计形式
    引用behaviour-driven.org来开始我的介绍：
BehaviourDrivenDevelopment grew out of a thought experiment based on NeuroLinguisticProgramming techniques. The idea is that the words you use influence the way you think about something
BDD产生自一个基于神经语言规划学技术的实验的想法。这个想法是你用的语言会影响你考虑问题的方式。
     这个想法是需要程序员关注用来描述一个测试类或者方法的词语，因为所选的词语将影响到他们对这个问题的关注点。实际上，采用BDD方法写测试类时，相比这些被测试的类/方法本身，我们将更加关注这些被测试类/方法的行为。当然，这也将改变很多我们写测试代码的方式，比如，我们将对一个方法测试多次来验证每个行为是否正确。
     OK, what if I don’t believe on Neuro Linguistic Programming(神经语言规划学)?是否我还不相信神经语言规划学。好的，从一个纯粹的开发者角度来看，我们根据我们的类和方法的行为作为约定来命名测试，因此，这个测试结果将是绝对清晰的(比如，
”shouldAcceptNullValue fails”就是一个清楚的表达，并不需要复杂的报告)。让我们提供一个简单的例子：

@Test( expected = IllegalArgumentException.class )
    public void shouldNotPermitMethodNull() throws Exception {
    [..]
    }
    @Test( expected = IllegalArgumentException.class )
    public void shouldNotPermitEndPointNull() throws Exception {
    }
    @Test
    public void shouldInitWebParams() throws Exception {
    }
    @Test
    public void getHoldersResultShouldReturnHolderForRightParameters() throws Exception {
    }
    @Test
    public void getHoldersResultShouldIgnoreUnknowntParameters() throws Exception {
    }
    @Test
    public void getHoldersResultShouldIgnoreINParameters() throws Exception {
    }
    @Test
    public void shouldRuninvokeForOneWayMethod() throws Exception {
    }
    @Test
    public void shouldRuninvokeForMethods() throws Exception {
    }
    @Test
    public void shouldRuninvokeForMethodsApplyingMapping() throws Exception {
    }

    你需要一个简单的关于如何使用BDD成功应用到java上的介绍吗(最初的主意来自Ruby’s RSpec)？可以先看看excellent post.
那么BDD就够了吗？
    答案当然是no.BDD是很强大，你可以试一下，但是如果你真正的用于实践，你就会发现这些测试类和被测试类很快就会失去其联系。在BDD中，不仅仅测试方法不再是testXXX，那些测试类也可能不再是按约定取的名称。或者，你可能针对同一个被测试类/方法，会拥有多个测试的方法。例如之前的那个例子，当然不是很贴切，可能一个具体的测试类，比如来测试getHolder方法的行为的测试类更好一点。
你需要帮助吗？这是我的新的项目TestedBy
    通过注释来标注被测试类和方法，来使其与测试类和方法联系在一起，怎么样？不是太坏，你说呢？
我的想法或多或少从这里开始，但是不仅限于一个注释。我很高兴这个主意，因此我决定开始一个新的开源项目来提供测试工具，用来把被测试类放到中心的位置。
    继续看，我将展示给你如何通过注释和相关工具来改变你测试的方法。
    TestedBy目标在于改变观察测试类和被测试类的角度。我们可以把被测试的类(项目中最重要的类)放在中心位置，并可从这些类连接到他们的测试类和方法。一个代码快照可能抵得上更多的解释：

public class TestedBySample {
 
    /**
     * @param args
     */
    public static void main( String[] args ) {
        TestedBySample sample = new TestedBySample();
        System.out.print(sample.add(1, 2));
 
    }
 
    @TestedBy( testClass = "it.javalinux.testedby.TestedBySampleTest", testMethod = "addShouldWork" )
    public int add( int i,
                    int j ) {
        return i + j;
    }
    @TestedByList( {@TestedBy( testClass = "it.javalinux.testedby.TestedBySampleTest", testMethod = "addShouldWork" ),
        @TestedBy( testClass = "it.javalinux.testedby.TestedBySampleTest", testMethod = "addShouldWork2" )} )
    public int add2( int i,
                     int j ) {
        return i + j;
    }
 
}

    很好吧，但是它确实改变了你单元测试的方法？我觉得是，怎么样，至少在两个方面。
1，通过接口和约束来设计Design by interface and contracts
    软件设计中著名的词语说“Design by interface”，仍然在我耳边响起。因此你也当然可以“Test interface”。
很多正式的“Design by interface”意味着定义好你的接口，并且接着实现它们(可能大部分时间是由不同的人或者公司来实现)。总之，你能够影响到的只是如一个强类型语言，例如java能为你提供的那样：一个接口的实现必须遵循接口的签名，类型和参数变量保持一致。你不能控制到那些具体的行为。当然，这也是一个API设计上的一个很大的局限性，因为可能导致实现完全不可预期的行为。
    这里我就引出Eiffell language 和他的 design by contract (DbC)方法，约定来引导继承过来的特征的重新定义。在java中有很多工具支持Dbc，但是我的想法是我们已经有一个很强大的方式来测试方法上的约束，并且使用更少的代码来清楚行为：Unit Tests单元测试。
    使用TestedBy,测试在接口(或者父类)上声明，所有实现类都能运行这些测试，来验证这些实现类的行为，是符合父类类型上的行为和约束定义的。API设计者不仅提供接口，也提供一套验证该接口行为的测试类。因此每个实现者需要提供他们自己的实现，并且运行API设计者提供的测试，来保证实现类不仅是类型安全的，也是行为安全的。TestedBy传递给测试类一个被测试接口的实体类，并调用接口定义好的测试。
    这是一个使用TestedBy的例子：我们已经添加了@TestedBy注释在API接口，并提供一个@BeforeTestedBy注释来提供一个接口的实例。TestedBy将在实现类APIImplOne和APIImplTwo上运行shouldAddTwoAndThree，测试在第一个类上成功而在第二个类上失败。

public interface APIInterface {
   @TestedBy( testClass = "it.javalinux.testedby.APITest", testMethod = "shouldAddTwoAndThree" )
   public int add(int a, int b);
}
 
public class APIImplOne {
   public int add(int a, int b) {
 return a + b;
}
 
public class APIImplTwo {
   public int add(int a, int b) {
 return a - b;
}
 
public class APITest {
 
  private APIInterface instance;
 
  @BeforeTestedBy
  public beforeTestedBy(APIInterface instance) {
 this.instance = instance;
  }    
 
  public void shouldAddTwoAndThree() {
 assertThat(instance.add(3,2), is(5));
  }
 
}

    Of course I hava kept the example simple,but TestedBy has some more annotations ,for instance factory of classes under test can be specified when simple reflective invocation of no argument constructor isn’t enough。
    当然，我使例子尽量简单，但是TestedBy有更多的注释，比如当没有参数的构造函数的简单反射调用时，被测试类的实例工厂能被指定，这些注释还远远不够。
2，在当前工作的类上运行测试
    你写一个测试类来检验代码的正确性。很多时候，你写单元测试来保证代码的改变不会影响正在工作的代码，或者其他同事正在用的代码。你如何做呢？你可能改变你的代码，然后跑所有的涉及到修改的类的测试类。然后，最后你跑所有的测试来保证你没有影响到其他代码。
    那么让你的IDE第一步做什么呢？它编译你修改的类，并同时运行对应的测试类？既然你或者你的IDE能够运行测试类，testedBy让这个成为可能。一个eclipse插件就能做这些工作，针对你修改的类来运行相应的测试类，以验证没有破坏你的测试集，不仅仅是在编译阶段，也能在你写代码的时候。而且这个也不会太费时，因为插件能够根据TestedBy的注释来只运行很少的测试类，即那些已经修改过的类/方法对应的测试类。
    而且，运行测试类，能够得到一些清楚的报告比如：

"ClassUnderTest.methodUnderTest shouldThrowExceptionWithNullParameter doen't pass"

或者更好的：

"Failure: methodUnderTest in ClassUnderTest doesn't throw exception with null parameter, but it should!"

    当然，你能够拒绝这种针对类/方法名称 (如果你想的话)提供的便利，自己从整个工程中去找那些测试类，根据需要自己来测试。
    当然针对所有的类来运行所有的测试类也是可能的，你的测试也能够在Junit上运行，因为TestedBy是基于Junit测试的。
一些特点
让我列举在我心中TestedBy的特点吧：
1，第一个可能是最没有价值的，但是也是最有用的：在你的IDE中，你能够导航你的源代码到对应的测试代码。这个特性将在eclipse4.4的时候发布，它能够根据类名称导航，即使类名处在一个字符串中。当然，这只是一个开始，一个专门的eclipse插件将被开发用来导航代码，以及被测试代码的测试代码树形结构，针对打开/修改的类(见第3点)执行测试代码，等等。我不是一个eclipse开发的大师，因此非常欢迎哪位能够在这方面做出贡献。
2，你将在你的java文档中找到这些注释，考虑这是一个多好的事情，如果你使用BDD方式开发，定义测试方法形如shouldNotAcceptNull()或者shouldThrowsExceptionIfEmpty等等。使用BDD方法，事实上你能够定义和检查约束，通过使用TestedBy的注释，在JavaDoc文档中把这些展示给你的API用户。
3，你能够从被测试类开始运行测试，而不是测试类。我在之前就说过这些了。
4，通过接口和约束的设计。我已经在上文中专门介绍了这些。
5，测试类自动生成。一个工具(ant,maven,或者eclipse工具)能用我们的TestedBy注释来生成测试类。见6点。
6，Ant /maven 任务/插件来从被测试类运行测试，这个工具将管理并平稳的使用(用来保证测试类和注释间的同步将很重要)：
    A，反转引擎：从存在的测试类开始，添加TestedBy注释到被测试类中。
    B，从TestedBy注释中开始运行测试类，来验证他们能运行所有的测试，并且没有注释指向不存在的测试。
    C，从注释开始生成(空的)测试类和方法。
    当然，这还不够，但是，我想这能给你一个想法。我现在正在做这些想法背后的事情，但是我需要在把他们呈现给社区之前把它们设计得更好。
Conclusions总结
     你对这个方法有兴趣吗？让我知道你的想法，并且跟你的朋友分享这个帖子…我能从这个帖子得到越多的反馈，我就能更好的做好它。

    现在问题是..目前这个项目的状态是什么？
你可以看一下project homepage on javalinuxlabs. googlecode 上面，你可以在svn下面找到一些类。这不是这个工程的第一次实现…它差不多是这个想法的证明。但是，我们需要更努力的工作来让它更快的派上用场。

    订购这个feeds.我将会经常发表声明，并且其他的回复也会关注这个想法,以使之得到不断的修正。
    你想贡献一份力量吗？看看this page来更好的理解我们需要哪些帮助。







已有 3 人发表回复，猛击->>这里<<-参与讨论


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 你想过自己的博客制作成书吗 - JavaEye推出博客自动生成电子书功能！
• 加入阿里巴巴，发展潜力无限
• Windows7在微软WinHEC 2008上揭开神秘面纱