* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Download JBoss and Aspects for Middlware Components
Survey
Document related concepts
Go (programming language) wikipedia , lookup
Falcon (programming language) wikipedia , lookup
Java syntax wikipedia , lookup
Design Patterns wikipedia , lookup
Java (programming language) wikipedia , lookup
Application Interface Specification wikipedia , lookup
Java performance wikipedia , lookup
Object-relational impedance mismatch wikipedia , lookup
Dependency injection wikipedia , lookup
Java ConcurrentMap wikipedia , lookup
Class (computer programming) wikipedia , lookup
Name mangling wikipedia , lookup
Object-oriented programming wikipedia , lookup
Transcript
JBoss and Aspects for Middleware Components Presented by: Alon Kama Seminar on Aspect-Oriented Software Development Instructor: Prof. Shmuel Katz Winter 2004-2005 Prologue “AOP is an exciting new paradigm that should have the same effect on SW dev that OOP had 15-20 years ago” -- Bill Burke, chief architect, JBoss • The goal of JBoss: deliver an enterprise-strength application server that enables powerful usage of aspects. Introduction: Middleware Middleware is composed of software that act as intermediaries between different application components, to ease programming, integration, and management. caching Application Application Middleware Middleware fault tolerance replication security logging transactions Network Middleware: another view • Middleware can also be viewed in the component model Network Encapsulated software that performs a service Accessed either locally or remotely Application Director y Services Security Introduction: About JBoss™ • Inc. is a for-profit company, developing the JBoss Enterprise Middleware System (JEMS) Free, open-source product; paid support, consulting, and training • .ORG is a developer community site JBoss Inc. capitalizes on the open-source community for contributing code, beta testing, answering user questions Introduction: About JEMS • A suite of integrating, open-source components for product development and execution JBoss Application Server J2EE compliant JBoss AOP Aspect oriented framework • Tightly coupled with Application Server JBoss jBPM workflow engine JBoss Cache fine-grained caching engine JGroups multicast communication module JBoss IDE Eclipse-based dev environment Introduction: JBoss AOP • Yet another aspect-oriented framework?!? • Yes, but: Not standalone, tightly integrated with other software Easy management Ability to dynamically apply or disengage aspects at runtime Professional support, consulting, and training Agenda • Review the JBoss method of defining and specifying: Interceptors Pointcuts Advice • Contrast with AspectJ • Show applicability for middleware JBoss and Java • JBoss AOP is designed to be run using JBoss Application Server J2EE 5.0 compliant 100% Pure Java • AOP constructs defined as pure Java classes • Constructs bound using XML or Java annotations Joinpoints • JBoss defines invocation objects that correlate to exposed joinpoints Method / Constructor invocation Field access • AspectJ exposes a bit more Execution of catch block Static initialization • Various syntactical differences (unimportant) Defining the Pointcut: interceptors • Interceptors come between a method call and its • execution Defining an interceptor in an XML file: <bind pointcut="public void com.mc.BankAccountDAO-> withdraw(double amount)"> <interceptor class="com.mc.Metrics"/> </bind > <bind pointcut="* com.mc.billing.*->*(..)"> <interceptor class="com.mc.Metrics"/> </bind > JBoss AOP Interceptor public class Metrics implements org.jboss.aop.Interceptor { public Object invoke(Invocation invocation) throws Throwable{ long startTime = System.currentTimeMillis(); try { return invocation.invokeNext(); } finally { long endTime = System.currentTimeMillis() - startTime; java.lang.reflect.Method m = ((MethodInvocation)invocation).method; System.out.println("method " + m.toString() + " time: ” + endTime + "ms"); } } } J2SE5.0: Annotations • An annotation is metadata that is written by the programmer in the source file. Later, a tool will process this and emit code instead. Offers a “declarative” programming style Does not affect program semantics, but affects the way a program is treated by tools and libraries Annotations: Example • Defining an annotation type: /** * Associates a copyright notice with the annotated API * element. */ public @interface Copyright { String authors(); String date() default “2005”; } • Annotation declaration: @Copyright( authors = “Alon”, date = “16/1/05” ) public class Foo {…} Means that Foo implements the Copyright interface, using the initialization above the declaration Annotations and AOP • Example: add syntax to fire void methods asynchronously: import org.jboss.aspects.Oneway; public class Foo { @Oneway public static void someMethod() {...} public static void main(String[] args) { someMethod(); // executes in background } } • Thus, easy to add an aspect element by way of an interface (in this case, a method interface) Defining syntax for @Oneway • Defining the interface strictly for methods: package org.jboss.aspects; import java.lang.annotation.ElementType; import java.lang.annotation.Target; @Target({ElementType.METHOD}) public @interface Oneway {} Defining aspect for @Oneway • Defining the aspect class: public OnewayAspect { private static class Task implements Runnable { private MethodInvocation invoc; public Task(MethodInvocation invocation) {this.invoc = invoc;} public void run() { try { invoc.invokeNext(); } catch (Throwable ignore) { } public Object oneway(MethodInvocation invoc) throws Throwable { MethodInvocation copy = invoc.copy(); Thread t =new Thread(new Task(copy)); t.setDaemon(false); t.start(); return null; } } Pointcut expression: @Oneway <aop> <aspect class="org.jboss.aspects.OnewayAspect"/> <bind pointcut= "execution(void *>@org.jboss.Oneway(..))"> <advice name="oneway" aspect="org.jboss.aspects.OnewayAspect"/> </bind> </aop> Dependency Injection • AOP can be used to specify dependencies upon object declaration, and have those dependencies met upon runtime Advantages: removal of dependency on concrete classes and external configurability e.g. Vendor-specific access methods • Can write a generic application and have user plug in the appropriate database-specific classes (e.g. Oracle, DB2) Dependency Injection • Example: A non-standardized way to access an object location service Would like to inject an instance of this service for every field that references it • Define the annotation: @Target({ElementType.FIELD}) public @interface Inject {} This defines the annotation for use on class’s fields Dependency Injection • Using the declaration in user’s code: import org.jboss.aspects.Inject; public class Foo { @Inject private LocationService loc; public void bar(String s) { Object o = loc.lookup(s); ... } } Dependency Injection • Defining the aspect class: public InjectLocAspect { private LocationService loc = Magic.getInstance(); public Object access(FieldReadInvocation invocation) throws Throwable { return loc; } public Object access(FieldWriteInvocation invocation) throws Throwable { throw new RuntimeException("Setting an @Injected variable is illegal"); } } Dependency Injection • Defining the XML binding: <aop> <aspect class=“org.jboss.aspects.InjectLocAspect”/> <bind pointcut= “field(LocationService*>@org.jboss.aspects.Inject)”> <advice name=“access”aspect=“org.jboss.aspects.InjectLocAsp ect”/> </bind> </aop> Dynamic AOP • Advices and Interceptors can be added or removed from any joinpoint at runtime. Useful for deploying and un-deploying metrics or statistic gathering on an as-needed basis. For testing, allows to deploy/un-deploy testing aspects while running automated tests Adding Advice Binding • At runtime, can add advice binding as follows: org.jboss.aop.advice.AdviceBinding binding = new AdviceBinding(“execution(POJO>new(..))”,null); binding.addInterceptor(SimpleInterceptor.class); AspectManager.instance().addBinding(binding); Per-instance AOP • Example: JBoss Cache AOP (TreeCacheAOP). The cache performs automatic replication across a cluster • For maintaining consistency, necessitates that an object’s field accesses are intercepted Before: Obj While in cache: Obj After leaving cache: Obj Per-instance AOP • TreeCacheAOP uses AOP to prepare classes so that field access may be intercepted. Upon inserting: adds field interceptors so that it can do automatic replication Upon removing: the field interceptors are removed • Does not affect object access when object is not associated with the cache Integration with pointcuts • After productizing and shipping an application, sometimes users want to integrate with it Users want “hooks” in different places of the application so that they can trigger things specific to their particular deployment If hooks are provided using OOP, it becomes tough to redesign or change API. By using pointcuts, the application designer provides logical names to pointcut expressions. The pointcut expression can change over time but the logical name stays the same Testing an application • Writing test suites to check all exception handling is time-consuming and errorprone Need to write code to produce all error conditions Using aspects, can test a live system by deploying/un-deploying certain aspects at runtime Testing example • Simulate SQL deadlock exception public class SQLDeadlockExceptionInjector { public Object throwDeadlock(Invocation invocation) throws Throwable { throw new SQLException("Oracle Deadlock", "RETRY“,ORACLE_DEADLOCK_CODE); } } • Advice to intercept execute() methods of java.sql.Statement <aspect class="SQLDeadlockExceptionInjector/> <bind pointcut="call(* $instanceof{java.sql.Statement}>execute*(..))"> <advice name="throwDeadlock” aspect="SQLDeadlockExceptionInjector"/> </bind> Testing example • To fine-grain it only for BankAccount class: <bind pointcut="call(* $instanceof{java.sql.Statement}>execute*(..)) AND within(BankAccount)"> <advice name="throwDeadlock" aspect="SQLDeadlockExceptionInjector"/> </bind> • To fine-grain for a specific method: <bind pointcut="call(* $instanceof{java.sql.Statement}>execute*(..)) AND withincode(void BankAccount>withdraw(double))"> <advice name="throwDeadlock" aspect="SQLDeadlockExceptionInjector"/> </bind> DesignByContract aspect • This novel feature is a design technique that lets us provide precise specifications of valid arguments to methods, return values, and valid states of objects Think Eiffel the programming language • Specify pre-/post-conditions and invariants by annotating the method or class DesignByContract conditions • Examples: Precondition /* @@org.jboss.aspects.dbc.Dbc */ public class PreCondExample{ /** @@org.jboss.aspects.dbc.PreCond ({"$0 > 0"}) */ public void squareRoot(int i) { .. } } Postcondition (what must be true at end) public class PostCondExample{ /** @@org.jboss.aspects.dbc.PostCond ({"$rtn=$0*$1"}) */ public int multiply(int i, int j) { .. } } DesignByContract conditions • Invariant: True before and after calling any public method /** @@org.jboss.aspects.dbc.Dbc * @@org.jboss.aspects.dbc.Invariant ({"$tgt.myString != null || $tgt.myString.length() > 0"}) */ public class InvariantExample { String myString; public void setMyString(String s) {myString=s;} } DesignByContract usage • Conditions may be defined for interfaces Enforced on all implementing classes /* @@org.jboss.aspects.dbc.Dbc */ public interface RootInterface{ /*@@org.jboss.aspects.dbc.PreCond ({"$0 > 0"}) */ public void someMethod(int i); } DesignByContract usage • Defining the aspect <aop> <aspect class="org.jboss.aspects.dbc.DesignByContractAspect" scope="PER_JOINPOINT"> </aspect> <bind pointcut="execution(* $instanceof{@org.jboss.aspects.dbc.Dbc}->*(..)) OR execution($instanceof{@org.jboss.aspects.dbc.Dbc}>new(..))"> <advice aspect="org.jboss.aspects.dbc.DesignByContractAspect" name="invoke"/> </bind> </aop> Conclusion • Who are the intended users for AOP? Application developers, to test code • Inject errors, invoke validation routines Middleware developers • Create transparent services System integrators / end-users • Customize software to environment Easier to manage than with config files • Rich environment for expansion, tweaking Unencumbered by OOP structure Case in Point: IBM • “On-demand computing” Conclusion • JBoss has released AOP version 1.0.0 as part of App Server v4.0.1 • Future development: undisclosed As a public company, JBoss does not reveal future functionality • JBoss has relationships with many partners and system integrators, such as HP and CA Thank You. Notes for myself