1. Use anotações:
No arquivo de configuração da Spring ApplicationContext.xml, adicione a varredura de anotação. O item de configuração configura a varredura de pacotes especificados para implementar a injeção de dependência.
<? xml versão = "1.0" coding = "utf-8"?> <span style = "font-size: 18px;"> <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" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/aop/spring-aop-3.xsd htttp://www.spring/sring-aop-3.xsd http://wwwwwwwworks.springfwworks http://www.springframework.org/schema/util/spring-util-3.0.xsd "> <aOP: aspectoj-autoproxy/> <Contexto: annotation-config/> <Contexto: componente-scan-patackage =" com.test "//>
2. Comentários comuns:
@Controlador@service@autowired@requestmapp@requestParam@modelAttribute@CachEable@CachefLush@Resource@postconstruct@predestroy@repositor
3. Anotações de primavera comumente usadas:
@Controller (para camada de apresentação)
Depois de usar a anotação @Controller para identificar o UserAction, significa que o UserAction deve ser entregue ao contêiner de mola para gerenciamento. Haverá uma ação chamada "UserAction" no contêiner de mola. Este nome é obtido com base no nome da classe UserAction. Nota: Se o @Controller não especificar seu valor 【@Controller】, o nome do feijão padrão será minúsculo na primeira letra do nome da classe. Se você especificar o valor 【@Controller (value = "UserAction")】 ou 【@Controller ("UserAction")】, use o valor como o nome do feijão.
O UserAction aqui também usa a anotação @Scope. @Scope ("Prototype") significa que o escopo da ação é declarado como um protótipo. Você pode usar o Scope = "Prototype" do contêiner para garantir que cada solicitação tenha uma ação separada para lidar com isso, evitando os problemas de segurança de threads de ação em suportes. Mola o escopo padrão é o modo Singleton (Scope = "Singleton"), que só criará um objeto de ação. Cada acesso é o mesmo objeto de ação. Os dados não são seguros. O STRUTS2 requer que cada acesso corresponda a uma ação diferente. scope = "protótipo" pode garantir que um objeto de ação seja criado quando houver uma solicitação.
@Controlador
@Scope ("Prototype") Public Class UserAction estende Baseaction <suser> {}@ Serviço (usado na camada lógica de negócios)
Observe que a anotação @Service é usada na classe de implementação da interface de serviço, não na interface.
Isso reflete muito bem a inversão de controle na primavera. Não estamos deixando o objeto instanciar o próprio objeto e confiar ativamente no objeto, mas, em vez disso, use um contêiner para criar o objeto, que é gerenciado pelo COI. Exemplo:
Quando o Action deseja usar o UserServiceImpl, você não precisa criar ativamente uma instância do UserServiceImpl. Criar uma instância do UserServiceImpl foi entregue à primavera. A primavera fornece à instância do criado UserServiceImpl e você pode usá -la diretamente após a ação. A ação pode ser usada imediatamente após a criação ativamente da instância do UserServiceImpl, mas espera -se passivamente a primavera para criar a instância do UserServiceImpl antes de injetá -la em ação. Isso mostra que o "controle" da ação sobre a classe "UserServiceImpl" foi "revertido". Acontece que a iniciativa está em minhas próprias mãos. Eu tenho que usar a instância da classe "UserServiceImpl". Posso tomar a iniciativa de usá -la imediatamente. Mas agora não posso levar a iniciativa a novas instâncias da instância da classe "UserServiceImpl". O poder da nova instância da classe "UserServiceImpl" foi retirado pela primavera. Somente a primavera pode novas instâncias da instância da classe "UserServiceImpl", e a ação só pode esperar a mola para criar a classe "Usuáriose" após a instância da classe rviceImpl "," por favor ", dê a instância criada da classe" UserServiceImpl ", também que pode usar" Usuários "depende", depender ", depender", depender a injeção de "Usuários da primavera", também pode ser chamado "depende" depende ", depende", depende ", depender de que a injeção de que seja" depende ", depende", depender a injeção de "Usu.Senseation. UserServiceImpl para trabalhar, por isso cria uma dependência do UserServiceImpl.
@Service ("UserService") Public Class UserServiceImpl implementa UserService {}@ Repositório (para gerenciamento de dados)
O autor usa a ferramenta para gerar o modelo de dados da camada de entidade e mapear ao contrário, para que essa anotação não seja usada, mas isso está simplesmente injetando um feijão no contêiner de mola.
@Repository (value = "userdao") classe pública userdaoimpl estende baseado em baseoimpl <suser> {}4. Anotações de Springmvc comumente usadas:
@Autowired (injetado por tipo)
Anote as variáveis, métodos e construtores do membro da classe para concluir o trabalho automático de montagem. Simplificando, é para ligar para o feijão e informar à Spring que ele existe e é gerenciado no contêiner.
@Autowired Search no artigo on -line da primavera, de acordo com o tipo de feijão. O tipo de registro deve ser único, caso contrário, uma exceção será relatada.
Quando a anotação @Autowired atua no tipo de mapa, se a chave do mapa for tipo de string, a mola adicionará todos os tipos no contêiner ao tipo correspondente do valor do mapa e usará o id ou nome do feijão como a chave do mapa.
@Autowired Outra função é que, se for anotado no tipo de beanfactory, tipo ApplicationContext, tipo de recurso, tipo ApplicationEventPublisher e tipo MessageRce, a primavera injetará automaticamente instâncias dessas classes de implementação sem operações adicionais.
@Autowired
Relatórios privados do IRORPORTSERVICE;
@Resource (injetado pelo nome)
Semelhante a @Autowired, @Resource Pesquisa por padrão de acordo com o nome do feijão. Se não for encontrado, ele pesquisará por tipo.
@Recurso
DataSource de DataSource privado; // Injete o feijão chamado 'DataSource'
@Resource (Name = "DataSource")
@Resource (type = DataSource.class)
Pergunta estendida: O que é montagem por tipo e o que é montagem pelo nome?
Por tipo significa que, quando houver um feijão com o mesmo tipo do atributo especificado no contêiner de mola, o atributo será montado automaticamente; Se houver vários feijões desse tipo, uma exceção será executada e é apontado que a montagem automática por tipo não poderá ser usada; Se nenhum feijão correspondente for encontrado, nada acontecerá.
O chamado nome significa montagem automática com base no nome do atributo. Este item verificará os feijões no recipiente de mola exatamente o mesmo que o nome do atributo e executará a montagem automática.
@RequestMapping (endereço de solicitação do mapa)
As anotações usadas para lidar com mapeamentos de endereços solicitados podem ser usados em classes ou métodos. Para uso em uma classe, todos os métodos que representam que as solicitações de resposta em uma classe tomam esse endereço como o caminho pai.
Existem seis atributos, a saber:
1. Valor, método;
Valor: Especifica o endereço real da solicitação e o endereço especificado pode estar no modo de modelo URI (que será explicado posteriormente);
Método: Especifique o tipo de método solicitado, obtenha, postar, colocar, excluir, etc.;
2. Consumem, produz
Consumidores: Especifica o tipo de envio (tipo de conteúdo) que lida com a solicitação, como Application/JSON, Text/HTML;
Produz: especifica o tipo de conteúdo retornado, que será retornado apenas se o tipo (aceitar) no cabeçalho da solicitação de solicitação contiver o tipo especificado;
3. Params, cabeçalhos
Params: especifica que a solicitação deve conter certos valores de parâmetros antes que o método possa ser processado.
Cabeçalhos: especifica que a solicitação deve conter alguns valores especificados do cabeçalho para que o método lide com a solicitação.
@Controlador@requestmapping ("/bbtforum.do") classe pública BBTFORUMCONTROLLER {@RequestMapping (params = "Method = listboardtopic") public string listboardtopic (int toppId, usuário do usuário) {}}@requestmapping ("/Softpg/downsoftpg.ax) {}}}@ Método = requestMethod.post) @RequestMapping (value = "/OSU/Product/detalhe.do", params = {"modify = false"}, método = requestmethod.post)@RequestParam (obtenha o valor do parâmetro de solicitação)
Por exemplo, nosso endereço de acesso no navegador é: localhost: 8080/hello? Id = 1000, e obtemos o valor de identificação, por exemplo:
@RestControllerPublic Classe Hellocontroller {@RequestMapping (value = "/hello", Method = requestMethod.get) public string dizhello (@requestParam ("id") integer id) {return id: "+id; }}@Pathvaribale (obtenha dados em URL)
@RestControllerPublic Classe Hellocontroller {@ReQuestMapping (value = "/hello/{id}", Method = requestMethod.get) public string dizhello (@pathvariable ("id") integer id) {return id: "+id; }}@ResponseBody (Tipo de retorno JSON)
Função: Esta anotação é usada para converter o objeto retornado pelo método do controlador no formato especificado através do httpMessageConverter apropriado e escrevê -lo na área de dados do corpo do objeto de resposta.
Hora de usar: Os dados retornados não são uma página com a tag HTML, mas são usados quando os dados em algum outro formato (como JSON, XML etc.);
Resumir
O exposto acima é a análise de anotações comuns no Spring Springmvc apresentado a você pelo editor. Espero que seja útil para você. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a você a tempo. Muito obrigado pelo seu apoio ao site wulin.com!