Forem: Wellington Domiciano

Métodos obsoletos da HttpSecurity no Spring Security 6.1

Wellington Domiciano — Sat, 29 Jul 2023 23:07:21 +0000

No Spring Security 6.1 vários métodos da classe HttpSecurity tornaram-se obsoletos e isto afeta projetos criados com Spring Boot a partir da versão 3.1.

Métodos como cors(), csrf(), authorizeHttpRequests(), etc... não devem mais ser usados, pois a expectativa é de que sejam removidos no Spring Security 7.

O que devemos usar atualmente é a versão destes métodos que aceita um Customizer como argumento, o que a documentação chama de Lambda DSL.

Então, o que antes seria configurado assim:

http
  .authorizeHttpRequests()
    .requestMatchers("/blog/**").permitAll()
    .anyRequest().authenticated()
    .and()
  .cors()
    .and()
  .csrf()
    .disable()

Hoje deve ser feito assim:

import static org.springframework.security.config.Customizer.withDefaults;
// ...
http
  .authorizeHttpRequests(
    customizer -> customizer
      .requestMatchers("/blog/**").permitAll()
      .anyRequest().authenticated()
  )
  .cors(withDefaults())
  .csrf(customizer -> customizer.disable())

Este não é um jeito novo, pois está presente desde o Spring Security 5.2, que saiu em 2019. Apenas o que era opcional, hoje é recomendado e logo será requerido e uma das justificativas é de que o estilo de configuração antigo é bastante confuso.

O uso do método estático withDefaults() indica que estamos ativando aquela funcionalidade com suas configurações padrão, mas ele é opcional.

Você poderia usá-lo sem a importação estática.

import org.springframework.security.config.Customizer;
// ...
http
  // ...
  .formLogin(Customizer.withDefaults())
  // ...

Ou apenas usando uma expressão lambda com o corpo vazio.

http
  // ...
  .httpBasic(customizer -> {})
  // ...

E para desabilitar uma funcionalidade é possível usar method references, que eu, particularmente, acho mais elegante.

import org.springframework.security.config.annotation.web.configurers.CsrfConfigurer;
// ..
http
  // ...
  .csrf(CsrfConfigurer::disable)
  // ...

Para mais informações, visite esta página da documentação oficial:

https://docs.spring.io/spring-security/reference/migration-7/configuration.html

Embora eu tenha focado nos métodos da HttpSecurity, outras coisas se tornaram obsoletas nesta versão e a lista completa esta na página abaixo.

https://docs.spring.io/spring-security/site/docs/6.1.2/api/deprecated-list.html#method

Vale destacar que para configurar o HttpSecurity não é necessário encadear os métodos como nos exemplos acima. O mesmo resultado pode ser alcançado da seguinte forma:

http
  .authorizeHttpRequests(
    customizer -> {
      customizer.requestMatchers("/blog/**").permitAll();

      customizer.anyRequest().authenticated();
    }
  );

http.cors(withDefaults());

http.csrf(customizer -> customizer.disable());

// ...

return http.build();

Assim, se você estiver com problemas para entender a Lambda DSL, fazer invocações separadas como acima pode lhe ajudar a entendê-la melhor.

O método toString do Java

Wellington Domiciano — Tue, 05 Apr 2022 02:35:46 +0000

Criou uma classe maneira e na hora de mostrar o resultado com print() viu uns números estranhos?

class User {
  private String name;
  private int age;

  User(String name, int age) {
    this.name = name;
    this.age = age;
  }
}

public class Main {
  public static void main(String... args) {
    User user = new User("João", 29);

    System.out.println(user); // Apenas um ex.: User@1a2b3c
  }
}

Não se preocupe, a sua classe está apenas usando o método toString() implementado na classe Object.

Nesta implementação é usado o nome da classe seguido pelo símbolo @ e finalizando com o hashcode do objeto (mas em hexadecimal).

Dá para atestar isso com o código abaixo.

class User {
  private String name;
  private int age;

  User(String name, int age) {
    this.name = name;
    this.age = age;
  }
}

public class Main {
  public static void main(String... args) {
    User user = new User("João", 29);

    String className = user.getClass().getName();
    int hashCode = user.hashCode();
    String myToString = className + '@' + Integer.toHexString(hashCode);

    System.out.println(user.toString().equals(myToString)); // true
  }
}

Ou olhando a documentação.

Ou olhando o código fonte.

Porém, somos livres para sobrescrever este método e deixar do jeito que quisermos.

class User {
  private String name;
  private int age;

  User(String name, int age) {
    this.name = name;
    this.age = age;
  }

  @Override
  public String toString() {
    return "User[name=" + name + ", age=" + age + "]";
  }
}

O jeito mostrado no exemplo acima é parecido com o que algumas IDEs geram automaticamente. Mas, na minha opinião, há formas mais elegantes de obter o mesmo resultado, veja:

@Override
public String toString() {
  return String.format("User[name=%s, age=%d]", name, age);
}

Ou, com Java 17 ou mais recente:

@Override
public String toString() {
  return "User[name=%s, age=%d]".formatted(name, age);
}

O que achou? Não ficou muito mais fácil de ler?

Arrays também usam a implementação padrão e uma das opções mais simples que temos para mostrar o seu conteúdo é com o método Arrays.toString(), veja:

import java.util.Arrays;

public class Main {
  public static void main(String... args) {
    int[] numbers = { 1, 2, 3 };

    System.out.println(Arrays.toString(numbers)); // [1, 2, 3]
  }
}

Se for um array de arrays, toString() não é o bastante. Precisamos do deepToString():

import java.util.Arrays;

public class Main {
  public static void main(String... args) {
    int[][] numbers = {
      { 1, 2, 3 },
      { 4, 5, 6 },
      { 7, 8, 9 }
    };

    System.out.println(Arrays.deepToString(numbers)); // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  }
}

Agora estamos prontos para deixarmos os nossos objetos mais apresentáveis!

Como agrupar asserts no JUnit

Wellington Domiciano — Wed, 16 Mar 2022 04:53:15 +0000

Pode haver momentos em que precisamos usar múltiplos asserts em um mesmo teste. Independente se você considera certo ou errado, afinal não estamos aqui para julgar, eu gostaria de apresentar uma forma de lidar melhor com estes asserts agrupando-os através do método assertAll().

No código abaixo eu tenho 2 testes, cada um com 2 asserts que falham. No primeiro eu usei asserts individuais enquanto no segundo eu os agrupei.

import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.fail;

import org.junit.jupiter.api.Test;

class AppTest {
  @Test
  void usingIndividualAsserts() {
    fail("Test 1, assert 1");
    fail("Test 1, assert 2");
  }

  @Test
  void usingGroupedAsserts() {
    assertAll(
      () -> fail("Test 2, assert 1"),
      () -> fail("Test 2, assert 2")
    );
  }
}

Meu build.gradle.kts está assim (estou usando Gradle 8.4):

plugins {
  java
}

repositories {
  mavenCentral()
}

dependencies {
  testImplementation(platform("org.junit:junit-bom:5.10.0"))
  testImplementation("org.junit.jupiter:junit-jupiter")
}

tasks.test {
  useJUnitPlatform()

  testLogging {
    showExceptions = true
    showCauses = false
    showStackTraces = false
    exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
  }
}

E esta é a estrutura do meu projeto de teste:

project
├── build.gradle
└── src
    └── test
        └── java
            └── AppTest.java

A princípio ambos os testes rodam da mesma forma, porém, veja a saída no console quando eu executo o comando gradle test:

AppTest > usingIndividualAsserts() FAILED
    org.opentest4j.AssertionFailedError: Test 1, assert 1

AppTest > usingGroupedAsserts() FAILED
    org.gradle.internal.exceptions.DefaultMultiCauseException: Multiple Failures (2 failures)
        org.opentest4j.AssertionFailedError: Test 2, assert 1
        org.opentest4j.AssertionFailedError: Test 2, assert 2

Veja como no primeiro teste apenas a primeira falha é reportada. Na verdade, ele nem chega a executar o segundo assert, pois o teste é interrompido imediatamente.

Já no segundo teste as 2 falhas são reportadas nos dando a visão completa do que deu errado logo de cara.

Por isso, se vai usar vários asserts num mesmo teste, não deixe de agrupá-los, beleza?

The Java's Boolean class

Wellington Domiciano — Tue, 14 Dec 2021 14:59:52 +0000

As of Java 9 the Boolean class constructors have become deprecated and when we want to use Boolean instances we use Boolean.TRUE or Boolean.FALSE constants.

We can get one of these constants from a primitive using the Boolean.valueOf() method.

System.out.println(Boolean.valueOf(true) == Boolean.TRUE); // true
System.out.println(Boolean.valueOf(false) == Boolean.FALSE); // true

This method also accepts a String that, if it equals the word true, ignoring if the letters are uppercase or lowercase, the result will be equal to Boolean.TRUE, otherwise it will be Boolean.FALSE.

System.out.println(Boolean.valueOf("true") == Boolean.TRUE); // true
System.out.println(Boolean.valueOf("TRUE") == Boolean.TRUE); // true
System.out.println(Boolean.valueOf("TrUe") == Boolean.TRUE); // true
System.out.println(Boolean.valueOf("false") == Boolean.FALSE); // true
System.out.println(Boolean.valueOf("") == Boolean.FALSE); // true
System.out.println(Boolean.valueOf(null) == Boolean.FALSE); // true

The Boolean.parseBoolean() method also accepts a String and works the same way, but returns a primitive instead of an object.

Using in expressions

We can use a Boolean directly in places where booleans expressions are expected, such as in if or while conditions.

Boolean value = Boolean.TRUE;

if (value) {
  // ...
}

while (value) {
  // ...
}

But be aware that as a Boolean can be null, a NullPointerException can be thrown.

Boolean value = null;

if (value) { // will throw NullPointerException
  // ...
}

Other cool static methods

The Boolean.logicalAnd() method is equivalent to using the && operator and returns true only if both values are true.

System.out.println(Boolean.logicalAnd(true, true));   // true
System.out.println(Boolean.logicalAnd(true, false));  // false
System.out.println(Boolean.logicalAnd(false, true));  // false
System.out.println(Boolean.logicalAnd(false, false)); // false

The Boolean.logicalOr() method is equivalent to using the || operator and returns true if at least one of the values is true.

System.out.println(Boolean.logicalOr(true, true));   // true
System.out.println(Boolean.logicalOr(true, false));  // true
System.out.println(Boolean.logicalOr(false, true));  // true
System.out.println(Boolean.logicalOr(false, false)); // false

The Boolean.logicalXor() methods is equivalent to using the ^ operator and returns true only if one of the values is true.

System.out.println(Boolean.logicalXor(true, true));   // false
System.out.println(Boolean.logicalXor(true, false));  // true
System.out.println(Boolean.logicalXor(false, true));  // true
System.out.println(Boolean.logicalXor(false, false)); // false

The Boolean.getBoolean() method is used to return a System Property as a boolean primitive following to same rules as the Boolean.parseBoolean() method.

It is possible to pass to the program arbitrary System Properties using the -D option at runtime.

// Compile and run with the command below.
// java -Daaa=true -Dbbb=false Program
public class Program {
  public static void main(String... args) {
    System.out.println(Boolean.getBoolean("aaa")); // true
    System.out.println(Boolean.getBoolean("bbb")); // false
  }
}

A classe Boolean do Java

Wellington Domiciano — Tue, 14 Dec 2021 14:58:16 +0000

A partir do Java 9 os construtores da classe Boolean tornaram-se obsoletos e quando queremos usar instâncias de Boolean usamos as constantes Boolean.TRUE ou Boolean.FALSE.

Podemos obter uma destas constantes a partir de um primitivo usando o método Boolean.valueOf().

System.out.println(Boolean.valueOf(true) == Boolean.TRUE); // true
System.out.println(Boolean.valueOf(false) == Boolean.FALSE); // true

Este método também aceita uma String que, se for igual a palavra true ignorando se as letras são maiúsculas ou minúsculas, o resultado será igual a Boolean.TRUE, caso contrário será Boolean.FALSE.

System.out.println(Boolean.valueOf("true") == Boolean.TRUE); // true
System.out.println(Boolean.valueOf("TRUE") == Boolean.TRUE); // true
System.out.println(Boolean.valueOf("TrUe") == Boolean.TRUE); // true
System.out.println(Boolean.valueOf("false") == Boolean.FALSE); // true
System.out.println(Boolean.valueOf("") == Boolean.FALSE); // true
System.out.println(Boolean.valueOf(null) == Boolean.FALSE); // true

O método Boolean.parseBoolean() também aceita uma String e funciona da mesma forma, mas retorna um primitivo ao invés de um objeto.

Uso em expressões

Podemos usar um Boolean diretamente em locais em que expressões booleanas são esperadas, como nas condições do if ou do while.

Boolean value = Boolean.TRUE;

if (value) {
  // ...
}

while (value) {
  // ...
}

Mas fique atento, pois como um Boolean pode ser null, uma NullPointerException pode ser lançada.

Boolean value = null;

if (value) { // vai lançar NullPointerException
  // ...
}

Outros métodos estáticos legais

O método Boolean.logicalAnd() é equivalente ao uso do operador && e retorna true apenas se ambos os valores forem true.

System.out.println(Boolean.logicalAnd(true, true));   // true
System.out.println(Boolean.logicalAnd(true, false));  // false
System.out.println(Boolean.logicalAnd(false, true));  // false
System.out.println(Boolean.logicalAnd(false, false)); // false

O método Boolean.logicalOr() é equivalente ao uso do operador || e retorna true se pelo menos um dos valores forem true.

System.out.println(Boolean.logicalOr(true, true));   // true
System.out.println(Boolean.logicalOr(true, false));  // true
System.out.println(Boolean.logicalOr(false, true));  // true
System.out.println(Boolean.logicalOr(false, false)); // false

O método Boolean.logicalXor() é equivalente ao uso do operador ^ e retorna true apenas se um dos valores forem true.

System.out.println(Boolean.logicalXor(true, true));   // false
System.out.println(Boolean.logicalXor(true, false));  // true
System.out.println(Boolean.logicalXor(false, true));  // true
System.out.println(Boolean.logicalXor(false, false)); // false

O método Boolean.getBoolean() é usado para retornar uma System Property como um primitivo boolean seguindo as mesmas regras do método Boolean.parseBoolean().

É possível passar para o programa System Properties arbitrárias usando a opção -D na hora de executar.

// Compile e execute com o comando abaixo.
// java -Daaa=true -Dbbb=false Program
public class Program {
  public static void main(String... args) {
    System.out.println(Boolean.getBoolean("aaa")); // true
    System.out.println(Boolean.getBoolean("bbb")); // false
  }
}

Como ler e escrever arquivos de texto com Java

Wellington Domiciano — Thu, 24 Jun 2021 16:50:08 +0000

Neste artigo eu apresento alguns casos de usos simples de leitura e escrita de arquivos de texto com Java.

Leitura

O código abaixo mostra como retornar todo o conteúdo de um arquivo de texto como uma String.

import static java.nio.charset.StandardCharsets.UTF_16;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class ReadingAllContent {
  public static void main(String... args) {
    try {
      Path path = Paths.get("text.txt");
      byte[] bytes = Files.readAllBytes(path);
      String content = new String(bytes, UTF_16);
      System.out.println(content);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Com Java 11 ou mais recente o código fica mais simples usando o método Files#readString:

Path path = Path.of("text.txt");
String content = Files.readString(path, UTF_16);

Também é possível retornar todas as linhas do arquivo como uma lista de String usando o método Files#readAllLines.

Path path = Paths.get("text.txt");
List<String> lines = Files.readAllLines(path, UTF_16);
lines.forEach(System.out::println);

Os métodos acima carregam todo o conteúdo do arquivo na memória de uma só vez, por isso só devem ser usados quando o arquivo não for tão grande.

Para ler arquivos maiores, linha a linha, podemos usar o método Files#lines que retorna uma Stream que lê as linhas conforme é consumida.

import static java.nio.charset.StandardCharsets.UTF_16;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Stream;

public class ReadingAsStream {
  public static void main(String... args) {
    Path path = Paths.get("text.txt");

    try (Stream<String> stream = Files.lines(path, UTF_16)) {
      stream.forEach(System.out::println);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

A Stream retornada precisa ser fechada quando não for mais útil, por isso, no exemplo eu utilizei o try-with-resource que garante seu fechamento.

Escrita

O código abaixo mostra como escrever uma String em um arquivo.

import static java.nio.charset.StandardCharsets.UTF_16;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class WritingString {
  public static void main(String... args) {
    try {
      Path path = Paths.get("text.txt");
      String content = "abc";
      byte[] bytes = content.getBytes(UTF_16);
      Files.write(path, bytes);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Com Java 11 ou mais recente o código fica mais simples usando o método Files#writeString.

Path path = Path.of("text.txt");
Files.writeString(path, "abc", UTF_16);

O método Files#write também aceita uma lista de String como argumento.

Path path = Paths.get("text.txt");
List<String> lines = Arrays.asList("a", "b", "c");
Files.write(path, lines, UTF_16);

Neste caso, cada String da lista será escrita como uma nova linha no arquivo.

Observação 1: Escolhendo o charset

Nos exemplos acima eu passei o Charset UTF-16 explicitamente apenas para mostrar que é possível, pois nem sempre é necessário.

O método Files#readString, por exemplo, poderia ser invocado assim:

Path path = Paths.get("text.txt");
String content = Files.readString(path);

Neste caso o charset usado por padrão será o UTF-8 e o mesmo vale para os métodos mostrados abaixo:

Path path = Paths.get("text.txt");

String a = Files.readString(path);

List<String> b = Files.readAllLines(path);

Stream<String> c = Files.lines(path);

Files.writeString(path, "abc");

Files.write(path, Arrays.asList("a", "b", "c"));

Já no método String#getBytes, se o charset não for passado explicitamente, será usado o charset padrão da sua plataforma. Para obter o charset padrão, você pode usar o método abaixo:

Charset charset = Charset.defaultCharset();

Por fim, a classe StandardCharsets possui constantes apenas para os charsets que são requeridos por qualquer implementação da plataforma Java. Se você precisar de um charset não definido nesta classe, é possível obter da seguinte forma:

Charset charset = Charset.forName("UTF-32");

Se o charset desejado for suportado pela JVM, uma instância de Charset será retornada, caso contrário uma exceção será lançada.

Observação 2: Outras opções

Os métodos de escrita Files#writeString e Files#write também aceitam opções extras.

Por padrão eles criarão um novo arquivo caso não exista ou sobrescreverão o conteúdo de um arquivo existente, mas é possível mudar este comportamento.

Considere o código abaixo:

import static java.nio.file.StandardOpenOption.APPEND;
import static java.nio.file.StandardOpenOption.CREATE;
import static java.nio.file.StandardOpenOption.CREATE_NEW;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class WritingWithOptions {
  public static void main(String... args) throws IOException {
    byte[] content = "abc".getBytes();

    /* 1 */ Files.write(Paths.get("a.txt"), content, APPEND);
    /* 2 */ Files.write(Paths.get("b.txt"), content, CREATE, APPEND);
    /* 3 */ Files.write(Paths.get("c.txt"), content, CREATE_NEW);
  }
}

O exemplo 1 acrescentará content à um arquivo existente e lançará uma exceção caso o arquivo não exista.

O exemplo 2 é parecido com o primeiro, mas criará um novo arquivo caso não exista ao invés de lançar uma exceção.

Já no exemplo 3 ele sempre tentará criar um novo arquivo e lançará uma exceção se o arquivo já existir.

Há outras opções disponíveis na classe StandardOpenOption, consulte a documentação para saber mais.

Conclusão

Há outras formas de ler e escrever arquivos em Java e compreender os métodos acima é um bom ponto de partida antes de partir para casos mais complexos.

Se encontrar algum erro ou tiver alguma informação adicional, não deixe de usar os comentários.

How to use @Attribute decorator in Angular

Wellington Domiciano — Tue, 09 Feb 2021 18:47:00 +0000

Clique aqui para ler em Português.

The @Attribute decorator allows passing data from a parent to a child component in a way very similar to the @Input decorator.

But @Attribute is very limited in comparison to @Input as it only allows passing simple static string data.

How to use

First, you must decorate a constructor parameter.

In the code below I used the readonly keyword just as a preference matter, your parameter doesn’t need to be read-only and you can use any access modifier you want.

@Component({
  selector: "app-hello",
  template: `{{ parameter }}`,
})
export class HelloComponent {
  constructor(@Attribute("message") readonly parameter: string) {}
}

So you can pass a static string as a normal HTML attribute. Note that the attribute name must be the same as the argument passed to @Attribute.

@Component({
  selector: "app-root",
  template: `<app-hello message="Hello"></app-hello>`,
})
export class AppComponent {}

How DO NOT use

You cannot use data binding with @Attribute. The code below shows four WRONG ways to use this decorator.

@Component({
  selector: "app-root",
  template: `
    <app-hello [attr.message]="'Hello'"></app-hello>
    <app-hello [message]="'Hello'"></app-hello>
    <app-hello message="{{ hello }}"></app-hello>
    <app-hello [message]="hello"></app-hello>
  `,
})
export class AppComponent {
  hello = "World";
}

Final thoughts

Although the @Input decorator is more flexible, sometimes a simple static string may be more suitable. In these times the @Attribute decorator may be very useful.

I hope this article was helpful.