How to turn a String value into a object reference in Java?

Question

I am currently working on a very simple client-server-connection. The client and the server are connected through sockets and communicate by using streams.

Now I want the client to be able to invoke methods on the server. Therefore the client should send a message to the server. This message is then split into two Strings. The first string methodName contains the name of the method to be called. The second String objectName contains the name of an object on which the method should be called.

One way to this would be by using if-statements like if(methodName.equals("mymethod")){mymethod()};. This method works just fine and can be extended to check for objectName as well. Still I am very unhappy with this solution. I want to be able to invoke a lot of different methods on a lot of different objects (even on objects that don't even exist yet). I just don't want to write thousand of if-statements or cases.

That's why I try to find a different approach. I already found a partial solution for methodName by using this:

java.lang.reflect.Method method = myObject.getClass().getMethod(methodName);
method.invoke(myObject);

This would effectively turn the String value of methodName into a reference to the corresponding method. That's just what I was looking for.

But it comes with the problem that both instructions require an object reference. By now the "name" of that reference is still stored in objectName and most important, it is a String value and not a reference. What I am now looking for is a instruction like this:

Object myObject = turnTheStringValueIntoAReference(objectName);

For now we can just assume that there already exists an object reference with the name that is stored in objectName. Otherwise there might also be a way to do something like this:

Object turnTheStringValueIntoAReference(objectName) = new Object();

I tried my best to find a way to turn a String value into a object reference but sadly I couldn't find any solution. I now have reached to point where I was thinking that this "feature" purposely doesn't exist in Java because it would basically eliminate type safety. Not to mention all the exceptions that might occur.

However I still would be very happy and very thankful if anyone could tell me if there actually is a way to do this. Maybe I just didn't figure it out yet.

With further research I found out that RMI might be an alternative to this. I guess RMI would even be a much better way to this. The reason I still don't want to RMI is that I plan on expanding the server in a way that it doesn't only accept my own client but also clients that are written in different languages. I think managing this will be ways easier if the client only needs to send a message than somehow support Java RMI without being written in Java.

Well, I think that's it. I would really appreciate your help.

Answer 1

I now have reached to point where I was thinking that this "feature" purposely doesn't exist in Java because it would basically eliminate type safety.

You are correct. There is no way to access variable names -- at least not local variable names -- in Java. You can access fields, at least, with getField(fieldName), but this is still a terrible idea.

You should really look into existing solutions that solve these problems in principled, cross-language ways. Any RPC or REST system would be a good start. This is not an area where you have to invent your own solution.

Answer 2

Here's an example of what is possible for you:

Person:

package reflection;

public class Person {

    private final String firstName;
    private final String lastName;

    public Person() {
        this("Tom", "Jones");
    }

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }
}

Address:

package reflection;

public class Address {

    private final String street;
    private final String city;
    private final String state;
    private final String zip;

    public Address() {
        this("100 Fifth Avenue", "New York", "NY", "10003");
    }

    public Address(String street, String city, String state, String zip) {
        this.street = street;
        this.city = city;
        this.state = state;
        this.zip = zip;
    }

    public String getStreet() {
        return street;
    }

    public String getCity() {
        return city;
    }

    public String getState() {
        return state;
    }

    public String getZip() {
        return zip;
    }
}

ReflectionSample:

package reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @link https://stackoverflow.com/questions/76567190/how-to-turn-a-string-value-into-a-object-reference-in-java?noredirect=1#comment134999266_76567190
 * @link https://stackoverflow.com/questions/1782598/with-java-reflection-how-to-instantiate-a-new-object-then-call-a-method-on-it
 */
public class ReflectionSample {

    public static void main(String[] args) {
        if (args.length > 1) {
            String className = args[0];
            String methodName = args[1];
            try {
                Constructor<?> defaultConstructor = Class.forName(className).getConstructor();
                Object instance = defaultConstructor.newInstance();
                Method method = instance.getClass().getMethod(methodName);
                System.out.println(method.invoke(instance));
            } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException |
                     InvocationTargetException e) {
                System.err.println(className + " class with method name " + methodName + " not found");
            }
        } else {
            System.out.println("Usage: reflection.ReflectionSample <class> <method>");
        }
    }
}

This sample will instantiate instances of Person and Address and call the method I wish on that instance. I pass the class and method names in as command line arguments (e.g. "reflection.Person getFirstName" and "reflection.Address getState")

But you see the problems that are built into this approach. I would not recommend that you go this way. You overestimate the requirement of flexibility for your clients.