Implementation of Documentum Business Object Framework (BOF)


Business Object framework is the object oriented framework provided by Documentum to build, deploy, test and execute reusable business logic component known as Business Objects.
Types of BOF Modules:
  1. TBO – Type Based Business Object
  2. SBO – Service Based Business Object
  3. Aspects
  4. Simple Module
Steps to Create different type of Modules
  1. TBO:
As TBO depends on persistence object type, we can either modify the existing functionality of the persistence object or we can add new functionality.
We will discuss below how to modify the default save functionality as well we add new functionality.
  1. For writing TBO we must have a persistence object type. It is always a good practice to create a sub type of existing documentum types without trying to modify the default one. So in our case we will create an object type my_document_tbo. We can create the object type in different ways here we will do it via composer.

  1. We can now install the documentum project to create the object type in the docbase or we can do it after writing the TBO.
  2. Create the interface class by extending the corresponding DFC type class associated with super type of the object type. The interface class needs to directly or indirectly extends IDfBusinessObject. In our case, the interface class implements IDfDocument which in turn extends the IDfSysObject, which ultimately extends IDfBusinessObject .

  1. Create the implementation class. The implementation class must extend the DFC type class of the associated super type and it must implements IDfDynamicInheritence.
In this example, we are modifying the existing save functionality.
  1. Create interface jar don’t mix Implementation and interface classes together. We need to create separate jars for both of them.

Select only the interface class and browse the location to save the interface jar file as shown below:

  1. Create the implementation jar following the above steps.
  1. Once the jar files are created we have to create Jar file definition in Composer.

Select type as Interface and File points to the interface jar we created in previous steps.

  1. Same we have to do for implementation jar.

  1. Now we have to create the module definition. The TBO name must be the same as the object type for which we are creating the TBO.

  1. Install the documentum project into the repository.

Provide the login details of docbase and install the documentum project. Once the project is installed the TBO is ready to consume.

  1. To check the doSave method modification you can simply use DA to import or create file of our custom object type.
  1. In order to test the new functionality, we can write a client code to create an object of custom object type.
In client code we have add the interface jar in the class path.

  1. SBO:
Service Based Business Object is independent of object type and repository. The SBO is installed in the global repository.
Building and deploying SBO using Composer:
  1. Create an interface which extends IDfService and define your business method

  1. Add the business method which you want to expose to the user.

  1. Create the implementation class

  1. Add the business logic. In this example, it is shown how to create session in SBO and used it to get the docbase name.

  1. Create the interface jar

  1. Create the implementation jar

  1. Once the interface and implementation jars are created. It’s time to create the jar definition for both interface and implementation jars.

  1. Create the SBO module. Use full qualified name for the SBO. Generally the interface name is the SBO name.

  1. Install documentum Project to install the SBO into global repository

  1. To test the SBO which we have installed in the above, we have to create a client.
Create a client documentum project and add the interface jar in the class.

  1. Create a SBO client to call the SBO

  1. Simple Module:

Steps to create simple module:
  1. Create the interface class. The interface class will extend the IDfModule

  1. Create the implementation class extending DfSingleDocbaseModule and implements the interface created in step 1.

  1. Create the interface and implementation jars separately.

  1. Similar create the implementation jar

  1. Create jar file for both interface and implement

  1. Create the jar definition of interface and implementation jar

  1. Create the module definition

  1. Install the documentum Project to intall the simple module into the repository

  1. Create Client to run Simple Module. Add the Interface jar in the class path of the documentum project created for client.

  1. Implementation of Job and Method using BOF

  1. Create the implementation class. The implement class must implements IDfModule and IDfMethod

  1. Export the implementation class and create the jar.

  1. Create the jar definition of the exported jar.

  1. Create the module definition. The module name should be the fully qualified name.

  1. Create the method definition (dm_method), preferable to create in DA.

Note: Do not check Use as Workflow method, otherwise once the Job will run it will go to running state forever.

  1. Create the job definition same preferable to create in DA, as something the method is not detected stating that unable to find the method.

  1. Install the Documentum Project
  2. Once the project is successfully installed in the repository, run the job. Cheers 

Download the Source Code



  1. Great Article..Thanks dude!!

  2. very good article...but in reality we use TBO and SBO from Webtop/DA so what i am looking for is detail steps to test the TBO, SBO, Module from webtop/da client. Also details steps to debug them in composer.

  3. Thank you very much for sharing such a beautiful article.


Post a Comment

Popular posts from this blog

Create a web application in 5 minutes using Spring Boot and Maven

Creating Session in Documentum