Muitas pessoas, depois de ler meus artigos sobre a criação de um modelo para um projeto web e sobre a criação de um serviço web simples usando servlets , se perguntaram quando eu escreveria sobre Spring. Não quis, sugeri a leitura de um livro (e ainda digo que um livro vale mais que 10, ou até 100 artigos na internet). Mas agora decidi que, para explicar a mesma coisa para pessoas diferentes, passo mais tempo do que se me sentasse uma vez e escrevesse um artigo e depois postasse um link para ele. Então, estou escrevendo por causa do link)). Neste artigo não escreverei como fazer um projeto funcional no Spring em 5 minutos seguindo meu exemplo. Escreverei apenas sobre coisas básicas, sem as quais certamente é possível iniciar um projeto, mas o que está acontecendo ali e, mais importante, por que, não ficará claro.
O que é Spring Framework?
Spring Framework , ou simplesmente Spring , é um dos frameworks mais populares para criação de aplicações web em Java. Uma estrutura é algo semelhante a uma biblioteca (talvez este termo seja mais familiar para você), mas há um ponto. A grosso modo, usando uma biblioteca, você simplesmente cria objetos das classes que estão nela, chama os métodos que precisa e assim obtém o resultado que precisa. Ou seja, existe uma abordagem mais imperativa: você indica claramente em seu programa em que momento específico precisa criar qual objeto, em que momento precisa chamar um método específico, etc. Com frameworks, as coisas são um pouco diferentes. Você simplesmente escreve algumas de suas próprias classes, escreve alguma parte da lógica ali, e o próprio framework cria objetos de suas classes e chama métodos para você. Na maioria das vezes, suas classes implementam algumas interfaces do framework ou herdam algumas classes dele, recebendo assim algumas das funcionalidades já escritas para você. Mas não precisa ser assim. No Spring, por exemplo, eles tentam se afastar ao máximo desse acoplamento estrito (quando suas classes dependem diretamente de algumas classes/interfaces deste framework), e usam anotações para esse fim. Retornaremos a este assunto depois. Mas é importante entender que Spring é apenas um conjunto de algumas classes e interfaces que já foram escritas para você :) Também quero observar imediatamente que Spring pode ser usado não apenas para aplicações web, mas também para o console mais comum aplicativos que são tão familiares para todos nós, programas E hoje vamos até escrever algo assim.
Estrutura
Mas o Spring não é uma estrutura específica. Este é um nome geral para uma série de pequenos frameworks, cada um dos quais realiza algum tipo de trabalho diferente.
Como você pode ver, a mola possui uma estrutura modular. Isso nos permite conectar apenas os módulos que precisamos para nossa aplicação e não conectar aqueles que obviamente não usaremos. Pelo que eu sei, foi essa abordagem que ajudou o Spring a superar seu concorrente da época (EJB) e assumir a liderança. Porque os aplicativos que usam EJB carregavam consigo muitas dependências e, em geral, revelavam-se lentos e desajeitados. A imagem mostra que a estrutura de mola consiste em vários módulos:
Acesso de dados;
rede;
essencial;
e outros.
Hoje conheceremos alguns conceitos do módulo principal, como: beans, contexto e outros. Como você pode imaginar, o módulo de acesso a dados contém ferramentas para trabalhar com dados (principalmente bancos de dados), web - para trabalhar na rede (inclusive para criar aplicativos web, que serão discutidos mais adiante). Além disso, há também a chamada infra-estrutura completa do Spring: muitos outros projetos que não estão oficialmente incluídos no próprio framework, mas estão perfeitamente integrados ao seu projeto Spring (por exemplo, a mesma segurança do Spring para trabalhar com autorização do usuário no site, o que, espero, também sentiremos algum dia).
Por que Spring em Java?
Bem, além do fato de ser moderno, estiloso e jovem, posso dizer imediatamente que assim que você dominá-lo um pouco, você entenderá quantos trabalhos diferentes você não precisa fazer agora, e quanto Primavera assume. Você pode escrever algumas dezenas de linhas de configurações, escrever algumas classes - e você terá um projeto funcional. Mas assim que você começar a pensar sobre quanto existe “nos bastidores”, quanto trabalho está sendo feito e quanto código teria que ser escrito se você fizesse o mesmo projeto em servlets simples ou em soquetes e Java puro - você fica com os cabelos em pé :) Existe até essa expressão: como a "mágica" da Primavera. É quando você vê que tudo está funcionando, mas você estima aproximadamente o quanto deve acontecer lá para que tudo funcione e como tudo funciona lá - então parece que tudo isso está acontecendo graças a algum tipo de mágica, na verdade)) É mais fácil de chame tudo de mágico do que tente explicar como tudo está interligado ali. :) Bem, o segundo argumento “para” aprender Spring é que em aproximadamente 90% das vagas para júnior (de acordo com minhas observações pessoais), ou conhecimento ou pelo menos uma ideia geral do conjunto de cavalheiros Spring de data, web-mvce security:) é necessário apenas o básico.
DI/COI
Se você tentou ler algo no Spring, a primeira coisa que encontrou provavelmente foram estas letras: DI/IoC . Agora eu recomendo fortemente que você faça uma pausa neste artigo e leia este artigo sobre Habré ! IoC (Inversão de Controle) - inversão de controle. Já mencionei isso de passagem quando escrevi que ao usar uma biblioteca, você mesmo escreve em seu código qual método de qual objeto chamar, e no caso de frameworks, na maioria das vezes o framework chamará o código que você escreveu à direita momento. Ou seja, aqui você não controla mais o processo de execução do código/programa, mas o framework faz isso por você. Você transferiu o controle para ele (inversão de controle). DI é entendido como Inversão de Dependência (inversão de dependência, ou seja, tentativas de não fazer conexões rígidas entre seus módulos/classes, onde uma classe está diretamente ligada a outra), ou Injeção de Dependência (injeção de dependência, isto é, quando objetos cat não são criado por você no principal e então você os passa para seus métodos, e o Spring os cria para você, e você apenas diz a ele algo como “Eu quero pegar um gato aqui” e ele passa para você em seu método). Encontraremos o segundo com mais frequência em artigos futuros.
Feijão e contexto
Um dos conceitos-chave da primavera é o feijão . Em essência, é apenas um objeto de alguma classe. Digamos que para o nosso programa precisamos usar 3 objetos: um gato, um cachorro e um papagaio. E temos um monte de classes com vários métodos, onde às vezes precisamos de um gato para um método, e um cachorro para outro método, e às vezes teremos métodos onde precisamos de um gato e um papagaio (por exemplo, um método para alimentar um gato, hehe), e em alguns métodos, todos os três objetos serão necessários. Sim, podemos primeiro criar esses três objetos no principal, e depois passá-los para nossas classes, e de dentro das classes para os métodos que precisamos... E assim por diante ao longo do programa. E se também imaginarmos que queremos alterar periodicamente a lista de parâmetros aceitos para nossos métodos (bem, decidimos reescrever algo ou adicionar funcionalidade) - então teremos que fazer muitas edições no código se precisarmos mudar alguma coisa. Agora, e se imaginarmos que não temos 3, mas 300 desses objetos? Uma alternativa é coletar todos os nossos objetos em uma lista comum de objetos ( List<Object> ) e passá-la para todos os métodos, e de dentro dos métodos obter este ou aquele objeto que precisamos. Mas e se imaginarmos que à medida que o programa avança, algum objeto pode ser adicionado a esta lista, ou (o que é pior) eliminado? Então, em todos os métodos onde recuperamos objetos da lista pelo seu índice, tudo pode quebrar. Então decidimos armazenar não uma lista, mas um mapa, onde a chave será o nome do objeto que precisamos, e o valor será o próprio objeto, e então podemos obter os objetos que precisamos dele simplesmente pelo seu nome : get("parrot") e em resposta recebemos um objeto papagaio Ou, por exemplo, a chave é a classe do objeto e o valor é o próprio objeto, então não podemos mais indicar o nome do objeto, mas simplesmente a classe do objeto que precisamos, o que também é conveniente. Ou até mesmo escrever algum tipo de wrapper sobre o mapa, onde você pode criar métodos para que em alguns casos você possa recuperar objetos por seu nome, e em outros casos por classe. Isso é o que obtemos do contexto do aplicativo Spring . Um contexto é um conjunto de beans (objetos). Voltando ao contexto, podemos obter o bean (objeto) que precisamos pelo seu nome, por exemplo, ou pelo seu tipo, ou qualquer outra coisa. Além disso, podemos pedir ao Spring para procurar o bean que precisamos em seu contexto e passá-lo para o nosso método. Por exemplo, se tivéssemos um método como este:
publicvoiddoSomething(Cat cat){...}
Quando o Spring chamou esse método para nós, ele passou o objeto do nosso gato de seu contexto para ele. Agora decidimos que nosso método, além de um gato, também precisa de um papagaio. Usando a primavera - nada é mais fácil para nós! Simplesmente escrevemos:
publicvoiddoSomething(Cat cat,Parrot parrot){...}
e o Spring, quando chamar esse nosso método, vai entender que precisamos passar um gato e um papagaio aqui, ir até o contexto dele, pegar esses dois objetos e passá-los para o nosso método. Ao entregar as rédeas do nosso programa ao Spring, transferimos também para ele a responsabilidade de criar objetos e passá-los para os nossos métodos, que ele chamará. Surge a pergunta: como o Spring saberá quais objetos (bins) criar?
Métodos de configuração de aplicativos
Existem três maneiras principais de configurar uma aplicação (ou seja, informar ao Spring quais objetos precisamos para trabalhar):
usando arquivos/configurações xml;
usando configurações java;
configuração automática.
Os desenvolvedores do Spring os organizam nesta ordem de prioridade:
o método mais prioritário que deve ser preferido é a configuração automática;
se utilizando configuração automática não for possível configurar corretamente todos os beans possíveis, utilize configuração Java (criando objetos utilizando código Java);
Bem, a forma de menor prioridade é a antiga, usando configurações xml.
Além disso, o Spring permite combinar esses métodos. Por exemplo, deixe o Spring fazer tudo o que pode ser configurado automaticamente; onde você precisa especificar alguns parâmetros especiais, faça isso usando configurações Java e, além disso, você pode conectar algumas configurações legadas em formato xml. Em geral, tudo isso pode ser feito de forma bastante flexível. Mas ainda assim, se tudo pode ser feito usando configurações automáticas, use-as. Considerarei apenas a configuração automática e as configurações Java; As configurações xml já são usadas em quase todos os exemplos do Spring na Internet e, uma vez que você entenda como a configuração Java funciona, não deverá haver problemas em “ler” um arquivo xml que faça a mesma coisa. A configuração automática é usada quando os objetos que precisamos para trabalhar são objetos de classes que escrevemos . Se for necessária alguma lógica muito específica para criar um objeto da nossa classe, ou se não tivermos a oportunidade de marcar alguma classe com a anotação que precisamos, que seria captada pela configuração automática, isso pode ser feito nas configurações do Java . Na próxima parte , criaremos um projeto maven, conectaremos alguns módulos centrais do Spring a ele e criaremos nossos primeiros beans.
GO TO FULL VERSION