2015-09-02 30 views
5

Ecco il problema specifico che sto incontrando. Sto usando SLF4J Logger (Il tipo di variabile logger sotto)Come risolvere il riferimento al metodo ambiguo in scala

//After adding to a map 
logger debug ("Adding {} = {}", key, value) 

Ecco cosa passaggio del mouse in Eclipse (e il compilatore) mi dicono.

ambiguo riferimento alla definizione overload, sia metodo debug tratto Logger di tipo (x $ 1: stringa, x $ 2: Object *) Unità e metodo debug tratto Logger di tipo (x $ 1: stringa, x $ 2: qualsiasi, x $ 3: qualsiasi) Unità tipi di corrispondenza di argomenti (String, String, String)

capisco perché sono ambigue. Non sto certo discutendo con il compilatore :). Voglio semplicemente sapere come i programmatori esperti risolvono questo problema.

Qui ci sono le alternative che posso usare

  1. Creare e la matrice, e cavalcare le Object* definizione

    logger debug ("Adding {} = {}", Array(key, value):_*)

  2. Fusioni di Any

    logger debug ("Adding {} = {}", key.asInstanceOf[Any], value.asInstanceOf[Any])

Nessun approccio è particolarmente allettante. La comunità ha un approccio o dei suggerimenti migliori per me?

Grazie mille!

+1

Sembra che potrebbe essere un problema noto - vedere [qui] (https://github.com/typesafehub/scalalogging/issues/16) – Shadowlands

+0

Penso che sia così. Grazie per il tuo aiuto @Shadowlands! Se potessi pubblicare una risposta come risposta, potrei contrassegnare la domanda risolta e possiamo aiutare la comunità. – Prashant

+2

Con l'interpolazione delle stringhe, io uso sempre i dati di 'logger debug (s" Aggiunta di $ key = $ valore). "Poiché l'interpolazione delle stringhe è tempo di compilazione, probabilmente è anche più efficiente –

risposta

5

Prima di tutto un cenno del capo a @Shadowlands, @ArneClaassen e @OlgeRudenko. Come menzionato nei commenti, questo sembra essere un problema noto. Questo mi ha impedito di cercare di "risolverlo". La prossima cosa da fare era trovare un buon lavoro che non infrangesse gli idiomi di Scala.

Con questi vincoli in mente, ho scelto di andare con Interpolazione stringa come suggerito sopra. Sono passato anche a scala-logging. Citando dal loro GitHub/README,

Scala La registrazione è una libreria di registrazione comoda e performante che avvolge SLF4J. È comodo, perché puoi semplicemente chiamare i metodi di registro senza controllare se il rispettivo livello di registro è abilitato:

logger.debug (s "Qualche messaggio costoso $!")

E 'performante, perché grazie alla Scala macro del check-enabled-linguaggio viene applicata, proprio come la scrittura di questo codice più coinvolti:

se (logger.isDebugEnabled) logger.debug (s" Alcuni $ costoso messaggio! ")

Grazie tutti! per quanto mi riguarda, questo è stato risolto. Se i commentatori possono inviare le loro risposte, sarò felice di riconoscere loro.

come sempre, si sente bene a essere in piedi sulle spalle di giganti amichevoli!

PS: Ho appena verificato che non vi è alcun costo di esecuzione per l'interpolazione di stringa se si utilizza scala-logging. Il mio metodo di verifica era grezzo ma efficace.

log.debug{ 
     { 
      throw new IllegalAccessException("This should not have been called with debug off!") 
     } 
     s"Added Header ${name}:${headerValue}" 
     } 

Abbastanza sicuro, quando ho impostato il mio registro per DEBUG, l'eccezione viene generata, come previsto, ma svanisce quando ho impostato a un livello superiore. E sì, ho già rimosso la parte IllegalAccessException :).

+0

Grazie! Ho dimenticato di dirlo. Sono passato alla scala-logging. Non vi è alcun costo di esecuzione per le istruzioni di debug a meno che il debug sia vero. – Prashant

6

userei

logger.debug("Adding {} = {}", key, value: Any) 

alternativa seguente può essere utilizzato:

logger.debug("Adding {} = {}", Array(key, value):_*) 

Si prega di prestare attenzione a :_*. Dovresti omettere questi simboli e chiamerà il metodo Object* fornendo solo 1 argomento, che sarà un array.

+0

Sì, @OlegRudenko hai ragione nel segnalare l'errore. Non l'ho scritto correttamente. Sto indovinando quando ho scritto Oggetto *, devo avere mentalmente spuntato _ * Comunque un errore è un errore Grazie per averlo corretto correggerò la mia domanda originale – Prashant

+0

Sembra che il primo approccio sia preferibile rispetto al secondo h crea un array anche se il livello di log è disabilitato. Forse avvolgere quella versione in un controllo che il debug sia abilitato? – simbo1905

+0

Usa scala-logging. :) Le risposte solo per mostrare come risolvere riferimenti al metodo ambigui. Per quanto riguarda le prestazioni: la mia esperienza dimostra che è necessario concentrarsi sulla leggibilità del codice e ottimizzare le prestazioni SOLO se si vede realmente la necessità. –

Problemi correlati