We have been working with the EJB 3.0 implementations and see
a lot of synergy between the new approach to enterprise Java with
this new specification, and would love to see FDS add an adaptor to
support it.
Our new entity/session beans have annotated relationships,
primary key information, and security regarding access to the
object and it's methods are specified already in the Java source.
Centralized management of this information where it is closest to
the source is highly productive.
With so much of the FDS configuration still sitting in static
XML files, we are required to maintain a redundant copy of all of
the annotation information separately. This adds pure overhead to
the development process, and it is challenging to keep the two in
sync when applications are enhanced.
We would like to see the FDS framework more tightly
integrated with the rest of the J2EE world, and through Java
introspection and annotations learn about the applications
available on the server side without custom config files.
The fill, assembler, and synchronization methods could simply
be a standard class interface to be implemented with methods to
override, or even annotated with flex annotations. Destinations
would no longer need to be hand-configured. The meta-data about row
identity would be read from the entity beans themselves. If a fill
method has parameters, read them from the function prototypes.
(The existing Flash remoting product seems to have the above
features. We enjoy the integration of Flash Remoting, and the
development workflow associated. The Flash client only needs the
JNDI name of the services, and once authenticated, access to any
function is possible without further action. FDS goes above and
beyond to provide several very interesting features, but is not
quite as intuitive when it comes to J2EE services.)
To tie this meta-information on the server back to the IDE
for visual design, using real server-side object properties and
methods, and session bean functions would close the loop on the
development cycle. This could also be accomplished within Eclipse
since the server side Java classes could easily be in the
classpath. The IDE could give the developer a hand in choosing and
referencing valid return object properties. An actionscript object
could even be generated if necessary from the entity bean's
properties...
Are any of these ideas in the works, or are there any
exisiting methods for accomplishing these efficiencies?
