Questionário: Escopos e configuração avançada

Teste seus conhecimentos sobre escopos e propriedades de configuração.

30 questões - Clique em cada pergunta para revelar a resposta.

Questões 1-15: Escopos

Questão 1: Qual é o escopo padrão de um bean Spring?

Resposta: Singleton - uma única instância por container Spring.

@Component
public class MyService { }  // Singleton por padrão

Questão 2: Como criar um bean prototype?

Resposta:

@Component
@Scope("prototype")
public class PrototypeBean { }

// Ou
@Bean
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public MyService myService() { }

Nova instância a cada obtenção.

Questão 3: Quando usar o escopo prototype?

Resposta:

Objetos com estado mutável
Objetos não thread-safe
Objetos custosos de criar mas de uso único
Workflows ou processos independentes

Exemplo: parser de arquivo, processador de comando.

Questão 4: O que é o escopo request?

Resposta: Uma instância por requisição HTTP:

@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestContext {
    private User currentUser;
    // Dados específicos da requisição
}

Destruído ao final da requisição.

Questão 5: O que é o escopo session?

Resposta: Uma instância por sessão HTTP:

@Component
@Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class ShoppingCart {
    private List<Item> items = new ArrayList<>();
}

Persiste entre as requisições do mesmo usuário.

Questão 6: Por que proxyMode é necessário para request/session?

Resposta: O singleton é criado na inicialização, antes de qualquer requisição. O proxy permite acessar o bean com escopo dinamicamente:

@Component
@Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestData { }

@Service  // Singleton
public class MyService {
    private final RequestData data;  // Proxy, não a instância real
}

Questão 7: Quais são os tipos de proxyMode?

Resposta:

Modo	Uso
`DEFAULT`	Sem proxy
`NO`	Sem proxy
`INTERFACES`	Proxy JDK (interface)
`TARGET_CLASS`	Proxy CGLIB (classe)

Use TARGET_CLASS para classes concretas.

Questão 8: Como criar um escopo personalizado?

Resposta:

public class TenantScope implements Scope {
    
    private final ThreadLocal<Map<String, Object>> beans = new ThreadLocal<>();
    
    @Override
    public Object get(String name, ObjectFactory<?> factory) {
        Map<String, Object> scope = beans.get();
        if (!scope.containsKey(name)) {
            scope.put(name, factory.getObject());
        }
        return scope.get(name);
    }
    
    @Override
    public Object remove(String name) {
        return beans.get().remove(name);
    }
    // ...
}

@Configuration
public class ScopeConfig implements BeanFactoryPostProcessor {
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory factory) {
        factory.registerScope("tenant", new TenantScope());
    }
}

Questão 9: Como gerenciar thread-safety com singletons?

Resposta:

Beans stateless (sem campos mutáveis)
Campos imutáveis (final)
Sincronização se necessário
Usar ThreadLocal para estado por thread

@Service
public class StatelessService {
    // Sem campos mutáveis
    private final UserRepository repo;  // Imutável
    
    public User process(Long id) {
        // Tudo em variáveis locais
        return repo.findById(id).orElseThrow();
    }
}

Questão 10: Como verificar o escopo de um bean?

Resposta:

@Autowired
private ConfigurableListableBeanFactory beanFactory;

public void checkScope() {
    BeanDefinition definition = beanFactory.getBeanDefinition("myBean");
    String scope = definition.getScope();
    log.info("Scope: {}", scope);  // singleton, prototype, etc.
}

Questão 11: Como usar @RefreshScope?

Resposta: Para beans que precisam ser recriados após um refresh de configuração:

@RefreshScope
@Component
public class DynamicConfig {
    
    @Value("${app.feature.enabled}")
    private boolean featureEnabled;
}

Após POST /actuator/refresh, o bean é recriado com os novos valores.

Questão 12: Como testar beans com escopo?

Resposta:

@SpringBootTest
@WebAppConfiguration  // Para request/session scope
class ScopedBeanTest {
    
    @Autowired
    private WebApplicationContext context;
    
    @Test
    void testRequestScope() {
        MockHttpServletRequest request = new MockHttpServletRequest();
        RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request));
        
        try {
            RequestData data = context.getBean(RequestData.class);
            assertThat(data).isNotNull();
        } finally {
            RequestContextHolder.resetRequestAttributes();
        }
    }
}

Questão 13: Como beans prototype são destruídos?

Resposta: O Spring não destrói beans prototype automaticamente!

@Component
@Scope("prototype")
public class ExpensiveResource implements DisposableBean {
    
    @Override
    public void destroy() {
        // Nunca chamado automaticamente!
    }
}

É necessário gerenciar manualmente ou usar um BeanFactoryPostProcessor.

Questão 14: Como obter múltiplos beans do mesmo tipo?

Resposta:

// Lista de todos os beans
@Autowired
private List<NotificationService> notificationServices;

// Map com nome como chave
@Autowired
private Map<String, NotificationService> notificationMap;

// ObjectProvider para acesso lazy
@Autowired
private ObjectProvider<NotificationService> provider;

public void notify() {
    provider.forEach(service -> service.send(message));
}

Questão 15: Como usar @Primary vs @Qualifier?

Resposta:

// @Primary: bean padrão
@Service
@Primary
public class EmailNotification implements NotificationService { }

@Service
public class SmsNotification implements NotificationService { }

// @Qualifier: escolha explícita
public MyController(@Qualifier("smsNotification") NotificationService notif) { }

Questões 16-30: Configuração

Questão 16: Como ler uma propriedade com @Value?

Resposta:

@Value("${app.name}")
private String appName;

@Value("${app.timeout:5000}")  // Valor padrão
private int timeout;

@Value("${app.features}")  // Lista: a,b,c
private List<String> features;

@Value("#{${app.map}}")  // Map: {key1: 'val1', key2: 'val2'}
private Map<String, String> map;

Questão 17: Como usar SpEL em @Value?

Resposta:

@Value("#{systemProperties['user.home']}")
private String userHome;

@Value("#{T(java.lang.Math).random()}")
private double randomValue;

@Value("#{myBean.property}")
private String fromBean;

@Value("#{${app.timeout} * 2}")
private int doubleTimeout;

Questão 18: Como agrupar propriedades com @ConfigurationProperties?

Resposta:

# application.yml
app:
  mail:
    host: smtp.example.com
    port: 587
    username: user
    password: secret

@ConfigurationProperties(prefix = "app.mail")
@Validated
public class MailProperties {
    
    @NotBlank
    private String host;
    
    @Min(1)
    @Max(65535)
    private int port;
    
    private String username;
    private String password;
    
    // Getters e setters
}

@Configuration
@EnableConfigurationProperties(MailProperties.class)
public class AppConfig { }

Questão 19: Como validar propriedades?

Resposta:

@ConfigurationProperties(prefix = "app")
@Validated
public class AppProperties {
    
    @NotNull
    private String name;
    
    @Min(1000)
    @Max(65535)
    private int port;
    
    @Email
    private String adminEmail;
    
    @Valid  // Validar objetos aninhados
    private DatabaseProperties database;
}

A aplicação falha na inicialização se inválido.

Questão 20: Como configurar objetos aninhados?

Resposta:

app:
  database:
    primary:
      url: jdbc:postgresql://primary/db
      username: user1
    secondary:
      url: jdbc:postgresql://secondary/db
      username: user2

@ConfigurationProperties(prefix = "app.database")
public class DatabaseProperties {
    private DataSourceConfig primary;
    private DataSourceConfig secondary;
    
    public static class DataSourceConfig {
        private String url;
        private String username;
        // Getters/setters
    }
}

Questão 21: Como configurar listas?

Resposta:

app:
  servers:
    - host: server1.example.com
      port: 8080
    - host: server2.example.com
      port: 8081

@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private List<ServerConfig> servers;
    
    public static class ServerConfig {
        private String host;
        private int port;
    }
}

Questão 22: Como usar perfis de configuração?

Resposta:

# application.yml (comum)
app:
  name: My App

---
# application-dev.yml
spring:
  config:
    activate:
      on-profile: dev
logging:
  level:
    root: DEBUG

---
# application-prod.yml
spring:
  config:
    activate:
      on-profile: prod
logging:
  level:
    root: WARN

Ativação:

java -jar app.jar --spring.profiles.active=prod

Questão 23: Como externalizar a configuração?

Resposta: Ordem de prioridade (da mais alta para a mais baixa):

Argumentos de linha de comando
Variáveis de ambiente
application-{profile}.yml externo
application.yml externo
application-{profile}.yml dentro do JAR
application.yml dentro do JAR

java -jar app.jar --server.port=9090
export SERVER_PORT=9090

Questão 24: Como carregar uma configuração de um arquivo externo?

Resposta:

# Arquivo externo
java -jar app.jar --spring.config.location=file:/etc/myapp/config/

# Vários locais
java -jar app.jar --spring.config.location=classpath:/,file:/config/

# Arquivo específico
java -jar app.jar --spring.config.name=custom

Questão 25: Como usar variáveis de ambiente?

Resposta:

spring:
  datasource:
    url: ${DB_URL:jdbc:h2:mem:default}
    username: ${DB_USER:sa}
    password: ${DB_PASSWORD:}

Convenção de mapeamento:

app.my-property → APP_MY_PROPERTY
. → _
- → _

Questão 26: Como criptografar propriedades sensíveis?

Resposta: Com Jasypt ou Spring Cloud Config:

<dependency>
    <groupId>com.github.ulisesbocchio</groupId>
    <artifactId>jasypt-spring-boot-starter</artifactId>
</dependency>

jasypt:
  encryptor:
    password: ${JASYPT_PASSWORD}

spring:
  datasource:
    password: ENC(encrypted_value_here)

Questão 27: Como criar um PropertySource personalizado?

Resposta:

public class VaultPropertySource extends PropertySource<VaultClient> {
    
    public VaultPropertySource(VaultClient client) {
        super("vault", client);
    }
    
    @Override
    public Object getProperty(String name) {
        if (name.startsWith("vault.")) {
            return source.getSecret(name.substring(6));
        }
        return null;
    }
}

@Configuration
public class VaultConfig implements EnvironmentPostProcessor {
    
    @Override
    public void postProcessEnvironment(ConfigurableEnvironment env, SpringApplication app) {
        env.getPropertySources().addFirst(new VaultPropertySource(client));
    }
}

Questão 28: Como atualizar a configuração em tempo real?

Resposta:

@RefreshScope
@Component
public class DynamicConfig {
    
    @Value("${app.feature.enabled}")
    private boolean enabled;
}

# Com Spring Cloud Config
curl -X POST http://localhost:8080/actuator/refresh

Os beans @RefreshScope são recriados.

Questão 29: Como testar propriedades de configuração?

Resposta:

@SpringBootTest(properties = {
    "app.name=Test App",
    "app.timeout=1000"
})
class ConfigTest {
    
    @Autowired
    private AppProperties properties;
    
    @Test
    void propertiesLoaded() {
        assertThat(properties.getName()).isEqualTo("Test App");
        assertThat(properties.getTimeout()).isEqualTo(1000);
    }
}

// Ou com arquivo de teste
@SpringBootTest
@TestPropertySource("classpath:test-config.properties")
class ConfigTest { }

Questão 30: Quais são as boas práticas de configuração?

Resposta:

Tipar com @ConfigurationProperties
Validar com @Validated
Externalizar os segredos
Documentar cada propriedade
Valores padrão sensatos
Perfis para ambientes
Não commitar segredos
Centralizar com Config Server em microsserviços

@ConfigurationProperties(prefix = "app")
@Validated
public class AppProperties {
    
    /**
     * Nome da aplicação exibido nos logs.
     */
    @NotBlank
    private String name = "My Application";
}

Pontuação

Pontuação	Nível
27-30	Excelente - Escopos e configuração dominados
21-26	Bom - Algumas revisões
15-20	Médio - Releia o capítulo
Menos de 15	Precisa revisar

Voltar ao Módulo 5

Questões 1-15: Escopos​

Questões 16-30: Configuração​

Pontuação​

Questões 1-15: Escopos

Questões 16-30: Configuração

Pontuação