1 Recursos básicos de primavera
A primavera é uma estrutura de código aberto muito ativo; É uma estrutura que cria sistemas Javaee de várias camadas baseados no núcleo, e seu principal objetivo é simplificar o desenvolvimento corporativo.
A Spring gerencia seu código de maneira não invasiva. Os defensores da primavera "intrusão mínima", o que significa que você pode instalar ou desinstalar a mola no momento apropriado, e a primavera torna Java Bright. (Princípio aberto e de fechamento), aqui está o princípio de encerramento.
2. Ferramentas necessárias para desenvolver a primavera
(Aqui selecionamos primeiro a primavera 2.5 e depois 3.0)
2.1 pacote de jar da primavera
Faça o download da primavera em http://www.springsource.org/download, depois descompacte, encontre o seguinte arquivo JAR no diretório de descompressão e copie -o para o ClassPath
“A biblioteca da classe principal da primavera é dist/primavera.
“A biblioteca de terceiros introduzida é todo o documento da primavera em Lib, Lib/Jakarta-Commons/Commons-logging.jar
“Se a programação de aspectos (AOP) for usada, os seguintes arquivos jar lib/aspectoj/aspectojweaver.jar e aspectojrt.jarlib/cglib/cglib-nodep-2.1_3.jar também são necessários
“Se você usar as anotações no JSR-250, como@Resource/@PostConstruct/@PREDESTRY, o seguinte arquivo jar lib/j2ee/common-annotações.jar também é necessário
Nota: JSR (solicitação de especificação Java) refere -se a uma solicitação formal para adicionar uma especificação técnica padronizada ao JCP (Java Community Process). Qualquer pessoa pode enviar uma JSR (solicitação de especificação Java) para adicionar novas APIs e serviços à plataforma Java. JSR se tornou um padrão importante no mundo java
2.2 Arquivo de configuração de mola
Por padrão, é o arquivo ApplicationContext.xml. Muitos arquivos XML podem ser criados, e isso geralmente é configurado em projetos. (Criado no diretório SRC)
3 Explicação detalhada das funções básicas da primavera
3.1 Springioc
Inversão de controle da primavera: entregue a criação, inicialização, destruição e outras tarefas de objetos para o contêiner de mola. Controla o ciclo de vida de um objeto pelo recipiente da mola.
etapa:
•UM. Inicie o recipiente de primavera
1. Encontre arquivos de configuração no caminho de classe para instanciar o contêiner
A cópia do código é a seguinte: ApplicationContext ctx = new ClassPathXMLApplicationContext (new String [] {"ApplicationContext.xml"});
Você pode procurar arquivos XML em todo o caminho de classe
* Carregue dessa maneira. Você precisa colocar o arquivo de configuração do Spring no caminho do caminho de classe do projeto atual
* ClassPath Path refere -se ao diretório SRC do projeto atual, que é o local de armazenamento do arquivo de origem Java.
2. Encontre arquivos de configuração no caminho do sistema de arquivos para instanciar o contêiner
O arquivo de configuração do Spring pode especificar vários arquivos de configuração e pode ser passado através de matrizes de string.
Nota: Use o primeiro método para iniciar o contêiner com frequência
• b. Extrair objetos do recipiente de mola
Estrutura de contêiner de mola:
3.2 Alias
<Beans> <também alias name = "pessoa" alias = "p" /// alias é um alias, você pode levar a pessoa a p. <nome do feijão = "Pessoa"/> </ Beans>
Com essa configuração, o efeito da nomeação em um só lugar e o uso de nomes diferentes em vários lugares pode ser alcançado.
3.3 Objetos internos do contêiner de mola
1 Como criar um objeto
1.1 nenhum construtor de parâmetros
<bean id = "helloworld"> </sien>
1.2 Método de fábrica estática
<bean id = "helloworld2"
Factory-method = "getInstance"> </sien>
1.3 Exemplo de método de fábrica
<bean id = "helloworldfactory"> </siean>
<bean id = "helloworld3" factory-bean = "helloworldfactory" fábrica-method = "getInstance"> </ean>
Lembre -se do conceito. O primeiro método é o mais usado, mas ao integrar com outras ferramentas, o modelo de fábrica de instância é usado.
Exemplo :
Configure o ApplicationContext.xml
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema DescreciEs/springs-bans-2.5sd"> <!-Put uma classe em uma mola, Classe -> <bean id = "helloworld"> </i bean> <! ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ fábrica-method = "getInstance" > </i bean> <! ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Criar a classe de entidade Helloworld
pacote com.itheima10.spring.createObject; public classe helloworld {public void hello () {system.out.println ("hello"); }}Estabelecer uma fábrica estática helloworldfactory
pacote com.itheima10.spring.createObject.method; public classe helloworldFactory {public static helloworld getInstance () {system.out.println ("método estático"); retornar novo helloworld (); }}Estabelecer uma fábrica física helloworldFactory2
pacote com.itheima10.spring.createObject.method; public classe helloworldFactory2 { / *** O objeto de fábrica deve ser criado antes que o método possa ser chamado* @return* / public helloworld getInstance () {retorna new helloworld (); }}Método de teste de gravação CreateObjectMethodtest
pacote com.itheima10.spring.createObject.method; importar org.junit.test; importar org.springframework.context.applicationContext; importar org.springframework.context.support.classpathpatheration stromationContext; CreateObjectMethodTest { / *** Por padrão, o contêiner da mola chama o construtor padrão de uma classe para criar um objeto* / @test public void testCreateObject_default () {ApplicationContext context = new ClassPathXMLApplicationContext ("ApplicationContext.xml"); Helloworld helloworld = (helloworld) context.getbean ("helloworld"); helloworld.hello (); }/*** Crie um objeto usando uma fábrica estática* <bean id = "helloworld2" fábrica-method = "getInstance"> </i bean> o que o contêiner da mola faz: o método getInstance é chamado usando a classe HelloworldFactory*/@test public void testsCreateBject_staticFactory (). ClassPathXMLApplicationContext ("ApplicationContext.xml"); Helloworld helloworld = (helloworld) context.getbean ("helloworld2"); helloworld.hello (); }/** * O método de fábrica de instância cria um objeto * <bean id = "helloworldFactory" *> </i bean> * <bean id = "helloworld3" factory-bean = "helloworldfactory" fábrica de fábrica para o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que você está. objeto*/ @Test public void testCreateObject_instanceFactory () {ApplicationContext context = new ClassPathXMLApplicationContext ("ApplicationContext.xml"); Helloworld helloworld = (helloworld) context.getbean ("helloworld3"); helloworld.hello (); }}2 escopo de objeto
O escopo de um objeto possui duas propriedades: Singleton e Prototype. Singleton significa Singleton
2.1 Singleton (valor padrão)
Em cada contêiner do COI da primavera, existe apenas uma instância de objeto (compartilhada).
2.2 Protótipo
Permitindo que o feijão seja instanciado várias vezes (crie uma instância uma vez usada). A primavera não pode ser responsável por todo o ciclo de vida de um protótipo de feijão. Isso significa que é de responsabilidade do cliente ser claro sobre os objetos escopos de protótipo e liberar os recursos caros mantidos por qualquer protótipo de feijão.
<bean id = "helloworld" scope = "singleton"> </shean>
<bean id = "helloworld" scope = "prototype"> </bean>
Crie aula de Helloworld
classe pública helloworld {list public <string> lists = new ArrayList <String> (); public helloworld () {System.out.println ("new Instância"); } public void hello () {System.out.println ("hello"); }}Crie um Scopetest da classe de teste
pacote com.itheima10.spring.scope; importar org.junit.test; importar org.springframework.context.applicationContext; importar org.springframework.Context.support.classpathpathxmlApplication; Colocada no recipiente de mola e esta classe é um singleton, então as propriedades da classe serão compartilhadas*/ @Test public void testCreateObject_Scope_Default () {ApplicationContext context = new ClassPathXMLApplicationContext ("ApplicationContext.xml"); Helloworld hello1 = (helloworld) context.getbean ("helloworld"); hello1.lists.add ("aaaa"); hello2 = (helloworld) context.getbean ("helloworld"); hello2.lists.add ("bbbb"); System.out.println (helloworld.lists.size ()); // 2, e somente a saída de nova instância}/** * Se o arquivo de configuração da mola for o seguinte: * <bean id = "helloworld" scope = "prototype"> </i bean> Então o contêiner da mola criará vários objetos para */@Test public void testCreate_scope_prototype () {ApplicationContext ClassPathXMLApplicationContext ("ApplicationContext.xml"); Helloworld hello1 = (helloworld) context.getbean ("helloworld"); hello1.lists.add ("aaaa"); hello2 = (helloworld) context.getbean ("helloworld"); hello2.lists.add ("bbbb"); System.out.println (helloworld.lists.size ()); // 1, e apenas a saída de nova instância}}3 tempo de inicialização
Carregamento preguiçoso - Por padrão, o feijão será inicializado quando o contêiner iniciar, mas podemos especificar o preguiçoso -init = "verdadeiro" do nó do feijão para atrasar a inicialização do feijão. Neste momento, o feijão será inicializado apenas se o feijão for recuperado pela primeira vez. como:
<bean id = "xxx" lazy-init = "true"/>
Se você deseja aplicar a inicialização tardia a todos os grãos, pode definir o padrão-lazy-init = "true" no feijão raiz, como segue:
<Beans padrão-lazy-init = "true" ...>
A primavera instancia todos os feijões singleton com antecedência na startup por padrão. Instanciação precoce significa que, como parte da inicialização, o ApplicationContext cria e configura automaticamente todos os grãos singleton. Isso geralmente é uma coisa boa. Porque dessa maneira, quaisquer erros na configuração podem ser descobertos imediatamente.
A inits preguiçosa é falsa, o contêiner de mola relatará um erro quando for iniciado (uma maneira melhor)
A entrada preguiçosa é verdadeira e o recipiente de mola cometerá um erro ao ligar para a classe.
Configure o ApplicationContext.xml
<bean id = "helloworld" scope = "prototype"> </bean> </ Beans>
Crie a classe de teste CreateObjectWhente
pacote com.itheima10.spring.createObject.when; importar org.junit.test; importar org.springframework.context.applicationContext; importar org.springframework.context.support.classPathpath* térmico* rycringframework.context.support.class** HelloWorld object* 3. Object calling method* * <bean id="helloWorld"></bean> <bean id="helloWorld2"></bean> Because two beans are declared in the spring container, the spring container needs to create two objects: If struts2, hibernate, and spring containers are integrated, if an error occurs in the spring configuration file, an error will be reported when the tomcat container is Iniciado, e o erro será exibido particularmente cedo. Se um feijão armazenar uma grande quantidade de dados, esse método não será bom e os dados podem ficar presos na memória muito cedo. Se um feijão não for um singleton, não importa como ele seja configurado, o objeto deve ser criado quando for um contexto.getBean*/ @Test public void testCreateObject_when_default () {ApplicationContext context = new ClassPathXMLApplicationContext ("ApplicationContext.xml"); context.getbean ("helloworld"); } /*** <bean id = "helloworld" lazy-init = "true"> </i bean>* ordem* 1. Inicie o contêiner de mola* 2. Context.getBean* 3. Chame a função do construtor para criar um objeto* Descrição: Se o struts2, hibernate, e os contêineres são relatados, se um erro ocorrer na mola do arquivo de mola. Se um feijão armazenar uma grande quantidade de dados, será necessário carregar dados quando necessário*/ @test public void testCreateObject_when_lazy () {ApplicationContext Context = new ClassPathXMLApplicationContext ("ApplicationContext.xml"); context.getbean ("helloworld"); }}4 init, destruir métodos
Quando a primavera inicializa o feijão ou destrói o feijão, às vezes é necessário algum processamento; portanto, a primavera pode chamar os dois métodos do ciclo de vida do feijão ao criar e desmontar feijões. Você pode especificar um método para operar.
<bean id = "foo" class = "... foo" init-method = "setup" decoração-method = "teardown"/>
Ligue para o método init-method quando Foo for carregado no recipiente de mola. Chamando a implantação-método quando Foo é excluído do contêiner (Scope = Singleton Valid)
Escrevendo Helloworld
classe pública helloworld {public helloworld () {System.out.println ("new Instância"); } public void init () {System.out.println ("init"); } public void Destro () {System.out.println ("Destroy"); } public void hello () {System.out.println ("hello"); }}Escreva a classe de teste initDestroytest
pacote com.itheima10.spring.ioc.initdestroy; importar org.junit.test; importar org.springframework.context.applicationContext; importar org.springframework.context.support.cllasspathpathpathictication; 1. Inicie o contêiner de mola* 2. Crie objeto Helloworld* 3. Execute o método init* Execução automática dentro do contêiner de mola* 4. Método de chamada de objeto* 5. O método de destruição só pode ser executado quando o recipiente de mola é fechado: se o feijão não é um cantleton*, esse método também é chamado internamente pelo recipiente da mola* * In the spring container, only if one bean is a singleton, the spring container is responsible for the creation, initialization and destruction of objects* If a bean is not a singleton, the spring container is only responsible for the creation and initialization*/ @Test public void testInitDestroy(){ ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); Helloworld helloworld = (helloworld) context.getbean ("helloworld"); helloworld.hello (); ClassPathXMLApplicationContext ApplicationContext = (ClassPathXMLApplicationContext) Context; ApplicationContext.Close (); }} Diagrama de sequência de execução:
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.