Programas que eu gosto.

Sistema: Arch Linux.

 

 

Programas:

Vizualizar imagens: Gwenview

pacote: gwenview

 

Editor de texto: Kate

pacote: kate

 

Captura de tela: FlameShot

pacote: flameshot

 

Leitor de PDF: Okular

pacote: okular

Scanner: Simple Scan

pacote: simple-scan sane

Teclado virtual: Onboard

pacote: onboard

Comunicador: Telegram

pacote: telegram-desktop

 

Navegador: Vivaldi

pacote: vivaldi vivaldi-ffmpeg-codecs

Outros: system-config-printer

Todos: gwenview kate flameshot okular simple-scan sane onboard telegram-desktop vivaldi vivaldi-ffmpeg-codecs system-config-printer

Instalação do meu notebbok.

Notebook: Compaq Presario CQ 56.

Detalhes em October 14, 2020: 
Operating System: Arch Linux
KDE Plasma Version: 5.20.0
KDE Frameworks Version: 5.75.0
Qt Version: 5.15.1
Kernel Version: 5.8.14-arch1-1
OS Type: 64-bit
Processors: 2 × Pentium® Dual-Core CPU T4500 @ 2.30GHz
Memory: 3.7 GiB of RAM
Graphics Processor: Mesa DRI Mobile Intel® GM45 Express Chipset

Formatação / instalação:

September 17, 2020

iso: archlinux-2020.09.01-x86_64
05:39 PM - boot com o pendrive (início da instalação).

Verificar se tem acesso a internet:
~# ping google.com

Verificar os discos:
~# fdisk -l

/dev/sda1 80 Gb /a
/dev/sda2 210 Gb /home
/dev/sda3 8 Gb swap

Particionar:
~# cfdisk /dev/sda

Formatar:
~# mkfs.ext4 /dev/sda1

Montar a partição "/":
~# mount /dev/sda1 /mnt

Montar a partição "/home":
~# mkdir /mnt/home
~# mount /dev/sda2 /mnt/home

Ativar o swap:
~# swapon /dev/sda3

Editar o mirrorlist caso necessário:
~# nano /etc/pacman.d/mirrorlist

instalar o Arch:
~# pacstrap /mnt base linux linux-firmware base-devel

Criar arquivo fstab:
~# genfstab -U -p /mnt >> /mnt/etc/fstab
~# cat /mnt/etc/fstab

Alternar para o sistema novo:
~# arch-chroot /mnt

Configurar o timezone:
~# ln -sf /usr/share/zoneinfo/America/Sao_Paulo /etc/localtime

Sincronizar hora com a internet:
~# hwclock --systohc

Instalar nano:
~# pacman -S nano

Dar um nome para a máquina:
~# nano /etc/hostname
CQ56Arch

Configurar o arquivo hosts:
~# nano /etc/hosts
127.0.0.1 localhost
::1 localhost
127.0.1.1 CQ56Arch

Criar a senha do usuario root:
~# passwd

Adicionar o seu usuário:
~# useradd -m -g users -G wheel fercosmig

Criar a senha do seu usuário:
~# passwd fercosmig

Instalar ferramentas úteis:
~# pacman -S dosfstools os-prober mtools network-manager-applet networkmanager wpa_supplicant wireless_tools dialog sudo

Adicionar seu usuário no sudoers:
~# nano /etc/sudoers
# Adicionar texto abaixo no final do arquivo:
fercosmig ALL=(ALL) ALL

Instalar e configurar o grub:
~# pacman -S grub
~# grub-install --target=i386-pc --recheck /dev/sda
~# cp /usr/share/locale/en@quot/LC_MESSAGES/grub.mo /boot/grub/locale/en.mo
~# grub-mkconfig -o /boot/grub/grub.cfg

Sair:
~# exit

Remover o pendrive e reiniciar:
~# reboot

Iniciar configurações de rede:
~# systemctl enable NetworkManager
~# systemctl status NetworkManager
~# systemctl start NetworkManager

Testar configurações de rede:
~# ping google.com

Atualizar o sistema:
~# pacman -Sy

Instalar o xorg:
~# pacman -S xorg-server

Instalar drivers de vídeo:
~# pacman -S xf86-video-intel libgl mesa

Instalar e habilitar o SDDM:
~# pacman -S sddm
~# systemctl enable sddm

instalar o Plasma:
~# pacman -S plasma konsole dolphin

Reiniciar:
~# reboot

Instalar os navegares de sua preferencia:
~$ sudo pacman -S chromium firefox opera opera-ffmpeg-codecs

Pacote que faltou no discover:
~$ sudo pacman -S packagekit-qt5

Flatpak
~$ sudo pacman -S flatpak

GIT
~$ sudo pacman -S git

YAY - AUR helper:
~$ git clone https://aur.archlinux.org/yay.git
~$ cd yay
~$ makepkg -si

Timeshift
~$ yay -S timeshift

Pacote que faltou no timeshift:
~$ sudo pacman -S cronie

09:46 PM - Criado back-up com timeshift.

Telegram:
~$ sudo pacman -Ss telegram-desktop

Gwenview:
~$ sudo pacman -S gwenview

Spectacle:
~$ sudo pacman -S spectacle

Gimp:
~$ sudo pacman -S gimp

10:53 PM - Novo back-up timeshift.

VLC  - video player:
~$ sudo pacman -S vlc

Clementine - music player:
~$ sudo pacman -S clementine

KDE connect:
~$ sudo pacman -S kdeconnect
September 18, 2020

Editor de texto:
~$ sudo pacman -S kate

01:19 PM - Novo back-up timeshift.

Dependências do clementine:
$ sudo pacman -S gst-plugins-good gst-plugins-bad gst-plugins-ugly gst-libav gvfs

September 21, 2020

Leitor de PDF:
~$ sudo pacman -S okular

September 22, 2020

Calculadora
~$ sudo pacman -S kcalc

02:33 PM - Novo back-up timeshift.

September 23, 2020

LibreCAD
~$ sudo pacman -S librecad

September 29, 2020

Grub customizer
~$ sudo pacman -S grub-customizer

October 06, 2020

Interface RAR / ZIP:
~$ sudo pacman -S ark

October 09, 2020

Pacote office
~$ sudo pacman -S libreoffice-fresh

October 14, 2020

Java - JDK

~$ sudo pacman -S jdk-openjdk jre-openjdk

Visual Studio Code (vscode)

~$ sudo pacman -S code

October 15, 2020

Removendo o code

~$ sudo pacman -Rnsc code

Instalando o vscode

~$ yay -S visual-studio-code-bin

October 17, 2020

FreeCAD

~$ sudo pacman -S freecad

~$ sudo pacman -Rnsc freecad

October 18, 2020

FreeCAD

~$ sudo pacman -S freecad

23:48 PM - Novo back-up timeshift.

October 27, 2020

kdenlive

~$ sudo pacman -S kdenlive

November 25, 2020

Mapa de caracteres

sudo pacman -S kcharselect

December 24, 2020

Alternative AutoMate

sudo pacman -S xdotool

January 20, 2021

screenfetch & neofetch

sudo pacman -S screenfetch neofetch

February 5, 2021

Krita

sudo pacman -S krita

February 23, 2021

NodeJs

sudo pacman -S nodejs

npn

sudo pacmanc -S npm

Nativefier

sudo npm install nativefier -g

May 11, 2012

NTFS

sudo pacman -S ntfs-3g

Pen drive de boot.

Conecte o pendrive na sua máquina e execute o comando abaixo para saber qual o caminho do dispositivo:

sudo fdisk -l

No nosso exemplo, o pendrive reconhecido está localizado em /dev/sdb.

Depois de identificado o caminho do seu pendrive, vamos formatar o mesmo:

mkfs.vfat /dev/sdb

Relembrando que o caminho do pendrive pode variar conforme configuração da sua máquina.

Execute o comando abaixo para instalar a iso no pendrive:

dd if=local_da_imagem_iso of=/dev/sdb status=progress && sync

Para remover o pendrive com segurança, digite o comando:

umount /dev/sdb

Fonte: https://sempreupdate.com.br/como-criar-pendrive-de-boot-em-qualquer-distribuicao-linux/

YAY no Arch Linux - AUR

Para instalar o AUR Helper YAY no Arch Linux e derivados, você deve fazer o seguinte:

Passo 1. Abra um terminal;

Passo 2. Certifique-se de que seu sistema tem instalado o git e os pacotes da linguagem Go;

sudo pacman -S git go

Passo 3. Use o comando abaixo para baixar o código fonte do YAY;

git clone https://aur.archlinux.org/yay.git

Passo 4. Em seguida, acesse a pasta criada;

cd yay

Passo 5. Finalmente, use o comando abaixo para compilar e instalar o programa;

makepkg -si

Como usar o YAY?

O uso do YAY é semelhante a outros auxiliares e gerenciadores de pacotes do AUR.

Para instalar um pacote do utilitário YAY, execute o seguinte comando:

yay -s nome-do-pacote

Para procurar um pacote no AUR e no repositório oficial, execute o seguinte comando:

yay -Ss nome-do-pacote

Para ver as informações detalhadas sobre um determinado pacote:

yay -Si nome-do-pacote

Podemos pesquisar o pacote já instalado usando a seguinte opção:

yay -Qs nome-do-pacote

Para obter informações sobre o pacote instalado:

yay -Qi nome-do-pacote

Use o comando abaixo para atualizar qualquer pacote ou pacote no seu sistema:

yay -Syu

Para remover um pacote instalado com o yay:

yay -R nome-do-pacote

fonte: https://www.edivaldobrito.com.br/aur-helper-yay-no-arch-linux/

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.

VAPE KIT.

Comprei um kit que vou descrever aqui:


Sigelei Vcigo K3 Mod - Gun Metal

GeekVape Zeus RTA - Black

Sigelei Meteor Tank - Stainless

Demon Killer Prebuilt Coil Pack

Kendo Vape Cotton - Gold Edition (2 units)

Battery Imren IMR 18650 35A 2800 mAh flat top battery - 2 pack

Agora é só esperar chegar!

Comprei também 2 e-juices da Radiola, que já chegaram.

Perfect Day 3mg - 30ml

Strawberry Fields Forever 3mg - 30ml

É só aguardar!

e-Juice

Os juices podem ser comprados prontos ou feitos em casa.

Composição:

glicerina vegetal (VG) + propileno glicol (PG) + essência + nicotina.
A nicotina é opcional, é geralmente usada por fumantes e ex-fumantes.

Os ingredientes:

VG: Precisa ser bidestilada, de grau USP. Serve para produção de vapor.

PG: Precisa ser de grau USP. Serve para afinar o juice e fixar o sabor.

Essencias
Dá sabor ao e-juice. As essências nacionais possuem muito álcool, não prestam, dê preferência para importadas. Algumas marcas muito boas: TPA, FA, CAPELLA.
Existem essências com base em VG e outras com base em PG.

Tipos de essências:

• Aditivas - Tira a acidez.
• Frutadas - Sabor de frutas.
• Bebidas - Alcóolicas e não alcóolicas.
• Mentoladas - Menta.
• Doces - sobremesas, doces em geral.
• Atabacadas - gosto de cigarro.

Nicotina
Também com base em VG ou Base em PG. Existe com várias concentrações, de 30 a 100 mg / ml.
Independente de qual concentração você comprar, nos aplicativos que ajudam na receita de juice, você informa a concentração do seu produto que o aplicativo vai dosar corretamente sua nicotina.

Ideal é fazer o e-juice com 2 mg/ ml (igual a 1 maço de cigarros por dia).

O e-juice

Geralmente o juice é composto por 70% VG + 30% PG. Já vi para vender com 80% VG e 20% PG.

Quanto maior a porcentagem de VG mais vapor você terá.
Quanto maior a porcentagem de PG mais sabor você terá.

A essência, se for a base de VG, deve ser incorporada na porcentagem de VG, e se for a base de PG deve ser incorporada na porcentagem de PG, a nocotina é a mesma coisa.

Existem sites e aplicativos para android que fazem todo o calculo para você fazer seus e-juices, onde você fala os produtos que vai usar, a proporção que você quer, a quantidade total que quer fazer e o sistema passa para você a receita com as quantidades exatas de cada produto, com ou sem nicotina.

Android App - Vape Tools.

No Youtube tem vídeos mostrando como fazer:

Cigarros eletrônicos

O cigarro eletrônico é uma ótima opção para substituir os cigarros normais.

Como funciona:

O cigarro eletrônico possui uma resistência que vaporiza o seu e-juice. A nicotina está na composição do seu e-juice.

O e-juice é um liquido que pode ser comprado ou produzido por você, com as proporções que você desejar.

Com o cigarro eletrônico você pode aos poucos ir diminuindo a quantidade de nicotina dos seus e-juices.

No youtube existem vídeos do Dr. Drauzio Varella falando sobre o cigarro eletrônico e a nicotina. A nicotina não causa câncer, ela causa dependência, o que causa o câncer são os outros componentes do cigarro (alcatrão, monóxido de carbono e + 4700 substâncias tóxicas).

Por este motivo, os cigarros eletrônicos são considerados 95% menos prejudiciais que o cigarro comum. Os outros 5% ficam por conta da dependência da nicotina.

Algumas siglas:

VAPE - Vaporizador pessoal, personal vaporizer.

E-CIG - É o acrônimo para Eletrônic Cigarette, cigarro eletrônico, o mesmo que personal vaporizer, vaporizador pessoal.

E-LIQUID / E-JUICE - É o liquido responsável pela produção de vapor e aroma, nos e-cig.

O que compõe um VAPE:

Tipos de VAPE:

MTL - Mouth to lung.

Igual cigarro, puxa o vapor, traga e solta.

Encontrado em canetas vape, tipo cigarro mesmo.

DTL - Direct to lung.

Puxa direto para o pulmão, mais comum.

Tipos de atomizador:

Atomizador com coil substituível: é um dos mais comuns e geralmente possui uma manutenção mais simples. Nele, a coilhead – produzida industrialmente – deve ser substituída por uma nova após um determinado tempo de uso.

RTA: os Rebuildable Tank Atomizers podem ser reconstruídos sempre que estiverem muito desgastados. Não é uma tarefa tão simples construir uma nova coil, mas isso exige apenas um tipo específico de arame para fazer o resistor e material para fazer o pavio, que é o que fica embebido com o líquido. Pode ser um algodão especial, fio de sílica ou eco wool, uma espécie de lã de produção orgânica. A vantagem desse tipo de atomizador sobre o de coil substituível é que ele produz mais vapor e destaca melhor o sabor do líquido utilizado.

RDA: os Rebuildable Dripping Atomizers não possuem tanque de armazenamento para o líquido, pois você deve manualmente pingá-lo sobre a wick no resistor sempre que for vaporizar. São considerados os atomizadores que produzem o melhor sabor, mas não são tão práticos de usar.

RDTA: os Rebuildable Dripping Tank Atomizers são uma mistura dos dois tipos anteriores. Nele, o líquido é armazenado no tanque e você vai liberando-o aos poucos para que ele umedeça a coil e você possa vaporar.

Os MODs:

Os MODs contem as pilhas e os sistemas que controlam a energia enviada para as resistências (coil), conforme a configuração feita.