Spring_AOP_XML使用Aspect实现动态代理(常用)

Spring_AOP_XML使用Aspect实现动态代理(常用)

XML使用Aspect实现动态代理此方式比较常用,和使用注解最大的好处是我们不用每个方法前面定义横切点上面加入PointCut的说明,在XML中只需要定义一次就可以多出使用。

在上面Spring_AOP_Annotation使用Aspect实现动态代理的基础上修改,去除LogAspect中方法上的注解。

XML文件配置:

<?xml version="1.0" encoding="UTF-8"?>
<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/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">

	<!-- 打开Spring的Annotation的支持 -->
	<context:annotation-config />
	<!-- 设定Spring去哪些包中找Annotation -->
	<context:component-scan base-package="com.spring" />
	<!-- 打开基于Annotation的aop自动代理 -->
	<aop:aspectj-autoproxy />

	<aop:config>
		<!-- 定义切面 -->
		<aop:aspect id="myLogAspect" ref="logAspect">
		<!-- 在哪些位置加入相应的Aspect -->
			<aop:pointcut id="logPointCut"
				expression="execution(* com.spring.dao.*.add*(..))||
				execution(* com.spring.dao.*.update*(..))||
				execution(* com.spring.dao.*.delete*(..))" />
			<!-- 开始之前加入日志 -->
			<aop:before method="logStart" pointcut-ref="logPointCut" />
			<!-- 结束之后加入日志 -->
			<aop:after method="logEnd" pointcut-ref="logPointCut" />
			<!-- 执行过程中加入日志 -->
			<aop:around method="logAround" pointcut-ref="logPointCut"/>
		</aop:aspect>
	</aop:config>

</beans>

LogAspect类:

package com.spring.proxy;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

//让这个切面类被Spring所管理
@Component("logAspect")
// 声明这是一个切面类
@Aspect
public class LogAspect {

	public void logStart(JoinPoint jp) {
		// 得到执行的对象
		System.out.println(jp.getTarget());
		// 得到执行的方法
		System.out.println(jp.getSignature().getName());
		Logger.info("方法执行前加入日志,来自LogAspect");
	}

	public void logEnd(JoinPoint jp) {
		// 得到执行的对象
		System.out.println(jp.getTarget());
		// 得到执行的方法
		System.out.println(jp.getSignature().getName());
		Logger.info("方法执行后加入日志,来自LogAspect");
	}

	public void logAround(ProceedingJoinPoint pjp) throws Throwable {
		Logger.info("开始在Around中加入日志,来自LogAspect");
		//执行程序
		pjp.proceed();
		Logger.info("结束Around");
	}
}

测试代码及测试结果:

时间: 2024-08-13 19:57:15

Spring_AOP_XML使用Aspect实现动态代理(常用)的相关文章

Spring_AOP_Annotation使用Aspect实现动态代理

spring_aop_annotation 的实现: 1.1在beans.xml中加入aop的schema 1.2在xml中打开aop的自动检索 <aop:aspectj-autoproxy/> 1.3创建一个需要实现动态代理的类 1.4导入aspectj包,Spring使用的是aspect这个包来实现AOP,所以需要导入这个包. Maven之pom.xml : <dependency> <groupId>org.aspectj</groupId> <

使用 Java AOP API 完成动态代理的一些注意事项

代码示例 Java原生API中,动态代理常用的API有两个:InvocationHandler接口和Proxy类 首先上代码StaffLoggerAspect.java public class StaffLoggerAspect implements InvocationHandler { Object target; public Object getObject(Object object) { target = object; return Proxy.newProxyInstance(

常用设计模式之代理(动态代理)

常用设计模式之代理(动态代理) UML Code1 1 interface Subject{void doSth();} 2 class RealSubject implements Subject{ 3 public void doSth(){ 4 System.out.println("RealSubject doSth...."); 5 } 6 } 7 class ProxyHandler implements InvocationHandler 8 { 9 private Ob

【转载】Java JDK 动态代理(AOP)使用及实现原理分析

转自:http://blog.csdn.net/jiankunking/article/details/52143504 版权声明:作者:jiankunking 出处:http://blog.csdn.net/jiankunking 本文版权归作者和CSDN共有 一.什么是代理? 代理是一种常用的设计模式,其目的就是为其他对象提供一个代理以控制对某个对象的访问.代理类负责为委托类预处理消息,过滤消息并转发消息,以及进行消息被委托类执行后的后续处理. 代理模式UML图: 简单结构示意图: 为了保持

java动态代理原理及解析

代理:设计模式 代理模式是一种常用的设计模式,其目的就是为其他对象提供一个代理以控制对某个真实对象的访问.代理类负责为委托类预处理消息,过滤消息并转发消息,以及进行消息被委托类执行后的后续处理. 通过代理层这一中间层,有效的控制对于真实委托类对象的直接访问,同时可以实现自定义的控制策略(Spring的AOP机制),设计上获得更大的灵活性. java动态代理的类和接口(jdk1.6源码) 1,java.lang.reflect.Proxy:动态代理机制的主类,提供一组静态方法为一组接口动态的生成对

Atitit 代理CGLIB&#160;动态代理&#160;AspectJ静态代理区别

Atitit 代理CGLIB 动态代理 AspectJ静态代理区别 1.1. AOP 代理主要分为静态代理和动态代理两大类,静态代理以 AspectJ 为代表:而动态代理则以 spring AOP 为代表 1 1.2. JDK动态代理是模拟接口实现的方式,cglib是模拟子类继承的方式1 1.3. CGLIB代理模式的缺点 在static和final方法上应用横切关注点也是无法做到的.2 1.1. AOP 代理主要分为静态代理和动态代理两大类,静态代理以 AspectJ 为代表:而动态代理则以 

Spring之AOP原理_动态代理

面向方面编程(Aspect Oriented Programming,简称AOP)是一种声明式编程(Declarative Programming).声明式编程是和命令式编程(Imperative Programming)相对的概念.我们平时使用的编程语言,比如C++.Java.Ruby.Python等,都属命令式编程.命令式编程的意思是,程序员需要一步步写清楚程序需要如何做什么(How to do What).声明式编程的意思是,程序员不需要一步步告诉程序如何做,只需要告诉程序在哪些地方做什么

java动态代理【二】:JDK动态代理的内部原理

上一章我们简单的讲解了什么是动态代理和如何使用动态代理. 这章讲解一下jdk的动态代理的内部实现: 首先查看测试代码: //创建一个静态方法,生成代理类, public static Object newProxyInstance(Object speak){ System.out.println(JDKDynamicProxy.class.getClassLoader().toString()); return Proxy.newProxyInstance(JDKDynamicProxy.cl

Java动态代理 深度详解

代理模式是设计模式中非常重要的一种类型,而设计模式又是编程中非常重要的知识点,特别是在业务系统的重构中,更是有举足轻重的地位.代理模式从类型上来说,可以分为静态代理和动态代理两种类型. 今天我将用非常简单易懂的例子向大家介绍动态代理的两种类型,接着重点介绍动态代理的两种实现方式(Java 动态代理和 CGLib 动态代理),最后深入剖析这两种实现方式的异同,最后说说动态代理在我们周边框架中的应用. 在开始之前,我们先假设这样一个场景:有一个蛋糕店,它们都是使用蛋糕机来做蛋糕的,而且不同种类的蛋糕