[Primavera da entrada ao tutorial de combate real] Capítulo 1 Visão geral da primavera

1. Visão geral do Spring

1.1 O que é a Primavera

    Spring é uma estrutura de software livre leve Java EE atualmente popular e uma das estruturas de maior sucesso no mundo Java. O Spring foi proposto e fundado pelo "Pai do Spring" Rod Johnson. Seu objetivo é simplificar a dificuldade de desenvolvimento e o ciclo de desenvolvimento de aplicativos corporativos Java.
    
    Desde o lançamento oficial do Spring 1.0 em abril de 2004, o Spring entrou na quinta versão principal, que costumamos chamar de Spring 5.
    
    O Spring tem sido preferido desde o início e é considerado a primeira escolha pelos desenvolvedores para o desenvolvimento de aplicativos corporativos Java. Hoje, Spring tornou-se sinônimo de Java EE e o padrão de fato para construir aplicativos Java EE.
    
    O Spring Framework não se limita ao desenvolvimento do lado do servidor. Qualquer aplicativo Java pode se beneficiar do Spring em termos de simplicidade, testabilidade e baixo acoplamento. O framework Spring também é uma plataforma supercola, além de fornecer funções próprias, também oferece a capacidade de colar outras tecnologias e frameworks.
    
    Spring é uma estrutura de contêiner leve de Inversão de Controle (IOC) e Aspect Oriented (AOP).

Descreva especificamente a Primavera:

    Leve: Spring é leve em termos de tamanho e sobrecarga. A estrutura Spring completa pode ser distribuída em um arquivo JAR com pouco mais de 1 MB de tamanho. E a sobrecarga de processamento exigida pelo Spring é insignificante. Além disso, o Spring não é intrusivo: normalmente, os objetos em um aplicativo Spring não dependem de classes específicas do Spring. O Servlet que aprendemos antes é intrusivo, porque uma classe Java deve implementar ou herdar a API do Servlet se quiser se tornar um Servlet, mas o Spring basicamente não.
    
    Ideia central:
        Inversão de controle: IOC (inversão de controle).
        Injeção de dependência: DI (injeção de dependência).
        Programação orientada a aspectos: AOP (programação orientada a aspectos).
    
    Container: O Spring contém e gerencia a configuração e o ciclo de vida dos objetos da aplicação, no sentido de que é um container, você pode configurar como cada um dos seus beans é criado - com base em um protótipo configurável (protótipo), seu bean pode criar um separado instância ou gerar uma nova sempre que precisar - e como elas se relacionam entre si.
    
    Framework: O Spring pode configurar e combinar componentes simples em aplicativos complexos. No Spring, os objetos do aplicativo são compostos declarativamente, normalmente em um arquivo XML. O Spring também fornece muitas funções básicas (gerenciamento de transações, integração de estrutura de persistência, etc.), deixando o desenvolvimento da lógica do aplicativo para você.
    
    One-stop shop: Com base em IOC e AOP, pode integrar estruturas de código aberto de vários aplicativos corporativos e excelentes bibliotecas de classe de terceiros (por exemplo: trabalho colaborativo entre estruturas Struts2 e Hibernate), Spring é uma ponte ou gerenciamento em o programa Ou, todo o aplicativo depende do Spring para ser executado. Na verdade, o próprio Spring também fornece SpringMVC para a camada de apresentação e SpringJDBC para a camada de persistência.

1.1.1 O nascimento e desenvolvimento da Primavera

    O J2EE (plataforma Java EE) inicial defendia o método de desenvolvimento com EJB como núcleo, mas esse método de desenvolvimento tem várias desvantagens no processo de desenvolvimento real, como uso complexo, código inchado, código intrusivo forte, ciclo de desenvolvimento longo e portabilidade difícil Grande espera.

    Em seu livro best-seller "Expert One-on-One J2EE Design and Development" editado em 2002, Rod Johnson analisou e negou as várias estruturas inchadas de EJB uma a uma e as substituiu de uma maneira mais concisa.

    Neste livro, Rod Johnson mostra, por meio de um apêndice de 30.000 linhas, como construir um aplicativo Java escalável e de alta qualidade sem usar EJBs. Neste apêndice, Rod Johnson escreveu dezenas de milhares de linhas de código de infraestrutura, incluindo muitas interfaces e classes Java reutilizáveis, como ApplicationContext, BeanFactory e muito mais. O pacote raiz para essas classes é denominado com.interface21, o que significa: Esta é uma referência para o século XXI.

    Este livro teve um impacto de longo alcance. Mais tarde, Rod Johnson abriu o código de com.interface21 e nomeou esta nova estrutura de "Primavera", que significa: A primavera é como um raio de brisa primaveril, varrendo o inverno frio do tradicional J2EE.

    Em fevereiro de 2003, foi lançada a versão 0.9 do Spring, que adotou o protocolo de código aberto Apache 2.0; em abril de 2004, foi lançada oficialmente a versão 1.0 do Spring. Até agora, o Spring entrou na quinta versão principal, que costumamos chamar de Spring 5.

1.1.2 Sentido estreito e amplo de Primavera

    Em diferentes contextos, a Primavera representa diferentes significados. A seguir, apresentaremos a Primavera sob as perspectivas de “sentido amplo” e “sentido estrito”.
    
    Site oficial: https://spring.io/

Spring em um sentido amplo: pilha de tecnologia Spring

    Spring em um sentido amplo refere-se à pilha de tecnologia Spring com Spring Framework como o núcleo.

    Após mais de dez anos de desenvolvimento, o Spring não é mais uma estrutura de aplicativo pura, mas se desenvolveu gradualmente em uma tecnologia madura composta por vários subprojetos (módulos) diferentes, como Spring Framework, Spring MVC, SpringBoot, Spring Cloud, Spring Data, Spring Security, etc., entre os quais o Spring Framework é a base de outros subprojetos.

    Esses subprojetos abrangem tudo, desde o desenvolvimento de aplicativos de nível empresarial até a computação em nuvem, e podem ajudar os desenvolvedores a resolver vários problemas práticos que surgem no processo de desenvolvimento de software, proporcionando aos desenvolvedores uma melhor experiência de desenvolvimento.

Nome do Projeto	descrever
dados de primavera	O módulo de acesso a dados fornecido pelo Spring oferece bom suporte para JDBC e ORM. Por meio dele, os desenvolvedores podem utilizar uma forma relativamente uniforme de acessar dados localizados em diferentes tipos de bancos de dados.
Lote Primavera	Uma estrutura leve para tarefas diárias de processamento em lote em sistemas de nível empresarial, que pode ajudar os desenvolvedores a desenvolver facilmente aplicativos de processamento em lote robustos e eficientes.
Spring Security	Anteriormente conhecido como Acegi, é um dos submódulos mais maduros do Spring. É uma estrutura personalizável de autenticação e controle de acesso.
Spring Mobile	É uma extensão do Spring MVC para simplificar o desenvolvimento de aplicações web móveis.
bota de mola	É uma nova estrutura fornecida pela equipe do Spring. Ele fornece algumas configurações prontas para o Spring e bibliotecas de terceiros, que podem simplificar o processo de construção e desenvolvimento de aplicativos Spring.
nuvem de primavera	Uma estrutura de microsserviço baseada em Spring Boot. Não é uma determinada tecnologia, mas uma coleção ordenada de uma série de soluções ou estruturas de microsserviços. Ele integra frameworks de microsserviços maduros e comprovados no mercado e os reembala através da ideia de Spring Boot, protegendo e ajustando os complexos princípios de configuração e implementação e, finalmente, fornece aos desenvolvedores um conjunto de ferramentas simples, fáceis de entender e fáceis de entender. -to-deploy E um kit de desenvolvimento de sistema distribuído fácil de manter.

Mola estreita: estrutura de mola

    Spring em um sentido restrito refere-se especificamente ao Spring Framework, ao qual geralmente nos referimos como Spring Framework.

    A estrutura Spring é uma solução leve completa e em camadas para aplicativos Java orientados a aspectos. É o núcleo e a base da pilha de tecnologia Spring e foi criada para resolver a complexidade do desenvolvimento de aplicativos de nível corporativo.

    Spring tem duas partes principais: IoC e AOP.

essencial	descrever
COI	A abreviação de Inverse of Control, traduzida como "inversão de controle", refere-se a entregar o processo de criação de objetos ao Spring para gerenciamento.
AOP	A abreviação de Programação Orientada a Aspectos, traduzida como "programação orientada a aspectos". O AOP é usado para encapsular o comportamento público de várias classes e encapsular a lógica que não tem nada a ver com negócios, mas é comumente chamada por módulos de negócios, de modo a reduzir a duplicação de código no sistema e reduzir o acoplamento entre os módulos. Além disso, o AOP também resolve alguns problemas no nível do sistema, como logs, transações, permissões, etc.

    Spring é uma tecnologia de programação baseada em bean que está mudando profundamente o mundo do desenvolvimento Java. O Spring usa Java Beans simples e básicos para concluir o trabalho que somente o EJB poderia fazer antes, tornando muitos códigos complexos elegantes e concisos, evitando o modo de desenvolvimento inchado e ineficiente do EJB e facilitando muito a manutenção posterior e atualização de projetos e extensões.

    No desenvolvimento real, os aplicativos do lado do servidor geralmente adotam uma arquitetura de três camadas, que são camada de apresentação (web), camada de lógica de negócios (serviço) e camada de persistência (dao).

    A Spring está comprometida com a solução de cada camada do aplicativo Java EE e fornece suporte técnico para cada camada.
    Na camada de apresentação, fornece a integração de Spring MVC, Struts2 e outros frameworks;
    na camada de lógica de negócios, fornece as funções de gerenciamento de transações e gravação de logs;
    na camada de persistência, tecnologias como MyBatis, Hibernate e JdbcTemplate também podem ser integrado para acessar o banco de dados.

    Isso reflete totalmente que o Spring é uma solução abrangente e o Spring nunca fará coisas repetitivas para as áreas que já possuem soluções melhores.

    Do ponto de vista do design, o framework Spring oferece aos programadores Java um maior grau de liberdade e fornece boas soluções para problemas comuns na indústria. Portanto, é amplamente bem-vindo na comunidade de código aberto e é considerado um projeto Java pela maioria das empresas • A estrutura preferida para desenvolvimento.

1.1.3 Recursos do Spring Framework

    A estrutura do Spring tem as seguintes características.

    Desacoplamento conveniente e desenvolvimento simplificado: Spring é uma grande fábrica, que pode entregar a criação de todos os objetos e a manutenção de dependências para o gerenciamento Spring.

    Integração conveniente de vários frameworks excelentes: O Spring não exclui vários frameworks excelentes de código aberto e fornece suporte direto para vários frameworks excelentes (como Struts2, Hibernate, MyBatis, etc.).

    Reduz a dificuldade de uso da API Java EE: O Spring fornece empacotamento para algumas APIs (JDBC, JavaMail, chamadas remotas, etc.) que são muito difíceis de usar no desenvolvimento Java EE, o que reduz muito a dificuldade de usar essas APIs.

    Teste de programa conveniente: o Spring suporta JUnit4 e os programas Spring podem ser facilmente testados por meio de anotações.

    Suporte de programação AOP: Spring fornece programação orientada a aspectos, que pode facilmente implementar funções como interceptação de permissão e monitoramento de operação de programas.

    Suporte para transações declarativas: o gerenciamento de transações pode ser concluído apenas por configuração, sem programação manual.

1.2 Arquitetura de primavera

    O framework Spring é uma arquitetura em camadas. Cada módulo pode existir independentemente ou ser implementado em conjunto com outros módulos. Sua arquitetura é mostrada na figura a seguir:

     Spring Core: O módulo Core é a biblioteca de classes principal do Spring. Todas as funções do Spring dependem dessa biblioteca de classes. O Core implementa principalmente funções IOC e todas as funções do Sprign são realizadas com a ajuda do IOC.
    
    Spring AOP: O módulo AOP é a biblioteca AOP do Spring, que fornece suporte para programação orientada a aspectos para objetos gerenciados pelo contêiner Spring.
    
    Spring DAO: Spring fornece suporte para JDBC, encapsula JDBC, permite que JDBC use recursos Spring e fornece gerenciamento de transações com base no módulo AOP.
    
    Spring ORM: O módulo ORM do Spring fornece gerenciamento e suporte auxiliar para estruturas ORM comumente usadas. Spring suporta estruturas comumente usadas, como Hibernate, ibtas e jdo. Spring em si não implementa ORM, mas apenas encapsula estruturas ORM comuns e as gerencia.
    
    Spring Context: O módulo Context fornece um método de acesso Bean estilo framework, e outros programas podem acessar os recursos Spring's Bean através do Context. Adicionado suporte para internacionalização, propagação de eventos e validação, bem como suporte para muitos serviços corporativos e integração de estrutura de modelo.
    
    Spring Web: O módulo WEB é construído no módulo Context, fornecendo um contexto adequado para aplicativos da Web. Além disso, a integração de Spring e outras estruturas da Web (como Struts1, Struts2, JSF) também é fornecida.
    
    Spring Web MVC: O módulo WEB MVC fornece ao Spring um conjunto de implementações MVC leves.É um aplicativo da Web completo que acomoda um grande número de tecnologias de visualização, como JSP, Velocity e POI.

1.3 Entendendo a Inversão de Controle e Injeção de Dependência

    IoC é a abreviação de Inversion of Control, traduzido como "inversão de controle". Não é uma tecnologia, mas uma ideia de design. É uma importante regra de programação orientada a objetos que pode nos guiar como projetar programas fracamente acoplados e melhores.

    O Spring gerencia a instanciação e a inicialização de todos os objetos Java por meio do contêiner IoC e controla as dependências entre os objetos. Chamamos um objeto Java gerenciado pelo contêiner IoC de Spring Bean, que é indistinguível de um objeto Java criado usando a palavra-chave new.

    O contêiner IoC é um dos componentes principais mais importantes na estrutura do Spring, que percorre todo o processo do Spring, desde o nascimento até o crescimento.

1.3.1 Entendimento popular

Classe de endereço:

public class Address {
    
    /**
     * 在Address类中使用到了String类与Integer类
     * 可以理解为，Address类依赖了String,Integer
     */
    private String city; //城市
    private String street; //街道
    private Integer no; //门牌号

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public Integer getNo() {
        return no;
    }

    public void setNo(Integer no) {
        this.no = no;
    }
}

Classe de pessoa:

public class Person {
    /**
     * Person类依赖了String, Integer, Address类
     */
    private String name;
    private Integer age;
    private Address address;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public void show(){
        System.out.println("hello");
    }
}

teste:

public class SpringTest {
    @Test
    public void testNewObject() {
        //传统创建对象的方式：由代码编写者创建对象，对象的生命周期由程序员决定
        //根据对象定义位置的不同，对象的生命周期也不相同
        System.out.println("address对象的生命周期开始");
        if (true) {
            Address address = new Address();

            //使用对象
            address.setCity("郑州市");
            address.setStreet("迎春路");
            System.out.println(address.getCity());

            //如果把创建Address对象的代码放在if语句块中,那么if执行结束,我们可以认为对象生命周期就结束了
        }

        //System.out.println(address); //定义在if中,在if外无法使用address

        //如果Address对象放在test1()中,那么方法执行结束,我们可以认为对象生命周期就结束了
        System.out.println("address对象的生命周期结束");
    }

    @Test
    public void testIOC() {
        /*
         * 控制反转：IOC
         * 将创建对象的权力转交给Spring，由Spring来负责对象的创建、销毁和管理
         * 程序员无需创建对象，只需要从Spring容器中获取对象和使用对象即可
         */
    }

    @Test
    public void testDI() {
        Address address = new Address();

        /*
         * 首先我们理解什么是依赖：
         *  在Address类中使用到了String类与Integer类
         *  可以理解为，Address类依赖了String,Integer
         */
        //那么为依赖类型的属性赋值，就叫做依赖注入
        address.setCity("郑州市");
        address.setStreet("迎春路");
        address.setNo(18);

        Person p = new Person();
        //注入字面值
        p.setName(new String("张三"));
        p.setAge(new Integer(20));
        //注入其他的对象
        p.setAddress(address);
    }
}

1.3.2 Inversão de Controle

    Em aplicativos Java tradicionais, se uma classe deseja chamar uma propriedade ou método em outra classe, ela geralmente cria o último objeto em seu código por meio de new Object() antes de realizar a transferência de propriedade ou método. Para facilitar o entendimento e a descrição, podemos nos referir ao primeiro como "chamador" e ao segundo como "chamado". Em outras palavras, o chamador detém o controle sobre a criação do objeto chamado.

    Mas no aplicativo Spring, o controle da criação do objeto Java está nas mãos do contêiner IOC e as etapas gerais são as seguintes.
        1. Os desenvolvedores definem objetos Java por meio de arquivos de configuração XML, anotações, classes de configuração Java, etc., como usar tags <bean> em arquivos de configuração XML, usar anotações @Component em classes Java etc.
        
        2. Quando o Spring iniciar, o contêiner IoC criará e gerenciará automaticamente esses objetos de acordo com a definição do objeto. Esses objetos criados e gerenciados pelo container IOC são chamados de Spring Beans.
        
        3. Quando queremos utilizar um determinado Bean, podemos obtê-lo diretamente do container IOC (por exemplo, através do método getBean() do ApplicationContext), sem criá-lo manualmente através de código (por exemplo, a forma de new Object( )).

    A maior mudança trazida pelo IoC não está no nível do código, mas uma mudança de "transposição mestre-escravo" no nível ideológico. Originalmente, o chamador é a parte ativa e tomará a iniciativa de criar qualquer recurso que queira usar; mas no aplicativo Spring, o contêiner IOC detém a iniciativa e o chamador se torna a parte passiva, esperando passivamente pelo IOC container Crie os objetos (Bean) que ele precisa.

    Este processo possui uma inversão de controle no nível de responsabilidade, sendo que a criação dos objetos originalmente implementados pelo chamador através de código é revertida para o container IOC para ajuda, por isso chamamos este processo de "inversão de controle" do Spring.

1.3.3 Injeção de Dependência

    Depois de entender IoC, também precisamos entender outro conceito muito importante: injeção de dependência.

    Injeção de Dependência (DI para abreviar) foi proposta por Martin Fowler em 2004 ao explicar "Inversão de Controle". Martin Fowler acredita que o termo "inversão de controle" é muito obscuro e é impossível para as pessoas entenderem diretamente "onde está a inversão", então ele sugere o uso de "injeção de dependência" em vez de "inversão de controle".

    Na orientação a objetos, existe um relacionamento chamado "dependência" entre os objetos. Simplificando, um relacionamento de dependência é que um objeto precisa usar outro objeto, ou seja, existe um atributo no objeto e o atributo é um objeto de outra classe.

Por exemplo, existe uma classe Java chamada B cujo código é o seguinte:

public class B {
    String bid;
    A a;
}

    Pode-se ver pelo código que existe um atributo de objeto a do tipo A em B, neste momento podemos dizer que o objeto de B depende do objeto a. E a injeção de dependência é baseada nessa "relação de dependência".

    Sabemos que a ideia central da inversão de controle é que o Spring é o responsável pela criação dos objetos. Durante o processo de criação do objeto, o Spring injetará automaticamente o objeto do qual depende no objeto atual de acordo com o relacionamento de dependência, que é chamado de "injeção de dependência".

1.3.4 Como funcionam os COIs

    No processo de desenvolvimento de software Java, existem relacionamentos de acoplamento mais ou menos certos entre objetos no sistema, entre módulos e entre sistemas de software e sistemas de hardware.

    Se o acoplamento de um sistema for muito alto, causará problemas difíceis de manter, mas o código sem nenhum acoplamento dificilmente poderá concluir qualquer trabalho, porque quase todas as funções requerem a cooperação e a interdependência entre os códigos para serem concluídas. Portanto, quando projetamos programas, a ideia que defendemos geralmente é minimizar o grau de acoplamento sem afetar as funções do sistema.

    A camada inferior do IoC reduz o grau de acoplamento do código ao mínimo através do modo de fábrica, mecanismo de reflexão Java, análise XML e outras tecnologias.As principais etapas são as seguintes.
        1. No arquivo de configuração (como Bean.xml), configure cada objeto e as dependências entre eles;
        
        2. Podemos considerar o container IoC como uma fábrica, e o produto desta fábrica é o Spring Bean;
        
        3. Quando o container começa Esses arquivos de configuração serão carregados e analisados ​​para obter as informações básicas dos objetos e suas dependências
        
        ; Injetado em objetos que dependem dele.

    Como as informações básicas do objeto e as dependências entre os objetos são definidas no arquivo de configuração e não fortemente acopladas no código, mesmo que o objeto mude, precisamos apenas modificá-lo no arquivo de configuração em vez de Modificar o código Java, que é o princípio de desacoplamento Spring IoC.

1.4 Criar ambiente de desenvolvimento Spring

1.4.1 Criar um projeto Java

    No módulo básico do Spring, não há conteúdo relacionado à Web e não há necessidade de criar um projeto JavaWEB, apenas um projeto Java.

1.4.2 Importar o pacote jar principal

Pacotes principais do framework Spring:

nome	efeito
spring-core-xxxx.jar	Contém as classes de ferramentas básicas do framework Spring, e outros componentes Spring devem usar as classes neste pacote, que é o núcleo básico de outros componentes.
spring-beans-xxxx.jar	Usado por todos os aplicativos, ele contém todas as classes relacionadas ao acesso a arquivos de configuração, criação e gerenciamento de beans e execução de operações de Inversão de Controle (IoC) ou Injeção de Dependência (DI).
spring-context-xxxx.jar	O Spring fornece serviços estendidos com base em funções IoC básicas e também fornece suporte para muitos serviços de nível corporativo, como serviços de correio, agendamento de tarefas, localização JNDI, integração EJB, acesso remoto, armazenamento em cache e encapsulamento de várias estruturas de camada de exibição.
spring-expression-xxxx.jar	Define a linguagem de expressão do Spring. Deve-se observar que, ao desenvolver com Spring, além do pacote JAR que acompanha o Spring, um pacote JAR de terceiros, commons.logging, é necessário para processar informações de log.

Método 1: Importar pacote jar

 Método 2: configuração de dependência maven

<dependencies>
    <!-- spring核心包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>
    <!-- springbeans包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>
    <!-- springcontext包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>
    <!-- spring表达式包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

1.4.3 Beans de Escrita

HelloWorld.java

public class HelloWorld {
    
    public String show() {
        return "Hello Spring";
    }
}

1.4.4 Gravando arquivos de configuração do Spring

    applicationContext.xml é o nome padrão e sua função é configurar os objetos Bean que precisam ser gerenciados pelo Spring no contêiner SpringIOC.
    
    O gerenciamento de configuração do Spring pode ser configurado usando XML, e existe um conceito de namespace em XML. Na verdade, é um pouco semelhante ao significado das tags. Depois de fornecer um namespace, as tags no contexto desse namespace podem ser usadas nesse arquivo XML.
    
    1. beans: o nó raiz do arquivo xml.
    
    2. xmlns: é a abreviação de XML NameSpace, porque os nomes de tags de arquivos XML são todos personalizados, as tags escritas por si e definidas por outros provavelmente serão nomeadas repetidamente, mas as funções são diferentes, então um namespace precisa ser adicionado Para distinguir este arquivo xml de outros arquivos xml, semelhante ao pacote em java.
    
    3. xmlns:xsi: significa que o arquivo xml está em conformidade com a especificação xml, e o nome completo de xsi: instância do esquema xml refere-se à especificação que os elementos definidos no arquivo de recurso do esquema usado no aplicativo específico devem obedecer. Ou seja, a quais padrões os elementos definidos no arquivo http://www.w3.org/2001/XMLSchema-instance obedecem.
    
    4. xsi:schemaLocation: Refere-se às normas que os elementos xml deste documento cumprem. Estas normas são todas formuladas pelo governo. Você pode entrar no site que escreveu para ver as mudanças de versão. A URL do xsd também pode ajudá-lo a determinar se o código que você está usando é legal.

<?xml version="1.0" encoding="UTF-8"?>
<!-- Spring配置文件xml，采用schema约束规范（一个xml文件可以采用多个文件的规范） -->
<!--
	xmlns：扩展当前xml的规范
	xsi:schemaLocation：规范文件，成对出现
-->
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!-- 配置bean：将Java中类的对象托管给springIOC容器 -->
    <bean id="helloworld" class="com.newcapec.bean.HelloWorld"></bean>
</beans>

A diferença entre Schema e DTD:

    Esquema é a definição e descrição da estrutura do documento XML, e sua principal função é restringir o documento XML e verificar a validade do documento XML. A função do DTD é definir os blocos de construção legais do XML, que usam uma série de elementos legais para definir a estrutura do documento. As diferenças entre eles são as seguintes:

    1. O esquema em si também é um documento XML. A definição de DTD não tem nada a ver com XML. O esquema tem muitos benefícios na compreensão e na aplicação prática.

    2. A estrutura do documento DTD é "plana". Se você definir um documento XML complexo, é difícil entender o relacionamento de aninhamento entre cada elemento; o documento Schema tem uma estrutura forte e o relacionamento de aninhamento entre cada elemento é muito intuitivo.

    3. O DTD só pode especificar que o elemento contém texto e não pode definir o tipo específico de texto do elemento, como tipo de caractere, tipo inteiro, tipo de data, tipo personalizado etc. Os esquemas são mais fortes que os DTDs nesse aspecto.

    4. O esquema suporta a descrição da ordem dos nós dos elementos. DTD não fornece uma descrição de situações desordenadas. Para definir situações desordenadas, todas as situações devem ser arranjadas exaustivamente. O esquema pode usar xs:all para representar situações não ordenadas.

    5. Suporte para namespaces. O DTD não pode aproveitar os namespaces XML e o Schema satisfaz os namespaces muito bem. Além disso, Schema também fornece dois métodos de inclusão e importação de namespaces de referência.

    6. XML Schema não pode definir entidades como DTD, e é mais complicado que DTD, mas Xml Schema é agora o padrão da organização w3c, e está gradualmente substituindo DTD.

Benefícios do esquema:

    1. Quando os usuários de XML usam o XML Schema, eles não precisam reaprender a entender o XML Schema, o que economiza tempo;
    
    2. Como o próprio XML Schema também é um tipo de XML, muitas ferramentas de edição XML, kits de desenvolvimento de API e análise de sintaxe XML Os filtros podem ser aplicados diretamente ao esquema XML sem modificação.
    
    3. Como uma aplicação de XML, o XML Schema herda naturalmente a autodescrição e a extensibilidade do XML, o que torna o XML Schema mais legível e flexível.
    
    4. Como o formato é exatamente igual ao XML, o XML Schema pode não apenas ser processado como XML, mas também ser armazenado da mesma forma que o documento XML que ele descreve, o que é conveniente para o gerenciamento.
    
    5. A consistência entre o esquema XML e o formato XML facilita a troca de esquemas entre sistemas de aplicativos que usam XML como troca de dados.
    
    6. XML tem requisitos de legalidade muito altos.A descrição de XML em XML DTD é frequentemente usada como base para verificar a legalidade de XML.No entanto, a legalidade de XML DTD em si carece de um bom mecanismo de verificação e deve ser tratada de forma independente. O XML Schema é diferente, tem o mesmo mecanismo de verificação de legalidade do XML.

1.4.5 Teste

@Test
public void testSpringIOC() {
    //1、创建IOC容器ApplicationContext
    //ClassPathXmlApplicationContext是ApplicationContext接口的实现类，该对象通过加载类路径下面的spring配置文件
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

    //2、从容器中获取bean对象
    /**
         * Object getBean(String name)
         * 参数name: 获取对象的名称，对象的唯一标识符，bean标签的id属性值
         * 返回值Object: 对象
         */
    Object obj = ac.getBean("helloworld");
    System.out.println(obj instanceof HelloWorld);
    HelloWorld helloWorld = (HelloWorld) obj;
    String str = helloWorld.show();
    System.out.println("方法的返回值为：" + str);

    Object obj1 = ac.getBean("helloworld");

    System.out.println(obj == obj1);
}

Há duas coisas a serem observadas sobre o código acima:

• A classe ClassPathXmlApplicationContext é utilizada na criação do objeto ApplicationContext, esta classe é utilizada para carregar o arquivo de configuração do Spring, criar e inicializar todos os objetos (Bean).

• O método ApplicationContext.getBean() é usado para obter o Bean, e o tipo de valor de retorno desse método é Object, que é convertido em um objeto de instância de HelloWorld por meio de conversão de tipo obrigatória, e o método show() nele é chamado.