Your SlideShare is downloading. ×
0
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Presentazione java7
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Presentazione java7

1,755

Published on

Published in: Technology, Education
0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
1,755
On Slideshare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
25
Comments
0
Likes
1
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Java 7, le novità Andrea Del Bene Jug Marche [email_address]
  • 2. Per i più distratti... <ul><li>Java 6 (codename Mustang) : rilasciata l'11 Dicembre 2006 ci ha fatto compagnia per quasi 5 anni in cui è successo di tutto nel mondo Java. E' stata la versione più longeva di Java. </li></ul><ul><li>Java 7 (codename Dolphin) : rilasciata il 7 Luglio 20011. Ha avuto una gestazione decisamente travagliata. Sancisce il passaggio definitivo e totale di Java alla licenza GPL . </li></ul>Dolphin doveva contenere un bel po' di novità, soprattutto sul fronte del linguaggio (progetti Lambda e Coin ) e della modularizzazione (progetto Jigsaw ).
  • 3. Per i più distratti... Alcuni fatti contingenti (passaggio a GPL, passaggio di Sun ad Oracle...) hanno subito fatto capire che lo sviluppo di Dolphin non sarebbe stato rapido... Inoltre le feature principali sono oggettivamente molto complesse e di forte impatto sul linguaggio. Impensabile realizzarle in pochi anni... E così Oracle chiese alla community se volevano “l'uovo oggi o la gallina domani”: <ul><li>Piano A: aspettare il 2012 per avere Java 7 con tutte le feature previste
  • 4. Piano B: rilasciare a metà 2011 Java 7 ma senza alcune delle feature previste, posticipandole di un anno e dando vita a Java 8. </li></ul>
  • 5. Il piano B Il piano B è stato quello vincente. Oggi abbiamo Java 7 ma senza alcune delle caratteristiche più complesse. I progetti Lambda , Jigsaw , e parte di Coin sono stati rinviati al Java 8 previsto il prossimo anno (ma basterà davvero un anno ???) Nonstante questi tagli importanto Java 7 presenta molte interessanti novità e non è certo una release in tono minore ! Le novità sono circa 25 divise nei seguenti gruppi: <ul><li>Virtual machine
  • 6. Language
  • 7. Core
  • 8. Internationalization
  • 9. I/O and Networking (probabilmente il gruppo più ricco)
  • 10. Security & Cryptography
  • 11. Database Connectivity
  • 12. Client
  • 13. Web
  • 14. Management </li></ul>
  • 15. Le novità di Java 7 Nome Gruppo Descrizione More new I/O APIs for the Java platform (NIO.2) I/O and networking Nuove classi per rendere l' I/O asincrono , scalabile e flessibile. Small language enhancements (Project Coin) Language Possibilità di usare le stringhe nello switch , migliorato il catching di più eccezioni , migliorata la type inference , ecc... Concurrency and collections updates Core Introduzione di un fork/join framework e miglioramento dell'attuale libreria per la concorrenza. Elliptic-curve cryptography (ECC) Security & Cryptography Evoluzione dell'attuale sistema di crittografia a chiave pubblica RSA. Offre maggior sicurezza con chiavi più piccole. Siccome la carne al fuoco è tanta inizieremo da quelle che dovrebbero essere le novità più “forti”
  • 16. Un nuovo CSS per i JavaDoc :-)
  • 17. New I/O in Java 7 Andrea Del Bene Jug Marche [email_address]
  • 18. La vecchia libreria di I/O La gestione dell'I/O di Java è sempre stata la feature più criticata assieme alle gestione della date (per queste tocca aspettare la 8). Quasi tutti gli utenti (specialmente i newbies) si sono chiesti almeno una volta perché scrivere tanto codice per leggere/scrivere un file: In realtà l'I/O stream-based di Java non è affatto male, ma come molte sui aspetti manca di qualche “utility” che renda il suo uso più amichevole. //legge tutte le righe di un file FileInputStream fstream = new FileInputStream ( &quot;textfile . txt&quot; ) ; List<String> lines = new ArrayList<String>(); DataInputStream in = new DataInputStream ( fstream ) ; BufferedReader br = new BufferedReader ( new InputStreamReader ( in )) ; String strLine ; while (( strLine = br . readLine ()) != null ) { lines.add ( strLine ) ; } in . close () ;
  • 19. Jakarta Commons I/O Per far fronte a questa complessità d'uso sono nate varie librerie tra cui la più famosa probabilmente è Jakarta Commons I/O: org.apache.commons.io Class FileUtils java.lang.Object org.apache.commons.io.FileUtils General file manipulation utilities. Facilities are provided in the following areas: <ul><li>writing to a file
  • 20. reading from a file
  • 21. make a directory including parent directories
  • 22. copying files and directories
  • 23. deleting files and directories
  • 24. converting to and from a URL
  • 25. listing files and directories by filter and extension
  • 26. comparing file content
  • 27. file last changed date
  • 28. calculating a checksum </li></ul>
  • 29. I “fantastici 4” del nuovo I/O Per migliorare l' I/O Java 7 ha introdotto due classi utilities ricalcando quanto fatto con Collections e Arrays per le rispettive entità. Sono le classi Files e FileSystems , entrambe nel package java.nio.file . Le classi prendono spunto da quanto fatto in Jakarta Commons I/O, proponendo addirittura metodi quasi identici come static List<String> readAllLines() . Ovviamente non si sono limitati a copiare la “concorrenza”. Le classi Files e FileSystems non operano direttamente sulla classe File o sugli stream ma su due nuove entità nuove di zecca, ossia l'interfaccia Path e la classe astratta FileSystem presenti sempre nel package java.nio.file . FileSystems fa da factory per FileSystem , che a sua volta instanzia Path . FileSystems FileSystem Path
  • 30. L'interfaccia Path e la classe Paths E' un po' l'elemento centrale del nuovo I/O. Non rappresenta direttamente un file o una directory, ma piuttosto il suo path system dependent. Restituisce l'istanza File associata tramite toFile() . Permette di “navigare” l'albero del file system in un modo che ricorda molto la navigazione di un documento XML: path ha un parent e dei siblings e un path root (vedremo in un esempio successivamente). Paths è la classe utility per istanziare dei Path usando il FileSystem locale bypassando la chiamata a FileSystems <ul><li>Apertura di un file: </li></ul>Path path = FileSystems.getDefault().getPath(&quot;logs&quot;, &quot;access.log&quot;); Path path = Paths.get(&quot;logs&quot;, &quot;access.log&quot;); <ul><li>Apertura di un file con classe Paths : </li></ul>
  • 31. Esempi apertura file e navigazione FS Sia getPath di FileSystem sia get di Paths accettano uno o più parametri stringa che compongono il path: <ul><li>Apertura di un file con percorso “/home/andrea/text.txt”: </li></ul>Path path = Paths.get(&quot;home&quot;, &quot;andrea&quot;, “text.txt”); <ul><li>La stessa cosa la possiamo ottenere sfruttando i metodi resolve che permettono di navigare il file system partendo da un path ed innestandone altri: </li></ul>Path path = Paths.get(&quot;home&quot;); path = path.resolve(“andrea”); path = path.resolve(“text.txt”);
  • 32. Classe Files E' la classe factotum e corrisponde grossomodo a FileUtils di Jackarta Commons. Tra i metodi più interessanti (tutti static) si segnalano: Nome Ritorna Descrizione copy Path Copia un file. Presente in diverse versioni per supportare in input il tipo Path ma anche InputStream e OutPustream. <ul><li>create(temp)Directory
  • 33. Create(temp)File
  • 34. Delete
  • 35. ... </li></ul><ul><li>Path
  • 36. Void per delete </li></ul>Supporto alla creazione/distruzione di directory e file. Delete esiste solo nella version con Path in input. Esistono versioni di creazione per lavorare nella directory temporanea di sistema readAllLines List<String> Legge tutte le righe di un file testuale. Funzione pensata per file non troppo grandi. readAttributes BasicFileAttributes o Map<String,Object> Lettura degli attributi di un file
  • 37. Lettura di tutte le righe di un file <ul><li>L'esempio iniziale di lettura di tutte le righe di un file in Java 7 si riduce alle seguenti righe di codice: </li></ul>//legge tutte le righe di un file Path fileToRead = Paths.get ( &quot;textfile . txt&quot; ) ; List<String> lines = Files.readAllLines( fileToRead, “UTF-8” ); <ul><li>Non devo più gestire direttamente gli stream e la loro creazione/chiusura. </li></ul>
  • 38. “Ciclare” su una directory <ul><li>Problema : ciclare su una dierctory stampandone il contenuto.
  • 39. Soluzione : uso del metodo walkFileTree </li></ul>public class WalkThroughtDir { public static void main(String[] args) throws Exception{ Path start = Paths.get(System.getProperty( &quot;user.home&quot; )); Files.walkFileTree(start, new SimpleFileVisitor<Path>() { @ Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException{ System.out.println(file); return FileVisitResult.CONTINUE; } @ Override public FileVisitResult postVisitDirectory(Path dir, IOException e) throws IOException{ System.out.println(dir); return FileVisitResult.CONTINUE; } }); } }
  • 40. Esplorare le proprietà dei file <ul><li>Problema : recuperare i permessi POSIX di un file
  • 41. Soluzione : Files.getPosixFilePermissions(... </li></ul><ul><li>Problema : interrogare un file sulla sua eseguibilità
  • 42. Soluzione : Files.isExecutable(... </li></ul><ul><li>Problema : recuperare l'utenet possessore di un file
  • 43. Soluzione : UserPrincipal Files.getOwner(... </li></ul><ul><li>Problema : ...
  • 44. Soluzione : ... </li></ul>
  • 45. File change notification <ul><li>Problema : monitorare i cambiamenti e le attività che avvengono in una directory.
  • 46. Soluzione : uso del metodo walkFileTree </li></ul>public static void main(String[] args) throws Exception { WatchService watcher=FileSystems.getDefault().newWatchService(); Path dir = Paths.get(System.getProperty( &quot;user.home&quot; )); WatchKey key = dir.register(watcher, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY); for (;;) { // wait for key to be signalled key = watcher.take(); // process events for (WatchEvent<?> event: key.pollEvents()) { System.out.println(event.context()); } // reset key key.reset(); } }
  • 47. Asynchronous I/O <ul><li>L'I/O asincrono prevede la possibilità di scrivere/leggere su file o su stream generali di I/O (come le socket) in maniea asincrona. </li></ul><ul><li>E' una caratteristica a metà strada tra I/O e concorrenza.... </li></ul><ul><li>Con questo tipo di I/O i nostri programmi non sono più costretti ad aspettare la fine dei cicli di I/O per proseguire con l'esecuzione. </li></ul><ul><li>Questa feature è stata costruita come estensione “naturale” degli strumenti di concorrenza aggiunti con Java 5:
  • 48. classi Future, ExecutorService, ecc... </li></ul><ul><li>Purtroppo non si trovano ancora esempi di codice completi di questa feature :-( </li></ul>
  • 49. Asynchronous I/O <ul><li>...però possiamo riassumere lo schema d'uso di questa feature con le socket. </li></ul><ul><li>Creare un pool di thread, sottoclasse di ExecutorService
  • 50. Creare un gruppo AsynchronousChannelGroup : AsynchronousChannelGroup group = AsynchronousChannelGroup
  • 51. .Ottenere un canale asincrono: AsynchronousSocketChannel channel = AsynchronousSocket Channel.open(group);
  • 52. Leggere/scrivere sul canale Future<Integer> result = channel.write(buf, position); </li></ul>
  • 53. Concurrency and collections updates Andrea Del Bene Jug Marche [email_address]
  • 54. Il modello “Fork/Join” Nel campo del calcolo distribuito il modello Fork/Join mira a risolvere problemi complessi dividendolo in micro-problemi più semplici da eseguire in parallelo. Il problema ed i suoi sottoproblemi sono risolti da una singola unità esecutiva ( Task ) che rispetta il seguente algoritmo (funzione): Result solve(Problem problem) { if (problem is small) directly solve problem else { -split problem into independent parts -fork new subtasks to solve each part -join all subtasks -compose result from subresults } }
  • 55. Implementare Fork/Join in Java Implementare il modello Fork/Join non è così semplice come sembra... Se ad un task si fa corrispondere un Thread Java si otterrebbe un'implementazione molto pesante e l'overhead supererebbe i benefici. Dug Lea è un professore dell'università di New York, “luminare” della programmazione parallela. Ha scritto una libreria per introdurre il modello Fork/Join in Java. Quella libreria è diventata la JSR 166y, rilasciata in Java 7 La libreria si occupa interamente della creazione dei task e della loro sincornizzazione.
  • 56. Somma di un array di interi 1/2 public class Solver extends RecursiveAction { private int [] list; public long result; public Solver( int [] array) { this .list = array; } @ Override protected void compute() { if (list.length == 1) { result = list[0]; } else { int midpoint = list.length / 2; int [] l1 = Arrays.copyOfRange(list, 0, midpoint); int [] l2 = Arrays.copyOfRange(list, midpoint, list.length); Solver s1 = new Solver(l1); Solver s2 = new Solver(l2); invokeAll(s1, s2); result = s1.result + s2.result; } } public long getResult(){ return result; } } Vediamo un esempio di applicazione del modello Fork/Join. Come caso d'uso consideriamo la somma degli elementi interi di un array.
  • 57. Somma di un array di interi 2/2 public static void main(String[ ] args ) { // Check the number of available processors int nThreads = Runtime.getRuntime().availableProcessors(); System.out . println( nThreads ); int [] list = new int [2000000]; Random generator = new Random(19580427); for ( int i = 0; i < list.length ; i ++ ) { list[i] = generator.nextInt(500000); } Solver mfj = new Solver(list); ForkJoinPool pool = new ForkJoinPool(nThreads); pool . invoke( mfj ); long result = mfj.getResult(); System.out .println ( &quot;Done. Result: &quot; + result); }
  • 58. Progetto Coin Andrea Del Bene Jug Marche [email_address]
  • 59. Strings in switch public class TestStringsInSwitch { public void test() { final String str = &quot;foo&quot; ; switch (str) { case &quot;foo&quot; : System.out.println( &quot;mooh&quot; ); break ; case &quot;bar&quot; : System.out.println( &quot;miau&quot; ); break ; default : break ; } } public static void main( final String[] args) { new TestStringsInSwitch().test(); } }
  • 60. Diamond operator import java.util.ArrayList; import java.util.List; public class TestDiamondOperator { public void test() { final List<String> list = new ArrayList <> (); list.add( &quot;Foo&quot; ); System.out.println(list); } public static void main( final String[] args) { new TestDiamondOperator().test(); } } E' stata migliorata la type inference aggiungendo l'operatore diamond <> utile quando si istanziano le collection
  • 61. Multy catch and rethrow public class TestMultiCatchAndRethrow { class ExA extends Exception { } class ExB extends Exception { } public void testMultiCatch() { final int a = 0; try { if (a == 0) { throw new ExA(); } if (a == 1) { throw new ExB(); } } catch ( ExA|ExB ex ) { System.out.println(ex.getClass() + &quot; was thrown and caught&quot; ); } } public void testReThrow() throws ExB { final int a = 0; try { if (a == 0) { throw new ExA(); } if (a == 1) { throw new ExB(); } } catch ( final ExA exa) { System.out.println( &quot;Exa was caught&quot; ); } catch ( final Exception ex) { System.out.println(ex.getClass() + &quot; was thrown, caught and rethrown&quot; ); throw ex; } } }
  • 62. Automatic resource management public class TestAutomaticResourceManagement { public void test() { try ( final BufferedReader br = new BufferedReader( new FileReader( &quot;./TestAutomaticResourceManagement.java&quot; ))) { String line; while ((line = br.readLine()) != null ) { System.out.println(line); } } catch ( final IOException e) { } } public static void main( final String[] args) { new TestAutomaticResourceManagement().test(); } }
  • 63. Integer litterals public class TestIntegerLiterals { public void test() { final int large = 1_000_000; System.out.println(large); final int binary = 0b1011; System.out.println(binary); } public static void main( final String[] args) { new TestIntegerLiterals().test(); } } Si tratta di un po' di “zucchero sintattico” per esprimere più comodamente nel codice dei valori numerico/binari.
  • 64. Crittografia a curva ellittica Andrea Del Bene Jug Marche [email_address]
  • 65. I cifrari a chiave pubblica. <ul><li>RSA è il cifrario a chiave pubblica correntemente più utilizzato, ma non è l'unico cifrario di questo tipo esistente. </li></ul><ul><li>Un limite di RSA è la grandezza della sue chiavi. Per avere un minimo di sicurezza occorre una chiave di 1024 bit, ma già se ne sconsiglia l'uso in favore dei 2048 bit. Con i cifrari simmetrici la chiavi di solito è lunga 128 bit o 256 bit. </li></ul><ul><li>TUTTI i cifrari a chiave pubblica noti si basano su operazioni matematiche semplici da eseguire ma difficili da ricostruire .
  • 66. Per difficile si intende che teoricamente è possibile ricostruire e “clonare” le chiavi private partendo da quelle pubbliche, ma la mole di calcoli scoraggia chiunque dal farlo </li></ul>
  • 67. Le operazioni “difficili” dei cifrari <ul><li>L'operazione“difficile” da ricostruire che sta alla base di RSA è la scomposizione dei numeri interi in fattori primi </li></ul><ul><li>In RSA ci si scambia un numero c che il prodotto di due numeri primi p1 e p2 moooolto grandi:
  • 68. c = p1 * p2
  • 69. Questo prodotto è facile da eseguire noti p1 e p2, ma è quasi impossibile ricavare p1 e p2 noto solo c! </li></ul><ul><li>In un cifrario a curva ellittica come operazione “difficile” da ricostruire si usa il logaritmo discreto. Dati i numeri a, b, x e p (primo) si esegue la seguente operazione:
  • 70. a b mod p = x
  • 71. Anche in questo caso l'operazione è semplice noti i 4 elementi, ma se x è ignota ricavarla richiede una capacità computazionale fantascientifica. </li></ul>
  • 72. Cuva ellittica vs RSA <ul><li>Il vantaggio dei cifrari a curva ellittica (ECC) su RSA è la dimensione della chiave. La stessa sicurezza che RSA ha con 2048 bit di chiave ECC la fornisce con soli 192 bit </li></ul><ul><li>Java 7 fornisce un'implementazione portabile di ECC. La classe centrale è EllipticCurve nel package java.security.spec. </li></ul>
  • 73. Support for Dynamically Typed Languages in the JVM Andrea Del Bene Jug Marche [email_address]
  • 74. Linguaggi dinamici su JVM <ul><li>Questa feature si pone come obbiettivo l'integrazione di altri linguaggi diversi da Java sulla JVM </li></ul><ul><li>La specifica JSR 277 si poneva un obbiettivo simile, ma considerava solo l'interpretazione di linguaggi, non la compilazione . </li></ul><ul><li>Per questa feature è stato quindi cambiato il bytecode Java tenendo conto delle esigenze dei linguaggi con tipi dinamici, dovendo ovviamente preservare la retrocompatibilità </li></ul><ul><li>Non sono purtroppo presenti esempi di codice al riguardo :-( </li></ul><ul><li>Avrà comunque un forte impatto sui linguaggi non-Java presenti sulla JVM. </li></ul>
  • 75. Grazie ! Andrea Del Bene JUG Marche - www.jugancona.it

×