sorted by: recent | see : popular

Content Tagged with 132 + Java

Apache Cocoon is a Spring-based (since version 2.2) framework built around the concepts of separation of concerns and component-based development. Cocoon implements these concepts around the notion of component pipelines, each component on the pipeline specializing on a particular operation. This makes it possible to use a Lego(tm)-like approach in building web solutions, hooking together components into pipelines, often without any required programming. Cocoon used as web framework is "web glue for your web application development needs". It is a glue that keeps concerns separate and allows parallel evolution of all aspects of a web application, improving development pace and reducing the chance of conflicts. In particular it makes it easy to support multiple output formats, offers continuation based web controller implementations and comes with a JSR-168 compatible Portal implementation. Cocoon blocks A block is the unit of modularization (in comparison: Eclipse uses the term plugins, OSGi bundles) in Cocoon. Everything that goes beyond what Cocoon provides in its core modules (Spring integration, sitemap and pipeline implementation) is provided as block. Custom Cocoon applications are also developed as blocks. A block can provide the following features: * general servlet services (any servlet can be managed by the Cocoon servlet-service framework), * special services that provide pipelines as services, * component services (Spring beans, Avalon services/components), * a container for classes and resources. A block is packaged as a Java archive (jar) following certain conventions concerning the directory structure. General features * Apache Cocoon is a Spring-based (since version 2.2) framework built around the concepts of separation of concerns and component-based development, ensuring that people can interact and collaborate on a project without stepping on each other toes. * Cocoon implements these concepts around the notion of component pipelines, each component on the pipeline specializing in a particular operation (usual pipeline uses a Generator, Transformers and a Serializer). This makes it possible to use a Lego(tm)-like approach in building web solutions, hooking together components into pipelines without requiring programming. * Advanced Control Flow: continuation-based page flow hides the complexity of request/response processing and is cleanly separated from the view and data components. * Cocoon is open source software (based on the Apache License 2.0). * Cocoon does not duplicate efforts but tightly integrates many technologies. * Cocoon is in use at many live sites and on many company networks. * Cocoon has a strong community, with many active developers and more than plenty of active committers! * There is free support from the thousands of people on our mailing lists and commercial support is available from various companies and consultants. * There are many Cocoon sessions at different conferences: o Cocoon GetTogether o ApacheCon o Austrian Cocoon Day o WJAX o JAX Usage scenarios As you would expect, all of these scenarios can be combined. * Dynamic multi-channel web publishing (see below for the possible datasources and output formats) * Create static content (automatically) by separating data from view * Offline generation modes with Cocoon's own offline facilities: command-line interface (CLI), ant task, bean. Also with Apache Forrest which utilises Cocoon. * Dynamic document preparation with Apache Forrest, the 'forrest run' mode. Use many different data input formats, see the transformed result immediately in the browser. * Advanced web applications with J2EE integration (with separation of your data, the view and the flow logic --> this really means you can change one of the parts without touching another) * Develop your company portal using the Cocoon Portal framework * Support multiple clients, layouts and languages (i18n) without code duplication * Integrate Cocoon with your existing web applications or use it to put a better face on them (page scraping) * Add full-text search to any datasource that can be converted to XML (see below) * Use Cocoon as the base for Enterprise Application Integration (EAI) * Use Cocoon as the base for your Content Management System (CMS) (see Apache Lenya, Daisy CMS and Hippo CMS) * Use Cocoon for producing mobile content (mobile phones, PDAs) * Datawarehouse reporting across multiple formats (see xReporter) Apache Cocoon Home Page http://cocoon.apache.org/ Download Apache Cocoon http://cocoon.apache.org/mirror.cgi

Direct Web Remoting(DWR) allows Javascript in a browser to interact with Java on a server and helps you manipulate web pages with the results. DWR is Easy Ajax for Java DWR is a Java open source library which allows you to write Ajax web sites. It allows code in a browser to use Java functions running on a web server just as if it was in the browser. DWR consists of two main parts: * A Java Servlet running on the server that processes requests and sends responses back to the browser. * JavaScript running in the browser that sends requests and can dynamically update the webpage. DWR works by dynamically generating Javascript based on Java classes. The code does some Ajax magic to make it feel like the execution is happening on the browser, but in reality the server is executing the code and DWR is marshalling the data back and forwards. This method of remoting functions from Java to JavaScript gives DWR users a feel much like conventional RPC mechanisms like RMI or SOAP, with the benefit that it runs over the web without requiring web-browser plug-ins. Java is fundamentally synchronous where Ajax is asynchronous. So when you call a remote method, you provide DWR with a callback function to be called when the data has been returned from the network. The diagram shows how DWR can alter the contents of a selection list as a result of some Javascript event like onclick.

DWR dynamically generates an AjaxService class in Javascript to match some server-side code. This is called by the eventHandler. DWR then handles all the remoting details, including converting all the parameters and return values between Javascript and Java. It then executes the supplied callback function (populateList) in the example below which uses a DWR utility function to alter the web page. DWR helps you in producing highly interactive web-sites by providing some Javascript libraries to help with DHTML and by giving you a set of examples to copy from. Direct Web Remoting(DWR) Project Home Page http://getahead.org/dwr Download Direct Web Remoting(DWR) http://getahead.org/dwr/download Direct Web Remoting(DWR) Documentation http://getahead.org/dwr/documentation

AspectWerkz is a dynamic, lightweight and high-performant AOP framework for Java. AspectWerkz offers both power and simplicity and will help you to easily integrate AOP in both new and existing projects. AspectWerkz utilizes bytecode modification to weave your classes at project build-time, class load time or runtime. It hooks in using standardized JVM level APIs. It has a rich and highly orthogonal join point model. Aspects, advices and introductions are written in plain Java and your target classes can be regular POJOs. You have the possibility to add, remove and re-structure advice as well as swapping the implementation of your introductions at runtime. Your aspects can be defined using either Java 5 annotations, Java 1.3/1.4 custom doclets or a simple XML definition file. AspectWerkz provides an API to use the very same aspects for proxies, hence providing a transparent experience, allowing a smooth transition for users familiar with proxies. AspectWerkz performance is reported in this separate project. AspectWerkz is Free Software. The LGPL-style license allows the use of AspectWerkz 2.0 in both commercial and open source projects. AspectWerkz Features This is a very incomplete list, see the documentation for all features. * Very high-performant. Weaved code is entirely statically compiled. AspectWerkz ranks 1st or 2nd in most of the benchmarks. Read more about the figures on the AspectWerkz Bench project pages. * Annotation support: Matching on annotations (both JavaDoc and JSR-175). Supports user-defined annotations, retrieval of annotations. Both JavaDoc and JSR-175 annotations are accessed through one single API and both schemes are strongly typed. * Aspects, advices and introductions are written in plain old Java code. I.e. no new language to learn, no new compilation phases, no need to tell your manager ;-). Will work seamlessly in any IDE, debugger, refactoring tool and test framework. * The target classes can be regular POJOs (Plain Old Java Objects), i.e. do not require to have an interface. * Weaving (bytecode modification) at compile time, load time and runtime. Hooks in and transforms classes loaded by any class loader except the bootstrap class loader. Which basically means that you can easily transform any (legacy) application or external library apart from rt.jar both at runtime and compile time. JSR-163 JVMTI is supported for Java 1.5 usage as well. * The join point model supports: staticinitialization, method execution and call, constructor execution and call, field access, field modification, catch handlers, cflow, within and withincode, hasmethod and hasfield. All advice works with all join points. * Rich semantics allow to access runtime information about the join point within the advice using regular types without any casting or object array access. Reflective access to runtime information is also possible. * Introductions/Inter type declarations (also called Mixins), i.e. the possibility to add interfaces and implementations to existing classes. * META-INF/aop.xml container: Support for deploying several aop.xml Aspect defintion/deployment files alongside deployed application ( WEB-INF/aop.xml, META-INF/aop.xml) and have them following the classloader hierarchy. * Annotation definition. Define your aspects and mixins using annotations using wether standardized Java 5 Annotations (JSR-175) or Java 1.3/1.4 custom doclet with strongly typed access. * XML definition. Define your aspects and mixins using XML. The XML definition can also be used to refine, override and resolve the annotation definition. * Pluggable aspect manager that can make it work seamlessly with IoC frameworks like Spring or PicoContainer. * Support several different deployment models (scope) for aspects (perJVM(singleton), perClass, perInstance) and for mixin (perInstance, perClass, perJVM(singleton)). * Hot deployment, aspects can be deployed and undeployed at runtime using a simple API. * Fine-grained pattern language for selecting the join points. * Highly orthogonal underlying model. All advice works with all join points and pointcut composition supports mixing all kinds of pointcuts. * "Offline" transformation (can be used as a post-processor). * Support for passing configuration parameters to the advices through the definition. * Simple usage and configuration. * Extensible container architecture allows to run any Aspects (AspectWerkz, Spring AOP, AOP Alliance, subset of AspectJ) within the AspectWerkz runtime. AspectWerkz Downloads http://aspectwerkz.codehaus.org/releases.html Documentation & Tutorials for AspectWerkz http://aspectwerkz.codehaus.org/introduction.html http://docs.codehaus.org/display/AW/Tutorials