<jsp:root xmlns:jsp="http://java.sun.com/JSP/Page" version="2.1"
           xmlns:f="http://java.sun.com/jsf/core"
           xmlns:pe="http://xmlns.oracle.com/adf/pageeditor"
           xmlns:cust="http://xmlns.oracle.com/adf/faces/customizable"
           xmlns:af="http://xmlns.oracle.com/adf/faces/rich">

<af:resource type="javascript">
    function myFunc() { [ any JS code ] };
</af:resource>

In the managed bean, put the following code in the appropriate method (e.g. in a action listener if we want to execute the JS code after a commandButton or commandLink is selected):

import javax.faces.context.FacesContext;
import org.apache.myfaces.trinidad.render.ExtendedRenderKitService;
import org.apache.myfaces.trinidad.util.Service;

[…]

FacesContext facesContext = FacesContext.getCurrentInstance();
ExtendedRenderKitService service = (ExtendedRenderKitService) org.apache.myfaces.trinidad.util.Service.getRenderKitService(facesContext, ExtendedRenderKitService.class);
service.addScript(facesContext, "myFunc();");

OperationBinding searchOp = ADFUtils.findOperation("searchBusinessUnits");

The ADFUtils.findOperation() method has the following definition:

public static OperationBinding findOperation(String operationName) {
   OperationBinding op = getDCBindingContainer().getOperationBinding(operationName);
   if (op == null) {
      throw new RuntimeException("Operation '" + operationName +"' not found");
   }
   return op;
}

Unfortunately, when the previous code is executed in a method action invoked at page load time through an invokeAction binding, it happens that the reference to the binding container is null at this point. In this case, we need to access the binding container in a different way, using EL:

import oracle.adfinternal.view.faces.model.binding.FacesCtrlActionBinding;

[. . .]

FacesCtrlActionBinding searchOp = null;
searchOp = (FacesCtrlActionBinding)JSFUtils.resolveExpression("#{data.portal_peoplefinder_resultsPageDef.searchBusinessUnits}");
Map opParams = searchOp.getParamsMap();
opParams.put("searchTerm", searchString);
Object result = searchOp.execute();

The pageDef excerpt of the page (or page fragment) containing the binding I need to access (in this case peopleFinder_resultsPageDef.xml ):

<bindings>
 [...]
 <methodAction id="searchBusinessUnits" InstanceName="ContentServicesDC.dataProvider"
 DataControl="ContentServicesDC" RequiresUpdateModel="true"
 Action="invokeMethod" MethodName="searchBusinessUnits" IsViewObjectMethod="false"
 ReturnName="data.ContentServicesDC.methodResults.searchBusinessUnits_ContentServicesDC_dataProvider_searchBusinessUnits_result"/>
 [...]
 </bindings>

And the line of DataBindings.cpx regarding this binding:

<page id="portal_peoplefinder_resultsPageDef"
 path="oracle.webcenter.portalapp.pagefragments.peoplefinder_resultsPageDef"/>

IMPORTANT: the EL expression we are using to retrieve the binding must be comply with the following format:

[“data”] + [id of the corresponding <page> entry in DataBindings.cpx] + [name of the binding we want to retrieve]

Thanks to ADF Data Control capability, we can incapsulate our custom code in a method of a POJO, and finally expose this as a Data Control (it’s worth reminding that it complies with JSR 227 specification, so it’s actually adherent to Java standards).

As we have many flavours of bindings, we are going to show in this tutorial how to achieve the same result using an attribute binding, and then using a method binding.

For this tutorial JDeveloper 11.1.1.5.0 has been used.

As a first step, let’s create a new Fusion Web Application (ADF) :

In the Model project we now create a new Java class, named PageLoadDC:

and expose this class as a Data Control:

After this, the Data Controls panel is populated with the new item:

And the DataControls.dcx file is updated with the following content:

Now let’s work on the ViewController project: at first we create a new JSF page, named home.jspx:

To make JDeveloper create the necessary bindings for you in the pageDef file for the new page, just drag & drop the method binding from the DataControls panel onto the page, choosing ADF Output Text as display mode for this binding:

In this way, many things happen behind the scenes:

–        a new pageDef for home.jspx page is created

–        a new binding for the method exposed in the data control is created

–        an iterator has been defined for this binding, to access the results of this method call.

The generated code in the newly created pageDef is:

Running the application gives the expected result:

An interesting observation:

Having named the DC method with a name starting with ‘get’ (in this case ‘getContentAtPageLoad’), this is interpreted by ADF as a getter of a property ‘contentAtPageLoad’, so the binding definition is really an attribute binding rather than a pure method binding, and in the home.jspx page the following EL expression is used to retrieve the value:

#{bindings.contentAtPageLoad.inputValue}

Now we add a new method in the DC, this time naming it in a different name, e.g. ‘buildContentAtPageLoad’:

and we expose the file as a DC again:

we can now notice how a method binding is actually created.

Now in the bindings box select the Plus icon to create a new binding, the select methodAction:

In the next screen just select the DC we just created, and the method name will appear in the ‘Operation’ dropdown list, then press OK:

As a result, a new binding is created in the pageDef file, and it appears in the ‘Bindings’ box in the page overview :

Now, to make this methodAction execute when the page is loaded, we just need to create an invokeAction to actually invoke it: in the ‘Executables’ panel in the ‘Bindings’ tab for the home.jspx page just click the Plus icon and select InvokeAction:

In the ‘InsertInvokeAction’ select the ‘buildContentAtPageLoad’ method and assign it an arbitrary ID, then click OK:

Then select the newly created invokeActionBinding, and in the property inspector set the ‘Refresh’ dropdown to ‘Always’:

In the JSPX page set the EL expression for the new binding like that:

Running the page again we get the expected result:

Easy as a pie.

You can download the example JDeveloper project here (remove the .pdf extension before unpacking).

Here the key points:

• Oracle is very committed to Java and sees it as essential to their future.
• An open, vibrant community is an essential part of that future, in fact it’s the community that’ll determine what standard technologies and techniques should go into the std platform (SE/EE).
• The JVM will remain open and free forever, and additional technologies will be incorporated and open-sourced as appropriate.
• Oracle is looking for willing partners in the community to engage and be part of the conversation – and they are listening.

My first intention was to achieve the certification without attending the VMWare course, using the so called “grandfather voucher“… unfortunately such a voucher is no more recognized by Springsource, so the only way was to attend an official SpringSource course.

The course

The course was definitely worth it, the teacher (Joris Kuipers) was great: very prepared, engaging and pleasant. I bothered him with many questions, he always answered in a quick and accurate way
Despite the many course subjects, we covered all of them without being in a rush, the course material and the labs are really good and useful (I’m still using it as a reference), we were provided with a perfectly working and configured STS environment.

The preparation

I know it’s very hard to find resources on the internet to prepare this exam (I’m referring to mock exams of course).

The resources I’ve actually used are the following:

• Jeanne Boyarsky’s experiences ans study notes
• Gavin Lasnitzki’s notes (it’s an extension of Jeanne’s notes)
• SkillGuru mock test 1
• Skill guru mock test 2
• Skill guru mock test 3
• BlackBeltFactory mock test 1

Many other links and useful advices are available in Jeanne’s and Gavin’s webistes.

My Study Notes

As the trainer said, the most valuable resource to prepare the certification exam is the course slides, they cover all the subjects of the certification… but in my opinion some study is still required. What I did is integrating the
Gavin notes with all the missing stuff taken from the course slides, obtaining my final version of Spring Study Notes, which you can download here. Thanks a lot to Jeanne and Gavin for their efforts, my preparation has been much faster and easier because of them!!

The exam

The exam duration is 88 minutes, 50 questions and 76% passing score, I completed it in about 40 minutes (including review).  In my opinion, the questions average difficulty is not so different than the SkillGuru/BlackBeltFactory mock tests linked above (BTW take into consideration
that they contain a lot of questions regarding subjects out of the course/exam scope). I think that a VERY good understanding of the IoC container, Spring AOP and Transaction Management is required to pass the exam, all the other subjects are less covered compared to these two. Also understanding the dynamic proxying mechanism used by Spring AOP under the hood will help a lot. What I can advice is to check the Spring 3 Reference Documentation in case of any doubts, it helped me a lot.

Good luck!

http://www.smartclient.com/smartgwt/showcase/#main

Smart GWT is a GWT-based framework that allows you to not only utilize its comprehensive widget library for your application UI, but also tie these widgets in with your server-side for data management. For a quick conceptual overview of Smart GWT, read this article, or visit the official site.

Smart GWT is based on the powerful and mature SmartClient library. In addition to Smart GWT LGPL, Pro & Enterprise editions of Smart GWT are available with additional features & tools, as well as commercial support.

The author took inspiration from Eric Evans’ book “Domain Driven Design”, covering the domain modeling and design aspects mainly from a conceptual and design stand-point.  On InfoQ is also available “Domain Driven Design Quickly” , a summary of Evan’s book.

These writings discuss the main elements of DDD such as Entity, Value Object, Service etc or they talk about concepts like Ubiquitous Language, Bounded Context and Anti-Corruption Layer.

The objective of this article is to cover the domain modeling and design from a practical stand-point on how one would go about taking a domain model and actually implementing it. We will look at the guidelines, best practices, frameworks and tools that the technical leads and architects can use in the implementation effort.

The article includes a sample loan processing application to demonstrate how design aspects and development best
practices discussed here, can be used in a real-world domain driven development project. The sample application uses
frameworks like Spring, Dozer, Spring Security, JAXB, Arid POJOs and Spring Dynamic Modules in implementing the
loan processing domain model. The example code will be in Java, but it should be fairly easy to understand for most
developers, regardless of language background.

This acquisition furthers VMware’s cloud application platform strategy by empowering additional developers to build and run modern applications that share information with underlying infrastructure to maximize performance, quality of service and infrastructure utilization.

WaveMaker is a proven, browser-based visual tool for building Spring applications.

With WaveMaker we can create a unique opportunity for coding and non-coding developers to collaborate on the Spring platform, providing large business value.

Traditionally the Achilles heel of such approaches is that the visual tooling produces applications that developers won’t want to hand edit—meaning that once the non-technical staff hit a wall and need further modifications to the application, specialist developers can’t help without reimplementing the application from scratch.

We chose WaveMaker because with it, we can avoid this problem.  A WaveMaker application is a Spring application.  Going forward, we will ensure that WaveMaker applications keep up-to-date with Spring best practices and innovations.

Like Spring, WaveMaker is open source and has a growing community. Over the last 12 months it’s seen a dramatic upswing in adoption, with 135K downloads per month. Let me be the first to welcome the WaveMaker community into the SpringSource family and to encourage the SpringSource community to take a look at how to get started with WaveMaker.

Java EE 7 has been filed as JSR 342 in the JCP program. This JSR (Java Specification Request) will develop Java EE 7, the next version of the Java Platform, Enterprise Edition. It is an “umbrella JSR” because the specification includes a collection of several other JSRs. The proposal suggests the addition of two new JSRs: Concurrency Utilities for Java EE (JSR-236) and JCache (JSR-107) as well as updates to JPA, JAX-RS, JSF, Servlets, EJB, JSP, EL, JMS, JAX-WS, CDI, Bean Validation, JSR-330, JSR-250, and Java Connector Architecture. There are also two new APIs under discussion: a Java Web Sockets API and a Java JSON API. These are the new JSRs that are currently up for ballot:

• JSR 342: Java Platform, Enterprise Edition 7 Specification

• JSR 340: Java Servlet 3.1 Specification

• JSR 341: Expression Language 3.0

• JSR 343: Java Message Service 2.0

• JSR 344: JavaServer Faces 2.2

All 5 JSRs are now up for Executive Committee voting with ballots closing on 14 March, and slated for inclusion in Java EE  7.  All of these JSRs are also open for Expert Group nominations. Any JCP member can nominate themself to serve on the Expert Groups for these JSRs. Details on how to become a JCP member are on jcp.org. The JCP gives you a chance to have your own work become an official component of the Java platform and to offer suggestions for improving and growing the technology. Either way, everyone in the Java community benefits from your participation.

There’s a nice discussion about Java EE 7 in this podcast with Java EE spec lead Robert Chinnici and more information in this blog post on the Aquarium. It’s exciting to see so much activity currently underway.