- AspectJ(tm) is a simple and practical extension to the Java(tm) programming language that adds to Java aspect-oriented programming (AOP) capabilities. AOP allows developers to reap the benefits of modularity for concerns that cut across the natural units of modularity. In object-oriented programs like Java, the natural unit of modularity is the class. In AspectJ, aspects modularize concerns that affect more than one class.
You compile your program using the AspectJ compiler (perhaps using the supported development environments) and then run it, supplying a small (< 100K) runtime library.
The AspectJ technologies include a compiler (ajc), a debugger (ajdb), a documentation generator (ajdoc), a program structure browser (ajbrowser), and integration with Eclipse, Sun-ONE/Netbeans, GNU Emacs/XEmacs, JBuilder, and Ant.
- Simple, high-performant, dynamic, lightweight and powerful AOP for Java.
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.
- CaesarJ is a new Java based programming language, which facilitates better modularity and development of reusable components. The components are collaborations of classes, but they can modularize crosscutting features or non-functional concerns. Caesar language features help to implement, abstract and integrate such components. Caesar can be used in combination with plain Java. Tool support is available in the form of an Eclipse plugin.
Even more interested?
CaesarJ is open source and you can participate in the implementation and development of CaesarJ. Professional support is available for sponsors and industry partners. Please contact us if you want to know more!
- This distribution provides an infrastructure for scalable scientific and technical computing in Java. It is particularly useful in the domain of High Energy Physics at CERN: It contains, among others, efficient and usable data structures and algorithms for Off-line and On-line Data Analysis, Linear Algebra, Multi-dimensional arrays, Statistics, Histogramming, Monte Carlo Simulation, Parallel & Concurrent Programming. It summons some of the best concepts, designs and implementations thought up over time by the community, ports or improves them and introduces new approaches where need arises. In overlapping areas, it is competitive or superior to toolkits such as STL, Root, HTL, CLHEP, TNT, GSL, C-RAND / WIN-RAND, (all C/C++) as well as IBM Array, JDK 1.2 Collections framework, JGL (all Java), in terms of performance (!), functionality and (re)usability.
- DynamicAspects is a aspect-oriented framework for Java using only pure Java.
* Aspects are written in pure Java.
* Aspects can be installed and deinstalled during runtime.
* Target classes can be written on a SUN JDK 1.4 or a SUN JDK 5.0 ( 1.5 ) basis.
* DynamicAspects needs the Runtime Environment SUN JRE 5.0.
* DynamicAspects uses the JavaAgent technology introduced in SUN JDK 5.0.
* DynamicAspects lets you write Advices that can be installed around Method/Constructor-executions or -calls.
* DynamicAspects lets you write Cflow-Advices.
* DynamicAspects lets you write MixIns/IntertypeDeclarations ( which are currently loaded at program start and not deinstallable ).
* Regular expressions are used for describing the pointcuts.
* The current release of DynamicAspects is beta.
* Download DynamicAspects here.
- dynaop, a proxy-based Aspect-Oriented Programming (AOP) framework, enhances Object-Oriented (OO) design in the following areas:
* code reuse
* dependency reduction
- Event-based Aspect-Oriented Programming (EAOP) for Java. EAOP 1.0 realizes the EAOP model through the following characteristics:
* Expressive crosscuts: execution points can be represented by events and crosscuts can be expressed which denote arbitrary relations between events.
* Explicit aspect composition: Aspects may be combined using a (extensible) set of aspect composition operators.
* Aspects of aspects: Aspects may be applied to other aspects.
* Dynamic aspect management: Aspects may be instantiated, composed and destroyed at runtime.
The tool provides a testbed for the experimentation of aspect languages. As such, it does not provide specialized languages for pointcuts and advice (such as AspectJ) but offers a framework for the definition of arbitrary aspects.
JAC - Java Aspect Components
- JAC (Java Aspect Components) is a project consisting in developing an aspect-oriented middleware layer.
JAC aspect components provide:
* seamless persistence (CMP) that fully handles collections and references
* flexible clustering features (customisable broadcast, load-balancing, data-consistency, caching)
* instantaneously defined users, profiles management, access rights checking, and authentication features
* RAD (Rapid Application Development):
* the GUI aspect allows the programmer to develop Swing and WEB applications at incredible speeds
* the UMLAF IDE (UML Aspectual Factory) allows the programmer to generate running Java applications simply by drawing boxes and by configuring existing aspect components
* distributed transactions with JOTM
and many more
JBoss Aspect Oriented Programming
- JBoss AOP is a 100% Pure Java aspected oriented framework usuable in any programming environment or tightly integrated with our application server. Aspects allow you to more easily modularize your code base when regular object oriented programming just doesn't fit the bill. It can provide a cleaner separation from application logic and system code. It provides a great way to expose integration points into your software. Combined with JDK 1.5 Annotations, it also is a great way to expand the Java language in a clean pluggable way rather than using annotations solely for code generation. Check out our User Guide linked below as it described in detail why you'd want to use aspects.
JBoss AOP is not only a framework, but a prepackaged set of aspects that are applied via annotations, pointcut expressions, or dynamically at runtime. Some of these include caching, asynchronous communication, transactions, security, remoting, and many many more. Check out our WIKI for more detail.
- Jdon is a meta framework , a fast J2EE development framework. 1. JdonFramework source is an implementation of Ioc/Aop. 2. it supports Struts+EJB/POJO Services, the interface for ejb services is more perfect.
- Nanning Aspects is a simple yet scaleable aspect-oriented framework for Java.
Nanning is also nice "little" town in Guanxi province in southern China. It's about 1-2 million inhabitants which barely qualifies it as a town by chinese standards. It is not to be confused with the much larger Nanking/Nanjing.
Most documentation is located at our SnipSnap http://nanning.snipsnap.org . It's an ongoing effort.
Report bugs to our bug tracker .
We're occasionally hanging out at the Codehaus IRC server. Connect a suitable IRC-client to irc.codehaus.org channel #nanning .
- Spring is a layered Java/J2EE application framework, based on code published in Expert One-on-One J2EE Design and Development by Rod Johnson (Wrox, 2002).
* Generic abstraction layer for transaction management, allowing for pluggable transaction managers, and making it easy to demarcate transactions without dealing with low-level issues. Generic strategies for JTA and a single JDBC DataSource are included. In contrast to plain JTA or EJB CMT, Spring's transaction support is not tied to J2EE environments.
* JDBC abstraction layer that offers a meaningful exception hierarchy (no more pulling vendor codes out of SQLException), simplifies error handling, and greatly reduces the amount of code you'll need to write. You'll never need to write another finally block to use JDBC again. The JDBC-oriented exceptions comply to Spring's generic DAO exception hierarchy.
* Integration with Hibernate, JDO, and iBATIS SQL Maps: in terms of resource holders, DAO implementation support, and transaction strategies. First-class Hibernate support with lots of IoC convenience features, addressing many typical Hibernate integration issues. All of these comply to Spring's generic transaction and DAO exception hierarchies.
* AOP functionality, fully integrated into Spring configuration management. You can AOP-enable any object managed by Spring, adding aspects such as declarative transaction management. With Spring, you can have declarative transaction management without EJB... even without JTA, if you're using a single database in Tomcat or another web container without JTA support.
* Flexible MVC web application framework, built on core Spring functionality. This framework is highly configurable via strategy interfaces, and accommodates multiple view technologies like JSP, Velocity, Tiles, iText, and POI. Note that a Spring middle tier can easily be combined with a web tier based on any other web MVC framework, like Struts, WebWork, or Tapestry.