Spring笔记07（Spring AOP的通知advice和顾问advisor）

package cn.pb.dao;public interface UserDao {
//主业务
String add();
//主业务
void del();
}

package cn.pb.dao;public class UserDaoImpl implements UserDao{
//主业务
public String add() {
//模拟异常
//int a=8/0;
System.out.println("add ok!");
return "新增成功！";
}
//主业务
public void del() {
System.out.println("del ok!");
}

package cn.pb.advices;
/**
* 前置增强类 实现MethodBeforeAdvice接口
* 在目标对象方法执行之前执行
*/import org.springframework.aop.MethodBeforeAdvice;import java.lang.reflect.Method;public class BeforeAdvice implements MethodBeforeAdvice {
/**
*
* @param method :目标方法
* @param args :目标方法参数
* @param target :目标对象
* @throws Throwable
*/
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("前置增强====================》");
}
}

package cn.pb.advices;
/**
* 后置增强类 实现AfterReturningAdvice接口
* 在目标对象方法执行之后执行
*/
import org.springframework.aop.AfterReturningAdvice;import java.lang.reflect.Method;public class AfterAdvice implements AfterReturningAdvice {
/**
*
* @param target:目标对象
* @param method ：目标方法
* @param args ：目标方法参数
* @param returnValue ：目标方法返回值
* @throws Throwable
*/
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println("后置增强==================》");
}
}

package cn.pb.advices;
/**
* 环绕增强 ：
* 在前置通知 之后，
* 后置通知之前执行环绕通知！
*/import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;public class AroundAdvice implements MethodInterceptor {
/**
* 在前置通知 之后，后置通知之前执行环绕通知！
* 可以获取方法的返回值，并且改变！
* @param methodInvocation 方法的执行器， getMethod 包含了方法中的所有方法
* @return
*/
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
System.out.println("执行方法之前的 环绕通知");
//执行目标方法
Object result= methodInvocation.proceed();
if (result!=null){
//对方法的返回值进行修改
result="xiaoheihei";
}
System.out.println("执行方法之后的 环绕通知");
return result;
}
}

package cn.pb.advices;/**
* 异常增强类：在目标方法出现异常的时候执行
* 实现ThrowsAdvice接口
*/import org.springframework.aop.ThrowsAdvice;public class ExceptionAdvice implements ThrowsAdvice{
public void throwsAdvice(){
System.out.println("方法在执行过程中出现了异常！");
}
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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.xsd"> <!--01.配置目标对象-->
<bean id="userDao" class="cn.pb.dao.UserDaoImpl"/>
<!--02.配置通知-->
<bean id="beforeAdvice" class="cn.pb.advices.BeforeAdvice"/>
<bean id="afterAdvice" class="cn.pb.advices.AfterAdvice"/>
<bean id="aroundAdvice" class="cn.pb.advices.AroundAdvice"/> <!--03.通过配置代理工厂bean，生成代理类，来把通知织入到目标对象
问题：只能管理 通知！
01.只能将切面织入到目标类的所有方法中！
02.只能配置一个 目标对象
-->
<bean id="userProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<!--注册目标对象 如果nam为target 那么ref="userDao" -->
<property name="targetName" value="userDao"/>
<!--注册通知-->
<property name="interceptorNames" value="beforeAdvice,afterAdvice,aroundAdvice"/> </bean> <!--配置异常目标对象-->
<bean id="userException" class="cn.pb.exceptionPackage.UserServiceImpl"/>
<!--配置异常通知-->
<bean id="myException" class="cn.pb.advices.ExceptionAdvice"/> <!--现在是一个service对应一个ProxyFactoryBean 这样不可以！-->
<bean id="exceptionProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<!--注册目标对象 -->
<property name="targetName" value="userException"/>
<!--注册通知-->
<property name="interceptorNames">
<array>
<value>myException</value> <!--异常通知-->
</array>
</property>
<!--代理类的优化 设置之后程序就会自动选择是使用JDK动态代理还是使用cglib动态代理-->
<property name="optimize" value="true"/>
<!-- <property name="proxyTargetClass" value="true"/>
proxyTargetClass：默认是false ，默认执行jdk动态代理！
设置成true，强制执行cglib！
optimize ： 代理类的优化
有接口就是用jdk，没有接口使用cglib动态代理-->
</bean>
<!--
我们的动态代理 （在程序运行期间，动态生成的代理类） 分为两种方式：
01.jdk 只能应用于实现接口的情况
02.cglib 应用于实现接口和类的情况
如果我们是接口的情况，使用jdk效率高！
如果我们是类的情况，必须使用cglib！
问题？
程序 spring容器怎么知道我们是用的类还是接口？？
public class ProxyConfig implements Serializable
private boolean proxyTargetClass = false;
private boolean optimize = false;
spring底层默认使用cglib！ 现在我们的项目中使用的是接口！
用spring默认的性能不高！
proxyTargetClass 和optimize都是用来设置 我们使用的代理模式是jdk还是cglib！
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
根据我们配置文件中 proxyTargetClass 和 optimize的配置
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
根据目标对象返回对应的动态代理
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
--></beans>

package cn.pb;import cn.pb.dao.UserDao;
import cn.pb.exceptionPackage.ServiceException;
import cn.pb.exceptionPackage.UserException;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class TestAdvice { /**
* 前置 后置 通知测试
*/ @Test
public void testBefore(){
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao service= (UserDao) context.getBean("userProxy");
service.add();
System.out.println("*************");
service.del();
} /**
* 环绕 通知测试
*/ @Test
public void testAround(){
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao service= (UserDao) context.getBean("userProxy");
String result= service.add();
System.out.println(result);
System.out.println("*************");
service.del();
} /**
* 异常通知测试
*/ @Test
public void testException(){
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
ServiceException service= (ServiceException) context.getBean("exceptionProxy");
try {
service.chechUser("admins",25);
} catch (UserException e) {
e.printStackTrace();
} }}

顾问：在通知的基础之上，在细化我们的aop切面！通知和顾问都是切面的实现方式！
通知是顾问的一个属性！顾问会通过我们的设置，将不同的通知，在不通过的时间点，把切面
织入到不同的切入点！PointCutAdvisor接口！
比较常用的两个实现类：
NameMatchMethodPointcutAdvisor :根据切入点（主业务方法）名称织入切面！
RegexpMethodPointcutAdvisor :根据自定义的正则表达式织入切面！正则表达式中常用的三个运算符
. 任意单个字符
+ 表示字符出现一次或者多次
* 表示字符出现0次或者多次

package cn.pb.dao;public interface UserDao {
//主业务
void add();
//主业务
void del();
}

package cn.pb.dao.impl;import cn.pb.dao.UserDao;public class UserDaoImpl implements UserDao{ //主业务
public void add() {
System.out.println("add ok!");
}
//主业务
public void del() {
System.out.println("del ok!");
}
}

package cn.pb.advices;
/**
* 前置增强类 在目标方法执行之前 执行
* 要实现MethodBeforeAdvice接口
*/import org.springframework.aop.MethodBeforeAdvice;import java.lang.reflect.Method;public class BeforeAdvice implements MethodBeforeAdvice {
/**
* 在目标方法执行之前
* @param method 目标方法
* @param args 目标方法的参数列表
* @param target 目标对象
* @throws Throwable
*/
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("前置增强==============》");
}
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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.xsd"> <!--01.配置目标对象-->
<bean id="userDao" class="cn.pb.dao.impl.UserDaoImpl"/>
<!--02.配置增强 通知-->
<bean id="beforeAdvice" class="cn.pb.advices.BeforeAdvice"/> <!---配置顾问 实现了 在指定的主业务方法中 增强-->
<bean id="myAdvisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
<!--通知就是顾问中的一个属性-->
<property name="advice" ref="beforeAdvice"/>
<!--配置切入点 这里的切入点指的是 方法的简写!-->
<property name="mappedNames" value="add,del"/>
</bean> <!--03.配置代理对象-->
<bean id="userProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<!--注册目标对象-->
<property name="target" ref="userDao"/>
<!--注册顾问-->
<property name="interceptorNames" value="myAdvisor"/>
</bean></beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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.xsd"> <!--01.配置目标对象-->
<bean id="userDao" class="cn.pb.dao.impl.UserDaoImpl"/>
<!--02.配置增强 通知-->
<bean id="beforeAdvice" class="cn.pb.advices.BeforeAdvice"/> <!---配置顾问 实现了 在指定的主业务方法中 增强-->
<bean id="myAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<!--通知就是顾问中的一个属性-->
<property name="advice" ref="beforeAdvice"/>
<!--配置切入点 这里的切入点指的是 方法的全限定方法名
cn.pb.dao.impl.UserServiceImpl.add
cn.pb.dao.impl.UserServiceImpl.del-->
<!-- <property name="pattern" value=".*add.*"/> 匹配单个方法-->
<!-- <property name="pattern" value=".*mpl.*"/>匹配多个方法-->
<!--<property name="patterns" value=".*add.*,.*del.*"/> 匹配多个方法-->
<property name="pattern" value=".*add.*|.*del.*"/></bean><!--03.配置代理对象-->
<bean id="userProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<!--注册目标对象-->
<property name="target" ref="userDao"/>
<!--注册顾问-->
<property name="interceptorNames" value="myAdvisor"/>
</bean></beans>

package cn.pb;import cn.pb.dao.UserDao;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class TestUser {
/**
* 测试NameMatchMethodPointcutAdvisor
*/
@Test
public void testNameMethod(){
ApplicationContext context=new
ClassPathXmlApplicationContext("applicationContext.xml");
UserDao proxy= (UserDao) context.getBean("userProxy");
proxy.add();
System.out.println("***************");
proxy.del();
} /**
* 测试RegexpMethodPointcutAdvisor
*/
@Test
public void testRegexpMethod(){
ApplicationContext context=new
ClassPathXmlApplicationContext("regexp.xml");
UserDao proxy= (UserDao) context.getBean("userProxy");
proxy.add();
System.out.println("***************");
proxy.del();
}
}