1. Introdução do IOC
O último artigo apresentou que IOC e AOP são o núcleo do Spring. O que é IOC? IOC (Inversion Of Control) significa inversão de controle, transfere a criação de objetos e a relação de chamada entre os objetos para o Spring gerenciar, de forma a atingir o objetivo de reduzir o acoplamento entre as classes.
Existem duas formas de IOC, DI (injeção de dependência) e DL (pesquisa de dependência). DI é injeção de dependência, que é o que costumamos chamar de injeção de atributo, e DL é a entidade de software atual que vai ativamente a um local de registro de serviço para encontrar de quais serviços depende (não muito usado, menos dados).
Para a distinção específica entre IOC, DI e DL, consulte este blog: https://www.cnblogs.com/vince-zww/p/11498605.html
Em segundo lugar, o princípio do COI
Na camada inferior do IOC, três tecnologias principais são usadas, a saber: análise de arquivo XML; modo de fábrica; reflexão. Portanto, algumas pessoas têm dúvidas: quais são os benefícios do COI? A seguir, simulamos uma cena real para analisar. Na estrutura da Web de três camadas, geralmente usamos UserService para chamar UserDao para concluir as operações de negócios do usuário.A implementação tradicional é realmente boa?
1. A maneira tradicional
A forma tradicional é a seguinte, acredito que todos podem escrever da seguinte forma:
Na forma tradicional, o acoplamento entre as classes UserService e UserDao é muito alto. Supondo que o caminho do UserDao seja alterado neste momento, o UserService também será alterado neste momento. Essa maneira de movimentar todo o corpo em um passo aumenta muito a dificuldade de desenvolvimento e não contribui para a expansão do programa.
2. Realização do modo de fábrica
O padrão de fábrica define especificamente uma classe como responsável pela criação de instâncias de outras classes, o que reduz o acoplamento entre as classes até certo ponto, da seguinte maneira:
Essa abordagem reduz o acoplamento entre UserSerivce e UserDao, mas não atinge o menor grau de acoplamento.
3. Método IOC
Por meio do método IOC, quando o caminho de UserDao muda, apenas o atributo de classe do bean no arquivo de configuração precisa ser modificado.
Três, contêiner IOC
O container IOC possui um container com função de injeção de dependência, podendo criar objetos, sendo que o container IOC é responsável por instanciar, localizar, configurar objetos na aplicação e estabelecer dependências entre esses objetos. Normalmente uma nova instância, o controle é controlado pelo programador, e "inversão de controle" significa que o trabalho da nova instância não é feito pelo programador, mas pelo container Spring. BeanFacotry é o representante real do contêiner IOC na primavera. O Spring fornece dois tipos diferentes de contêineres: ApplicationContext e BeanFactory.
1 、 BeanFactory
BeanFactory é a implementação básica do contêiner IOC. É uma interface usada internamente pelo Spring e não é fornecida aos desenvolvedores. O objeto não é criado quando o arquivo de configuração é carregado, ele é criado somente quando o objeto é obtido. Geralmente não é recomendado usar BeanFactory. Basta usar BeanFactory.
(1) Etapas de implementação
1) Crie a classe HelloApp e defina o método sayHello ().
2) Configure HelloApp em bean.xml.
3) Execute o teste de unidade.
(2) Processo de realização
Defina HelloApp.java:
package com.yht.example1;
public class HelloApp {
public void sayHello(){
System.out.println("hello Spring");
}
}
Configure em bean.xml:
<bean id="helloApp" class="com.yht.example1.HelloApp"></bean>
Teste de unidade:
@Test
public void testBeanFactory(){
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("bean.xml"));
HelloApp helloApp = (HelloApp) beanFactory.getBean("helloApp");
helloApp.sayHello();
}Os resultados da execução são os seguintes:
Preste atenção aos seguintes dois pontos:
Na primeira etapa, use a API XmlBeanFactory () fornecida pela estrutura para gerar beans de fábrica e use a API ClassPathResource () para carregar os arquivos de configuração de bean disponíveis no caminho CLASSPATH. A API XmlBeanFactory () é responsável por criar e inicializar todos os objetos, ou seja, beans no arquivo de configuração.
Na segunda etapa, use o método getBean () do objeto de fábrica de feijão gerado na primeira etapa para obter o bean necessário. Este método retorna um objeto real por meio do ID do bean no arquivo de configuração. Depois de obter esse objeto, você pode usá-lo para chamar qualquer método da classe.
2 、 ApplicationContext
ApplicationContext é uma subinterface do BeanFactory, incluindo todas as funções do contêiner BeanFactory, e os objetos no arquivo de configuração serão criados quando o arquivo de configuração for carregado.
Classe de implementação da interface ApplicationContext:
| Nome da classe | efeito |
|---|---|
| FileSystemXmlApplicationContext | O contêiner carrega os beans definidos do arquivo XML. Aqui, você precisa fornecer o caminho completo do arquivo XML para o construtor. O caminho aqui é o caminho da letra da unidade onde o arquivo está localizado, como: D: \ spring \ bean.xml. |
| ClassPathXmlApplicationContext | O contêiner carrega os beans definidos do arquivo XML. Não é necessário fornecer o caminho completo do arquivo XML, apenas configure a variável de ambiente CLASSPATH corretamente, porque o contêiner irá procurar o arquivo de configuração do bean a partir do CLASSPATH. |
| WebXmlApplicationContext | O contêiner irá carregar os beans definidos no arquivo XML dentro do escopo de um aplicativo da web |
O teste é o seguinte: modifique o exemplo anterior, altere o caminho do arquivo de configuração para o diretório java no disco D, crie um objeto por meio de FileSystemXmlApplicationContext e chame o método.
@Test
public void testFileSystemXmlApplicationContext(){
ApplicationContext applicationContext = new FileSystemXmlApplicationContext("D:\\Java\\bean.xml");
HelloApp helloApp = (HelloApp) applicationContext.getBean("helloApp");
helloApp.sayHello();
}Os resultados da execução são os seguintes:
3. Comparação de BeanFactory e ApplicationContext
| BeanFactory | ApplicationContext |
|---|---|
| Interfaces usadas internamente pelo Spring | Subinterface de BeanFactory |
| O objeto não é criado quando o arquivo de configuração é carregado, e apenas quando o objeto é usado | Crie o objeto quando o arquivo de configuração for carregado |
| Geralmente não recomendado | Uso recomendado |
A razão pela qual BeanFactory não é recomendado é que ele é criado quando o objeto é usado. Algumas pessoas terão perguntas: Isso não é ruim? É importante notar que, quando usamos o Spring como um aplicativo da web, colocaremos operações que consomem desempenho quando o servidor é iniciado, e as operações de criação de objetos acabam consumindo mais desempenho. Além disso, ApplicationContext é uma subinterface de BeanFactory, que fornece algumas funções avançadas, incluindo algumas funções para aplicativos corporativos, enquanto BeanFactory fornece apenas funções básicas.