Enviar email utilizando Java

Criei uma estrutura em Java para enviar emails de forma simples. Basta apenas configurar o host do smtp (algum personalizado ou o próprio Gmail).

Forma de uso (mais detalhes no Github.):

Gerador de thumbnails em Java

Resolvi compartilhar um gerador de thumbnail de imagens muito útil que sempre utilizo.
Basicamente o código recebe o arquivo de origem, o destino, a largura e a altura máxima do thumbnail a ser gerado.

É tudo muito simples e requer apenas a biblioteca padrão awt do Java.

Primeiro vamos ler o arquivo de origem:

FileInputStream input = new FileInputStream(source);
BufferedImage bufImage = ImageIO.read(input);

Agora precisamos calcular o scale, que será o índice para redimensionar a área da imagem. Se a altura original da imagem for maior, o scale será o resultado da divisão da altura do thumb pela altura original. E vice- versa.

double scale1 = (double) width / (double) bufImg.getWidth();
double scale2 = (double) height / (double) bufImg.getHeight(); 
double resultScale = scale1 > scale2 ? scale2 : scale1;

Utilizando o resultado obtido para o cálculo do redimensionamento:

int realWidth = bufImg.getWidth();
int realHeigth = bufImg.getHeight();
BufferedImage imageScaled = new BufferedImage((int) (
    w * resultScale), (int) (h * resultScale), 
    BufferedImage.TYPE_INT_RGB);

Só o BufferedImage gerado não basta. É necessário, por fim, desenhar os gráficos da imagem novamente com os novos parâmetros calculados:

Graphics2D g2 = scaled.createGraphics();
g2.setComposite(AlphaComposite.Src);
g2.drawImage(img.getScaledInstance((int) (realWidth * resultScale), 
    (int) (realHeigth * resultScale), Image.SCALE_SMOOTH),
    0, 0, (int) (w * resultScale), (int) (h * resultScale), null);
g2.dispose();

// Escrevendo no arquivo de sáida
ImageIO.write(imageScaled, "JPG", output);

Código completo:

public class ThumbGenerator {

    public static boolean generate (File source, File dest, 
                   int height, int width) throws IOException {
        if (source != null && dest != null) {
     FileInputStream input = new FileInputStream(source);
     try {
                BufferedImage bufImage = ImageIO.read(input);
  if(bufImage != null) {
      double scale = calcScale(bufImage, width, height);
      BufferedImage imageScaled = scale(bufImage, scale);
      FileOutputStream fos = new FileOutputStream(dest);
      ImageIO.write(imageScaled, "JPG", fos);
      fos.close();
                    input.close();
      return true;
  }

     } catch (Exception e) {
         e.printStackTrace();
     }
 }
 return false;
    }

    private static double calcScale(BufferedImage img, 
                                      int width, int height) {
        double scale1 = (double) width / (double) img.getWidth();
        double scale2 = (double) height / (double) img.getHeight();
        double scale = scale1 > scale2 ? scale2 : scale1;
 return scale;
    }

    private static BufferedImage scale(BufferedImage img, 
                                               double scale) {
        int w = img.getWidth();
        int h = img.getHeight();
        BufferedImage scaled = new BufferedImage((int) (w * scale), 
                (int) (h * scale), BufferedImage.TYPE_INT_RGB);
        Graphics2D g2 = scaled.createGraphics();
        g2.setComposite(AlphaComposite.Src);
        g2.drawImage(img.getScaledInstance((int) (w * scale), 
                (int) (h * scale), Image.SCALE_SMOOTH),
                0, 0, (int) (w * scale), (int) (h * scale), null);
        g2.dispose();
        return scaled;
    }
}

Daí é só chamar:

ThumbGenerator.generate(imgSource, output, 400, 400); 
// Ver resultado no arquivo output

ThumbGenerator.generate(imgSource, output, 400, 600); 
ThumbGenerator.generate(imgSource, output, 600, 400); 
ThumbGenerator.generate(imgSource, output, 100, 100); 

Parser HTML com Java

Fazer parser HTML é uma tarefa extramamente complicada, visto que HTML não é uma linguagem regular, e por isso o uso de expressões regulares em HTML é, na maioria das vezes, inconsistente.

Para facilitar a manipulação de páginas HTML, o time do Apache Maven desenvolveu a biblioteca HTML Parser.

Esta biblioteca visa a simplicidade e performance em manipular HTML. Basicamente trabalha na extração de objetos DOM, que são armazenados em árvores, permitindo assim uma fácil manipulação.
Encapsulei a tarefa de navegar entre todos os nós da árvore de forma recursiva, permitindo assim a manipulação de uma página HTML completa sem expressão regular:

String marcaCarro = MyHtmlParser.getContent(resourceHtml, "div class\"carroStyle\"");

Se existir mais de um elemento com o mesmo atributo na página, basta informar qual a posição passando um terceiro argumento:

String marcaCarro2 = MyHtmlParser.getContent(resourceHtml, "div class\"carroStyle\"", 2);

Subi este projeto no meu Github, livre a todos que quiserem ajudar a melhorá-lo.

Ssh e Ftp com Java utilizando J2SSH

Para fazer comunicação Ssh e FTP com Java é um tanto sofrível, visto que uma das bibliotecas mais famosas, o JFTP, não superou as minhas expectativas.

Uma alternativa é o J2SSH. Embora sua documentação seja péssima, encapsulei uma comunicação completa com SSH e FTP utilizando esta biblioteca e disponibilizei no Github. Seu uso final seria muito simples e da seguinte forma:

SshConnectionHolder sshConnection = SshConnectionFactory.createSshConnection(server, user, password);
String remoteDirectory = "/path-remote-dir";
File localFile = new File("/path-local-dir", "fileName");

// Enviando arquivo via SFTP
sshConnection.sendFileViaSFTP(localFile, remoteDirectory);

// Executando comando remoto via SSH        
String cmd = "ls";
String response = sshConnection.execCommandAndGetResponse(cmd);

// Download via SFTP        
sshConnection.getFileViaSFTP(remoteDirectory, localFile.getName(), localFile);

// Removendo arquivo remoto via SFTP
sshConnection.removeFileViaSFTP(localFile.getName(), remoteDirectory);

sshConnection.disconnect();

Mais detalhes sobre o projeto, ele está completamente disponível no meu Github, para que possa ser constantemente melhorado.

Java Templates no Eclipse

No Eclipse existe uma ferramenta muito legal que é de criar Java Templates.
Um template é um pedaço de código que pode ser colocado através do CTRL + (espaço). Por padrão o Eclipse já vem com alguns templates pré-definidos, onde você pode alterar ou criar novos templates de acordo com sua necessidade.

Como exemplo, você digita "main", aperta CTRL + (espaço) e o Eclipse te traz o template (estrutura) de um método main. Eu acho isso muito produtivo e facilita o trabalho do programador.

Esta ferramenta fica em Window => Preferences. Depois escolher os sub-menus Java => Editor => Templates.

Pronto, você pode alterar ou criar seus próprios templates!
Vou criar aqui um template Singleton, para mostrar como é fácil:

Java Server Pages (JSP) e JSTL

Tentando usar a taglib "foreach" do JSTL, o seguinte erro ocorria:
"According to TLD or attribute directive in tag file, attribute items does not accept any expressions"

Um post neste fórum me salvou.

Minha declaração no JSP estava assim:
%@ taglib prefix="c" uri="http://java.sun.com/jstl/core"%

E por estar usando uma versão do Tomcat acima da 5 (Versão 6), a solução foi trocar a declaração por:
%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%

"It Works!"

Problema com JSTL+Eclipse+Tomcat (Resolvido)

Estava eu fazendo um 'Hello World' com o VRaptor 3, e ao fazer a página de que lista os produtos, com a taglib do JSTL, me apareceu o seguinte erro ao acessar a página:

"SEVERE: Servlet.service() for servlet jsp threw exception
org.apache.jasper.JasperException: Unable to read TLD "META-INF/c-1_0.tld" from JAR file "file:/WEB-INF/lib/standard-1.1.2.jar": org.apache.jasper.JasperException: Failed to load or instantiate TagLibraryValidator class: org.apache.taglibs.standard.tlv.JstlCoreTLV"

Segundo este artigo, se trata de um possível conflito no jar "jsp-api.jar" do CLASSPATH do meu projeto com o CLASSPATH da instalação do Tomcat. Apenas retirei este jar da lib do meu projeto (não sei porque raios coloquei ele lá mas...) e tudo correu bem.