Criptografia MD5

package util;

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/**
 * Classe de criptografia.
 * O método getMD5 recebe uma string e devolve a mesma string criptografada em MD5.
 * Utilizado para verificar e salvar senhas no banco de dados.
 * 
 * sat, dec 14, 2019
 * @author Fernando Costa Migliorini
 * fercosmig@gmail.com
 */
public class Encryption {
private static final Logger LOGGER = LogManager.getLogger(Encryption.class.getName());

   /** Constructors */
   public Encryption() {
   }

   /** Methods */
   public static String getMD5(String input) {
      LOGGER.info("iniciando metodo getMD5");

      try {
         MessageDigest md = MessageDigest.getInstance("MD5");
         byte[] messageDigest = md.digest(input.getBytes());
         BigInteger num = new BigInteger(1, messageDigest);
         String hashText = num.toString(16);
         while (hashText.length() < 32) {
            hashText = "0" + hashText;
         }
         return hashText;
      } catch (NoSuchAlgorithmException e) {
         LOGGER.error(e);
         throw new RuntimeException(e);
      }
   }
}

LOG4J2

Dependências no pom.xml:

<!-- LOG4J2 -->
<!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-api -->
<dependency>
   <groupId>org.apache.logging.log4j</groupId>
   <artifactId>log4j-api</artifactId>
   <version>2.12.1</version>
</dependency>

<!-- LOG4J2 -->
<!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
<dependency>
   <groupId>org.apache.logging.log4j</groupId>
   <artifactId>log4j-core</artifactId>
   <version>2.12.1</version>
</dependency>

Arquivo log4j2.properties [src/main/resources/log4j2.properties]:

status = error

name = PropertiesConfig

filters = threshold

filter.threshold.type = ThresholdFilter

filter.threshold.level = debug

appenders = console

appender.console.type = Console

appender.console.name = STDOUT

appender.console.layout.type = PatternLayout

appender.console.layout.pattern = %d{MMM dd, yyyy HH:mm:ss} [%t] %-5level %logger:%L - %m%n

#TRACE < DEBUG < INFO < WARN < ERROR < FATAL 

rootLogger.level = debug

rootLogger.appenderRefs = stdout

rootLogger.appenderRef.stdout.ref = STDOUT

Exemplo de utilização:

package string;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

public class Test {

   private static final Logger LOGGER = LogManager.getLogger(Test.class.getName());

   public static void main(String[] args) {

      String msg = "Iniciando o método main da classe Test";

      LOGGER.debug(msg);

      LOGGER.info(msg);

      LOGGER.warn(msg);

      LOGGER.error(msg);

      LOGGER.fatal(msg);

   }

}

Só usar agora!

JPA - Java Persistence API

JPA

Entidades

Obrigatórios os métodos getters, setters, hashcode, equals e um construtor sem argumentos.

Anotações

@Entity - anota uma classe.
@Table - define o nome da tabela.
@Id - define um campo chave.
@GeneratedValue - autonumeração (@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column - Propriedades da coluna (@Column(name=”nome”, length = 60, nullable = false))
@Enumerated - Define um campo ENUM (@Enumerated(EnumType.STRING))
@Temporal - Define campo data (@Temporal(TemporalType.DATE))
@ManyToOne - Tipo de relacionamento entre tabelas (@ManyToOne(optional = false))
@JoinColumn -Nome da coluna do relacionamento (@JoinColumn(name = "entidade_id"))

Exemplo:
@Entity
@Table(name = "tbContato")
public class Contato {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Integer id;
   @Column(nullable = false)
   private String name;
   private String email;
   private String phone;
   @Column(nullable = false, insertable = false, updatable = true)
   private Boolean status;
   @Temporal(TemporalType.TIMESTAMP)
   @Column(nullable = false, insertable = false, updatable = false)
   private Date registrationDate;

persistence.xml

O arquivo persistence.xml deve ficar na pasta src/main/resources/META-INF, é criado automaticamente ao adicionar o Project Faces: JPA.

Configuração de uma conexão com o MySql no persistence.xml



<persistence-unit name="ProjetoPU">
   <provider>org.hibernate.ejb.HibernatePersistence</provider>
   <properties>
      <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost/banco" />
      <property name="javax.persistence.jdbc.user" value="usuario" />
      <property name="javax.persistence.jdbc.password" value="senha" />
      <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver" />
      <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />
      <property name="hibernate.show_sql" value="true" />
      <property name="hibernate.format_sql" value="true" />
      <property name="hibernate.hbm2ddl.auto" value="update" />
   </properties>
</persistence-unit>

Gerar tabelas no banco

import javax.persistence.Persistence;
public class CriaTabelas {
   public static void main(String[] args) {
      Persistence.createEntityManagerFactory("ProjetoPU");
   }
}

Classe responsável por fornecer uma instância do EntityManager:

package util;

import javax.persistence.EntityManager;

import javax.persistence.EntityManagerFactory;

import javax.persistence.Persistence;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class JPAUtil {

   private static final Logger LOGGER = LogManager.getLogger(JPAUtil.class.getName());

   private static EntityManagerFactory factory;
   static {
      LOGGER.info("Criando um objeto factory de testJPAPU.");
      factory = Persistence.createEntityManagerFactory("testJPAPU");
   }
   public static EntityManager getEntityManager() {
      LOGGER.info("Objeto factory retornando uma instância de EntityManager.");
      return factory.createEntityManager();
   }
   public static void close() {
      LOGGER.info("Fechando o objeto factory.");
      factory.close();
   }

}

JSF - Java Server Faces

JSF

Usado para trabalhar com MenagedBean, templates, EL / JSTL, MVC.

@ManagedBean - Escopos

@NoneScoped

O bean será instanciado a cada vez que for referenciado.

@RequestScoped

É o padrão, tem vida curta, começando quando é referenciado em uma única requisição HTTP e terminando quando a resposta é enviada de volta ao cliente.

@ViewScoped

A instância permanece ativa até que o usuário navegue para uma próxima página.

@SessionScoped

Mantém a instância durante diversas requisições e até mesmo navegações entre páginas, até que a sessão do usuário seja invalidada ou o tempo limite é atingido. Cada usuário possui sua sessão de navegação, portanto, os objetos não são compartilhados entre os usuários.

@ApplicationScoped

Mantém a instância durante todo o tempo de execução da aplicação. É um escopo que compartilha os

objetos para todos os usuários do sistema.

Ciclo de vida dos componentes do JSF

Restaurar visão

Aplicar valores de requisição

Processar validações

Atualizar os valores do modelo

Invocar a aplicação

Renderizar a resposta

Arquivo de configuração: faces-config.xml

Local do arquivo: src/main/webapp/WEB-INF

JSF: https://javaee.github.io/javaserverfaces-spec/

Bibliotecas de componentes de interface

Ao criar uma página xhtml, usamos o cabeçalho abaixo para definir as bibliotecas do JSF que iremos

utilizar.

Core: (:f) suporte às outras bibliotecas, não possui componentes visuais.

HTML: (:h) formulários.

Facelets: (:ui) para criação de templates de páginas.

Composite: (:composite) usada para criar componentes customizados.

<html xmlns="http://www.w3.org/1999/xhtml"
   xmlns:f="http://xmlns.jcp.org/jsf/core"   xmlns:h="http://xmlns.jcp.org/jsf/html"   xmlns:ui="http://xmlns.jcp.org/jsf/facelets"   xmlns:composite="http://xmlns.jcp.org/jsf/composite">

Layout

O JSF permite que você trabalhe com um layout para não ficar repetindo códigos de cabeçalho e rodapé em todas as páginas.

Devemos criar um arquivo layout.xhtml na pasta: “webapp/WEB-INF/template” do projeto.

Exemplo de arquivo de layout:

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:f="http://xmlns.jcp.org/jsf/core"
xmlns:h="http://xmlns.jcp.org/jsf/html"
xmlns:ui="http://xmlns.jcp.org/jsf/facelets">
<h:head>
<!-- Utilize a “ui” dentro do “<title>” para alterar o título da janela. -->
<title><ui:insert name="titulo">Login</ui:insert></title>
<!-- Utilize a “ui” dentro do “<head>” para adicionar arquivos e scripts. -->
<ui:insert name="head"></ui:insert>
</h:head>
<h:body>
<header>
<h:graphicImage library="images" name="fcm.png" />
</header>
<div id="conteudo">
<!-- Utilize a “ui” dentro da “<div>” para inserir o conteudo da página. -->
<ui:insert name="conteudo"></ui:insert>
</div>
<footer>
<hr />
Login - Developed by .:: Fer Cos Mig ::.
</footer>
</h:body>
</html>

Exemplo de utilização do layout:

<!DOCTYPE html>
<ui:composition template="/WEB-INF/template/layout.xhtml"
xmlns="http://www.w3.org/1999/xhtml"
xmlns:f="http://xmlns.jcp.org/jsf/core"
xmlns:h="http://xmlns.jcp.org/jsf/html"
xmlns:ui="http://xmlns.jcp.org/jsf/facelets">
<ui:define name="titulo">Login - Daily</ui:define>
<ui:define name="head">
<h:outputStylesheet library="css" name="estilos.css" />
<h:outputScript library="js" name="scripts.js" target="head" />
</ui:define>
<ui:define name="conteudo">
<h:form id="frmLogin">
<h:panelGrid columns="2">
<f:facet name="header">
<h:outputText value="Formulário de login" />
</f:facet>
<h:outputLabel value="Nome de usuário: " for="username" />
<h:inputText id="username" />
<h:outputLabel value="Senha do usuário: " for="password" />
<h:inputSecret id="password" />
<h:outputLabel />
<h:commandButton id="btnEnviar" value="Enviar"/>
</h:panelGrid>
<h:messages />
</h:form>
</ui:define>
</ui:composition>

Repositorio de arquivos / library

Usando JSF você pode criar um repositório de arquivos, para isso, crie dentro da pasta “webapp” uma pasta chamada “resources”, dentro da pasta resources você pode criar pastas para imagens, css, javascript, etc... 

Exemplo de utilização, imagine que temos tres pastas, uma images, uma css e uma js, podemos usar da

seguinte forma:

<h:outputStylesheet library="css" name="estilos.css" />
<h:outputScript library="js" name="scripts.js" target="head" />
<h:graphicImage library="images" name="fcm.png" />

Backing bean

Criar os objetos do HTML no Bean como atributos, inclusive com getters e setters para que pelo java você possa alterar as propriedades do objeto:

private HtmlInputText inputNome;
private HtmlCommandButton botaoAdicionar;

Adicionar propriedade binding:
<h:inputText value="#{nomesBean.nome}" binding="#{nomesBean.inputNome}" />

Maven - pom.xml

Maven

pom.xml

Configurar encoding UTF-8

<!-- configurando UTF-8 -->
<properties>
   <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

Configurar versão do java

<!-- Configurando versão do Java -->
<build>
   <plugins>
      <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
         <version>3.8.1</version>
         <configuration>
            <release>13</release>
         </configuration>
      </plugin>
   </plugins>
</build>

Personalizando o Eclipse

Personalizando o Eclipse

Número de colunas

Abra o menu Window e clique em preferences, na caixa de busca digite "Formatter", selecione a opção:

Java -> Code Style -> Formatter.

Na aba Formatter selecione 'New', digite o nome do seu novo profile e em seguida selecione "Edit". Na próxima janela, são mostradas as opções de formatação automática. Selecione a opção "Line Wrapping" e digite na caixa "Maximum Line Width" o comprimento máximo que você deseja para suas linhas. O valor padrão é 80, mas você pode aumentar a seu gosto.

Autor no JAVADOC

Para alterar o valor padrão da propriedade @author no Eclipse basta simplesmente editar o arquivo eclipse.ini que se encontra na pasta raiz do eclipse com o valor seguinte (adicionar no final do arquivo):

-Duser.name=NovoNomeDoAutor

Customizar template do JAVADOC

Abra o menu Window e clique em preferences, na caixa de busca digite "code templates" abra a opção “comments” e “selection types”.

Veja um exemplo abaixo:

/**
* @autor ${user}
* @since ${date}b${year}
* ${file_name}
* ${tags}
* /

Linguagem JAVA

Linguagem Java

Modificadores

Public

Pode ser acessada de qualquer lugar e por qualquer entidade que possa visualizar a classe a qual ela pertence.

Private

Não se aplica a classes, somente a métodos e atributos. Indica que um método ou atributo é usado somente dentro da classe criada. Estes atributos e métodos não serão visualizados em classes herdadas.

Protected

Pode ser acessada por classes do mesmo pacotes ou herdadas.

Final

Uma classe com o modificador final não pode ser estendida, isto é, não podem ter classes que herdam dela.

Um método com o modificador final não pode ser sobrescrito nas subclasses.

Um atributo com o modificador final pode ter seu valor atribuído uma única vez, não pode ser modificado.

Static

Classes static são classes declaradas dentro de outra classe que podem ser usadas sem a necessidade de uma instância.

Métodos static podem ser chamados sem uma instância.

Os atributos definidos como static possuem um único valor para todas as instâncias criadas do objeto.

Classes Abstratas

São usadas para padronizar as classes filhas, usamos o modificador "abstract" na declaração da classe, a classe abstrata não pode ser instanciada.

Exemplos:

Classe Pessoa (não pode ser instanciada).

Abstract class Pessoa{
   private Int id;
   private String nome;

   // métodos getters and setters
}

Classe PessoaFisica (estende a classe pai Pessoa)

public class PessoaFisica extends Pessoa{
   private String CPF;

   /** Construtor */
   public PessoaFisica(Int id, String nome, String CPF){
      super.setId(id);
      super.setNome(nome);
      this.CPF = CPF;
   }
}

Classe PessoaJuridica (extende a classe pai Pessoa)

public class PessoaJuridica extends Pessoa{
   private String CNPJ;

   /** Construtor */
   public PessoaJuridica(Int id, String nome, String CNPJ){
      super.setId(id);
      super.setNome(nome);
      this.CNPJ = CNPJ;
   }
}

Interfaces

É um recurso utilizado no JAVA para "obrigar" um determinado grupo de classes a ter métodos ou propriedades em comum, mesmo que os métodos forem implementados de uma forma diferente em cada uma delas.

JAVA - Definições

JAVA

Java é uma linguagem de programação orientada a objetos.

JAVA EE

É uma plataforma padrão com várias especificações para desenvolver aplicações JAVA.

Segue abaixo algumas especificações/tecnologias do JAVA EE:

Servlets

São componentes Java executados no servidor para gerar conteúdo dinâmico para a web, como HTML e XML.

JSP

JavaServer Pages é uma especialização de Servlets que permite que aplicações web desenvolvidas em Java sejam mais fáceis de manter. É similar a tecnologias como ASP e PHP.

JSF

JavaServer Faces é um framework web baseado em Java que utiliza um modelo de interfaces gráficas

baseado em eventos. JSF é baseado no padrão de projeto MVC (Model View Controller).

A JSF foi criada através do Java Community Process (JCP), que é uma entidade formada pelas mais importantes empresas de tecnologia do mundo e especialistas em diversos assuntos.

A implementação do JSF mais conhecida atualmente é a Mojarra.

JPA

Java Persistence API é uma API padrão do Java para persistência de dados, que usa um conceito de mapeamento objeto-relacional.

EJB

Enterprise Java Beans são componentes que executam em servidores de aplicação e possuem como principais objetivos, fornecer facilidade e produtividade no desenvolvimento de componentes distribuídos, transacionados, seguros e portáveis.

Hibernate

É um framework que possui vários módulos, por exemplo, o Hibernate EntityManager, que é a implementação do JPA.

Primefaces

É um framework para desenvolvimento JAVA, com uma enorme biblioteca de componentes de interface gráfica para as aplicações web baseadas em JSF.

CDI

É uma especificação do JAVA EE 6 que cuida da parte de injeção de dependências.

Spring MVC

É um framework MVC (model - view - controller).

JSTL

JavaServer Pages Standard Template Library, usado para facilitar a utilização de conteúdo dinâmico nas páginas web, trocando o código JAVA por tags. Fornece bibliotecas de tags, EL (Expression Language).

IDE

Integrated Development Environment. Ambiente de desenvolvimento integrado.

Eclipse

IDE desenvolvida pela IBM e doada para a comunidade como software livre.

Netbeans

IDE desenvolvida pela comunidade, comprada pela SUN, atualmente Oracle, hoje possui código aberto e é atualizada pela comunidade.

IntelliJ IDEA

IDE desenvolvida e mantida por uma empresa chamada JetBrains, possui uma versão ultimate que é paga, porém tem também uma versão livre para a comunidade.

GIT HUB

GIT

Instalação

sudo apt-get install git

Configuração

Variáveis globais do GIT com username e e-mail.

git config --global user.name "alfredo"
git config --global user.email alfredo@gmail.com

Para verificar as suas configurações do GIT uso o comando:

git config --list

Novo repositório

Ao criarmos um novo repositório no site github.com, o mesmo vai nos fornecer o endereço do repositório, para configurarmos na pasta do nosso projeto. Exemplo:

https://github.com/fercosmig/nome_do_repositorio.git.

Entrar na pasta do projeto pelo terminal e executar os comandos:

git init
git status

Verificar arquivos desnecessários, e criar um arquivo .gitignore:

nano .gitignore

Digite dentro do arquivo aberto no nano o nome das pastas e arquivos desnecessários para o projeto no GitHub, exemplo:

.classpath
.project
.settings
target/

Salve o arquivo e agora execute o comando abaixo para ver a diferença:

git status

Upload de arquivos

Adicionar os arquivos que não foram colocados no .gitignore para upload.

git add --all

Primeiro commit

git commit -m "Primeiro commit, subindo um novo projeto ao GitHub"

Informamos ao git qual é o nosso repositório, usando o endereço fornecido pelo GitHub.

git remote add origin https://github.com/fercosmig/nome_repositorio.git

Vamos subir o projeto para a web/GitHub.

git push -u origin master

Atualizando o projeto no GitHub

Abra o terminal, entre na pasta do projeto e digitar os comandos abaixo:

git status
git add --all
git status
git commit -m 'mensagem'
git push origin master

Pronto, seu projeto já está no GitHub.

Command INXI

Informações sobre o sistema / computador

 $ sudo inxi -F  

O parâmetro F é de FULL, traz todas as informações coletadas pelo comando inxi.

OCTOPI x PAMAC

Manjaro - Trocar Octopi pelo Pamac

Instalar o Pamac:

$ sudo pacman -S pamac-gtk pamac-tray-appindicator

Remover o Octopi:

$ sudo pacman -R octopi octopi-notifier-frameworks

Fonte: https://manjariando.wordpress.com/2018/04/10/o-poderoso-pamac-no-manjaro-kde/

Comando uteis

Alguns comando que eu uso regularmente.

 $ iw dev  
Exibe a interface de comunicação ativa


 $ iw dev <interface> link   
Exibe detalhes da rede wi-fi, sinal, etc...


 $ systemctl stop NetworkManager.service   
 $ systemctl start NetworkManager.service   
 $ systemctl restart NetworkManager.service   
Comandos para "parar", "iniciar" e "reiniciar" o serviço de rede.

 $ sudo pacman -Syyu   
Atualiza o sistema.