Mismo programa en muchos lenguajes distintos

http://rosettacode.org/wiki/Rosetta_Code

http://www.arquitecturajava.com/

http://www.arquitecturajava.com/

Google sitemap generator

instalar apache2
comando de instalacion en ubuntu:
sudo sh install.sh -g www-data -c /etc/apache2/apache2.conf -t /usr/sbin/apache2ctl

http://googlesitemapgenerator.googlecode.com/svn/trunk/doc/gsg-configuration.html#gsg_con_first
http://www.webdigitalanalytics.com.ar/seo/google-sitemap-xml-generator-webmaster-tools_2013-08-07_1057

FTP por java con JSCH

http://atechblogagain.wordpress.com/2013/06/04/simple-sftp-example-in-java-with-jsch/

2 clases java LogsTools y SshTools que se pueden utilizar para conectarse a servidores en remoto con sesiones exec y ssh y obtener logs. Me ha sido muy útil para ver todos los logs a la vez de muchos servidores e instancias de una aplicación. Además se puede realizar un grep a partir de una cadena buscada y devuelve  desde la primera linea del log donde aparece hasta la última, muy útil para buscar excepciones en logs muy grandes.

 import java.io.BufferedReader;  
 import java.io.BufferedWriter;  
 import java.io.IOException;  
 import java.util.ArrayList;  
 import java.util.List;  
 import org.apache.log4j.Logger;  
 import com.rvillalba.utils.ssh.SshTools;  
 import com.jcraft.jsch.JSchException;  
 import com.jcraft.jsch.Session;  
 /**  
  * The Class LogsTools.  
  */  
 public class LogsTools {  
  /** The Constant LOGGER. */  
  protected static final transient Logger LOGGER = Logger.getLogger(LogsTools.class);  
  /**  
  * Split log by filter.  
  *   
  * @param session  
  *      the session  
  * @param logFilePath  
  *      the log file path  
  * @param filter  
  *      the filter  
  * @param numberLinesAfterLastOccurrence  
  *      the number lines after last occurrence  
  * @return the list  
  */  
  public static List<string> splitLogByFilter(Session session, String logFilePath, String filter,  
   Integer numberLinesAfterLastOccurrence) {  
  List<string> result = new ArrayList<string>();  
  try {  
   Integer firstLine = findFirstOccurrenceLine(session, logFilePath, filter);  
   Integer lastLine = findLastOccurrenceLine(session, logFilePath, filter);  
   if (firstLine != null &amp;&amp; lastLine != null) {  
   result = split(session, logFilePath, numberLinesAfterLastOccurrence, firstLine, lastLine);  
   }  
  } catch (Exception e) {  
   LOGGER.error(e);  
  }  
  return result;  
  }  
  /**  
  * Split.  
  *   
  * @param session  
  *      the session  
  * @param logFilePath  
  *      the log file path  
  * @param numberLinesAfterLastOccurrence  
  *      the number lines after last occurrence  
  * @param firstLine  
  *      the first line  
  * @param lastLine  
  *      the last line  
  * @return the list  
  * @throws IOException  
  *       Signals that an I/O exception has occurred.  
  */  
  private static List<string> split(Session session, String logFilePath, Integer numberLinesAfterLastOccurrence,  
   Integer firstLine, Integer lastLine) throws IOException {  
  List<string> result = new ArrayList<string>();  
  String command = "cat " + logFilePath + " | head -" + ((lastLine) + numberLinesAfterLastOccurrence)  
   + " | tail -" + ((lastLine - firstLine) + numberLinesAfterLastOccurrence + 1);  
  BufferedReader bufferedReader = SshTools.executeCommand(session, command);  
  String line = "";  
  while ((line = bufferedReader.readLine()) != null) {  
   result.add(line);  
  }  
  return result;  
  }  
  /**  
  * Find last occurrence line.  
  *   
  * @param session  
  *      the session  
  * @param logFilePath  
  *      the log file path  
  * @param filter  
  *      the filter  
  * @return the integer  
  * @throws Exception  
  *       the exception  
  */  
  private static Integer findLastOccurrenceLine(Session session, String logFilePath, String filter) throws Exception {  
  String command = "cat " + logFilePath + " | grep -n '" + filter + "' |tail -1 | cut -d : -f 1";  
  BufferedReader bufferedReader = SshTools.executeCommand(session, command);  
  String line = "";  
  Integer result = null;  
  while ((line = bufferedReader.readLine()) != null) {  
   result = Integer.valueOf(line);  
  }  
  return result;  
  }  
  /**  
  * Find first occurrence line.  
  *   
  * @param session  
  *      the session  
  * @param logFilePath  
  *      the log file path  
  * @param filter  
  *      the filter  
  * @return the integer  
  * @throws Exception  
  *       the exception  
  */  
  private static Integer findFirstOccurrenceLine(Session session, String logFilePath, String filter) throws Exception {  
  String command = "cat " + logFilePath + " | grep -n '" + filter + "' |head -1 | cut -d : -f 1";  
  BufferedReader bufferedReader = SshTools.executeCommand(session, command);  
  String line = "";  
  Integer result = null;  
  while ((line = bufferedReader.readLine()) != null) {  
   result = Integer.valueOf(line);  
  }  
  return result;  
  }  
  /**  
  * Prints the logs line.  
  *   
  * @param bw  
  *      the bw  
  * @param hostname  
  *      the hostname  
  * @param fileName  
  *      the file name  
  * @param logs  
  *      the logs  
  * @throws IOException  
  *       Signals that an I/O exception has occurred.  
  */  
  public static void printLogsLine(BufferedWriter bw, String hostname, String fileName, List<string> logs)  
   throws IOException {  
  if (logs != null &amp;&amp; !logs.isEmpty()) {  
   bw.write("INICIO:" + hostname + ":" + fileName + ":");  
   bw.write("\r\n");  
   for (String line : logs) {  
   bw.write(hostname + ":" + fileName + ":" + line);  
   bw.write("\r\n");  
   }  
  }  
  }  
  /**  
  * Find in logs.  
  *   
  * @param bw  
  *      the bw  
  * @throws JSchException  
  *       the j sch exception  
  * @throws IOException  
  *       Signals that an I/O exception has occurred.  
  */  
  public static void findInLogs(BufferedWriter bw, String hostnames, String paths, String login, String password,  
   String fileNames, String filter) throws JSchException, IOException {  
  for (String hostname : hostnames.split(";")) {  
   Session session = SshTools.remoteAccess(hostname, login, password, 22);  
   for (String path : paths.split(";")) {  
   for (String fileName : fileNames.split(";")) {  
    List<string> result = LogsTools.splitLogByFilter(session, path + fileName, filter, 15);  
    printLogsLine(bw, hostname, path + fileName, result);  
   }  
   }  
   SshTools.close(session);  
  }  
  bw.close();  
  }  
 }  
 package com.rvillalba.utils.ssh;  
 import java.io.BufferedReader;  
 import java.io.InputStream;  
 import java.io.InputStreamReader;  
 import java.io.OutputStream;  
 import java.io.PrintStream;  
 import org.apache.log4j.Logger;  
 import com.jcraft.jsch.Channel;  
 import com.jcraft.jsch.ChannelExec;  
 import com.jcraft.jsch.JSch;  
 import com.jcraft.jsch.JSchException;  
 import com.jcraft.jsch.Session;  
 /**  
  * The Class SshTools.  
  */  
 public class SshTools {  
  /** The Constant LOGGER. */  
  protected static final transient Logger LOGGER = Logger.getLogger(SshTools.class);  
  /**  
  * Remote file access.  
  *   
  * @param host  
  *      the host  
  * @param user  
  *      the user  
  * @param pass  
  *      the pass  
  * @param port  
  *      the port  
  * @return the session  
  * @throws JSchException  
  *       the j sch exception  
  */  
  public static Session remoteAccess(String host, String user, String pass, Integer port) throws JSchException {  
  Session session = null;  
  try {  
   JSch jsch = new JSch();  
   java.util.Properties config = new java.util.Properties();  
   config.put("StrictHostKeyChecking", "no");  
   session = jsch.getSession(user, host, port);  
   session.setConfig(config);  
   session.setPassword(pass);  
   session.connect();  
  } catch (Exception e) {  
   LOGGER.error(e);  
  }  
  return session;  
  }  
  /**  
  * Generate channel.  
  *   
  * @param session  
  *      the session  
  * @param command  
  *      the command  
  * @return the channel  
  * @throws JSchException  
  *       the j sch exception  
  */  
  private static Channel generateChannel(Session session, String command) throws JSchException {  
  Channel channel = null;  
  try {  
   channel = session.openChannel("exec");  
   ((ChannelExec) channel).setCommand(command);  
   channel.setInputStream(null);  
   ((ChannelExec) channel).setErrStream(System.err);  
   channel.connect();  
  } catch (Exception e) {  
   LOGGER.error(e);  
  }  
  return channel;  
  }  
  /**  
  * Generate shell channel.  
  *   
  * @param session  
  *      the session  
  * @param commandToRun  
  *      the command to run  
  * @return the channel  
  * @throws JSchException  
  *       the j sch exception  
  */  
  private static Channel generateShellChannel(Session session, String commandToRun) throws JSchException {  
  Channel channel = session.openChannel("shell");  
  OutputStream ops;  
  try {  
   ops = channel.getOutputStream();  
   channel.setOutputStream(System.out);  
   PrintStream ps = new PrintStream(ops, true);  
   channel.connect();  
   ps.println(commandToRun);  
   ps.println("exit");  
   ps.close();  
   do {  
   Thread.sleep(1000);  
   } while (!channel.isEOF());  
  } catch (Exception e) {  
   LOGGER.error(e);  
  }  
  return channel;  
  }  
  /**  
  * Execute shell command.  
  *   
  * @param session  
  *      the session  
  * @param command  
  *      the command  
  * @return the buffered reader  
  */  
  public static BufferedReader executeShellCommand(Session session, String command) {  
  BufferedReader reader = null;  
  try {  
   Channel channel = generateShellChannel(session, command);  
   InputStream inputStream = channel.getInputStream();  
   InputStreamReader inputStreamReader = new InputStreamReader(inputStream);  
   reader = new BufferedReader(inputStreamReader);  
   channel.disconnect();  
  } catch (Exception e) {  
   LOGGER.error(e);  
  }  
  return reader;  
  }  
  /**  
  * Execute command.  
  *   
  * @param session  
  *      the session  
  * @param command  
  *      the command  
  * @return the buffered reader  
  */  
  public static BufferedReader executeCommand(Session session, String command) {  
  BufferedReader reader = null;  
  try {  
   Channel channel = generateChannel(session, command);  
   InputStream inputStream = channel.getInputStream();  
   InputStreamReader inputStreamReader = new InputStreamReader(inputStream);  
   reader = new BufferedReader(inputStreamReader);  
  } catch (Exception e) {  
   LOGGER.error(e);  
  }  
  return reader;  
  }  
  /**  
  * Close.  
  *   
  * @param session  
  *      the session  
  */  
  public static void close(Session session) {  
  try {  
   session.disconnect();  
  } catch (Exception e) {  
   LOGGER.error(e);  
  }  
  }  
 }  

Api para comparar ficheros

http://code.google.com/p/google-diff-match-patch/
http://code.google.com/p/google-diff-match-patch/

tostring con reflection usando ToStringBuilder

http://kodejava.org/how-do-i-use-apache-commons-tostringbuilder/

eclemma, plugin para ver la cobertura de tests Junit

http://www.eclemma.org/index.html

Log4J: Modificar el nivel de log en tiempo de ejecución con el soporte de Spring.

http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=springLog4jConfigListener

Checklist scrum

http://autentia.com/wp-content/uploads/2014/03/Checklist-Scrum.pdf

Orientacion a objetos, javascript vs java

http://micaelgallego.github.io/blog/Orientacion-a-Objetos-en-JavaScript-comparado-con-Java/

Log4mongo

http://log4mongo.org/display/PUB/Log4mongo+for+Java