Recentemente, comprei este livro introdutório da primavera: Springinaction. Eu naveguei aproximadamente e me senti muito bem. Só um pouco de começar. Os livros de Manning ainda são bons. Embora eu não me concentre em Manning como aqueles que apenas lêem os livros de Manning, eu o li com reverência e paixão. Mais uma vez, aceitei os conceitos centrais da primavera como COI, DI e AOP. Deixe -me falar sobre minha opinião sobre o COI e o DI primeiro.
COI (DI): De fato, o conceito de arquitetura do núcleo da primavera não é tão complicado e não é tão obscuro como descrito em alguns livros. Todos os programadores Java sabem que cada lógica de negócios em um programa Java requer pelo menos dois ou mais objetos para colaborar. Geralmente, quando cada objeto usa seu objeto de parceiro, ele deve usar uma sintaxe como newObject () para concluir o trabalho de aplicação do objeto parceiro. Você descobrirá que o acoplamento entre objetos é alto. A idéia do COI é: os recipientes de mola para realizar a criação e coordenação desses objetos interdependentes. Os objetos precisam apenas ter a própria lógica de negócios de relacionamento. Nesse sentido, a responsabilidade de como um objeto recebe seu objeto colaborativo é revertido (COI, DI).
Esta é a minha experiência do COI da primavera. DI é realmente outra maneira de dizer o COI. Di foi proposto pela primeira vez por Martin Fowler em um artigo no início de 2004. Ele concluiu: o que o controle é revertido? Ou seja: a maneira de obter objetos dependentes é revertida.
Se você ainda não entende esse conceito central: aqui citamos uma resposta simples e fácil de entender em um blog chamado Bromon:
COI e DI
Primeiro, quero falar sobre o COI (InversionOfControl, Control Inversão). Este é o núcleo da primavera, por toda parte. Para a estrutura da primavera, a primavera é responsável por controlar o ciclo de vida de um objeto e a relação entre objetos. O que isto significa? Para dar um exemplo simples, como encontramos uma namorada? Uma situação comum é que vamos a todos os lugares para ver onde temos mulheres bonitas e bonitas e, em seguida, perguntamos sobre seus interesses, números de QQ, números de telefone, números de IP, números de QI ..., encontre maneiras de conhecê-los, dar a eles o que eles gostam e depois hehe ... esse processo é complexo e profundo, e devemos projetar e enfrentar cada ligação a nós mesmos. O mesmo vale para o desenvolvimento tradicional do programa. Em um objeto, se você deseja usar outro objeto, deve obtê -lo (novo sozinho ou consultar um da JNDI). Após o uso, o objeto deve ser destruído (como conexão, etc.), e o objeto sempre será combinado com outras interfaces ou classes.
Então, como o COI faz isso? É como encontrar uma namorada através de uma agência de casamento e apresentar um terceiro entre mim e minha namorada: uma agência de casamento. A agência de casamento gerencia muitas informações sobre homens e mulheres. Posso fornecer uma lista para a agência de casamento e dizer que tipo de namorada quero encontrar, como parecer Michelle Reis, tendo uma figura como Lin Xilei, cantando como Jay Chou, tendo uma velocidade como Carlos e tendo uma tecnologia como Zidane. Em seguida, a agência de casamento fornecerá um MM de acordo com nossos requisitos. Só precisamos nos apaixonar e nos casar. É simples e claro. Se os candidatos dados a nós não atenderem aos requisitos, faremos uma exceção. Todo o processo não é mais controlado por mim, mas é controlado por uma instituição semelhante a um contêiner como uma agência de casamento. Este é o método de desenvolvimento defendido pela primavera. Todas as aulas serão registradas no recipiente da primavera para dizer à primavera o que você é e o que você precisa. Em seguida, a primavera fornecerá o que você deseja quando o sistema estiver sendo executado para o nível apropriado e, ao mesmo tempo, entregando você a outras coisas que precisam de você. Todas as classes são criadas e destruídas pela primavera, o que significa que o objeto que controla o ciclo de vida de um objeto não é mais o objeto que o faz referência, mas a mola. Para um objeto específico, ele usado para controlar outros objetos, mas agora todos os objetos são controlados pela primavera, portanto, isso é chamado de inversão de controle.
Um dos pontos -chave do COI é fornecer dinamicamente um objeto com outros objetos de que precisa durante a operação do sistema. Isso é conseguido através de DI (dependência de injeção). Por exemplo, o objeto A precisa operar o banco de dados. No passado, sempre escrevemos código em A para obter um objeto de conexão. Com a primavera, precisamos dizer apenas à Spring que é necessária uma conexão em A. Quanto a como construir essa conexão e quando construí -la, a não precisa saber. Quando o sistema estiver em execução, a primavera criará uma conexão no momento apropriado e a injetará em uma injeção como uma injeção, completando assim o controle da relação entre cada objeto. Uma necessidade de confiar na conexão para executar normalmente, e essa conexão é injetada em uma primavera, e o nome da injeção de dependência vem disso. Então, como o DI é implementado? Um recurso importante após o Java 1.3 é a reflexão, que permite ao programa gerar dinamicamente objetos, executar métodos de objetos e alterar as propriedades dos objetos ao executar. A primavera é injetada através da reflexão. Para obter informações relacionadas sobre reflexão, consulte o Javadoc.
Depois de entender os conceitos de COI e DI, tudo se tornará simples e claro, e o restante do trabalho é apenas acumular blocos na estrutura da primavera.
Vamos aprender como a primavera funciona.
public static void main (string [] args) {ApplicationContext context = new FileSystemXMLApplicationContext ("ApplicationContext.xml"); Animal animal = (animal) context.getBean ("animal"); Animal.Say (); }Você deve estar familiarizado com este código, mas vamos analisá -lo. Primeiro, ApplicationContext.xml
<bean id = "animal"> <propriedade name = "name" value = "kitty" /> </i bean>
Ele tem uma classe phz.springframework.test.cat
public class Cat implementa Animal {private String Name; public void diz () {System.out.println ("eu sou" + nome + "!");} public void setName (nome da string) {this.name = name;}}Implementou a interface phz.springframework.test.animal
Public Interface Animal {public void diz (); }Obviamente, o código acima produz Iamkitty!
Então, como a primavera faz isso?
Em seguida, vamos escrever uma primavera para ver como a primavera funciona!
Primeiro, definimos uma aula de feijão, usada para armazenar propriedades de propriedade de um feijão
/ * ID do feijão */ ID de sequência privada; / * Classe de feijão */ Tipo de sequência privada; / * Propriedade do feijão */ mapa privado <string, objeto> Propriedades = new Hashmap <string, object> ();
Um feijão inclui ID, tipo e propriedades.
A próxima primavera começa a carregar nosso arquivo de configuração e salva as informações de configuração em um hashmap. A chave do hashmap é o ID do feijão e o valor do hasmap é o feijão. Somente dessa maneira podemos obter a classe de animais através do método de contexto.GetBean ("Animal"). Todos sabemos que o Spirng pode injetar tipos básicos e pode injetar tipos como Lista e Mapa. Em seguida, vamos tomar mapa como exemplo para ver como a primavera é salva
A configuração do mapa pode ser como o seguinte
<bean id = "test"> <propriedade name = "testmap"> <pap> <entradas key = "a"> <value> 1 </value> </entradas> <entrada key = "b"> <value> 2 </value> </string> </map> </property> </i bean>
Como a primavera salva a configuração acima? O código é o seguinte:
if (beanproperty.Element ("map")! = null) {map <string, object> PropertiesMap = new Hashmap <string, object> (); Propriedades do elementoListmap = (elemento) beanProperty.Elements (). Get (0); Iterator <?> PropertiesIterator = PropertiesListmap.Elements (). Iterator (); while (PropertiesIterator.hasNext ()) {elemento vet = (elemento) PropertiesIterator.Next (); if (vet.getName (). Equals ("Entrada")) {String key = vet.attributeValue ("key"); Iterator <?> ValoresIterator = vet.elements (). Iterator (); while (valoresiterator.hasNext ()) {elemento valor = (elemento) ValuseItIerator.Next (); if (value.getName (). Equals ("value")) {PropertiesMap.put (key, value.getText ()); } if (value.getName (). Equals ("ref")) {PropertiesMap.put (key, new String [] {value.attributeValue ("bean")}); }}}} bean.getProperties (). put (nome, propertiesmap); }Em seguida, vamos para a parte principal. Vamos ver como a primavera é a injeção de dependência. De fato, a idéia de injeção de dependência também é muito simples. É implementado através do mecanismo de reflexão. Ao instantar uma classe, ela injeta os atributos da classe armazenados no hashmap na classe, refletindo o método de conjunto na classe. Vamos ver como é feito.
Primeiro instanciar uma aula, como esta
public estático objeto newInstance (string className) {classe <?> cls = null; objeto obj = null; tente {cls = class.ForName (ClassName); obj = cls.NewInstance ();} catch (ClassNoTException E) {throw RunTimeException (e);} catch (Catch (Catch (Catch (ClassNotException e) {throw) (IlegalAccescessception e) {throw New RunTimeException (e);} retorna obj;}Então injeta as dependências desta classe nela, assim
public static void setProperty (object obj, nome da string, value string) {classe <? estende objeto> clazz = obj.getClass (); tente {string methodName = returnSetMthodName (name); método [] ms = clazz.getMethods (); para (método m: ms) {if (m.getName (). Equals (métodname)) {if (m.getParameterTypes (). m.getParameterTypes () [0]; SetfieldValue (clazzParameterType.getName (), valor, m, obj); break;}}}}} catch (securityException e) {throw RunTimeException (e);} catch (ilegalArgutumentException e) {throw RunTimeException (e);} catch (ilegalArgumentExtEd e) {tlowTimeException (e); RUNTimeException (e);}}Finalmente, ele retorna uma instância dessa classe para nós e podemos usá -la. Vamos tomar o mapa como exemplo para ver como é feito. O código que escrevi é criar um hashmap e injetar o hashmap na classe que precisa ser injetado, assim
if (Instância do valor do mapa) {iterator <?> EntryIterator = ((map <?,?>) value) .EntrySet (). iterator (); Mapa <string, object> map = new hashmap <string, object> (); while (EntryIterator.hasNext ()) {Entry <?,?> EntryMap = (Entry <?,?>) EntryBerterator.Next (); if (EntryMap.getValue () instanceof string []) {map.put ((string) entradas.getKey (), getBean (((string []) entrymap.getValue ()) [0])); }} Beanprocesser.setProperty (obj, propriedade, mapa); }Ok, para que possamos usar o Spring para criar a classe para nós. Não é difícil? Claro que a primavera pode fazer mais do que isso. Este programa de exemplo fornece apenas parte da função de injeção de dependência mais central da Spring.
Este artigo referenciou um grande número de artigos e não pode agradecer um por um. Obrigado aqui juntos. Peço desculpas por sua violação de direitos autorais. Espero que seja útil para todos!
Resumir
O exposto acima é todo o conteúdo deste artigo sobre a explicação detalhada dos princípios do COI da primavera, e espero que seja útil para todos. Amigos interessados podem continuar se referindo a este site:
Um breve entendimento dos exemplos de COOP, AOP e código da primavera
Introdução detalhada à implementação da simulação do COI da Spring
Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!