Java 7: ejemplos prácticos

1: Switch permite tomar tipos Strings como argumentos:

public stringsEnCase(Trade t) {
 
            String status = t.getStatus();
 
            switch(status) {
 
            caseNEW:
 
                  newTrade(t);
 
                  break;
 
            caseEXECUTE:
 
                  executeTrade(t);
 
                  break;
 
            casePENDING:
 
                  pendingTrade(t);
 
                  break;
 
 
 
            default:
 
                  break;
 
            }
 
      }

2: Gestión automática de recursos

 public voidnewTry() {
 
            try(FileOutputStream fos = newFileOutputStream("movies.txt");
 
                        DataOutputStream dos = newDataOutputStream(fos)) {
 
                  dos.writeUTF("Java 7 yeah");
 
            } catch(IOException e) {
 
                  // log the exception
 
            }
 
      }

3: Literales numéricos con barra baja

int million  =  1_000_000

4: Mejorado el manejo de excepciones

 public voidnewMultiCatch() {
 
            try{
 
                  methodThatThrowsThreeExceptions();
 
            } catch(ExceptionOne | ExceptionTwo | ExceptionThree e) {
 
                  // log and deal with all Exceptions
 
            }
 
      }

5: Nuevas apis de fichero

package java7;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class PruebasDeFichero {

	public void pruebas() {

		Path pathOrigen = Paths.get("c:\\Temp\\tempOrigen");

		System.out.println("Número de nodos:" + pathOrigen.getNameCount());

		System.out.println("Nombre de fichero:" + pathOrigen.getFileName());

		System.out.println("Raíz:" + pathOrigen.getRoot());

		System.out.println("Padre:" + pathOrigen.getParent());

		OutputStream fis;
		try {
			fis = new FileOutputStream(new File(
					"c:\\Temp\\temp2\\holaMundo2.txt"));

			Files.copy(pathOrigen, fis);
			Path pathOrigenDestino = Paths.get("c:\\Temp\\tempDestino");
			Files.move(pathOrigen, pathOrigenDestino);

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		try {
			Files.delete(pathOrigen);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			Files.deleteIfExists(pathOrigen);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

6: Escucha activa de eventos sobre ficheros

/**
 
 * This initiates the police
 
 */
 
private voidinit() {
 
      path= Paths.get("C:\Temp\temp\");
 
      try{
 
            watchService= FileSystems.getDefault().newWatchService();
 
            path.register(watchService, ENTRY_CREATE, ENTRY_DELETE,
 
                        ENTRY_MODIFY);
 
      } catch(IOException e) {
 
            System.out.println("IOException"+ e.getMessage());
 
      }
 
}
 
/**
 
 * The police will start making rounds
 
 */
 
private voiddoRounds() {
 
      WatchKey key = null;
 
      while(true) {
 
            try{
 
                  key = watchService.take();
 
                  for(WatchEvent event : key.pollEvents()) {
 
                        Kind kind = event.kind();
 
System.out.println("Event on "+ event.context().toString() + " is " + kind);
 
                  }
 
            } catch(InterruptedException e) {
 
System.out.println("InterruptedException: "+e.getMessage());
 
            }
 
            booleanreset = key.reset();
 
            if(!reset)
 
                  break;
 
      }
 
}

7: Tareas recursivas

package forkJoinDemoEjemploAsíncrono;
 
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.RecursiveTask;
 
public class ProcesadorDeDirectorios extends RecursiveTask>
{
   private static final long serialVersionUID = 1L;
   //El path que será procesado
   private final String      path;
   //Extensión de ficheros en cuestión
   private final String      extension;
 
   //Constructor
   public FolderProcessor(String path, String extension)
   {
      this.path = path;
      this.extension = extension;
   }
 
   //Implementación del método compute, que debe devolver un listado de Strings, pues aśi fue parametrizado RecursiveTask
   @Override
   protected List compute()
   {
      //La lista de los nombres de los ficheros almacenados en el directorio
      List list = new ArrayList();
      //Tareas que almacenan las subtareas que van a procesar los subdirectorios almacenados
      //en el directorio padre
      List tasks = new ArrayList();
      //Obtiene el contenido del directorio
      File file = new File(path);
      File content[] = file.listFiles();
      //Para cada elemento del directorio, si hay un subdirectorio, cra un objeto FolderProcessor
      if (content != null)
      {
         for (int i = 0; i < content.length; i++)
         {
            if (content[i].isDirectory())
            {
               FolderProcessor task = new FolderProcessor(content[i].getAbsolutePath(), extension);
               task.fork();
               tasks.add(task);
            }
            //Otherwise, compare the extension of the file with the extension you are looking for using the checkFile() method
            //En otro caso, compara la extensión del fichero con la que se busca (definida
            //en el método checkfile()
            else
            {
               if (checkFile(content[i].getName()))
               {
                  list.add(content[i].getAbsolutePath());
               }
            }
         }
      }
      //Si el listado de tareas de FolderProcesar supera los 50 elementos, se muestra un mensaje
      //por consola
      if (tasks.size() > 50)
      {
         System.out.printf("%s: %d Tareas ejecutadas.\n", file.getAbsolutePath(), tasks.size());
      }
      //Añade a la lista de ficheros los resultados returnados por las subtareas ejecutadas en 
      //esta tarea
      addResultsFromTasks(list, tasks);
      //Retorna el listado de strings.
      return list;
   }
 
   //Para cada tarea almacenada en la lista de tareas, llama al método join() que esperará
   //a la finalización y retornará entonces el resultado de las tareas.
   private void addResultsFromTasks(List list, List tasks)
   {
      for (FolderProcessor item : tasks)
      {
         list.addAll(item.join());
      }
   }
 
   //Compara si el nombre del fichero pasado como parámetro tiene como extensión la que buscamos
   private boolean checkFile(String name)
   {
      return name.endsWith(extension);
   }
}

package forkJoinDemoAsyncExample;
 
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.TimeUnit;
 
public class Main
{
   public static void main(String[] args)
   {
      //Crea el pool fork join usando el constructor por defecto.
      ForkJoinPool pool = new ForkJoinPool();
      //Crea tres tareas FolderProcessor. Inicializa cada una de ellas con un path
      //de directorio diferente
      FolderProcessor system = new FolderProcessor("C:\\Windows", "log");
      FolderProcessor apps = new FolderProcessor("C:\\Program Files", "log");
      FolderProcessor documents = new FolderProcessor("C:\\Documents And Settings", "log");
      //Ejecuta las tres tareas en el pool mediante el método execute.
      pool.execute(system);
      pool.execute(apps);
      pool.execute(documents);
      //Escribe a la consola información sobre el estado del pool cada segunda, hasta que
      //las tres tareas han finalizado su ejecución
      do
      {
         System.out.printf("******************************************\n");
         System.out.printf("Main: Paralelismo: %d\n", pool.getParallelism());
         System.out.printf("Main: Hilos activos: %d\n", pool.getActiveThreadCount());
         System.out.printf("Main: Contados de tareas: %d\n", pool.getQueuedTaskCount());
         System.out.printf("******************************************\n");
         try
         {
            TimeUnit.SECONDS.sleep(1);
         } catch (InterruptedException e)
         {
            e.printStackTrace();
         }
      } while ((!system.isDone()) || (!apps.isDone()) || (!documents.isDone()));
      //Para el pool de fork join 
      pool.shutdown();
      //Escribe el número de resultados generados por cada tarea a la consola
      List results;
      results = system.join();
      System.out.printf("System: %d ficheros encontrados.\n", results.size());
      results = apps.join();
      System.out.printf("Apps: %d ficheros encontrados.\n", results.size());
      results = documents.join();
      System.out.printf("Documents: %d ficheros encontrados.\n", results.size());
   }
}

Muchas gracias,

Un saludo

Comments

[Mitsu Gami]

Dejo 2 para no hacer muy largo el comentario:

1. Inyección de dependencias


@Qualifier
@Retention(RUNTIME)
@Target({FIELD, METHOD, PARAMETER, TYPE})
public @interface PostgreSQL {}



@Qualifer
@Retention(RUNTIME)
@Target({FIELD, METHOD, PARAMETER, TYPE})
public @interface MySQL {}



public interface IConnection {
Connection getConection();
}



@PostgreSQL
public class PostgreSQLConnection implements IConnection {

@Override
public Connection getConnection() throws SQLException {
Class.forName("org.postgresql.Driver");
return DriverManager.getConnection("jdbc:postgresql://localhost:5432/bbdd",
"useer", "pass");
}
}



@MySQL
public class MySQLConnection implements IConnection {

@Override
public Connection getConnection() throws SQLException {
Class.forName("com.mysql.jdbc.Driver");
return DriverManager.getConnection("jdbc:mysql://localhost:3306/bbdd",
"useer", "pass");
}
}



@Stateless
@LocalBean
public class ItemEJB {

@Inject @PostgreSQL
private Connection conn;
}


2. Produces y Disposes


@Qualifier
@Rentention(RUNTIME)
@Target({FIELD, METHOD, PARAMETER, TYPE})
public @interface Connection {
ConnectionType type();
String host();
String port();
String database();
String user();
String pass();

public enum ConnectionType {
MYSQL, POSTGRESQL, ORACLE, DERBY;
}
}



public class ConnectionProducer {

@Produces @Connection
public Connection connection(InjectionPoint ip) throws SQLException {

Annotated annotated = ip.getAnnotated();
Annotation annotation = annotated.getAnnotation(Connection.class); // del qualifier
ConnectionType connType = annotation.type(); // obtiene el tipo de conexión elegido

// propiedades de la conexión
String host = annotation.host();
String port = annotation.port();
String database = annotation.database();
String user = annotation.user();
String pass = annotation.pass();

String connUri;

switch(connType) {
case ConnectionType.MYSQL:
String connUri = "jdbc:mysql://" + host + ":" + port + "/" + database;
Class.forName("com.mysql.jdbc.Driver");
break;
case ConnectionType.POSTGRESQL:
String connUri = "jdbc:postgresql://" + host + ":" + port + "/" + database;
Class.forName("org.postgresql.Driver");
break;
case ConnectionType.ORACLE:
String connUri = "jdbc:oracle:thin:@" + host + ":" + port + ":" + database;
Class.forName("org.postgresql.Driver");
break;
case ConnectionType.DERBY:
String connUri = "jdbc:derby://" + host + "/" database;
}

return DriverManager.getConnection(connUri, user, pass);
}

public void closeConnection(@Disposes @Connection Connection conn) throws SQLException {
conn.close();
}
}



@Stateless
@LocalBean
@RequestScoped
public class ItemEJB {

@Inject @Connection(
host = "127.0.0.1",
port = "5432",
database = "NasaDB",
user = "root",
pass = "toor",
ConnectionType.POSTGRESQL
)
private Connection connection;

...
}


DI gist
Producer/Disposer gist

[luis]

lo de la escucha a ficheros esta interesante
y lo de tareas re cursivas esta super util para hacer tareas pesadas de manera rápida
pero es bien raro párese que no sirve pero si lo intentas con varios cores mas memoria con volumen de procesamiento grande y con un thr@1171@lot alto si reduce casi a mas de la mitad sin esfuerso

[alvaro]

Aquí tenéis un post "más o menos" con los mismos ejemplos explicados.
http://radar.oreilly.com/2011/09/java7-features.html

[jcarmonaloeches]

Gracias Álvaro, en efecto, es el post original.
Lo incluyo en fuentes (References, al final del artículo). pensé que ya lo había hecho). ¡Mis disculpas!