1.如何用SwingBuilder使用自定义的swing组件
2.java程序员为什么使用Groovy
3.Google Aviator——轻量级 Java 表达式引擎实战
4.groovy教程
5.规则引擎基本原理及应用架构简介

如何用SwingBuilder使用自定义的swing组件

       groovy已经在SwingBuilder里为我们预设了很多swing组件，以使我们可以用下面这样的快捷形式来构建界面：

       swingBuilder.frame(

       //属性集

       ){

       //子组件

       }

       å¯¹äºŽä»…仅使用swing的原生组件，这没有任何问题，但在实际开发中可能会遇到需要使用对原生组件扩展后的自定义组件（如一个继承了JPanel的MyPanel类）的情况，而这个类明显不可能出现在SwingBuilder的预设列表里，那这种情况下是不是就意味着不可以使用groovy为我们提供的便利，只能用回传统的java形式去构建界面呢？

       ç­”案是否定的。SwingBuilder虽然不会预设用户自定义的组件，但它提供了几个接口可以让用户把自定义的组件设置进去，这样就依然可以用groovy的快捷形式来构建界面了。这几个接口分别是：

       public void registerFactory(String name,源码 Factory factory)

       public void registerBeanFactory(String theName, Class beanClass)

       registerFactory()

       registerFactory方法可以注册一个自定义组件，name指定了通过swingBuilder构建组件的名称，如JFrame在swingBuilder里预设的name是"frame"，这就使得我们可以通过swingBuilder.frame()构建一个JFrame。

       ç¬¬äºŒä¸ªå‚数接收一个实现了Factory接口的类，这个类需指明（实现）如何实例化自定义组件（newInstance），如何处理add进来的子组件（setChild）等一系列策略。通常并不需要直接实现Factory接口，groovy为我们提供了一个抽象类（AbstractFactory），我们应优先继承这个类，然后再按需挑相应的方法进行重写。下面来看一个如何使用这个接口的例子：

       /

       * 自定义了一个可以显示背景图片的面板

       * @author keenlight

       */

       class ImagePanel extends JPanel{

       /

       */

       private static final long serialVersionUID = 1L

       private BufferedImage image

       public ImagePanel(BufferedImage image){

       super()

       this.image = image

       }

       public ImagePanel(BufferedImage image, LayoutManager layout) {

       super(layout)

       this.image = image

       }

       public void paintComponent(Graphics g)

       {

       super.paintComponent(g)

       if(image != null){

       g.drawImage(image, 0, 0, this)

       }

       }

       }

       /

       * ImagePanel的Factory

       * @author keenlight

       */

       class ImagePanelFactory extends AbstractFactory{

       private BufferedImage image

       ImagePanelFactory(BufferedImage image){

       this.image = image

       }

       @Override

       public Object newInstance(FactoryBuilderSupport builder, Object name, Object value, Map properties) throws InstantiationException, IllegalAccessException {

       def layout = properties.remove("layout")

       new ImagePanel(image, layout)

       }

       public void setChild(FactoryBuilderSupport builder, Object parent, Object child) {

       if (!(child instanceof Component) || (child instanceof Window)) {

       return

       }

       parent = parent as ImagePanel

       try {

       def constraints = builder.context.constraints

       if (constraints != null) {

       parent.add(child, constraints)

       if (child instanceof JComponent) {

       child.putClientProperty(LayoutFactory.DEFAULT_DELEGATE_PROPERTY_CONSTRAINT, constraints)

       }

       builder.context.remove('constraints')

       } else {

       parent.add(child)

       }

       } catch (MissingPropertyException mpe) {

       parent.add(child)

       }

       }

       }

       å®šä¹‰å¥½è¿™äº›ç±»åŽå¦‚何使其生效？只需一步：

       def bgImage = ImageIO.read(new File(image_path))

       swingBuilder.registerFactory("imagePanel", new ImagePanelFactory(bgImage))

       æ³¨å†Œå¥½ä¹‹åŽï¼ŒImagePanel组件便可像其他原生组件一样使用了（如上文的JFrame一样）。

       registerBeanFactory()

       registerBeanFactory是registerFactory的一种便利形式，调用此接口无需提供Factory，只需提供自定义类的类名即可。比如原生组件里的JPanel就是用这个接口注册的，SwingBuilder类中注册JPanel的源码如下：

       registerBeanFactory("panel", JPanel)

       è¿™æ ·å°±å¯ä»¥æŠŠJPanel注册为"panel"来使用了。其实registerBeanFactory这个方法里面一样也实例化了一个继承了AbstractFactory类，它会把调用这个方法注册的组件当做一个javaBean（方法名已经很明显了），所以它在继承AbstractFactory类时重写的newInstance方法里是直接返回调用class.newInstance()的实例化结果，class由第二个入参提供。所以对于那些在实例化时调用默认构造器就足够的组件，用registerBeanFactory()方法来注册会更为便利。当然，对于我上面定义的ImagePanel来说就不行了，因为ImagePanel类在实例化时需要接受一个图片对象，所以必须使用略麻烦一点的registerFactory()。

java程序员为什么使用Groovy

       ä¸€ç›´å¬è¯´java世界里有个Groovy，但是一直没时间去了解它究竟是一个怎么样子的。我们现在的项目里放了很多开源包，而且项目中做流程的时候，规则就是用Groovy实现的。近来闲来无事，于是开始认真的看看Groory究竟有什么好的。其实最初我接触它是因为Grails这一个框架，这两个都是为了实现一个目的，java的敏捷开发，与java的无缝对接。在某些情况下，java需要半天处理的事情，Groovy只需要几分钟，是的，几分钟…剩下来的时间，程序员终于有时间泡妹子了，^_^…….技术宅的兄弟，赶紧来看看吧。

        脚本语言，动态语言？难道是javascript一类的？好吧，它的确和javascript有一点像，但是它太强大了，远远超出了javascript能处理的事情。这里不和javascript做比较了，直接来和Java比较吧，看看Groovy能做什么。

       Groovy 的网站（ http://groovy.codehaus.org ） 给出了 groovy 的最好定义： groovy 是在 java平台上的、 具有象 Python ， Ruby 和 Smalltalk 语言特性的灵活动态语言， groovy 保证了这些特性象 java 语法一样被 java 开发者使用。 而且学习Groovy对javaer来说，是很容易的一件事情。如果你还没有开始学Ruby，来吧，和我一起来Groovying一下…………而且附带一个Grails来媲美Ruby on rails。

        1.Groovy可以兼容java。

        是的，你可以用java语法来编写groovy,最后还可以生成class文件，直接用java调用。你会说，这有什么好的，不就是改了个后缀名么？呕，也许吧…但是它的亮点当然不是这个，它的亮点是你可以在Groovy里面直接用java语法混搭写，当然不是很推荐这样做的。

       2.Groovy是动态的。

       ä¸éœ€è¦java的反射，不需要冗长的代码，不需要各种try catch 异常，你就可以实现各种神奇的事情。Groovy的class可以这样新增一个方法，或者调用它。

       //用闭包定义一个方法 var1为参数 ,->后面是执行语句（当然参数不是必须的）

       def methodA={ var1-> print "this is methodA"}

       //用闭包定义一个方法 var1为参数 ,->后面是执行语句（当然参数不是必须的）

       def methodB={ var1-> print "this is methodB"}

       String.metaClass.addMethodA=methodA; //将methodA绑定为成员方法。

       String.metaClass.'static'.addMethodB=methodB; //将methodB绑定为静态方法

       String s="str";

       s.addMethodA('good'); //实例调用方法A

       String.addMethodB('hello'); //静态类调用方法B

       ä»¥ä¸Šçš„代码将两个方法添加到了String class里面（天哪，final的String 也被攻破了），然后分别用实例对象调用addMethodA,静态类调用AddMethodB.

       3.Groovy是一把瑞士军刀。

       java是一把基础工具，等你需要的时候，你需要到处去找jar包，来填充自己的程序，而且你需要看API去弄懂各种使用。此外，java的编写实在是太冗长了，为了打印一个HelloWorld，你需要编写class, 写一个main函数。对于Groovy来说：print “hello world!”.这一句就足够了，这只是开始…

       é€šè¿‡ groovy 你能快速的打开控制台， 通过输入如下代码来输出所有的文件名 ( 递归处理 ) ：

       groovy -e "new File('.').eachFileRecurse { println it }"

       å³ä½¿ java 有一个名称为 eachFileRecurse 的方法和一个 FileListener 的接口，你仍旧需要显示的创建一个类， 声明一个 main 方法， 保存源代码到一个文件中， 并且编译它， 然后你才能运行它， 基于比较， 我们来看看 java 做相同工作的代码， 我们假设存在单独的 eachFileRecurse 方法：

       public class ListFiles { // JAVA !!

       public static void main(String[] args) {

        new java.io.File(".").eachFileRecurse( // 假设 java 存在该方法

        new FileListener() {

        public void onFile (File file) {

        System.out.println(file.toString());

        }

        }

       );

       }

       å¥½å§ï¼Œä¸‹è½½ä¸€æœ¬å¥½ä¹¦ã€ŠGroovy in Action[文字版][中文].pdf》，现在开始学习Groovy吧。

Google Aviator——轻量级 Java 表达式引擎实战

       本文将探讨Google Aviator——一款轻量级Java表达式引擎，其在实战中的源码表现和与其他常用表达式引擎如Drools、IKExpression和Groovy的源码对比。Drools以其高性能和Java实现闻名，源码但主要关注复杂对象的源码规则匹配，而Aviator则定位在轻量级和高性能之间，源码115源码交易编译执行模式提供更好的源码性能。IKExpression作为解释执行的源码引擎，虽然简洁，源码但在性能上不如Aviator和Groovy。源码Groovy凭借动态执行和JIT编译，源码适用于频繁执行的源码场景。

       在实际场景中，源码比如监控告警规则配置，源码Aviator能快速将规则转化为表达式并执行，源码如示例所示：

       通过自定义函数实现，只需继承AbstractAlertFunction，h5棋牌源码海蓝积分如源码所示，并在初始化时注册。对于性能问题，推荐使用编译缓存模式，以减少每次执行时的编译成本。

       Aviator的性能优化和管理可以通过其提供的缓存管理方法来实现。对于更深入的技术探讨和参考，可以参考作者的个人博客和相关文档。

groovy教程

       本文将简要介绍如何入门Groovy编程，从创建项目到运行代码。首先，我们通过New -> Project -> Java Project创建一个Java项目，为源文件管理，建议在source文件夹中创建java和groovy两个子文件夹，分别存放Java和Groovy源代码。

       接着，上海商城系统源码怎么用为项目添加Groovy支持至关重要。在项目右键菜单中选择"Groovy" -> "Add Groovy Nature"，这将引入Groovy Libraries，为项目集成Groovy功能。然后，我们可以在groovy源文件夹中右键，选择"New" -> "Other" -> "Groovy" -> "Groovy Class"，创建一个新的Groovy类。

       运行Groovy类同样简单。只需在源文件上右键，选择"Compile Groovy File"进行编译，再通过"Run As" -> "Groovy"运行。值得注意的是，Groovy语法的简洁性体现在即使文件中只有"println Hello World"这一行代码，程序也能正常运行。当然，微信改单系统源码下载为了显示Groovy与Java的兼容性，你也可以使用标准的Java语法编写HelloWorld类。

       总的来说，通过以上步骤，你已经具备了基本的Groovy项目创建和运行能力，可以开始探索Groovy语言的简练和便利之处了。

规则引擎基本原理及应用架构简介

       规则引擎，这个业务决策的革命性工具，其核心在于将复杂的业务逻辑抽象化，实现决策逻辑的独立分离。它如同一座高效运作的自动化工厂，输入数据，解析规则，产出决策，首要目标是业务逻辑的复用和快速响应市场变化。在开源领域，物联网云平台系统源码分类Java规则引擎的佼佼者有Drools和urule，后者凭借Rete算法和Drools Workbench的易用性以及活跃的社区备受青睐；Groovy则以其动态特性，强大的嵌入性成为另一选择。Drools以Java和Groovy编写规则，urule则强调规则设计工具，而Groovy则支持动态脚本加载，实现实时适应性。

       规则引擎的内部构造犹如精密的齿轮系统，工作内存和生产内存是其关键组件。urule的开源版本已停止更新，商业版本需特别关注，而Groovy借助JVM的特性，允许脚本热加载，但可能对内存管理带来挑战。为解决FullGC问题，脚本更新后需重新创建，以保持高效运行。

       Aviator，这个轻量级的表达式引擎，以其高效执行、小型化jar包和适度的功能特性，成为简单场景的理想选择。它虽功能“节制”，但扩展性强，适合基础开发，只是高级特性和复杂场景可能需要额外自定义函数支持。

       规则引擎的实现原理各异：Java结合Rete算法（如Drools和urule），脚本语言与JVM（如Groovy），以及Java表达式和JVM（如Aviator）。Rete算法的核心在于其高效的模式匹配机制，通过网络结构筛选和传播，以空间换时间，涉及的事实、规则、模式节点以及各种类型的节点如根节点、条件节点等。

       比如ObjectTypeNode，通过HashMap直接获取新实例，避免字面检查，展现了节点的高效性能。每个节点都有特定功能，如BetaNode处理连接与取反操作，记忆功能帮助高效决策；LeftInputAdapterNodes处理单对象转换；TerminalNode表示规则匹配，NotNode则负责结果取反。

       规则编译过程细致入微：首先创建根节点并加入规则和工作内存，接着为新类型创建类型节点并添加Alpha节点，然后组合Beta节点并构建内存表，封装动作为叶节点，最后如同执行数据库查询，执行预编译的规则。

       运行时，规则引擎通过一系列步骤：从工作内存出发，匹配事实，遍历节点，合并符合条件的事实，触发规则，加入议程，解决冲突，最终执行决策。Rete算法的共享性和优化设计，确保匹配速度独立于规则数量，同时避免重复计算。

       Groovy的实现原理源于Rete网络，其源码编译与Java类似，支持预编译和运行时加载。Groovy的动态性体现在表达式编译、函数定义、类生成以及元类机制，提供了灵活的开发环境。Aviator则通过ASM生成字节码，构建ClassExpression，体现了不同的编译策略。

       规则引擎的应用场景丰富多样，例如Drools架构强调规则的实时同步，适用于业务需求频繁变化的场景，自建后台集成Workbench则提供规则工程管理，尽管成本高，但支持高可用性和扩展性。URule则以Restful接口提供独立服务或客户端服务器模式，适用于复杂数据处理和规则管理，但需考虑负载均衡问题。

       无论哪种架构，规则引擎在业务策略管理、版本控制、变量管理、名单库管理、业务监控以及数据分析等领域都发挥着关键作用。从冠军规则到数据调用统计，规则引擎是现代企业中不可或缺的决策支持工具。