Archive

Posts Tagged ‘Tutorial’

FindBugs x Checkstyle x PMD

Featured imageInúmeras pessoas fazem a comparação entre as ferramentas FindBugs, Checkstyle e PMD. Vale dizer que as três permitem a escrita de um melhor código fonte, o inspecionando em busca de possíveis problemas e gerando relatórios para que o desenvolvedor possa tomar providências.

Porém, a abordagem delas é um pouco distinta:

  • FindBugs: Funciona procurando padrões de Bugs. Analise o Bytecode, e não o código fonte em si. Funciona como se tivesse um banco de dados interno com os bugs comuns, e vasculha seu código procurando por esses bugs. Eventualmente pode dar falsos positivos, apontando erros que no contexto de sua aplicação, não são erros. A própria documentação oficial do Findbugs diz: “In practice, the rate of false warnings reported by it is less than 50%”.
    http://findbugs.sourceforge.net/index.html
  • CheckStyle: Seu foco é em problemas relacionados as convenções e padrões Java, por exemplo: ausência de Java docs, abertura de chaves { depois de Ifs, etc. Ele varre o código fonte de seu projeto.
    http://checkstyle.sourceforge.net/
  • PMD: Vasculha o código fonte procurando por más práticas e problemas de código por exemplo: import com *, muitos métodos em classes, etc.
    http://pmd.sourceforge.net/

Em geral o PMD e o Checkstyle são mais similares. Todavia, eu recomendo o uso das 3 ferramentas em seu projeto, e além disso, que sejam criados arquivos de configurações para CADA ferramente e que os mesmos sejam utilizados por TODO o time, garantindo assim, a homogeneidade na produção do seu código fonte.

O uso principalmente do checkstyle e do PMD garantem um código fonte mais legível, de melhor manutenabilidade, tornando-se o trabalho com os mesmos mais eficiente e rápido.

Eu fiz video aulas introdutórias sobre as 3 ferramentas, que ensinam como instalar, configurar e utilizar, como sempre, de maneira simples e objetiva. Seguem os links:

  1. FindBugs
  2. Checkstyle
  3. PMD

Enjoy!

Introdução ao PMD

março 16, 2015 1 comentário

Featured imageUltimamente estou implementando algumas ferramentas para garantir maior qualidade em meu projeto, e a bola da vez é o PMD. O PMD é uma ferramenta que auxilia desenvolvedores efetuando varredura de código fonte buscando por problemas em potencial, tais como (retirado diretamente do site oficial):

  • Bugs – empty try/catch/finally/switch statements
  • Dead code – unused local variables, parameters and private methods
  • Suboptimal code – wasteful String/StringBuffer usage
  • Overcomplicated expressions – unnecessary if statements, for loops that could be while loops
  • Duplicate code – copied/pasted code means copied/pasted bugs

Assim como o Checkstyle, utilizar o PMD e efetuar os ajustes que o mesmo recomenda, ajuda a obter-se uma melhoria em seu código fonte, tornando-o mais legível e aumentando sua manutenabilidade.

Recomendo a todos os desenvolvedores que o utilizem em conjunto o o FindBugs e com o CheckStyle, pois são ferramentas com finalidades parecidas e garantem juntas um sólido código fonte. Neste post, você pode encontrar mais informações sobre o FindBugs. Neste outro post você encontra mais informações sobre o Checkstyle.

No vídeo abaixo, você pode ver facilmente como instalar e utilizar o PMD. Os slides utilizados no vídeo estão aqui.

Enjoy!

Introdução ao FindBugs

FindBugs é uma ferramenta que pode nos ajudar a aprimorar a qualidade dos aplicativos que produzimos. Basicamente trata-se de uma ferramenta que busca padrões de bug em seu aplicativo e gera um relatório permitindo que o desenvolvedor tome ações para os eliminar se aplicável.

Gravei um vídeo ensinando a instalar e utilizar no Eclipse e com algumas breves explicações. Os slides apresentados no vídeo podem ser baixados da seguinte URL https://drive.google.com/file/d/0BxhdMuoEQRL-N2tudi02dXNWRG8/view?usp=sharing

Eis o vídeo:

Enjoy.

Instalando uma máquina virtual Linux para estudos

Para quem quer começar a estudar Linux e tem “medo” de perder as coisas de seu computador, uma boa pedida é criar uma máquina virtual para os estudos.

Criei o vídeo abaixo para que os interessados possam seguir e iniciar nesse mundo que tem muito a agregar.

Qualquer crítica, sugestões ou comentários, serão bem vindos!

Enjoy!

Criando um projeto Java que conecta no Derby

Segue um breve tutorial sobre como criar uma aplicação Java que se conecta no Derby e o manipula.

1- Baixe a versão mais recende do Derby em http://db.apache.org/derby/derby_downloads.html
Existe a distribuição binária (bin distribution) que além das bibliotecas requeridas, tras documentação, exemplos, etc. Eu costumo baixar a Lib distribution, que contem somente os JARS necessários.

2- Descompacte o arquivo baixado. Veja que existe um diretório LIB nele. Lá estarão as bibliotecas que utilizaremos em seguida.

3- É opcional, mas eu prefiro criar uma pasta em meu projeto chamada Derby e copiar os arquivos do Derby para dentro da mesma, assim, ao levar o projeto para outras máquinas, o banco vai junto. Criada a pasta, os dois arquivos necessários são:

  • derby.jar
  • derbytools.jar

4- Adicione os dois Jars copiados em seu ClassPath, para isso, clique com o botão direito no projeto e vá em propriedades, então em Java Build Path, e na Aba Libraries, clique em Add Jars e apontar o local onde estão os dois arquivos.

Feito isso, vamos para o código. Criei uma classe chamada TesteDerby no pacote br.com.tix11.programs , ele foi baseado na documentação oficial do Derby. A classe tenta se conectar num banco Derby, vê se o db ESCOLA existe, caso não exista o cria e popula e faz um select simples. Segue o conteúdo:

Feito isso, vamos para o código. Criei uma classe chamada TesteDerby no pacote br.com.tix11.programs , ele foi baseado na documentação oficial do Derby. A classe tenta se conectar num banco Derby, vê se o db ESCOLA existe, caso não exista o cria e popula e faz um select simples. Segue o conteúdo:

package br.com.tix11.programs;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;

import org.apache.derby.tools.ij;

public class TestDerby {

	private static String driver = "org.apache.derby.jdbc.EmbeddedDriver";
	private static String protocol = "jdbc:derby:";

	public static void main(String args[]) {
		if (checkDB())
		{
			System.out.println("BANCO ESTA PRONTO PARA O USO.");
		} else
		{
			System.out.println("BANCO NAO ESTÁ OPERACIONAL.");
		}
	}

	public static boolean checkDB() {
		boolean retorno = false;
		loadDriver();
		Connection conn = null;

		ArrayList statements = new ArrayList(); // list of Statements,
												// PreparedStatements
		Statement s = null;
		ResultSet rs = null;
		try
		{
			String dbName = "ESCOLA"; // the name of the database
			// caso DB não exista, ele cria
			conn = DriverManager.getConnection(protocol + dbName + ";create=true");
			System.out.println("Connected to and created database " + dbName);

			// Imprimindo o conteudo da tabela disciplina
			s = conn.createStatement();
			rs = s.executeQuery("SELECT * FROM ESCOLA.discipline");
			while (rs.next()){
				System.out.println(rs.getInt(1) + " - " + rs.getString(2));
			}

			// Efetuando shutdown no DERBY
			try
			{
				DriverManager.getConnection("jdbc:derby:;shutdown=true");
			} catch (SQLException se)
			{
				if (((se.getErrorCode() == 50000) && ("XJ015".equals(se.getSQLState()))))
				{
					System.out.println("Derby shut down normally");
				} else
				{
					System.err.println("Derby did not shut down normally");
					printSQLException(se);
				}
			}

		} catch (SQLException sqle)
		{
			// Caso eu nao encontre o banco ou a tabela, eu os crio. Deve passar aqui somente na primeira execussao
			printSQLException(sqle);
			if  ( ( sqle.getMessage().equalsIgnoreCase("Table/View 'ESCOLA.discipline' does not exist.")) || (sqle.getMessage().equalsIgnoreCase("Schema 'ESCOLA' does not exist")) )
			{
				System.out.println("Ill create the database.");
				if (createDB(conn))
				{
					System.out.println("Banco Criado");
					System.out.println("Populando Banco");
					if (populateDB(conn))
					{
						System.out.println("Banco nao pode ser populado");
					} else
					{
						System.out.println("Banco populado");
						retorno = true;
					}
				} else
				{
					System.out.println("Banco não pode ser criado");
				}

			}
		} finally
		{
			// release all open resources to avoid unnecessary memory usage
			try
			{
				if (rs != null)
				{
					rs.close();
					rs = null;
				}
			} catch (SQLException sqle)
			{
				printSQLException(sqle);

			}

			// Statements and PreparedStatements
			int i = 0;
			while (!statements.isEmpty())
			{
				// PreparedStatement extend Statement
				Statement st = (Statement) statements.remove(i);
				try
				{
					if (st != null)
					{
						st.close();
						st = null;
					}
				} catch (SQLException sqle)
				{
					printSQLException(sqle);
				}
			}

			// Connection
			try
			{
				if (conn != null)
				{
					conn.close();
					conn = null;
				}
			} catch (SQLException sqle)
			{
				printSQLException(sqle);
			}
		}
		return retorno;
	}

	/**
	 * Cria a tabela
	 * @param conn
	 * @return
	 */
	private static boolean createDB(Connection conn) {
		FileInputStream fileStream = null;
		try
		{
			fileStream = new FileInputStream("./scripts/create.sql");
			int result = ij.runScript(conn, fileStream, "UTF-8", System.out, "UTF-8");
			System.out.println("Result code is: " + result);
			if (result == 1)
			{
				return true;
			} else
			{
				return false;
			}
		} catch (FileNotFoundException e)
		{
			return false;
		} catch (UnsupportedEncodingException e)
		{
			return false;
		} finally
		{
			if (fileStream != null)
			{
				try
				{
					fileStream.close();
				} catch (IOException e)
				{
				}
			}
		}
	}

	/**
	 * Popula a tabela
	 * @param conn
	 * @return
	 */
	private static boolean populateDB(Connection conn) {
		FileInputStream fileStream = null;
		try
		{
			fileStream = new FileInputStream("./scripts/populate.sql");
			int result = ij.runScript(conn, fileStream, "UTF-8", System.out, "UTF-8");
			System.out.println("Result code is: " + result);
			if (result == 1)
			{
				return true;
			} else
			{
				return false;
			}
		} catch (FileNotFoundException e)
		{
			return false;
		} catch (UnsupportedEncodingException e)
		{
			return false;
		} finally
		{
			if (fileStream != null)
			{
				try
				{
					fileStream.close();
				} catch (IOException e)
				{
				}
			}
		}
	}

	private static void loadDriver() {
		try
		{
			Class.forName(driver).newInstance();
			System.out.println("Loaded the appropriate driver");
		} catch (ClassNotFoundException cnfe)
		{
			System.err.println("\nUnable to load the JDBC driver " + driver);
			System.err.println("Please check your CLASSPATH.");
			cnfe.printStackTrace(System.err);
		} catch (InstantiationException ie)
		{
			System.err.println("\nUnable to instantiate the JDBC driver " + driver);
			ie.printStackTrace(System.err);
		} catch (IllegalAccessException iae)
		{
			System.err.println("\nNot allowed to access the JDBC driver " + driver);
			iae.printStackTrace(System.err);
		}
	}

	private static void reportFailure(String message) {
		System.err.println('\t' + message);
	}

	public static void printSQLException(SQLException e) {
		while (e != null)
		{
			System.err.println("\n----- SQLException -----");
			System.err.println("  SQL State:  " + e.getSQLState());
			System.err.println("  Error Code: " + e.getErrorCode());
			System.err.println("  Message:    " + e.getMessage());
			e = e.getNextException();
		}
	}

}

Repare que eu criei dois scripts SQL, um que cria a tabela que utilizaremos para teste e outro que a popula. Então, no exemplo JAVA você verá dois métodos sendo invocados caso necessário, para chamar respectivamente os scripts que criam e populam a tabela. Dentro do projeto tem uma pasta chamada scripts, e nela, os dois scripts.

create.sql

CREATE TABLE "ESCOLA".discipline
(
  id numeric(10) NOT NULL,
  "NAME" character varying(100) NOT NULL
);

populate.sql

INSERT INTO "ESCOLA".discipline (id, name) VALUES (1, 'Module 1');
INSERT INTO "ESCOLA".discipline (id, name) VALUES (2, 'Module 2');
INSERT INTO "ESCOLA".discipline (id, name) VALUES (3, 'Module 3');
CategoriasJAVA Tags:, , , ,

Criando uma aplicação Java conversando com Filas MQ

Galera, achei uma fonte muito legal sobre o tema Java e WebSphere MQ, segue ai:

http://www.angusyoung.org/2011/10/23/tutorial-sobre-websphere-mq/

Quartz + Tomcat ou Qualquer Servidor de App

Este é um passo a passo de como criar uma aplicação Web que tem uma tarefa agendada. Por exemplo, vamos supor que você tem uma aplicação Web, que eventualmente deve efetuar uma limpeza de dados em uma base. Você pode utilizar o quartz para isso (outra alternativa seria Ejb timer). Vamos la:

1- Baixe o Quartz (http://www.quartz-scheduler.org/)
2- Crie um projeto Web Dinâmico no Eclipse e nas dependencias do mesmo, coloque todas as bibliotecas do Quartz baixadas no passo anterior.
3- Crie as classes abaixo:
3.1- Tarefa

package com.br.infoserver.quartz;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * Esta classe demonstra uma tarefa que ira ser invocada pelo Quartz
 * Tem que implementar a interface Job do Quartz
 * @author julianom
 */
public class TarefaExemplo implements Job{
	/**
	 * Metodo que é executado quando a tarefa é invocada
	 */
	public void execute(JobExecutionContext context)
	throws JobExecutionException {
		// aqui vai a lógica da tarefa a ser chamada,
		// por exemplo, fazer um select no banco e enviar algum dado para uma fila MQ
		// Neste exemplo, vai somente imprimir no console a data de hoje no intervalo de 5 segundos
		SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy – hh:mm:ss");
		System.err.println("Rodou: " + dateFormat.format( new Date() ));
	}
}

3.2- Agendador, esta classe será invocada por um servlet na inicialização da aplicação WEB

package com.br.infoserver.quartz;

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

/**
 * Esta é a classe que deve ser invocada e irá disparar a tarefa nos momentos
 * determinados
 *
 * @author julianom
 *
 */
public class Agendador {

	public static void inicia() throws Exception {
		// Detalhes da tarefa
		JobDetail job = JobBuilder.newJob(TarefaExemplo.class).withIdentity(
				"tarefaAloMundo", "group1").build();
		// Gatilho - ou seja, quando irá chamar, neste caso, a cada 5 segundos
		Trigger trigger = TriggerBuilder.newTrigger().withIdentity(
				"gatilhoAloMundo", "group1").withSchedule(
				CronScheduleBuilder.cronSchedule("0/5 * * * * ?")).build();

		// Agenda e voa lá!
		Scheduler scheduler = new StdSchedulerFactory().getScheduler();
		scheduler.start();
		scheduler.scheduleJob(job, trigger);

	}

}

4- Crie um servlet, este Servlet deverá ser configurado para ser carregado na inicialização da aplicação, eu fiz isso utilizando annotation, dependendo de sua versão de Java, Apache, WebSphere, etc… vai ter que tirar do Servlet e colocar no arquivo web.xml

package com.br.infoserver.quartz.servlet;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.br.infoserver.quartz.Agendador;

/**
 * Servlet implementation class QuartzServlet
 */
@WebServlet(
		urlPatterns = { "/QuartzServlet" },
		initParams = {
				@WebInitParam(name = "load-on-startup", value = "2")
		})
public class QuartzServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;

    /**
     * @see HttpServlet#HttpServlet()
     */
    public QuartzServlet() {
        super();
		try {
			Agendador.inicia();
		} catch (Exception e) {
			e.printStackTrace();
		}
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
	}

}

Pronto, simples e fácil. Basta efetuar o deploy de sua aplicação em seu servidor, e verá que neste exemplo ele ficará escrevendo a data no SystemOut do mesmo!

Enjoy!

Seguir

Obtenha todo post novo entregue na sua caixa de entrada.

Junte-se a 302 outros seguidores