Jess7.0p1：Java平台上的规则引擎入门指南

PDF文件

下载需积分: 0 | 765KB | 更新于2024-07-29 | 164 浏览量 | 举报 1 收藏

立即下载

"《jess应用手册》是关于Jess推理机的详细指南，重点讲解了如何在Java平台上使用Jess。虽然手册是英文版，但通过深入阅读，可以理解其内容。手册涵盖了Jess开发环境的安装与使用、Jess语言基础、函数定义、工作内存管理以及规则的创建等多个方面。" Jess是基于Java平台的规则引擎，它主要用于构建专家系统，通过推理处理复杂的逻辑和数据。以下是手册中涉及的关键知识点： 1. **JessDE开发者环境**: JessDE（Jess Developer's Environment）是Jess的集成开发环境，提供了安装指南和使用教程，帮助开发者进行规则编写和测试。 2. **Jess语言基础**: 包括符号、数字、字符串、列表和注释的基本概念。列表可以表示复杂的数据结构，而变量则用于存储和传递值。 3. **函数调用**: Jess支持调用函数，这是执行特定任务或计算的重要部分。 4. **定义函数**: `deffunction`用于定义用户自定义函数，而`defadvice`则允许在函数调用前后添加行为，实现方法的增强或拦截。 5. **工作内存**: 工作内存是Jess的核心组成部分，它存储事实（facts）。模板定义了事实的结构，分为无序事实、阴影事实、有序事实等类型，通过`deffacts`来创建。 6. **规则定义**: `defrule`是创建规则的主要构造，规则由条件和动作组成。简单的模式匹配是规则的基础，深入的模式则包括多槽匹配。规则的冲突解决机制可以通过优先级（salience）来控制。 7. **条件元素**: 包括'and'、'or'、'not'、'exists'等，这些元素决定了规则的触发条件。'and'表示所有子条件都必须满足，'or'则只需满足其中之一，'not'表示否定一个条件，'exists'检查是否存在满足条件的事实。手册详细阐述了 Jess 的使用方法，对于理解规则引擎的工作原理和在Java环境中构建专家系统非常有帮助。通过学习这些内容，开发者能够熟练地利用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

2. The JessDE Developer's Environment

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.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 express 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, numbers, and the following

punctuation: $*=+/<>_?#. . A symbol may not begin with a number; 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, numbers, 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

3. Jess Language Basics

inside double-quoted strings; they become part of the string. The following are all valid

strings:

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

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)

剩余191页未读，继续阅读

little_huaduo

粉丝: 5

Jess7.0p1：Java平台上的规则引擎入门指南

JESS+JAVA详细配置手册

规则系统JESS 7.1 P2

jess运用，语法介绍，环境配置

Fuzzy Jess&jFuzzyLogic

java专家系统jess资源包

MTK9255 用户手册

Jess专家系统使用教程详解

Java专家系统Jess资源包深度解析

Jess in Action：Java中的规则系统

JESS 7.1 P2版本发布：增强的规则系统全面解禁

探索Java中的Jess规则系统：实战与资源分享

Java中的规则基础系统：《Jess in Action》深度解析

MT9255用户手册：开发与更新指南

Razor开发指南：全面详解与应用

三菱图形操作终端连接手册（非三菱产品1）.pdf

【基于RESTful设计的高性能API接口实战开发：用户管理与权限控制系统全流程详解】

Canvas实现两张图片合成操作

【电子设计竞赛】2025电赛D题全解：声音定位系统设计与实现详解

在 Service 和 Activity 之间传递 Action 时，Action 定义的问题【重名】

综合布线设计与施工教学魏楚元.pptx

最新资源