Rapid Application Development with Cocoon

2,627 views
2,487 views

Published on

From the Cocoon GetTogether 2005:

When flowscript came up it was not only the powerful idea of continuations that helped making it a big success. In combination with its scripting nature it provided a much quicker development cycle.Soon people wished to have such a short turnaround in their java based development environments. And that's what we have in the latest Cocoon trunk - today! Auto-compilation of javaflow (the java based alternative to flowscript) and instant reloading of components helps to cut down development times tremendously. Without further need of restarting your servlet container after every little change, java development has finally become as easy as it should be.

This session will demonstrates on how to use features like reloading or auto-compilation of the current Cocoon trunk. It will also try to demystify the magic behind javaflow and will provide an overview about the current status and limitations.

Published in: Business, Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
2,627
On SlideShare
0
From Embeds
0
Number of Embeds
33
Actions
Shares
0
Downloads
41
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Rapid Application Development with Cocoon

  1. 1. Torsten Curdt <vafer/>.org tcurdt@apache.org Rapid Application Development with Cocoon javaflow and the compiling classloader Cocoon GetTogether 2005, Amsterdam
  2. 2. about me : 2 : • with Cocoon since 1.x • member of the Cocoon PMC • member of the Jakarta PMC • ASF member
  3. 3. quote : 3 : “Rapid Application Development is exactly the opposite of what Cocoon provided a fears ago - but gladly enough times have changed” Torsten Curdt
  4. 4. agenda : 4 : • general environment hints • Cocoon features for RAD • web application and IDE config • live demonstration • behind the scenes • overview of jci and javaflow
  5. 5. hints : 5 : • stripped down version of Cocoon • build the source jars • relocate the webapp with the COCOON_WEBAPP_HOME environment variable • use “cocoon servlet-debug”
  6. 6. features : 6 : • compiling + reloading of classes • compiling + reloading of javaflow • compiling + reloading of components • reloading of jars
  7. 7. map:classpath : 7 : <map:components> ... <map:classpath> <class-dir src=”...”/> <src-dir src=”...”/> <lib-dir src=”...”/> </map:classpath> ...
  8. 8. store : 8 : <map:components> ... <map:classpath> <class-dir src=”...”> <store class=”...”/> </class-dir> </map:classpath> ...
  9. 9. eclipse : 9 : DEMO
  10. 10. hmmm : 10 : So how does it work?
  11. 11. sitemap : 11 : • own component manager • can have a dedicated classpath • uses a paranoid* classloader *parent-last classloader
  12. 12. reloading : 12 :
  13. 13. adding flow : 13 : • resources transformed on-the-fly • similar to pipelines
  14. 14. ...but! : 14 : • does not help for core development • be careful on a live system upgrade • object types defined per classloader
  15. 15. dimensions : 15 :
  16. 16. gotchas : 16 : • objects in sessions • parent component manager component interactions • old continuations
  17. 17. commons : 17 : • commons jci does the • monitoring • compilation • commons javaflow provides • java continuations • cocoon javaflow block • evolved out of cocoon 2.1 • now being used in cocoon trunk
  18. 18. cocoon block : 18 : • flow interpreter • flow object model • base classes • integration with CForms
  19. 19. example : 19 : public class MyFlow extends AbstractContinuable { public void run() { ... sendPageAndWait( ”page”, data); ... }
  20. 20. jci : 20 : • compiler abstraction • supports eclipse, janino, groovy • filesystem monitoring • events for create, change and delete • compiling/reloading class loader http://jakarta.apache.org/commons/sandbox/jci
  21. 21. jci API : 21 : CompilationResult result = compiler.compiler( classNames, new FileResourceReader(dir), new MemoryResourceStore()); if (result.getErrors() .length > 0) { ...
  22. 22. jci API : 22 : FilesystemAlterationMonitor fam = new F..A..M(); fam.start(); fam.addListener( new CompilingListener( dir));
  23. 23. future : 23 : • almost ready for a release (94% testcase coverage!!) • better dependencies support • adding more compilers • javac, pizza, jikes, gcj • maven might switch to jci
  24. 24. javaflow : 24 : • java continuations through bytecode instrumentation • works hand in hand with jci • ant-task for jar/class rewriting • supports serialization(!!) http://jakarta.apache.org/commons/sandbox/javaflow
  25. 25. javaflow API : 25 : Continuation continuation = Continuation.startWith( new Calculator()); ... Continuation.continueWith( continuation);
  26. 26. continuations : 26 :
  27. 27. instrumentation : 27 :
  28. 28. scalability : 28 : • the deeper your flow, the more memory used per continuation • increases linearly • avoid recursion • the more method calls, the more overhead • can be heavily optimized
  29. 29. limitations : 29 : • suspend in synchronized blocks • suspend in a catch/finally
  30. 30. future plans : 30 : • remove current limitations • call graph analysis for optimization • switching from BCEL to ASM(?) • support for external suspends(?) • talking with the guys from RIFE • release within the next few months
  31. 31. summary : 31 : • auto-compiling and reloading of • classes • javaflow • components • full IDE support • debugging • refactoring • (potential) serialization support • persisting continuations across restarts • session and flow replication
  32. 32. thanks : 32 : questions?

×