Desenvolvimento de sistemas

 

 

Introdução a Programação


 

  • Conceitos
    • Algoritmo lógico → instruções ordenadas de forma compreensível;
    • Programa de computador
      • formulação concreta de algoritmos abstratos e estrutura de dados;
      • conjunto de instruções executadas por um processador com finalidade definida;
    • Lógica de programação → estudo das leis de raciocínio e seu modo de aplicação;
    • Linguagem de máquina → linguagem de operação (reconhecida e executada) do processador;
    • Compilador → traduz um programa escrito em linguagem de alto nível em um programa (módulo) objeto (não executável)
    • Linker (editor de ligação) → gera um programa executável a partir de um mais módulos objeto;
  • Algoritmo → sequencia finita e efetiva de passos (ou instruções), descritos em ordem lógica, e atingir objetivos bem definidos;  cada passo deve ser rigorosamente definido a fim de evitar ambiguidade;
    • Identificador → é o nome iniciado por letra;
    • Constante → é um determinado valor que não se modifica;
    • Variável → corresponde a uma área de memória a qual atribuímos um identificador;
    • Atribuição → armazena um valor em uma variável (←);
    • Operadores
      • Aritméticos (resultado numérico): adição (+), subtração (–), multiplicação (*), divisão (/), exponenciação (** ou ^) e menos unário (-);
      • Relacionais (resultado lógico): igual (=), diferente (<>, ≠ ou !=), maior que (>), menor que (<), maior ou igual (>= ou ≥) e menor ou igual (<= ou ≤);
      • Lógicos (resultado lógico): conjunção (e, &&), disjunção (ou, ||) e negação (não, !)
      • Atenção: tratando-se de algoritmos, são aceitos: ≠, ≥, ≤, e, ou, não;
    • Prioridade → parêntesis, funções, menos unário, ^, * e /, + e –, relacionais, não, e, ou.
    • Estrutura
      • algoritmo nome
      • <declarações (variáveis, constantes, módulos)>
      • início
      • <comandos>
        • leia(var a, …,  var n);
        • imprima ou escreva(‘mensagem’, var a);
        • se <condição>
          • então <comando 1> # estrutura condicional simples
            • <comando n>
          • senão <comando 1> # estrutura condicional composta
            • <comando n>
        • fimse
        • enquanto <condição> faça # estrutura de repetição
          • <comando 1>
          • <comando n>
        • fimenquanto
        • repita
          • <comando 1>
          • <comando n>
        • até <condição>
      • fim

 

Orientação a objetos

 

  • Conceitos
    • Classe → representam um modelo comum para entidades semelhantes, e genérico a um grupo de objetos com mesma característica;
    • Instância (objeto) → representam entidades individualizadas, são membros ou exemplos da classe, podem executar seus métodos, e armazenam um estado;
      • Identidade → cada objeto possui um identificador que o distingue e permite seu endereçamento;
      • Atributos → são as propriedades encapsuladas para o registro de informações, ocultas do acesso externo (encapsulamento);
        • Multiplicidade → indica a dimensão de atributos do tipo matrizes e vetores (valores[5], matriz[2,4];
        • Tipo → indica o formato, tipos padrões (int, double, float) ou outras classes;
        • Valor inicial → indica o conteúdo do atributo após sua criação (int = 10);
        • Propriedades → indica comentário ({transiente});
      • Comportamentos → conjunto de habilidades de processamento descritas por uma ou mais funções;
        • Visibilidade → (+) públicos, (-) privados, (#) protegidos;
        • Nome → identificação exclusiva;
        • Parâmetros → passagem de valores para sua execução, seu tipo e valor padrão;
        • Valor de retorno → tipo do dado retornado ao fim da execução;
  • Princípios
    • Encapsulamento
      • Capacidade de ocultar atributos e implementação dos métodos;
      • Possibilita a visão apenas de métodos públicos ou protegidos às subclasses;
    • Agregação (relação Todo/Parte)
      • Mecanismo de reaproveitamento de classes (aumentar qualidade e produtividade);
      • Quando uma classe (A) é faz referência (composta) a outras classes (B);
      • Agregação por composição♦→ Se a classe B existir especificamente para atender a classe A (ex: A→nota fiscal e B→tipos de nota fiscal);
      • Agregação por associação (compartilhada) → Se a classe B puder ser usada por outras classes distintas de A (ex: A→time de futebol e B→pessoa);
    • Herança
      • Reaproveitamento de atributos e métodos, e diminuição das linhas de código do sistema;
      • Superclasse ou classe mãe (genérica) → classe que foi herdada;
      • Subclasse (especializada) → classe que herdou outra;
    • Polimorfismo
      • Comportamento distinto do método herdado, reimplementação.
      • Polimorfismo de sobrecarga → típico de métodos construtores, onde o comportamento é definido pela quantidade e tipo dos argumentos utilizados na chamada;
      • Polimorfismo de sobreposição → típico de herança onde há a reimplementação do método de mesmo nome;
      • Classe abstrata → representa um conjunto de características, que não pode ser instanciada;
      • Casting → utilizado para forçar uma classe apresentar outra estrutura compatível, quando houver métodos comuns;

 

Java


 

  • Java → uma linguagem de programação de alto nível e fornece um conjunto de componentes multiplataforma (plataforma de desenvolvimento);
    • Orientada a objetos;
    • Arquitetura neutra;
    • Portável;
    • Distribuída;
    • Alto desempenho;
    • Multi-threads;
    • Robusta → suporta sistemas altamente complexos;
    • Dinâmica → tipagem dinâmica;
    • Segura → controles nativos;
  • Fases do programa Java (ECOCAVEX)

    • Edição → escrita do código java (.java);
    • Compilação → geração do bytecode (.class);
    • Carregamento → carrega os bytecodes na memória principal;
    • Verificação → confirma se todos os bytecodes carregados são válidos e não violam restrições de segurança;
    • Execução → tradução dos bytecodes para linguagem de máquina;
  • Conceitos
    • Plataforma
      • combinação entre um ambiente de software e/ou hardware;
    • Plataforma Java
      • o ambiente de software é composto pela  JVM, APIs e bibliotecas de componentes;
    • Java
      • linguagem de programação que permite o desenvolvimento de aplicações para diversos sistemas operacionais;
    • JSR
      • documentos formais que descrevem as especificações e tecnologias da plataforma Java;
    • JSE (Java Standard Edition)
      • voltada para o desenvolvimento de aplicações desktop com interfaces (Swing, awt, prompt);
      • possui gerenciamento de memória embutida (coleta de lixo);
      • especificação base para a JEE e JME;
    • JEE (Java Enterprise Edition)
      • extensão do JSE voltada para o desenvolvimento de aplicações distribuídas para internet e intranet;
      • tecnologias voltados para o servidor de aplicação;
      • faz uso de anotações para prover informações dos descritores de implantação;
      • Profile → subconjuntos de tecnologias suportadas (web, application server, etc);
      • Containers → aplicação cliente, applet, web e EJB;
    • JME (Java Micro Edition)
      • ambiente de desenvolvimento de aplicações para dispositivos móveis;
    • JDK (Java development kit) → conjunto de ferramentas pra o desenvolvimento de aplicações, inclui a JRE;
      • javac → compilador, transforma o código-fonte .java em bytecode .class;
      • jar → empacotador de aplicações;
      • javadoc → compilador de documentação de código;
    • JRE (Java runtime environment)
      • plataforma Java composta por JVM e APIs, utilizadas na máquinas para interpretação e execução dos bytecodes (.class);
    • JVM (Java virtual machine)
      • responsável por interpretar e executar o bytecode;
      • provê meios de comunicação entre o aplicativo e o sistema operacional;pode ser desenvolvida a partir de especificações JCP;
    • Padrão de projeto MVC → separa o sistema em três responsabilidades;
      • Modelo → representa os objetos de negócio e mantém o estado do negócio;
      • Visão → responsável pela interface com o usuário;
      • Controlador → responsável por ligar o modelo a sua visualização;

 

Servidores de Aplicação

 

  • Conceitos
    • fornece um ambiente para instalação e execução de certas aplicações de forma centralizada;
    • fornece um ambiente de tempo de execução para o desenvolvimento e execução múltiplas aplicações de forma escalável, confiável e multicamadas;
    • dispensa a instalação da aplicação nos computadores clientes;
    • provê recursos (APIs) de uso comum, como segurança, transação, integração com o back-end, balanceamento de carga, etc;
    • abstrai do desenvolvedor do software algumas complexidades de um sistema computacional por meio da implementação de APIs;
  • Pacotes → os descritores de implantação são opcionais, exceto o web.xml, sendo obrigatório pelo especificação Servlet;
    • .jar → java archive, usado para bibliotecas, EJBs (ejb-jar.xml) ou aplicações desktop (application-client.xml);
      • META-INF/manifest.mf → arquivo opcional que especifica a classe Main, inclusive dependências e pode conter a assinatura ou checksum;
        • Manifest-Version: 1.0
        • Created-By: 1.2 (Sun Microsystems Inc.)
        • Signature-Version: 1.0
        • Class-Path: MyUtils.jar
        • Main-Class: com.example.MyClassName
      • META-INF/example.sf → arquivo gerado para cada entidade que assinou o pacote (pode ser utilizado o comando jarsigner);
        • Signature-Version: 1.0
        • MD5-Digest-Manifest-Main-Attributes: (base64 representation of MD5 digest)
        • Name: common/class1.class
        • MD5-Digest: (base64 representation of MD5 digest)
      • META-INF/example.dsa → bloco de assinatura gerado pela chave privada do assinante;
      • META-INF/example.rsa → certificado que contém a chave pública do assinante, para que qualquer um possa verificar a assinatura;
    • .war → web archive, usado para aplicações web, cuja a estrutura de organização dos arquivos é denominada web module;
      • WEB-INF/web.xmldescritor de implantação de aplicação web que indica parâmetros de inicialização e restrições de segurança;
      • WEB-INF/lib → pacotes (.jar) carregados para o classloader, não sendo necessários incluídos na opção Class-Path do manifest.mf;
      • WEB-INF/classes →classes do web module; atualização das classes implantadas por pacote war requerem a implantação de todo o pacote;
    • .ear → enterprise archive, usado para um conjunto de módulos;
      • META-INF/application.xml → lista os módulos do pacote com seus respectivos tipos (java, ejb, web);
    • .rar → resource adapter (ra.xml), usados para conectores JCA;
  • Apache
    • Conceitos
      • servidor HTTP (pode ser referenciado como servidor web) que provê conteúdo estático e, por meio de módulos (cgi/php), conteúdo dinâmico;
    • Módulos
      • diretiva Directory → utilizado para agrupar diretivas para um diretório;
        • Order Deny,Allow → avalia as regras Allow, depois as Deny, sendo que a regra padrão é permitir;
        • Order Allow,Deny → avalia as regras Deny, depois as Allow, sendo que a regra padrão é negar;
  • Tomcat
    • Conceitos
      • servidor web (servidor de aplicações Java para a web) que implementa o container web (container Servlet) e o servidor HTTP;
      • o container web permite executar aplicações baseadas em Servlets e JSP que recebem requisições e constroem páginas HTML;
      • tem a capacidade de atuar como servidor HTTP autônomo ou ainda como parte de um servidor de aplicações como o JBoss;
      • inclui tecnologias como Realms (controle da autenticação e autorização pelo servidor), JNDI e JDBC;
      • processa o arquivo META-INF/context.xml dos pacotes de aplicação como descritor de contexto (de implantação em runtime);
      • Tomcat Manager (role manager-gui) é uma aplicação web que permite listar, parar, iniciar, recarregar e despublicar as aplicações instanciadas;
      • Host Manager (role admin-gui) é uma aplicação web que permite criar, parar, iniciar e remover virtual hosts associados a uma aplicação;
    • TOMCAT_HOME → variável de ambiente com o caminho do diretório raiz do Tomcat;
      • /bin
        • /startup.sh → script simplificado de inicialização que executa: catalina.sh start “$@”; aceita a opção -security para ativar o Security Manager;
        • /shutdown.sh → script simplificado de parada que executa: catalina.sh stop “$@”; aceita as opções n (inteiro em segundos antes do kill) e -force;
        • /catalina.sh → script de controle que aceitas os parâmetros: debug, jpda start, run (foregroud), start (backgroud), stop [n] [-force], configtest;
      • /conf
        • /catalina.policy → políticas de segurança aplicadas pela JVM para acesso a propriedades, sockets e classes (grant e permission);
        • /catalina.properties → propriedades do servido web, de JarScanner e de pacote protegidos de alterações em Runtime;
        • /server.xml → tags: Listener, GlobalNamingResources, Service{Connector, Engine{Realm,Host,Valve}};
        • /tomcat-users.xml → tags: role, user; usuários associados a role manager-gui não devem possuir as roles manager-script e manager-jmx;
          • admin-gui → role que permite acesso ao Host Manager;
          • manager-gui → role que permite o acesso ao Tomcat Manager HTML e a página de status;
          • manager-script → role que permite o acesso a interface de texto e a página de status;
          • manager-jmx → role que permite acesso ao proxy JMX e a página de status;
          • manager-status → role que permite acesso somente a página de status;
      • /logs → arquivos de logs;
      • /lib → bibliotecas;
      • /webapps → publicação de aplicações (deploy); uma aplicação /wepapps/exemplo.war será extraída para /webapps/exemplo;
  • JBoss AS

    • Conceitos
      • servidor de aplicações corporativas (JEE) que implementa o container web e o container EJB para invocação de métodos remotos;
      • executa o processamento de requisições simultâneas com multithread e contém recursos transacionais e integração ao banco de dados;
      • clusterizadas (replicação de estado) com balanceamento de carga (distribuição de requisições) e fail-over (desabilita nós indisponíveis);
      • permite reinstalação dinâmica (hot deploy) para a atualização de aplicações sem reiniciar o serviço;
      • realiza o desligamento limpo ao aguardar o término do processamento para finalizar o processo;
      • fornece um serviço de mensagens para sistemas fracamente acoplados;
      • gerencia o ciclo de vida dos objetos (criação e destruição de objetos conforme a demanda) e o pool de objetos (reutilização);
      • recursos de autenticação e autorização para controlar e executar operações permitidas, com suporte a autenticação LDAP;
      • fornece recursos para monitoração de cada aplicação (JMX) e registro de logs e auditoria;
    • Termos
      • Classloader → especifica de dependência explícita entre módulos e é organizado de forma hierárquica para isolar as aplicações;
      • Extensões → módulos que estendem as funcionalidades do servidor de aplicação (org.jboss.as.weld, org.jboss.as.webservices, etc);
      • Profiles → um nome para um conjunto de extensões (default, full, ha, full-ha);
      • Path → um nome para um caminho do sistema de arquivos (jboss.home, jboss.server.base.dir, etc);
      • Interface → um nome para uma interface de rede;
      • Socket-biding → um nome para uma porta;
    • Domain → gerenciamento centralizado de múltiplas instâncias (não está relacionado a adição de capacidades ou funcionalidades);
      • Domain Controller → serviço http na porta 9990;
        • é uma instância do Host Controller que atua como master (host-master.xml); tag “domain-controller” tem valor “local”;
        • utiliza a porta 9999 como “native-interface” para receber conexões dos slaves;
        • permite o gerenciamento centralizado de diversos Host Controllers e o controla o ciclo de vida das instâncias do servidor de aplicação;
        • compartilha configurações (domain.xml) para todos os servidores de aplicação do domínio;
        • não há vantagem em sua utilização em um único servidor;
      • Host Controller
        • é uma instância que atua como slave, tag “domain-controller” tem valor “remote”, em cada máquina que interage com o Domain Controller;
        • auxilia o Domain Controller no gerenciamento, iniciando e parando as instâncias do servidor de aplicação;
        • há uma senha para a comunicação (host-slave.xml) na tag “server-identities” e “secret”;
        • compartilha configurações (host.xml) para todos os servidores de aplicação do host, ao combiná-las com as configurações do domínio (domain.xml);
      • Server Group
        • são definidos no Domain Controller e associados a um profile, a configuração de jvm, de socket-binding-group e de deployments;
        • conjunto de servidores de aplicação em uma ou mais máquinas são associados a um grupo;
      • Application Server
        • há zero, uma ou mais instâncias em cada máquina, que podem pertencer a distintos grupos;
        • cada instância é membro de um grupo que utilizam as configurações definidas no Domain Controller;
        • somente o Host Controller pode iniciar uma instância, não sendo possível iniciá-la por linha de comando;
    • JBOSS_HOME → variável de ambiente com o caminho do diretório raiz do JBoss;
      • /bin
        • /standalone.sh –server-config=standalone-ha.xml → modo standalone; pode-se usar -c;
        • /domain.sh –domain-config=domain.xml → modo domain; pode-se usar -c;
        • /jboss-cli.sh → interface de linha de comando;
          • cn/cd, connect, deploy, history, ls, pwn/pwd, undeploy;
          • add-jms-queue, remove-jms-queue, add-jms-topic, remove-jms-topic, add-jms-cf, remove-jms-cf, data-source, xa-data-source;
      • /docs
      • /modules
      • /standalone
        • /configuration/standalone.xml → tags: extensions (carregar módulos/subsystems), management, profile (conjunto de extensões), interface, socket-binding-group;
        • /configuration/standalone-full.xml → inicia o serviço de mensagens HornetQ;
        • /configuration/standalone-ha.xml → inicia o mod_cluster e replicação de cache (infinispan);
        • /configuration/standalone-full-ha.xml → combina os dois anteriores;
        • /deployments → publicação de aplicações (deploy);
        • /lib/ext
      • /domain
        • /configuration/domain.xml → configuração do Domain Controller; tags: extensions, management, profiles, interfaces, socket-binding-groups, server-groups;
        • /configuration/host.xml → configuração do Host Controller (host-master.xml, host-slave.xml); tags: management, domain-controller, interfaces, interfaces, jvms, servers;
        • /data/content → publicação de aplicações (deploy);
        • /lib/ext
  • Tecnologias
    • Renderização de componentes web
      • Java Servlets;
        • compilada, carregada e inicializada pelo container web;
      • Java Server Pages (JSP);
        • transforma-se em uma Servlet;
      • Java Server Faces (JSF);
        • tecnologia para desenvolvimento web, com interfaces gráficas e eventos;
        • define a forma que os dados são apresentados e encaminha as ações do usuário para o controlador;
    • Transações e objetos distribuídos
      • Java Database Connectivity API (JDBC) → API de baixo nível que permite o acesso a banco de dados;
      • Java Persistence API (JPA) → padroniza o acesso a banco de dados;
      • Java Transaction API (JTA) → padroniza o uso de transações distribuídas;
      • Enterprise Java Beans (EJB) → padroniza a invocação métodos remotos;
        • provê o gerenciamento de Transações, Persistência, Ciclo de vida e Segurança;
      • Java Connector Architecture (JCA) → arquitetura genérica para conexões que especifica contratos para:
        • Gerenciamento de conexões → permite a utilização de um pool de conexões;
        • Gerenciamento de transações → permite transações entre vários gerenciadores de recursos;
        • Gerenciamento da segurança → protege classes relevantes para mitigar de ameaças aos recursos;
        • Gerenciamento do ciclo de vida → controle da inicialização de resource adapters e notificação para desligamento limpo;
        • Gerenciamento de threads (work) → controle de pool de threads para a execução de atividades submetidas;
        • Gerenciamento de fluxo de transação → controle da passagem de transações entre entidades;
        • Gerenciamento de fluxo de mensagens → entrega assíncrona de mensagens;
    • WebServices e Arquivos XML
      • Java API for XML Binding (JAX-B);
      • Java API for XML Web Services (JAX-WS);
      • Java API for RESTful Services (JAX-RS);
    • Mensagens assíncronas (JSR 343) → Java Message Service (JMS);
      • Conceitos
        • permite criar, enviar, receber e ler mensagens de forma fracamente acoplada;
        • destinatário não precisa ser identificado ou estar disponível;
        • o processamento pode continuar após o envio da mensagem, sem aguardar uma resposta;
      • Provedor → controlador das mensagens ou adaptador de middleware (HornetQ para JBoss);
      • Cliente → aplicação que envia ou recebe mensagens;
      • Produtor → aplicação que cria e envia a mensagem ao provedor;
      • Consumidor → aplicação que recebe a mensagem do provedor, de forma síncrona ou assíncrona de filas ou tópicos;
      • Objetos administrados → configurados e gerenciados pelo JBoss, usados pelos clientes e acessíveis por JNDI;
        • fábrica de conexões → objeto utilizado para obter acesso ao provedor;
        • destino → objeto do provedor criado para cada fila ou tópico (queue ou topic) para receber e encaminhar as mensagens;
      • Fila (queue) → modelo ponto a ponto;
        • mensagens disponíveis no provedor, sem ordem específica, para serem recebidas por um único consumidor;
        • mensagens não consumidas podem ser expiradas;
        • há notificação do produtor (acknowledged) que a mensagem foi recebida;
      • Tópico (topic) → modelo produtor/assinante;
        • distribuição de mensagens a vários assinantes (subscriber) que fazem o papel de consumidor;
        • em tópicos não-duráveis os assinantes só recebem as mensagens enquanto estiverem conectados ao provedor;
    • Interface para acesso a objetos nomeados
      • Java Naming and Direcotry Interface (JNDI);
    • Extensão para monitoramento de aplicação → Java Management Extensions (JMX);
      • Conceitos
        • permite a coleta de informações (getter) e a configuração de parâmetros (setter) de recursos gerenciados (por uma classe MBean) de forma remota;
        • utiliza uma interface e respectiva implementação para acesso aos recursos gerenciados (quaisquer informações) de aplicações, dispositivos, etc;
        • a instância pode enviar notificações (mudança de estado, evento, etc) ao implementar a interface NotificationBroadcaster ou NotificationEmitter;
        • as notificações possuem um número de sequência e são identificadas pelo nome do MBean registrado no MBeanServer;
        • podem ser criadas anotações para a adição de metadados ao MBean, derivadas de @DescriptorKey, como descritores da interface e de métodos;
      • Instrumentação (instrumentation) → cria-se uma interface e implementação (MBean/ManageBean) que permite acesso a recursos gerenciáveis;
        • Standard MBeans
          • define-se uma interface com getters/setters de atributos, operações (métodos) e notificações para acesso aos recursos gerenciados;
          • a interface não necessita estender alguma interface específica, salvo quando for requerido o envio de notificações;
          • public interface HelloMBean { public void sayHello(); public int add(int x, int y); public String getName(); }
        • Dynamic MBeans
          • usado quando a interface não é conhecida em tempo de compilação;
          • estende a interface DynamicMBean que possui métodos para armazenar atributos genéricos (Object);
        • Open MBeans
          • são Dynamic MBeans cujos atributos são limitados aos objetos de tipos primitivos, String, CompositeData, TabularData e ObjectName;
        • Model MBeans
          • são Dynamic MBeans que podem ser configurados em tempo de execução;
          • permite expor métodos de objetos que não são MBeans;
        • MXBeans
          • MBean que permite retornar quaisquer objetos em vez de tipos nativos;
      • Agente JMX → conjunto de instâncias de MBeans registradas no MBeanServer e disponíveis para gerenciamento remoto;
        • Agent Services
          • expõe objetos (counter(int), gauge(int,float), string(str), timers, etc) que podem realizar operações nos MBeans registrados;
        • MBeanServer
          • expõe os MBeans para acesso remoto;
        • Exemplo de registro do MBean (na aplicação que proverá informações)
          • MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
          • mbs.registerMBean(new Hello(), new ObjectName(“com.example:type=Hello”));
          • Thread.sleep(Long.MAX_VALUE);
        • Executando a aplicação
          • noauth=“-Dcom.sun.management.jmxremote.authenticate=false”
          • nossl=“-Dcom.sun.management.jmxremote.ssl=false”
          • java -Dcom.sun.management.jmxremote.port=9999 $noauth $nossl com.example.Main
      • Gerenciamento remoto → utiliza conectores JMX para acesso ao agente JMX e gerenciamento dos recursos por meio de MBeans;
        • Adaptador
          • provê uma visão de todos os MBeans registrados por meio de um protocolo específico, como SNMP ou web HTML;
        • Conector
          • provê uma interface de comunicação da aplicação de gerenciamento para o MBeanServer para cada protocolo (RMI, IIOP, JMS);
          • a JSE provê conector RMI nativo que permite a chamada de métodos do MBean remoto como se estivesse executando localmente;
          • um conector de servidor deve estar associado ao MBeanServer para aguardar por conexões;
          • um conector de cliente deve ser utilizado pela aplicação de gerenciamento remoto para realizar conexões;
        • Exemplo do acesso remoto ao MBean (na aplicação remota)

          • JMXServiceURL url = new JMXServiceURL(“service:jmx:rmi:///jndi/rmi://:9999/jmxrmi”);
          • JMXConnector jmxc = JMXConnectorFactory.connect(url, null);
          • MBeanServerConnection mbsc = jmxc.getMBeanServerConnection();
          • HelloMBean mbeanProxy = JMX.newMBeanProxy(mbsc, new ObjectName(“com.example:type=Hello”), HelloMBean.class, true);
    • Autenticação e autorização
      • Java Authentication and Authorization Service (JAAS);

 

XML – eXtensible Markup Language


 

  • Conceitos
    • linguagem para a definição, representação, armazenamento e intercâmbio de conteúdo para qualquer fim (e não para exibição);
    • não especifica elementos (tags), sendo definidos (inventadas) pelo usuário (autor do documento XML);
    • foco na corretude e validação da sintaxe em que erros podem impedir a troca de informações;
    • não possui informações sobre como o conteúdo será apresentado (separação total entre o conteúdo e a apresentação);
  • Definições
    • Linguagem de Marcação eXtensível
      • estrutura a informação de forma hierárquica (aninhamento) por meio de elementos (tags) que descrevem seu conteúdo (metadados);
      • deve haver um único elemento raiz, e;
      • os elementos devem estar corretamente aninhados (<pessoa><nome>Rei</nome></pessoa>) tornando o documento “Bem-formado“;
      • “Bem-formado” representa sintaxe correta que não abrange “validação” ou “namespaces”, relacionados com DTD e XSD;
    • prólogo
      • define a versão e a codificação do documento XML (declaração XML);
      • opcional e não faz parte da árvore e do documento XML;
      • se o prólogo existir, deve ser a primeira linha do documento e deve possuir o atributo ‘version’;
      • o atributo ‘enconding’ é opcional, e se existir, deve ser o próximo ao atributo ‘version’;
      • o atributo ‘standalone’ é opcional, e indica se o documento XML depende de algum recurso externo;
      • <?xml version=“1.0” encoding=“UTF-8”?>
      • <?xml-stylesheet href=“my-style.css”?>
    • doctype
      • define o DTD para validação do documento;
      • deve ser a linha após o prólogo;
      • é opcional e não faz parte da árvore e do documento XML;
      • se existir, deve referenciar, pelo menos, o elemento raiz;
      • <!DOCTYPE myxml >
    • comentário
      • não pode possuir ‘–‘ entre ‘<!–‘ e ‘–>’
      • não pode estar dentro do nome do elemento (<tag<!– …)
      • <!– comentário –>
    • elementos
      • são auto descritivos e tem papel de metadado por descreverem o conteúdo armazenado;
      • marcação completa → utiliza elementos antes (<nome>) e depois (</nome) da informação não vazia ou elementos vazios (<casado />);
      • é ilegal omitir o fechamento do elemento;
      • são case sensitive;
    • atributos
      • complementam a descrição da informação armazenada no elemento e são recomendados para metadados (id=”100″);
      • não há regras para representação de informação como atributo ou elemento;
      • o valor dos atributos devem estar sempre entre “aspas”, ‘apóstrofos’, “aspas ‘usadas’ externamente” ou “apóstrofos &quot;usados&quot; assim”;
      • um atributo não podem ter múltiplos valores (elementos podem);
      • atributos não podem ter valores em árvore (elementos podem);
      • atributos não são facilmente extensíveis em mudanças futuras;
    • conteúdo
      • informação entre tags;
      • espaços não são truncados (xml:space);
      • quebras de linhas são armazenados como LF independentemente do sistema operacional;
    • entidade
      • utilizado para referência a textos repetidos ou caracteres que não podem ser incluídos diretamente;
      • <!DOCTYPE myxml [
        • <!ENTITY coffe “café”>
      • ]>
      • entidades pré-definidas
        • &lt; → <
        • &gt; → >
        • &amp; → &
        • &quot; → “
        • &apos; → ‘
        • &coffe; → café;
      • < e & são estritamente ilegais em conteúdo de elementos XML;
  • Práticas de nomenclatura de elementos e atributos

    • devem iniciar com uma letra ou underscore;
    • podem conter letras, números, hifens, underscores e pontos;
    • caracteres acentuados são válidos, mas alguns softwares podem não suportá-los;
    • não podem iniciar com ‘xml’, ‘XML’, ‘Xml’, etc;
    • não podem conter espaços;
    • usar nomes descritivos, curtos e simples, como: <nome>, <sobrenome> e <idade>;
    • evitar “-“, alguns softwares podem realizar a operação de subtração;
    • evitar “.”, alguns softwares podem referenciar propriedades de um objeto (pessoa.idade);
    • evitar “:”, são reservados para namespaces;
    • não há um estilo de nomenclatura definido (lower case, upper case, pascal case ou camel case), mas após escolhido deve ser único (consistente);
  • Validação → conjunto de regras opcionais (DTD ou XSD) para verificação do documento XML;
    • permite que um grupo de pessoas concordem com um padrão de elementos para a troca de dados;
    • recomenda-se elaborá-lo, se for necessário, quando a especificação do XML estiver estável (poucas mudanças no elementos);
    • $ xmllint –noout –valid my.xml
    • Document Type Definition (DTD) → define a estrutura do documento XML com a lista dos elementos e atributos válidos;
      • DTD externa → em arquivo separado e reutilizável;
        • myxml.xml
          • <?xml version=“1.0” encoding=“UTF-8” standalone=“no” ?>
          • <!DOCTYPE myxml SYSTEM “Myxml.dtd”>
          • <myxml>
            • <pessoa id=”a100″>
              • <nome sexo=”M”>Rei</nome>
              • <idade>33</idade>
              • <flag/>
            • </pessoa>
            • <pessoa id=”a101″ parent=”a100″>
              • <nome sexo=”F”>Beka</nome>
              • <idade>2</idade>
            • </pessoa>
          • </myxml>
        • Myxml.dtd
          • <!ELEMENT myxml (pessoa+)>                              <!– uma ou mais repetições –>
          • <!ELEMENT pessoa (nome, idade?, flag?)>        <!– ordem de elementos (idade e flag opcionais) –>
          • <!ELEMENT nome (#PCDATA)>                            <!– um elemento nome do tipo parsed data –>
          • <!ELEMENT idade (#PCDATA)>                             <!– parsed data expande entidades definidas –>
          • <!ELEMENT flag EMPTY>                                        <!– elemento vazio –>
          • <!ATTLIST pessoa
          •       id ID #REQUIRED                                                <!– tipo ID, identificar único (requerida) –>
          •       status (important|normal) “normal”                    <!– lista com valor padrão “normal” –>
          •       parent IDREF #IMPLIED                                      <!– tipo IDREF, um ID de outro atributo (opcional) –>
          •       child IDREFS #IMPLIED>                                    <!– tipo IDREFS, IDs separados por espaço (opcional) –>
          • <!ATTLIST nome sexo CDATA #REQUIRED>      <!– unparsed data não expande entidades definidas –>
      • DTD interna → definida dentro do documento XML para regras específicas ao documento e não reutilizáveis;
        • <?xml version=”1.0″ encoding=”UTF-8″ standalone=”yes” ?>
        • <!DOCTYPE myxml [
          • <!ELEMENT myxml (pessoa*)>                 <!– zero ou mais repetições –>
          • <!ELEMENT pessoa (nome, idade?)>      <!– ordem de elementos (zero ou um elemento idade) –>
          • <!ELEMENT nome (#PCDATA)>
          • <!ELEMENT idade (#PCDATA)>
        • ]>
        • <myxml>
          • <pessoa> …
    • XML Schema Definition (XSD) → usa a linguagem XML para definir a estrutura e suporta namespaces e restrições de tipo de dado (mais recursos que o DTD);
      • Elementos simples → não possuem atributos ou elementos aninhados (filho);
      • Elementos complexos (compostos) → possuem atributos ou elementos aninhados (filhos);
      • Tipos internos de dados → xs:string, xs:integer, xs:decimal, xs:boolean, xs:date e xs:time;
      • <?xml version=”1.0″ encoding=”UTF-8″ ?>
      • <xs:schema xmlns:xs=“http://www.w3.org/2011/XMLSchema”>
        • <xs:element name=”myxml”>
          • <xs:complexType>
            • <xs:sequence> <!– <xs:all> para não impor a ordem –>
              • <xs:element name=”nome” default=”noname”>
                • <xs:simpleType>
                  • <xs:restriction base=”xs:string”>
                    • <xs:minLength value=”3″ />
                    • <xs:maxLength value=”100″ />
                  • </xs:restriction>
                • </xs:simpleType>
              • </xs:element>
              • <xs:element name=”idade”>
                • <xs:simpleType>
                  • <xs:restriction base=”xs:integer”>
                    • <xs:minInclusive value=”0″ />
                    • <xs:maxInclusive value=”150″ />
                  • </xs:restriction>
                • </xs:simpleType>
              • </xs:element>
              • <xs:element name=”cpf”>
                • <xs:simpleType>
                  • <xs:restriction base=”xs:integer”>
                    • <xs:length value=”11″ />
                  • </xs:restriction>
                • </xs:simpleType>
              • </xs:element>
              • <xs:element name=”sexo” />
                • <xs:simpleType>
                  • <xs:restriction base=”xs:string”>
                    • <xs:enumeration value=”Masculino” />
                    • <xs:enumeration value=”Feminino” />
                  • </xs:restriction>
                • </xs:simpleType>
              • </xs:element>
              • <xs:element name=”blog” />
                • <xs:simpleType>
                  • <xs:restriction base=”xs:string”>
                    • <xs:pattern value=”^(http|www)” />
                  • </xs:restriction>
                • </xs:simpleType>
              • </xs:element>
            • </xs:sequence>
          • </xs:complexType>
        • </xs:element>
      • </xs:schema>
  • Namespaces → permite utilizar elementos de distintos XML Schemas (XSDs);
    • <myxml xmlns:p=”http://example.org/pns ” xmlns:q=”http://example.org/qns “>
      • <p:pessoa id=”a100″>
        • <p:nome>Reinaldo</p:nome>
      • </p:pessoa>
      • <q:pessoa id=”a100″>
        • <q:nick>Rei</p:nick>
      • </q:pessoa>
    • </myxml>
    • Namespace padrão → <myxml xmlns=”http://example.org/pns “>
    • Extendendo um namespace
    • Qualificador do namespace → exigir ou não o uso de namespace para elementos ou atributos;
      • elementFormDefault=”qualified” → todos os elementos (globais e locais) devem ser qualificados com um namespace;
      • elementFormDefault=”unqualified” → os elementos globais devem ser qualificados com um namespace;
      • attributeFormDefault=”qualified” → todos os atributos (globais e locais) devem ser qualificados com um namespace;
      • attributeFormDefault=”unqualified” → todos os atributos (globais e locais) não precisam ser qualificados com um namespace;

 

HTML5


 

  • Visão geral

    • W3C (World Wide Web Consortium)
      • consórcio internacional de organizações para o desenvolvimento de especificações técnicas (padrões, protocolos e diretrizes);
      • garantir o crescimento de longo prazo da Web;
      • um processo que maximiza o consenso entre as comunidades de desenvolvedores e do público em geral;
      • recomenda padrões comuns e independentes de tecnologia, como HTML 4.01 e HTML 5 (note o espaço), svg, png e xml;
    • W3C-WAI (Web Accessibility Initiative)
      • WAI desenvolve estratégias, diretrizes e recursos para ajudar a fazer a Web acessível;
      • WCAG 2.0 (Web Content Accessibility Guidelines) é um conjunto de diretrizes e padrões para a acessibilidade do conteúdo web;
      • objetiva atender às necessidades de indivíduos e organizações;
      • a acessibilidade envolve perceber, entender, navegar e interagir com a Web;
      • design inclusivo abrangem pessoas com necessidades especiais e aqueles não incluídos à tecnologia (idosos, WAI-AGE);
    • WHATWG (Web Hypertext Application Technology Working Group)
      • grupo de trabalho (Apple, Mozilla e Opera) criado para acelerar o lento avanço dos padrões da Web;
      • propuseram as especificações do HTML5 a fim de contrapor a adoção do XHTML pelo W3C;
      • Web Workers define a API para ativar ECMAScript (JavaScript) para utilização eficiente de CPUs multi-core;
      • WebForm 2.0, que foi incluído na especificação HTML5 e WebControls 1.0;
    • HTML5
      • HTML5 aprimora a WEB (3.0) com marcação semântica para a compreensão por máquinas;
      • linguagem para a formatação e apresentação de conteúdo de páginas web;
      • linguagem de marcação, apresentação e estruturação de conteúdo em hypertexto;
      • hypertexto permite a interligação de documentos web de forma não linear, com utilização de hiperlinks;
      • especifica um conjunto definido de elementos (tags) e atributos para a configuração de páginas web;
      • foco na melhor exibição possível em caso de erros da estruturação dos elementos;
    • Modelo de conteúdo HTML5
      • define o tipo de conteúdo esperado para cada elemento (tag) e classifica em categorias;
      • cada elemento pertence a uma ou mais categorias;
      • Categorias → metadados, fluxo, seção, cabeçalhos, frase, incorporado, interativo e formulário;
    • SGML
      • metalinguagem usada para definir linguagens de marcação, usada como base para o HTML 4.01;
      • HTML5 não é baseado em SGML e não necessita referenciar um DTD;
    • DOCTYPE
      • não é tag HTML; indica a linguagem, e sua versão, de um documento; primeira linha de código, antes da tag <html>;
      • HTML4.01 → <!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.01//EN” “http://www.w3.org/TR/html4/strict.dtd”>
      • HTML5 → <!DOCTYPE html>
    • meta
      • descreve características da página no elemento <head>;
      • HTML4.01 → <meta http-equiv=“Content-Type” content=“text/html”; charset=“UTF-8”>
      • HTML5 → <meta charset=“UTF-8”>; indica a tabela de tradução de caractere que deve ser utilizada no documento;
  • Elementos existentes no HTML 4.01

    • html → delimita todo o código HTML (conjunto hierárquico de tags);
    • head →contém elementos não visuais (codificação, título, JavaScript, CSS, …);
      • meta charset=“utf-8” → codificação da página;
      • link rel=“icon” href=“favicon.png” → adiciona ícone ao site;
      • link rel=“stylesheet” type=“text/css” href=“style.css” → inclui um estilo CSS ao site;
      • title → título da página ou da aba do navegador;
    • body → contém elementos visuais, como conteúdo e propriedades;
      • tabindex → atributo que define a ordem de navegação pelo teclado e tornar o elemento selecionável;
      • title → atributo com conteúdo que é exibido quando o mouse está sobre o elemento;
    • h1 até h6 → cabeçalhos ou títulos de seções do texto; níveis de h1 (maior fonte) a h6 (menor fonte);
    • p → parágrafo;
    • link → conexão entre o documento e recursos externos e hyperlinks, dos seguintes tipos;
      • alternate, author, help, icon, license, next, prev, prefetch, search, stylesheet;
    • ul → lista não ordenada;
    • ol → lista ordenada;
    • dl → lista informações de uma entidade;
    • li → item da lista;
    • img → insere imagem na página;
      • src → caminho da imagem (obrigatório);
      • alt → texto descritivo da imagem para deficientes e macanismos de busca (obrigatório);
      • width → largura da imagem;
      • height → altura da imagem;
    • a → link para a própria página ou para outra (link → bookmark, nofollow, noreferrer, tag);
      • href → endereço completo ou relativo do link para outra página;
      • name → âncora para a própria página;
    • table → tabela; controle da borda das células: border-collapse: separate; border-spacing: 5px;
      • colgroup → agrupa elementos <col> para aplicar estilos em colunas (usado antes de thead, tbody ou tfoot);
      • col → define propriedades de estilo para colunas (atributos style e span);
      • thead → cabeçalho da tabela (contém tr e th); não afeta o layout por padrão;
      • tbody → conteúdo da tabela (contém tr e td); não afeta o layout por padrão;
      • tfoot → rodapé da tabela (contém tr e td); não afeta o layout por padrão;
      • tr → linha da tabela;
      • th → célula de cabeçalho linhas ou colunas iniciais;
      • td → célula de conteúdo da linha;
        • colspan → célula pode ocupar mais de uma coluna;
        • rowspan → célula pode ocupar mais de uma linha;
    • q → texto entre aspas;
    • b → negrito;
    • sub → subscrito, texto abaixo;
    • sup → sobrescrito, texto acima;
    • blockquote → define um texto que é uma citação de outra fonte;
  • Atributos globais → podem ser usados em todos os elementos (tags) da html5, inclusive de elementos da html4;
    • accesskey → tecla de atalho (ctrl+shift+atalho ou número) para ativar/focus um elemento;
    • class → associa uma folha de estilo a um elemento;
    • contenteditable → indica se o conteúdo do elemento é editável ou não;
    • contextmenu → associa um menu de contexto ao elemento (clique botão direito);
    • data-* → usado para armazenar dados privados da página ou da aplicação;
    • dir → direção da escrita do texto (ltr, rtl);
    • draggable → torna o elemento arrastável (true, false, auto);
    • dropzone → indica o tipo de conteúdo que pode ser arrastável para determinado elemento (copy, move, link);
    • hidden → indica se o elemento deverá ou não estar visível ao usuário;
    • id → identifica unicamente um elemento em um documento (deve conter ao menos um caractere e não pode possuir espaço);
    • itemid, itemprop, itemref, itemscope, itemtype → adição semântica para robôs de indexação (WHATWG microdata);
    • lang → indica o idioma do conteúdo do elemento (BCP47);
    • spellcheck → indica que o elemento pode ser corrigido ortograficamente;
    • style → declara regras de estilo diretamente ao elemento;
    • tabindex → define a ordem de navegação pelo teclado e tornar o elemento selecionável;
    • title → informação adicional sobre o elemento (pode ser apresentada como tooltip ao usuário);
    • translate → indica se o valores e conteúdos dos elementos devem ser traduzidos;
  • Elementos com nova definição no HTML5
    • i → não necessarimente representa itálico, pode ser usado para formatar o texto;
    • u → define um texto que deve ser estilisticamente difrente do normal, como erros ortográficos;
    • s → define um texto que não está mais correto;
    • cite → define o nome de uma trabalho (livro, artigo);
  • Elementos removidos ou substituídos no HTML5

    • acronym → substituído por abbr (abreviação de palavra ou acrônimo);
    • applet → substituído por object;
    • dir → substituído por ul;
    • center → substituído por CSS (centralizar texto);
    • basefont → substituído por CSS (cor ou tamanho padrão do texto);
    • font → substituído por CSS (tipo, tamanho ou cor do texto);
    • big → substituído por CSS (texto maior que o normal);
    • strike → substituído por CSS (texto rasurado);
    • tt → substituído por CSS (fonte monospace);
    • frame → removida;
    • frameset → removida;
    • noframes → removida;
  • Elementos do HTML5

    • main → semântica para definir o conteúdo principal do documento;
    • nav → semântica para agrupar quaisquer links de navegação da página;
    • section → semântica para definir uma seção da página;
    • header → semântica para definir o cabeçalho de um elemento, como da seção ou da página;
    • footer → semântica para definir o rodapé de um elemento, como da seção ou da página;
    • article → semântica para definir um conteúdo independente, autosuficiente e completo (faz sentido por si só);
    • aside → semântica para definir um conteúdo secundário, separado e relacionado a página;
      • em forma de barra lateral (textos adicionais, anúncios de publicidade, grupo de <nav>);
      • caso omitido, não prejudica o entendimento do conteúdo da página;
    • figure → container para conteúdos independentes e relacionados (imagens, gráficos, vídeos, etc) no fluxo do documento;
    • figcaption → legenda de um elemento <figure>;
      • <figure>
        • <img src=”html.png” alt=”html5″>
        • <figcaption>Apredendo html5</figcaption>
      • </figure>
    • hgroup → agrupa elementos <h1>/<h6>;
    • time → semântica para datas (atributo datetime);
    • mark → destaca um texto relevante com finalidade de referência;
    • wbr → possível quebra de linha;
    • bdi → uma parte do texto que pode ser formatada em direção diferente;
    • details → fornece informações adicionais ao conteúdo da página que o usuário pode visualizar ou esconder;
    • summary → fornece rótulos com sumário sobre as informações adicionais do details;
    • dialog → caixa de diálogo ou janela;
    • menu → container para elementos command;
    • command → identificar um comando evocado pelo usuário por meio de menu de contexto ou barra de ferramentas;
      • possui atributos type, label, icon, disabled, checked e title;
      • <command type=”radio” radiogroup=”arquivo” label=”Abrir”>
    • menuitem → um item de menu ou de comando que pode ser invocado por um popup;
    • meter → indica um valor de um intervalo escalar conhecido;
    • progress → indica o progresso de uma tarefa;
    • ruby → define anotação para pronúncia correta do texto (tipografia da Ásia Oriental);
    • rp → texto a ser exibido quando o navegador não suporta anotações <ruby>;
    • rt → texto com explicação dos caracteres da tipografia da Ásia Oriental;
  • Elementos de formulário
    • form → define um formulário;
    • fieldset → agrupa campos de entrada de dados e rótulos (labels);
      • legend → descrição do conjunto de campos;
    • label → rótulo da entrada de dados (for=”inputid”);
    • input → entrada de dados com controles interativos, usabilidade e validação a partir de sua semântica;
      • type=”radio” → define a semântica da entrada de dados;
        • HTML4.01 → button, checkbox, file, hidden, image, password, radio, reset, submit, text;
        • HTML5 → color, date, datetime-local, email, month, number, range, search, tel, time, url, week;
      • name=”nome1″ → identifica a entrada (deve ser o mesmo para um conjunto de radio);
      • placeholder=”explicação” → exemplo ou dica de preenchimento da entrada;
      • required → o campo deve ser preenchido;
      • autofocus → define a entrada de dados inicial para o cursor;
      • autocomplete → permite que o navegador exiba valores já utilizados;
      • pattern → validação por expressão regular;
      • multiple → permite valores múltiplos separados por vírgula ou envio de múltiplos arquivos;
      • min, max, step → validação para números e datas (mínimo, máximo e intervalo);
      • HTML4.01 → accept, alt (type=”image”), checked, disabled, maxlenght, readonly, size, src (type=”image”);
      • HTML5 → dirname, form, formaction, formenctype, formmethod, formnovalidate, formtarget, height, width, list;
    • textarea → entrada de dados multilinha de texto (cols=”40″ rows=”10″);
    • select → entrada de dados a partir da seleção em uma lista;
      • option → item da lista;
    • button → botão para envio do formulário;
      • type=”submit” → define o tipo para envio do formulário;
    • datalist → opções pré-definidas para inputs (faixa de valores);
      • <label for=”ano”>Ano:</label>
      • <input type=”text” list=”anos” id=”ano”>
      • <datalist id=”anos”>
        • <option value=”2014″>
        • <option value=”2015″>
        • <option value=”2016″>
      • </datalist>
    • keygen → manipulação de chaves criptográficas para autenticação no envio de formulários;
    • output → container para um resultado calculado;
  • Elementos gráficos
    • canvas → determina uma área para criação de bitmaps dinâmicos, como imagens, gráficos estáticos e dinâmicos e jogos;
      • <canvas id=”exemplo” width=”200″ height=”200″>
        • <p>texto para navegadores sem suporte a canvas</p>
      • </canvas>
      • // javascript
        • var ctx = document.getElementById(“exemplo”).getContext(“2d”)
        • ctx.fillStyle = “rgb(200,0,0)”;
        • ctx.fillRect(10,10,120,80);
    • svg → linguagem XML que descreve gráficos bidimensionais, estáticos, dinâmicos; vetorial e independente de resolução; suporta eventos;
      • <svg width=”200″ height=”200″>
        • <circle cx=”80″ cy=”80″ r=”60″ stroke=”red” stroke-width=”7″ fill=”green” />
      • </svg>
      • <svg width=”200″ height=”100″>
        • <rect width=”200″ height=”100″ style=”fill:rgb(200,0,0);stroke-width:7;stroke:rgb(0,120,0)” />
      • </svg>
      • <svg width=”200″ height=”200″>
        • <polyline points=”0,40 40,40 40,80 80,80 80,120 120,120″ style=”fill:white;stroke-width:7;stroke:blue”/>
      • </svg>
  • Elementos de mídia
    • audio → conteúdo de áudio;
    • video → conteúdo de vídeo;
    • source → código para fontes de video e audio;
    • track → faixas para video e audio;
    • embed → container para aplicações externas (plugins);
  • APIs
    • Geolocalização
      • // javascript
      • navigator.geolocation.getCurrentPosition(showPosition);
      • //navigator.geolocation.watchPosition(showPosition); // obtém continuamente a localização;
      • //navigator.geolocation.clearWaltch(); // parar a obtenção contínua;
      • function showPosition(position) {
        • document.getElementById(“geotext”).innerHTML = “Latitude: ” + position.coords.latitude + “<br>Longitude: ” + position.coords.longitude;
        • var latlon = position.coords.latitude + “,” + position.coords.longitude;
        • var img_url = ‘http://maps.googleapis.com/maps/api/staticmap?center=&#8217; + latlon + ‘&zoom=14&size=400×300&sensor=false’;
        • document.getElementById(“geoimg”).innerHTML = “<img src='”+img_url+”‘>”;
      • }
    • Drag and Drop
      • dragstart → um elemento começou a ser arrastado;
      • drag → o objeto está sendo arrastado;
      • dragenter → o objeto sendo arrastado está sobre o objeto alvo (target);
      • dragleave → o objeto sendo arrastado deixou de estar sobre o objeto alvo;
      • dragover → o objeto sendo arrastado está se move sobre o objeto alvo (target);
      • drop → o objeto sendo arrastado foi solto no objeto alvo (target);
    • Local Storage
      • Histórico
        • history.pushState(data,title[,url]) → acrescenta entrada no histórico;
        • history.replaceState(data,title[,url]) → modifica a entrada no histórico;
      • Storage API
        • localStorage → objeto javascript para armazenamento sem período para expiração;
        • sessionStorage → objeto javascript para armazenamento para sessão atual;
        • Store
          • localStorage.simpletext = “Hello World”;
          • localStorage.setItem(“simpletext”, “Hello World”);
        • Retrieve
          • document.getElementById(“hello”).innerHTML = localStorage.simpletext;
        • Remove
          • localStorage.removeItem(“simpletext”);
    • Application cache (Aplicações Offline) → aplicação web armazenada em cache para utilização sem conexão a internet;
      • <!DOCTYPE html>
        • <html manifest=”exemplo.appcache”>
        • <body> … </body>
        • </html>
      • content type → text/cache-manifest;
      • Arquivo .appcache
        • CACHE MANIFEST → arquivos listados serão armazenados em cache após o primeiro download;
          • /logo.png
          • /css/style.css
          • /js/script.js
        • NETWORK → arquivos listados não serão armazenados em cache;
          • *
        • FALLBACK → arquivos listados especificam páginas alternativas em caso de falhas;
          • /pages/erro.html
      • Atualização
        • usuário apaga dados em cache;
        • desenvolvedor atualiza o arquivo de manifesto;
        • desenvolvedor atualiza o cache por meio de script e pelo objeto applicationCache;
    • Web workers → processamento em background;
    • SSE → atualização automática de página;

 

CSS – Cascading Style Sheets


 

  • Visão geral
    • Aplicação de estilo
      • Por meio do atributo style na tag → <tag style=”propriedade: valor;”></tag>
      • Por meio do atributo class na tag → <tag class=”classname”></tag>
      • Com classe definida no head → <style> .classname { propriedade: valor; }; </style>
      • Com classe incluída no head → <link rel=“stylesheet” type=“text/css” href=“style.css” />
    • Unidades de medida
      • px → unidade de medida absoluta;
      • em → unidade de medida relativa a altura do tamanho da fonte do elemento;
      • rem → unidade de medida relativa a altura do tamanho da fonte do elemento html ou a definida no navegador;
      • ch → unidade de medida relativa a largura do caracter “0” da fonte;
      • % → unidade de medida relativa ao elemento pai;
      • calc(75% + 15px) → cálculo da medida;
    • Prefixo para propriedades em desenvolvimento
      • -webkit-pname → Chrome;
      • -moz-pname → Firefox;
      • -ms-pname → Microsoft;
  • Seletores
    • Seletores de elementos
      • tag { propriedade: valor; }; → seletor por tag;
      • .classname { propriedade: valor; }; → seletor por classe;
      • #idname { propriedade: valor; }; → seletor por id;
      • tag1 tag2 { propriedade: valor; }; → seleciona todas as tag2 em qualquer nível hierárquivo interno a tag1 (filhos e netos);
      • tag1 > tag2 { propriedade: valor; }; → seleciona todas as tag2 somente no nível hierárquivo subsequente a tag1 (só filhos);
      • tag1 ~ tag2 { propriedade: valor; }; → seleciona todas as tag2 após a tag1, de mesmo nível hierárquivo (irmão e imãos);
      • tag1 + tag2 { propriedade: valor; }; → seleciona a tag2 imediatamente após a tag1, de mesmo nível hierárquivo (irmão e irmão);
      • [id] → seletor por atributo;
      • [src$=“.jpg”] → seletor por atributo com expressão final;
      • [href^=“http://”] → seletor por atributo com expressão inicial;
      • [class=“classname”] → equivalente ao seletor .classname;
    • Priorização de seletores
      • prioridade ao seletor mais específico, na ordem: #idname, .classname, tag;
      • seletor de mesma prioridade, a prioridade para a última definição do estilo (ordem de declaração no CSS);
    • Seletores por pseudoclasses dinâmicas ou interativas

      • :hover → quando o mouse passa sobre o elemento (usar em conjunto com seletor :focus para acessibilidade);
      • :focus → quando o cursor está no elemento (usar em conjunto com atributo tabindex para acessibilidade);
      • :active → quando o botão está pressionado no elemento;
    • Seletores por pseudoclasses estruturais

      • :only-child → elemento qualquer desde que seja o único filho, equivalente a :nth-child(1):nth-last-child(1);
      • :nth-first-child → 1º elemento qualquer;
      • :nth-last-child → último elemento qualquer;
      • :nth-child(5) → 5º elemento qualquer;
      • :nth-child(odd) → elementos quaisquer em quantidade ímpar, equivalente a :nth-child(2n+1);
      • :nth-child(even) → elementos quaisquer em quantidade par, equivalente a :nth-child(2n);
      • :nth-first-of-type → primeiro elemento de mesmo tipo daquele utilizado no seletor;
      • :nth-last-of-type → último elemento de mesmo tipo daquele utilizado no seletor;
      • :nth-of-type(odd) → elementos de mesmo tipo daquele utilizado no seletor em quantidade ímpar;
      • :nth-of-type(even) → elementos de mesmo tipo daquele utilizado no seletor em quantidade par;
      • :nth-of-type(n+2) → segundo elemento em diante;
    • Seletores por pseudoelemento
      • ::first-letter → primeiro caractere, quando este é conteúdo;
      • ::before → conteúdo inicial do elemento, quando este é decorativo; requer propriedade ‘content:’;
      • ::after → conteúdo final do elemento, quando este é decorativo; requer propriedade ‘content:’;
  • Propriedades
    • font-family → define a fonte;
      • font-family: serif; → fonte com serifa escolhida pelo navegador;
      • font-family: sans-serif; → fonte sem serifa escolhida pelo navegador;
      • font-family: cursive; → fonte cujas letras são ligeiramente ligadas e escolhida pelo navegador;
      • font-family: monospace; → fonte mono-espaçada escolhida pelo navegador;
    • font-size → tamanho da fonte o texto;
      • font-size: 24px;
      • font-size: 120%; → relativo a fonte do elemento pai;
    • font-style → estilo da fonte do texto;
      • font-style: italic;
    • color → cor do texto;
      • color: #A0A0A0;
      • color: rgb(160, 160, 160);
      • color: inherit; → utiliza a cor do elemento superior;
    • text-align → alinhamento do texto;
      • text-align: center;
    • text-decoration → aparência do texto, como sublinhado;
      • text-decoration: none;
    • text-transform → transformação do texto;
      • text-transform: uppercase; → transformações visuais que podem implicar em melhor semântica e acessibilidade;
    • text-shadow → sombra do texto, na ordem: sombra horizontal (positivo para baixo, negativo para cima), sombra vertical e desfocar;
      • text-shadow: 3px -4px #000; → sombra para baixo e para esquerda;
      • text-shadow: 3px 4px 5px #000; → sombra desfocada;
    • line-height → espaçamento entre as linhas de um parágrafo;
      • line-height: 1.5;
    • list-style → define identificar de lista (ol e ul);
      • list-style: none;
    • margin → distância (espaçamento) externa ao elemento;
      • width: 940px;
      • width: 85%; → relativo a largura do elemento pai;
      • margin: 0 auto; → divide o espaçamento entre esquerda (margin-left) e direita (margin-right);
      • margin-left: auto; margin-right: auto;
    • padding → distância (espaçamento) interna ao elemento;
      • padding: 1px 2px 3px 4px; → definição rápida (shorthand) na ordem do relógio: top, right, bottom, left;
      • padding-top: 1.25em; → relativo a altura do tamanho da fonte do elemento (1.25x20px=25px);
      • padding-top: 1.25rem; → relativo a altura do tamanho da fonte do elemento html ou a definida no navegador;
      • padding-left: 1.25ch; → relativo a largura do caracter “0” da fonte;
    • display → altera a forma de exibição; cada elemento possui uma forma padrão, li é block, span é inline;
      • display: block; → exibição com quebra de linha;
      • display: inline; → exibição sem quebra de linha; não permite aplicar height e width ao elemento;
      • display: inline-block; → exibição sem quebra de linha;
      • display: none; → não exibe o elemento;
      • display: flex; → controla o leiaute de um conjunto de elementos (alinha os elementos lado a lado à esquerda e aplica a mesma altura);
      • align-itens: center; → alinha os elementos ao centro de um flexbox (não aplica mais a mesma altura);
      • justify-content: space-between; → distribui os espaços horizontalmente entre os elementos de um flexbox;
      • flex-direction: column; → altera o justify-content para espaço verticais, assim os elementos ocupam largura de 100%;
      • order: 1; → define a ordem do elemento de um flebox (propriedade dos filhos), é necessário por a ordem nos demais elementos;
      • flex: 1 1 80px; → define a proporção de cada elemento de um flebox e faz ocupar todo o espaço não ocupado (propriedade dos filhos);
      • flex-grow: 1; → define a proporção para crescimento do elemento em relação aos demais elementos de um mesmo container;
      • flex-shrink: 1; → define a proporção para encolhimento do elemento em relação aos demais elementos de um mesmo container;
      • flex-basis: 80px; → tamanho inicial (mínimo) do elemento;
    • float → faz o elemento não seguir o fluxo (flutuar), sendo deslocado à esquerda ou à direita da tela, mantendo a mesma altura;
      • float: right; → se já houver um elemento antecedente com float: right, o elemento ficará esquerda deste elemento;
      • float: left;
    • clear → faz o elemento não flutuar por um float anterior;
      • clear: right; → impede elementos com float a direita;
      • clear: left; → impede elementos com float a esquerda;
      • clear: both; → impede elementos com float a esquera ou a direita;
    • position → define a referência à disposição de elementos (top, bottom, left, right);
      • position: static; → referencia o fluxo de conteúdo (refência padrão ao elemento pai);
      • position: relative; → referencia a posição original (que não é alterada, apenas a visualização) do elemento no fluxo de conteúdo;
      • position: absolute; → referencia ao primeiro elemento pai não static (fora do fluxo de conteúdo, sofre scroll);
      • position: fixed; → referencia a tela (fora do fluxo de conteúdo, não sofre scroll e continua no mesmo local da tela);
      • top: 0;
      • right: 0;
    • box-sizing → determina o comportamento da propriedade width (forma como o navegador mede a largura);
      • box-sizing: border-box; → width computado a partir do limite da borda do elemento (inclui padding e border);
      • box-sizing: content-box; → width computado a partir do limite do conteúdo do elemento (padrão);
    • box-shadow → sombra, na ordem: distância horizontal, distância vertical, efeito de falta de nitidez e cor (0-255) e transparência (0-1);
      • box-shadow: 0 0 3px rgba(0,0,0,0.7); → sombra uniforme, sem deslocamento horizontal ou vertial;
      • box-shadow: 10px 10px black, -10px -10px blue; → sombra azul para cima e para esquerda, sombra preta para baixo e para direita;
      • box-shadow: 0 0 3px #000, inset 0 0 3px #FFF; → sombra uniforme externa e interna ao elemento;
      • box-shadow: 0 0 0 3px #FFF; → simular uma borda;
      • box-shadow: 0 0 0 3px black, 0 0 0 3px transparent, 0 0 0 3px black; → bordas sobrepostas;
      • box-shadow: 0 0 0 99999px rgba(0,0,0,.7); → simula um dialog;
    • border → borda do elemento (shorthand) para top, right, bottom, left, na ordem: border-width, border-style, border-color;
      • border: 1px solid black;
    • border-style → definição na ordem do relógio: border-top-style, border-right-style, border-bottom-style, border-left-style;
      • border-style: dotted solid dashed double;
      • border-style: groove ridge inset ouset;
    • border-radius → curvatura da borda do elemento;
      • border-radius: 15px;
      • border-radius: 10px 0; → apenas dois cantos com bordas (superior esquerdo e inferior direito);
      • border-radius: 50%; → forma um círculo;
      • border-radius: 10% 50% / 50% 10%; → curvatura elíptica da borda do elemento (rx rx / ry ry);
    • background-color → cor de fundo;
      • background-color: #D0D0D0;
      • background-color: rgb(208, 208, 208);
      • background-color: rgba(208, 208, 208, .3); → fundos semitransparente;
    • background → cor de fundo (shorthand);
      • background: linear-gradient(top, #A0A0A0, #FFFFFF 40%);
    • background-image → imagem para o fundo do elemento;
      • background-image: url(image.png);
      • background-image: linear-gradient(to bottom, #000, #FFF);
      • background-image: linear-gradient(to bottom, #000, #999, #CCC, #FFF);
      • background-image: linear-gradient(to bottom, #000 0%, #999 30%, #CCC 60%, #FFF 100%);
      • background-image: linear-gradient(120deg, transparent, transparent 10px, rgba(0,0,0,0.1) 15px, transparent 15px, transparent);
    • background-size → tamanho ocupado pelo background-image, na ordem: largura e altura;
      • background-image: linear-gradient(to bottom, #000, #CCC 60%, #FFF);
      • background-size: 100% 150px;
    • background-repeat → define a repetição da imagem em background-image;
      • background-repeat: no-repeat;
    • background-position → define a posição da imagem em background-image;
      • background-position: center center;
    • transform → transformação (não funciona em elementos inline, devendo-se usar inline-block);
      • transform: rotate(-5deg);
      • transform: rotate(20deg); → rotacionar;
      • transform: skew(35deg); → deslocamento superior à esquerda e inferior à direita;
      • transform: scale(2.0); → aumentar ou diminuir;
      • transform: translate(20px, 40px); → deslocamento;
      • transform: scale(2.0) rotate(20deg); → transformações combinadas de forma ordenada (aplicadas da direita para a esquerda);
    • transform-style → calcular transformações 3D considerando as transformações 3D de elementos aninhados;
      • transform-style: preserve-3d; → definido no elemento entre aqueles que sofrerão transformação e aquele que define a perspectiva;
    • transform-origin → ponto de origem da transformação (a partir do centro do elemento, por padrão);
      • transform-origin: 0 0; → define o cálculo de transformação a partir do canto superior esquerdo;
    • perspective → distância do observador para a tela para cálculo de transformações 3D (translateZ);
      • perspective: 5px; → definido no elemento pai daqueles que sofrerão transformação;
      • transform: translateZ(20px); → deslocamento em eixo Z (positivo para perto do observador, negativo para longe);
      • transform: translate(-50%, -50%) rotate(10deg) translateZ(3px); → para que elementos absolute transformem pela posição central;
      • font-size: 400%;
      • transform: translate(-50%, -50%) rotate(15deg) translateZ(3px) scale(0.25); → aumentar a fonte e reduzir por scale melhora sua qualidade;
    • perspective-origin → deslocamento angular (vertical e horizontal) do observador em relação a tela para cálculo de transformações 3D;
      • perspective-origin: 40% 120px; → definido no elemento pai daqueles que sofrerão transformação;
    • opacity → torna o elemento translúcido;
      • opacity: .5; → de 0, para maior transparência, até 1, para opaco (visível).
    • transition → controle da transição acionada por pseudoclasses;
      • transition: box-shadow 1s linear, transform 2s easy-in-out;
    • transition-delay → atraso para inicio de cada transição;
      • transition-delay: 0s, 2s;
    • animation → controle de transição acionada na renderização da página;
      • animation: nome1 2s; → animção realizada apenas uma vez;
      • animation: nome2 2s infinite; → animção é repetida;
    • @keyframes → composição da animação;
      • @keyframes nome1 { 0% { opacity: 0; } 100% { opacity: 1; } }
      • @keyframes nome2 { from { top: 0; } to { top: 5px; } }
    • animation-direction → controla se a animação flui inicio->fim ou inicio->fim->inicio;
      • animation-direction: alternate; → animação inicio->fim->inicio;
    • animation-timing-function → controla a acelaração/pausa da animação;
      • animation-timing-function: linear; → aceleração constante;
      • animation-timing-function: ease-in; → aceleração maior no inicio da animação;
      • animation-timing-function: ease-out; → aceleração maior no final da animação;
      • animation-timing-function: ease-in-out; → aceleração maior no inicio e no final da animação;
    • animation-play-state → controla a execução ou parada da animação;
      • animation-plat-state: paused; → animação pausada;
      • animation-plat-state: running; → animação em execução;
    • animation-fill-mode → controla o carregamento dos estilos antes ou depois de iniciar a animação;
      • animation-fill-mode: backwards; → o estilo é aplicado antes da animação iniciar;
  • Exemplos
    • Substituição semântica de imagem por texto (image exibida, texto oculto); → melhora a acessbilidade;
      • background-image: url(image.png);
      • width: 32px;
      • height: 32px;
      • display: inline-block;
      • text-indent: -9999px;
      • font-size: 0; → alternativa ao text-indent negativo, mas não funciona bem em todos os navegadores;
    • Substituição semântica de imagem por texto (image exibida, texto oculto); → melhora a acessbilidade;
      • content: attr(title);
      • font-size: .75em;
      • background: black;
      • position: absolute; → elemento pai deve ser position: relative;
      • top: 100%;
      • right: 0;
      • text-indent: 0;
      • width: 300%;
    • Fundo em gradiente → linha com inclinação de 135º ou 45º;
      • background-color: #DDD;
      • background-image: linear-gradient(135deg, transparent 14px, rgba(0,0,0,0.1) 14px, rgba(0,0,0,0.1) 15px, transparent 15px);
      • background-size: 20px 20px;
      • background-attachment: fixed; → fundo fixo, acompanha o scroll;
    • Fundo com efeito elíptico
      • width: 300px;
      • background-size: 35% 100%;
      • background-repeat: no-repeat;
      • background-image: radial-gradient(ellipse at left bottom, rgba(10, 20, 40, 0.8), rgba(10, 20, 40, 0.8) 65%, black 65%, black 70%, transparent 70%);
    • Simular borda com gradiente
      • background-image: linear-gradient(to right, transparent, black, transparent);
      • background-size: 100% 1px;
      • background-size: 100% 1px;
      • background-repeat: no-repeat;
      • background-position: bottom center;
    • Dialog
      • position: fixed;
      • top: 50%;
      • left: 50%;
      • transform: translate(-50%, -50%);
      • width: 50%;
      • background-color: #FFF;
      • padding: 15% 5%;
      • text-align: center;
      • font-size: 2em;
      • box-shadow: 0 0 0 9999px rgba(0, 0, 0, 0.75);
      • z-index: 9999;
    • Balão de diálogo
      • a::before {
      • content: ”;
      • background-color: black;
      • width: 1em;
      • height: 1em;
      • position: absolute;
      • bottom: 0;
      • left: 0;
      • transform: translateY(.5em) rotate(45deg);
      • }

 

JavaScript


 

  • JavaScript

    • Visão geral
      • linguagem de script para páginas HTML interpretada a partir da tag <script src=“js/script.js”>;
      • provê acesso a estrutura da página por meio do objeto document (Document Object Model – DOM);
      • DOM é a representação em memória da renderização da página em que a sua alteração reflete na visualização da tela;
    • Plataformas JavaScript
      • linguagem front-end padrão interpretada por navegadores web e partir do console JavaScript;
      • plataforma Node.js para backend web;
      • plataforma Johnny-Five para microcontroladores;
      • plataforma Electron para aplicações desktop;
    • Console JavaScript do Navegador (ctrl+shift+j)
      • execução de código;
      • analisar conteúdo de objetos;
      • notificação de erros;
    • Operadores
      • Aritméticos → peso / (altura * altura);
      • Lógico OR → if (peso <= 0 || peso >= 1000) {}
      • Lógico AND → if (idade > 18 && idade < 65) {}
      • Negação → if (!valido) {}
      • Round → salario.toFixed(2);
    • Array e Objeto
      • Array → var erros = []; erros.push(“mensagem”);
      • Objeto → var pessoa { nome: “Reinaldo”, idade: 33 }
    • Laços
      • For → for(var i = 0; i < 4; i++) {}
      • ForEach → erros.forEach(function(erro){});
  • Funções
    • Depuração
      • alert(“mensagem”);
      • console.log(“mensagem”);
    • Document Object Model
      • var node = document.querySelector(“#id1”); // obtém um elemento;
      • var nodes = document.querySelectorAll(“.classe1”); // obtém um array de elementos;
    • Document Node
      • node.textContent = “parágrafo1”; // define o texto interno ao elemento;
      • node.style.backgroundColor = “red”; // adiciona estilo CSS em camelCase (preferir usar classes CSS);
      • node.classList.add(“msg-erro”); // adiciona classe CSS (sem ponto);
      • node.parentNode.classList.add(“classe-pai”); // referência ao elemento pai;
      • var nodes = document.querySelectorAll(“.classe1”);
      • for (var i = 0; i < nodes.length; i++) { node = nodes[i]; console.log(node); };
    • Formulário
      • var node = document.querySelector(“#form1”);
      • node.idade.value = “33”; // define o valor de um input;
      • node.reset(); // limpa o formulário;
      • Não submeter o formulário → ev.preventDefault();
      • node.btcadastrar.addEventListener(‘click’, function(ev){ ev.preventDefault(); console.log(‘função 1.’); });
    • Eventos
      • Associar eventos → permite associar distintas funções a um evento;
      • node.btcadastrar.addEventListener(‘click’, function(ev){ ev.preventDefault(); console.log(‘função 1.’); });
      • node.btcadastrar.addEventListener(‘click’, function(ev){ ev.preventDefault(); console.log(‘função 2.’); });
      • Associar evento único → permite associar uma única função a um evento (preferir usar addEventListener);
      • node.btcadastrar.onclick = function(ev){ ev.preventDefault(); console.log(‘node clicado.’); };
      • Capturar alvo do evento → permite adicionar evento a elemento pai e identificar o alvo (node) do evento;
      • document.querySelector(“table”).addEventListener(‘click’, function(ev){ console.log(ev.target); });
    • Criar elemento
      • div = document.createElement(“div”);
      • h1 = document.createElement(“h1”);
      • h1.textContent = “título”;
      • p = document.createElement(“p”);
      • p.textContent = “parágrafo”;
      • div.appendChild(h1);
      • div.appendChild(p);
      • document.querySelector(“body”).appendChild(div);
    • Remover elementos
      • div.innerHTML = “”; // remove todos os elementos internos ao elemento;
      • div.remove(); // remove o elemento e elementos internos;
  • Node.js
    • Visão geral
      • nmp install realiza a instalação de dependências descritas no arquivo package.json;

 

 

Ajax – Asynchronous JavaScript And XML


 

  • Conceitos
    • Conjunto de tecnologias padrões da internet utilizadas em páginas HTML e XHTML para o desenvolvimento de páginas interativas;
    • Permite realizar consultas em segundo plano e atualizar partes (pequenas porções) de uma página web (atualização dinâmica);
    • Consultas assíncronas permitem o processamento em paralelo a requisição uma vez que não necessitam aguardar resposta;
    • Implementado em JavaScript por meio do objeto XMLHttpRequest para comunicação com o servidor e do DOM e CSS para atualizar a página web;
    • Utiliza XML ou JSON para a comunicação (intercâmbio de dados) com o servidor e XSLT para manipulação e transformação de dados;
  • Informações adicionais
    • Permite a redução do volume de dados trocados com o servidor;
    • Torna mais rápida a resposta ao usuário, aumenta a usabilidade (mais fáceis de usar) e a interatividade das páginas, e aprimora a experiência do usuário;
    • Está associado a camada de visão (não envolve regras de negócio);
    • O modelo de objetos html/xml (DOM) é acessado e transformado por JavaScript para exposição e interação dinâmica (atualização a página web);
    • A comunicação assíncrona também pode ser realizada pelo objeto iFrame;
    • O CESPE considerou em 2011 o objeto XMLHttpResponse e linguagem VBScript como relacionados ao Ajax;
  • XMLHttpRequest → envia e recebe dados do servidor depois da página estar carregada;
    • Inicializar
      • if (window.XMLHttpRequest)
        • xmlhttp = new XMLHttpRequest();
    • Implementar método executado a cada evento de mudança de estado
      • xmlhttp.onreadystatechange = function() { // code }
    • Estado da requisição → xmlhttp.readyState;
      • xmlhttp.readyState == 0 → requisição não inicializada;
      • xmlhttp.readyState == 1 → conectado ao servidor;
      • xmlhttp.readyState == 2 → requisição enviada ao servidor;
      • xmlhttp.readyState == 3 → requisição recebida pelo servidor;
      • xmlhttp.readyState == 4 → resposta recebida;
    • Status da resposta → xmlhttp.status; xmlhttp.statusText;
      • xmlhttp.status == 200 → OK;
      • xmlhttp.status == 404 → Not found;
    • Requisição → método, url, async;
      • xmlhttp.open(“GET”, “/page/core?op=” + opt, true);
      • xmlhttp.setRequestHeader(“headerName”,”content”);
      • xmlhttp.setRequestHeader(“Content-type”,”application/x-www-form-urlencoded”); // POST
      • xmlhttp.send(); // GET
      • xmlhttp.send(postString); // POST
    • Resposta
      • xmlhttp.responseText → string; // JSON.parse(xmlhttp.responseText)
      • xmlhttp.responseXML → objeto XML;
      • xmlhttp.responseXML.getElementsByTagName(“nome”)[0].firstChild.nodeValue;
    • Caso de uso assíncrono e GET

      • xmlhttp = new XMLHttpRequest();
      • xmlhttp.onreadystatechange = function() {
        • if (xmlhttp.readyState == 4 && xmlhttp.status == 200)
          • document.getElementById(“divId”).innetHTML = xmlhttp.responseText;
      • }
      • xmlhttp.open(“GET”, “/page/core?op=” + opt, true);
      • xmlhttp.send();
    • Caso de uso síncrono e POST

      • xmlhttp = new XMLHttpRequest();
      • xmlhttp.open(“POST”, “/page/core”, false);
      • xmlhttp.send(“op=” + opt);
      • document.getElementById(“divId”).innetHTML = xmlhttp.responseText;

 

Automatização de rotinas de construção Web


 

  • Gulp → módulo Node.js gulp-cli para automação de rotinas (build) que utiliza o gulpfile.js para configuração;
    • apt-get install npm →instalação do gerenciador de pacotes para a plataforma Node.js;
    • npm init → cria a configuração inicial do Node.js em package.json para utilização do Gulp na raiz do projeto;
    • npm install gulp –save-dev → realiza o download do gulp em ./node_modules e atualiza o package.json;
    • npm install gulp-clean –save-dev → realiza o download do módulo gulp-clean e atualiza o package.json;
    • npm install → realiza o download dos módulos descritos em package.json para a plataforma de uma nova máquina;
    • gulpfile.js
      • var gulp = require(‘gulp’); // função require(str) do Node.js para carregar módulos;
      • var clean = require(‘gulp-clean’);
      • gulp.task(‘clean’, function() { return gulp.src(‘dist’).pipe(clean()); });
      • gulp.task(‘copy’, [‘clean’], function() { return gulp.src(‘src/**/*’).pipe(gulp.dest(‘dist’)); });
  • jshint → verificação de erros de sintaxe nos arquivos JavaScript;
    • npm install jshint –save-dev → realiza o download do jshint e atualiza o package.json;
    • gulpfile.js
      • var jshint = require(‘gulp-jshint’);
      • gulp.task(‘jshint’, function() {
        • gulp.watch(‘src/js/**/*.js’).on(‘change’, function(ev) {
        • gulp.src(ev.path).pipe(jshint()).pipe(jshint.reporter()); });
        • });
  • csslint → verificação de erros de sintaxe nos arquivos CSS;
    • npm install csslint –save-dev → realiza o download do csslint e atualiza o package.json;
    • gulpfile.js
      • var csslint = require(‘gulp-csslint’);
      • gulp.task(‘csslint’, function() {
        • gulp.watch(‘src/css/**/*.css’).on(‘change’, function(ev) {
        • gulp.src(ev.path).pipe(csslint()).pipe(csslint.reporter()); });
        • });
  • autoprefixer → prefixação de propriedades experimentais (–webkit, –moz) em arquivos CSS;
    • npm install gulp-autoprefixer –save-dev → realiza o download do autoprefixer e atualiza o package.json;
    • gulpfile.js
      • var autoprefixer = require(‘gulp-autoprefixer’);
      • gulp.task(‘autoprefixer’, function() {
        • gulp.src(‘src/css/*.css’).pipe(autoprefixer({ browsers: [‘last 20 versions’], cascade: false })).pipe(gulp.dest(‘dist’));
        • });
  • BrowserSync → sincronização da navegação entre distintos dispositivos e com mudanças no código fonte;
    • npm install browser-sync –save-dev → realiza o download do browser-sync e atualiza o package.json;
    • gulpfile.js
      • var browserSync = require(‘browser-sync’);
      • gulp.task(‘server’, function() {
        • browserSync.init({ server: { baseDir: ‘src’ } }); // inicia servidor web na porta 3000;
        • browserSync.init({ server: { proxy: ‘192.168.0.1:8080’ } }); // inicia proxy na porta 3001 p/ servidor;
        • gulp.watch(‘src/**/*’).on(‘change’, browserSync.reload); }); // monitora mudanças em ./src;

 

Otimização de Performance Web


 

  • Performance Web (link)
    • Visão geral
      • performance é uma característica relacionada com usabilidade e experiência do usuário;
      • otimiza o tempo de carregamento com redução da quantidade requisições e de bytes transferidos;
      • aprimora tempo de início de renderização e o progresso de visualização do topo da página (above-the-fold);
      • minimiza o efeito dos objetos bloqueantes de renderização com a otimização do caminho crítico de renderização;
      • estudos de caso e experimentos do impacto de otimização de performance web estão disponíveis em WPO stats;
      • indicadores de tendências e estatísticas estão disponíveis em httpachive;
    • Otimização do caminho crítico de renderização
      • CSS bloqueante ou inline somente para as classes referenciadas pelo topo da página;
      • atrasar o carregamento do CSS não aplicados ao topo da página com preload (PolyfillloadCSS);
      • atrasar o carregamento de elementos HTML pesados com innerHTML em setTimeout({}, int) ou window.onscroll com throttle;
      • atrasar o carregamento de JavaScripts menos prioritários com função setTimeout({}, int);
      • carregamento dos JavaScripts no final body e de forma assíncrona (async) para aqueles não dependentes entre si;
      • optar por servidor com boa latência (RTT) a fim de reduzir o atraso das requisições (RRC, DNS, TCP handshake, TLS, HTTP);
      • reduzir o número de requisições reduz o impacto da latência à experiência do usuário;
    • Resource Hints (link1, link2)
      • link rel=dns-prefetch → antecipa a resolução de nome;
      • link rel=preconnect → antecipa a resolução, a conexão e o tls (https);
      • link rel=prefetch → antecipa o download de recurso para navegação futura, quando estiver ocioso e pode ser ignorado;
      • link rel=preload → antecipa o download de recurso que devem ser baixados imediatamente sem bloquear a renderização;
      • link rel=prerender → antecipa o carregamento de uma página html e seus recursos;
    • Ferramentas
  • Minificação
    • imagemin → módulo Node.js para otimização do tamanho de imagens;
      • npm install gulp-imagemin –save-dev → realiza o download do módulo e atualiza o package.json;
      • gulpfile.js
        • var imagemin = require(‘gulp-imagemin’);
        • gulp.task(‘imagemin’, [‘copy’], function() { gulp.src(‘src/img/**/*’).pipe(imagemin()).pipe(gulp.dest(‘dist/img’)); });
    • UglifyJS → módulo Node.js para minificação de arquivos JavaScript do projeto;
      • npm install gulp-uglify –save-dev → realiza o download do módulo e atualiza o package.json;
    • cssmin (ou cssnano)→ módulo Node.js para minificação de arquivos CSS do projeto;
    • JQuery → substituir pela versão minificada disponível para download no site do JQuery;
  • Otimização de Imagens
    • redimensionar imagens para o tamanho de exibição;
    • utilizar menor qualidade para compressão que produza uma imagem aceitável;
    • remover metadados (EXIF);
    • simular nas plataformas Kraken, Tinypng e SVGOMG;
    • simular nas ferramentas ImageMagick, exiftran, pngnq/pngquant, pngcrush e SGVO;
  • Otimização no backend
    • Visão geral
      • Kernel → aumentar a quantidade de segmentos enviados no início de uma conexão TCP;
      • Keep-alive → permitir que sucessivas requisições HTTP sejam realizadas por cada conexão;
      • Flush → codificação para encaminhar o HTML já disponível, como o cabeçalho da página, enquanto um SQL é processado;
      • Content Delivery Network (CDN) → utilizada para reduzir a latência com servidores distribuídos geograficamente;
    • HTTP2
      • ativado sob HTTPS por fins de compatibilidade;
      • cabeçalhos binário e compactados (HPACK);
      • cabeçalhos diferenciais em requisições sucessivas (header tables) com estado no servidor;
      • corpo compactado com gzip;
      • múltiplas requisições paralelas e respostas parciais assíncronas e fora de ordem em uma conexão TCP (multiplexing);
      • requisições indicam o peso para informar a relevância de cada objeto ao servidor;
      • respostas a requisições de arquivos HTML podem incluir objetos referenciados, como CSS e JS (Server Push);
    • Compactação com Nginx → ler sobre o Brotli;
      • Compactação on-the-fly
        • server {
        • listen 8080;
        • root /path/to/site;
        • gzip on;
        • gzip_types text/plain text/xml text/css application/javascript image/svg+xml;
        • }
      • Pré compactação → uma requisição de /path/to/file será enviado o arquivo /path/to/file.gz;
        • gzip_static on;
      • Recarregar → nginx -s reload
    • Cache com Nginx
      • Configuração
        • location /resources {
        • expires 1y; → adiciona os cabeçalhos Expires e Cache-Control na resposta de requisição;
        • add_header Cache-Control public; → proxies intermediários podem fazer cache ou não (private);
        • }
      • Controle e automação
        • utilizar cache de períodos maiores depende da mudança da URL a cada modificação nos arquivos;
        • o módulo rev do NodeJS permite adicionar um hash ao nome dos arquivos para evitar cache de arquivos modificados;
  • Redução do número de requisições → desnecessário com HTTP2 em virtude do multiplexing;
    • Junção de CSSs e JavaScripts
      • módulo usemin (sucessor do useref) para concatenação de recursos integrada ao htmlmin, uglify, cssmin e imagemin;
      • permite a inclusão do conteúdo dos recursos dentro do HTML a partir do atributo ‘inline’ (substituído pelo Server Push);
    • Junção de imagens (sprites)
      • ImageMagick (componente convert) → convert in*.png –append out.png;
      • sprinty (NodeJS) ou spritesmith → sprinty create /output/dir /input/files*.png -s sprite.css;
      • controlar exibição das imagens pelo propriedade do CSS background-position;
    • Junção de imagens vetoriais
      • svg-sprite
        • modulo svg-sprite do NodeJS com integração com gulp para automatização;
      • Arquivo SVG → utiliza tag symbol com id para agrupamento de imagens SVGs em um arquivo;
        • <svg width=“0” height=“0” xmlns=“http://www.w3.org/2000/svg”><defs><symbol id=“id1” …
      • Arquivo HTML → utiliza tag svg para exibição de cada imagem;

 

Plataforma mobile


 

  • Aspectos do dispositivo móvel relevantes ao desenvolvimento
    • Telas de variados tamanhos e proporções;
    • Restrições de hardware (processamento, armazenamento e bateria);
    • Segurança;
    • Compatibilidade com a versão do sistema operacional móvel;
  • Arquitetura de visão de desenvolvimento móvel
    • Nativo → app específico a cada plataforma para acesso às APIs do SO (acesso nativo ao hardware → câmera, acelerômetro, GPS, etc);
      • app nativo com linguagem e SDK de cada plataforma, alta performance e instalação do app no dispositivo móvel;
      • código não reutilizável entre plataformas;
      • maior tempo de desenvolvimento e manutenção mais difícil;
    • Cross-platform → app reutilizável a diversas plataformas, embora de menor performance;
      • web → app utilizado por meio do navegador (acesso ao hardware limitado ao javascript);
        • app web acessado pelo navegador, menor performance, sem a instalação no dispositivo móvel;
        • utiliza linguagem web responsiva (CSS @media screen) para adaptação à telas de distintos tamanhos e proporções;
        • menor tempo de desenvolvimento e manutenção mais fácil;
      • híbrido → app que encapsula o navegador para cada SO e provê acesso as APIs à aplicação web;
        • app web com código nativo (container) e instalação no dispositivo móvel;
        • o container implementa o navegador e prover interfaces para acesso às APIs do SO;
        • há frameworks específicos com funcionalidade de container e empacotamento para diversos SOs (Adobe PhoneGap, Intel XDK, etc);
        • o projeto Apache Cordova prover uma API em javascript que padroniza o acesso a diversas APIs nativas;
        • tempo de desenvolvimento e manutenção intermediários;

 

Plataforma Android

 

  • Introdução
    • Sistema operacional de código aberto para dispositivos móveis e não móveis (TVs), formado por um conjunto de aplicações (software stack):
      • aplicativos;
      • frameworks de aplicação → fornecem funcionalidades a nível de serviço para implementação de aplicativos;
        • managers → window, activity, notification, package, telephony, resource, location;
        • content provides, view systems, XMPP service;
      • bibliotecas → fornecem funcionalidades para implementação de aplicativos;
        • Android runtime → core, Dalvik Virtual Machine;
        • libc, SSL, SGL, WebKit, FreeType, OpenGL/ES, SQLite, Media framework, Surface manager;
        • SQLiteDatabase → objeto com métodos delete, update, insert, query e execSQL para executar operações no SQLite;
      • Linux kernel
        • drivers → display, camera, bluetooth, USB, WiFi, audio, etc;
    • Máquina virtual (não usa JVM)
      • Dalvik → execução “Just-in-Time” por meio de interpretação do bytecode .dex em tempo de execução;
        • DX converter → conversor do formato .class (java bytecode) para formato .dex (Dalvik bytecode);
      • ART → execução “Ahead-of-Time” (à frente do tempo) por meio da compilação do .dex em linguagem de máquina durante a instalação do app;
        • binário dependente do sistema e compilado (ou pré-compilação) antes da execução;
        • instalação do app mais demorada;
    • Gerenciamento de recursos
      • caso um conjunto de aplicativos utilizados exceda o total de memória disponível o SO terminar automaticamente o aplicativo de menor prioridade
  • Versões e funcionalidades
    • Android 3.0/3.1/3.2 (Honeycomb) → API v11 a v13;
      • versão exclusiva para tablets;
    • Android 4.0 (Ice Cream Sandwich) → API v14 e v15;
      • kernel 3.0.1;
    • Android 4.1/4.2/4.3 (Jelly Bean) → API v16 a v18;
      • aprimora a interface do usuário (antecipação de toque, buffer triplo, tempo vsync estendido e usa taxa fixa de 60 fps);
      • perfis restritos para limitar o acesso a apps e conteúdo;
      • suporte para Bluetooth Smart (Bluetooth de baixa energia);
      • suporte para OpenGL ES 3.0;
    • Android 4.4 (KitKat) → API v19;
      • suporte para Bluetooth MAP;
      • suporte closed captions e legendas;
      • fotografia HDR+ (combinação de sequência rápida de fotos);
      • suporte a emissor de infravermelho (IR);
      • sandboxes de apps com o Security-Enhanced Linux (SELinux);
      • suporte a pedômetro (contagem de passos);
    • Android 5.0/5.1 (Lollipop) → API v21;
      • nova política visual (Material Design) → movimentos naturais e responsivos, iluminação e sombras realistas;
      • compactação de apps e serviços em segundo plano;
      • chamadas telefônicas não interrompem o que você está assistindo ou jogando;
      • bate-papo por vídeo ou chamada VoIP não são interrompidos ao mudar do Wi-Fi para a rede celular;
      • opção de economia de bateria e tempo estimado antes que seja necessário recarregar o dispositivo;
      • sandboxes SELinux em todos os apps;
      • suporte para dispositivos de 64 bits ARM, x86 e MIPS;
      • suporte a HEVC para permitir a reprodução de vídeos em 4K UHD;
      • suporte a Android TV (para dispositivos na sala de estar);
    • Android 6.0 (Marshmallow) → API v23;
      • app em espera → coloca apps abertos e pouco usados “em espera” (status para o escalonador de processos);
      • compatibilidade com USB tipo C* para carga de energia e transmissão de dados usando o mesmo cabo;
      • apps só requerem a permissão quando forem utilizar o recurso;
      • suporte Bluetooth stylus para sensibilidade à pressão e teclas modificadoras;
      • suporte a impressão frente e verso;
      • suporte a bandas de frequência de 5 GHz para pontos de acesso Wi-Fi portátil;
      • modo “não perturbe” com diversas novas configurações;
  • Desenvolvimento
    • Ambiente de desenvolvimento

      • Java Developer Kit (JDK);
      • Android SDK;
        • Android Asset Packaging Tool (APK) → compilador de recursos (processa XMLs de layout) e gera os pacotes .apk (compactado);
        • Android Debug Bridge (adb) → ambiente de depuração em tempo de execução com suporte a TCP (consegue receber informações via usb/rede/wifi do app em modo debug);
        • Android Virtual Devices Manager (AVD Manager) → interface gráfica para criar e gerenciar Android Virtual Devices (AVDs), que são requeridos pelo Android Emulator;
      • Android NDK → permite desenvolver rotinas em C ou C++ (alta performance);
      • Eclipse IDE;
      • Eclipse plugin ADT (Android Development Toolkit);
    • Estrutura do pacote APK

      • /src → código fonte Java;
      • /gen → código fonte (R.java) gerado como resultado do processamento de código /src;
      • /res → arquivos de recursos como imagens e configurações em XML;
        • /drawable-xxx → diretórios com imagens para cada tamanho de tela (-mdpi ,-hdpi , -xhdpi);
        • /layout-xxx → diretórios com layouts XMLs para cada tamanho de tela (-small, -sw600dp);
        • /values-xxx → diretórios com strings para cada versão da API (-v21, -v23)
      • /assets → repositório de arquivos a serem utilizados como streams de bytes;
      • /bin → estrutura de arquivos produzidos pela compilação do código fonte e processamento dos arquivos de recursos utilizados para o empacotamento da aplicação em formato .apk;
      • AndroidManifest.xml → contém informação essencial sobre a aplicação (descreve a natureza da aplicação e dos componentes);
      • proguard-project.txt, proguard.cfg → configurações para a ferramenta ProGuard (embaralha, otimiza, ofusca, renomeia classes, métodos e atributos); prduz menor APK e de difícil engenharia reversa;
      • ic_launcher-web.png → icon do projeto,  32-bit PNG com canal alpha de 512 x 512 pixels e tamanho máximo de 1024KB;
    • Componentes
      • Activity (atividade) → classe que representa uma tela da aplicação;
        • estende a classe android.app.activity.Activity (onCreate, onStart, onPause, onResume, onStop, onRestart, onDestroy);
        • public class MyActivity extends Activity {
          • protected void onCreate(Bundle savedInstanceState) { // inicializar os elementos da tela;
            • super.onCreate(savedInstanceState);
            • setContentView(R.layout.main); } }
        • Views → superclasse de Widgets (button, combobox, etc) que representa uma área retangular da tela;
        • Viewgroups → subclasse para aplicação de layouts (ListView, GridView, Linear Layout, Relative Layout);
      • Services → classe cujo processamento continua ainda que o aplicativo seja colocado em segundo plano;
        • é executado no processo principal (não é um processo separado ou thread);
        • caso o serviço realize operações intensivas ou de bloqueio, deve iniciar uma thread a partir do serviço;
        • útil para realizar operações longas (com uso de thread) e não fornece uma interface do usuário;
        • o serviço possui ciclo de vida próprio (não , ou seja, pode ser finalizado com stopService();
        • Declaração do serviço no Manifest
          • <manifest … >   …
            • <application … >
              • <service android:name=”.ExampleService” />
            • </application>
          • </manifest>
        • Iniciar um serviço
          • Intent intent = new Intent(this, HelloService.class);
          • startService(intent);
      • Intent (intenção) →objeto de mensagem para solicitar uma ação (explícita ou implícita) de outro componente;
        • casos de uso
          • Iniciar nova instância → startActivity() ou startActivityForResult();
            • navegabilidade → new Intent(this, NextActivity.class);
            • imagem da câmera → new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
            • abrir o navegador → new Intent(Intent.ACTION_VIEW, Uri.parse(sURL));
          • Iniciar um serviço → startService() ou bindService();
          • Iniciar uma transmissão → sendBroadcast(), sendOrderedBroadcast() ou sendStickyBroadcast();
        • explícitas → indica o nome totalmente qualificado da classe (atividade ou serviço), normalmente componente no próprio aplicativo;
          • new Intent(this, DownloadService.class);
          • new Intent(this, NextActivity.class);
        • implícitas → indica uma String padrão (Intent.ACTION_VIEW) em que sistema avalia todos os aplicativos instalados para determinar quais deles podem tratar esse tipo de intenção;
          • Intent it = new Intent(Intent.ACTION_VIEW, Uri.parse(sURL));
          • if (it.resolveActivity(getPackageManager()) != null) { startActivity(it); } // teste comumente realizado em ações implícitas;
        • componentes
          • nome do componente → argumento de tipo classe, em geral ‘this’ (torna uma intenção explícita)
            • new Intent(this, NextActivity.class);
          • ação → argumento de tipo String que especifica a ação genérica a realizar (torna uma intenção implícita)
            • new Intent(Intent.ACTION_VIEW, Uri.parse(sURL));
          • dados → argumento de tipo URI que referencia os dados a serem aproveitados e/ou o tipo MIME desses dados
            • setData(), setType() ou setDataAndType();
          • categorias → String que contém informações adicionais sobre o tipo de componente que deve tratar da intenção
            • addCategory();
          • extra → Pares de valores-chave que carregam informações adicionais
            • putExtra();
          • sinalizadores → funcionam como metadados para a intenção
            • setFlags();
      • Broadcast Receiveis (receptor de broadcast) → permite o tratamento de eventos externos;
        • Intents globais enviados pelo sistemas;
        • requer um Intent Filter para selecionar os Intents que serão tratados;
      • Content Provider (provedor de conteúdo) → permite compartilhar dados entre aplicativos;
        • gerenciam o acesso a um conjunto estruturado de dados e fornecem mecanismos para definir a segurança dos dados;
        • interface padrão para a comunicação de dados em um processo com execução de código em outro processo;
        • pode usar qualquer forma de armazenamento de dados (persistente ou não);


Reinaldo Gil Lima de Carvalho