<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Alexandre Lucchetta on Medium]]></title>
        <description><![CDATA[Stories by Alexandre Lucchetta on Medium]]></description>
        <link>https://medium.com/@luchetti.92?source=rss-f733742f1761------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*0IKOffkS7oOangHoSO5JzA.jpeg</url>
            <title>Stories by Alexandre Lucchetta on Medium</title>
            <link>https://medium.com/@luchetti.92?source=rss-f733742f1761------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 07:16:45 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@luchetti.92/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[#11 Qual a diferença entre Statement e PreparedStatement no JDBC?]]></title>
            <link>https://medium.com/@luchetti.92/11-qual-a-diferen%C3%A7a-entre-statement-e-preparedstatement-no-jdbc-e50b99b52937?source=rss-f733742f1761------2</link>
            <guid isPermaLink="false">https://medium.com/p/e50b99b52937</guid>
            <category><![CDATA[jdbc]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[backend-engineering]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[sql]]></category>
            <dc:creator><![CDATA[Alexandre Lucchetta]]></dc:creator>
            <pubDate>Mon, 20 Jul 2026 11:01:01 GMT</pubDate>
            <atom:updated>2026-07-20T11:01:01.751Z</atom:updated>
            <content:encoded><![CDATA[<h3>#11 Qual a diferença entre Statement e PreparedStatement no JDBC? Por que PreparedStatement é preferido, além da questão de SQL injection?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hxvc3jks455pThMOSRbyDw.png" /></figure><h3>Resposta direta</h3><p>Statement envia o texto SQL bruto para o banco exatamente como você monta a string. Cada execução é analisada (parsed), planejada e compilada do zero pelo engine do banco — não há reaproveitamento. Montar queries concatenando input do usuário em um Statement faz esse input ser interpretado como parte do próprio SQL, o que é exatamente o que permite SQL injection: um valor malicioso como &#39; OR &#39;1&#39;=&#39;1 muda a lógica da query.</p><p>PreparedStatement envia o template SQL com placeholders (?) uma vez, e o banco faz parse e compila um plano de execução (execution plan) para esse template. Os valores dos parâmetros são enviados separadamente, fora da string SQL (out-of-band), como dados tipados — nunca são mesclados ao texto SQL. É por isso que fecha o vetor de SQL injection: o parser nunca relê os parâmetros como SQL.</p><p>Além da segurança, há dois outros benefícios que entrevistadores costumam cobrar. Primeiro, cache de plano de execução (query plan caching): como o template é pré-compilado, o banco (e o driver JDBC, dependendo da configuração) pode reaproveitar o plano de execução entre chamadas com parâmetros diferentes, reduzindo o overhead de parsing em queries executadas repetidamente (ex: dentro de um loop ou em um hot path). Segundo, segurança de tipos (type safety): métodos como setInt, setString, setTimestamp tratam o escaping/formatação/encoding corretos para cada tipo JDBC, evitando bugs de formatação manual de string (formatação de data dependente de locale, escaping de aspas).</p><p>Um conceito relacionado: PreparedStatement suporta batching (addBatch() / executeBatch()), permitindo enviar vários conjuntos de parâmetros para o mesmo template em uma única viagem de rede (round trip) — crítico para performance de inserts/updates em massa (bulk), algo que o Statement puro tecnicamente também consegue fazer, mas sem o benefício de reaproveitar o plano.</p><h3>Exemplo de código</h3><pre>// VULNERABLE: user input becomes part of the SQL text<br>String unsafe = &quot;SELECT * FROM users WHERE email = &#39;&quot; + userInput + &quot;&#39;&quot;;<br>Statement stmt = connection.createStatement();<br>ResultSet rs = stmt.executeQuery(unsafe);<br><br>// SAFE: template is fixed, parameter sent separately<br>String sql = &quot;SELECT * FROM users WHERE email = ?&quot;;<br>PreparedStatement ps = connection.prepareStatement(sql);<br>ps.setString(1, userInput); // never merged into the SQL string<br>ResultSet rs2 = ps.executeQuery();<br><br>// Batching many inserts with one template<br>PreparedStatement insert = connection.prepareStatement(<br>    &quot;INSERT INTO logs (msg, level) VALUES (?, ?)&quot;);<br>for (LogEntry e : entries) {<br>    insert.setString(1, e.getMessage());<br>    insert.setString(2, e.getLevel());<br>    insert.addBatch();<br>}<br>insert.executeBatch(); // one round trip, plan reused</pre><h3>Armadilhas que os entrevistadores exploram</h3><ul><li>Achar que PreparedStatement sozinho impede toda SQL injection — se você concatenar input do usuário para montar nomes de tabela/coluna (identifiers) dinamicamente, o placeholder não ajuda, porque ? só funciona para valores (values), não para identifiers.</li><li>Esquecer de fechar (close) o PreparedStatement/ResultSet — sem try-with-resources, o cursor no banco e recursos do driver vazam (resource leak).</li><li>Assumir que o cache de plano de execução é automático e universal — depende do banco (query plan cache) e, em alguns drivers, de configurações específicas (ex: cachePrepStmts no MySQL Connector/J); não é garantido em todo setup.</li><li>Confundir executeQuery(), executeUpdate() e execute() — o primeiro é para SELECT (retorna ResultSet), o segundo para INSERT/UPDATE/DELETE (retorna contagem de linhas), o terceiro é genérico e usado quando não se sabe o tipo do resultado em tempo de compilação.</li><li>Reusar o mesmo PreparedStatement entre threads sem sincronização — não é thread-safe (thread-safe), diferente de uma Connection em pool corretamente configurada por thread.</li></ul><h3>Perguntas de follow-up</h3><blockquote>Como tornar nomes de tabela/coluna dinâmicos com segurança, já que placeholders não funcionam nesse caso?</blockquote><p>A prática segura é usar uma whitelist (allowlist) de nomes válidos conhecidos em tempo de compilação e escolher entre eles com um switch/mapa, nunca inserir a string do usuário diretamente. Nunca se deve montar identifiers por concatenação direta de input externo.</p><blockquote>Como o connection pooling (ex: HikariCP) interage com o cache de PreparedStatement?</blockquote><p>Pools como o HikariCP reutilizam conexões físicas (physical connections), e drivers como o do PostgreSQL ou MySQL podem cachear statements preparados por conexão (per-connection statement cache), então queries repetidas na mesma conexão reaproveitada evitam recompilação. Isso amplifica o ganho de performance do PreparedStatement em aplicações com pool bem configurado.</p><blockquote>Spring Data JPA / Hibernate ainda usa PreparedStatement por baixo dos panos?</blockquote><p>Sim — mesmo com JPQL ou Criteria API, o Hibernate traduz tudo para SQL e executa via PreparedStatement, com os valores das entidades vinculados como parâmetros (bound parameters). Por isso queries via JPA/Hibernate já são protegidas contra SQL injection por padrão, desde que não se use concatenação manual em @Query nativo.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e50b99b52937" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[#10 Como funciona a cadeia de filtros (filter chain) do Spring Security, e qual a diferença entre…]]></title>
            <link>https://medium.com/@luchetti.92/10-como-funciona-a-cadeia-de-filtros-filter-chain-do-spring-security-e-qual-a-diferen%C3%A7a-entre-55554364badd?source=rss-f733742f1761------2</link>
            <guid isPermaLink="false">https://medium.com/p/55554364badd</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[jwt-authentication]]></category>
            <category><![CDATA[spring]]></category>
            <category><![CDATA[spring-security]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Alexandre Lucchetta]]></dc:creator>
            <pubDate>Thu, 16 Jul 2026 11:01:01 GMT</pubDate>
            <atom:updated>2026-07-16T11:01:01.726Z</atom:updated>
            <content:encoded><![CDATA[<h3>#10 Como funciona a cadeia de filtros (filter chain) do Spring Security, e qual a diferença entre autenticação e autorização nesse pipeline?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iy7BIZJS18Zzz83Pl2lf4w.png" /></figure><h3>Resposta direta</h3><p>O Spring Security se conecta na cadeia de filtros de servlet através de um único Filter, o DelegatingFilterProxy, que delega para um FilterChainProxy gerenciado pelo Spring. Esse proxy guarda uma ou mais SecurityFilterChain — listas ordenadas de filtros, cada uma associada a um padrão de requisição (ex: uma cadeia para /api/**, outra para o resto).</p><p>Dentro da cadeia correspondente, a requisição passa por filtros ordenados: um carrega/salva o SecurityContext; filtros de autenticação (login por formulário, HTTP Basic, ou um filtro JWT customizado) verificam credenciais e, se ok, populam o SecurityContextHolder com um Authentication; o ExceptionTranslationFilter converte exceções de segurança em respostas HTTP; por fim o AuthorizationFilter decide o acesso usando um AuthorizationManager.</p><p>Autenticação (authentication) responde “quem é você” — roda primeiro sempre. Autorização (authorization) responde “você pode fazer isso” — roda depois, contra o recurso pedido. Falha na autenticação → 401. Passa na autenticação mas falha na autorização → 403.</p><h3>Exemplo de código</h3><pre>@Configuration<br>@EnableWebSecurity<br>public class SecurityConfig {<br><br>    @Bean<br>    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {<br>        http<br>            .authorizeHttpRequests(auth -&gt; auth<br>                .requestMatchers(&quot;/public/**&quot;).permitAll()<br>                .requestMatchers(&quot;/admin/**&quot;).hasRole(&quot;ADMIN&quot;)<br>                .anyRequest().authenticated()<br>            )<br>            .sessionManagement(sm -&gt; sm.sessionCreationPolicy(SessionCreationPolicy.STATELESS))<br>            .addFilterBefore(new JwtAuthFilter(), UsernamePasswordAuthenticationFilter.class);<br>        return http.build();<br>    }<br>}<br><br>class JwtAuthFilter extends OncePerRequestFilter {<br>    protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain chain)<br>            throws ServletException, IOException {<br>        String token = req.getHeader(&quot;Authorization&quot;);<br>        if (token != null &amp;&amp; isValid(token)) {<br>            Authentication auth = buildAuthentication(token); // sets authorities too<br>            SecurityContextHolder.getContext().setAuthentication(auth); // authentication step<br>        }<br>        chain.doFilter(req, res); // AuthorizationFilter runs further down the chain<br>    }<br>}</pre><h3>Armadilhas que os entrevistadores exploram</h3><ul><li>Confundir 401 (Unauthorized — falha de autenticação) com 403 (Forbidden — autenticado mas sem autorização) — clássico em entrevista.</li><li>Inserir um filtro customizado na posição errada da cadeia (ex: depois do filtro de autorização) — ele nunca vê o SecurityContext populado corretamente.</li><li>Achar que SecurityContextHolder é compartilhado entre threads — por padrão usa ThreadLocal; propagar para @Async/pools exige DelegatingSecurityContextExecutor.</li><li>Configurar múltiplas SecurityFilterChain sem `@Order` explícito — o Spring pode aplicar a cadeia errada ou lançar erro de ambiguidade.</li><li>Esquecer de desabilitar CSRF e sessão (SessionCreationPolicy.STATELESS) em APIs stateless com JWT — comportamento fica inconsistente.</li><li>Validar o token no filtro mas esquecer de popular as authorities/roles no Authentication — autentica, mas toda checagem de role na autorização falha.</li></ul><h3>Perguntas de follow-up</h3><blockquote>Qual a diferença entre os status 401 e 403 nesse contexto?”</blockquote><p>401 (Unauthorized) significa que a autenticação falhou ou não foi fornecida — o servidor não sabe quem você é. 403 (Forbidden) significa que você foi autenticado com sucesso, mas não tem permissão (authority/role) para aquele recurso. No Spring, isso é decidido por AuthenticationEntryPoint (401) vs AccessDeniedHandler (403), ambos acionados pelo ExceptionTranslationFilter.</p><blockquote>Como adicionar autenticação JWT numa filter chain do Spring Security?”</blockquote><p>Crie um filtro customizado (geralmente estendendo OncePerRequestFilter) que extrai e valida o token, populando o SecurityContextHolder com as authorities do usuário. Registre-o antes do UsernamePasswordAuthenticationFilter via addFilterBefore, e desabilite sessão (STATELESS) e CSRF, já que JWT é stateless.</p><blockquote>O SecurityContextHolder é thread-safe entre chamadas assíncronas?”</blockquote><p>Por padrão usa uma estratégia baseada em ThreadLocal, então o contexto não é propagado automaticamente para novas threads (ex: @Async, thread pools). É preciso DelegatingSecurityContextExecutor/Runnable, ou mudar a estratégia para InheritableThreadLocal.</p><blockquote>Qual o papel do AuthorizationManager comparado ao antigo AccessDecisionManager?”</blockquote><p>Ambos decidem se uma requisição autenticada pode prosseguir, mas AuthorizationManager substitui o modelo de voters por uma API funcional com um método `check()` que retorna uma AuthorizationDecision, facilitando compor regras (ex: AuthorityAuthorizationManager) sem a complexidade do padrão antigo de votação.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=55554364badd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[#9 Explique como os generics do Java funcionam por baixo dos panos (type erasure) e como wildcards…]]></title>
            <link>https://medium.com/@luchetti.92/9-explique-como-os-generics-do-java-funcionam-por-baixo-dos-panos-type-erasure-e-como-wildcards-ff5aeca1d96a?source=rss-f733742f1761------2</link>
            <guid isPermaLink="false">https://medium.com/p/ff5aeca1d96a</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[generics]]></category>
            <category><![CDATA[oops-interview-questions]]></category>
            <category><![CDATA[pec]]></category>
            <dc:creator><![CDATA[Alexandre Lucchetta]]></dc:creator>
            <pubDate>Mon, 13 Jul 2026 11:01:01 GMT</pubDate>
            <atom:updated>2026-07-13T11:01:01.135Z</atom:updated>
            <content:encoded><![CDATA[<h3>#9 Explique como os generics do Java funcionam por baixo dos panos (type erasure) e como wildcards limitados (? extends T / ? super T) permitem APIs flexíveis. O que é o princípio PECS?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lAolM35-4Z9JnXF_Ip_7WQ.png" /></figure><h3>Resposta direta</h3><p>Os generics do Java são implementados via type erasure: a informação de tipo genérico existe só em tempo de compilação. O compilador a remove, substituindo os parâmetros de tipo pelo seu limite (bound) (Object se não houver limite) e inserindo casts onde necessário. Por isso List&lt;String&gt; e List&lt;Integer&gt; compartilham a mesma classe em runtime. Não dá para fazer new T(), usar instanceof com tipo parametrizado, criar arrays genéricos diretamente, nem sobrecarregar (overload) métodos que seriam apagados (erased) para a mesma assinatura.</p><p>Por causa do erasure, wildcards são essenciais para APIs flexíveis. ? extends T (limite superior/upper bounded) significa que a coleção <em>produz</em> (produce) T ou subtipos — você lê, mas não adiciona com segurança (exceto null). ? super T (limite inferior/lower bounded) significa que a coleção <em>consome</em> (consume) T — você adiciona T ou subtipos, mas a leitura volta como Object. Mnemônico: <strong>PECS</strong> — Producer Extends, Consumer Super. Exemplo canônico: Collections.copy(List&lt;? super T&gt; dest, List&lt;? extends T&gt; src) — src produz, dest consome.</p><h3>Exemplo de código</h3><pre>// PECS: Producer Extends, Consumer Super<br>static void copy(List&lt;? super Number&gt; dest,   // consumer -&gt; super<br>                  List&lt;? extends Number&gt; src) { // producer -&gt; extends<br>    for (Number n : src) {   // OK: reading as Number<br>        dest.add(n);          // OK: adding into a &quot;super Number&quot; list<br>    }<br>    // src.add(1);  // compile error: src is read-only<br>}<br><br>List&lt;Integer&gt; ints = List.of(1, 2, 3);<br>List&lt;Object&gt; objs = new ArrayList&lt;&gt;();<br>copy(objs, ints); // Integer is-a Number, Object is a &quot;super&quot; of Number<br><br>// Type erasure in action:<br>List&lt;String&gt; a = new ArrayList&lt;&gt;();<br>List&lt;Integer&gt; b = new ArrayList&lt;&gt;();<br>System.out.println(a.getClass() == b.getClass()); // true</pre><h3>Armadilhas que os entrevistadores exploram</h3><ul><li>Achar que o tipo genérico existe em runtime — na verdade é apagado (type erasure), então List&lt;String&gt;.class == List&lt;Integer&gt;.class.</li><li>Tentar criar um array genérico (new T[10]) — não compila, pois arrays são reificados (reified) e isso causaria heap pollution silenciosa.</li><li>Confundir ? extends com &quot;posso adicionar qualquer subtipo&quot; — na verdade é somente leitura (read-only), exceto add(null).</li><li>Esquecer que métodos com erasure idêntico não podem ser sobrecarregados (overload) — foo(List&lt;String&gt;) e foo(List&lt;Integer&gt;) na mesma classe dá erro de compilação.</li><li>Ignorar unchecked warnings sem entender — podem esconder um ClassCastException em runtime.</li><li>Confundir bounded type parameter (&lt;T extends Comparable&lt;T&gt;&gt;) com wildcard (? extends Comparable) — são conceitos distintos.</li></ul><h3>Perguntas de follow-up</h3><blockquote>Por que não é possível criar um array genérico como new T[10]?</blockquote><p>Porque arrays em Java são reificados (reified) — sabem seu tipo em runtime e checam cada store. Como generics sofrem type erasure, o compilador não consegue garantir essa checagem, o que causaria heap pollution silenciosa. Por isso a criação é bloqueada.</p><blockquote>Qual a diferença entre List&lt;Object&gt; e List&lt;?&gt;?</blockquote><p>List&lt;Object&gt; é concreta e aceita qualquer Object nela. List&lt;?&gt; (unbounded wildcard) representa uma lista de um tipo desconhecido específico — você lê como Object, mas não pode adicionar nada (exceto null), pois o compilador não sabe o tipo real.</p><blockquote>É possível usar tipos primitivos com generics?</blockquote><p>Não diretamente — generics só trabalham com reference types, então você usa wrapper classes (ex: Integer, Double) via autoboxing/unboxing. Isso traz custo de performance e overhead de memória comparado a arrays primitivos.</p><blockquote>Como o PECS se aplica a copy(List&lt;? super T&gt; dest, List&lt;? extends T&gt; src)?</blockquote><p>src é o produtor (producer) — fornece T ou subtipos, por isso usa extends. dest é o consumidor (consumer) — recebe elementos T, por isso usa super, aceitando destinos de supertipos mais genéricos. Isso maximiza a flexibilidade sem perder type safety.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ff5aeca1d96a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[#8 O que são sealed classes/interfaces em Java e que problema elas resolvem?]]></title>
            <link>https://medium.com/@luchetti.92/8-o-que-s%C3%A3o-sealed-classes-interfaces-em-java-e-que-problema-elas-resolvem-544687ca38b8?source=rss-f733742f1761------2</link>
            <guid isPermaLink="false">https://medium.com/p/544687ca38b8</guid>
            <category><![CDATA[jvm]]></category>
            <category><![CDATA[oops-interview-questions]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Alexandre Lucchetta]]></dc:creator>
            <pubDate>Thu, 09 Jul 2026 11:01:01 GMT</pubDate>
            <atom:updated>2026-07-09T11:01:01.085Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R9tsg_eHX38A2DUyhDRABA.png" /></figure><h3>Resposta direta</h3><p>Uma classe ou interface sealed (a partir do Java 17) restringe quais outras classes/interfaces podem estendê-la ou implementá-la. A declaração lista explicitamente os subtipos permitidos com a cláusula permits.</p><p>Isso resolve o problema de modelar uma hierarquia de tipos <em>fechada</em> (closed type hierarchy) — um conjunto fixo e conhecido de variantes, como um algebraic data type. Antes do sealed, você usava uma classe/interface abstrata sem restrição (qualquer um podia estender, sem garantia de exaustividade/exhaustiveness) ou um enum (fechado, mas cada variante não pode carregar formatos de dados diferentes).</p><p>Cada subtipo permitido precisa ser declarado como final, sealed ou non-sealed — não existe &quot;deixar aberto por acidente&quot;. O ganho real aparece com pattern matching em switch: como o compilador conhece todos os subtipos possíveis, ele consegue verificar que um switch sobre um tipo sealed é exaustivo (exhaustive) sem precisar de um branch default.</p><h3>Exemplo de código</h3><pre>sealed interface Shape permits Circle, Square, Triangle {}<br><br>record Circle(double radius) implements Shape {}<br>record Square(double side) implements Shape {}<br>record Triangle(double base, double height) implements Shape {}<br><br>static double area(Shape shape) {<br>    // No default needed: compiler proves all cases are covered<br>    return switch (shape) {<br>        case Circle c   -&gt; Math.PI * c.radius() * c.radius();<br>        case Square s   -&gt; s.side() * s.side();<br>        case Triangle t -&gt; 0.5 * t.base() * t.height();<br>    };<br>}</pre><h3>Armadilhas que os entrevistadores exploram</h3><ul><li>Se os subtipos permitidos estiverem no mesmo arquivo (mesma compilation unit), o permits pode ser omitido (inferido implicitamente). Em arquivos separados, é obrigatório.</li><li>Todo subtipo direto precisa ser final, sealed ou non-sealed — esquecer isso é erro de compilação, não decisão opcional.</li><li>sealed restringe apenas herança/implementação direta, não o número de instâncias — diferente de enum, que controla as instâncias.</li><li>Diferença com final: final proíbe qualquer subclasse; sealed permite uma lista específica e controlada.</li><li>Permissão (permitted subtype) precisa estar no mesmo módulo (ou, sem módulos, no mesmo pacote/package) que o tipo sealed — não dá pra “selar” para um subtipo em outro módulo arbitrário.</li><li>Records combinam muito bem com sealed (sealed + records = algebraic data type), e é um combo clássico cobrado em entrevista de Java moderno.</li><li>Adicionar um novo subtipo permitido depois quebra a exhaustiveness em todo switch existente sobre aquele tipo — o compilador força a atualização (isso é uma vantagem, mas surpreende quem não conhece).</li></ul><h3>Perguntas de follow-up</h3><blockquote>Como sealed se relaciona com exhaustive switch pattern matching?</blockquote><p>Como o compilador conhece todos os subtipos permitidos (permitted subtypes), ele consegue garantir, em tempo de compilação, que um switch tratou todos os casos (exhaustiveness check), dispensando o default. Sem sealed, o compilador não tem como provar isso.</p><blockquote>Qual a diferença entre sealed e final?</blockquote><p>final bloqueia toda e qualquer subclasse (zero extensibilidade). sealed permite extensão, mas só para uma lista fixa e conhecida de subtipos (controlled extensibility), o que mantém a hierarquia fechada sem eliminar polimorfismo.</p><blockquote>Por que preferir sealed types em vez de um enum simples?</blockquote><p>Enum exige que todas as variantes compartilhem exatamente os mesmos campos (fixed shape). Sealed + records permite que cada variante carregue dados diferentes (heterogeneous data), mantendo a mesma garantia de fechamento (closed set) que o enum oferece.</p><blockquote>Um subtipo permitido pode estar em um pacote diferente?</blockquote><p>Só se estiver no mesmo módulo (named module); sem módulos explícitos, o subtipo precisa estar no mesmo package do tipo sealed. Essa restrição evita que código externo “se infiltre” na hierarquia fechada.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=544687ca38b8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[#7 Qual é a diferença entre uma interface e uma classe abstrata em Java?]]></title>
            <link>https://medium.com/@luchetti.92/7-qual-%C3%A9-a-diferen%C3%A7a-entre-uma-interface-e-uma-classe-abstrata-em-java-fdf76490d499?source=rss-f733742f1761------2</link>
            <guid isPermaLink="false">https://medium.com/p/fdf76490d499</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[oops-interview-questions]]></category>
            <dc:creator><![CDATA[Alexandre Lucchetta]]></dc:creator>
            <pubDate>Mon, 06 Jul 2026 11:01:01 GMT</pubDate>
            <atom:updated>2026-07-06T11:01:01.122Z</atom:updated>
            <content:encoded><![CDATA[<h3>#7 Qual é a diferença entre uma interface e uma classe abstrata em Java? Quando você usaria uma ao invés da outra?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XCq-SzEao8sLXJC_ok1rKw.png" /></figure><h3>Resposta direta</h3><p>Uma interface define um contrato comportamental — um conjunto de assinaturas de métodos que as classes implementadoras devem cumprir. Uma classe pode implementar <strong>múltiplas interfaces</strong> (multiple interface implementation), viabilizando herança múltipla de tipo. Desde o Java 8, interfaces também podem ter métodos default e static (implementações concretas). Desde o Java 9, também são permitidos métodos private como helpers internos.</p><p>Uma abstract class não pode ser instanciada diretamente e pode conter métodos abstratos (sem corpo) e concretos (com corpo), além de <strong>estado de instância</strong> (instance fields). Uma classe só pode estender <strong>uma</strong> classe abstrata (single inheritance).</p><p><strong>Use uma interface</strong> quando quiser definir uma capacidade que classes não relacionadas possam compartilhar — ex: Comparable, Serializable, Runnable.<br><strong>Use uma abstract class</strong> quando quiser compartilhar código e estado entre classes relacionadas, fornecendo uma implementação parcial como base.</p><p>O princípio GoF se aplica aqui: “Programe para uma interface, não para uma implementação.”</p><h3>Exemplo de código</h3><pre>// Interface — defines a contract (capability only, no instance state)<br>interface Flyable {<br>    void fly();<br><br>    default String describe() { return &quot;I can fly!&quot;; } // Java 8+<br>}<br><br>// Abstract class — shared base with instance state + partial impl<br>abstract class Animal {<br>    protected String name; // instance state — impossible in an interface<br><br>    Animal(String name) { this.name = name; }<br><br>    abstract String sound(); // subclass MUST implement<br><br>    String describe() { // concrete — reused by all subclasses<br>        return name + &quot; says &quot; + sound();<br>    }<br>}<br><br>// One abstract class + MULTIPLE interfaces — perfectly legal<br>class Eagle extends Animal implements Flyable, Comparable&lt;Eagle&gt; {<br>    Eagle(String name) { super(name); }<br><br>    @Override String sound() { return &quot;screech&quot;; }<br>    @Override public void fly() { System.out.println(name + &quot; soars!&quot;); }<br>    @Override public int compareTo(Eagle o) { return name.compareTo(o.name); }<br>}</pre><h3>Armadilhas que os entrevistadores exploram</h3><ul><li>Desde o Java 8, interfaces podem ter implementações concretas via <em>default methods</em> — dizer que “interface só tem métodos abstratos” está desatualizado e vai costar pontos.</li><li>Campos em interfaces existem, mas são sempre <em>public static final</em> implicitamente — constantes, nunca <em>instance state</em>. Confundir isso é um erro clássico.</li><li>Conflito de <em>default methods</em>: se uma classe implementa duas interfaces com o mesmo <em>default method</em>, o compilador força um <em>override</em> explícito — não é silencioso.</li><li>Uma <em>abstract class</em> pode implementar uma <em>interface</em> deixando os métodos da interface como abstratos — repassando a obrigação para a subclasse concreta.</li><li>Mito de performance: não há diferença significativa de desempenho entre as duas. Escolha pelo design, não por suposta “eficiência”.</li></ul><h3>Perguntas de follow-up</h3><blockquote>Uma classe abstrata pode implementar uma interface sem fornecer todos os métodos?</blockquote><p>Sim. Uma <em>abstract class</em> pode deixar os métodos da interface sem implementação — eles continuam abstratos e a obrigação de implementá-los passa para a primeira subclasse concreta (<em>concrete subclass</em>) da hierarquia.</p><blockquote>O que acontece quando duas interfaces declaram o mesmo <em>default method</em> e uma classe implementa ambas?</blockquote><p>Erro de compilação (<em>compile error</em>). A classe deve fazer <em>override</em> explícito do método conflitante. Para reutilizar uma das implementações, chame <em>InterfaceA.super.method()</em> ou <em>InterfaceB.super.method()</em> dentro do <em>override</em>.</p><blockquote>Por que interfaces não podem ter <em>instance fields</em>?</blockquote><p>Por design: interfaces definem contratos de comportamento, não estado. Qualquer campo em uma interface é <em>public static final</em> implicitamente — uma constante de classe. Permitir estado de instância violaria o propósito da interface como contrato puro.</p><blockquote>O que os <em>private methods</em> em interfaces (Java 9) realmente adicionaram?</blockquote><p>Permitiram que múltiplos <em>default methods</em> compartilhem lógica interna via um <em>helper method</em> privado, sem expor esse utilitário como parte do contrato público da interface. Reduz duplicação de código sem poluir a API.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fdf76490d499" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[#6 Qual é a diferença entre ArrayList e LinkedList em Java? Em qual situação você usaria cada um?]]></title>
            <link>https://medium.com/@luchetti.92/6-qual-%C3%A9-a-diferen%C3%A7a-entre-arraylist-e-linkedlist-em-java-em-qual-situa%C3%A7%C3%A3o-voc%C3%AA-usaria-cada-um-20e9b4463f2b?source=rss-f733742f1761------2</link>
            <guid isPermaLink="false">https://medium.com/p/20e9b4463f2b</guid>
            <category><![CDATA[collections-in-java]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[arrays]]></category>
            <dc:creator><![CDATA[Alexandre Lucchetta]]></dc:creator>
            <pubDate>Thu, 02 Jul 2026 11:01:00 GMT</pubDate>
            <atom:updated>2026-07-02T11:01:00.949Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FCaQxMie1GcJALQlfoHEQw.png" /></figure><h3>Resposta direta</h3><p>Ambas implementam a interface List, mas suas estruturas internas são completamente diferentes.</p><p>ArrayList usa um array dinâmico (dynamic array) por baixo. Acesso aleatório por índice é O(1) — é só um deslocamento de ponteiro. Adicionar no final é O(1) amortizado: quando o array enche, Java aloca um novo com ~1,5× o tamanho e copia os elementos (resize). Inserções ou deleções no meio são O(n) porque os elementos precisam ser deslocados (shift).</p><p>LinkedList é uma lista duplamente encadeada (doubly-linked list). Cada nó carrega o elemento mais dois ponteiros (anterior e próximo). Adicionar ou remover na cabeça ou na cauda é O(1). Mas acesso por índice é O(n) — é preciso percorrer desde o início. Ela também implementa Deque, sendo usada nativamente como fila (queue) ou pilha (stack).</p><p>Na prática, <strong>ArrayList vence na grande maioria dos casos</strong> por causa da localidade de cache (cache locality) — CPUs modernas pré-buscam memória contígua com eficiência. LinkedList tem overhead maior de memória por elemento (dois ponteiros extras) e causa cache misses frequentes durante iteração.</p><h3>Exemplo de código</h3><pre>import java.util.*;<br><br>public class ListComparison {<br><br>    public static void main(String[] args) {<br>        List&lt;String&gt; arrayList   = new ArrayList&lt;&gt;();<br>        List&lt;String&gt; linkedList  = new LinkedList&lt;&gt;();<br>        Deque&lt;String&gt; deque      = new LinkedList&lt;&gt;(); // as a queue<br><br>        // O(1) amortised — adding at the end<br>        arrayList.add(&quot;a&quot;);<br>        arrayList.add(&quot;b&quot;);<br><br>        // O(1) — adding at head/tail<br>        ((LinkedList&lt;String&gt;) linkedList).addFirst(&quot;x&quot;);<br>        ((LinkedList&lt;String&gt;) linkedList).addLast(&quot;y&quot;);<br><br>        // O(1) random access — ArrayList shines here<br>        String s = arrayList.get(0);<br><br>        // O(n) random access — LinkedList pain point<br>        String t = linkedList.get(0); // traverses from head!<br><br>        // O(n) middle insertion — shifts all elements right<br>        arrayList.add(0, &quot;first&quot;); // expensive!<br><br>        // O(1) middle insertion IF you already have an iterator<br>        ListIterator&lt;String&gt; it = linkedList.listIterator(0);<br>        it.add(&quot;head&quot;); // just pointer updates, no shift<br><br>        // Prefer ArrayDeque over LinkedList when you need a queue<br>        Deque&lt;String&gt; betterQueue = new ArrayDeque&lt;&gt;();<br>    }<br>}</pre><h3>Pegadinhas e armadilhas</h3><ul><li>“LinkedList é melhor para inserções no meio” — só é verdade se você já tem um Iterator na posição. Buscar o índice primeiro (get(i)) custa O(n), anulando a vantagem.</li><li>O entrevistador pode perguntar sobre o <strong>resize</strong> interno do ArrayList: o threshold é ~75% da capacidade no JDK moderno, e o novo tamanho é (oldCapacity * 3) / 2 + 1. Saber isso diferencia candidatos.</li><li>LinkedList implementa Deque (double-ended queue), mas na prática ArrayDeque é mais rápida para uso como fila ou pilha porque evita os cache misses dos nós espalhados na heap.</li><li>Memória: cada nó de LinkedList aloca um objeto extra com dois ponteiros — em JVMs 64-bit sem compressed oops, são ~40 bytes por nó vs ~4–8 bytes por slot no array do ArrayList.</li><li>Iterar via for (int i=0; i&lt;list.size(); i++) list.get(i) numa LinkedList é O(n²). Sempre use enhanced-for ou iterator — isso é um erro clássico de performance.</li></ul><h3>Perguntas de follow-up</h3><blockquote>Como o ArrayList lida com o redimensionamento interno?</blockquote><p>Quando a capacidade é atingida, ArrayList aloca um novo array com tamanho ≈ 1,5× (grow factor) e copia todos os elementos via Arrays.copyOf. Essa operação é O(n) pontualmente, mas como acontece com frequência exponencialmente menor, o custo amortizado (amortized cost) por inserção ainda é O(1). Você pode evitar o resize chamando new ArrayList&lt;&gt;(initialCapacity) se souber o tamanho esperado.</p><blockquote>Quando você preferiria LinkedList em produção?</blockquote><p>Raramente. Um caso legítimo é quando você tem um ListIterator já posicionado e faz muitas inserções/deleções consecutivas naquela posição (ex.: processamento de stream de eventos com cursor fixo). Para filas e deques, prefira ArrayDeque, que é mais rápida e tem melhor footprint de memória.</p><blockquote>O que é um iterator fail-fast e como ele se relaciona com essas coleções?</blockquote><p>Ambas usam iteradores fail-fast (fail-fast iterators): mantêm um contador interno modCount que incrementa a cada modificação estrutural. Se o iterator detecta que modCount mudou durante a iteração, lança ConcurrentModificationException. Isso não garante thread-safety — é apenas um mecanismo best-effort para detectar bugs de modificação concorrente (concurrent modification).</p><blockquote>Qual é a alternativa thread-safe ao ArrayList?</blockquote><p>CopyOnWriteArrayList do pacote java.util.concurrent: a cada escrita, cria uma cópia completa do array interno, permitindo leituras concorrentes sem locks. É ideal quando leituras dominam e escritas são raras. Para casos com muitas escritas, prefira uma lista sincronizada via Collections.synchronizedList combinada com sincronização explícita nos blocos de iteração.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=20e9b4463f2b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[#5 Como funciona o Garbage Collector do Java?]]></title>
            <link>https://medium.com/@luchetti.92/5-como-funciona-o-garbage-collector-do-java-faf46b1cb24c?source=rss-f733742f1761------2</link>
            <guid isPermaLink="false">https://medium.com/p/faf46b1cb24c</guid>
            <category><![CDATA[jvm]]></category>
            <category><![CDATA[garbage-collection]]></category>
            <category><![CDATA[jvm-memory]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Alexandre Lucchetta]]></dc:creator>
            <pubDate>Mon, 29 Jun 2026 11:01:01 GMT</pubDate>
            <atom:updated>2026-06-29T11:01:01.206Z</atom:updated>
            <content:encoded><![CDATA[<h3>#5 Como funciona o Garbage Collector do Java? Explique o GC geracional, as regiões de memória e como os objetos se movem entre elas.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kLam7goMa7kdte0UUUf8ug.png" /></figure><h3>Resposta direta</h3><p>O Java gerencia memória automaticamente via GC, que recupera espaço na heap ocupado por objetos que não são mais alcançáveis a partir de nenhuma GC root (variáveis locais, campos estáticos, threads ativas). Ele se baseia na hipótese geracional (generational hypothesis): a maioria dos objetos morre jovem, então a heap é dividida em regiões para coletar de forma barata.</p><p>Objetos nascem no <strong>Eden</strong>. Quando o Eden enche, um Minor GC roda — objetos vivos vão para um Survivor space (S0 ou S1), alternando entre eles a cada ciclo. Após sobreviver um número limite de ciclos (padrão 15), o objeto é promovido (promoted) para a <strong>Old Generation</strong>. Um Major/Full GC (muito mais caro, geralmente stop-the-world) coleta a Old Gen eventualmente. O <strong>Metaspace</strong> (desde Java 8, substituindo o PermGen) guarda metadados de classes e cresce fora da heap (off-heap).</p><p>Principais coletores disponíveis</p><ul><li>Serial GC: Single thread. Pequenas apps, ambientes com 1 CPU.</li><li>Parallel GC: Múltiplas threads. Foco em throughput. Padrão Java 8.</li><li>G1 GC: Heap dividida em regiões. Padrão Java 9+. Balanceia latência e throughput.</li><li>ZGC / Shenandoah: Pausas &lt; 1ms. Ideal para heaps grandes e baixa latência.</li></ul><h3>Exemplo de código</h3><pre>// Memory leak: GC cannot collect because &#39;cache&#39; holds strong references<br>public class LeakyCache {<br>    private static final Map&lt;String, byte[]&gt; cache = new HashMap&lt;&gt;();<br><br>    public void store(String key) {<br>        cache.put(key, new byte[1024 * 1024]); // 1 MB per entry, never removed<br>    }<br>}<br><br>// Fix: use WeakReference so GC can reclaim when memory is needed<br>private static final Map&lt;String, WeakReference&lt;byte[]&gt;&gt; cache = new HashMap&lt;&gt;();<br><br>// Or use a purpose-built cache like WeakHashMap:<br>private static final Map&lt;String, byte[]&gt; cache = new WeakHashMap&lt;&gt;();<br><br>// Force GC suggestion (NOT guaranteed — JVM decides)<br>System.gc(); // hint only; avoid in production code<br><br>// JVM flags to tune GC:<br>// -Xms512m -Xmx2g         → min/max heap size<br>// -XX:+UseG1GC             → use G1 collector<br>// -XX:MaxGCPauseMillis=200 → target pause time for G1<br>// -verbose:gc              → print GC events to stdout</pre><h3>Pegadinhas e armadilhas</h3><ul><li>Achar que System.gc() garante coleta — é só uma sugestão ao GC; a JVM pode ignorar completamente. Nunca dependa disso em produção.</li><li>Confundir memory leak com OOM — um memory leak em Java ocorre quando objetos ainda têm referências fortes (strong references) e o GC não pode coletá-los, mesmo que o código nunca mais os use (ex: listeners não removidos, caches estáticos).</li><li>Achar que o PermGen sumiu — o PermGen foi removido no Java 8 e substituído pelo Metaspace, que cresce dinamicamente no native memory. Ainda é possível ter OutOfMemoryError: Metaspace se houver vazamento de classloaders.</li><li>Não saber a diferença entre Minor, Major e Full GC — Minor coleta Young Gen (rápido, stop-the-world curto); Major/Full coleta Old Gen ou toda a heap (lento, pause longa). G1 e ZGC minimizam as pausas com coleta concorrente (concurrent marking).</li><li>Implementar finalize() para limpeza de recursos — o método é deprecated desde Java 9 e removido no Java 18. Use try-with-resources com AutoCloseable ou Cleaner (Java 9+).</li></ul><h3>Perguntas de follow-up</h3><blockquote>O que são GC roots e por que elas importam?</blockquote><p>GC roots são os pontos de partida do algoritmo de marcação (mark phase). O GC percorre o grafo de referências a partir delas e tudo que não for alcançável é coletado. As principais roots são: variáveis locais em stack frames ativos, campos estáticos de classes carregadas, referências de threads ativas e referências JNI. Entender isso é fundamental para diagnosticar memory leaks.</p><blockquote>O que é stop-the-world (STW) e como os GCs modernos o reduzem?</blockquote><p>Stop-the-world é uma pausa em que todas as threads da aplicação são suspensas para o GC trabalhar com segurança — sem objetos sendo movidos enquanto os escaneia. GCs modernos como G1 fazem a fase de marcação (marking) de forma concorrente (sem pausar), reservando STW apenas para as fases curtas de início e fim. ZGC e Shenandoah vão além, fazendo a própria compactação (relocation) de forma concorrente, reduzindo pausas para sub-milissegundo.</p><blockquote>Qual a diferença entre WeakReference, SoftReference e PhantomReference?</blockquote><p>WeakReference é coletada no próximo ciclo de GC assim que não há strong references — usada em caches como WeakHashMap. SoftReference só é coletada quando a JVM está com pouca memória — ideal para caches sensíveis à memória. PhantomReference nunca devolve o objeto (sempre retorna null) e é usada para executar ações de limpeza pós-coleta via ReferenceQueue, substituindo o finalize().</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=faf46b1cb24c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[#4 O que a palavra-chave volatile faz no Java? Como ela difere de synchronized?]]></title>
            <link>https://medium.com/@luchetti.92/4-o-que-a-palavra-chave-volatile-faz-no-java-como-ela-difere-de-synchronized-014f18a87457?source=rss-f733742f1761------2</link>
            <guid isPermaLink="false">https://medium.com/p/014f18a87457</guid>
            <category><![CDATA[jvm]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[threads]]></category>
            <category><![CDATA[concurrency]]></category>
            <dc:creator><![CDATA[Alexandre Lucchetta]]></dc:creator>
            <pubDate>Thu, 25 Jun 2026 11:01:01 GMT</pubDate>
            <atom:updated>2026-06-25T11:01:01.324Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XrKMFzUg352qROAH7txxww.png" /></figure><h3>Resposta direta</h3><p>Para entender volatile, é necessário entender o <strong>Java Memory Model (JMM)</strong>. Cada thread pode armazenar valores de campos em registradores de CPU ou cache L1/L2. Sem sincronização, uma escrita feita pela Thread A não tem visibilidade garantida para a Thread B — é o chamado <em>visibility problem</em> (problema de visibilidade).</p><p>Declarar um campo como volatile oferece duas garantias: (1) <strong>visibilidade</strong> — toda leitura vai diretamente à memória principal (<em>main memory</em>), toda escrita é imediatamente publicada lá; (2) <strong>ordenação happens-before</strong> — uma escrita num campo volatile <em>happens-before</em> toda leitura subsequente desse campo por qualquer thread, impedindo reordenação de instruções (<em>instruction reordering</em>) em torno desse acesso.</p><p>synchronized garante tudo isso <em>mais</em> <strong>atomicidade</strong> (exclusão mútua). volatile não garante atomicidade. Portanto, volatile int counter; counter++ ainda é uma <em>race condition</em> — são três operações: leitura, incremento, escrita.</p><p>Volatile vs Synchronized</p><p>volatile</p><ul><li>✓ Visibilidade entre threads</li><li>✓ Happens-before ordering</li><li>✗ Sem atomicidade</li><li>✗ Não serve para compound actions</li></ul><p>Ideal: flags de controle, estado singleton (double-checked locking)</p><p>synchronized</p><ul><li>✓ Visibilidade entre threads</li><li>✓ Happens-before ordering</li><li>✓ Atomicidade (mutex)</li><li>✓ Compound actions seguras</li></ul><p>Ideal: operações compostas, blocos críticos com múltiplas variáveis</p><h3>Exemplo de código</h3><pre>// 1. Correct use of volatile: visibility-only flag<br>class Worker implements Runnable {<br>    private volatile boolean running = true;  // visible across threads<br><br>    public void stop() { running = false; }   // write flushed to main memory immediately<br><br>    @Override<br>    public void run() {<br>        while (running) {  // always reads from main memory<br>            doWork();<br>        }<br>    }<br>}<br><br>// 2. WRONG: volatile does not make compound operations atomic<br>class BrokenCounter {<br>    private volatile int count = 0;<br><br>    public void increment() {<br>        count++;  // READ + INCREMENT + WRITE — still a race condition!<br>    }<br>}<br><br>// 3. CORRECT alternatives for atomic increment<br>class CorrectCounter {<br>    // Option A: synchronized<br>    private int count = 0;<br>    public synchronized void increment() { count++; }<br><br>    // Option B: AtomicInteger (lock-free, faster)<br>    private final AtomicInteger atomicCount = new AtomicInteger(0);<br>    public void incrementAtomic() { atomicCount.incrementAndGet(); }<br>}<br><br>// 4. Classic double-checked locking — needs volatile on Java 5+<br>class Singleton {<br>    private static volatile Singleton instance;  // volatile required!<br><br>    public static Singleton getInstance() {<br>        if (instance == null) {                  // first check (no lock)<br>            synchronized (Singleton.class) {<br>                if (instance == null) {          // second check (with lock)<br>                    instance = new Singleton();  // without volatile, partial<br>                }                               // construction may be visible<br>            }<br>        }<br>        return instance;<br>    }<br>}</pre><h3>Pegadinhas e armadilhas</h3><p><strong>volatile não substitui </strong><strong>synchronized para operações compostas</strong>: qualquer sequência <em>check-then-act</em> (ex: if (x == null) x = new X()) ainda exige sincronização, porque as duas operações não são atômicas juntas, mesmo com volatile.</p><p><strong>Double-checked locking sem </strong><strong>volatile quebra no Java</strong>: sem volatile no campo instance, a JVM pode publicar uma referência parcialmente construída ao objeto — outro thread lê uma referência não-nula mas com campos ainda não inicializados. O volatile proíbe o reordenamento da escrita de construção.</p><p><strong>volatile em arrays protege apenas a referência, não os elementos</strong>: volatile int[] arr garante visibilidade da referência ao array, mas <strong>não</strong> dos elementos internos. Para elementos atômicos, use AtomicIntegerArray.</p><p><strong>Custo de performance</strong>: leituras de campo volatile são mais caras que leituras normais porque impedem certas otimizações do compilador JIT e forçam barreiras de memória (<em>memory barriers</em>). Não use em campos lidos em loops de alta frequência sem necessidade.</p><p><strong>Alternativa moderna esquecida</strong>: AtomicReference, AtomicInteger e classes do pacote java.util.concurrent.atomic usam operações <em>CAS (Compare-And-Swap)</em> — são <em>lock-free</em> e atômicas. Em muitos cenários substituem tanto volatile quanto synchronized com melhor performance.</p><h3>Perguntas de follow-up</h3><blockquote><em>O que é a relação happens-before no Java Memory Model?</em></blockquote><blockquote><em>Quando você preferiria </em><em>AtomicInteger em vez de </em><em>synchronized?</em></blockquote><blockquote><em>O que é uma barreira de memória (memory barrier) e como o </em><em>volatile a utiliza?</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=014f18a87457" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[#3 Como o @Transactional funciona no Spring, e o que são os níveis de propagação (propagation) e…]]></title>
            <link>https://medium.com/@luchetti.92/3-como-o-transactional-funciona-no-spring-e-o-que-s%C3%A3o-os-n%C3%ADveis-de-propaga%C3%A7%C3%A3o-propagation-e-a2eb713167fc?source=rss-f733742f1761------2</link>
            <guid isPermaLink="false">https://medium.com/p/a2eb713167fc</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[hibernate]]></category>
            <category><![CDATA[spring-framework]]></category>
            <category><![CDATA[jdbc]]></category>
            <category><![CDATA[spring-boot]]></category>
            <dc:creator><![CDATA[Alexandre Lucchetta]]></dc:creator>
            <pubDate>Mon, 22 Jun 2026 11:01:01 GMT</pubDate>
            <atom:updated>2026-06-22T13:50:00.380Z</atom:updated>
            <content:encoded><![CDATA[<h3>#3 Como o @Transactional funciona no Spring, e o que são os níveis de propagação (propagation) e isolamento (isolation)?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o0TwJOHIH57skfMxP7xebw.png" /></figure><h3>Resposta direta</h3><p>@Transactional é uma anotação do Spring que envolve um método (ou classe inteira) em uma transação de banco de dados. O Spring usa um <strong>proxy</strong> (JDK dynamic proxy ou CGLIB) para interceptar a chamada, abrir uma transação antes do método executar, e fazer commit ou rollback ao final. O proxy é criado na inicialização pelo container do Spring — esse é o núcleo da implementação baseada em AOP (Aspect-Oriented Programming).</p><p><strong>Propagação (propagation)</strong> controla o que acontece quando um método transacional chama outro método transacional. Valores principais:<br> — REQUIRED (padrão): entra na transação existente, ou cria uma nova se não houver.<br>— REQUIRES_NEW: suspende a transação atual e inicia uma nova independente.<br>— NESTED: cria um savepoint dentro da transação atual; só faz rollback até o savepoint em caso de falha.<br>— MANDATORY: exige que já exista uma transação ativa, caso contrário lança exceção.<br>— SUPPORTS / NOT_SUPPORTED / NEVER: comportamentos progressivamente menos transacionais.</p><p><strong>Isolamento (isolation)</strong> controla a visibilidade de dados não commitados entre transações concorrentes. Níveis principais (ordem crescente de rigor):<br> — READ_UNCOMMITTED: permite leitura de dados sujos (dirty reads).<br>— READ_COMMITTED: apenas dados commitados visíveis; evita dirty reads mas permite non-repeatable reads.<br>— REPEATABLE_READ: mesma linha retorna o mesmo dado dentro da transação; evita non-repeatable reads mas permite phantom reads.<br>— SERIALIZABLE: isolamento total; evita phantom reads mas tem pior performance.<br>O Spring usa DEFAULT por padrão, que delega ao banco de dados (tipicamente READ_COMMITTED no PostgreSQL/MySQL).</p><h3>Exemplo de código</h3><pre>@Service<br>public class OrderService {<br><br>    @Autowired<br>    private OrderRepository orderRepo;<br>    @Autowired<br>    private AuditService auditService;<br><br>    // Default: REQUIRED propagation, DEFAULT isolation<br>    @Transactional<br>    public void placeOrder(Order order) {<br>        orderRepo.save(order);<br>        // auditService.log() runs in the SAME transaction<br>        auditService.log(&quot;Order placed: &quot; + order.getId());<br>        // If anything throws RuntimeException → whole tx rolls back<br>    }<br><br>    // Audit log must be persisted even if outer tx rolls back<br>    @Transactional(propagation = Propagation.REQUIRES_NEW)<br>    public void log(String message) {<br>        // Runs in its OWN transaction, committed independently<br>        auditRepo.save(new AuditEntry(message));<br>    }<br><br>    // High-stakes read: prevent phantom reads in financial reports<br>    @Transactional(<br>        readOnly = true,<br>        isolation = Isolation.SERIALIZABLE<br>    )<br>    public BigDecimal getBalance(Long accountId) {<br>        return accountRepo.findBalance(accountId);<br>    }<br>}</pre><h3>Pegadinhas &amp; armadilhas</h3><ul><li><strong>Self-invocation (chamada interna)</strong>: se um método da própria classe chama outro método @Transactional da mesma classe, o proxy é bypassed — a transação do método interno é ignorada. Solução: injetar o próprio bean ou usar AspectJ weaving.</li><li><strong>Checked exceptions não fazem rollback por padrão</strong>: somente RuntimeException (unchecked) dispara rollback automático. Para checked exceptions, use @Transactional(rollbackFor = Exception.class).</li><li><strong>Métodos private ou protected</strong>: o proxy do Spring não intercepta métodos private ou protected — a anotação é silenciosamente ignorada.</li><li><strong>readOnly = true não é uma garantia</strong>: é uma hint para o driver/banco otimizar (ex: evitar flush do Hibernate). Não impede escritas a nível de código.</li><li><strong>Lazy loading fora da transação (LazyInitializationException)</strong>: acessar uma associação lazy de uma entidade JPA depois que a sessão/transação foi fechada lança essa exception. Solução: abrir a transação corretamente, usar @Transactional no nível certo, ou usar fetch join.</li></ul><h3>Perguntas de follow-up</h3><blockquote>Qual a diferença entre propagação REQUIRES_NEW e NESTED?</blockquote><blockquote>Como o Spring implementa o @Transactional internamente?</blockquote><blockquote>O que acontece se você usa @Transactional num método que chama uma API REST externa?</blockquote><blockquote>O que é um phantom read e qual nível de isolamento o previne?</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2eb713167fc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[#2 Você pode explicar composição sobre herança, e quando preferiria uma abordagem sobre a outra em…]]></title>
            <link>https://medium.com/@luchetti.92/2-voc%C3%AA-pode-explicar-composi%C3%A7%C3%A3o-sobre-heran%C3%A7a-e-quando-preferiria-uma-abordagem-sobre-a-outra-em-a36dc411d179?source=rss-f733742f1761------2</link>
            <guid isPermaLink="false">https://medium.com/p/a36dc411d179</guid>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Alexandre Lucchetta]]></dc:creator>
            <pubDate>Mon, 15 Jun 2026 13:36:25 GMT</pubDate>
            <atom:updated>2026-06-15T13:47:45.512Z</atom:updated>
            <content:encoded><![CDATA[<h3>#2 Você pode explicar composição sobre herança, e quando preferiria uma abordagem sobre a outra em Java?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pHuAV-mLIMBMood6uTRMsA.png" /></figure><h3><strong>Resposta direta</strong></h3><p><strong>Herança</strong> (<em>inheritance</em>, palavra-chave extends) cria uma relação <em>é-um</em> (<em>is-a</em>). A subclasse herda a implementação do pai e fica fortemente acoplada (<em>tightly coupled</em>) a ele — qualquer mudança no pai pode quebrar subclasses. Java suporta apenas <strong>herança simples</strong> (<em>single inheritance</em>) para classes, limitando a flexibilidade.</p><p><strong>Composição</strong> (<em>composition</em>) modela uma relação <em>tem-um</em> (<em>has-a</em>): em vez de estender uma classe, você mantém uma referência a ela e delega (<em>delegate</em>) o comportamento. Esse é o princípio do padrão GoF “favoreça composição sobre herança” (<em>favor composition over inheritance</em>).</p><p>Composição vence quando: (1) você precisa mudar comportamento em <em>runtime</em>; (2) quer reutilizar código (<em>code reuse</em>) sem comprometer-se com uma hierarquia de tipos (<em>type hierarchy</em>); (3) a classe pai é complexa ou não foi projetada para extensão (<em>not designed for extension</em>). Herança é válida quando há uma relação <em>is-a</em> genuína e estável (ex.: ArrayList extends AbstractList).</p><p>Checagem rápida: pergunte <em>“Um Dog é realmente um Animal para sempre, ou ele só precisa de um comportamento de fala?”</em> Se só precisar do comportamento, injete-o via interface + composição.</p><h3>Exemplo de código</h3><pre>// ❌ Inheritance: Logger is forced into a class hierarchy<br>class FileLogger {<br>    public void log(String msg) { /* write to file */ }<br>}<br>class UserService extends FileLogger { // tight coupling!<br>    public void createUser(String name) { log(&quot;Creating: &quot; + name); }<br>}<br><br>// ✅ Composition: inject the dependency via interface<br>interface Logger {<br>    void log(String msg);<br>}<br>class UserService {<br>    private final Logger logger; // has-a<br><br>    UserService(Logger logger) { this.logger = logger; }<br><br>    public void createUser(String name) { logger.log(&quot;Creating: &quot; + name); }<br>}<br><br>// Swap behavior at runtime — no subclassing needed<br>UserService svc = new UserService(new ConsoleLogger());<br>UserService svc2 = new UserService(new SilentLogger()); // tests!</pre><h3>Pegadinhas &amp; armadilhas</h3><ul><li><strong>Fragilidade da classe base</strong> (<em>fragile base class problem</em>): mudanças na superclasse podem quebrar subclasses silenciosamente, mesmo sem alterar a assinatura dos métodos.</li><li><strong>Herança de implementação vs. de tipo</strong>: herdar só para reutilizar código é errado — prefira composição. Herança de tipo (via <em>interface</em>) é sempre segura.</li><li><strong>Violação do LSP</strong> (<em>Liskov Substitution Principle</em>): se a subclasse não pode substituir a superclasse sem alterar comportamento esperado, a herança foi usada de forma incorreta.</li><li><strong>Explosão de hierarquia</strong> (<em>class hierarchy explosion</em>): com herança, adicionar variações resulta em subclasses exponenciais; com composição, você injeta comportamentos independentemente.</li><li><strong>Confundir </strong><strong>extends com </strong><strong>implements</strong>: <em>extends</em> herda implementação (perigoso); <em>implements</em> apenas herda o tipo/contrato (sempre seguro). Em entrevistas, distinguir isso é crucial.</li></ul><h3>Perguntas de follow-up</h3><blockquote>Como o padrão Decorator se relaciona com composição?</blockquote><blockquote>Dá para reutilizar código só com interface em Java?</blockquote><blockquote>Como o Spring usa composição internamente?</blockquote><blockquote>Quando a herança é a escolha certa?</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a36dc411d179" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>