Can a Java class add a method to itself at runtime?

Question

Can a class add a method to itself at runtime (like from a static block), so that if someone is performing reflection on this class, they'll see the new method, even though it wasn't defined at compile time?

Background:

A framework I'm using expects Action classes to be defined that have a doAction(...) method, by convention. The framework inspects these classes at runtime to see what type of parameters are available in their doAction() method. For example: doAction(String a, Integer b)

I'd like each class to be able to programatically generate its doAction() method with various parameters, just-in-time when it is inspected. The body of the method can be empty.

Yes it is possible. Check this question : http://stackoverflow.com/questions/17323500/aspect-weaving-at-runtime — Mehdi, Oct 26 '15 at 20:13
I understand that aop can be used for things like logging but the OP requires that a framework identify classes for a certain type of processing based on the existence of a method. In other words can AOP be used to add a method signature? — Quaternion, Jun 21 '16 at 20:01

score 62 · Accepted Answer · edited Feb 25 '13 at 17:25

It's not simple. Once a class is loaded by a classloader, there is no way to change the methods of loaded classes. When a class is requested, a classloader will load it and link it. And there is no way (with Java) to change the linked code or to add/remove methods.

The only trick that comes to my mind is playing with classloaders. If we delete a custom classloader, then the classes loaded by that classloader should be deleted or inaccessible too. The idea that comes to my mind is to

implement one custom classloader
load the dynamic class with that custom classloader
if we have an updated version of this class,
remove the custom classloader and
load the new version of this class with a new instance of the custom classloader

I leave that as food for thought, can't prove, if this leads to a solution or if we have pitfalls.

As a simple answer to the question: No, we can't change a loaded class like we can change the content of fields with reflection. (we can't add or remove fields too).

Sure you can do this, but then you also have to reload all classes that are compiled against this one. — Stefan Reich, May 31 '17 at 00:15

score 25 · Answer 2 · answered Sep 14 '12 at 23:26

Andres_D is right, we can very well do so using custom class loading, here is a detailed guide on how to do this: http://www.javaworld.com/javaworld/jw-06-2006/jw-0612-dynamic.html?page=1

The article explains how to write dynamic Java code. It discusses runtime source code compilation, class reloading, and the use of the Proxy design pattern to make modifications to a dynamic class transparent to its caller.

In fact researcher in Austria have written a JVM that even allows reloading classes with different type hierarchies. They have achieved this by using existing thread save points to generate a complete 'side universe' of an object and all it's related references and referenced content and then once fully reshuffled with all required changes simply swap in all changed classes. [1] Here a link to their project http://ssw.jku.at/dcevm/ the oracle sponsorship certainly makes for interesting speculations on future plans.

Less intrusive changes to method bodies and fields are already possible in the standard java VM using the Hot Swap capabilities of the JPDA as introduced in Java 1.4:
docs.oracle.com/javase/1.4.2/docs/guide/jpda/enhancements.html#hotswap

I'm not sure whether it was the first one but this Sun employee's paper from 2001 appears to be one of the early proposals mentioning the capabilities of the HotSpot to Hot Swap. [2]

REFERENCE

[1] T. Würthinger, C. Wimmer, and L. Stadler, “Dynamic Code Evolution for Java,” presented at the 8th International Conference on the Principles and Practice of Programming in Java, Vienna, 2010.

[2] M. Dmitriev, “Towards flexible and safe technology for runtime evolution of java language applications,” in OOPSLA Workshop on Engineering Complex Object-Oriented Systems for Evolution, 2001.

http://www.javaworld.com: Page not found – Sam Ginrich Apr 01 '22 at 13:02 — Sam Ginrich, Apr 01 '22 at 13:02

score 10 · Answer 3 · edited Mar 19 '20 at 21:35

10

I've never tried anything quite like that myself, but you should have a look at ASM, cglib, and Javassist.

edited Mar 19 '20 at 21:35

dan1st

12,568
8
34
67

answered Jul 13 '11 at 14:41

Ryan Stewart

126,015
21
180
199

2

And a custom class loader as mentioned in other answers. – Bodey Baker May 19 '14 at 00:10
@Bodey Baker Pretty sure, they use a custom class loader as this one https://github.com/Sanjay007/CustomLoader/blob/master/src/test/main/MyClassLoader.java – Sam Ginrich Apr 01 '22 at 13:08

score 5 · Answer 4 · answered Jul 13 '11 at 14:42

5

No, that is not (easily) possible in Java.

It sounds like you are trying to use Java as if it is a dynamic programming language. For example, Ruby has open classes: you can add and remove methods from Ruby classes at runtime. In Ruby, you can also have a "method missing" method in your class, that will be called when you try to call a method that doesn't exist in the class. Such a thing also doesn't exist in Java.

There is a version of Ruby that runs on the JVM, JRuby, and it has to do very difficult tricks to make open classes work on the JVM.

answered Jul 13 '11 at 14:42

Jesper

202,709
46
318
350

It is easily possible with bytecode manipulation libraries like ASM – Angsuman Chakraborty Jun 13 '16 at 11:40
1

@AngsumanChakraborty I wouldn't call that "easy". You'd have to understand what bytecode is and how it works. The point is that Java does not have something like Ruby's open classes as a standard feature. – Jesper Jun 13 '16 at 11:45
It is as easily possible using Groovy which is well integrated with Java – Angsuman Chakraborty Jul 04 '16 at 09:17

score 3 · Answer 5 · answered May 15 '16 at 22:45

It looks like there is no way to add method dynamically. But you can prepare an class with a list of Methods or an hash like:

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashMap;

public class GenericClass {
    private HashMap<String, Method> methodMap = new HashMap<String, Method>();

    public Object call(String methodName,Object ...args) 
               throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        Method method = methodMap.get(methodName);
        return method.invoke(null, args);
    }

    public void add(String name,Method method){
        if(Modifier.isStatic(method.getModifiers()))
            methodMap.put(name, method);
    }

    public static void main(String[] args) {
        try   {
            GenericClass task = new GenericClass();
            task.add("Name",Object.class.getMethod("Name", new Class<?>[0]));
        } catch (NoSuchMethodException | SecurityException e) {
            e.printStackTrace();
        }
   }
}

Than, using reflections you can set or unset the attribute.

score 3 · Answer 6 · answered Jul 13 '11 at 14:42

3

You can have a doAction method which does whatever you would like the generated method to do. Is there a reason it needs to be generated or can it be dynamic?

answered Jul 13 '11 at 14:42

Peter Lawrey

525,659
79
751
1,130

score 2 · Answer 7 · answered Dec 27 '13 at 15:19

2

Proxy may help. But have to instantiate a Proxy every time you want to add or remove a method.

answered Dec 27 '13 at 15:19

Boki

31
1

score 2 · Answer 8 · answered Apr 30 '18 at 15:13

What I suggest should work for your situation: 1. You have an existing class MyClass with n methods 2. You want to include (n+1) th method which is not in the class while compiling in another .java source file

My way to solve it is Inheritance. Create a new .java source file for a Class MyClassPlusOne extending the first class MyClass. Compile this class and use the object. How can I compile and deploy a java class at runtime?

class MyClassPlusOne extends MyClass
{
     void doAction(String a, Integer b)
     {
         int myNPlus1 = a+b;
         //add whatever you want before compiling this code
      }
}

score 2 · Answer 9 · answered Jul 13 '11 at 14:45

2

I believe you need some byte code altering tool/framework, such as asm, cglib or javassist. You can achieve this via aspects/weaving like it's done Spring, but I believe you still need to have the method defined first.

answered Jul 13 '11 at 14:45

carlspring

31,231
29
115
197

score 1 · Answer 10 · answered Jul 13 '11 at 14:43

I'm not sure that is possible. However, you could use AspectJ, ASM, etc. and weave these methods into the appropriate classes.

The other alternative is to use composition to wrap the target class and provide the doAction method. You would end up delegating to the target class in this case.

Nodens2k · Answer 11 · 2020-07-28T10:28:39.467

This is a rather old question, but I still found myself looking at it today so, just in case, I'll add my two cents.

If you are using Java 8+, you can define "default" implementations of an interface method, so you can just define the interface with all the extra methods with empty default implementations, and add the implements clause in the desired classes. This approach, in some cases, may be the easiest one.

If you don't have control over the definition of the classes, or you need compatibility with older Java versions, you can still define an interface containing all the required extra methods; but in this case, implement a "Decorator" class with a method that receives the object to "decorate" as parameter, and returns a DynamicProxy instance, wrapping the passed object with this interface.

If you are using Spring, the decorator can be added to the context as a @Component, so you can inject it wherever you need to use it. If any of the objects you need to inject are Spring Beans, you could implement a FactoryBean that uses the decorator to return the instances, so you can just forget about calling the decorator explicitly for them.

Can a Java class add a method to itself at runtime?

11 Answers11

Linked

Related