Desenvolvimento manual - programa simples baseado em configuração Spring XML - análise de código-fonte

Programa baseado em configuração Spring XML simples de desenvolvimento manual

Este artigo o levará a escrever um contêiner Spring simples. Ao ler o arquivo de configuração beans.xml, você pode obter o primeiro objeto JavaBean:Monster, atribuir um valor ao objeto, colocá-lo no contêiner e gerar as informações do objeto.

Vamos primeiro revisar ao usar o Spring, obtemos ClassPathXmlApplicationContexto contêiner, o contêiner lê automaticamente o arquivo de configuração beans.xml, obtemos o objeto iocpor meio do método contêiner e produzimos o objeto.getBean

Tudo que você precisa fazer agora é:

• Para implementar você mesmo um contêiner ioc, a premissa é implementar um de sua preferência ClassPathXmlApplicationContext();
• ClassPathXmlApplicationContext()Forneça um método getBean().

Análise de pensamento@

Aqui, na verdade, nos concentramos no ClassPathXmlApplicationContext()processo de implementação específico:

• Defina um iocmapeamento ConcurrentHashMapque armazene o ID do nome do objeto e o objeto.
• Crie um construtor e coloque todas as seguintes operações neste construtor
• Use xmla tecnologia de análise dom4jpara beans.xmller as informações no arquivo e obter os valores dos atributos das informações do nó.
• Crie objetos usando reflexão
• Coloque o objeto iocem
• forneça um getBeanmétodo

Ao usar a tecnologia de análise xml dom4jpara ler as informações no arquivo beans.xml e obter os valores dos atributos das informações do nó, você precisa primeiro obter o caminho para o arquivo beans.xml. O caminho aqui se refere ao caminho onde estão localizados os arquivos compilados do projeto, ou seja, targeto caminho no diretório de trabalho. Nosso arquivo beans.xml é colocado resourceno diretório. Após a compilação, ele será executado no diretório target/classes , então aqui O diretório que dom4jlemos deve ser D:/Java/JavaProjects/spring-context-v1/target/classes/; o caminho completo do arquivo deve ser D:/Java/JavaProjects/spring-context-v1/target/classes/beans.xml;

 String path = this.getClass().getResource("/").getPath();
//        System.out.println("path="+path);
        SAXReader saxReader = new SAXReader();
        Document document = saxReader.read(new File(path + iocBeanXmlFile));
        

Depois de obter documento objeto de documento, obtivemos todo o conteúdo em beans.xml. Neste momento, obtivemos o nó raiz e, em seguida, obtivemos o primeiro objeto bean da tag bean através do nó raiz, os atributos na tag bean e o Os valores podem ser obtidos. Você pode obter o caminho de classe completo através do atributo de classe da tag bean. Depois de obter o caminho de classe, você pode criar um objeto por meio de reflexão. O tipo deste objeto é o objeto do seu caminho de classe.

 SAXReader saxReader = new SAXReader();
        Document document = saxReader.read(new File(path + iocBeanXmlFile));
        Element rootElement = document.getRootElement();
        Element bean = (Element) rootElement.elements("bean").get(0);
        String id = bean.attributeValue("id");
        String classFullPath = bean.attributeValue("class");
        System.out.println("id="+id);
        System.out.println("classFullPath="+classFullPath);
        List<Element> property = bean.elements("property");
        String monsterId = property.get(0).attributeValue("value");
        String name = property.get(1).attributeValue("value");
        System.out.println("monsterId="+monsterId);
        System.out.println("name="+name);

Somente objetos criados por reflexão podem ter uma estrutura semelhante ao objeto Monster. Podemos injetar os valores dos atributos do objeto bean retirados de beans.xml no objeto criado por nossa reflexão e, em seguida, adicionar esse objeto à coleção ioc .

        Class<?> aClass = Class.forName(classFullPath);
        Monster o = (Monster) aClass.newInstance();
        o.setId(Integer.valueOf(monsterId));
        o.setName(name);
        ioc.put(id,o);

Finalmente, um getBeanmétodo é fornecido para encontrar o objeto Monster mapeado correspondente no contêiner ioc quando o monsterId é fornecido.

    public Object getBean(String id){
    
    
        return ioc.get(id);
    }

Finalmente, a imagem acima foi realizada. Precisamos apenas configurar o objeto bean no arquivo xml e, em seguida, dar o nome do arquivo xml ao LingHuApplicationcontêiner para inicialização para obter um contêiner ioc. A essência do contêiner ioc é uma ConcurrentHashMap. Internamente, as informações de configuração do objeto bean são lidas por meio do dom4j, o objeto é criado por meio de reflexão como classFullPath e as informações de configuração do objeto bean são injetadas no novo objeto. Este novo objeto é colocado nele ConcurrentHashMape getBean(String monsterId)percorremos métodos ConcurrentHashMappara encontrar o novo objeto.

A importância de fazer essas coisas é que separamos o trabalho de configuração do trabalho de negócios, e o tedioso trabalho de gerenciamento de objetos é todo concluído por meio do arquivo de configuração, o que reduz o acoplamento do código e elimina o código de negócios. Portanto, a essência da ideia do contêiner do Spring é: ConcurrentHashMap+Reflection cria objetos.

Código completo e:

LingHuApplication.java:

package com.linghu.spring.linghuapplication;


import com.linghu.spring.bean.Monster;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.springframework.context.annotation.ComponentScan;

import java.io.File;
import java.net.MalformedURLException;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author 
 * @version 1.0
 *  * 1. 这个程序用于实现Spring的一个简单容器机制
 *  * 2. 后面我们还会详细的实现
 *  * 3. 这里我们实现如何将beans.xml文件进行解析，并生成对象,放入容器中
 *  * 4. 提供一个方法 getBean(id) 返回对应的对象
 *  * 5. 这里就是一个开胃小点心, 理解Spring容器的机制
 */

public class LingHuApplication {
    
    
    private ConcurrentHashMap<String, Object> ioc =
            new ConcurrentHashMap<>();

    public LingHuApplication(String iocBeanXmlFile) throws MalformedURLException, DocumentException, ClassNotFoundException, InstantiationException, IllegalAccessException {
    
    
        String path = this.getClass().getResource("/").getPath();
//        System.out.println("path="+path);
        //得到一个解析器
        SAXReader saxReader = new SAXReader();
        //老师的代码技巧->debug 看看document对象的属性
        //分析了document对象的底层结构
        Document document = saxReader.read(new File(path+iocBeanXmlFile));

        //1. 得到rootElement, 你是OOP
        Element rootElement = document.getRootElement();
        //2. 得到第一个bean-monster01
        Element bean = (Element) rootElement.elements("bean").get(0);
        //获取到第一个bean-monster01的相关属性
        String id = bean.attributeValue("id");
        String classFullPath = bean.attributeValue("class");
        List<Element> property = bean.elements("property");
        System.out.println("id="+id);
        System.out.println("classFullPath="+classFullPath);
        //获取bean对象中的property属性值-id和name
        String name = property.get(1).attributeValue("value");
        String monsterId = property.get(0).attributeValue("value");
        System.out.println("name="+name);
        System.out.println("id="+monsterId);

        //使用反射创建对象
        Class<?> aClass = Class.forName(classFullPath);
        //o对象就是monster对象
        Monster o = (Monster) aClass.newInstance();
//        System.out.println("o="+o);
        o.setId(Integer.valueOf(monsterId));
        o.setName(name);

        //将创建好的对象放入到ioc对象中
        ioc.put(id,o);

    }
    //提供一个getBean(id)返回对应的bean对象
    public Object getBean(String id){
    
    
        return ioc.get(id);
    }
}

Gitee: "Programa baseado em configuração Spring XML simples de desenvolvimento manual"