Análise de perguntas e respostas de entrevistas para desenvolvedor Java. Parte 6

Olá Mundo! Continuar a desenvolver é muito importante para qualquer desenvolvedor. Afinal, se você parar, existe o risco de não ser reclamado e sair completamente do mercado: o mundo da TI está em constante desenvolvimento e avanço, e você precisa acompanhá-lo. Mas, ao mesmo tempo, não se pode focar apenas nas novas e frescas tecnologias, para não esquecer, por assim dizer, os clássicos (temas clássicos). Hoje quero continuar minha análise de questões sobre tópicos “clássicos” para um desenvolvedor Java. Observo que minhas respostas não são a autoridade final - é assim que vejo as respostas corretas para essas perguntas, e você pode não concordar com algumas delas. Isso será normal, então fique à vontade para compartilhar sua opinião nos comentários. Links para partes da análise estão no final do artigo.

Bibliotecas e padrões

52. O que é hibernar? Qual é a diferença entre JPA e Hibernate?

Acho que para responder essa pergunta, primeiro precisamos entender o que é JPA . JPA é uma especificação que descreve o mapeamento objeto-relacional de objetos Java simples e fornece uma API para armazenar, recuperar e manipular tais objetos. Ou seja, como lembramos, os bancos de dados relacionais (BDs) são apresentados na forma de diversas tabelas interligadas. E JPA é um padrão amplamente aceito que descreve como os objetos podem interagir com bancos de dados relacionais. Como você pode ver, JPA é algo abstrato e intangível. É como a ideia em si, a abordagem. Ao mesmo tempo, o Hibernate é uma biblioteca específica que implementa os paradigmas JPA . Ou seja, com a ajuda desta biblioteca você pode trabalhar com um banco de dados relacional através de objetos que representam dados do banco de dados (Entidade). Como se costuma dizer, esta biblioteca está muito próxima dos ideais do JPA e talvez por isso tenha se popularizado. E como você entende, a popularidade de uso é um bom argumento para desenvolvimento e melhorias adicionais. Além disso, por trás do seu uso frequente existe uma enorme comunidade que já resolveu todas as questões possíveis e impossíveis relacionadas a esta ferramenta. Aqui está um exemplo de livro que examina detalhadamente todos os cantos obscuros desta tecnologia. Ou seja, o Hibernate foi estudado tanto quanto possível e, ao que parece, é confiável. Na verdade, não é à toa que mesmo a implementação ideal do JPA no lado do Spring geralmente usa o Hibernate nos bastidores.

53. O que é cascata? Como é usado no Hibernate?

Como falei anteriormente, no Hibernate a comunicação é realizada através de objetos de dados chamados entidades . Essas entidades representam algumas tabelas específicas no banco de dados e, como você lembra, em Java as classes podem conter referências a outras classes. Esses relacionamentos são refletidos no banco de dados. Em um banco de dados, via de regra, são chaves estrangeiras (para OneToOne, OneToMany, ManyToOne) ou tabelas intermediárias (para ManyToMany).Você pode ler mais sobre o relacionamento entre entidades neste artigo . Quando a sua entidade possui links para outras entidades relacionadas, são colocadas anotações acima desses links para indicar o tipo de conexão: @OneToOne, @OneToMany, @ManyToOne, @ManyToMane, em cujos parâmetros você pode especificar o valor da propriedade - cascata - o tipo de cascata para esta conexão. JPA possui métodos específicos para interagir com entidades (persistir, salvar, mesclar...) . Os tipos em cascata são usados ​​precisamente para mostrar como os dados associados devem se comportar quando esses métodos são usados ​​na entidade alvo. Então, quais são as estratégias em cascata (tipos de cascata)? O padrão JPA implica o uso de seis tipos de cascata:

• PERSIST - as operações de salvamento ocorrerão em cascata (para os métodos save() e persist() ). Ou seja, se salvarmos uma entidade associada a outras entidades, elas também serão salvas no banco de dados (se ainda não estiverem lá)

• MERGE - as operações de atualização ocorrerão em cascata (para o método merge() )

• REMOVE - as operações de remoção ocorrem em cascata ( método remove() )

• ALL - contém três operações em cascata ao mesmo tempo - PERSIST - MERGE - REMOVE

JPA tem o conceito de entidade persistente - uma entidade associada aos seus dados no banco de dados, que é controlada pela sessão (conexão) atual . Se você alterá-lo, mas não salvar as alterações no banco de dados, seus dados no banco de dados ainda serão alterados.

• Entidades relacionadas a DETACH não serão gerenciadas pela sessão ( método detach() ). Ou seja, quando eles mudarem, não haverá alteração automática de seus dados no banco de dados - eles são transferidos do estado persistente para desanexado (entidade não gerenciada pelo JPA)

• REFRESH - toda vez que uma entidade é atualizada com dados do banco de dados ( refresh() - atualiza objetos desanexados), as entidades relacionadas são atualizadas da mesma forma. Por exemplo, você alterou de alguma forma os dados retirados do banco de dados e deseja retornar seus valores originais. Neste caso, esta operação será útil para você.

O Hibernate suporta todas essas operações em cascata padrão, mas também introduz três delas próprias:

• REPLICATE - Utilizado quando temos mais de uma fonte de dados e queremos que os dados sejam sincronizados (método Hibernate - replicate). Todas as entidades devem possuir identificadores (id) para que não haja problemas na sua geração (para que uma mesma entidade não tenha ids diferentes para bases de dados diferentes)

• SAVE_UPDATE - salvar/excluir em cascata (para o método Hibernate - saveOrUpdate )

• LOCK é a operação inversa de DETACHED : transfere a entidade desanexada de volta ao estado de persistência , ou seja, entidade será rastreada novamente pela sessão atual

Se o tipo em cascata não for selecionado, nenhuma operação em uma entidade terá efeito em outras entidades associadas a ela.

54. Uma classe Entity pode ser abstrata?

Na especificação JPA no parágrafo 2.1 A Classe Entidade há uma linha: “ Tanto as classes abstratas quanto as concretas podem ser entidades ”. Portanto a resposta é sim, uma classe abstrata pode ser uma entidade e pode ser anotada com @Entity.

55. O que é um gestor de entidade? Pelo que ele é responsável?

Em primeiro lugar, gostaria de observar que o EntityManager é um dos principais componentes do JPA , usado para interagir entidades com o banco de dados. Em geral, chama os métodos de interação entre a entidade e o banco de dados (persistir, mesclar, remover, desanexar)... Mas também observaria que este componente, via de regra, não é o mesmo para toda a aplicação: na maioria das vezes é leve e geralmente é removido e um novo é criado usando EntityManagerFactory . Se traçarmos um paralelo com JDBC , onde EntityManagerFactory será um análogo de DataSource , então EntityManager, por sua vez, será um análogo de Connection . Anteriormente mencionei uma entidade de persistência , como uma entidade controlada pela conexão atual. Então: essa entidade é gerenciada justamente pelo EntityManager , que está intimamente relacionado à conexão atual e pelo TransactionManager , que é responsável por abrir/fechar transações. Mais adiante na figura abaixo você pode ver o ciclo de vida de uma entidade: EntityManager gerencia a entidade quando ela está no estágio Gerenciado (neste momento é persistente, pois possui conexão com o EntityManager). Ou seja, não é mais novo e ainda não foi removido. Podemos dizer que quando uma entidade é nova ou removida, ela também é desvinculada, pois não é gerenciado pelo EntityManager. Existem diferentes estratégias para EntityManager. Ou seja, pode haver um EntityManager singleton para toda a aplicação, ou um novo pode ser criado a cada vez, para cada conexão. Se você usar Spring, a criação/exclusão do EntityManager será controlada automaticamente nos bastidores (mas isso não significa que você não possa personalizá-lo ^^). Vale dizer que um ou mais EntityManagers formam o contexto de persistência . Contexto de persistência é um ambiente em que instâncias de entidades são sincronizadas com entidades semelhantes no banco de dados (como eu disse, isso só funciona para entidades persistentes). Se você se aprofundar no JPA (o que eu recomendo fortemente), você encontrará esses conceitos com muita frequência.

56. O que é a classe Assert? Por que usá-lo?

Eu não ouvi falar de tal classe em JPA , então assumirei que se refere à classe JUnit da biblioteca usada para testes unitários de código. A classe desta biblioteca, Assert , é usada para verificar os resultados da execução do código ( asser é uma declaração de que você tem um determinado estado/dados em um determinado local). Por exemplo, você está testando um método que deve criar um gato. Você executa um método e obtém algum resultado:

Cat resultOfTest = createCat();

Mas você precisa ter certeza de que foi criado corretamente, certo? Portanto, você criou anteriormente um determinado gato - esperadoCat - manualmente com exatamente os parâmetros que você espera do gato obtido do método createCat() . A seguir, você usa a classe Assert para verificar os resultados:

Assert.assertEquals(resultOfTest, expectedCat);

Se os gatos forem diferentes, será lançada uma exceção AssertionError , que nos informa que os resultados esperados não convergem. A classe Assert possui muitos métodos diferentes que cobrem muitas das tarefas de verificação dos resultados esperados. Aqui estão alguns deles:

• assertTrue(<boolean>) - o valor esperado recebido como argumento deve ser verdadeiro

• assertFalse(<boolean>) - o valor esperado recebido como argumento deve ser falso

• assertNotEquals(<object1>, <object2>) - objetos recebidos como argumentos devem ser diferentes quando comparados usando iguais ( false )

• assertThrows(<ClassNameOfException>.class, <exceptionObject>) - espera-se que o segundo argumento seja uma exceção da classe especificada pelo primeiro argumento (ou seja, como regra, no lugar do segundo argumento, é chamado um método que deve lançar uma exceção do tipo necessário)

Corda

57. Caracterizar String em Java

String é uma classe padrão em Java, responsável por armazenar e manipular valores de string (sequências de caracteres), é uma classe imutável ( escrevi sobre imutável anteriormente ), ou seja, Os dados dos objetos desta classe não podem ser alterados após a criação. Gostaria de observar imediatamente que as classes StringBuilder e StringBuffer são duas classes praticamente idênticas, com a única diferença de que uma delas se destina ao uso em um ambiente multithread (StringBuffer). Essas classes são análogas a String , mas diferentemente dela, são mutáveis . Ou seja, os objetos, uma vez criados, permitem a modificação da string que representam sem criar um novo objeto. Na verdade, os métodos diferem dos métodos String padrão e visam atender às necessidades de alteração da string (não é à toa que são chamados de construtor). Leia mais sobre String , StringBuffer e StringBuilder neste artigo .

58. Quais são as diferentes maneiras de criar um objeto String? Onde ele é criado?

A maneira mais comum de criar uma string é simplesmente especificar o valor que precisamos entre colchetes duplos:

String str = "Hello World!";

Você também pode fazer isso diretamente via new :

String str = new String("Hello World!");

Você pode criar uma string começando com um array de caracteres:

char[] charArr = {'H','e','l','l','o',' ', 'W','o','r','l','d','!'};
String str = new String(charArr);

Como resultado do método toString em execução em algum objeto:

String str = someObject.toString();

Como o resultado de qualquer outro método, ele retorna uma representação de string. Por exemplo:

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String str =  reader.readLine();

Como você entende, pode haver muitas maneiras de criar uma string. Quando um objeto String é criado, ele é armazenado no string pool , sobre o qual falaremos com mais detalhes em uma das perguntas abaixo.

59. Como comparar duas strings em Java e como classificá-las?

Para comparar valores em Java, é usado o sinal de igual duplo == . Se precisássemos comparar alguns valores simples como int , nós o usaríamos. Mas este método não é aplicável para comparar objetos completos. Neste caso, será apenas uma comparação de referências – quer apontem para o mesmo objeto ou não. Ou seja, ao comparar dois objetos com exatamente os mesmos valores de campos internos, a comparação através de == dará o resultado falso : apesar dos campos idênticos dos objetos, os próprios objetos ocupam células de memória diferentes. E os objetos da classe String , apesar de sua simplicidade enganosa, ainda são objetos. E a comparação via == também não é aplicável a eles (mesmo apesar da presença de um conjunto de strings). Aqui entra em ação o método padrão da classe Object - equals , que deve ser substituído na classe para que funcione corretamente (caso contrário, por padrão ele compara usando == ). Ele é substituído na classe String , então apenas pegamos e usamos:

String firstStr = "Hello World!";
String secondStr = "Hello World!";
boolean isEquals = firstStr.equals(secondStr);

Falamos sobre comparações de correspondência, agora vamos dar uma olhada nas comparações de classificação. Afinal, para classificar algo, precisamos saber por qual princípio classificar. Para fazer isso, você pode usar um conjunto classificado padrão - TreeSet . Você pode ler mais sobre várias coleções em Java neste artigo . Esta lista funciona com base no algoritmo de árvore vermelho-preto e classifica o conjunto de acordo com o princípio de classificação especificado. Como eu disse anteriormente, você precisa entender como classificar objetos de um determinado tipo. Comparadores são usados ​​para definir o método de comparação para classificação . Normalmente eles precisam ser implementados para as classes que você deseja classificar, mas no caso de String eles já estão implementados. Portanto, simplesmente adicionamos as linhas necessárias ao TreeSet e ele as classificará:

TreeSet<String> sortedSet = new TreeSet<>();
sortedSet.add("B");
sortedSet.add("C");
sortedSet.add("A");
sortedSet.forEach(System.out::println);

Saída do console:

60. Forneça um algoritmo para converter uma string em um caractere. Escreva o código apropriado

Como eu disse anteriormente, os objetos da classe String possuem vários métodos úteis diferentes. Um deles é toCharArray . Este método converte uma string em uma matriz de caracteres:

String str = "Hello world";
char[] charArr = str.toCharArray();

A seguir temos um array de caracteres que podemos chamar por índice:

char firstChar = charArr[0]; // H

61. Como converter uma string em uma matriz de bytes e vice-versa? Escreva o código apropriado

Semelhante ao método toCharArray , a classe String possui um método getBytes que retorna uma matriz de bytes da string:

String str = "Hello world";
byte[] byteArr = str.getBytes();
byte firstChar = byteArr[6]; // 119

A parte da análise de hoje chegou ao seu fim lógico. Obrigado pela sua atenção!