Come posso verificare se una classe groovy ha una proprietà statica?

Question

Data la seguente classe Groovy:

​class A { 
    static x = { } 
} 

Come posso verificare se la classe A è definita una proprietà statica denominata 'x'? Nessuna delle due opzioni qui sotto sembra funzionare:

A.hasProperty('x') 
A.metaClass.hasProperty('x') 

Answer 1

non ho potuto vedere alcun modo ovvio per verificare la presenza di una proprietà statica direttamente, ma il controllo di un metodo statico chiamato getProperty è equivalente (credo)

def getStaticProperty(String name, Class clazz) { 
    def noArgs = [].toArray() 
    def methodName = 'get' + name[0].toUpperCase() 

    if (name.size() > 1) { 
    methodName += name[1..-1] 
    } 

    clazz.metaClass.getStaticMetaMethod(methodName, noArgs) 
} 

// class that will be used in tests 
class Foo { 

    static String x = 'bar' 
    static Integer num = 3 
} 

// tests 
assert getStaticProperty('x', Foo) 
assert getStaticProperty('num', Foo) 
assert getStaticProperty('noSuchProperty', Foo) == null 

Answer 2

non ho potuto vedere un modo groovier di fare questo diverso utilizzando la riflessione API di Java:

import static java.lang.reflect.Modifier.isStatic 

class A { 
    static x = 1 
} 

def result = A.class.declaredFields.find { 
    it.name == 'x' && isStatic(it.modifiers) 
} 

println result == null ? 'class does not contain static X' : 
         'class contains static X' 

Answer 3

look at GrailsClassUtils.getStaticFieldValue - restituisce uno STATI c valore del campo per nome, null se nessuna proprietà esiste o non è impostata. Si può guardare in esecuzione, se questo è utile

Answer 4

A.metaClass.hasProperty(A,'x') 

o

A.metaClass.respondsTo(A,'getX') 

Answer 5

A partire dal 2017 e 2.4.x Groovy, il modo migliore per controllare sembra essere questo:

A.metaClass.getMetaProperty('x') != null 

E ' funziona sia per le proprietà statiche e non statiche che per le proprietà definite solo con getter e setter (ma senza campo effettivo) o da un campo senza getter o setter (ad esempio in una classe java). È possibile controllare MetaProperty restituito per ulteriori dettagli, se necessario. Fai attenzione che una proprietà potrebbe essere definita da un setter solo per non essere quindi leggibile. Quindi, se è importante, modifica i tuoi assegni di conseguenza.

Si noti tuttavia che questo metodo non consente di verificare se la proprietà è statica.

sudhir è probabilmente la seconda soluzione migliore, poiché l'implementazione si basa su getDeclaredFields e, di conseguenza, non trova proprietà definite solo da getter e setter. Inoltre è utile solo se stai usando i graal. Inoltre recupera il valore reale se presente che può o non può essere desiderato.

Le risposte di SteveD non funzionano. Tuttavia può essere risolto rimuovendo la 'classe' prima di campi dichiarati e aggiungendo controlli per getter e setter. Così, pieno di controllo per l'esistenza di proprietà è la seguente:

def hasProperty = { Class c, String propertyName -> 
    if (!propertyName) 
     return false; 
    String p2 = propertyName.substring(0, 1).toUpperCase() 
    if (propertyName.length()> 1) 
     p2 += propertyName.substring(1) 
    return c.declaredFields.find { 
     it.name == propertyName /* && isStatic(it.modifiers) */ 
    } || c.declaredMethods.find { 
     it.name == ('get' + p2) /* && isStatic(it.modifiers) */ 
    } || c.declaredMethods.find { 
     it.name == ('is' + p2) /* && isStatic(it.modifiers) */ 
    } || c.declaredMethods.find { 
     it.name == ('set' + p2)/* && isStatic(it.modifiers) */ 
    } 
} 

Si noti che questo metodo controlla anche che la proprietà è in realtà statico (solo importazione statica java.lang.reflect.Modifier.isStatic e controlli isStatic decommentare). Come sopra, fate attenzione alle proprietà di solo setter.