UaiMockServer – Muitas novidades para ajudar ainda mais em seus testes

Olá, tudo bem?

A nova versão do uaiMockServer tem diversas novas funcionalidades que vão revolucionar os frameworks open source que fazem papel de mock HTTP.

A primeira grande novidade é justamente uma tela que permite a edição dos seus requests:

Index

Index

Agora não será mais necessário você editar seus requests através de um tedioso arquivo de configuração, utilize a ferramenta gráfica que fará isso de modo simples e prático. Basta acessar a tela de edição pela URL: http://localhost:1234/uaiGui/index

Outra novidade é justamente poder identificar o que está sendo enviado e recebido no request de um modo prático. Basta ir na aba “Log” e disparar o request:

Request Log

Request Log

Ao detalhar um request com sucesso você poderá ver:

Success Request

Success Request

Ao detalhar um requets com erro você verá como:

Error Detail 01

Error Detail 01

Um detalhe interessante é que será possível ver o Log do Servidor, esse log ajudará analisar o que aconteceu de errado no request:

Error Detail 02

Error Detail 02

E por último, mas não menos importante, agora é possível utilizar Runner em seus testes com JUnit. Veja o exemplo abaixo:

UaiMockServer JUnit Runner

UaiMockServer JUnit Runner

Desse modo você não precisa mais fazer o controle manual do seu servidor. Você também pode especificar qual o arquivo de configuração a ser utilizado:

UaiMockServer JUnit Runner Configuration

UaiMockServer JUnit Runner Configuration

E para você que usa o Spring, você também pode utilizar o Runner especializado para o Spring:

UaiMockServer JUnit SpringRunner Configuration

UaiMockServer JUnit SpringRunner Configuration

Uma última alteração que foi necessário é fazer a troca do tipo do arquivo de configuração, infelizmente não é mais possível usar o arquivo do tipo HCON como na primeira versão. Agora o arquivo deve ser no formato JSON. Peço desculpas ao incômodo que isso possa causar, mas foi uma mudança para melhor.

O arquivo de configuração está como abaixo:

New Configuration File as JSON

New Configuration File as JSON

Uma vantagem em ter o arquivo de configuração em formato JSON é justamente de qualquer editor de texto poder formatar o código.

Site do projeto: http://uaimockserver.com

Código fonte: https://github.com/uaihebert/uaiMockServer

Versão standalone e arquivo de configuração: https://sourceforge.net/projects/uaimockserver/

Import do Maven:

<dependency>
    <groupId>uaihebert.com</groupId>
    <artifactId>uaiMockServer</artifactId>
    <version>1.1.0</version>
    <scope>test</scope>
</dependency>

Espero que você goste das novidades.

Qualquer dúvida ou sugestão, poste como comentário abaixo.

o_

uaiMockServer – Crie um servidor Rest de teste com apenas uma linha de comando

Olá, tudo bem?

Sabe aquele momento em que você precisa chamar um serviço REST, mas esse serviço não está pronto ainda?

Imagine que você está desenvolvendo uma nova tela do APP que o serviço REST ainda não está pronto. Nesse caso você precisará ter um código falso em seu projeto, e esse código terá que ser substituído quando o serviço ficar pronto. Não importa se você trabalha com Java, .NET, PHP, Ruby, Python, etc.. Você terá que ter sempre o trabalho de primeiro criar o mock e depois criar a chamada real quando o serviço REST não estiver pronto.

Para testes unitários temos o mesmo problema, é comum termos uma classe com a implementação real e uma classe com um código falso. Na hora do teste é que a classe falsa é utilizada. O ruim dessa abordagem é que o código que executa a chamada nunca é testado.

Como podemos resolver esse problema? E o mais interessante: “existe uma solução que atenda delphi, .NET, PHP, Java, Android, IOS, WindowsPhone, etc?”

Apresento para vocês o mais novo produto que criei: “uaiMockServer

Com o uaiMockServer você poderá criar um servidor de teste utilizando o JAR e um arquivo de configuração. Com o uaiMockServer você poderá disparar os testes usando HTTP, mas com seus dados de testes.

Existem dois modos de utilizar o uaiMockServer: Standalone e com Testes Unitários.

Standalone

O modo standalone é quando você dispara o jar manualmente. Para executar o serviço manualmente basta fazer:

java -jar uaiMockServer-{VERSION}.Standalone.jar

Tudo o que você precisa agora é do arquivo de configuração que estará descrito mais abaixo.

No arquivo exemplo de configuração já vem mapeado um hello world apontando para a porta 1234. Se você estiver usando linux, execute o comando:

curl localhost:1234/uaiMockServer/

E você já verá o JSON retornado.

Testes Unitários

Primeiro passo é adicionar o projeto em seu pom:

<dependency>
   <groupId>uaihebert.com</groupId>
   <artifactId>uaiMockServer</artifactId>
   <version>1.0.1</version>
   <scope>test</scope>
</dependency>

Uma vez que a dependência já está em seu pom você pode criar um teste como o abaixo:

public class YourTest {
    private static UaiMockServer uaiMockServer;

    @BeforeClass
    public static void beforeClass() {
        uaiMockServer = UaiMockServer.start();
    }

    @AfterClass
    public static void afterClass() {
        uaiMockServer.shutdown();
    }

    @Test
    public void aTest() {
        final Customer customer = // invoke the URL
        assertTrue(customer != null);
    }
}

A chamada na URL tem que ser feita com algum framework de sua preferência. Eu coloco abaixo um exemplo feito utilizando RestEasy e o arquivo de configuração (mostrado mais abaixo):

@Test
public void isGetRootReturning200() {
    final String url = "http://localhost:1234/uaiMockServer/";

    Client client = ClientBuilder.newClient();
    Response response = client.target(url).request().get();

    assertEquals(200, response.getStatus());
}

A vantagem disso? Agora você não precisa mais de um código mock em seus testes. Você pode chamar diretamente do JUnit o servidor criado.

Configuração

Para rodar corretamente é necessário um arquivo de configuração. Um exemplo simples seria o arquivo abaixo:

com.uaihebert.uaimockserver {
	port = 1234
	host = localhost
	fileLog = false
	consoleLog = true
	context = /uaiMockServer
	defaultContentTypeResponse = "text/html;charset=UTF-8"
	routes = [
	    {
			request {
				path = "/"
				method = "GET"
			}
			response {
				contentType = "application/json;charset=UTF-8"
				statusCode = 200
				body = """{"mockBody":{"title":"Hello World"}}"""
			}
	    }
    ]
}

O arquivo tem que ter a extensão .config e não está no formato JSON, mas sim é um superset do JSON – HCON – utilizado para configurações (clique aqui para mais detalhes).

Com esse arquivo você pode configurar a porta a ser chamada, o host, header, queryparam e diversas outras funções que estão descritas na documentação do uaiMockServer.

Note que foi criado um request e response desse modo você pode simular toda chamada que você quiser.

Caso você rode a versão Standalone, esse arquivo deve ficar na mesma pasta que o jar. Você também pode passar o caminho completo assim:

java -jar uaiMockServer-{VERSION}.Standalone.jar CAMINHO_COMPLETO_DO_ARQUIVO

Caso você vá rodar o serviço em seus testes unitários (JUnit por exemplo), você deve colocar o arquivo na pasta “src/test/resources” do maven. Você também poderia passar o caminho completo do arquivo como:

uaiMockServer = UaiMockServer.start(CAMINHO_COMPLETO_DO_ARQUIVO);

É grátis?

Sim. Use a vontade.

O código fonte é aberto? Sim: https://github.com/uaihebert/uaiMockServer

A documentação está onde? http://uaimockserver.com

E para baixar o .config e o JAR Standalone? http://sourceforge.net/projects/uaimockserver/files/

Tem teste? Sim, Temos bastantes testes unitários e 100% de cobertura.

Performance desse trem é bom?

No próprio GIT tem um teste que dispara 300 requests e tem todas as resposta em menos de 2 segundos.

Agradecimentos Especiais

Seja um Desenvolvedor, não um liquidificador

Olá, tudo bem?

Vivemos em uma época onde é muito fácil de criar projetos com frameworks “mágicos”. O que é ensinado em diversos blogs e faculdades é que: “basta anotar com isso aqui que está pronto”.

Anotações tem a função de facilitar a utilização e a identificação de comportamentos dos frameworks, mas existem desenvolvedores que se perdem com essa facilidade e acabam esquecendo de conceitos básicos.

CRUD, filas JMS, Beans, controle de transações podem ser criados em minutos, mas e a parte de Orientação a Objeto? Conceitos básicos do Java? O que tem acontecido para que as boas práticas que demoraram anos para serem desenvolvidas simplesmente serem abandonadas?

Misturando Conceitos

Para ser mais claro, vamos ver alguns exemplos de códigos postados por desenvolvedores em fóruns. No primeiro exemplo é possível ver a mistura de JPA com JSON:

@Entity
@XmlRootElement
@JsonAutoDetect
@DiscriminatorColumn(name = "animal_type")
@JsonTypeInfo(
        use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.PROPERTY,
        property = "type")
@JsonSubTypes({
        @JsonSubTypes.Type(value = Dog.class, name = "dog"),
        @JsonSubTypes.Type(value = Cat.class, name = "cat"),
        @JsonSubTypes.Type(value = Bird.class, name = "bird")
})
public class Animal {

    @Id
    private int id;

    @JsonSerialize(using = JsonDateSerializer.class)
    private Date birthday;

    @JsonView(ToothView.class)
    @OneToMany(mappedBy = "animal")
    private List<Tooth> teethList;

    // other stuff
}

@Entity
@JsonRootName(value = "Dog")
@JsonIgnoreProperties(ignoreUnknown = true)
public class Dog extends Animal {

    @JsonProperty
    private String name;

    @Convert(converter = JsonAttributeConverter.class)
    private Double weight;

    @JsonIgnore
    @OneToMany(fetch = FetchType.EAGER, mappedBy = "dog", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Bone> boneList;

    public Dog() {
    }
}

Qual o problema do código acima? Qual o motivo da mistura de anotações de JSON (view) com anotações do JPA (modelo)? Note que, por causa dessa mistura, qualquer campo que a view deva exibir de modo diferente afetará justamente a mesma classe utilizada para salvar dados no banco de dados.

Não respeitando as camadas

Vamos a outro exemplo:

@ViewScoped
@ManagedBean
@TransactionManagement(TransactionManagementType.BEAN)
public class ManagedBeanOne extends SuperManagedBean implements Serializable {
     // attributes
    public String doSomething() {
        try{
            transaction.begin(); 
            // do something
            transaction.commit();
        }
        catch(Exception ex){
            transaction.rollback();
        }
    }
}


@ManagedBean
@WebService
@ViewScoped
public class ManagedBeanTwo implements Serializable{}

Por que fazer de um ManagedBean de JSF também como um EJB? E até pior, por que deixar que um ManagedBean controle uma transação? Qual o ganho em deixar o ManagedBean com diversas responsabilidades?

Tamanho mais atrapalha que ajuda

Um exemplo que eu não tive como colocar aqui foi de uma classe com mais de 1k de linhas. A pior parte é saber que esse tipo de classe fica sempre como motivo de chacota, ou essa classe é tratada como um objeto de terror e espanto pois qualquer alteração quebra o sistema.

Até quando os desenvolvedores vão ter o hábito de sempre querer adicionar um if sem antes fazer um pequeno refactoring?

Exception que é Chefe

Outra prática terrível é deixar uma exceção controlar o fluxo. Veja como é fácil cometer esse erro:

try{
    myObject.doSomething();
} catch(MyExceptionOne one){
    sendErrorSmsToCustomer();
    defineOldPlanToCustomer();
    sentToScreenOne();
} catch(MyExceptionTwo two){
    sendErrorEmailToCustomer();
    defineNewPlanToCustomer();
    sentToScreenTwo();
}

No exemplo acima, o que aconteceria com os dados do banco se na primeira linha de uma exceção acontecesse um erro? O que aconteceria se algum desenvolvedor fosse executar a chamada myObject.doSomething(); em alguma outra classe, e não tratasse todos os erros como no exemplo acima? E se ele não adicionasse a linha onde não trata o plano do usuário?

E agora?

Falar dos problemas é fácil, mas eu creio que ser necessário mostrar soluções que podemos aplicar em nosso dia a dia para melhorar a qualidade de código. O que vamos ver nas próximas páginas não é nada inventado por mim, mas são práticas extraídas de livros sobre design patterns e boas práticas de programação.

O que veremos:

  • Página 2: Não transpasse camadas
    • Atenção nos pacotes
  • Página 3: Aumente a coesão
  • Página 4: Reduza o acoplamento
    • Facade é uma boa pedida
  • Página 5: Voltemos ao mundo dos DTOs
    • Como facilitar a cópia de uma Entity para um DTO
  • Página 6: Métodos e Classes pequenas
  • Página 7: Como usar exceção corretamente?
  • Página 8: Teoria da Janela quebrada
    • Mantenha seu build sempre funcionando
    • Nunca deixe testes quebrados
    • Não comente/ignore seus testes
  • Página 9: Boas práticas que ajudam
    • KISS
    • DRY
  • Página 10: Quantidade de testes não importa, mas sim a qualidade
    • Utilize ferramentas
    • Achou um bug? Crie um teste
  • Página 11: Conclusão

Espero que este post seja útil ao seu dia a dia. (:

Não poderia deixar de agradecer ao Rodrigo Sasaki (http://cv.rodrigosasaki.com/) que me deu uma força absurda na revisão do post.

EasyCriteria evoluiu para uaiCriteria. Novo nome e novas funcionalidades

Olá, tudo bem?

É com muita felicidade que venho anunciar o uaiCriteria, a evolução do EasyCriteria.

Por que a mudança de nome? Descobri que já existia no mercado um framework com o mesmo nome e para evitar qualquer problema eu resolvi mudar o nome do framework. A diferença é que o uaiCriteria trabalha com String como parâmetro, e o outro framework trabalha com MetaModel diretamente.

Para esclarecer algumas dúvidas sobre a mudança:

  • Seu código antigo continuará funcionando sem problema algum, o código é retro compatível

  • As classes EasyCriteira estão marcadas com @Deprecated e serão removidas na próxima versão

  • As novas classes tem os mesmo métodos que as antigas e muitas outras novidades. Basta fazer um “replace” de EasyCriteria por UaiCriteria e todo problema estará resolvido

  • Novamente, eu não queria mudar o nome mas também não quero problemas com outras pessoas

O framework também ganhou um mascote, eu espero que vocês gostem:

mascote

mascote

De novidades temos muitas, mas muitas mesmo! Vamos ver primeiro mudanças de estrutura:

  1. O site mudou, agora o site é o: http://uaicriteria.com

  2. O repositório mudou, agora estamos hospedados no GIT. Após diversos pedidos movi para o GIT para melhorar a visualização do código: https://github.com/uaihebert/uaicriteria

  3. Para ajudar na cobertura do código e análise estática foi adicionado o plugin do SONAR. A imagem de cobertura agora ficou até mais bonita:

    uaicriteria cobertura

    uaicriteria cobertura

  4. O site antigo será desativado e todos os dados antigos foram levados para site novo, até mesmo a documentação legada. [=

  5. A API atual existe limitações, algo como não possibilitar o uso do HAVING e algumas outras funções, desse modo será criada para próxima versão uma Interface/API para Criterias Complexas – aceito sugestão de nome para a Interface (:

Com relação ao código, temos diversas novidades:

Boas vindas ao Batoo

O Batoo é um provedor de JPA assim como EclipseLink ou Hibernate. Com essa nova versão diversas funcionalidades foram cobertas com o Batoo.

Note que eu disse diversas, mas não todas. Infelizmente o Batoo ainda tem muitos, mas muitos problemas mesmo com consultas e Criterias.

O uaiCriteria ainda dá cobertura aos frameworks Hibernate, EclipseLink e OpenJPA na maioria dos métodos.

MultiSelect

É possível escolher quais campos serão retornados em uma consulta, veja a JPQL:

select 
    p.name, 
    p.age

from Person p

Transformando a consulta acima em criteria:

final UaiCriteria<Person> uaicriteria = 
    UaiCriteriaFactory.UaiCriteriaFactory.createMultiSelectCriteria(entityManager, Person.class);

uaiCriteria.addMultiSelectAttribute("name")
           .addMultiSelectAttribute("age");

final List multiselectList = uaiCriteria.getMultiSelectResult();

Algumas considerações sobre o código acima:

  • O resultado terá um Object caso você retorne apenas um campo

  • O resultado terá um Object[] caso você retorne diversos campos

  • A implementação pode variar de Object[] ou Vector (pelo menos comigo o EclipseLink estava retornando Vector)

SubQuery

Agora é possível fazer subQuery. Imagine uma JPQL como a abaixo:

select p from Person p 
where p.id in 
        (select dog.person.id from Dog dog where dog.cute = true)

Nem vou citar quantas linhas de código seriam necessárias para fazer o código acima, mas com o UaiCriteria ficou bem mais fácil:

final UaiCriteria<Person> uaiCriteria = UaiCriteriaFactory.createQueryCriteria(Person.class);

final UaiCriteria<Dog> subQuery = uaiCriteria.subQuery("person.id", Dog.class); // dog.person.id

subQuery.andEquals("cute", true);

uaiCriteria.andAttributeIn("id", subQuery); //person.id

Basta criar um objeto de subQuery passando qual será o retorno da subQuery. Depois chame o método o attributeIn(…) da query principal passando qual o campo a ser comparado.

MapIsEmpty [NOT]

Agora é possível utilizar a função isEmpty com Map:

uaiCriteria.andCollectionIsEmpty("ENTITY_MAP");

AttributeIn [NOT]

Existe a opção de verificar se um valor está ou não dentro de uma lista. Veja o exemplo abaixo:

select p
from Payment p
where
    p.statusEnum in :enumList

Para transformar o código acima em criteria:

final UaiCriteria<Payment> uaiCriteria = 
    UaiCriteriaFactory.createQueryCriteria(Payment.class);

uaiCriteria.andAttributeIn("statusEnum", 
                           Arrays.asList(StatusEnum.VALUE_01, StatusEnum.VALUE_02));

O atributo não precisa ser necessariamente um enum, poder ser número, string, etc.

MemberOf [NOT]

A consulta abaixo

select d
from Departament d
where :person member of d.employeeList

Pode ser criada como:

final UaiCriteria<Departament> uaiCriteria = UaiCriteriaFactory.createQueryCriteria(Departament.class);

uaiCriteria.andIsMemberOf(person, "employeeList");

Count e CountRegularCriteria

Agora como é possível realizar uma consulta MultiSelect o método count() foi renomeado como countRegularCriteria(). Funciona do mesmo modo, houve apenas uma alteração no nome para ficar mais claro seu funcionamento.

CountAttribute

Existe situações onde é necessário realizar o count em cima de um atributo, algo como:

select count(p.id)
from Person p

E para executar como Criteria:

final UaiCriteria<Person> uaiCriteria = 
    UaiCriteriaFactory.createMultiSelectCriteria(Person.class);

uaiCriteria.countAttribute("id");

final List result = uaiCriteria.getMultiSelectResult();

GroupBy e funções de Agregação

Agora é possível realizar groupBy juntamente com diversas funções de agregação. Funções como sum, diff, divide, module, etc.

select sum(p.value), p.status
from Payment p
group by p.status

Poderia se executada como:

final UaiCriteria<Payment> uaiCriteria = 
    UaiCriteriaFactory.createMultiSelectCriteria(Payment.class);

uaiCriteria.sum("id").groupBy("status");

final List result = uaiCriteria.getMultiSelectResult();

Novo Import no Maven

Para utilizar a nova versão em seu projeto, basta adicionar o código abaixo ao seu pom.xml

<dependency>
    <groupId>uaihebert.com</groupId>
    <artifactId>uaiCriteria</artifactId>
    <version>4.0.0</version>
</dependency>

Bem, espero que você tenha gostado das novidades.

Não esqueça de visitar o site —————-> http://uaicriteria.com

Qualquer dúvida/crítica/sugestão basta falar.

Até mais. o_

Alternativas ao JPA Hibernate. O que usar quando o JPA não atende meu projeto?

Olá, tudo bem?

Hoje vamos falar sobre situações onde o JPA pode não nos atender. Com quais alternativas podemos contar a partir do momento que percebemos que o JPA não está ajudando?

O que vamos ver aqui hoje:

  • Problemas do JPA e do Hibernate
  • Soluções para problemas do JPA
  • Critérios para escolha dos frameworks descritos aqui
  • Spring JDBC Template
  • MyBatis
  • Sormula
  • sql2o
  • Vale a pena conferir: jOOQ e Avaje
  • E o JDBC puro? Ainda vale a pena?
  • Considerações sobre qual framework escolher
  • Conclusão

Criei em meu github 4 CRUDS completos das ferramentas detalhadas aqui no post, cada URL está em cada página que descreve o framework.

Eu não sou o tipo de pessoa radical que acha que o JPA não serve para nada, pelo contrário, creio que em determinados momentos é necessário escolher o framework mais adequado para a cada situação. Para quem não sabe eu já escrevi um livro de JPA e ainda assim não o considero a bala de prata para todos os problemas.

Espero que vocês gostem. [=

Ultimo dia da promoção compre 1 e leve outro da Packt

Pessoal, bom dia.

Entraram em contato comigo da editora Pack pedindo para anunciar o último dia da promoção:

Packt Publishing celebrates their 2000th title with an exclusive offer – We’ve got IT covered!

Abaixo o texto promocional:

Known for their extensive range of pragmatic IT ebooks, Packt Publishing are celebrating their 2000th book title `Learning Dart’– they want their customers to celebrate too.

To mark this milestone Packt Publishing will launch a ‘Buy One Get One Free’ offer across all eBooks on March 18th – for a limited period only.

Packt is one of the most prolific and fast-growing tech book publishers in the world. Originally focused on open source software, Packt contributes back into the community paying a royalty on relevant books directly to open source projects. These projects have received over $400,000 as part of Packt’s Open Source Royalty Scheme to date.

Their books focus on practicality, recognising that readers are ultimately concerned with getting the job done. Packt’s digitally-focused business model allows them to quickly publish up-to-date books in very specific areas across a range of key categories – web development, game development, big data, application development, and more. Their commitment to providing a comprehensive range of titles has seen Packt publish 1054% more titles in 2013 than in 2006.

Here are some of the best titles across Packt’s main categories – but Buy One, Get One Free will apply across all 2000 titles:

Protegendo sua aplicação – Mini Livro

Olá, tudo bem?

Esse post é para comemorar a marca de 1 milhão de visualizações que o blog atingiu no mês passado. Abaixo você encontrará mini livro sobre segurança, grátis.

Todos os milhares de envolvidos no blog (cof cof cof) estão mega animados e prontos para celebrar esse marco histórico:

happy

Melhor deixar a celebração para outro dia… =P

Hoje vamos falar sobre segurança. Não apenas segurança de ambiente, mas também em como criar um código seguro. Esse post na verdade faz parte do que eu chamo de Mini Livro. Não será publicado como livro, mas também foge a regra de que um post deve ter poucas páginas.

Por diversas vezes ouvimos falar de ataques, mas não paramos para pensar em como poderíamos proteger nossa aplicação.

Um projeto com um código seguro e um ambiente de produção que sejam seguros e de rápida respostas a um ataque é primordial para qualquer empresa. Precisamos ter a certeza de que nosso código está seguindo boas práticas e que, nosso ambiente de produção está protegido e bem preparado para qualquer tipo de ataque que chegar.

Atenção: Eu não vou gerar uma versão em PDF deste post. Já levo muito tempo apenas para planejar, escrever, formatar e traduzir o post. Para mim é inviável gerar uma versão em PDF ou qualquer outro formato para colocar a disposição aqui no blog. Este mini livro estará apenas disponível online.

Graças ao Rogério Angeliski temos ao final do post a versão em PDF do post.
Muito obrigado Rogério!

O que veremos por aqui:

  • Página 02: No que se baseia segurança?
  • Página 03: Público Alvo
  • Página 04: Um bom hacker sempre tem tempo
    • Cuidado com a informação retornada
    • Cuidado com o tamanho da mensagem retornada
    • Firewall/SSL não faz mágica
  • Página 05: Tipos de ataques e sugestões para evitá-los/tratá-los:
    • SQL Injection
    • JPQL Injection e HQL Injection
    • Cross-Site scripting (XSS)
    • Brute Force Attack
    • Man In The Middle
    • XPath Injection
    • LDAP Injection
    • DoS ou DDoS
    • Slow DoS
  • Página 06: Cuidado com os dados
    • Protegendo a entrada de dados
    • Protegendo a saída de dados
  • Página 07: Cuidados com o “Client Side”
    • Fique atento a URL
    • Testes Técnicos
  • Página 08: Validações
    • Validando dados
    • Cuidado com arquivos
  • Página 09: Sempre dê o menor privilégio possível
  • Página 10: Trate os erros do projeto
  • Página 11: Cuidados com bibliotecas de terceiros
  • Página 12: Versão do projeto
  • Página 13: Preste atenção com o log
  • Página 14: Separe seu projeto das camadas
  • Página 15: Comentários nem sempre são saudáveis
  • Página 16: Sempre valide seu código
  • Página 17: Tenha um CheckList
  • Página 18: Cuidado com a equipe de TI
    • Exposição dos dados
    • Cuidado com o código escrito
    • Futuro ex-funcionário
    • Code Review / Pair Programming
    • Fique atento a terminologia
  • Página 19: Proteja a senha do modo correto
  • Página 20: Boas práticas para controle de acesso
    • Esconda o botão/link, mas proteja o código
    • Conheça a necessidade do seu usuário
    • Sempre oculte
  • Página 21: Políticas de Segurança
  • Página 22: Evitando falhas de códigos e/ou frameworks
    • Não exponha tecnologias desnecessariamente
    • Nunca misture os tipos
    • Utilize chaves nos “IFs”
    • Inteiros com Flutuantes
    • Sempre programe defensivamente

Não sou nenhum especialista no assunto, apenas estou compartilhando coisas que aprendi por leitura ou vivenciei no dia a dia do desenvolvimento.

Vamos começar?

Review do Livro: Developing RESTful Services

Olá pessoal, tudo bem?

Fui convidado pela editora Packt para fazer o review do livro: Developing RESTful Services with JAX-RS 2.0, WebSockets, and JSON.

Esse livro foi laçado em inglês apenas e não sei se haverá uma versão em português.

Ele é um livro pequeno e direto. Não se aprofunda muito no assunto, mas mostra todos os conceitos necessários para começar a construir um projeto com conceitos RESTFul.

O que mais me chamou atenção do livro foi que no capítulo dois onde ele descreve sobre pooling. O assunto foi muito bem abordado e detalhado.

Ao final do livro é possível encontrar dois projetos completos que mostram duas abordagens para a utilização de Webservice em um projeto.

É um livro interessante para quem quer saber rapidamente sobre os conceitos básicos de Webservices.

Até a próxima pessoal! o_

Novo livro lançado: JPA Eficaz: As melhores práticas de persistência de dados em Java

Pessoal, bom dia.

É com muita alegria que gostaria de compartilhar que meu novo livro acabou de ser lançado.

JPA Eficaz: As melhores práticas de persistência de dados em Java

JPA-Eficaz-ebook_large

Ele aborda diversos assuntos do JPA, desde os conceitos básicos como analisando o persistence.xml a como fazer controle de concorrência.

Aqui é possível fazer o download de todo o sumário do livro: https://s3.amazonaws.com/casadocodigo/jpa-eficaz/sumario.pdf

São 173 páginas com códigos detalhados, explicações do conceito do JPA com exemplos que se aplicam ao nosso dia a dia.

Uma lista de discussão do livro já foi criada e é livre para qualquer participar: https://groups.google.com/d/forum/jpa-eficaz

Para comprar o livro, basta vir aqui: http://www.casadocodigo.com.br/products/livro-jpa-eficaz

E aguardem que até o final do ano, mais um mini livro de um assunto ainda não detalhado aqui no blog. ;)