第三章 AOP 通过Java API创建切面

最新推荐文章于 2024-04-10 19:43:34 发布

s112322341

最新推荐文章于 2024-04-10 19:43:34 发布

阅读量294

点赞数

文章标签： java

在前面使用增强的时候，我们发现增强会被织入到目标类的所有的方法中。我们如果把增强织入到目标类的特定的方法中，需要使用切点进行目标连接点的定位。然后我们可以通过切点及增强生成一个切面了。

3.4.1切点类型

静态方法切点：org.springframework.aop.support.StaticMethodMatcherPointcut

动态方法切点：org.springframework.aop.support.DynamicMethodMatcherPointcut

注解切点：org.springframework.aop.support.annotation.AnnotationMatchingPointcut

表达式切点：org.springframework.aop.support.ExpressionPointcut

流程切点：org.springframework.aop.support.ControlFlowPointcut

3.4.2静态方法来匹配切面

org.springframework.aop.support.StaticMethodMatcherPointcutAdvisor

a、增强类

在这里使用的是3.3.2的前置增强：

http://blog.csdn.net/p_3er/article/details/9239925

只是UserDaoImpl中有两个方法，save方法和delete方法。然后我们给save方法配置切面。

b、切面类继承StaticMethodMatcherPointcutAdvisor

public class StaticAdvisor extends StaticMethodMatcherPointcutAdvisor {
	/*
	 * 切点方法匹配规则
	 */
	public boolean matches(Method method, Class<?> clazz) {
		return method.getName().equals("save");
	}

	/*
	 * 重写StaticMethodMatcherPointcut的getClassFilter()
	 * 匹配哪个类下的方法
	 */
	public ClassFilter getClassFilter() {
		ClassFilter classFilter = new ClassFilter() {
			public boolean matches(Class<?> clazz) {
				return UserDaoImpl.class.isAssignableFrom(clazz);
			}
		};
		return classFilter;
	}
}

c、配置

<!-- 增强Bean -->
	<bean id="userDaoBeforeAdvice" class="cn.framelife.spring.advice.UserDaoBeforeAdvice"></bean>
	
	<!-- 目标Bean -->
	<bean id="userDao" class="cn.framelife.spring.dao.impl.UserDaoImpl"></bean>
	
	<!-- 管理切面类。p:advice-ref把增强放入切面 -->
	<bean id="staticAdvisor" class="cn.framelife.spring.advisor.StaticAdvisor" p:advice-ref="userDaoBeforeAdvice"></bean>
	
	<!-- 
		设置父代理类 
		p:interceptorNames 放切面，而不再是增强
	-->
	<bean id="paramProxy" 
		class="org.springframework.aop.framework.ProxyFactoryBean"
		p:interceptorNames="staticAdvisor"
		p:proxyTargetClass="true" />	
	<!-- 设置子代理类 -->
	<bean id="userDaoProxy" parent="paramProxy" p:target-ref="userDao"></bean>

d、测试

ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});
		UserDao userDao = (UserDao) context.getBean("userDaoProxy");
		//UserDaoImpl中有两个方法，save方法中有切面，delete中没切面
		userDao.save();
		System.out.println("----------");
		userDao.delete();

e、结果

我是前置增强:save
保存用户...
----------
删除用户...

3.4.3静态正则表达式方法配置切面

这种方法不需要自己写切面类。

org.springframework.aop.support.RegexpMethodPointcutAdvisor是正则表达式方法匹配的切面实现类。

a、增强类

在这里使用的是3.3.2的前置增强：

http://blog.csdn.net/p_3er/article/details/9239925

b、配置

<!-- 增强Bean -->
	<bean id="userDaoBeforeAdvice" class="cn.framelife.spring.advice.UserDaoBeforeAdvice"></bean>
	
	<!-- 目标Bean -->
	<bean id="userDao" class="cn.framelife.spring.dao.impl.UserDaoImpl"></bean>
	
	<!-- 
		设置切面Bean 
		patterns 用正则表达式定义目标类全限定方法名的匹配模式串
			目标类全限定方法名，指的是带类名的方法名。如: cn.framelife.spring.dao.impl.UserDaoImpl.delete()
		<value>.*delete</value> 匹配模式串
	-->
	<bean id="regexpAdvisor" 
		class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"
		p:advice-ref="userDaoBeforeAdvice">
		<property name="patterns">
			<list>
				<value>.*delete</value>
			</list>
		</property>
	</bean>
	
	<!-- 
		设置代理类 
	-->
	<bean id="regexpProxy" 
		class="org.springframework.aop.framework.ProxyFactoryBean"
		p:interceptorNames="regexpAdvisor"
		p:target-ref="userDao"
		p:proxyTargetClass="true" />

c、测试

ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});
		UserDao userDao = (UserDao) context.getBean("regexpProxy");
		userDao.save();
		System.out.println("----------");
		userDao.delete();

d、结果

保存用户...
----------
我是前置增强:delete
删除用户...

常用的正则表达式规则

1、.*set.*表示所有类中的以set为前缀的方法。如：com.abc.UserDao.setName()。

2、com\.abc\.service\..*表示com.abc.service.包下所有的类的所有的方法。

Com.abc.service.a.User.setName()

Com.abc.service.UserService.save()

3、com\.abc\.service\..*Service\..*表示com.abc.service包下以Service结尾的类的所有的方法。如:com.abc.service.UserService.save()

4、com\.abc\.service\..*Service\.save.+匹配所有以save为前缀的方法，而且save后必须拥有一个或多个字符。如：com.abc.service.UserService.saveUser()

3.4.4动态切面

org.springframework.aop.support.DynamicMethodMatcherPointcut类即有静态切点检查的方法，也有动态切点检查的方法。由于动态切点检查会对性能造成很大的影响，我们应当避免在运行时每次都对目标类的各个方法进行检查。

Spring检查动态切点的机制：在创建代理时对目标类的每个连接点进行静态切点检查，如果仅静态切点检查就可以知道连接点是不匹配的，在运行期就不进行动态检查了；如果静态切点检查是匹配的，在运行期才进行动态方法检查。

动态切面通过DefaultPointcutAdvisor切面类与DynamicMethodMatcherPointcut切点结合起来生成。主要是针对连接点方法的参数。

a、增强类

在这里使用的是3.3.2的前置增强:

http://blog.csdn.net/p_3er/article/details/9239925

只是UserDaoImpl中多了一个out方法，带一个参数。

b、切点类继承DynamicMethodMatcherPointcut

public class DynamicPointcut extends DynamicMethodMatcherPointcut {
	//用list集合保存参数名
	private List<String> specialNames = new ArrayList<String>();
	
	public DynamicPointcut(){
		specialNames.add("aa");
		specialNames.add("bb");
	}
	/*
	 * 对类进行静态切点检查
	 */
	public ClassFilter getClassFilter() {
		
		return new ClassFilter() {
			@Override
			public boolean matches(Class<?> targetClass) {
				System.out.println("使用getClassFilter静态检查："+targetClass.getName());
				return UserDaoImpl.class.isAssignableFrom(targetClass);
			}
		};
	}

	/*
	 *对方法进行静态切点检查
	 */
	public boolean matches(Method method, Class<?> targetClass) {
		System.out.println("使用matches(method,targetClass)方法静态检查："+targetClass.getName()+"--"+method.getName());
		return method.getName().equals("out");
	}


	/*
	 *对方法进行动态切点检查
	 */
	public boolean matches(Method method, Class<?> targetClass, Object[] args) {
		System.out.println("使用matches(method,targetClass)方法动态检查："+targetClass.getName()+"--"+method.getName()+"的参数");
		String name = (String)args[0];
		return specialNames.contains(name);
	}
}

c、配置

<!-- 增强Bean -->
	<bean id="userDaoBeforeAdvice" class="cn.framelife.spring.advice.UserDaoBeforeAdvice"></bean>

	<!-- 目标Bean -->
	<bean id="userDao" class="cn.framelife.spring.dao.impl.UserDaoImpl"></bean>
	
	
	<!-- 切面 -->
	<bean id="dynamicAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
		<!-- 设置切点 -->
		<property name="pointcut">
			<bean class="cn.framelife.spring.pointcut.DynamicPointcut"></bean>
		</property>
		<!-- 织入增强 -->
		<property name="advice" ref="userDaoBeforeAdvice"></property>
	</bean>
	
	<!-- 
		设置代理 
	-->
	<bean id="dynamicProxy" 
		class="org.springframework.aop.framework.ProxyFactoryBean"
		p:interceptorNames="dynamicAdvisor"
		p:target-ref="userDao"
		p:proxyTargetClass="true" />

d、测试

ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});
		UserDao userDao = (UserDao) context.getBean("dynamicProxy");
		//UserDaoImpl中多了一个out方法，带一个参数。
		System.out.println("----------");
		userDao.save();
		System.out.println("----------");
		userDao.out("aa");
		System.out.println("----------");
		userDao.out("1111");
		System.out.println("----------");

e、结果

使用getClassFilter静态检查：cn.framelife.spring.dao.impl.UserDaoImpl
使用matches(method,targetClass)方法静态检查：cn.framelife.spring.dao.impl.UserDaoImpl--out
使用getClassFilter静态检查：cn.framelife.spring.dao.impl.UserDaoImpl
使用matches(method,targetClass)方法静态检查：cn.framelife.spring.dao.impl.UserDaoImpl--save
使用getClassFilter静态检查：cn.framelife.spring.dao.impl.UserDaoImpl
使用matches(method,targetClass)方法静态检查：cn.framelife.spring.dao.impl.UserDaoImpl--delete
使用getClassFilter静态检查：cn.framelife.spring.dao.impl.UserDaoImpl
使用matches(method,targetClass)方法静态检查：cn.framelife.spring.dao.impl.UserDaoImpl--clone
使用getClassFilter静态检查：cn.framelife.spring.dao.impl.UserDaoImpl
使用matches(method,targetClass)方法静态检查：cn.framelife.spring.dao.impl.UserDaoImpl--toString
----------
使用getClassFilter静态检查：cn.framelife.spring.dao.impl.UserDaoImpl
使用matches(method,targetClass)方法静态检查：cn.framelife.spring.dao.impl.UserDaoImpl--save
保存用户...
----------
使用getClassFilter静态检查：cn.framelife.spring.dao.impl.UserDaoImpl
使用matches(method,targetClass)方法静态检查：cn.framelife.spring.dao.impl.UserDaoImpl--out
使用matches(method,targetClass)方法动态检查：cn.framelife.spring.dao.impl.UserDaoImpl--out的参数
我是前置增强:out
out输出名字为:aa
----------
使用matches(method,targetClass)方法动态检查：cn.framelife.spring.dao.impl.UserDaoImpl--out的参数
out输出名字为:1111
----------

3.4.5流程切面

一个类中的某一方法使用目标类的两个方法，那么我们可以使用流程切面给这两个方法都积入增强。

如：UserServiceImpl类(使用类)operate方法中使用UserDaoImpl(目标类)的两个方法。

流程切面使用ControlFlowPointcut与DefaultPointcutAdvisor结合形成。

a、增强类

在这里使用的是3.3.2的前置增强：

http://blog.csdn.net/p_3er/article/details/9239925

只是UserDaoImpl中有两个方法，save方法和delete方法。然后我们给save方法配置切面。

b、UserServiceImpl类

public class UserServiceImpl implements UserService {
	private UserDao userDao;
	
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

	public void addUser() {
		userDao.save();
	}

	@Override
	public void operate() {
		//这里同时使用了userDao的两个方法
		userDao.delete();
		userDao.save();
	}
}

c、配置

<!-- 增强Bean -->
	<bean id="userDaoBeforeAdvice" class="cn.framelife.spring.advice.UserDaoBeforeAdvice"></bean>

	<!-- 目标Bean -->
	<bean id="userDao" class="cn.framelife.spring.dao.impl.UserDaoImpl"></bean>
	
	<!-- 切点 -->
	<bean id="controlFlowPointcut" class="org.springframework.aop.support.ControlFlowPointcut">
		<!-- 指定流程切点的类 -->
		<constructor-arg type="java.lang.Class" value="cn.framelife.spring.service.impl.UserServiceImpl"></constructor-arg>
		<!-- 指定流程切点的方法 -->
		<constructor-arg type="java.lang.String" value="operate"></constructor-arg>
	</bean>
	
	<!-- 切面 -->
	<bean id="controlFlowAdvisor" 
		class="org.springframework.aop.support.DefaultPointcutAdvisor"
		p:pointcut-ref="controlFlowPointcut"
		p:advice-ref="userDaoBeforeAdvice"/>	
	
	<!-- 
		设置代理 
	-->
	<bean id="controlFlowProxy" 
		class="org.springframework.aop.framework.ProxyFactoryBean"
		p:interceptorNames="controlFlowAdvisor"
		p:target-ref="userDao"
		p:proxyTargetClass="true" />
	
	<!-- 把使用目标类的Bean交由Spring管理 -->
	<bean id="userService" class="cn.framelife.spring.service.impl.UserServiceImpl">
		<property name="userDao" ref="controlFlowProxy"></property>
	</bean>

d、测试

ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});
		UserService userService = (UserService) context.getBean("userService");
		userService.operate();
		System.out.println("----------------");
		userService.addUser();

e、结果

我是前置增强:delete
删除用户...
我是前置增强:save
保存用户...
----------------
保存用户...

3.4.6复合切面

在前面的例子中，我们所定义的切面都只有一个切点而已。有时候我们一个切面需要多个切点，也就是多个条件才能决定连接点。多个切点组成一个切点，这样的切点是复合切点。由复合切点加上增强形成的切面，称为复合切面。

a、增强类

在这里使用的是3.3.2的前置增强：

http://blog.csdn.net/p_3er/article/details/9239925

b、一个普通类中有一个获取Pointcut的方法

public class MyPointcut {
//获取Pointcut的方法名是get开头
	public Pointcut getMyComposablePointcut(){
		//创建一个复合切点
		ComposablePointcut cp = new ComposablePointcut();

		//创建一个流程切点（参数：使用类、类中的方法）这里使用的是3.4.5中的UserServiceImpl类
		Pointcut pt1 = new ControlFlowPointcut(UserServiceImpl.class,"operate");
		
		//创建一个静态方法切点
		Pointcut pt2 = new StaticMethodMatcherPointcut() {
			public boolean matches(Method method, Class<?> clazz) {
				return UserDaoImpl.class.isAssignableFrom(clazz)&&method.getName().equals("delete");
			}
		};

		//两个切点进行交集操作.
		return cp.intersection(pt1).intersection(pt2);
	}
}

c、配置

<!-- 增强Bean -->
	<bean id="userDaoBeforeAdvice" class="cn.framelife.spring.advice.UserDaoBeforeAdvice"></bean>

	<!-- 目标Bean -->
	<bean id="userDao" class="cn.framelife.spring.dao.impl.UserDaoImpl"></bean>
	
	<!-- 切点所在类 -->
	<bean id="myPoincut" class="cn.framelife.spring.pointcut.MyPointcut"></bean>
	
	<!-- 
		切面
		p:pointcut #{ myPoincut.myComposablePointcut} 是由MyPointcut的getMyComposablePointcut方法获取的
	-->
	<bean id="composableAdvisor" 
		class="org.springframework.aop.support.DefaultPointcutAdvisor"
		p:pointcut="#{ myPoincut.myComposablePointcut}"
		p:advice-ref="userDaoBeforeAdvice"/>	
	
	<!-- 
		设置代理 
	-->
	<bean id="composableProxy" 
		class="org.springframework.aop.framework.ProxyFactoryBean"
		p:interceptorNames="composableAdvisor"
		p:target-ref="userDao"
		p:proxyTargetClass="true" />
	
	<!-- 把使用目标类的Bean交由Spring管理 -->
	<bean id="userService" class="cn.framelife.spring.service.impl.UserServiceImpl">
		<property name="userDao" ref="composableProxy"></property>
	</bean>

d、测试

ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});
		UserService userService = (UserService) context.getBean("userService");
		userService.operate();

e、结果

我是前置增强:delete
删除用户...
保存用户...

3.4.7引介切面

a、使用3.3.6引介增强里面的东西（接口与增强类）

http://blog.csdn.net/p_3er/article/details/9239925

b、配置

<!-- 目标Bean -->
	<bean id="userDao" class="cn.framelife.spring.dao.impl.UserDaoImpl"></bean>
	
	<!-- 
		切面
		constructor-arg 设置引介增强
	-->
	<bean id="introductionAdvisor" 
		class="org.springframework.aop.support.DefaultIntroductionAdvisor">
		<constructor-arg>
			<bean class="cn.framelife.spring.advice.IntroductionAdvice"></bean>
		</constructor-arg>
	</bean>	
	
	<!-- 
		设置代理 
	-->
	<bean id="incluctionProxy" 
		class="org.springframework.aop.framework.ProxyFactoryBean"
		p:interceptorNames="introductionAdvisor"
		p:target-ref="userDao"
		p:proxyTargetClass="true" />

c、测试

ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});
		UserDao userDao = (UserDao) context.getBean("aProxy");
		userDao.save();
		
		System.out.println("-------------");
		
		AInterface a = (AInterface)userDao;
		a.say();
		
		System.out.println("-------------");
		userDao.save();

d、结果

方法执行前执行
org.springframework.aop.framework.Cglib2AopProxy$CglibMethodInvocation
save
保存用户...
方法执行后执行
-------------
方法执行前执行
org.springframework.aop.framework.Cglib2AopProxy$CglibMethodInvocation
say
UserDao要说话
方法执行后执行
-------------
方法执行前执行
org.springframework.aop.framework.Cglib2AopProxy$CglibMethodInvocation
save
保存用户...
方法执行后执行

s112322341

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第三章 AOP 通过Java API创建切面

在前面使用增强的时候，我们发现增强会被织入到目标类的所有的方法中。我们如果把增强织入到目标类的特定的方法中，需要使用切点进行目标连接点的定位。然后我们可以通过切点及增强生成一个切面了。3.4.1切点类型静态方法切点：org.springframework.aop.support.StaticMethodMatcherPointcut动态方法切点：org.spr...
复制链接

扫一扫