Presentazione java7

2,143 views

Published on

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

No Downloads
Views
Total views
2,143
On SlideShare
0
From Embeds
0
Number of Embeds
252
Actions
Shares
0
Downloads
31
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

Presentazione java7

  1. 1. Java 7, le novità Andrea Del Bene Jug Marche [email_address]
  2. 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. 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. 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. 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. 6. Language
  7. 7. Core
  8. 8. Internationalization
  9. 9. I/O and Networking (probabilmente il gruppo più ricco)
  10. 10. Security & Cryptography
  11. 11. Database Connectivity
  12. 12. Client
  13. 13. Web
  14. 14. Management </li></ul>
  15. 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. 16. Un nuovo CSS per i JavaDoc :-)
  17. 17. New I/O in Java 7 Andrea Del Bene Jug Marche [email_address]
  18. 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. 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. 20. reading from a file
  21. 21. make a directory including parent directories
  22. 22. copying files and directories
  23. 23. deleting files and directories
  24. 24. converting to and from a URL
  25. 25. listing files and directories by filter and extension
  26. 26. comparing file content
  27. 27. file last changed date
  28. 28. calculating a checksum </li></ul>
  29. 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. 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. 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. 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. 33. Create(temp)File
  34. 34. Delete
  35. 35. ... </li></ul><ul><li>Path
  36. 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. 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. 38. “Ciclare” su una directory <ul><li>Problema : ciclare su una dierctory stampandone il contenuto.
  39. 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. 40. Esplorare le proprietà dei file <ul><li>Problema : recuperare i permessi POSIX di un file
  41. 41. Soluzione : Files.getPosixFilePermissions(... </li></ul><ul><li>Problema : interrogare un file sulla sua eseguibilità
  42. 42. Soluzione : Files.isExecutable(... </li></ul><ul><li>Problema : recuperare l'utenet possessore di un file
  43. 43. Soluzione : UserPrincipal Files.getOwner(... </li></ul><ul><li>Problema : ...
  44. 44. Soluzione : ... </li></ul>
  45. 45. File change notification <ul><li>Problema : monitorare i cambiamenti e le attività che avvengono in una directory.
  46. 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. 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. 48. classi Future, ExecutorService, ecc... </li></ul><ul><li>Purtroppo non si trovano ancora esempi di codice completi di questa feature :-( </li></ul>
  49. 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. 50. Creare un gruppo AsynchronousChannelGroup : AsynchronousChannelGroup group = AsynchronousChannelGroup
  51. 51. .Ottenere un canale asincrono: AsynchronousSocketChannel channel = AsynchronousSocket Channel.open(group);
  52. 52. Leggere/scrivere sul canale Future<Integer> result = channel.write(buf, position); </li></ul>
  53. 53. Concurrency and collections updates Andrea Del Bene Jug Marche [email_address]
  54. 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. 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. 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. 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. 58. Progetto Coin Andrea Del Bene Jug Marche [email_address]
  59. 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. 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. 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. 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. 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. 64. Crittografia a curva ellittica Andrea Del Bene Jug Marche [email_address]
  65. 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. 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. 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. 68. c = p1 * p2
  69. 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. 70. a b mod p = x
  71. 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. 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. 73. Support for Dynamically Typed Languages in the JVM Andrea Del Bene Jug Marche [email_address]
  74. 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. 75. Grazie ! Andrea Del Bene JUG Marche - www.jugancona.it

×