Este artigo demonstra a implementação da AOP usando a anotação de aspecto e a configuração XML na primavera
A seguir , o projeto Java que implementa AOP usando anotações de aspecto
Primeiro é o arquivo ApplicationContext.xml localizado sob o caminho de classe
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd "> <!-Enable Aspectj Support para ANOTNATATION-> <aop" id = "SecurityHandler"/> </ Beans>
Depois, há a interface da camada de serviço e a classe de implementação
pacote com.jadyer.annotation; interface pública UserManager {public void adduser (nome de usuário da string, string senha); public void Deluser (int userID); public string findUserById (int userID); public void modifyUser (int userID, string nome de usuário, senha da string); } / *** O UserManager acima é a interface da camada de serviço* O seguinte UserManagerImpl é a classe de implementação da interface da camada de serviço* / package com.jadyer.annotation; classe pública userManagerImpl implementa o userManager {public void adduser (string userName, string senha) {System.out.println ("------- userManagerImpl.adduser () é invocado -----"); } public void deluser (int userID) {System.out.println ("-------- UserManagerImpl.delUser () é invocado ------"); } public string findUserById (int userId) {System.out.println ("------ UserManagerImpl.findUSERBYID () é invocado ------"); Retornar "Vida com cara de ferro"; } public void modifyUser (int userID, string nome de usuário, string senha) {System.out.println ("------- userManagerImpl.modifyUser () é chamado ------"); }} Em seguida é a classe de entrada marcada com aspecto
pacote com.jadyer.annotation; importar org.aspectj.lang.annotation.after; importar org.aspectj.lang.annotation.aspect; importar org.aspectj.lang.annotation.pointcut; @Aspect public class SecurityHandler { /** * Definir Pointcut * @see Pointcut O nome do Pointcut é addaddmethod (). Este método não possui valor de retorno e parâmetros* @see Este método é um identificador e não o chama*/@PointCut ("Execution (* add* (..))") // corresponde a todos os métodos que começam com Add Private void AddaddMethod () {}; /*** Definir aconselhamento* @see indica a que assinaturas pontuais nosso conselho se aplica a nos pontos de junho*/// @antes ("addaddmethod ()") @after ("addaddmethod ()) private void checkSecurity () {System.out.println (" ----- 【【【; }} Finalmente, a aula de teste do cliente
pacote com.jadyer.annotation; importar org.springframework.context.ApplicationContext; importar org.springframework.context.support.classPathXMLApplicationContext; /*** Suporte da Spring para AOP: adota o método de anotação* @see • Pré-requisito: Como é um proxy dinâmico do JDK, se você deseja gerar um proxy, a classe deve implementar uma interface* @see se a classe não tiver uma interface de implementos e ainda usa a implementação de AOP padrão da Spring. Isto é, desenvolva o hábito de programação orientada para interface* @see --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Adicionado suporte à anotação * @see * spring_home // dist // spring.jar * @see * spring_home // lib // log4j // log4j-1.2.14.jar * @see * spring_home // lib // jakarta-commons // comandingj/ * @. Relatões cruzadas e estabelecer o SecurityHandler.java * @see 3. Use anotações para especificar o SecurityHandler como aspecto * @see 4. Use anotações para definir conselhos e pontos * @see 5. Ativar suporte de aspecto para anotação para anotação e configurar a classe de destino e a classe de aspecto no IOC * @see 6. --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (UserManager) Factory.getBean ("UserManager"); userManager.adduser ("Zhang Qiling", "02200059"); }} A seguir , o projeto Java que implementa a AOP usando arquivos de configuração XML
Primeiro é o arquivo ApplicationContext-cglib.xml localizado no diretório raiz da SRC
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-cl.xsd "> <!-Uso do proxy cGLIB-> <!-<aop: aspecto" id = "userManager"/> <bean id = "SecurityHandler"/> <AOP: config> <aop: aspecto id = "securityAspect" ref = "securityHandler"> <aOP: pointcut id = "addaddMethod" Expression = "Execution (* add*)"/> <aop: antes do método "verificador" " </aOP: Aspect> </aOP: config> </beans> <!- corresponde a todos os métodos que começam com add (*add*(..)) correspondem a todos os métodos de todas as classes em com.jadyer.servcices.impl com.jadyer.services.impl.*. Add*(..)) || execução (*com.jadyer.services.impl.*. del*(..)) ->
Depois, há a interface da camada de serviço e a classe de implementação
pacote com.jadyer.cglib; interface pública UserManager {public void adduser (nome de usuário da string, string senha); public void Deluser (int userID); public string findUserById (int userID); public void modifyUser (int userID, string nome de usuário, senha da string); } / *** O UserManager acima é a interface da camada de serviço* O seguinte UserManagerImpl é a classe de implementação da interface da camada de serviço* / package com.jadyer.cglib; classe pública userManagerImpl {// implementa o userManager {public void addUser (nome de usuário da string, string senha) {System.out.println ("------- userManagerImpl.adduser () é invocado -----"); } public void deluser (int userID) {System.out.println ("-------- UserManagerImpl.delUser () é invocado -----"); } public string findUserById (int userId) {System.out.println ("------ UserManagerImpl.findUSERBYID () é invocado -----"); retornar "Zhang San"; } public void modifyUser (int userID, string nome de usuário, string senha) {System.out.println ("------- userManagerImpl.modifyUser () é chamado -----"); }} Em seguida, é a classe de entrada especificada no ApplicationContext-cglib.xml
pacote com.jadyer.cglib; importar org.aspectj.lang.joinpoint; /*** Passe as informações de chamada do cliente para o conselho* @see Você pode adicionar um parâmetro de junção ao conselho para obter o nome do método e o valor do parâmetro da chamada do cliente* @see no futuro, há menos casos de uso puramente da AOP para escrever coisas como essa. Usamos principalmente as transações fornecidas pelo Spring* @see que você pode saber sobre isso. A seguir, é apresentado o código de amostra */ classe pública SecurityHandler {Private Void CheckSecurity (junção jun juntpoint) {for (int i = 0; i <junção -ponto.getargs (). Length; i ++) {System.out.println (jun JoinPoint.getargs () [i]); // Obtenha o valor do parâmetro do método chamado pelo cliente} System.out.println (junção.getSignature (). GetName ()); // Obtenha o nome do método chamado pelo cliente System.out.println ("------ [ChequeSecurity é invocado] -----"); }} Finalmente, a aula de teste do cliente
pacote com.jadyer.cglib; importar org.springframework.context.ApplicationContext; importar org.springframework.context.support.classPathXMLApplicationContext; /** * @ver ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Since it is herança, é melhor não usar a declaração final para a classe de destino* @see ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Porque as metas que proxy geralmente são objetos de negócios* @see --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- classe pública client {public static void main (string [] args) {ApplicationContext Factory = new ClassPathXMLApplicationContext ("ApplicationContext-cglib.xml"); // Quando o userManagerImpl implementa a interface do userManager, o Spring usará automaticamente o proxy dinâmico do JDK // se o projeto tiver introduzido a biblioteca do CGLIB e forçou o uso de proxy do CGLIB no arquivo de configuração, o Spring usará apenas o CGLIB Proxy // UserManagerManager = (manager); // Como o userManagerImpl não implementa a interface do userManager no momento, a interface do userManager não pode ser usada no tipo de recebimento.//the CGLIB Library foi introduzido no projeto. Embora o proxy do CGLIB não seja forçado a ser usado no arquivo de configuração, o Spring usará automaticamente o CGLIB Proxy UserManagerImpl UserManager = (UserManagerImpl) Factory.getBean ("UserManager"); userManager.adduser ("wu sansheng", "02200059"); }}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.