Jess：Java平台的规则引擎官方指南

5星 · 超过95%的资源需积分: 13 69 浏览量更新于2024-07-27 收藏 614KB PDF 举报

本文档是关于Jess推理Java Clips的官方指南，版本为7.1p2，发布于2008年11月5日。由Ernest Friedman-Hill和Sandia National Laboratories提供。Jess是专为Java平台设计的规则引擎，它允许开发者定义和执行复杂的逻辑规则，以便在特定条件下自动处理业务流程。 **1. 引言与入门** - Jess提供了一个集成开发环境（IDE），称为Jess DE，帮助用户快速上手。 - 入门步骤包括明确需求和准备环境，确保满足必要的软件配置。 **2. Jess DE 开发者环境** - 安装Jess DE是使用Jess的第一步，文档详细指导了安装过程。 - 使用Jess DE时，用户可以创建、编辑和测试规则，以及查看工作内存中的事实和推理结果。 **3. Jess语言基础** - 学习语言基础至关重要，包括符号的使用、数字和字符串的表示、列表数据结构、注释、函数调用、变量声明以及控制流的概念。 **4. 定义Jess函数** - Jess支持函数定义，包括正常函数和advice（用于处理特定事件或行为的特殊类型函数）。 - 函数的编写和调用是实现复杂逻辑的核心组件。 **5. 工作内存与事实管理** - 工作内存是Jess存储和操作事实的地方，包括模板（预定义的结构）、无序事实、对Java对象的隐喻性处理（shadow facts）、有序事实和defacts（动态添加的事实）。 - Jess如何实现事实和推理的底层机制也进行了深入解释。 **6. 自定义规则的创建** - 用户可以通过`defrule`语句创建规则，规则可以包含简单模式匹配、深度分析、多槽匹配、绑定、正则表达式应用等元素。 - 文档还介绍了 salience（规则执行顺序）和冲突解决策略，以及条件元素如`and`、`or`和`not`的使用。通过阅读这份文档，开发者能够掌握如何在Java平台上构建和运用Jess规则引擎来自动化业务决策和流程，从而提高代码的灵活性和可维护性。无论你是初学者还是经验丰富的开发者，都能从中获得关于Jess语言特性和实践应用的宝贵知识。

2. The JessDE Developer's Environment

To use the Rete Network View, you'll need to have the Eclipse Graph Editing Framework (GEF)

installed. You can get the GEF from the Eclipse project page here, or install it through Eclipse's

built-in update manager. Then to display this view, find it under the "Jess Debugger" group in

Eclipse's "Show view" dialog. Then when the cursor is inside a rule in a Jess editor window, the

Rete Network View will show the compiled network for that rule.

2.2. Using the JessDE

2.2.1. The Jess language editor

The JessDE editor can edit ".clp" files. By default, any file you create with the extension "clp" will

be opened using the JessDE editor. There's no separate Jess perspective, or Jess project type;

we expect that most people will use the JessDE tools to write the Jess components of a hybrid

Jess/Java application, and so the tools expect to be used on files in a Java project. The JessDE

uses your Java project's class path to resolve Java class names used in Jess language code --

i.e., in a call to the defclass function.

The editor has all the features you'd expect from a modern programmer's editor.

Syntax coloring you can customize.

You can change the default colors using the "Jess Editor" tab of the Eclipse global

preferences dialog.

Content assistant supplies deftemplate, slot and function names.

You can invoke Eclipse's "Content Assist" feature in many different places within the

JessDE editor; JessDE will make it much easier to enter Jess code. Press Alt-'/' while

typing to produce a list of choices.

"Quick fix" assistant can repair code automatically

This feature is bound to Ctrl-1 by default. Quick fix currently knows how to define

undefined deftemplates, and add new slots to existing deftemplates (if they're defined in

the same file.) More to come!

Real-time error checking with markers and error highlighting

Errors and warnings are highlighted as you type

Automatic code formatting

Code is indented as you type. You can also choose "Format" from the "Source" menu to

format an entire buffer.

Fast navigation using outline view

The Eclipse outline view lists all the constructs defined in a buffer; you can click on any

one of them to quickly navigate to it.

Parenthesis matching and auto-insertion

When you type a '(' or '"' character, JessDE insert the matching character as well. When

your cursor is next to a parenthesis, JessDE shows you the matching parenthesis.

Online help for Jess functions and constructs via "hovers"

You have quick access to the Jess manual description of every function and construct

type.

Help hovers for deftemplates and deffunctions

If you hold your mouse over the name of a deftemplate or deffunction, anywhere in the

code, JessDE will show a "tooltip" containing information about that template or function.

Run and Debug commands for Jess programs

You can run or debug a Jess program using the normal Eclipse "Run..." menu or by right

clicking on Navigator items or in the edit window.

2. The JessDE Developer's Environment

2.2.2. Dependencies among files

Sometimes one *.clp file depends on code in some other *.clp file having been read first; for

example, rules.clp might need the definitions in templates.clp. Without these definitions,

rules.clp will appear to have syntax errors. To deal with this, you can use the require*

function. "require*" lets you explicitly declare these dependencies.

If a file rules.clp depends on Jess commands being executed from Java, you can deal with this

by creating a special file just for this purpose (you might call it ruledepends.clp). That special

file can contain whatever declarations are needed to make rule.clp parse properly in the editor.

If you add "(require* ruledepends)" to rules.clp, then this extra file will be parsed only if it's

present, as it will be during development. When you deploy the code, you can simply not deploy

ruledepends.clp, and allow rules.clp to get its declarations from Java code.

The "require" mechanism replaces the "Source dependencies" property sheet from earlier

versions of JessDE, which is no longer supported.

2.2.3. The Rete Network view

You can instantly see a graphical representation of the Rete network derived from any rule

using the JessDE's "Rete Network View". When this view is open (you can open it using the

"Windows | View | Other..." dialog in Eclipse) it will display the Rete network for the rule that the

editor caret is in. You can use this to see, in real time, how modifying a rule changes the Rete

network. The graph layout is far superior to that you get from the Jess "view" command -- there

are no overlapping or crossing lines, and the height of each "column" can vary.

2.2.4. The Jess debugger

The JessDE debugger lets you debug a Jess program defined in a .clp file. It has all the

features you'd expect from a graphical debugger: you can suspend and resume a program, or

step through it. When the program is stopped, the contents of the execution stack are displayed,

and you can examine the variables defined in each stack frame. Selecting a stack frame also

navigates to the source code being executed. You can also set (or clear) breakpoints in any .clp

file by right-clicking in the ruler on the left-hand edge of the editor window. Breakpoints can be

set only on functions (either built-in or user defined), so you can't break on a defrule or

deftemplate construct. You can, however, break on a function call on the left or right-hand side

of a rule.

3. Jess Language Basics

Most of the time, you'll write Jess rules in the Jess rule language. If you've never used Lisp, the

Jess rule language may look a bit odd at first, but it doesn't take long to learn. The payoff is that

it's very expressive, and can implement complex logical relationships with very little code.

In this chapter, we'll look at the basic syntax of the Jess language. In subsequent chapters, we'll

learn how to define high-level concepts like facts and rules, but here, we'll just be looking at the

nuts and bolts.

In this language guide, I'll use an extremely informal notation to describe syntax. Basically

strings in <angle-brackets> are some kind of data that must be supplied; things in [square

brackets] are optional, things ending with + can appear one or more times, and things ending

with * can appear zero or more times. In general, input to Jess is free-format. Newlines are

generally not significant and are treated as whitespace; exceptions will be noted.

3.1. Symbols

The symbol is a core concept of the Jess language. Symbols are very much like identifiers in

other languages. A Jess symbol can contain letters, digits, and the following punctuation:

$*=+/<>_?#. . A symbol may not begin with a digit; it may begin with some punctuation marks

(some have special meanings as operators when they appear at the start of a symbol).

Jess symbols are case sensitive: foo, FOO and Foo are all different symbols.

The best symbols consist of letters, digits, underscores, and dashes; dashes are traditional

word separators. The following are all valid symbols:

foo first-value contestant#1 _abc

There are three "magic" symbols that Jess interprets specially: nil, which is somewhat akin to

Java's null value; and TRUE and FALSE, which are Jess' boolean values.

3.2. Numbers

Jess uses the Java functions parseInt(java.lang.String), parseLong(java.lang.String), and

parseDouble(java.lang.String) to parse integer, long, and floating point numbers, respectively.

See the documentation for those methods for a precise syntax description. The following are all

valid numbers:

3 4. 5.643 5654L 6.0E4 1D

3.3. Strings

Character strings in Jess are denoted using double quotes ("). Backslashes (\) can be used to

escape embedded quote symbols. Note that Jess strings are unlike Java strings in several

important ways. First, no "escape sequences" are recognized. You cannot embed a newline in a

string using "\n", for example. On the other hand, real newlines are allowed inside double-

quoted strings; they become part of the string. The following are all valid strings:

"foo" "Hello, World" "\"Nonsense,\" he said firmly." "Hello,

3. Jess Language Basics

There"

The last string is equivalent to the Java string "Hello,\nThere".

3.4. Lists

Another fundamental unit of syntax in Jess is the list. A list always consists of an enclosing set

of parentheses and zero or more symbols, numbers, strings, or other lists. The following are

valid lists:

(+ 3 2) (a b c) ("Hello, World") () (deftemplate foo (slot bar))

The first element of a list (the car of the list in Lisp parlance) is often called the list's head in

Jess.

3.5. Comments

Jess supports two kinds of programmer's comments: Lisp-style line comments and C-style block

comments. Line comments begin with a semicolon (;) and extend to the end of the line of text.

Here is an example of a line comment:

; This is a list

(a b c)

Block comments work as they do in C: they start with the two characters "/*" and end with "*/".

Block comments don't nest.

Here is an example of a list (commented out):

(a b c)

Comments can appear anywhere in a Jess program, including inside constructs like templates

and rules.

3.6. Calling functions

As in Lisp, all code in Jess (control structures, assignments, procedure calls) takes the form of a

function call. There are no "operators"; everything is a function call. However, some functions

have names that look like Java operators, and in these cases, they operate much like their Java

counterparts.

Function calls in Jess are simply lists. Function calls use a prefix notation; a list whose head is a

symbol that is the name of an existing function can be a function call. For example, an

expression that uses the + function to add the numbers 2 and 3 would be written (+ 2 3). When

evaluated, the value of this expression is the number 5 (not a list containing the single element

5!). In general, expressions are recognized as such and evaluated in context when appropriate.

You can type expressions at the Jess> prompt. Jess evaluates the expression and prints the

result:

Jess> (+ 2 3)

Jess> (+ (+ 2 3) (* 3 3))

剩余203页未读，继续阅读

chenxiao899

粉丝: 0
资源: 1

Jess：Java平台的规则引擎官方指南

jess.jar JESS java规则

Manning - Jess in Action书籍源代码

规则系统JESS 7.1 P2

Manning - JESS in Action - Rule-Based.Systems in Java

ng-proper-possessive:用于处理姿势名词的AngularJS指令（Bill's vs Jess'）

基于web的在线图书销售系统的设计与开发毕业设计_说明.doc

MStar_TV_SN客户开发指导书_V1.1-Cultraview.pdf

Jess in Action：Java规则引擎实战

基于React框架的react-demo设计源码学习参考

Delphi 12 控件之unidac-10.3.1-d25pro.exe

最新资源