Spring: Una buona guida?

[jabjoint]

Salve, non mi entra in testa l'utilità dei bean in Spring.
Conosco abbastanza bene la sintassi Java.
Diciamo che arrivo alle Mappe e le so gestire.
Tuttavia vorrei ampliare le mie abilità per l'utilizzo con il tool STS. Avete da proporre una guida che definisca in modo elementare per il momento l'utilità dei Beans?
Io son fermo ai seguenti concetti più o meno corretti:

I Beans sono oggetti che Spring gestisce in modo autonomo con una programmazione orientata agli aspetti per gestire le risorse dell' applicazione in modo più efficiente.
So che esiste un Context dove risiedono i Beans.
Mi interessa capire come funziona il meccanismo autonomo di Spring di gestione Beans al fine di
comprenderne l'utilizzo.

So che esistono classi POJO ovvero scheletri con pochi dati.
Se non erro queste servono per evitare di trasportare oggetti pesanti e quindi atte a non appesantire gli oggetti.

Inoltre come fa Spring dietro e quinte ad interpretare le @Annotations?

Una volta che avrò chiaro questi concetti potrò proseguire.
Grazie

[jabjoint]

Ovviamente conosco anche la programmazione orientata agli oggetti.
So gestire liste. Ecc.

[andbin]

So che esistono classi POJO ovvero scheletri con pochi dati.

https://en.wikipedia.org/wiki/Plain_old_Java_object

Se non erro queste servono per evitare di trasportare oggetti pesanti e quindi atte a non appesantire gli oggetti.

No, la questione non è quanti dati ha un oggetto.

Inoltre come fa Spring dietro e quinte ad interpretare le @Annotations?

Generalmente le scopre e utilizza tramite reflection.

Guarda, se non hai mai fatto questa prova, fai così: definisci una nuova annotation Autore che abbia il value() String in modo da poterla usare così:

@Autore("jabjoint")
public class UnaClasse {
}

Attenzione, la annotation deve avere la retention policy a RUNTIME, altrimenti non viene esposta a runtime! E il Target deve essere almeno TYPE (dato che la usi su un tipo).

Poi fai un classico main altrove. Parti da UnaClasse.class, questo è il class-literal dell'oggetto Class<UnaClasse>. Su questo fai un getAnnotation(Autore.class). Ti dà o null o l'oggetto della annotation (se hai fatto giusto, ovviamente l'oggetto).
L'annotation è come se fosse una interface "speciale" ma a runtime ottieni un oggetto che la implementa. E poi stampi il value()

Se hai dubbi, chiedi. Ma se capisci questo, capisci il 90% delle annotation.

Ovviamente conosco anche la programmazione orientata agli oggetti.
So gestire liste. Ecc.

Sì ma devi conoscere molto bene anche il resto. Tutte le feature di Java 5 (compresi e soprattutto i generics). Più multi-threading/concorrenza e possibilmente anche le feature di Java 8 (lambda expression, method reference, Stream API, Date-Time API).

Se io ti chiedessi cosa è un bounded wildcard o la differenza tra ArrayList<?> e ArrayList<Object>, dovresti saper rispondere.
E anche perché un ArrayList<String> NON è assegnabile ad un ArrayList<Object> (questa è proprio la base fondamentale dei generics).

[jabjoint]

Ciao grazie del suggerimento per la creazione dell' Annotation personalizzata.
Tento di fare quel che mi hai suggerito. Sembra interessante.

Si fermo restando che nessuo � omniscente nemmeno su un argomento, mi dar� da fare per saperne il pi� possibile, in genere mi cimento ad apprendere il necessario. Anche perch� non si finirebbe mai.

In genere il <?> � un carattere universalmente adattabile in informatica. Mentro <Object> � proprio un oggetto generico di Java.
Se non ricordo male tutti gli oggetti estendono Object di Default in Java.

Quindi suppongo che il carattere ? sia di uso pi� generale e non solo per gli oggetti, forse anche per le interfacce?

Non sono andato a leggere altrove per rispondere; ma lo far�.

L' ArrayList serve a generare una lista di elementi(da indicare al posto di ? in <?>) indefiniti.

Penso che come valga per ArrayList<String> valga per tutti gli elementi <?> in ArrayList<?>
Una lista di elementi non si potr� trattare come un elemento per fare il casting?

Personalmente il casting l' ho visto fare da un tipo di oggetto ad un altro ma mai da una lista ad un' altra.
Quindi l'operatore casting non sar� definito per questa operazione...?
Un metodo potrebbe essere banalmente quello di eseguire un ciclo e fare il casting per ogni elemento?

[jabjoint]

Il seguente breve codice per la conversione da ArrayList<String> ad ArrayList<Object>:

package simple;


import java.util.ArrayList;



public class Main {


public static void main(String[] args) {

        ArrayList<String> arrString = new ArrayList<String>();
        ArrayList<Object> arrObj = new ArrayList<Object>();

      arrString.add("a");
      arrString.add("b");
      arrString.add("c");

      arrObj.addAll(arrString);

      arrObj.forEach((e) -> outmsg(e.toString()));

    }

static void outmsg(Object o){
       
   System.out.println(o);
    
}


}

Genera l' Output:

a
b
c

[andbin]

In genere il <?> è un carattere universalmente adattabile in informatica. Mentro <Object> è proprio un oggetto generico di Java.

Quindi suppongo che il carattere ? sia di uso più generale e non solo per gli oggetti, forse anche per le interfacce?

Penso che come valga per ArrayList<String> valga per tutti gli elementi <?> in ArrayList<?>

No, purtroppo sei (molto) fuori strada. Il wildcard (<?> e le versioni "bounded" con super/extends) è stato introdotto nei generics per un motivo ben preciso.

Il seguente breve codice per la conversione da ArrayList<String> ad ArrayList<Object>

E ... no. Non stavo parlando di fare un "banale" arrObj.addAll(arrString);

Io stavo parlando di assegnabilità!

Tutto nasce dal fatto che in Java questa seguente assegnazione è ok e lecita:

Object[] arr = new String[10];

mentre invece questa assegnazione NON è lecita:

ArrayList<Object> lst = new ArrayList<String>();      // NO, ERRORE

Detto in altro modo:
String[] è un sottotipo di Object[]
ma
ArrayList<String> NON è un sottotipo di ArrayList<Object>

C'è un motivo ben preciso perché il primo è lecito mentre il secondo no. E' proprio la "teoria" di base dei generics.


Se mai ti dovesse interessare, c'è un bellissimo libro (io ce l'ho da molti anni, l'ho studiato tutto ): "Java Generics and Collections" della O'Reilly. Ma se fossi interessato, aspetta, non prendere l'edizione originale (del 2006) perché tra poco più di 1 mese (a Maggio) esce la 2° edizione, questa: https://www.oreilly.com/library/view...9781098136710/

[andbin]

jabjoint, forse sono andato un po' "fuori tema", nel senso che all'inizio chiedevi una buona guida per Spring.

Capisco, ma il punto è che se hai lacune su generics e magari su altro (es. multi-threading), a Spring ci arrivi un po' maluccio e rischi solo di fare sfracelli se non gestisci correttamente le cose (specialmente con i thread).

In sostanza, prima di arrivare a Spring (o qualunque altro framework similare), dovresti assicurarti di sapere bene:

- multi-threading, sincronizzazione/concorrenza (synchronized, lock e condition queue intrinseca degli oggetti, memory-model, lock espliciti, collezioni concorrenti, ecc...)
- tutte le feature di Java 5: generics, annotations, autoboxing/unboxing, enums, varargs, enhanced for ("for-each"), static import
- il "diamond" per i generics e il try-with-resource, entrambi di Java 7 (cosine piccole ma utili)
- le principali feature più importanti di Java 8: functional interfaces, lambda expressions, method references, Stream API, Date/Time API

Piuttosto, se hai dubbi/domande su questi argomenti, apri altre discussioni a riguardo e se nessun altro risponde prima, se passo io posso rispondere di certo.

[jabjoint]

jabjoint, forse sono andato un po' "fuori tema", nel senso che all'inizio chiedevi una buona guida per Spring.

Capisco, ma il punto è che se hai lacune su generics e magari su altro (es. multi-threading), a Spring ci arrivi un po' maluccio e rischi solo di fare sfracelli se non gestisci correttamente le cose (specialmente con i thread).

In sostanza, prima di arrivare a Spring (o qualunque altro framework similare), dovresti assicurarti di sapere bene:

- multi-threading, sincronizzazione/concorrenza (synchronized, lock e condition queue intrinseca degli oggetti, memory-model, lock espliciti, collezioni concorrenti, ecc...)
- tutte le feature di Java 5: generics, annotations, autoboxing/unboxing, enums, varargs, enhanced for ("for-each"), static import
- il "diamond" per i generics e il try-with-resource, entrambi di Java 7 (cosine piccole ma utili)
- le principali feature più importanti di Java 8: functional interfaces, lambda expressions, method references, Stream API, Date/Time API

Piuttosto, se hai dubbi/domande su questi argomenti, apri altre discussioni a riguardo e se nessun altro risponde prima, se passo io posso rispondere di certo.

Ciao certamente, chiederò sicuramente, le lacune ancora le ho e spero in qualche mese di poter usare Spring.
Java sebbene sia intuitivo e piuttosto semplice richiede una buona dose di studio.