Como foi dito no post sobre a arquitetura,
que pode ser visto nesse Link , o framework é composto de módulos. Neste post vamos abordar como configurar o módulo core, suas flexibilidades, alternativas e pontos de extensão.
O módulo CORE na atual versão é responsável por prover toda a estrutura de contextos no que diz respeito a beans como inversão de controle para provimento de injeção de depêndencia e é ele quem define toda a arquitetura e contratos que os outros módulos devem seguir.
Na versão atual, 1.0, o framework só prover a configuração do pacote base para scaneamento de beans candidatos a injeção de dependência e que farão parte do contexto de beans de usuário e que podem ser obtidos a partir do singleton
UserBeanContext.
- Configurando o COREA configuração do módulo CORE é composta por informações como pacote base para resolver beans para injeção de dependência, fábrica de beans, módulos dependêntes que se deseja utilizar. As configurações de CORE são mais simples, pois dizem respeito apenas as configurações gerais que são definidas para o núcleo do framework.
As duas propriedades que podem ser configuradas no CORE são:
- lindberg.core.di-basepackage (propriedade requerida):Pacote base de beans para injeção.
Constante que define essa propriedade: CoreConfiguration.CONFIG_PROPERTY_DI_BASEPACKAGE;
- lindberg.core.beanfactory (se não for definida a fábrica padrão será usada - AnnotationBeanFactory): Fábrica de beans a ser usada.
Constante que define essa propriedade: CoreConfiguration.CONFIG_PROPERTY_BEAN_FACTORY
Vamos definir uma configuração de CORE para os seguintes valores usando as duas implementações de CoreConfiguration na prática:
- Pacote base de beans para injeção (lindberg.core.di-basepackage) = org.lindbergframework.exemplo.*
- Bean factory (lindberg.core.beanfactory) = org.lindbergframework.beans.di.context.AnnotationBeanFactory
Estas duas propriedades são suficientes para configurarmos o core para usarmos apenas o mecanismo de injeção de dependência. Neste caso os beans para injeção serão procurados dentro do pacote org.lindbergframework.exemplo e o ponto asterisco “.*” define que o framework também procurará beans para injeção de dependência dentro dos sub-pacotes de org.lindbergframework.exemplo e sub-pacotes destes e assim em diante.
O lindbergframework define uma interface chamada BeanFactory que define uma fábrica de beans que pode ser usada para obtenção de instâncias de beans dentro do contexto de injeção de dependência corrente. Neste caso foi definida a implementação de uma fábrica de beans que trabalha em conjunto com annotations. Mais a frente serão abordados os detalhes dessa interface BeanFactory e de todo o mecanismo de injeção de dependência.
– Configurando o CORE na Prática - ProgramaticamenteAbaixo é mostrado um exemplo da implementação e uso dessas configurações programaticamente direto com código java usando a implementação SimpleCoreConfiguration:
SimpleCoreConfiguration coreConfiguration = new SimpleCoreConfiguration();
coreConfiguration.setDiBasePackage("org.lindbergframework.exemplo.*");
coreConfiguration.setBeanFactory(new AnnotationBeanFactory());
CoreContext.getInstance().initialize(coreConfiguration);
OBSERVAÇÃO: O trecho de código
CoreContext.getInstance().initialize(...) poderia ser substituido por
coreConfiguration.initializeContext(); - Esse método em CoreConfiguration faz com que o contexto de CORE
com esta configuração seja inicializado.
O trecho acima cria uma instância de
SimpleCoreConfiguration, seta as propriedades pacote base onde encontrar os beans que poderão ser usados dentro do contexto de DI (dependecy injection ou injeção de dependência) e a instância da fábrica de beans a ser usada pelo mecanismo de DI. Definidas as propriedades de configuração então o último passo é configurar o módulo core baseado nestas configurações. Para fazer isso é obtida a instância singleton de
CoreContext via
CoreContext.getInstance() e o método initialize passando a configuração criada é invocado. Pronto, o módulo CORE já está pronto para ser usado e em qualquer lugar você pode invocar
CoreContext.getInstance().getBeanFactory() para obter a instância configurada da fábrica definida e chamar o método getBean da fábrica para obter uma
instância de um bean desejado passando o “ID“ deste. Um outro modo de se obter uma instância de um bean através da mesma fábrica é usar a classe UserBeanContext via
UserBeanContext.getInstance().getBean(id). O mecanismo de injeção de dependência será detalhado mais a frente, aqui está apenas sendo demonstrado os conceitos de configuração.
– Configurando o CORE na prática – Usando XMLA seguir é demonstrado a mesma configuração só que usando uma implementação de
CoreConfiguration para configuração baseada em XML. O schema que define as configurações baseadas em XML é detalhado a seguir.
Schema:
http://www.lindbergframework.org/schema/lindberg-config.xsdO schema no que diz respeito a tag <core> para definições de configurações de CORE é ilustrado de forma detalhada na imagem abaixo:
Abaixo é mostrado um simples arquivo de configuração de core que define as mesmas configurações do exemplo anterior.
<?xml version="1.0" encoding="UTF-8"?>
<lindberg-configuration
xmlns="http://www.lindbergframework.org/schema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.lindbergframework.org/schema/lindberg-config.xsd">
<core>
<config-property name="lindberg.core.di-basepackage"
value="org.lindbergframework.exemplo.*"/>
<config-property name="lindberg.core.beanfactory"
value="org.lindbergframework.beans.di.context.AnnotationBeanFactory"/>
</core>
</lindberg-configuration>
NOTA: A beanfactory está sendo definida mas lembre que esta propriedade não é requerida e quando não informada a factory padrão, AnnotationBeanFactory, é usada automaticamente pelo framework.– A tag <config-property>A tag
<config-property> é a mais importante de todo o documento XML de configuração. Ela é
usada para a definição de propriedades de configuração. Estas propriedades definem todo o comportamento dos componentes fornecidos pelo framework como o pacote base para buscar beans de injeção automática, gerenciador de transações, resolvedor de comandos sql, schema de banco padrão que deve ser usado, entre outros. Estes últimos são abordados mais a frente, quando o componente de persistência (LINP) for apresentado.
Esta é uma tag basicamente de nome e valor, onde o atributo nome define a chave da propriedade de configuração e o atributo valor define o valor que será usado na configuração para esta propriedade.
Esta tag fornece a flexibilidade de definição de propriedades que serão setadas na objeto valor desta propriedade no momento da inicialização e propriedades que serão usadas como parâmetro para um construtor específico.
Supondo que nós tivéssemos uma propriedade de configuração de CORE cujo a chave é exemplo e o valor para esta chave fosse a classe com.aplicacao.Exemplo e esta classe tivesse uma propriedade String chamada propriedade1, então a definição dessa propriedade seria:
* Definindo a inicialização simples de propriedades dentro de uma propriedade de configuração<config-property name="exemplo" value="com.aplicacao.Exemplo">
<property name="propriedade1" value="valor da propriedade1" />
</config-property>
Observe que foi usada uma nova tag dentro da tag
<config-property>. Ela serve para definir
propriedades de inicialização e parâmetros de construtor de propriedades de configuração.
A tag
<property> pode ser usada um número ilimitado de vezes dentro da tag
<config-property> de acordo com a necessidade. Neste caso a utilizamos uma única vez, para definir o set da String 'valor da propriedade1' na propriedade de nome propriedade1 na instância do objeto do tipo com.aplicacao.Exemplo para a chave de configuração Exemplo. A propriedade propriedade1 será setada no momento da criação do objeto com.aplicacao.Exemplo. Se tivéssemos uma propriedade2, bastaria declarar uma outra tag
<property> dentro de <config-property> da mesma forma que a
propriedade1.
* Definindo a inicialização de propriedades do tipo List ou Array dentro de uma propriedade de configuraçãoSuponha agora que tivéssemos então as
propriedade2 e propriedade3 e estas fossem respectivamente uma List e um Array e ambas de String. Esta tag fornece a flexibilidade de inicialização de listas e arrays de Strings diretamente pelo XML de configuração. Abaixo é mostrado como ficaria a tag
<config-property> com a inicialização destas duas propriedades.
<config-property name="exemplo" value="com.aplicacao.Exemplo">
<property name="propriedade1" value="valor da propriedade1" />
<property name="propriedade2">
<list>
exemplo list string 1;
exemplo list string 2;
exemplo list string 3;
exemplo list string N;
</list>
</property>
<property name="propriedade3">
<array>
exemplo array string 1;
exemplo array string 2;
exemplo array string 3;
exemplo array string N;
</array>
</property>
</config-property>
No trecho acima agora definimos duas novas propriedades
propriedade2 e propriedade3. A primeira é uma List e a segunda um Array. Observe que agora temos duas novas tags para serem usadas dentro da tag <property>, as tags
<list> e
<array>. A primeira define uma lista e a segunda um array, ambos de Strings. Os valores de cada uma dessas tags são definidos com o conteúdo entre a tag de abertura e fechamento onde cada elemento da List ou Array é separado por um carácter ';'. Dentro da tag
<property> se tem a flexibilidade de usar qualquer um dos dois tipos sendo que nunca os dois ao mesmo tempo dentro da mesma <property>.
* Inicialização de propriedades de configuração usando um construtor específicoAgora suponhamos que a nossa classe Exemplo tenha um construtor que recebe uma String e uma
coleção de Strings e queiramos usar este construtor para a criação do objeto Exemplo transformando a nossa definição da
propriedade1 e
propriedade2 em parâmetros para o construtor. Suponha também que ainda assim queiramos setar a propriedade propriedade3 da mesma forma que o exemplo anterior.
A nossa nova definição da tag
<config-property> ficaria da seguinte forma:
<config-property name="exemplo" value="com.aplicacao.Exemplo">
<property value="valor da propriedade1"
constructor-arg="true" />
<property
constructor-arg="true">
<list>
exemplo list string 1;
exemplo list string 2;
exemplo list string 3;
exemplo list string N;
</list>
</property>
<property name="propriedade3">
<array>
exemplo list string 1;
exemplo list string 2;
exemplo list string 3;
exemplo list string N;
</array>
</property>
</config-property>
Observe que o que mudou neste exemplo foi que a tag que definiam as propriedades propriedade1 e propriedade2 agora não tem mais definidos seus atributos nome, pois agora são parâmetros de construtor e agora ao invés disto estas tags tem a propriedade
constructor-arg definido para 'true', indicando que estes serão atributos de construtor. Então o construtor que o framework buscaria para criar a instancia de Exemplo seria:
public Exemplo(String,List<String>)
Após a chamada a este construtor e a criação da instancia, a propriedade propriedade3 seria setada com o Array de String definido chamando o método
setPropriedade3.
VEJA TAMBÉM COMO CONFIGURAR O CORE USANDO XML NO POST: LINK
