Dobbiamo produrre delle stampe in pdf da java?
Le soluzioni sono tante. Noi oggi ne tratteremo una in particolare: jasperReport!
Non è semplicissimo, ma cercheremo di seguire tutti i passi necessari per renderlo facile…
Ecco cosa faremo:
1. produzione file jrxml e compilazione del file jrxml in jasper
2. uso del file jasper in java per produrre un file PDF
Prosegui nella lettura di “JasperReport, iReport e java” »
lug 02
giu 21
Se si lavora in team su un progetto software è quasi essenziale usare un repository. Ci si trova quindi molto spesso a dover installare SVN su eclipse.
In questo breve articolo, indicheremo le operazioni da eseguire per effettuare tale installazione.
Prosegui nella lettura di “Installare SVN su eclipse” »
giu 10
Questa è una buona notizia per i programmatori java 
Da qualche tempo è nato un ambizioso progetto: jQuery4j. Il nome dice già molto da solo: jQuery4j, ossia jQuery per java.
Come si può intuire quindi, il progetto ha come scopo quello di consentire agli sviluppatori java di creare le proprie funzioni jQuery lato server, con creazione dinamica degli script lato client per l’interazione con i widgets jQuery! Non male!
Prosegui nella lettura di “jQuery4j: gestire jQuery da java” »
giu 09
Era davvero un po’ di tempo che se ne parlava ed ora sembra proprio che ci siamo! Apache Tomcat 7 è finalmente sulla buona strada: l’ultima versione del popolare contenitore di servlet è arrivato alla fase finale dello sviluppo
Ad oggi, sono state rese disponibili quattro client-release agli sviluppatori per eseguire i vari test, con la RC4 rilasciata appena la mattina dell’8 giugno.
Tomcat 7 sarà perfettamente allineato alle specifiche Servlet 3.0, offrendo una serie di vantaggi interessanti per gli utenti Tomcat, tra cui:
- Supporto alle annotation
- Configurazione dinamica delle librerie tramite codice inserito nel web.xml
- Embedding semplificato
- Miglioramento del secure session tracking
Controlla le note di rilascio di Apache Tomcat 7, oppure vai semplicemente alla pagina di download della RC4.
apr 30
Usando eclipse in progetti distrubuiti in cui i componenti del team di sviluppo sono fisicamente distanti, capita molto spesso di avere a che fare con uno dei suoi tanti plugin: SVN.
Usando questo plugin può però capitare che, di punto in bianco e senza alcun apparente motivo, esso non consenta più di effettuare i propri commit, rispondendo nel modo riportato nel titolo del presente articolo, ossia:
Could not execute PROPPATCH
Se ci si trova in questa situazione, si può provare a risolvere la questione modificando la SVN interface.
Per fare questo apriamo eclipse e scegliamo “Window/Preferences…/Team/SVN”. Cerchiamo SVN Interface e scegliamo SVNKit (Pure Java). Poi Apply e OK.
Riproviamo ora a eseguire i nostri commit.
Facciamo attenzione al fatto che con tale modifica in fase di commit ci verrà quasi certamente richiesta un’utenza abilitata all’accesso al repository; dobbiamo quindi averne una a portata di mano.
apr 22
Su questo argomento si trova davvero poco online… davvero poco (almeno in italiano). Effettivamente si può considerare un argomento “di nicchia”, ma come si fa a non conoscere certi argomenti e poi esigere di esser chiamati “programmatori java”?
Comunque sia, chiariamo subito una cosa che sembra essere poco chiara:
In java, il ciclo di vita di un oggetto parte dal momento della sua creazione (cioè quando si usa la parola chiave new) e finisce quando l’oggetto è eliminato dal garbage collector.
In java l’allocamento degli oggetti nella RAM avviene in uno spazio di memoria riservato che prende il nome di heap. Per quanto questo spazio possa essere grande, esso è comunque finito e può quindi saturarsi. Per questo motivo la JVM, di tanto in tanto, ripulisce la heap dagli oggetti non più necessari. A tale scopo essa usa il garbage collector (gc). Esso è autonomamente in grado di decidere quali oggetti eliminare e quali no. Ma come fa questo strumento a prendere tali decisioni? Per rispondere a questa domanda dobbiamo necessariamente addentrarci nelle attività svolte dalla JVM.
Java è un sistema thread-based multitasking. Paroloni da paura che per adesso lasciamo così come sono. Quello che ci interessa sapere è che ogni thread ha il proprio runtime stack il quale viene usato per gestire l’esecuzione dei metodi. Ogni elemento di questo stack viene chiamato activation record e corrisponde ad una chiamata di un metodo. E’ proprio analizzando il runtime stack dei vari thread attivi che il garbage collector riesce a comprendere quale oggetto lasciare vivo e quale eliminare! Se il gc trova nella heap un oggetto che non ha alcun riferimento nei vari runtime stack e non viene richiamato da altri oggetti, allora il gc procede alla eliminazione dalla RAM di quell’oggetto, liberando memoria.
apr 17
Un’anonymous class (classe anonima) è una inner class che viene contemporaneamente definita e istanziata e non ha un nome.
Un’anonymous class (classe anonima) esiste se e soltanto se esiste una super classe da estendere o un’interfaccia da implementare!
Quando estende una classe, la sintassi dichiarativa assume la seguente forma:
new <nome superclasse> (<lista opzionale di argomenti>) {…}
Quando invece implementa un’interfaccia, assume la seguente forma:
new <nome interfaccia> () {…}
Bisogna osservare che sebbene una classe anonima estenda una classe o implementi un’interfaccia, essa non usa né la clausola extends né la clausola implements.
Inoltre, come per le local classes, anche le anomymous classes non possono usare la parola chiave static in fase di dichiarazione.
[to be continued...]
apr 12
Per local class (classe locale) si intende una inner class che è definita in un blocco di codice. Un blocco di codice potrebbe essere il corpo di un metodo, di un costruttore, un blocco locale, un inizializzatore statico o un inizializzatore di istanza.
Alcune caratteristiche di una local class:
- una local class non può avere memebri statici (questo però non esclude la possibilità di avere un membro final static, essendo esso una costante)
- una local class non può avere modificatori di accessibilità (public, private, ecc.). Sarà quindi dichiarata scrivendo semplicemente class nomeClasse {…}
- una local class può estendere un’altra classe
- all’interno del blocco in cui è definita, una local class può accedere solo ai membri dichiarati final
- una non-static local class può accedere sia ai membri statici sia ai membri non statici della classe contenitore (da non confondere con il blocco contenitore)
- una static local class può accedere solo ai membri statici della classe che la contiene
- una local class (essendo locale) può essere istanziata solo nel blocco nel quale è definita e deve essere dichiarata prima di essere utilizzata
Prima accortezza: se il blocco contenente la dichiarazione della local class è definito in un contesto statico (ad esempio un metodo statico o un inizializzatore statico) allora la local class è implicitamente statica e quindi non richiede alcun oggetto contenitore per essere istanziata.
Facciamo però attenzione al fatto che, sebbene in certi contesti (appena visti) la local class è intesa implicitamente statica, essa non consente di utilizzare nella propria dichiarazione la parola chiave static. Mai.
Facciamo anche attenzione al fatto che se una local class si trova dichiarata in un contesto statico, ciò influenzerà quello che la local class può “vedere” nel contesto contenitore. Prosegui nella lettura di “Java, local classes” »
apr 04
Una non-static member class è una inner class definita senza la keyword static (vedere il punto (2) dell’esempio sotto).
Bisogna osservare che:
- Un’istanza di una non-static member class può esistere solo e soltanto insieme all’istanza della classe che la contiene
- Una non-static member class non può avere static members (a meno che non siano anche final)
- Il codice scritto in una non-static member class può avere accesso diretto a ogni membro (inclusi i nested) anche se dichiarato private
Vediamo un esempio con un po’ di casi particolari.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | public class MyLinkedList { private String message = "Shine the light"; // (1) public Node makeInstance (String info, Node next) { return new Node(info, next); } public class Node { // (2) non-static member class (NSMC) final static int maxNumOfNodes = 100; private String nodeInfo; private Node next; private String message ="Messaggio dal Nodo "; // (3) public Node(String nodeInfo, Node next) { this.nodeInfo = nodeInfo; this.next = next; } @Override public String toString(){ message = "Modifica del message di Node"; // (4) return MyLinkedList.this.message + " in " + nodeInfo + " (" + maxNumOfNodes + ")"; // (5) } } } public class ListClient { public static void main(String[] args) { MyLinkedList list = new MyLinkedList(); MyLinkedList.Node node1 = list.makeInstance("node1", null); MyLinkedList.Node node2 = list.makeInstance("node2", node1); System.out.println(node2.toString()); } } |
Osserviamo il punto (4).
Viene modificato il valore asseganto all’attributo di tipo stringa message. Ma esistono 2 attributi di tipo stringa denominati message! Li vediamo dichiarati al punto (1) e al punto (3), entrambi private. Il message al punto (1) appartiene alla classe contenitore (MyLinkedList), mentre quello dichiarato al punto (4) appartiene alla non-static inner class (Node). Abbiamo detto che in una non-static member class possiamo riferirci a qualunque membro, anche dichiarato private, anche appartenente alla classe contenitore. Ma come possiamo riferisci all’attributo message del contenitore? Lo si può fare con un uso particolare della parole chiave this. Osserviamo a tal riguardo il punto (5).
ATTENZIONE.
Se non fosse stato dichiarato l’attributo al punto (4), allora scrivendo
1 | return message + " in " + nodeInfo + " (" + maxNumOfNodes + ")"; // (5a) |
non si avrebbe alcun errore (come invece ci si potrebbe aspettare), poiché ci riferiremmo, in modo implicito, all’attributo message della classe contenitore!!!
Facciamo attenzione a questo caso particolare!
mar 23
I plugin maven per Eclipse sono in uno stadio di maturità per il quale è probabilmente poco opportuno utilizzarli.
Se facciamo uno scouting sulla rete ne scoviamo almeno 2:
Il primo è di sicuro quello che mette a disposizione una maggiore quantità di features, ma da anche qualche rogna di troppo in fase di utilizzo. Il secondo invece è più semplice sia nell’installazione sia nell’utilizzo, ma fornisce una più ristretta capacità di atomazione. Fra tutte le differenze possiamo metterne in evidenza una: ad oggi, AIM non permette la creazione automatica di un progetto spring-ws.
Quindi se dovessimo scegliere in base a spring-ws, ci si dovrebbe poggiare su The Maven Integration for Eclipse. Tuttavia, come si diceva, questo plugin può condurre a un po’ di problemi in fase di utilizzo. Mettiamone in evidenza uno. Pertendo dal presupposto che:
- abbiamo installato/decompresso maven
- abbiamo settato correttamente la variabile d’ambiente JAVA_HOME
- abbiamo creato il file settings.xml nella cartella .m2
- vogliamo creare un progetto spring-ws
si potrebbe incorrere in alcuni errori. Uno dei più frequenti è il seguente:
Resource nexus-maven-repository-index.properties does not exist.
In questo caso in Eclipse procediamo come segue:
- window/preferences/Maven/ArtifactSearch/NexusArtifactSearch/
- premiamo il pulsante “Add” e aggiungiamo la seguente stringa
http://localhost:8081/nexus/content/groups/public
Così facendo dovremmo essere in grado di creare la struttura di un progetto spring-ws senza generare errori… dovremmo
