Cannot call static method through interface? about ognl HOT 8 CLOSED

Default methods aren't static, you must access them through an instance. I added an example how to do it.

from ognl.

@lukaszlenart Thank you for your reply. The example above does not invoke the default method; it calls a static method of an interface. It can be called directly without creating an object.

System.err.println(III.staticMethod()); // ok

from ognl.

Ah... right :D Yet I added another example and it works, see this test and the interface

from ognl.

@lukaszlenart Thanks.

It seems that using Ognl.compileExpression works correctly, using Ognl.parseExpression error.

        OgnlContext context = Ognl.createDefaultContext(null, new DefaultMemberAccess(false));
        Root root = new Root();
        context.setRoot(new Object());

        Object parseExpression = Ognl.parseExpression("@ognl.test.objects.StaticInterface@staticMethod()");

        Node compileExpression = Ognl.compileExpression(context, root,
                "@ognl.test.objects.StaticInterface@staticMethod()");

        // ok
        System.out.println(Ognl.getValue(compileExpression, context, root)); // or
        // error
        System.out.println(Ognl.getValue(parseExpression, context)); //error

output:

static
Exception in thread "main" ognl.OgnlException: No method accessor for interface ognl.test.objects.StaticInterface

from ognl.

I'm not sure if I understand the problem - parseExpression is rather used to validate the expression, it isn't used to compile the expression into an executable form

from ognl.

Sorry, maybe I didn't explain the situation clearly. I'll try my best to clarify.

Initially, I thought the following invocation would succeed:

        OgnlContext context = Ognl.createDefaultContext(null, new DefaultMemberAccess(false));
        Root root = new Root();
        context.setRoot(new Object());
        
        // javadoc: Convenience method that combines calls to parseExpression and getValue.
        Ognl.getValue("@ognl.test.objects.StaticInterface@staticMethod()", root); // error

However, it fails.

Based on the specific code execution process, I found that it is:

1. Calling Ognl.parseExpression("@ognl.test.objects.StaticInterface@staticMethod()");,
2. Then calling Ognl.getValue(parseExpression, context).

In the example you provided: https://github.com/orphan-oss/ognl/blob/master/src/test/java/ognl/test/StaticsAndConstructorsTest.java#L51

It can execute successfully because in the testcase, it explicitly calls Ognl.compileExpression

• https://github.com/orphan-oss/ognl/blob/master/src/test/java/ognl/test/OgnlTestCase.java#L114C10-L114C10

Ognl.compileExpression(context, root,
                "@ognl.test.objects.StaticInterface@staticMethod()");

Then it executes Ognl.getValue(compileExpression, context, root), so it can succeed.

So, my question is:

• ognl.Ognl.getValue(String, Object), should it be able to execute Ognl.getValue("@ognl.test.objects.StaticInterface@staticMethod()", root) successfully?
• Because other expressions can be executed successfully, for example: Ognl.getValue("@ognl.test.objects.StaticInterface@class", root).

from ognl.

class is threaten in some special way and from Ognl perspective class is a static field which is represented by ASTSTaticField class, while staticMethod() is a static method represented by ASTStaticMethod class - you cannot compare behaviour of those two.

Please also take a look on the compileExpression implementation:

    public static Node compileExpression(OgnlContext context, Object root, String expression) throws Exception {
        Node expr = (Node) Ognl.parseExpression(expression);

        OgnlRuntime.compileExpression(context, expr, root);

        return expr;
    }

You can notice the expression is parsed in the first step and then compiled. Just parsing the expression isn't enough, it works for class because there are special cases to cover such behaviour -> OgnlRuntime#getStaticField()

I would say the Ognl behaves properly, parsed expression isn't compiled - it's like Java source code, it should be parsable to be compiled into binary code.

from ognl.

@lukaszlenart Thank you very much.

from ognl.