Weblog for the AMIS Technology corner
Posts tagged task flow
Book review: JDeveloper 11g Handbook: A Guide to Fusion Web Development
Jul 21st
In this blog I will share with you my experiences with the Oracle JDeveloper11g Handbook – A Guide to Oracle Fusion Web Development (McGraw-Hill, 2010) – written by Duncan Mills, Peter Koletzke and Avrom Roy-Faderman. It is the successor of their previous book, JDeveloper 10g for Forms & PL/SQL Developers. This is a book to learn the basics of ADF Fusion development and a valuable guide for reference. If you’re a starter, than the hands-on part in this book is a good and practical exercise.
ADF 11g : What is the Currently Active Taskflow in a Dynamic Region ?
May 31st
There are use cases in which you need to determine what the currently active taskflow is. This looks like simple, but in fact it is not ! Let’s rephrase that : Depending on the context, it can be a pretty confusing task. Read the rest of this entry »
ADF 11g: Ode to the Task Flow
May 7th
Last night we organized the “Ode to the Task Flow” session at AMIS. After a short presentation introducing the Bounded Task Flow it was time for the hands-on lab: “Build your first taskflow”.
In this lab many of the attendees created their first taskflow, learning the basics of ADF taskflows. This first taskflow receives a job title, and optionally your favorite color via input parameters. Based on that information a welcome message is created. The taskflow is smart enough to invoke the proper logic by using a router to show the correct page fragment based on an input parameter. From this activity, you can change your name in another view activity. This taskflow includes routers, method calls, input parameters, default activities and wild card control flows.
After diner (great Chinese food) there was no time for my usual after diner dip. I had to present a demo on packaging an ADF Task Flow as an ADF Library, and invoking it into a new application. After this demo, the second hands-on lab started. This part of the “Ode to the Taskflow” hands-on lab, was about the mechanism used to achieve reuse across applications: the ADF Library – the bundle in which reusable taskflows are published with all their dependent objects. The ADF Library can subsequently be passed around and imported into other ADF applications. Goal of this lab: create an ADF Library for your first taskflow, and use it a new application.
After this hands-on lab the session was over. It was fun presenting this session. Attendees learned how to use taskflows and also about the mechanism behind reuse. I have uploaded some of the materials for the hands-on lab here.
I can’t wait to prepare a next ADF 11g session. Any topic suggestions ?
Kennissessie ADF 11g – Ode aan de Task Flow
Apr 20th
ADF 11g staat vooral bekend om zijn rich components waarmee een moderne, interactieve en aantrekkelijke user interface kan worden ontwikkeld. En een beetje om de Data Visualization Components (DVTs) waarmee allerlei geavanceerde grafieken en andere vormen van grafische data-presentatie kunnen worden ingepast in de web applicatie.
Veel minder bekend en zichtbaar is de Task Flow. Terwijl dat uit oogpunt van architectuur en voor een efficiente organisatie van een onvangrijk ontwikkel-project en zeker voor het kunnen realiseren van reuse de belangrijkste vernieuwing is geweest in ADF 11g.
Een TaskFlow is een op zichzelf staande module die zowel code – managed beans, navigation rules – als user interface bevat. Een task flow is bijna een mini-applicatie met mogelijk verschillende schermen, complexe navigatie tussen de schermen en een eigen memory scope. Een task flow kan worden geintegreerd in schermen in de applicatie (en in andere task flows). Het contract daarvoor bestaat uit input parameters en events. Task flows kunnen worden verpakt in libraries en tussen projecten worden uitgewisseld als generieke reusable componenten. Een voorbeeld van dat laatste gebruik van task flows zijn de WebCenter Services.
In deze KC sessie ‘Ode aan de Task Flow’ gaan we kennismaken met de Task Flow. Ook al weet je nog niets van ADF 11g – of al juist een heleboel – na deze bijeenkomst zijn task flows ook jouw vriend. Wel is enige ervaring met JDeveloper en ADF 10g nodig om zinvol deze sessie bij te wonen.
We laten zien – en daar ga je vervolgens ook zelf mee aan de slag – hoe de allereenvoudigste task flow kan worden gemaakt, kan worden gebruikt binnen de applicatie en kan worden uitgebreid met navigatie, eigen beans en input parameters. Dan gaan we een reusable task flow publiceren in een ADF Library en hergebruiken in een andere applicatie. Tenslotte laten we een demo zien van WebCenter Services die dus ook task flows als mechanisme gebruiken. We hebben het voornemen om binnen AMIS ook een collectie reusable task flows te gaan ontwikkelen. Deze sessie is daar het startpunt voor.
Hands-on: de bijeenkomst is gericht op hands-on aan de slag gaan met JDeveloper 11g, ADF 11g en met name de task flows. Breng dus een laptop mee waarop JDeveloper 11g is geinstalleerd
(eventueel downloaden van http://www.oracle.com/technology/software/products/jdev/index.html).
Ga naar http://www.forms2future.com/evenementen-archief om je te registreren voor deze bijeenkomst.
ADF 11g: Debugging Task Flows embedded from ADF Libraries using source code jars
Apr 3rd
We have been struggling quite a bit with a good approach for modularizing our ADF web applications through the use of (stand alone) Task Flows that are developed in independent projects and assembled into a single Web Application from ADF Libraries. In theory, this is a very structured, decoupled way of developing potentially complex ADF Web Applications – while allowing for reuse. The contextual events mechanism in combination with the task flow input parameters allow definition of a clear interface through which to reuse the task flow. So all seems well.
However, when you try to put this theoretical bliss into actual practice, there are some limitations that you run into. One of the tricky issues we had to deal with is: how can we debug our web application when part of the source of the application is reused from ADF Libraries? How can we put breakpoints in the sources that are part of the ADF Library?
On closer inspection, there seems to be a relatively easy way for doing this – using an additional library definition in JDeveloper that refers to the sources that form the foundation of the ADF Library.
Let’s take a quick look at how this would work:
OOW 2009: Experiences with Oracle WebCenter 11g: Implementing SOA with a User Interface
Oct 14th
One of the sessions I am (co-)presenting at Oracle Open World 2009 is on ‘applying the concepts of SOA to and achieving the SOA objectives with User Interfaces’. What goes for SOA and typical programmatic (web)services can be applied to User Interface components to a large extent. Decoupling – cross location, cross technology, cross development team and deployment unit – and reusing based on clear interface definitions and encapsulation of implementation is also available for user interface development.
Our presentation – I am copresenting with my colleague Peter Ebell – introduced the SOA concepts and objectives and demonstrates the application of SOA to the UI, using first Portlets and then ADF Task Flows. Subsequently we introduce WebCenter – as the portlet-infrastructure for ADF and also as the real life example of the notion of reusable, independently developed user interface components. We will discuss the nature of the contract you define for such reusable UI services (parameters, events – inbound and outbound) and demonstrate the steps you have to go through to make it work. Finally we will go into ‘how to add a user interface to a SOA implementation’- or: when does a SOA artefact need a user interface.
You can find the presentation below, embedded from slideshare. You can also download the demo applications we use for this session.
Create, Deploy and Consume an ADF Task Flow with ADF Business Components inside
Jul 6th
I have discussed ADF Task Flows before in raving terms and with some simple example to prove my point. To be honest, I have never before really digged deep in any article into the use case of creating a bounded task flow that has ADF Business Components inside, deploying it to an ADF Library and reusing that Task Flow from that library in a completely different ADF application. That may not even have Business Components itself. Now is the time to remedy that omission. And also demonstrate how the consumed task flow – originating from somewhere in the Resource Catalog – can be integrated and synchronized with the consuming page.
It is not very difficult, but some steps must be observed to wire it together neatly.
Our objective in this article:
* Create a bounded task flow EmployeesList that uses ADF Business Components (in this particular case to display data from a database table called EMP, you may have hear it mention before)
* Deploy the task flow to an ADF Library to make it reusable in other ADF applications
* Create a new ADF Application in which the task flow EmployeesList is reused.
The steps we go through to accomplish this:
1. Create the Bounded Task Flow
2. Deploy the Bounded Task Flow to an ADF Library
3. Add the ADF Library to the Resource Catalog and then to the consuming application
4. Add the Task Flow to a page and wire it into it.
Introduction to ADF reusable task flows – consume a bounded task flow that gets synchronized with input parameter changes
Jul 4th
Task Flows are the primary mechanism in ADF 11g for organizing the workload in manageable chunks that can be developed in a decoupled fashion in relative isolation, then merged together in web pages that implement the desired functionality. Task Flows are also one of the key mechanisms for reuse – along with but for other purposes than Page Templates, Page Fragments and Declarative Components. Task Flows are the key vehicle for creating encapsulated, stand alone services with a User Interface that can be consumed in multiple pages in various applications.
Task Flows come with their own managed beans, navigation rules, data binding, user interface – behind a fairly well defined interface which consists of input parameters and input/output events.
A few things that might be added to even improve a little on task flows:
- a structured method for documentation and discovery, something like WSDL or JavaDoc to describe the meaning of the Task Flow and its input parameters
- support for facets through which additional content can be injected into (views of) the task flow
- support for page templates with facets predefined by the taskflow that can be associated with the views of the task flow
- ability to register listeners with a task flow for specific events (the contextual event framework is quite awkward)
In this article a simple example of using the Task Flow mechanism for the creation of a reusable service – text translation – that is developed as a bounded task flow that is deployed in an ADF Library to be reused in potentially many applications and pages.
ADF 11g: how events in one region cause other regions to refresh
Aug 28th
One of the challenges in building Portal pages is to have events from one Portlet have the desired effect on other Portlets. For example when I select a location on a Map in one Portlet, other Portlets may need to be synchronized to show the weather, the best restaurants and the driving instructions for actually going there. The JSR-168 specification does not address this issue; the upcoming JSR-286 ("Portal 2.0") specs do. Working with ADF 11g, we have some fairly new mechanisms at our disposal, such as Task Flows and Regions, that allow us to construct pages (and applications) that are somewhat reminiscent of Portlets – or at least some of the interesting sides of Portlets in terms of creating relatively simple pieces of (stand-alone) functionality that can be wired together in a larger mashup – where ideally the mashup framework can provide event propagation between the stand alone pieces. In this article, I want to investigate how for example an event occuring in region A – based on a bounded taskflow – can be passed on to region B that is based on another bounded taskflow.
Read the rest of this entry »
