1. Notas
A anotação é um mecanismo semelhante à anotação. Adicionar anotações no código pode usar essas informações em algum momento depois. Ao contrário dos comentários, os comentários são para nós vermos. A máquina virtual Java não pode compilar e as anotações não são compiladas, mas podemos ler as informações nas anotações através do mecanismo de reflexão. A anotação usa a palavra -chave @interface, herda java.lang.annotition.annotation
1. Anotações em Javase
Deixe -me dar um exemplo para revisar o que é a anotação em Javase. A chave são dois pontos: a definição de anotação e como obter as informações acima da anotação através da reflexão.
1. Primeiro defina duas anotações. Um está anotado Classinfo na classe e o outro é anotado MethodInfo no método.
Classinfo
pacote com.itheima10.annotation; importar java.lang.annotation.documented; importar java.lang.annotation.ElementType; importar java.lang.annotation.retention; importation.lang.lang.annotation.retionPolicy; import java.lannOnTation.artation.arget.arget.NoTation.retionPolicy; importação java.lannOtation.artation.arget.arget; ser usado na classe @retention (retentionpolicy.runtime) // em java, arquivos de classe e anotações de tempo de execução @documented // pode ser gerado no documento de ajuda public @interface classinfo { /** * Esta anotação possui duas propriedades do tipo string * @return * /string name () default "";; String value () padrão "";}Methodinfo
pacote com.itheima10.annotation; importar java.lang.annotation.documented; importar java.lang.annotation.ElementType; import java.lang.annotation.retention; importanation.lang.annotation.retionPolicy; importação java.lannotation.artation.artation.lang.Notation.retionPolicy; import Java.LannTaTation.artation.artation.Lang.AnTation.retionPolicy; import Java.LannTaTation.artation.artation; ser usado nos métodos @retention (retentionpolicy.runtime) // em java, os arquivos de classe e anotações de tempo de execução @documented // pode ser gerado em ajuda documentar public @interface methodinfo { /*** Esta anotação possui duas propriedades do string type* /string name () default ""; String value () padrão "";}2. Escreva uma classe de anotação para usar a anotação definida acima
pacote com.itheima10.annotation; @classinfo (name = "xiaopingGuo118", value = "niu") classe pública AnoTationUse {@methodinfo (name = "java", value = "Spring Framework é importante") public void java () {}}3. Escreva a classe de teste anotação e analise as propriedades acima das duas anotações
pacote com.itheima10.annotation; importar java.lang.reflect.method; importar org.junit.test; public class AnnotationTest {public static void test () { / ** * se analise a anotação da classe, obtenha a classe * se pare o ano. // julgue se existe uma anotação Classinfo na classe if (classe1.isannotationPresent (Classinfo.class)) {// Obtenha a anotação no ClassClassinfo Classinfo = (Classinfo) Class1.getAnnotation (Classinfo.class); System.out.println (classinfo.value ()); System.out.println (classinfo.name ()); } Métodos [] métodos = classe1.getMethods (); para (Método Método: Métodos) {// Existe uma anotação MethodInfo no método que está sendo percorrido se (Method.isannotationPresent (MethodInfo.class)) {Metodinfo Metodinfo = MethodInnotation (MethodInfo.class); System.out.println (MethodInfo.name ()); System.out.println (MethodInfo.value ()); }}} @Test public void test () {ANNOTATIONTEST.TEST (); }}2. Anotações na primavera
A estrutura da primavera nos fornece funções de anotação.
O uso da programação de anotação é principalmente para substituir os arquivos XML e tornar o desenvolvimento mais rápido. No entanto, o uso de arquivos XML é resolver o problema de modificar o código -fonte do programa. Agora que não uso arquivos XML, não viola o princípio de abrir e fechar? É verdade. No entanto, as anotações também são boas, então você não precisa configurar tantos arquivos XML ao usar anotações. O mais importante é que eles tenham alta eficiência de desenvolvimento. .
Quando nenhuma anotações são usadas, muitas tags <rience> precisam ser configuradas no arquivo de arquivo de configuração ApplicationContext.xml da estrutura da mola para declarar objetos de classe. Usando anotações, você não precisa adicionar puxões de tag no arquivo de configuração e a descrição correspondente é adicionar instruções na posição "Comentário" da classe correspondente. A introdução específica é a seguinte:
• 1. A combinação de relacionamentos entre os objetos @Resource , o padrão é montar pelo nome. Se o objeto associado não puder ser encontrado com base no nome, a pesquisa por tipo será continuada. Se nenhum atributo de nome for especificado,
• Quando a anotação é marcada em um campo, o padrão é tomar o nome do campo como o nome do feijão para encontrar o objeto de dependência
• Quando a anotação é marcada no método do setter do atributo, o nome do atributo padrão é considerado o nome do feijão para encontrar o objeto de dependência.
• Nota: Se o atributo de nome não for especificado e o objeto de dependência não poderá ser encontrado por padrão, a anotação @Resource voltará à montagem por tipo. Mas uma vez que o atributo de nome é especificado, ele só pode ser montado pelo nome.
• 2. @Autowired
@Autowired é montado por tipo por padrão, @Resource é montado pelo nome por padrão e somente quando um feijão que corresponde ao nome não pode ser encontrado será montado por tipo. A solução é montar objetos dependentes por tipo. Por padrão, requer que os objetos dependentes existam. Se os valores nulos forem permitidos, ele poderá ser definido como falso.
• 3. @Qualifier
Se quisermos usar o Assembly pelo nome, podemos usá -lo em conjunto com a anotação @qualifier.
1. Para usar anotações, você precisa adicionar namespace e etapas de arquivo de restrição ao arquivo de configuração:
Introdução ao namespace de contexto
<Beans xmlns = "http://www.springframework.org/schema/beans"
xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance"
xmlns: context = "http://www.springframework.org/schema/context"
...
http://www.springframework.org/schema/context/spring-context-2.5.xsd ">
2. Adicione o contexto: tag de anotação-config ao arquivo de configuração
<Contexto: anotação-config> </context: anotação-config>
Exemplo de demonstração:
Escreva uma aula de pessoa com um atributo do aluno e um método Say (). O código é o seguinte
pacote com.itheima10.spring.di.annotation; importar javax.annotation.resource; importar org.springframework.beans.factory.annotation.autowired; import org.springframework.beans.actory.annotation.qualifier;/*** @AUTOLOWIRATION TIPO @Qualifier ("Student") * */Public Class Pessoa {@Resource (name = "Student") estudante de estudante particular; public void diz () {this.student.say (); }}O código de aula do aluno é o seguinte
pacote com.itheima10.spring.di.annotation; public class Student {public void Say () {System.out.println ("Student"); }}Configure o arquivo ApplicationContext.xml
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: context = "http://wwwxt.springframework.org/schema =" http://wwwx. 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-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"> <!-- Put Pessoa e estudante no recipiente de primavera-> <bean id = "Person"> </ Bean> <bean id = "student"> </i bean> <!-Apresente o nome de nome de contexto XMLNS: context = "http://www.springframework.org/schema/Contet" http://www.springframework.org/schema/context/spring-context-2.5.xsd "-> <!-O analisador de anotação que foi injetado desde que foi iniciado-> <Contexto: anotação-config> </contexto: annotation-config>
Escreva a classe de teste annotationtest
pacote com.itheima10.spring.di.annotation; importar org.junit.test; importar org.springframework.context.applicationContext; importar org.springframework.context.support.classpathpathrationContext. O recipiente de mola é analisado para* <Contexto: Anotação-Config> </Contexto: Anotação-Config>*, O analisador de anotação para injeção de dependência será iniciado* 4. O recipiente de mola procurará que o @Resource do feijão* se fosse o gerenciamento de primavera. O valor do atributo de nome da anotação é "" * se for "", ele corresponderá ao nome do atributo em que a anotação está localizada e o valor do ID no contêiner da mola. Se a correspondência for bem -sucedida, a atribuição * se a correspondência não tiver êxito, a tarefa será executada de acordo com o tipo. If the match is successful, the assignment will be assigned * If the match is unsuccessful, the assignment will be reported * If the match is unsuccessful, the assignment will be reported directly * If the match is not successful, the assignment will be reported * If the match is not successful, the assignment will be reported directly * If the match is not successful, the assignment will be reported * If the match is not successful, the assignment will be reported directly * Description: Annotations can only be used to Compare o tipo de referência XML e anotações. A eficiência é relativamente alta. Escrever é mais problemático. A gravação de anotações é relativamente simples e menos eficiente * */public class AnotationTest {@Test public void testannotation () {ApplicationContext context = new ClassPathXMLApplicationContext ("ApplicationContext.xml"); Pessoa pessoa = (pessoa) context.getBean ("pessoa"); pessoa.Say (); }}Se você usar anotações, não precisará carregar a pessoa e o aluno no arquivo de configuração, que pode simplificar a escrita do arquivo de configuração.
3. Digitalizar
Nos exemplos anteriores, usamos a definição de feijão XML para configurar componentes. Em um projeto um pouco maior, geralmente existem centenas de componentes. Se esses componentes estiverem configurados usando a definição de feijão XML, ele obviamente aumentará o tamanho do arquivo de configuração, tornando -se muito conveniente para encontrar e manter. A Spring2.5 apresenta um mecanismo automático de varredura de componentes para nós, que pode encontrar classes anotadas com anotações @Component, @service, @Controller e @repository sob o ClassPath e incorporam essas classes ao contêiner de mola para gerenciar. Sua função é a mesma que usar componentes de configuração do nó do feijão em um arquivo XML. Para usar o mecanismo automático de varredura, precisamos abrir as seguintes informações de configuração:
1. Introduzir namespace de contexto
Adicionar contexto: tag-scan componente no arquivo de configuração XML
Onde o pacote básico é o pacote (subpackage) que precisa ser digitalizado.
Exemplo:
O exemplo acima é escrito em um modo de varredura da seguinte forma
@ComponentPublic Class Pessoa {@Resource (name = "Student") estudante de estudante particular; public void diz () {this.student.say (); }}@ComponentPublic Classe Student {public void Say () {System.out.println ("Student"); }}ApplicationContext.xml só precisa ser configurado em uma frase
<!-O componente componente coloca uma classe em um recipiente de mola, e a classe é chamada de digitalização do componente sob o pacote e subpackage especificado por package base-> <Contexto: componente-scan-package = "com.itheima10.spring.scan"> </context-scan>
Escreva a classe de teste annotationtest
/*** Princípio* 1. Iniciar o contêiner de mola* 2. Analisação de contêineres de mola* <Contexto: componente-cacan-package = "com.itheima10.spring.scan"> </context: componente-scan> 3. @Can em Pacotes e subpacotes especificados por essa patchage para ver que a classe contém @componente. == equivalente a <bean id = "pessoa"> @component ("aa") public class Pessoa {} == equivalente a <bean id = "aa"> 5. Siga as etapas de análise de @Resource: o processo inteiro é digitalizado duas vezes, a eficiência está ficando mais baixa e a escrita é mais fácil e mais fácil * */ * * */, a eficiência está ficando mais baixa (a mais baixa e mais fácil * * * */é digitalizada duas vezes, a eficiência está ficando mais baixa e a escrita é mais fácil e mais fácil * * */ context = new ClassPathXMLApplicationContext ("ApplicationContext.xml"); Pessoa pessoa = (pessoa) context.getBean ("pessoa"); pessoa.Say (); }}Reaparecimento de instâncias
Alteraremos o último sistema de gerenciamento de documentos no item51 na anotação. A interface do documento permanece inalterada, com métodos de leitura e gravação. As classes de implementação são as seguintes ExcelDocument, PDFDocument e WordDocument.
@Component ("ExcelDocument") classe pública ExcelDocument implementa o documento {public void read () {System.out.println ("Excel Read"); } public void write () {System.out.println ("Excel Write"); }}@Componente ("pdfdocument") classe pública pdfdocument implementa o documento {public void read () {System.out.println ("pdf read"); } public void write () {System.out.println ("pdf write"); }}@Componente ("worddocument") classe public wordDocument implementa o documento {public void read () {system.out.println ("word read"); } public void write () {System.out.println ("word write"); }}DocumentManager
@Component ("DocumentManager") Public Class DocumentManager {@Resource (name = "ExcelDocument") Documento privado do documento; public void read () {this.document.read (); } public void write () {this.document.write (); }}Arquivo de configuração
<Contexto: Componente-Scan Base-Package = "com.itheima10.spring.iocdi.document">
</contexto: componente-varejo>
Escreva uma classe de teste DocumentTest
public class DocumentTest {@Test public void testDocument () {ApplicationContext context = new ClassPathXMLApplicationContext ("ApplicationContext.xml"); DocumentManager DocumentManager = (DocumentManager) Context.getBean ("DocumentManager"); documentManager.read (); documentManager.Write (); }} 2. Introdução a outras funções de anotação
@Service é usado para anotar componentes da camada de negócios e anotações da camada de serviço
@Controller é usado para anotar componentes da camada de controle (como ação em suportes) e anotar a anotação da camada
@Repository é usado para anotar componentes de acesso a dados, ou seja, componentes dao. Anotação da camada de persistência
@Component refere -se a componentes. Quando os componentes não são fáceis de classificar, podemos usar essa anotação para anotar.
Exemplos reproduzem o caso MVC
Analisamos os casos de MVC no Item51 novamente, adicionando as camadas DAO, Serviço e Ação de Persondaoimpl, Personaction e PersOnserviceImpl, respectivamente, para adicionar anotações ao DAO, Serviço e Camadas de Ação de Persondaoimpl.
@Repository ("persondao") classe pública Persondaoimpl implementa Persondao {@Override public void SavePerson () {System.out.println ("Salvar pessoa"); }} @Service ("perseverService") Public Class PersonServiceImpl implementa PERSOnservice {@Resource (name = "persondao") private Persondao persondao; public void setPersondao (persondao persondao) {this.persondao = persondao; } @Override public void savePerson () {this.persondao.saveperson (); }} @Controlador ("Personaction") Public class Personaction {@Resource (name = "persevice") PERSONSVICE PERSONSERVAMENTO PERSONSERVAÇÃO; public void setPerSoService (Persevice Persenservice) {this.personservice = Persenservice; } public void savePerson () {this.personservice.savePerson (); }}Escreva o teste de teste
classe pública mvctest {@test public void testmvc () {ApplicationContext context = new ClassPathXMLApplicationContext ("ApplicationContext.xml"); Personacte Personaction = (Personact) context.getBean ("Personaction"); Personact.SavePerson (); }}4. Herança na primavera
A primavera suporta a herança, que pode ser dividida em herança de classe e herança de atributos.
1. Herança de classe
Propriedades da primavera:
(1) Resumo: Se definido como true, significa que o feijão definido é abstrato, diga à primavera para não instanciar o feijão;
Pergunta: Deve ser uma classe abstrata? Poderia ser uma classe abstrata?
(2) Pai: indica a função do ID do feijão no feijão, que é equivalente à função de estendências na classe Java;
Cena: Existem três feijões:
<bean id = "bean1" class = "… testbean"> <propriedade name = "sexo" value = "masculino"/> </i bean> <bean id = "bean2" class = "… testbean"> <names name = sexo "value =" masculino "/> </bean> <bean id =" bean3 "class" "…"…
Modificar: Definir Bean Spring Parent
<bean id = "base" class = "… testbean"> <name da propriedade = "sexo" value = "masculino"/> </i bean>
Defina sub -orete
<bean id = "bean1" parent = "base"/> herdar as propriedades do parentário <bean id = "bean2" parent = "base"/> <bean id = "bean3" parent = "base"> sobrescrever as propriedades do parentário <nome da propriedade <nome "sexo" value = "feminino" "/bready> <Bean> <Bean> <.
Os grãos infantis podem herdar as propriedades do feijão pai ou substituir as propriedades do feijão pai.
2. Herança de atributo
Existem os mesmos atributos entre vários feijões diferentes, e a cena pode ser extraída:
<bean id = "bean1" class = "… atestbean"> <propriedade name = "sexo" value = "masculino"/> <names name = "tarefa" ref = "tarefa"/> </i bean> <bean id = "bean2" class = ""… btestBean "> <nome da propriedade =" sexo "=" masculino "/> </bean>
Modificar: (1) Extrair atributos públicos
<bean id = "basesex" abstract = "true"> <propriedades name = "sexo" value = "masculino"/> </i bean>
(2) modificação do feijão
<bean id = "bean1" class = "... AtestBean" parent = "basesex"> <propriedade name = "tarefa" ref = "tarefa"/> </shean> <bean id = "bean2" class = "… btestbean" parent = "basesex"/>
Aqui, o feijão tem atributos de pai e classe, e o Basesex apontado pelo pai é permitir que diferentes feijões compartilhem o mesmo valor de atributo; Quando o TransactionProxyFactoryBean declara o serviço, a herança do atributo Bean pode reduzir significativamente a configuração XML redundante.
A herança baseada em anotação não requer atributos dos pais.
Vamos ter uma pequena imagem de resumo por último
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.