Spring_aop学习

1. Spring 的aop配置学习

面向切面编程(用到的设计模式---代理模式)

 

1.1. 步骤(BeforeAdvice)：前置通知

1.1.1. 编写需要执行的service并且利用IOC将这个类放到AppliactionContext池里

package com.bjsxt.lc.service.impl;   import org.springframework.stereotype.Service;   import com.bjsxt.lc.service.IUserService; @Service(value="userServiceImpl") public class UserServiceImpl implements IUserService { @Override public int cave() { System.out.println("========cave========="); return 100; } @Override public void update() { System.out.println("========update========="); } @Override public void insert(Object obj) { System.out.println("========insert========="); } }

1.1.2. 写自己需要执行的方法(MethodBeforeAdvice)

l 第一步：创建一个普通的类

l 第二步：实现methodBeforeAdvice接口，重写before方法

n Before方法---具体参数含义

u Method:表示执行的方法的全称

u Object[]:表示参数列表

u Object:表示执行方法的类

l 第三步：将创建的这个类放到IOC容器里，以便以创建对象

package com.bjsxt.lc.aop;   import java.lang.reflect.Method; import java.util.Arrays;   import org.springframework.aop.MethodBeforeAdvice; import org.springframework.stereotype.Component; /**  *测试SpringBefore  * @author lc   * 再通知  *  */ @Component(value="beforeAdvice") public class BeforeAdvice implements MethodBeforeAdvice { /*  * method:执行的方法的全称--  * public abstract void com.bjsxt.lc.service.IUserService.insert(java.lang.Object),  * objs: 表示执行方法的参数列表  * Objecet:表示执行的类的全称  * com.bjsxt.lc.service.impl.UserServiceImpl@638ef7ed  *  */ @Override public void before(Method method, Object[] objs, Object obj) throws Throwable { System.out.println("--before-\n-method="+method+",\n objs"+Arrays.toString(objs)+"\n,obj="+obj); } }

1.1.3. 配置配置文件(applicationContext.xml)

l 第一步：引入AOP的dtd文件

l 第二步：开启自动装配的模式(default-autowire=”byName”)

l 第三步：确定需要自动装配的包路径

n <context:component-scan base-package="com.bjsxt" />

l 第四步：开启配置AOP

n <aop:config></aop:config>

l 第五步：引入切面的类

<aop:pointcut     expression="execution(* com.bjsxt.lc.service.impl.*.*(..))" id="pointcut" />

n Expression:表示地址表达式-----意思就是在里面配置的那些类的哪些方法需要执行AOP程序。。。。

n Id：是指的是这个AOP的名字

l 第五步：通知类型(相当于一个多对多的中间表将两个方法联系在一起)

<!-- 通知类型 将beforeAdvice关联到上面的横切面上(pointcut) advice-ref:表示那个类被关联到到横切面上 pointcut-ref：表示这个通知类关联到那个横切面上  -->  <aop:advisor advice-ref="beforeAdvice" pointcut-ref="a"/>

n Advice-if:表示执行的那个类(制定)

n Pointcut-ref：表示制定的那个aop执行

1.1.4. 测试：

package com.bjsxt.lc.test;   import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.junit.Before; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext;   import com.bjsxt.lc.service.IUserService;   public class BasicTest { protected Logger logger = LogManager.getLogger("BasicTest"); protected ApplicationContext applicationContext; @Before public void info() {  applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); } @Test public void testSpring() { IUserService userService = (IUserService) this.applicationContext.getBean("userServiceImpl"); logger.info("---testUserService----{}--",userService); //userService.update(); userService.insert("aa"); logger.info("-------testSpring--------"); } }

1.1.5. 结果：

2016-11-14 19:31:31,125 INFO  [main] test.TestSpring (TestSpring.java:14) - ---testUserService----com.bjsxt.lc.service.impl.UserServiceImpl@638ef7ed-- --before- -method=public abstract void com.bjsxt.lc.service.IUserService.insert(java.l cade ang.Object),  objs[aa] ,obj=com.bjsxt.lc.service.impl.UserServiceImpl@638ef7ed ========insert========= 2016-11-14 19:31:31,130 INFO  [main] test.TestSpring (TestSpring.java:17) - -------testSpring--------

1.2. 步骤(AfterAdvice)：后置通知

1.2.1. 第一步与前置通知一样

1.2.2. 第二步写自己的后置执行类

l 第一步：创建一个普通的类

l 第二步：实现AfterRrturningAdvice接口，重写afterReturning方法

n afterReturning方法---具体参数含义

u Object:表示执行的返回值

u Method：表示执行的方法

u Object[]:表示参数列表

u Object:表示执行方法的类

l 第三步：将创建的这个类放到IOC容器里，以便以创建对象

package com.bjsxt.lc.aop;   import java.lang.reflect.Method;   import org.springframework.aop.AfterReturningAdvice; import org.springframework.stereotype.Component; /**  * 后置通知  * @author Administrator  *  */ @Component(value="afterAdvice") public class AfterAdvice implements AfterReturningAdvice { /**  * obj1:表示返回值  * method:表示执行的方法的全称  * object[]:表示参数列表  * object：执行方法的类的全称  */ @Override public void afterReturning(Object obj1, Method mthod, Object[] objs, Object arg2) throws Throwable { System.out.println("后置通知(1)---->obj1"+obj1); System.out.println("后置通知(2)---->mthod"+mthod); System.out.println("后置通知(3)---->objs"+objs); System.out.println("后置通知(4)---->arg2"+arg2); } }

 

 

1.2.3. 第三步：配置文件的处理

l 与前置通知没有区别：通知类型(相当于一个多对多的中间表将两个方法联系在一起)

<aop:advisor advice-ref="afterAdvice" pointcut-ref="a"/>

1.2.4. 第四步：测试一样

1.2.5. 第五步：结果

========cave========= 后置通知(1)---->obj1100 后置通知(2)---->mthodpublic abstract int com.bjsxt.lc.service.IUserService.cave() 后置通知(3)---->objs[Ljava.lang.Object;@2e570ded 后置通知(4)---->arg2com.bjsxt.lc.service.impl.UserServiceImpl@3cce57c7 2016-11-14 19:44:06,189 INFO  [main] test.TestSpring (TestSpring.java:17) - -------testSpring--------

1.3. 步骤(RoundAdvice):环绕通知

1.3.1. 第一步：与上步骤一样

1.3.2. 第二步：写自己的环绕通知类

n 第一步：创建一个普通的类

n 第二步：实现MethodInterceptor接口，重写invoke方法

u 获得前置和后置的参数

l invoc..getArguments():获得参数列表

l invoc.getMethod();获得执行的方法

l Invoc.proceed();开始执行

l invoc.getThis():得到执行的类

n 第三步：将创建的这个类放到IOC容器里，以便以创建对象

1.3.3. 配置文件：引入即可

1.3.4. 测试

1.3.5. 结果:

=========Before============== objects=[Ljava.lang.Object;@2ca26d77 method=public abstract void com.bjsxt.lc.service.IUserService.insert(java.lang.Object) ========insert========= clazz=com.bjsxt.lc.service.impl.UserServiceImpl@3576ddc2 ==========After================= 2016-11-14 20:07:33,331 INFO  [main] test.BasicTest (BasicTest.java:30) - -------testSpring--------