9

I'm looking for a Java solution that would allow me to use AOP to weave new code on top of already running code at runtime. The key is not to require the restart of the JVM. Also, I'd like to remove the woven at runtime, leaving the old code running the way it was before weaving.

I'm thinking AspectJ load time weaving + runtime class loading/unloading would do it. Has anyone tried it? Any recommendations? Thank you.

Faustas
  • 350
  • 1
  • 2
  • 10
  • 1
    I know this one is old, but still listed as unanswered. Would you please accept and upvote my answer if it seems appropriate? Thanks. – kriegaex Jun 09 '14 at 12:38

3 Answers3

13

A few things to consider:

  • True, you can do LTW during class loading, but not after a class has already been loaded.
  • There is no such concept as class unloading because for a class to be unloaded it needs to be garbage-collected and for that no references to the class must exist anymore. Even if the latter was the case, the JVM specification AFAIK declares it as optional whether or not and when unloading or GC should clear off an already loaded class. You could never rely on it.

Having said that, you either can try concepts such as OSGi or write your own class loader (or find one of many existing ones on the Internet) which loads each class or each JAR in a separate classloader instance. This can get arbitrarily complex, so maybe you want to consider this simple approach as long as it is within the technical bounds of your situation:

  • Compile your aspects into your code or use LTW, it does not really matter. Just make sure that the aspect code is woven before the classes are actually used. Compile time is obviously more than soon enough, load time is just barely soon enough, but fine.
  • Use if() pointcuts for all relevant advice and provide a means to dynamically change the value of the variable used by the pointcuts so as to be enable to dynamically switch advice on and off. The performance overhead will usually be minimal, don't worry. Just give it a try before you say it is too expensive.

This solution satisfies your conditions that it can be (de)activated dynamically and that no JVM restart is necessary after the aspect code has been woven.

kriegaex
  • 63,017
  • 15
  • 111
  • 202
  • Well, that puts the responsibility on the developer to write aspects that can be turned on/off. And I would like to avoid it. – Faustas Jul 19 '13 at 15:02
  • I was thinking about using JRebel or any other class-reloading-at-runtime tool. Since the classes get re-loaded at runtime, my assumption is that it would allow re-weaving on re-load as well. – Faustas Jul 19 '13 at 15:03
  • Hm, I think developers do have responsibilities. Core code devs are responsible for core code, aspect devs are responsible for cross-cutting concerns. So I guess it is not asking too much. Anyway, just because you made me curious I gave JRebel a quick try last weekend and used it with AspectJ. It worked nicely for compile-time weaving, but I could not get it working within 5 minutes (which does not mean much) with load-time weaving. It is a nice tool for developers, but I am not sure I would use it in production. – kriegaex Jul 26 '13 at 07:15
9

Aspect

An aspect is the cross-cutting functionality you are implementing. It is the aspect, or area, of your application you are modularizing. The most common (albeit simple) example of an aspect is logging. Logging is something that is required throughout an application. However, because applications tend to be broken down into layers based on functionality, reusing a logging module through inheritance

does not make sense. However, you can create a logging aspect and apply it throughout your application using AOP.

Weaving

Weaving is the process of applying aspects to a target object to create a new, proxied object. The aspects are woven into the target object at the specified joinpoints. The weaving can take place at several points in the target class’s lifetime:

  • Compile time :Aspects are woven in when the target class is compiled. This requires a special compiler.
  • Classload time :Aspects are woven in when the target class is loaded into the JVM. This requires a special ClassLoader that enhances that target class’s bytecode before the class is introduced into the application.
  • Runtime :Aspects are woven in sometime during the execution of the application. Typically, an AOP container will dynamically generate a proxy class that will delegate to the target class while weaving in the aspects.

enter image description here
enter image description here

(Source)

Premraj
  • 72,055
  • 26
  • 237
  • 180
  • 6
    This doesn't actually address the question. It's just general information about AOP. – Dennis Aug 24 '15 at 12:46
  • Weaving is the process of applying aspects to a target object to create a new, proxied object --- this is true only when it comes to 'create a new proxied target' that is in SpringAOP scope, not for Aspectj. – Ross Bu Mar 21 '19 at 01:31
0

You can Implement an ASM solution that would allow to weave new code on top of already running code at runtime (with no downtime)

  • ASM can retransform already loaded classes it basically reads the class on the file and retransform the loaded class in Memory
  • Manipulation with ASM (https://www.baeldung.com/java-asm)

You might can use the same solution to remove the woven at runtime

  • the loaded class remains on the file system that might can be reload.
Avi Chalbani
  • 842
  • 7
  • 11