今天尝试了将jbpm和spring进行结合，主要参考http://betafox.javaeye.com/blog/177649来进行。

版本：

jbpm          3.1.4

struts2       2.0.11

spring        2.5.1

hibernate   3.2.5.ga

配置文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:util="http://www.springframework.org/schema/util"
	xmlns:jee="http://www.springframework.org/schema/jee"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:lang="http://www.springframework.org/schema/lang"
	xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd"
	default-autowire="byName">

	<bean id="workflow1"
		class="org.springmodules.workflow.jbpm31.definition.ProcessDefinitionFactoryBean">
		<property name="definitionLocation"
			value="classpath:jbpm/processes/processdefinition.xml" />
	</bean>

	<!-- jBPM configuration-->
	<bean id="jbpmConfiguration"
		class="org.springmodules.workflow.jbpm31.LocalJbpmConfigurationFactoryBean">
		<property name="sessionFactory" ref="sessionFactory" />
		<property name="configuration" value="classpath:jbpm.cfg.xml" />

		<property name="processDefinitions">
			<list>
				<ref local="workflow1" />
			</list>
		</property>
		<!-- 
			<property name="createSchema" value="true" />
			<property name="dropSchema" value="true" />
		-->
	</bean>

	<!-- jBPM template -->
	<bean id="jbpmTemplate"
		class="org.springmodules.workflow.jbpm31.JbpmTemplate">
		<constructor-arg index="0" ref="jbpmConfiguration" />
		<constructor-arg index="1" ref="workflow1" />
	</bean>

</beans>

 在casspath下添加了jbpm.cfg.xml，内容是从default.jbpm.cfg.xml中复制过来的：

<jbpm-configuration>

	<jbpm-context name="default.jbpm.context">

		<service name="persistence"
			factory="org.jbpm.persistence.db.DbPersistenceServiceFactory" />
		<service name="message"
			factory="org.jbpm.msg.db.DbMessageServiceFactory" />
		<service name="scheduler"
			factory="org.jbpm.scheduler.db.DbSchedulerServiceFactory" />
		<service name="logging"
			factory="org.jbpm.logging.db.DbLoggingServiceFactory" />
		<service name="authentication"
			factory="org.jbpm.security.authentication.DefaultAuthenticationServiceFactory" />
	</jbpm-context>


	<!-- 不再使用<string name="resource.hibernate.cfg.xml" value="hibernate.cfg.xml" />-->
	<string name="resource.business.calendar"
		value="org/jbpm/calendar/jbpm.business.calendar.properties" />
	<string name="resource.default.modules"
		value="org/jbpm/graph/def/jbpm.default.modules.properties" />
	<string name="resource.converter"
		value="org/jbpm/db/hibernate/jbpm.converter.properties" />
	<string name="resource.action.types"
		value="org/jbpm/graph/action/action.types.xml" />
	<string name="resource.node.types"
		value="org/jbpm/graph/node/node.types.xml" />
	<string name="resource.parsers"
		value="org/jbpm/jpdl/par/jbpm.parsers.xml" />
	<string name="resource.varmapping"
		value="org/jbpm/context/exe/jbpm.varmapping.xml" />

</jbpm-configuration>

在配置过程中也遇到了一些问题。

问题一：系统报找不到 default.jbpm.context。

解决方法：在自己的jbpm.cfg.xml中设置

jbpm-context name="default.jbpm.context"

问题二：系统报找不到hibernate.cfg.xml。

解决方法：我的系统里hibernate配置放在spring的配置文件里，没有使用hibernate.cfg.xml。跟踪DbPersistenceServiceFactory和LocalJbpmConfigurationFactoryBean.afterPropertiesSet发现问题出在jbpmContext构建时需要获取持久层，如果sessionFactory存在则不会去读取hibernate.cfg.xml，除了在配置jbpmConfiguration时要设置sessionFactory外，如果jbpm的数据库表已经存在，则不要设置createSchema和dropSchema否则会报错。按上面的配置文件设置后，不会再去读取hibernate.cfg.xml，可以注释掉jbpm.cfg.xml中的resource.hibernate.cfg.xml。

注意：如果使用这种配置方式，省略了hibernate.cfg.xml文件，但如果调用jbpmConfiguration.createSchema();jbpmConfiguration.dropSchema();等方法还是会出错，跟踪源码可以发现这些方法都会调用DbPersistenceServiceFactory.getConfiguration()方法，这个方法会去读取hibernate.cfg.xml。我们可以使用jbpm-db\build\mysql\scripts\下的脚本手工创建或删除数据库，这在做单元测试时稍显麻烦。

问题三：jbpm-identity中有User.hbm.xml，这个名称与我系统中原有的User.hbml.xml冲突，尽管他们不在同一个包中，但还是产生了冲突。只能调整一下自己的代码了。

spring配置文件中配置流程定义的xml有些多余，反而使系统在启动的时候更新数据库里的流程定义。完全可以将流程部署到数据库。JbpmTemplate有无参数的构造器，可以不使用构造器注入，只需要在spring配置文件中注它的jbpmConfiguration属性就可以了。

另，没有添加参考文章里说的过滤器，暂时没发现问题。

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

在使用使用FormPanel时我们通常需要使用它的form对象来加载数据或提交数据。FormPanel中的 form对象为Ext.form.BasicForm类型的对象，它有load和submit方法分别用于加载数据和提交数据。而这两个方法都是通过调用 Ext.form.BasicForm中的doAction方法来操作的。doAction方法带有两个参数，其中第二个参数为从load或submit 方法传递过来的Ext.form.Action对象的配置数据（Config Options）。其中的success和failure属性是用于处理请求成功或失败的函数。但需要注意的是，文档中的说明是这个success或 failure取决于Http请求过程是否出错。实际情况却并非这样，我在开发过程中发现HTTP响应代码一直都是200，但被调用的函数却一直都是 failure属性对应的函数。通过查看Action.js可以发现响应过来的数据是需要符合一定格式的，Ext.form.Action.Load的 API文档开头就说明了响应数据包必须类似下面的格式：

{
    success: true,
    data: {
        clientName: "Fred. Olsen Lines",
        portOfLoading: "FXT",
        portOfDischarge: "OSL"
    }
}

小结：

1. ExtJS中JsonReader对于数据的处理总是一致的，不管你需要的是单条记录还是多条记录，它总是通过total属性判断记录数，通过root属性对应的名称来取记录集合。
2. FormPanel中处理数据的为内置的BasicForm类型的对象，它通过load和submit方法来加载或提交数据。而这两个方法是通过 Ext.form.Action的两个子类Ext.form.Action.Load、Ext.form.Action.Submit来提交请求和调用用 户的success和failure方法。决定调用success和failure的并非Http请求是否出错，而是决定于Action.js中 handleResponse的处理结果。我们可以通过设置FormPanel的reader配置对象来干预handleResponse对数据的处理。 而这个reader也可设置响应数据与FormPanel中字段的对应关系。
3. 多看源码，可以获取更多。

附：

表格中双击进行编辑的JS源码，这个代码比官方文档中的处理方式简单一些，觉得官方文档中的edit中加载数据的处理是一种hack的方式，并不太适合实际应用。

ExtJS网站上的CRUD的文章，其中包含有加载数据进行编辑的例子

Ext.onReady(function(){
var newFormWin;
var form1;

    //表格处理
    //Ext.BLANK_IMAGE_URL = 'extjs/resources/images/default/s.gif';
    Ext.QuickTips.init();
    var sm = new Ext.grid.CheckboxSelectionModel(); //CheckBox选择列

    var cm = new Ext.grid.ColumnModel([
        new Ext.grid.RowNumberer(), //行号列
        sm,
        {header:'编号',dataIndex:'id'},
        {header:'性别',dataIndex:'sex',renderer:function(value){
            if(value=='1'){
                return "男";
            }else{
                return "女";
            }
        }}, //增加性别，自定义renderer，即显示的样式，可以加html代码，来显示图片等。
        {header:'名称',dataIndex:'name'},
        {header:'描述',dataIndex:'memo'}
    ]);

    var ds = new Ext.data.Store({
        proxy: new Ext.data.HttpProxy({url:ACTION_URL}),//调用的动作
        reader: new Ext.data.JsonReader({
            totalProperty: 'total',
            root: 'list',
            successProperty :'success'
        },
                                        [{name: 'id',mapping:'id',type:'string'},
                                         {name: 'sex',mapping:'sex',type:'string'},
                                         {name: 'name',mapping:'name',type:'string'},
                                         {name: 'memo',mapping:'memo',type:'string'} //列的映射
                                        ])
    });


    var grid = new Ext.grid.GridPanel({
        id: 'grid',
        el: 'center',
        region:'center',
        title:'用户',
        ds: ds,
        sm: sm,
        cm: cm,
        bbar: new Ext.PagingToolbar({
            pageSize: 10,
            store: ds,
            displayInfo: true,
            displayMsg: '显示第 {0} 条到 {1} 条记录，一共 {2} 条',
            emptyMsg: "没有记录"
        }) //页脚显示分页
    });


    //布局处理
    Ext.state.Manager.setProvider(new Ext.state.CookieProvider());
    new Ext.Viewport({
        layout:'border',
        items:[
            {
                xtype:'box',
                region:'north',
                el: 'north',
                height:32,
                title:'north'
            },{
                region:'south',
                contentEl: 'south',
                split:true,
                height: 100,
                minSize: 100,
                maxSize: 200,
                collapsible: true,
                title:'South',
                margins:'0 0 0 0'
            },
            grid
        ]
    });

    //el:指定html元素用于显示grid
    grid.render();//Ext.getCmp('grid').render();//渲染表格
    ds.load({params:{start:0, limit:10}}); //加载数据

    grid.on("rowdblclick", function(grid) {
        loadFormData(grid);
        //alert(form1.reader);
    });

    // 载入被选择的数据行的表单数据
    var loadFormData = function(grid) {
        var _record = grid.getSelectionModel().getSelected();
        if (!_record) {
            Ext.example.msg('修改操作', '请选择要修改的一项！');
        } else {
            myFormWin();
            form1.form.load( {
                url : EDIT_ACTION_URL+'?sid='+ _record.get('id'),
                waitMsg : '正在载入数据...',
                success : function(form,action) {
                    Ext.example.msg('编辑', '载入成功！');
                },
                failure : function(form,action) {
                    Ext.example.msg('编辑', '载入失败');
                }
            });
        }
    };




    var myFormWin = function() {
        // create the window on the first click and reuse on subsequent
        // clicks

        if (!newFormWin) {
            newFormWin = new Ext.Window( {
                el : 'topic-win',
                layout : 'fit',
                width : 400,
                height : 300,
                closeAction : 'hide',
                plain : true,
                title : '窗口',
                items : form1
            });
        }
        newFormWin.show('New1');
    };



    form1 = new Ext.FormPanel( {
        // collapsible : true,// 是否可以展开
        labelWidth : 75, // label settings here cascade unless overridden
        url : 'AddLevel.action',
        frame : true,
        title : '修改',
        bodyStyle : 'padding:5px 5px 0',
        width : 350,
        waitMsgTarget : true,
        //这个属性决定了load和submit中对数据的处理，list必须是一个集合类型，json格式应该是[]包含的一个数组
        reader: new Ext.data.JsonReader({root:'list'},
                                        [{name: 'id',mapping:'id',type:'string'},
                                         {name: 'sex',mapping:'sex',type:'string'},
                                         {name: 'memo',mapping:'memo',type:'string'}
                                        ]),
        defaults : {
            width : 230
        },
        defaultType : 'textfield',
        items : [ {
            fieldLabel : '编号',
            name : 'id',
            allowBlank : false
        }, {
            fieldLabel : '性别',
            name : 'sex',
            allowBlank : false
        }, new Ext.form.TextArea( {
            fieldLabel : '备注',
            name : 'memo',
            growMin : 234
        })],

        buttons : [ {
            text : '保存',
            disabled : false,
            handler : function() {
                if (form1.form.isValid()) {
                    form1.form.submit( {
                        url : 'AddLevel.action',
                        success : function(from, action) {
                            Ext.example.msg('保存成功', '添加级别成功！');
                            ds.load( {
                                params : {
                                    start : 0,
                                    limit : 30,
                                    forumId : 4
                                }
                            });
                        },
                        failure : function(form, action) {
                            Ext.example.msg('保存失败', '添加级别失败！');
                        },
                        waitMsg : '正在保存数据，稍后...'
                    });
                    dialog.hide();
                } else {
                    Ext.Msg.alert('信息', '请填写完成再提交!');
                }
            }
        }, {
            text : '取消',
            handler : function() {
                newFormWin.hide();
            }
        }]
    });



});

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛

一直以来对于w3m、tramp、dired等与shell关系密切的mode不是很了解，没有仔细读过代码。但总觉得应该是调用shell命令，再将shell命令的输出重定向到emacs中进行处理。今天在网上看到了相关的方法：

1. 调用shell命令

   (defun zj-open-directory-with-explorer ()
     "在windows中用explorer浏览当前目录"
     (interactive)
     (shell-command "explorer.exe .")
     (browse-url "www.google.cn")
     )
   

    
2. 处理shell命令输出

   (defun zj-display-directory-files ()
     "执行shell命令并处理它的输出。这里为显示当前目录下的文件"
     (interactive)
     (message (shell-command-to-string "ls -l"))
     )

    

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

关于实体对象

实体对象包含了业务逻辑和对表的DML操作。

对象模型和关键类

• oracle.apps.fnd.framework.server.OAEntityCache：这个缓冲用于存储特殊实体的查询过的行。映射到同样的实体的多个视图对象共享相同的实体缓存。
• <YourEntityName>EOImpl继承oracle.apps.fnd.framework.server.OAEntityImpl：这是实体对象本身。当实例化后，它代表数据中的一行。
• oracle.apps.fnd.framework.server.OAEntityDefImpl：表示描述实体对象的元数据，包括属性 （attributes）、事件、校验器、关联和属性（properties）。当实例化后，它描述了实体对象类的所有实例。实体定义类是一个单例类。
• <YourEntityName>Expert继承oracle.apps.fnd.framework.server.OAEntityExpert：这是一个特殊的单例辅助类，它用于注册一个实体。
• oracle.jbo.Key：这是一个不可变的主、外键或复合主键。

创建

为了创建实体对象，必须调用对应的上层视图对象中的createRow方法然后再调用insertRow方法。

// In the application module; this example from the OA Framework
// ToolBox Tutorial will instantiate a SupplierEOImpl.

public void create()
{
  OAViewObject vo = getSuppliersVO();
  vo.insertRow(vo.createRow());

  // Always call this after you perform a row insert. See the Entity Object
  // New / Initial section below for additional information.
  vo.setNewRowState(Row.STATUS_INITIALIZED);
}

警告： 不要将初始化逻辑放到实体对象的构造器中；总是应该将这些代码添加到create()方法中super.create(attributeList)方法调用的后面。

技巧： 如果默认值可以在设计时决定，并且是为特定的UI而决定的，也可以通过在设计器中设置item的Initial Value属性来指定默认值。这些值可以被用户个性化；而不需要创建实体你的对象的子类并覆盖create()方法来设置默认值。查看 Defaulting章节查看细节信息。

/**
 * In the SupplierEOImpl class; initialize a new supplier.
 */
Public void create(AttributeList attributeList)
{
  super.create(attributeList);
  OADBTransaction transaction = getOADBTransaction();

  // Supplier id is obtained from the table's sequence
  Number supplierId = transaction.getSequenceValue("FWK_TBX_SUPPLIERS_S");
  setSupplierId(supplierId);

  // Start date should be set to sysdate
  setStartDate(transaction.getCurrentDBDate());
} // end create()

复合实体关联

在复合关联中BC4J将在设置父对象主键属性值时自动设置子实体对象。父对象主键值是在调用create()方法时通过attributeList参数传递进去的，并且在super.create(attributeList)被执行时被设置值。

不要尝试自己来处理主键值。

实体对象的Initial/New状态

缺省情况下，实体对象被创建时row状态为STATUS_NEW，并且BC4J将它们添加到它们的校验器中并且 post监听。这时，任何事件触发校验或数据库提交sequence包括这些实体对象。（By default, entity objects are created with the row state of STATUS_NEW, and BC4J adds them to its validation and post listener lists. In this case, any event that triggers a validation or database post sequence includes these entity objects.）

如OA Framework Model Coding Standards中的规定，应该将通过显式的在视图对象中调用创建新行的方法后立即调用ViewRowImpl对象的setNewRowState(STATE_INITIALIZED)方法。

当执行这个后，BC4J将从事务中和校验监听列表中移除对应的实体对象，这样它们将不会被校验或提交到数据库。当用户做出修改（属性的 “setter”被调用后），实体对象的状态修改为STATUS_NEW，并且BC4J返回它到validation/post lists。你也可以在ViewRowImpl上调用setNewRowState(STATUS_NEW)在任何时候手工改变状态。

特殊“Create”的情况

“Flattened”主／从处于单一行中

在OA Framework ToolBox教程中，我们有主／从实体显示于同一行中，“flattened”行中。比如采购单包含了很多行，它们依次包含了多个供货商，在我们的UI中，我们将采购单的行和供货单实现为1:1的关系。

尽管BC4J可以很容易的为单个视图对象行创建多个不同类型的实体对象——这些实体对象是不相关的或是平等的——在一个对象是另一个对象子对象时需 要你介入。在这种情况下，必须在你的视图对象行实现的create()方法中添加下面的代码，以确保正确的父对象的主键被设置到低层次的子对象的实体中：

// The following is required to support the creating the master/detail line
// and shipment entities that have been "flattened" into a single row in
// POLineShipFullVO with a 1:1 join.
//
// If you don't do this, BC4J will automatically treat them like peers and
// try to set the po header id as the parent key for both entities.

protected void create(oracle.jbo.AttributeList nvp)
{
  PurchaseOrderLineEOImpl lineEO = (PurchaseOrderLineEOImpl)getEntity(0);
  PurchaseOrderShipmentEOImpl shipmentEO = (PurchaseOrderShipmentEOImpl)getEntity(1);

  try
  {
    // Create Lines EO
    lineEO.create(nvp);

    // Create Shipments EO
    shipmentEO.create(lineEO);

    // Calling this ensures that any personalization default values are
    // properly set since the OAF normally sets this in the super.create(), but
    // since this is not called in this workaround, we need another method
    // to ensure customer defaults are applied.
    setDefaultValue();
  }
  catch (Exception ex)
  {
    lineEO.revert();
    shipmentEO.revert();

    if (ex instanceof oracle.jbo.JboException)
    {
      oracle.jbo.JboException jboEx = (oracle.jbo.JboException)ex;
      // Developers have to do the mapping on their own because of the override.
      jboEx.doEntityToVOMapping(getApplicationModule(), new oracle.jbo.ViewObject[]{getViewObject()});
      throw jboEx;
    }
    throw OAException.wrapperException(ex);
  }
} // end create()

实体对象缓存

一旦被创建后，BC4J将实体对象因为各种原因被存储于特殊的事务缓冲区中，在JDeveloper BC4J文档中有完整的描述。两个重要的好处在于：

• 处理同一个根应用模块中的多个视图对象可以共享同样的下层实体对象。这意味着在一个视图对象中修改实体后将立即反映到其它引用该实体对象的视图对象中。
• 数据修改将被保留在缓冲区中即使视图对象的行集被刷新。比如，在主－从关系中，在 从 视图对象中由实体对象派生的属性值被保存在缓存中，即使用户从一个 主 视图对象转换到另一个。所有数据修改将原封不动的保存在事务生命中。

懂得这个缓冲区的存在是很重要的，因为你必须明确的执行某些验证，比如，当执行唯一性验证时你必须同时检查实体缓冲区和数据库。

有三种主要方式同时检查缓冲区和数据库：

1. 使用findByPrimaryKey()方法
2. 手工迭代缓冲区
3. 使用关联对象迭代缓冲区

findByPrimaryKey()方法

findByPrimaryKey()方法确保先查询缓冲区中与给定的主键相匹配的实体对象，然后查找数据库。这是一个非常用有的方法，但它并不是一个轻量的方法，因为它为从数据库中找到的记录实例化实体对象。它将 整个 实体对象放入内存，而不只是主键。这个方法可以——也应该——被用于当你不需要查找一个匹配的情况——比如，当验证一个基于序列的主键。它也适合用于需要在查找到的目标上调用方法以便中间层访问的情况。

下面的代码来自于oracle.apps.fnd.framework.toolbox.schema.server.SupplierEOImpl类，描述了这个方法的使用：

public void setSupplierId(Number value)
{
  if (value != null)
  {
    // Supplier id must be unique. To verify this, you must check both the
    // entity cache and the database. In this case, it's appropriate
    // to use findByPrimaryKey( ) because you're unlikely to get a match, and
    // and are therefore unlikely to pull a bunch of large objects into memory.

    // Note that findByPrimaryKey() is guaranteed to check all suppliers.
    // First it checks the entity cache, then it checks the database.

    OADBTransaction transaction = getOADBTransaction();
    Object[] supplierKey = {value};
    EntityDefImpl supplierDefinition = SupplierEOImpl.getDefinitionObject();
    SupplierEOImpl supplier =
      (SupplierEOImpl)supplierDefinition.findByPrimaryKey(transaction, new Key(supplierKey));
    if (supplier != null)
    {
      throw new OAAttrValException(OAException.TYP_ENTITY_OBJECT,
             getEntityDef().getFullName(), // EO name
             getPrimaryKey(), // EO PK
             "SupplierId", // Attribute Name
             value, // Bad attribute value
             "ICX", // Message application short name
             "FWK_TBX_T_SUP_ID_UNIQUE"); // Message name
    }
  }

  setAttributeInternal(SUPPLIERID, value);
} // end setSupplierId()

手工迭代缓冲区

可以通过手工的方式检查实体缓冲区，以执行与findByPrimaryKey()相同的检查。然后再在另一步中执行对数据库的检查。这种方式的好处是可以避免不必要的实例对象（译：实体）。

下面的例子也是来自于ToolBox教程中SupplierEOImpl类中：

public void setName(String value)
{
  // Since this value is marked as "mandatory," the BC4J Framework will take
  // care of ensuring that it's a non-null value. However, if it is null, we
  // don't want to proceed with any validation that could result in a NPE.

  if ((value != null) || (!("".equals(value.trim()))))
  {
    // Verify that the name is unique. To do this, we must check both the entity
    // cache and the database. We begin with the entity cache.
    com.sun.java.util.collections.Iterator supplierIterator =
      getEntityDef().getAllEntityInstancesIterator(getDBTransaction());

    Number currentId = getSupplierId();

    while ( supplierIterator.hasNext() )
    {
      SupplierEOImpl cachedSupplier = (SupplierEOImpl)supplierIterator.next();

      String cachedName = cachedSupplier.getName();
      Number cachedId = cachedSupplier.getSupplierId();

      // We found a match for the name we're trying to set, so throw an
      // exception. Note that we need to exclude this EO from our test.

      If (cachedName != null && value.equalsIgnoreCase(cachedName) &&
        cachedId.compareTo(currentId) != 0 )
      {
        throw new OAAttrValException(OAException.TYP_ENTITY_OBJECT,
                               getEntityDef().getFullName(), // EO name
                               getPrimaryKey(), // EO PK
                               "Name", // Attribute Name
                               value, // Attribute value
                               "ICX", // Message product short name
                               "FWK_TBX_T_SUP_DUP_NAME"); // Message name
      }
    }

    // Now we want to check the database for any occurrences of the supplier
    // name. The most efficient way to check this is with a validation view
    // object which we add to a special "Validation" application module.
    OADBTransaction transaction = getOADBTransaction();
    OAApplicationModule vam;
    // Look to see if the VAM has already been created in this transaction. If not,
    // create it.
    vam = (OAApplicationModule)transaction.findApplicationModule("supplierVAM");
    if (vam == null)
    {
      vam =
      (OAApplicationModule)transaction.createApplicationModule("supplierVAM",
         "oracle.apps.fnd.framework.toolbox.schema.server.SupplierVAM");
    }

    // Now, we use a lightweight "validation" view object to see if a supplier exists
    // with the given name.
    SupplierNameVVOImpl valNameVo = (SupplierNameVVOImpl)vam.findViewObject("SupplierNameVVO");
    valNameVo.initQuery(value);
    if (valNameVo.hasNext())
    {
      throw new OAAttrValException(OAException.TYP_ENTITY_OBJECT,
            getEntityDef().getFullName(), // EO name
            getPrimaryKey(), // EO PK
            "Name", // Attribute Name
            value, // Attribute value
            "ICX", // Message application short name
            "FWK_TBX_T_SUP_DUP_NAME"); // Message name
    }
  }

  setAttributeInternal(NAME, value);
} // end setName()

关联对象迭代

这与findByPrimaryKey()类似，它保证同时检查实体缓冲区和数据库。它也将会将找到的实体对象加载到内存，这用于需要调用实体中方 法时。与findByPrimaryKey()方法不同，它可以通过任何key查找任何类型的实体对象，这只用于与当前对象间通过关联对象相关联的实体对 象。

下面的代码描述了根复合实体对象使用关联对象查找它的所有子对象。

private void checkLineExists()
{
  // A purchase order header must have at least 1 associated line.
  // To check this, we first do a manual check of the entity cache
  // If we find a line for this header, we're done (note that the entity cache won't
  // include EOs that are DELETED or DEAD).

  com.sun.java.util.collections.Iterator fastIterator =
    PurchaseOrderLineEOImpl.getDefinitionObject().getAllEntityInstancesIterator(getDBTransaction());

  Number currentHeaderId = getHeaderId();
  while ( fastIterator.hasNext() )
  {
    PurchaseOrderLineEOImpl cachedLine = (PurchaseOrderLineEOImpl)fastIterator.next();

    Number cachedHeaderId = cachedLine.getHeaderId();

    // If we find a match, we're done. Don't forget to look ONLY for lines
    // for this header... The entity cache can include lines for other headers
    // also.

    If ((cachedHeaderId != null) && (cachedHeaderId.compareTo(currentHeaderId) == 0 ))
    {
      return;
    }
  }

  // We haven't found any matches in the cache yet, so now we need to check
  // the database...

  // In this example, we're illustrating the use of the association between the
  // header and its lines to iterate through all the shipments.  This will
  // check both the cache and the database, and will bring all the rows
  // into the middle tier.
  // Note that this looks only at lines for this
  // header so we don't need to filter our results, so it is convenient.
  RowIterator linesIterator = getPurchaseOrderLineEO();

  if (!(linesIterator.hasNext()))
  {
    throw new OARowValException(OARowValException.TYP_ENTITY_OBJECT,
                getEntityDef().getFullName(),
                getPrimaryKey(),
                "ICX", // Message product short name
                "FWK_TBX_T_PO_NO_LINES"); // Message name
  }
} // end checkLineExists()

实体状态

每个实体对象都有一个相关的“实体状态”它描述了实体的状态与下层数据库和事务关联。可以调用getEntityState()检查实体的状态。

技巧： BC4J从实体缓冲区中自动移除任何状态为STATUS_DEAD的实体对象，因此你不需要在查找“好”的实体对象时关心手工排除这些对象的问题。

• STATUS_NEW 实体对象在当前事务中是新的
• STATUS_DELETED 实体对象来自于数据库并且在当前事务中已经被删除
• STATUS_MODIFIED 实体对象来自于数据库并且已经被改变了
• STATUS_UNMODIFIED 实体对象来源于数据库并且没有被改变为，或者已经被改变过并且改变已经被提交
• STATUS_DEAD 实体对象在当前事务中是新的并且已经被删除
• STATUS_INITIALIZED 实体对象牌“临时（temporary）”状态并且将不会被提交或校验

修改／校验

这节描述如何正确执行属性级和实体级的校验。

属性级校验

如实现视图一章中描述的，当向页面发起HTTP POST请求时修改的值时，OA Framework将这些值回写到下层的视图对象，再通过调用实体对象的setter方法将这些值写入下层的实体对象。

因此每个属性的校验应该被添加到它的setter方法中（查看ToolBox的PurchaseOrderHeaderEOImpl的setHeaderId()方法，如下），调用实体对象的setter方法执行的是属性级的校验。

如果显示的指定了校验（比如，你在JDeveloper Entity Object Wizard中指定一个属性在它被保存后不能被更新），这个校验是在setAttributeInternal()方法中执行的，你应该将它放在你自己的 校验逻辑的后面执行。它也将在validateEntity()中执行。

/**
 * Sets the PO Header Id.
 *
 * Business Rules:
 * Required; cannot be null.
 * Cannot be updated on a committed row.
 */
public void setHeaderId(Number value)
{
  // BC4J validates that this can be updated only on a new line. This
  // adds the additional check of only allowing an update if the value
  // is null to prevent changes while the object is in memory.

  If (getHeaderId() != null)
  {
    throw new OAAttrValException(OAException.TYP_ENTITY_OBJECT,
                                 getEntityDef().getFullName(), // EO name
                                 getPrimaryKey(), // EO PK
                                 "HeaderId", // Attribute Name
                                 value, // Attribute value
                                 "ICX", // Message product short name
                                 "DEBUG -- need message name"); // Message name
  }
  if (value != null)
  {
    OADBTransaction transaction = (OADBTransaction)getOADBTransaction();

    // findByPrimaryKey() is guaranteed to first check the entity cache, then check
    // the database. This is an appropriate use of this method because finding a
    // match would be the exception rather than the rule so we're not worried
    // about pulling entities into the middle tier.

    Object[] headerKey = {value};
    EntityDefImpl hdrDef = PurchaseOrderHeaderEOImpl.getDefinitionObject();
    PurchaseOrderHeaderEOImpl hdrEO =
      (PurchaseOrderHeaderEOImpl)hdrDef.findByPrimaryKey(transaction, new Key(headerKey));

    if (hdrEO != null)
    {
      throw new OAAttrValException(OAException.TYP_ENTITY_OBJECT,
                                   getEntityDef().getFullName(), // EO name
                                   getPrimaryKey(), // EO PK
                                   "HeaderId", // Attribute Name
                                   value, // Attribute value
                                   "ICX", // Message product short name
                                   "FWK_TBX_T_PO_ID_UNIQUE"); // Message name
    }
  }

  // Executes declarative validation, and finally sets the new value.
  setAttributeInternal(HEADERID, value);
} // end setHeaderId()

不同的“Set”方法

有多种方法可以设置实体变量的值。在编码中，通常调用set<AttributeName>()和 setAttributeInternal()。查看Entity Object and View Object Attribute Setters获取更多的信息。

交叉属性校验

任何与两个个或更多属性值相关的校验应该被包含在validateEntity()方法中；不要将交叉属性校验放在单个属性的setter方法中，因为属性值的设置可能是无序的。

实体校验

当OA Framework在HTTP POST处理周期中设置实体对象值时，它总会校验它接触到的视图对象的行，它依次在下层的实体对象（一个或多个）上调用validateEntity() 方法。而且，entities are validated again prior to posting (up to 10 times in a composition).

任何操作于行级的逻辑——且对被重复调用不是非常敏感的校验——应该被包含在validateEntity()方法中。

下面的PurchaseOrderHeaderEOImpl代码描述了实体级的校验：

/**
 * Performs entity-level validation including cross-attribute validation that
 * is not appropriately performed in a single attribute setter.
 */
protected void validateEntity()
{
  super.validateEntity();

  // If our supplier value has changed, verify that the order is in an "IN_PROCESS"
  // or "REJECTED" state. Changes to the supplier in any other state are disallowed.
  // Note that these checks for supplier and site are both performed here
  // because they are doing cross-attribute validation.

  String status = getStatusCode();

  if ((("APPROVED")Equals(status)) || ("COMPLETED"Equals(status)))
  {
    // Start by getting the original value and comparing it to the current
    // value. Changes at this point are invalid.

    Number oldSupplierId = (Number)getPostedAttribute(SUPPLIERID);
    Number currentSupplierId = getSupplierId();

    if (oldSupplierId.compareTo(currentSupplierId) != 0)
    {
      throw new OAAttrValException(OAException.TYP_ENTITY_OBJECT,
                                   getEntityDef().getFullName(), // EO name
                                   getPrimaryKey(), // EO PK
                                   "SupplierId", // Attribute Name
                                   currentSupplierId, // Attribute value
                                   "ICX", // Message product short name
                                   "FWK_TBX_T_PO_SUPPLIER_NOUPDATE"); // Message name
    }

    // If our supplier site has changed, verify that the order is in an "IN_PROCESS"
    // state. Changes to the supplier site in any other state are disallowed.

    Number oldSiteId = (Number)getPostedAttribute(SUPPLIERSITEID);
    Number currentSiteId = getSupplierSiteId();

    if (oldSiteId.compareTo(currentSiteId) != 0)
    {
      throw new OAAttrValException(OAException.TYP_ENTITY_OBJECT,
                                  getEntityDef().getFullName(), // EO name
                                  getPrimaryKey(), // EO PK
                                  "SupplierId", // Attribute Name
                                  currentSiteId, // Attribute value
                                  "ICX", // Message product short name
                                  "FWK_TBX_T_PO_SUPSITE_NOUPDATE"); // Message name
    }
  }

  // Verify that our supplier site is valid for the supplier and make sure it is
  // an active "Purchasing" site.

  SupplierEntityExpert supplierExpert =
    SupplierEOImpl.getSupplierEntityExpert(getOADBTransaction());

  if (!(supplierExpert.isSiteValidForPurchasing(getSupplierId(), getSupplierSiteId())))
  {
    throw new OAAttrValException(OAException.TYP_ENTITY_OBJECT,
                                 getEntityDef().getFullName(), // EO name
                                 getPrimaryKey(), // EO PK
                                 "SupplierSiteId", // Attribute Name
                                 getSupplierSiteId(), // Attribute value
                                 "ICX", // Message product short name
                                 "FWK_TBX_T_PO_SUPSITE_INVALID"); // Message name
  }
} // end validateEntity();

交叉实体校验

开发者经常认为他们需要实现“交叉实体（cross-entity）”校验，一个实体对象在校验中调用另一个的方法。在OA Framework中，“交叉实体校验”意味着某些非常特殊的东西：

• 实体A和实体B在执行validateEntity()方法时各自己引用对方（因为实体A需要从实体B获得一些属性，实体B需要从实体A获得一些属性）and...
• 期望两个对象都是“脏（dirty）”对象（需要校验）在同一个事务中and...
• 另一个实体对象必须是有效的，以便引用它的对象获取属性值用于自己的校验。这样问题就来了：哪个实体应该先校验？

技巧： 对于复合关联的主／从实体对象这不是个问题，因为子对象将会先于父对象被校验，且BC4J Framework将校验复合层级结构向上10次的校验，从底部到顶部直到所有实体都是有效的。

需要“交叉实体校验”的环境是非常少见的。如果你觉得需要，解决的办法是创建一个特殊的“调停者”对象实现BC4J的ValidationListener接口。简单来说，这个对象交叉实体中的哪个对象的校验先执行。

不妥当的校验失败处理

在实体级的校验方法（validateEntity()，set<AttributeName>()或其 它）中调用Transaction.rollback()，Transaction.clearEntityCache()执行回滚或清除BC4J缓冲的 操作。如果因为某些原因需要执行这些操作，你必须按下面的方法在 应用模块／事务级（application module/transaction level） 捕获校验异常，并执行你需要的方法。比如，在应用模块级执行回滚是安全的；在实体级执行回滚或清理实体缓冲区却不是，并且可能导致不可预知的行为。

Bad Code:
---------
protected void validateEntity()
{
  ...
  DBTransaction txn = getDBTransaction();

  // Do not issue a rollback from within the EO.
  txn.rollback();
  throw OAException(...);
}

Good Code:
----------
protected void validateEntity()
{
  ...
  throw OAException(...);
}

// The following logic is written at the application-module level.

try
{
  txn.commit();
}
catch (OAException e)
{
  // Cache the exception thrown by the validation logic in the EO,
  // and perform the rollback.
  txn.rollback();
}

删除

为了删除实体对象，可以在对应的视图对象上调用remove()方法，如下面的应用模块中的代码所示。

/**
 * Deletes a purchase order from the PoSimpleSummaryVO using the
 * poHeaderId parameter.
 */
public Boolean delete(String poHeaderId)
{
  // First, we need to find the selected purchase order in our VO.
  // When we find it, we call remove( ) on the row which in turn
  // calls remove on the associated PurchaseOrderHeaderEOImpl object.
  int poToDelete = Integer.parseInt(poHeaderId);

  OAViewObject vo = getPoSimpleSummaryVO();
  PoSimpleSummaryVORowImpl row = null;

  // This tells us the number of rows that have been fetched in the
  // row set, and will not pull additional rows in like some of the
  // other "get count" methods.
  int fetchedRowCount = vo.getFetchedRowCount();
  boolean rowFound = false;

  // We use a separate iterator -- even though we could step through the
  // rows without it -- because we don't want to affect row currency.
  RowSetIterator deleteIter = vo.createRowSetIterator("deleteIter");

  if (fetchedRowCount > 0)
  {
    deleteIter.setRangeStart(0);
    deleteIter.setRangeSize(fetchedRowCount);
    for (int i = 0; i < fetchedRowCount; i++)
    {
      row = (PoSimpleSummaryVORowImpl)deleteIter.getRowAtRangeIndex(i);

      // For performance reasons, we generate ViewRowImpls for all
      // View Objects. When we need to obtain an attribute value,
      // we use the named accessors instead of a generic String lookup.

      // Number primaryKey = (Number)row.getAttribute("HeaderId");
      Number primaryKey = row.getHeaderId();

      if (primaryKey.compareTo(poToDelete) == 0)
      {
        row.remove();
        rowFound = true;
        getTransaction().commit();
        break; // only one possible selected row in this case
      }
    }
  }

  // Always close iterators.
  deleteIter.closeRowSetIterator();
  return new Boolean(rowFound);
} // end delete()

校验和级联删除

row.remove()方法依次调用下层实体对象的remove()方法。为实现特殊的删除行为，比如，检查删除操作是否被允许，或实现级联删 除，应该在实体的remove()方法中添加代码，如下所描述的TooBox中的PurchaseOrderHeaderEOImpl。

注意： 由于Oracle Applications编码规范禁止使用数据库的级联删除功能。BC4J Framework需要我们手工为多层的purchase order业务对象实现自己的级联删除，每个实体对象在在执行super.remove()之前，先删除它自己的直接子对象。如下所示：

/**
 * Marks all the lines for deletion, then mark the header for deletion.
 * You can delete a purchase order only if it is "In Process" or "Rejected."
 */
public void remove()
{
  String status = getStatusCode();

  if (("IN_PROCESS"Equals(status)) || ("REJECTED"Equals(status)))
  {

    // Note this is a good use of the header -> lines association since we
    // want to call remove( ) on each line.
    RowIterator linesIterator = getPurchaseOrderLineEO();

    if (linesIterator != null)
    {
      PurchaseOrderLineEOImpl line = null;

      while (linesIterator.hasNext())
      {
        line = (PurchaseOrderLineEOImpl)linesIterator.next();
        line.remove();
      }
    }
    super.remove(); // Must be called last in this case.
  }
  else
  {
    throw new OARowValException(OARowValException.TYP_ENTITY_OBJECT,
                                getEntityDef().getFullName(),
                                getPrimaryKey(),
                                "ICX", // Message product short name
                                "FWK_TBX_T_PO_NO_DELETE"); // Message name
  }
} // end remove()

锁

BC4J支持下面的锁技术：

• 悲观锁 BC4J在执行setAttribute()方法时锁定实体对象对应的数据库行（在做出任何修改之前）。如果行已经被锁，BC4J将招聘一个AlreadyLockedException异常。这也是BC4J缺省的锁模式。
• 乐观锁 BC4J在执行数据库post处理逻辑时锁定实体对象对应的数据库行。如果行已经被锁，BC4J将抛出AlreadyLockedException异常。

注意： OA Framework默认使用乐观锁并且推荐使用，由于连接池使传统的悲观锁不能实行。但是对于基于Form的应用是使用悲观锁的。

如果你需要悲观锁，你必须改变事务的行为：

// In the application module...

OADBTransaction txn = getOADBTransaction();
txn.setLockingMode(Transaction.LOCK_PESSIMISTIC);

过期数据侦测

当BC4J锁定一行时，它试着决定行对象是否被其它用户删除或修改，因为它是为当前用户而查询的。

• 如果行已经被删除了，BC4J抛出RowAlreadyDeletedException。
• 如果行已经被修改，BC4J抛出RowInconsistentException。

为覆盖缺省的逐行比较的检测行为，可以在实体对象属性定义向导中使用属性级的Chage Indicator标志。如果某个属性的这个标志被选中，BC4J限制对这个属性的比较。Oracle Application PL/SQL API通常使用OBJECT_VERSION_NUMBER表列检查数据的改变，这列也可以影响实体对象。查看下面的Object Version Number Column。

提交

当准备提交实体对象的修改时，只要简单的从应用模块中调用getTransaction()Commit()。当调用这个方法时，你的对象被校验（如果需要），posted和committed。

1. commit()方法调用oracle.apps.fnd.framework.OADBTransaction.validate()方法。
2. validate()方法检查所有需要校验的根实体对象的“Validation Listener“。（在多个实体组成的复合对象，只有根实体对象被添加到Validation list）。校验完成后在commit前，它将不会存在于list中，因为当对象校验成功后，BC4J将会从validation list中移除它。

技巧： 也可以调用OADBTransaction.validate()方法在任何地方强制进行校验。它执行相同的功能。

1. 对象位于validation list中，OADBTransaction validate()方法将调用实体的final viladate()方法，现依次调用validateEntity()执行你的校验逻辑。

注意： 在BC4J中对于list中各个实体的校验顺序是随机的。但是，在一个复合对象中，比如一个采购单有多个供货商。BC4J总是在校验父对象前校验子对象。 BC4J只会将复合对象的根实体放入validation list中（子对象不会被包含进来）。当根实体对象调用super.validateEntity时，BC4J调用它的子对象的validate，直到遍 历整个层级结构。由于这个原因，你应该在你的校验逻辑之前调用super.validateEntity以保证父对象在校验子对象后才校验自己。

1. commit方法调用OADBTransaction postChanges方法。
2. postChanges方法检查“Post Listener”获得实体对象中哪些数据需要被提交（posted）到数据库。
3. 对于post list中的任何对象，OADBTransaction postChanges方法调用实体的postChanges方法。当对象被提交（posted），BC4J将它从post list中移除。
4. 如果没有错误发生，数据库commit被发出，任何数据库锁被释放。

回滚

OA Framework为post和commit动作实现了一个“all or nothing“的事务处理方式。不管错误是否严重，如果数据库post或commit失败，OA Framework：

• 发起JDBC rollback释放数据库锁。

注意： 这不会影响中间层的状态。

• 恢复视图行对象的状态以便于事务发起第二次尝试。

注意： 这意味着你不需要显式的rollback失败的实体对象事务；OA Framework将在post或commit失败后自动显示出用户友好的错误信息。下面的例子描述了用户按下Apply按钮后commit和后来显示“Confirmation“对话框的情况。

// In the root application module

public void apply()
{
  getTransaction()Commit();
}

// In the controller
public void processFormData(OAPageContext pageContext, OAWebBean webBean)
{
  super.processFormRequest(webBean);

  // Handle the user pressing the "Apply" button
  if (pageContext.getParameter("Apply") != null)
  {
    OAApplicationModule am = pageContext.getRootApplicationModule();

    // No need for any special exception handling.  You can just display the
    // confirmation message because the OAF won't reach this code if the post/commit
    // fails.
    am.invokeMethod("apply");
    OAException confirmMessage =
      new OAException("ICX", "FWK_TBX_T_SUPPLIER_CREATE_CONF", null,
                       OAException.CONFIRMATION, null);
    pageContext.putDialogMessage(confirmMessage);

  }
}

回滚方法

手工清除中间层视图对象和实体对象缓冲，可以从应用模块中调用getTransaction().rollback ()。这也将roll back任何数据库修改并清除任何缓存于事务中的值。查找Support the Browser Back Button了解这对于创建实体对象的作用。

如果执行PL/SQL过程需要显式的roll back数据库而不影响中间层，可以在应用模块中调用getTransaction().executeCommand("rollback")。

注意： 如BC4J Native JDBC Statement Management中说过的。Transaction.rollback()会调用vo.clearCache()关闭相关的视图对象的JDBC结果集（游标）。比如，如果按下面的顺序执行：

vo.executeQuery();
Transaction.rollback();
vo.next();

当Transaction.rollback() roll back 数据库状态和中间层业务对象状态，下层直接JDBC调用并不会有意识的rollback任何中间层业务对象的状态，因此不要关闭JDBC游标。

i. Transaction.executeCommand("rollback")调用或

ii. BC4J的“rollback to savepoint”数据库调用是在Transaction.postChanges()或Transaction.commit()方法调用时 validation或post出错时，由内部发出的的。尽管实体对象或视图对象中用户修改的数据仍然存在，实体的post state已经变回modified state以便用户可以再次发起post/commit。

BC4J Framework不会补偿JDBC或数据库的rollback，无效的JDBC和数据库游标中的结果集（当数据库执行rollback调用后，游标被打 开）。因此，如果你需要使用Transaction.executeCommand("rollback")，请先查看M52 model coding standards。

如果需要覆盖post处理或EntityImpl中的beforeCommid，请先参考下节不当的Post处理。

不当的Post处理

在下面的情况下避免调用executeQuery()：

• 在视图对象的EntityImpl的post处理器方法（postChanges，beforePost，afterPost）中。
• 在beforeCommit中并且随后试图在相同的视图对象中使用vo.next()，vo.first()等方法获取行。

• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师

异常类型

OA Framework处理三种基本类型的异常：通用、校验和严重。这些类型在这节中简单的描述；特殊异常的使用在下面介绍。

通用异常

BC4J框架中的错误是通过抛出类型为oracle.jbo.JBOException的隐式（runtime）异 常。OA Framework中有自己的对应的版本为oracle.apps.fnd.framework.OAException。这个特殊化的版本提供了一种机 制，可以将多个异常捆绑在一起，并使用Oracle应用消息字典（Oracle Applications Message Dictionary）翻译这些异常信息，以便显示出有用的信息。在任何代码中，通常可以抛出一个OAException类型的页面级别异常。

校验异常

校验异常是从实体对象和视图对象中抛出的，可以是由于属性级或行级的校验失败引起。

• oracle.apps.fnd.framework.OAAttrValException 特殊版本的OAException，用于属性级校验失败。
• oracle.apps.fnd.framework.OARowValException 特殊版本的OAException，用于行（row）（entity）级校验失败。

OA Framework使用下面的方式显示错误信息：

• 属性级异常将在错误项目（item）和页面顶部标示出来
• 行级异常将在错误行（row）和页面顶部标示出来
• 页面级异常通常在页面顶部标示出来

严重异常

严重（severe）（或称为“毁灭（fatal）”）性的异常包括不希望出现的系统级的错误（比如NullPointerException）和所选的JBOException如：NoDefExcpetion。可以直接在代码中抛出严重异常。

如果严重异常发生，用户将被定向到OAErrorPage（异常被渲染在页面的中间，页面是区域渲染的，页面显示了用户友好的错误信息，并包含了一个指向堆栈跟踪细节的链接）。

注意： 这是一个未翻译过的信息客户可以在站点中修改。

Oracle工作流通知

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛

设计一个OA Controller

如OA Framework Page解析中所描述的，OA Controller定义了web beans的行为。具体来说，编写控制器代码的目的是：

• 在运行时处理／初始化UI（包含那些通过编程方式添加的layout）
• 拦截或响应按钮按下之类的用户事件

控制器不应该包含任何业务逻辑；这应该属于模型类。

必备知识

通常来说，在提出如何设计控制器之前，应该思考一下是否需要创建控制器。

作为一条规则，应该只在绝对必要的情况下才编写控制器。如果可以通过设计的方式创建页面，就不要通过编程的方式实现region和item。编程方式创建的web beans不能被个性化，重用或继承。而且，一些硬编码的layouts可能会丢失BLAF UI样式。

在实现视图中说过，所有位于共同组件中的顶级regions必须与一个控制器关联。

粒度

OA Controllers可以与任何region关联（任何实现oracle.apps.fnd.framework.webui.beans.OAWebBeanContainer接口的web beans）；不能将控制器与items关联。

许多OA Framework新手都想知道控制器应该是”多大“。应该一个页面一个，或一个功能region一个（比如“Search” region），或一个复合web bean（比如一个table）一个，或者？答案是要看情况。

最初，在一个非常简单的页面，你可能不需要任何控制器（如果没有工作要作就不需要创建控制器）。如果需要编写代码，你需要根据下面的条件决定创建什么样的控制器：

• 利于封装，一个web bean实现了它自己的行为
• 组件重用，如果组件被设置为重用，它必须是自包含，自已自足。
• 代码实用性，尽管页面包含了8个regions时可以很容易的添加8个控制器（每个包含少量的代码），这种“纯”OO的观念可以导致代码维护困难，可能导致产品代码文件膨胀。

有一些方法可以帮助决定如何处理：

• 永远不要从child bean中设置parent/grandparent web bean的属性。
• 为相关联的region定义控制器来设置region和它的子孙region的属性。如果需要主控制器管理多个子／孙web bean，控制器应该与适当的父／祖父bean相关联。
• 对于复杂的beans（比如OATableBean）应该将控制器关联到bean自身，或关联到一个简单的容器bean中（如果它实现功能逻辑单元）。

通常，应该为页面创建少于满足上面规则和考虑数量的控制器。对于非常简单的页面，通常是为pageLayout区域关联单个的控制器。对于更复杂的 页面，应该为各个功能组件（比如，查询页面中典型的“Search”区域控制器和“Results”区域控制器）创建少量不同的控制器。共享区域应该拥有 自己的适当的控制器。

模型性／重用

在同一组相关联的页面中，你有时将找到可以重用代码的机会。下面是创建模块性更强的控制器代码的方法：

• 在控制器中添加私自己的私有方法。
• 创建一个公用的控制器类（它是oracle.apps.fnd.framework.webui.OAControllerImpl），然后为有需要的页面／区域继承这个类。
• 创建辅助的实用工具类，控制器中可以根据需要代理。这些类不需要实现任何OA Framework类或接口，应该被包含在与它们所辅助的控制器类所在的包中。注意，静态方法适合于在这些类中使用，当使用静态方法时，应该考虑下面的问题：
  • 不能影响子类中的静态方法。
  • 封装相关常量和静态方法。（There are packaging implications related to the use of constants and static methods ）

线程安全

OA Framework被设计为支持多线程web bean访问（尽管还没有实现）。大部分对于你的代码来说是透明的，只有少量规则必须在控制器代码中遵守：

• 如果在控制器或辅助类中使用静态方法，则永远不要包含状态。
• 总是将页面的OAPageContext传递给任何web bean存储器（如果需要可以带OAPageContext）。比如，使用setText(OAPageContext pageContext, String text)代替setText(String text)。

状态管理

不要在控制器中或你实例化的辅助类中添加非易失性成员变量。OA Framework不会钝化成员变量，因此一旦虚拟机失效被支持后将不能恢复这些值。可以添加static final成员变量。

编码规则

创建一个控制器

为一个区域创建控制器：

1. 在JDeveloper Structure页面中选择区域
2. 右键选择Set New Controller...
3. 在New Controller对话框中，输入包和类名。选择OK创建与选择区域关联的控制器。注意Inspector中的Controller Class属性值是类的全名，如： oracle.apps.fnd.framework.toolbox.tutorial.webui.HomeSearchCO。

JDeveloper将创建控制器模板。

/*===========================================================================+
 | Copyright (c) 2001, 2003 Oracle Corporation, Redwood Shores, CA, USA      |
 | All rights reserved.                                                      |
 +===========================================================================+
 | HISTORY                                                                   |
 +===========================================================================*/
package oracle.apps.fnd.framework.toolbox.tutorial.webui;

import oracle.apps.fnd.common.VersionInfo;
import oracle.apps.fnd.framework.webui.OAControllerImpl;
import oracle.apps.fnd.framework.webui.OAPageContext;
import oracle.apps.fnd.framework.webui.beans.OAWebBean;

/**
  * Controller for ...
  */
public class OrderSummaryCO extends OAControllerImpl
{
   public static final String RCS_ID="$Header$";
   public static final boolean RCS_ID_RECORDED =
   VersionInfo.recordClassVersion(RCS_ID, "%packagename%");

 /**
   * Layout and page setup logic for a region.
   * @param pageContext the current OA page context
   * @param webBean the web bean corresponding to the region
   */
   public void processRequest(OAPageContext pageContext, OAWebBean webBean)
   {
     super.processRequest(pageContext, webBean);
   }

 /**
   * Procedure to handle form submissions for form elements in
   * a region.
   * @param pageContext the current OA page context
   * @param webBean the web bean corresponding to the region
   */
   public void processFormRequest(OAPageContext pageContext, OAWebBean webBean)
   {
     super.processFormRequest(pageContext, webBean);
   }

}

注意： 缺省的模板内容不包含processFormData(OAPageContext pageContext, OAWebBean webBean)方法，这个方法在POST处理的第一个阶段被调用。如果需要（非常少见），可以将它加到控制器中。

注意： 也可以通过编程的方式将控制器与区域关联。查看OAWebBeanContainer中的setControllerClass(String javaClass)方法。

处理HTTP GET

在GET处理过程中，每个控制器的processRequest(OAPageContext pageContext, OAWebBean webBean)方法被按照它们被实例化时的层级结构而依次被调用。处理从pageLayout bean开始，然后递归处理整个层级结构。初始化页面——或影响层级结构中的web bean（通过设置属性，创建web bean等等）——属于processRequest()方法。

注意： 传递到processRequest()方法中的oracle.apps.fnd.framework.webui.OAWebBean参数是与当前控制器关联的区域。

下面是一个典型的processRequet的代码。它描绘的是根据从“search”页面传递过来的参数，初始化用于查看的“detail”页面。

/**
 * Layout and page setup logic for region.
 * @param pageContext the current OA page context
 * @param webBean the web bean corresponding to the region
 */
public void processRequest(OAPageContext pageContext, OAWebBean webBean)
{
   // Always call this before adding your own code.
   super.processRequest(pageContext, webBean);

   // Get the purchase order number from the request.
   String orderNumber = pageContext.getParameter("headerId");

   // We need to set the page header text to include the PO order number for reference.
   MessageToken[] tokens = { new MessageToken("PO_NUMBER", orderNumber) };

   // Always use a translated value from Message Dictionary when setting strings in
   // your controllers.
   String pageHeaderText = pageContext.getMessage("ICX", "FWK_TBX_T_PO_HEADER_TEXT", tokens);

   // Set the po-specific page title (which also appears in the breadcrumbs. Since this
   // controller is associated with the page layout region, simply cast the webBean
   // parameter to the right type and set the title.

   ((OAPageLayoutBean)webBean).setTitle(pageHeaderText);

   // Now we want to initialize the query for our single purchase order with all of its
   // details.
   OAApplicationModule am = pageContext.getApplicationModule(webBean);
   Serializable[] parameters = { orderNumber };
   am.invokeMethod("initDetails", parameters);

} // end processRequest()

使用页面的title值定义页面标题和breadcrumbs：

由于显示于页面中的值必须被翻译，我们在Oracle应用消息字典（Oracle Application Message Dictionary）中创建了一个名为FWK_TBX_T_PO_HEADER_TEXT的消息，消息内容为“Purchase Order: &PO_NUMBER”。这个代码定义了以令牌PO_NUMBER作为Purchase Order Number的占位符，然后从oracle.apps.fnd.framework.webui.OAPageContext（它将操作委派给 AOL/J）中提取翻译后的版本。然后将翻译后的字符串作为页面标题。

警告： 不要在用户界面中使用硬编码的文本值。所有以编程方式显示的文本值必须来源于消息字典（Message Dictionary）。也可以在设计时在web bean中使用这种方式（所有显示的bean属性都是被翻译的），或者也可以从多国语言表中查询出值来显示。

最后，这个只读的”details“页面自动按给定的编号进行查询而不管它是否会被渲染。它通过将编号传递给页面根应用模块的initDetails()方法。然后应用模块将参数传递给适当的视图对象，在那里将参数与WHERE子句绑定并执行查询。

修改Bean属性

注意： 作为规则来说，更好的修改web bean属性的方法是使用局部页面渲染（partial page rendering （PPR））和SPEL，在Dynamic User Interface中有描述。在不能通过PPR和SPEL的环境下，也必须在processRequest()方法中修改web bean层级结构（这节被包含在GET处理一章中，也是由于只能在processRequest()方法中才允许修改web bean层级结构）。

如果需要以编程方式在响应表单提交的事件中修改层级结构，必须forward到同一个页面的processRequest()方法（见下面POST事件处理）。作出这个限制的原因有：

• 确保web bean层级结构能在需要的时候被正确的重建。
• Beans被适当的初始化。主要是Rendered属性，或影响复杂组件渲染的prepareForRendering()方法。
• Bean层级结构被放在同一个方法中维护。

修改web bean的属性时，只需要简单的根据它的名称（在JDeveloper中赋给它的ID）查找到正确的bean，然后按下面的方法调用适当的方法。

警告： 当获得web bean时，在调用它的任何方法前都需要检查对象是否为空。即使你认为bean被包含于web bean层级结构中，但也有可能在用户使用个性化定制时半它隐藏了。

processRequest(OAPageContext pageContext, OAWebBean webBean)
{
  // Always call this before adding your own code.
  super.processRequest(pageContext, webBean);

  OATableBean table = (OATableBean)webBean.findIndexedChildRecursive("OrdersTable");

  if (table == null)
  {
     MessageToken[] tokens = { new MessageToken("OBJECT_NAME", "OrdersTable")};
     throw new OAException("ICX", "FWK_TBX_OBJECT_NOT_FOUND", tokens);
  }

  // Set the purchase-order specific "control bar" select text:
  // "Select Purchase Order(s) and..."

  String selectPOText = pageContext.getMessage("ICX", "FWK_TBX_T_SELECT_PO", null);
  table.setTableSelectionText(selectPOText);

}

如果需要修改控制器区域的属性，只需要将processRequest()的OAWebBean参数转换为正确的类型并调用需要的方法。

编程的方式创建Bean

注意： 本节包含于GET处理部分，因为只允许在processRequest()方法中修改web bean层级结构。

如果需要在响应表单提交事件中添加web bean到层级结构中，必须forward到同一个页面的processRequest()代码中执行。

作为规则，如果你可以通过设计的方式产生web bean就不应该通过编程的方式产生web beans。另外，如果你的页面与局部页面渲染相关，则也不能在运行时修改web bean层级结构。

对于那些极少见的必须手工实例化web bean的情况，则使用OAControllerImpl类中的createWebBean()工厂方法。不要直接使用web bean的构造器，不必担心要直接创建oracle.apps.fnd.framework.webui.OAWebBeanFactory，因为控制器 的createWebBean()方法代理了OAWebBeanFactory。

注意： 对于这些手工创建的beans，使用工厂方法时可以指定bean的“name”（JDeveloper中的ID属性）。避免使用deprecated的方 法，它允许你在创建web bean时不指定name。web bean的名称（name）在同一个页面中必须是一个唯一标识。另外，bean的名称可能被OA Framework用于BC4J对象实例名（比如应用模块实例），因此不应该包含Java命名中规定的无效字符。

比如，下面的代码描述了如何创建两个web bean并将它们添加到父区域中。

OATableLayoutBean tableLayout = (OATableLayoutBean)findIndexedChildRecursive(