1. Antecedentes
Recentemente, devido a problemas com a digitalização de pacotes do projeto, no processo de resolução do problema, descobri acidentalmente que a Spring e o SpringMVC têm um relacionamento entre pais e filhos, e é precisamente por isso que o problema da varredura de pacotes geralmente ocorre. Aqui analisamos e entendemos o relacionamento entre pais e filhos entre a Spring e o SpringMVC e fornecemos à maneira oficial recomendada de digitalização de pacotes nos arquivos de configuração Spring e Springmvc.
2. Compreensão do conceito e conhecimento que estabelece a fundação
No conceito central da estrutura geral da primavera, os contêineres são a idéia principal, que é usada para gerenciar todo o ciclo de vida de um feijão. Em um projeto, não há necessariamente apenas um contêiner. A mola pode incluir vários recipientes, e o recipiente possui níveis superior e inferior. O cenário mais comum no momento é introduzir as duas estruturas de Spring e SpringMVC em um projeto. Então são na verdade dois recipientes. A primavera é um contêiner pai e o Springmvc é seu recipiente infantil. O feijão registrado no contêiner dos pais da primavera está visível para o contêiner Springmvc, enquanto o feijão registrado no contêiner Springmvc é invisível para o contêiner dos pais da primavera, ou seja, o recipiente infantil pode ver o feijão registrado no contêiner pai, caso contrário, não funcionará.
Podemos usar a configuração de anotação unificada da seguinte maneira para registrar o bilhete, sem configurar cada feijão usando o XML separadamente.
<Contexto: componente-Scan Base-Package = "com.hafiz.www" />
A partir do manual de referência fornecido pela primavera, sabemos que a função dessa configuração é digitalizar todas as classes no pacote de embalagem de base configurado que usa a anotação @Component e registre-as automaticamente no contêiner. Ao mesmo tempo, eles também examinam as três anotações de @Controller, @Service e @Respository porque são herdadas do @Component.
No projeto, geralmente vemos a seguinte configuração. De fato, com a configuração acima, isso pode ser omitido, porque a configuração acima ativará a seguinte configuração por padrão. A configuração a seguir declarará as anotações como @Required, @Autowired, @PostConstruct, @PersistenceContext, @Resource, @Predestroy, etc. Por padrão.
<Contexto: anotação-config/>
Além disso, há outra configuração relacionada ao springmvc. Após a verificação, isso deve ser configurado para SpringMVC, pois declara @RequestMapping, @RequestBody, @ResponseBody, etc. Além disso, essa configuração carrega muitos métodos de ligação de parâmetros por padrão, como o JSON Conversão Parser.
<MVC: Anotação orientada />
A versão de configuração da frase acima antes da primavera 3.1 é equivalente ao seguinte método de configuração
<!-Configurar o Mapper do controlador de anotação, ele é usado no SpringMVC para mapear o URL da solicitação de solicitação para um controlador específico-> <bean/> <!-Configurar o Mapper do controlador de anotação, ele é usado no Springmvc para mapear solicitações específicas para um método específico-> <Bean/>
A versão após Spring3.1 é equivalente aos seguintes métodos de configuração
<!-Configurar o Mapper do controlador de anotação, ele é usado no SpringMVC para mapear o URL da solicitação de solicitação para um controlador específico-> <bean/> <!-Configurar o Mapper do controlador de anotação, ele é usado no Springmvc para mapear solicitações específicas para um método específico-> <Bean/>
3. Análise de cenário específica
Vamos dar uma olhada nas causas do conflito de contêineres entre a primavera e o SpringMVC?
Temos dois contêineres, Spring e SpringMVC, e seus arquivos de configuração são ApplicationContext.xml e ApplicationContext-Mvc.xml, respectivamente.
1. O <Contexto: Componente-Scan Base-Package = "com.hafiz.www" /> está configurado no ApplicationContext.xml para ser responsável por digitalizar e registrar todos os grãos que precisam ser registrados.
2. Configurar <MVC: anotação-driven /> no ApplicationContext-Mvc.xml para ser responsável pelo uso de anotações relacionadas ao SpringMVC.
3. Ao iniciar o projeto, descobrimos que a Springmvc não poderia pular. Definimos o nível de impressão de log do log para depurar para depuração. Descobrimos que as solicitações no contêiner Springmvc não pareciam ser mapeadas para o controlador específico.
4. Configurar <Contexto: Componente-Scan Base-Package = "com.hafiz.www" /> em ApplicationContext-Mvc.xml. Após reiniciar, a verificação é bem -sucedida e o salto Springmvc é válido.
Vamos verificar o motivo específico, observar o código -fonte e iniciar a partir do DispatcheserServlet da Springmvc para pesquisar. Descobrimos que, quando o SpringMVC for inicializado, procuraremos todos os feijões no contêiner Springmvc que usam a anotação @Controller para determinar se é um manipulador. A configuração de duas etapas de 1 e 2 faz com que o contêiner Springmvc atual não registre o feijão na anotação @Controller, mas todos os feijões com a anotação @Controller são registrados no recipiente pai do Spring, portanto, o SpringMVC não pode encontrar o processador e não pode pular. O código -fonte principal é o seguinte:
vazio protegido inithandlermethods () {if (logger.isdebugenabled ()) {Logger.debug ("Procurando mapeamentos de solicitação no contexto do aplicativo:" + getApplicationContext ()); } String [] beanNames = (this.detectHandlermethodsinancestorContexts? BeanFactoryUtils.BeanNamesfortypencludedAncestores (getApplicationContext (), object.class): getApplicationContext (). para (string beanname: beannames) {if (ishandler (getApplicationContext (). getType (beanname))) {detecthandlermethods (beanname); }} handlermethodsinitialized (gethandlermethods ());}No método IsHandler, determinaremos se a anotação do feijão atual é um controlador. O código -fonte é o seguinte:
BOOLEAN ISHANDLER protegido (classe <?> beantype) {return annotationutils.findannotation (beantype, controller.class)! = null;}Na configuração da 4ª etapa, todos os grãos com a anotação @Controller também são registrados no contêiner Springmvc, para que o Springmvc possa encontrar o processador para processamento, por isso salta normalmente.
Encontramos o motivo pelo qual não pode pular corretamente, então qual é a sua solução?
Percebemos que, no método initHandlermethods (), a comutador de detecthandlermethodsinancestorContexts, ele controla principalmente quais grãos no contêiner são obtidos e se o contêiner pai está incluído. Não está incluído por padrão. Portanto, a solução é configurar a propriedade DetectHandlermethodsinancestorContexts de manutenção de manutenção para true no arquivo de configuração Springmvc (aqui você precisa ver qual tipo de manutenção é usado de acordo com o projeto específico), para que ele possa detectar o feijão do contêiner pai. do seguinte modo:
<Bean> <Propriedade name = "DetectHandlermethodsinancestorContexts"> <Value> true </value> </property> </i bean>
No entanto, em projetos reais, haverá muitas configurações. Dividimos diferentes tipos de feijões em diferentes contêineres, de acordo com as recomendações oficiais, de acordo com diferentes módulos de negócios: o contêiner dos pais da primavera é responsável pelo registro de todos os outros feijões que não são anotados pelo @Controller, enquanto a Springmvc é responsável apenas pelo registro de grãos anotados pela @Controller, de modo que cada um dos seus próprios assumem suas próprias responsabilidades. O método de configuração é o seguinte
1.Configure em ApplicationContext.xml:
<!-Registre os grãos em recipientes de mola que não são anotados por @Controller-> <Contexto: component-scan base-package = "com.hafiz.www"> <Contexto: exclude-filter type = "annotation" Expression = "Org.springframework.steretype.Controlller"/> </contexto: component-scan>
2.Configuração no ApplicationContext-mvc.xml
<!-Apenas feijões com anotação @Controller estão registrados no contêiner springmvc-> <Contexto: componente-scan-package = "com.hafiz.www" use-default-filters = "false"> <contexto: incluído type = "anotation" = "Org.springFramework.StereTypeTyPeRyTyTr =" anotation " /" Org.springFramework.StereTypeTyPeRPETPELTER = "anotação" /"Org.sPringFramework.StereTypeTyTyTyTryTyTr.
3. Resumo
Dessa forma, depois de entendermos a relação entre pais e filhos entre a primavera e a SpringMVC e o princípio da varredura e registro, de acordo com as sugestões oficiais, podemos alocar diferentes tipos de feijões a diferentes contêineres para a gerência. Se houver problemas como o feijão não puder ser encontrado, o SpringMVC não poderá ser redirecionado e a configuração da transação falha, podemos localizar e resolver rapidamente o problema. Muito feliz, há algum ~
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.