Arquivo por categoria Java

Montando Um Ambiente De Desenvolvimento Java Completo

Esse é um post para aqueles que estão procurando começar a desenvolver em Java. Trata-se de um passo a passo em vídeos sobre como montar o ambiente de desenvolvimento Java completo. No primeiro vídeo eu faço uma pequena apresentação da série e dou algumas dicas rápidas.

No segundo vídeo aprendemos a baixar e instalar o Java 8 que pode ser baixado aqui.

No terceiro vídeo nos configuramos as variáveis de ambiente JAVA_HOME (C:\Program Files\Java\jdk1.8.0_92 – adapte esse endereço à sua realidade) e adicionamos sua referência ao Path (%JAVA_HOME%\bin).

No quarto vídeo realizamos a instalaçãp do Apache Maven que pode ser baixado aqui. E configuramos as variáveis de ambiente (C:\Program Files\Apache-Maven-3.3.9 – adapte esse endereço à sua realidade) e adicionamos sua referência ao Path (%M2_HOME%\bin).

Com o Maven já instalado nesse vídeo nós customizamos o diretório padrão em que salvamos as nossas dependências. Esse é um vídeo extra e se você tem espaço de sobra no seu HD pode simplesmente pular para o próximo vídeo.

No próximo vídeo eu demonstro como executar um projeto Maven se por acaso você já souber como fazer isso pode avançar direto para o próximo. Um ponto não mencionado no vídeo é que não raramente acontece é um proxy, firewall ou antivírus impedindo o download de nossas dependências então antes de xingar o Maven confira se essas três coisas não estão te sabotando.

Nesse vídeo nós aprendemos como instalar o Eclipse e como configurar o Maven nessa IDE. Você pode baixar o Eclipse aqui e a Spring Source Tool Suite aqui (a IDE que eu uso).

Agora veremos como importar e executar um projeto no Eclipse.

Os próximos vídeos é para aqueles que preferem trabalhar na IDE Netbeans que pode ser baixada aqui. Aprendemos qual opção de download escolher e como instalar.


No vídeo seguinte a gente importa e executa um projeto no Netbeans.

Nesse vídeo nos fazemos a instalação do GitBash que inclui o Git e um bash que você pode usar no lugar do prompt de comandos do DOS. As principais vantagens dele é prover funcionalidades similares às do Linux na linha de comando. O GitBash pode ser baixado aqui.


Agora nós instalaremos o MySQL que é um SGBD relativamente simples pra você iniciar seus estudos de Java acessando uma base de dados e pode ser baixado aqui.


Um passo óbvio depois de instalar um SGBD é instalar uma ferramenta de SGBD. No nosso caso instalaremos o HeidiSQL que usaremos para manipular os dados de nosso banco. Para baixá-lo clique aqui.


Nesse vídeo nos aprendemos como fazer um backup de uma base de dados.


E por fim aprendemos a restaurar um backup.

Com essas tecnologias configuradas temos bem além do básico necessário para trabalhar com Java. Como podem perceber você pode assistir os vídeos e instalar apenas as ferramentas que você precisar mas o objetivo final é te dar uma base tecnológica para construir aplicações Java se conectando a uma base de dados usando Maven. É isso aí bons estudos e se gostou da postagem torne-se um membro VIP e receba conteúdos exclusivos.

Usando código Groovy (o Java com esteróides) juntamente com código Java em um projeto com Spring Boot

Mais um post em que explico como integrar código Groovy junto ao seu código Java em um projeto com Spring Boot usando o gerenciador de dependencias Maven. No outro post usamos o ‘Groovy Eclipse Compiler Plugin‘ mas nunca consegui fazer ele funcionar corretamente com o Spring Boot então o substituimos pelo ‘GMaven Plugin‘. Além disso o ‘Groovy Eclipse Compiler Plugin‘ tem problemas de backward compatibility com o Java 8 diferentemente do ‘GMaven Plugin‘.
Então mãos a obra, adicione as configurações abaixo ao seu pom.xml e tenha todo poder do Groovy junto ao seu código Java.

	
	<!-- Adicione o Groovy às dependências do seu projeto -->
	<dependencies>
        <dependency>
            <groupId>org.codehaus.groovy</groupId>
            <artifactId>groovy-all</artifactId>
            <scope>compile</scope>
        </dependency>
	</dependencies>		
     
        .
        .
        .       
     
	<!-- Será necessário fazer algumas mudanças no seu processo de build --> 		
	<build>
		<resources>
			<resource>
				<directory>${basedir}/src/main/resources</directory>
			</resource>
		</resources>
		
		<!-- Adicione o GMaven Plugin -->
		<plugins>
			<plugin>
				<groupId>org.codehaus.gmaven</groupId>
				<artifactId>gmaven-plugin</artifactId>
				<version>1.5</version>
				<configuration>
					<providerSelection>2.0</providerSelection>
				</configuration>
				
				<!-- Adicione as dependencias 'gmaven-runtime-2.0' e 'groovy-all' ao plugin -->
				<dependencies>
					<dependency>
						<groupId>org.codehaus.gmaven.runtime</groupId>
						<artifactId>gmaven-runtime-2.0</artifactId>
						<version>1.5</version>
					</dependency>
					<dependency>
						<groupId>org.codehaus.groovy</groupId>
						<artifactId>groovy-all</artifactId>
						<version>2.1.8</version>
					</dependency>
				</dependencies>
				
				<!-- Defina suas metas de execução -->
				<executions>
					<execution>
						<goals>
							<goal>generateStubs</goal>
							<goal>compile</goal>
							<goal>generateTestStubs</goal>
							<goal>testCompile</goal>
						</goals>
					</execution>
				</executions>
			</plugin>

			<!-- Adicione o plugin do 'spring-boot-maven-plugin' -->			
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
			
		</plugins>
	</build>

Caso você tenha dúvidas poderá se basear em um projeto completo no Github o Erudio API OAUTH2 utilizando essas tecnologias juntas. Lets Groovy guys, bons estudos.

Tags: , , , ,

Usando código Groovy (o Java com esteróides) juntamente com código Java

Existem várias maneiras de se usar Groovy junto ao seu código Java. As mais usadas são com Gradle e Maven. No maven podemos usar o GMaven ou o Groovy Eclipse compiler plugin. Pessoalmente eu uso este ultimo e segue abaixo as configurações básicas pra que você tenha todo poder do Groovy a seu dispor.

	
	<!-- Adicione o Groovy às dependências do seu projeto -->
	<dependencies>
            <dependency>
                <groupId>org.codehaus.groovy</groupId>
                <artifactId>groovy-all</artifactId>
                <version>2.1.6</version>
            </dependency>
	</dependencies>
		
			.
			.
			.		
		
	<!-- Será necessário fazer algumas mudanças no seu processo de build -->	
	<build>
	
			.
			.
			.	
			
        <plugins>        

			.
			.
			.			
        
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
				
				<!-- Adicione o Groovy Eclipse compiler as suas configurações -->
                <configuration>
                    <compilerId>groovy-eclipse-compiler</compilerId>
                    <source>1.6</source>
                    <target>1.6</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
				
				<!-- Adicione as dependencias 'groovy-eclipse-compiler' e 'groovy-eclipse-batch' -->
                <dependencies>
                    <dependency>
                        <groupId>org.codehaus.groovy</groupId>
                        <artifactId>groovy-eclipse-compiler</artifactId>
                        <version>2.8.0-01</version>
                    </dependency>
                    <dependency>
                        <groupId>org.codehaus.groovy</groupId>
                        <artifactId>groovy-eclipse-batch</artifactId>
                        <version>2.1.5-03</version>
                    </dependency>
                </dependencies>
            </plugin>
			
			<!-- Adicione o plugin 'groovy-eclipse-compiler' -->
            <plugin>
                <groupId>org.codehaus.groovy</groupId>
                <artifactId>groovy-eclipse-compiler</artifactId>
                <version>2.8.0-01</version>
                <extensions>true</extensions>
            </plugin>            
        </plugins>         
    </build>

Não lhe garanto que em alguns momentos você passará por frustrações, principalmente por causa do Eclipse. Mas lhe garanto que vale a pena.

Tags: , ,

Iniciando Se No JSF – 02 – Configurando O Ambiente E Criando O Primeiro Projeto

Nesse segundo post do Curso De JSF Do Zero À Nuvem Eu explico como instalar e configurar as duas IDE’s mais utilizadas no mercado, os plugins de versionamento e a criação do primeiro projeto.

Inicialmente explico onde baixar e como instalar a IDE Eclipse e os plugins EGit e Github MyLyn Connector para versionar o projeto no GitHub. É algo relativamente simples mas que pode ajudar muito alguém iniciante.


Instalando O Eclipse E Os Plugins m2eclipse, Subclipse E EGit





Posteriormente eu explico como instalar o Netbeans e configurar o Apache Tomcat. Diferentemente do Eclipse não é necessário instalar nenhum plugin.


Instalando O Netbeans E Configurando O Tomcat





Por fim criamos um repositório no GitHub e criamos nosso primeiro projeto.


Criando O Repositório E Iniciando O Projeto Maven



Observação importante:

Se você pretende trabalhar com o Eclipse ou mesmo com as duas IDE’s recomendo que você edite o POM e altere tudo que está entre as tags plugins de modo que fique igual ao trecho abaixo.

<plugins>           
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
            <source>1.6</source>
            <target>1.6</target>
            <encoding>${project.build.sourceEncoding}</encoding>
        </configuration>
    </plugin>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-war-plugin</artifactId>
        <configuration>
            <failOnMissingWebXml>false</failOnMissingWebXml>
        </configuration>
    </plugin>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-resources-plugin</artifactId>
        <configuration>
            <encoding>${project.build.sourceEncoding}</encoding>
        </configuration>
    </plugin>
</plugins>

No mais boa sorte e bons códigos sem bugs.

Tags: , , , ,

Iniciando Se No JSF – 01 – Apresentação, O Projeto E As Tecnologias

Olá. Este post é para apresentar o curso de JSF a vocês. Quando eu comecei a trabalhar com JSF eu usava apostilas na internet, video aulas no Youtube, livros e vivia correndo atrás de todo mundo que pudesse me ajudar a entender melhor o framework. Aprendi bastante de lá pra cá e como eu não posso retribuir diretamente a todos que me ajudaram nem outros que como eu hoje precisam de ajuda então decidi gravar uma série de video aulas a respeito. Creio que esse é a melhor forma de contribuir, e espero que ajude você a começar com JSF.

Além de JSF você aprenderá o básico de uma série de outras tecnologias que vão desde o Hibernate, Primefaces, Spring Security, Maven, Tomcat, Netbeans, Eclipse e além disso ao final do projeto você aprenderá como fazer o deploy na nuvem. No vídeo abaixo eu apresento o resultado final de todo o projeto e as tecnologias com as quais iremos trabalhar.


Curso De JSF Do Zero À Nuvem – O Projeto E As Tecnologias Envolvidas

No segundo vídeo você irá entender os principais conceitos teóricos do JSF. Além disso você terá dicas de por onde começar com o JSF.


Entendendo O JSF E Dicas

Além dos livros indicados no vídeo existem muitas apostilas gratuitas na web. Temos uma da Algaworks que apesar de abordar a versão 1.2 do JSF é bem interessante para quem está iniciando. Temos duas muito boas da K19 uma de JSF com JPA e outra de JSF com EJB a Caelum surpreendentemente não tem nada sobre o JSF talvez seja pra puchar a sardinha do VRaptor. Outras apostilas como a Do Luis Fernado e a do Diego Rezende que podem ser baixadas do Scribd. Além dessas uma rápida pesquisa no Google pode lhe mostrar uma infinidade de materiais a respeito. No Youtube além das minhas vídeo aulas existem outras que podem ajudar bastante quem está começando.

Se você quiser baixar os slides da apresentação basta ir ao SlideShare e fazer isso.

Quero destacar também que os fontes desse curso podem ser baixados do GitHub. Serão feitos posts correspondentes às video aulas e recomendo que você acompanhe por que assim que possível irei realizando posts para complementar o que foi falado nos vídeos.

Tags: , , , ,

Manipulando de Exceções no JavaServer Faces (JSF) 2.x

Uma das funcionalidades mais simples e legais introduzidas pela especificação 2.0 do JSF é a possibilidade de se criar um manipulador global de exceções. Trechos de código como esse aqui abaixo tratando as exceções previstas uma a uma no web.xml se tornaram desnecessários.

<error-page>
  <error-code>404</error-code>
  <location>/404.xhtml</location>
</error-page>

Ao invés da solução acima, o JavaServer Faces nos permite implementar um manipulador global de exceções de forma relativamente simples para todas as exceções que podem ocorrer na aplicação. Para isso, você precisa apenas de criar duas classes que estendam as classes:
ExceptionHandlerWrapper – Que fornece uma implementação simplificada da ExceptionHandler permitindo por exemplo que os desenvolvedores possam fornecer um comportamento especializado para uma instância ExceptionHandler.
ExceptionHandlerFactory – Essa classe por sua vez atua como uma Factory responsável por criar e retornar, quando necessário, uma nova instância de ExceptionHandler.
Por fim você precisa apenas algumas linhas ao arquivo “faces.config.xml” responsáveis por registrar a classe de tratamento no FacesServlet.

	
<factory>
  <exception-handler-factory>
     br.com.semeru.exceptions.CustomExceptionHandlerFactory
  </exception-handler-factory>
</factory>

No trecho de código abaixo temos a classe “CustomExceptionHandlerFactory” que é responsável por fabricar uma instância da classe “CustomExceptionHandler” que é responsável por capturar e tratar a exceção.

package br.com.semeru.exceptions;

import javax.faces.context.ExceptionHandler;
import javax.faces.context.ExceptionHandlerFactory;

public class CustomExceptionHandlerFactory extends ExceptionHandlerFactory {
    private ExceptionHandlerFactory parent;

    public CustomExceptionHandlerFactory(ExceptionHandlerFactory parent) {
        this.parent = parent;
    }

    @Override
    public ExceptionHandler getExceptionHandler() {
        ExceptionHandler handler = new CustomExceptionHandler(parent.getExceptionHandler());
        return handler;
    }

}

Já no trecho abaixo temos a classe “CustomExceptionHandler” que pode tratar a exceção da forma que você julgar mais apropriada. Você pode simplesmente imprimir a StackTrace e retornar uma página de erros, ou tratar as exceções que mais ocorrem e retornar uma página personalizada para cada uma delas. Outra coisa que pode ser interessante é enviar a StackTrace via e-mail para a equipe de desenvolvimento.

package br.com.semeru.exceptions;

//import java.io.PrintWriter;
//import java.io.StringWriter;
import java.util.Iterator;
import java.util.Map;
import javax.faces.FacesException;
import javax.faces.application.FacesMessage;
import javax.faces.application.NavigationHandler;
import javax.faces.context.ExceptionHandler;
import javax.faces.context.ExceptionHandlerWrapper;
import javax.faces.context.FacesContext;
import javax.faces.event.ExceptionQueuedEvent;
import javax.faces.event.ExceptionQueuedEventContext;

//Inicialmente devemos implementar a classe CustomExceptionHandler que extende a classe ExceptionHandlerWrapper
public class CustomExceptionHandler extends ExceptionHandlerWrapper {

    private ExceptionHandler wrapped;

    //Obtém uma instância do FacesContext
    final FacesContext facesContext = FacesContext.getCurrentInstance();

    //Obtém um mapa do FacesContext
    final Map requestMap = facesContext.getExternalContext().getRequestMap();

    //Obtém o estado atual da navegação entre páginas do JSF
    final NavigationHandler navigationHandler = facesContext.getApplication().getNavigationHandler();

    //Declara o construtor que recebe uma exceptio do tipo ExceptionHandler como parâmetro
    CustomExceptionHandler(ExceptionHandler exception) {
        this.wrapped = exception;
    }

    //Sobrescreve o método ExceptionHandler que retorna a "pilha" de exceções
    @Override
    public ExceptionHandler getWrapped() {
        return wrapped;
    }

    //Sobrescreve o método handle que é responsável por manipular as exceções do JSF
    @Override
    public void handle() throws FacesException {

        final Iterator iterator = getUnhandledExceptionQueuedEvents().iterator();
        while (iterator.hasNext()) {
            ExceptionQueuedEvent event = iterator.next();
            ExceptionQueuedEventContext context = (ExceptionQueuedEventContext) event.getSource();

            // Recupera a exceção do contexto
            Throwable exception = context.getException();

            // Aqui tentamos tratar a exeção
            try {

//                // Aqui você poderia por exemploinstanciar as classes StringWriter e PrintWriter
//                StringWriter stringWriter = new StringWriter();
//                // PrintWriter printWriter = new PrintWriter(stringWriter);
//                // exception.printStackTrace(printWriter);
//                // Por fim você pode converter a pilha de exceções em uma String
//                String message = stringWriter.toString();
//
//                // Aqui você poderia enviar um email com a StackTrace
//                // em anexo para a equipe de desenvolvimento
//
//                // e depois imprimir a stacktrace no log
//                exception.printStackTrace();

                // Coloca uma mensagem de exceção no mapa da request
                requestMap.put("exceptionMessage", exception.getMessage());

                // Avisa o usuário do erro
                FacesContext.getCurrentInstance().addMessage(null, new FacesMessage
                    (FacesMessage.SEVERITY_ERROR, "O sistema se recuperou de um erro inesperado.", ""));

                // Tranquiliza o usuário para que ele continue usando o sistema
                FacesContext.getCurrentInstance().addMessage(null, new FacesMessage
                    (FacesMessage.SEVERITY_INFO, "Você pode continuar usando o sistema normalmente!", ""));

                // Seta a navegação para uma página padrão.
                navigationHandler.handleNavigation(facesContext, null, "/restrict/home.faces");

                // Renderiza a pagina de erro e exibe as mensagens
                facesContext.renderResponse();
            } finally {
                // Remove a exeção da fila
                iterator.remove();
            }
        }
        // Manipula o erro
        getWrapped().handle();
    }
}

No bloco try-finally você pode converter o Throwable em qualquer exceção específica e dar um tratamento especial a cada uma delas. Um simples problema de ViewExpiredException, por exemplo, pode ser redirecionado para uma página informando que a “sessão expirou” já, no caso de uma exceção do tipo NullPointerException podemos usar uma página padrão apenas dizendo algo como “Ocorreu um erro inesperado, por favor, tente novamente mais tarde.”
Um detalhe muito importante a se lembrar é que ao lidar com exceções em desenvolvimento web, você deve garantir que não está compartilhando informações indesejadas e/ou sensíveis ao retornar o erro para a página web.

Bom é isso e espero que gostem do post.

Editado para responder ao comentário do André

Olá gravei uma vídeo aula explicando de forma clara como adotar o exception handler em um projeto JSF.

Tags: , , , , ,