Spring AOP+AspectJ在XML配置例項(詳解)

阿新 • • 發佈：2019-01-06

在本教程中，我們將向你展示如何轉換上章節中轉成基於XML的配置。對於那些不喜歡註釋，使用JDK1.4，則可以基於XML，而不使用 AspectJ。再次回顧上個 customerBo 介面中的幾個方法，以後你將學會如何在 XML檔案實現 AspectJ 攔截。

File:CustomerBo.java

public interface CustomerBo {

	void addCustomer();
	
	String addCustomerReturnValue();
	
	void addCustomerThrowException() throws Exception;
	
	void addCustomerAround(String name);
}

File:CustomerBoImpl.java

public class CustomerBoImpl implements CustomerBo{

	@Override
	public void addCustomer() {
		System.out.println("addCustomer() is running");
	}

	@Override
	public String addCustomerReturnValue() {
		System.out.println("addCustomerReturnValue() is running");
		return "abc";
	}

	@Override
	public void addCustomerThrowException() throws Exception {
		System.out.println("addCustomerThrowException() is running");
		throw new Exception("Error");
	}

	@Override
	public void addCustomerAround(String name) {
		System.out.println("addCustomerAround() is running, args: " + name);
	}

}

1. AspectJ <aop:before> = @Before

File:LoggingAspect.java

public class LoggingAspect {

	public void logBefore() {
		System.out.println("logBefore() is running!");
		System.out.println("******");
	}
}

File:applicationContext.xml

在XML同等功能，使用 <aop:before>.

<?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:aop="http://www.springframework.org/schema/aop"	
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd">
	
	<aop:aspectj-autoproxy/>
	
	<bean id="customerBo" class="com.ray.customer.bo.impl.CustomerBoImpl"/>
	
	<!-- Aspect -->
	<bean id="logAspect" class="com.ray.aspect.LoggingAspect"/>
	
	<aop:config>
		<aop:aspect id="aspectLogging" ref="logAspect">
			<!-- @Before -->
			<aop:pointcut expression="execution(* com.ray.customer.bo.CustomerBo.addCustomer(..))" id="pointCutBefore"/>
			<aop:before method="logBefore" pointcut-ref="pointCutBefore"/>
		</aop:aspect>
	</aop:config>
</beans>

執行程式

public class Test {

	public static void main(String[] args) throws Exception {
		
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		CustomerBo customer = (CustomerBo) context.getBean("customerBo");
		customer.addCustomer();
	}
}

執行結果

logBefore() is running!
******
addCustomer() is running

2. AspectJ <aop:after> = @After

File:LoggingAspect.java

public class LoggingAspect {

	public void logAfter() {
		System.out.println("logAfter() is running!");
		System.out.println("******");
	}
}

File:applicationContext.xml

在XML同等功能，使用 <aop:after>實現。

<?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:aop="http://www.springframework.org/schema/aop"	
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd">
	
	<aop:aspectj-autoproxy/>
	
	<bean id="customerBo" class="com.ray.customer.bo.impl.CustomerBoImpl"/>
	
	<!-- Aspect -->
	<bean id="logAspect" class="com.ray.aspect.LoggingAspect"/>
	
	<aop:config>
		<aop:aspect id="aspectLogging" ref="logAspect">
			<!-- @After -->
			<aop:pointcut expression="execution(* com.ray.customer.bo.CustomerBo.addCustomer(..))" id="pointCutAfter"/>
			<aop:after method="logAfter" pointcut-ref="pointCutAfter"/>
		</aop:aspect>
	</aop:config>
</beans>

執行結果

addCustomer() is running
logAfter() is running!
******

3. AspectJ <aop:after-returning> = @AfterReturning

File:LoggingAspect.java

public class LoggingAspect {

	public void logAfterReturning(JoinPoint jp,Object result) {
		System.out.println();
		System.out.println("logAfterReturning() is running!");
		System.out.println("getName(): " + jp.getSignature().getName());
		System.out.println("Method returned value is : " + result);
		System.out.println("******");
	}
}

File:applicationContext.xml

在XML同等功能 - 使用 <aop:after-returning>.

<?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:aop="http://www.springframework.org/schema/aop"	
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd">
	
	<aop:aspectj-autoproxy/>
	
	<bean id="customerBo" class="com.ray.customer.bo.impl.CustomerBoImpl"/>
	
	<!-- Aspect -->
	<bean id="logAspect" class="com.ray.aspect.LoggingAspect"/>
	
	<aop:config>
		<aop:aspect id="aspectLogging" ref="logAspect">
			<!-- @AfterReturning -->
			<aop:pointcut expression="execution(* com.ray.customer.bo.CustomerBo.addCustomerReturnValue(..))" id="pointCutAfterReturning"/>
			<aop:after-returning method="logAfterReturning" pointcut-ref="pointCutAfterReturning" returning="result"/>
		</aop:aspect>
	</aop:config>
</beans>

執行程式

public class Test {

	public static void main(String[] args) throws Exception {
		
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		CustomerBo customer = (CustomerBo) context.getBean("customerBo");
		customer.addCustomerReturnValue();
	}
}

執行結果

addCustomerReturnValue() is running

logAfterReturning() is running!
getName(): addCustomerReturnValue
Method returned value is : abc
******

4. AspectJ <aop:after-throwing> = @AfterThrowing

File:LoggingAspect.java

public class LoggingAspect {

	public void logAfterThrowing(JoinPoint jp,Throwable error) {
		System.out.println();
		System.out.println("logAfterThrowing() is running!");
		System.out.println("getName() : " + jp.getSignature().getName());
		System.out.println("Exception : " + error);
		System.out.println("******");
	}
}

File:applicationContext.xml

在XML同等功能 - 使用 <aop:after-throwing>.

<?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:aop="http://www.springframework.org/schema/aop"	
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd">
	
	<aop:aspectj-autoproxy/>
	
	<bean id="customerBo" class="com.ray.customer.bo.impl.CustomerBoImpl"/>
	
	<!-- Aspect -->
	<bean id="logAspect" class="com.ray.aspect.LoggingAspect"/>
	
	<aop:config>
		<aop:aspect id="aspectLogging" ref="logAspect">
			<!-- @AfterThrowing -->
			<aop:pointcut expression="execution(* com.ray.customer.bo.CustomerBo.addCustomerThrowException(..))" id="pointCutAfterThrowing"/>
			<aop:after-throwing method="logAfterThrowing" pointcut-ref="pointCutAfterThrowing" throwing="error"/>
		</aop:aspect>
	</aop:config>
</beans>

執行程式

public class Test {

	public static void main(String[] args) throws Exception {
		
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		CustomerBo customer = (CustomerBo) context.getBean("customerBo");
		customer.addCustomerThrowException();
	}
}

執行結果

addCustomerThrowException() is running

logAfterThrowing() is running!
getName() : addCustomerThrowException
Exception : java.lang.Exception: Error
******
Exception in thread "main" java.lang.Exception: Error
	at com.ray.customer.bo.impl.CustomerBoImpl.addCustomerThrowException(CustomerBoImpl.java:21)

5. AspectJ <aop:after-around> = @Around

File:LoggingAspect.java

public class LoggingAspect {

	public void logAround(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("logAround() is running!");
		System.out.println("getName(): " + pjp.getSignature().getName());
		
		System.out.println("before is running!");
		pjp.proceed();
		System.out.println("after is running!");
		System.out.println("******");
	}
}

File:applicationContext.xml

在XML同等功能 - 使用 <aop:after-around>.

<?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:aop="http://www.springframework.org/schema/aop"	
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd">
	
	<aop:aspectj-autoproxy/>
	
	<bean id="customerBo" class="com.ray.customer.bo.impl.CustomerBoImpl"/>
	
	<!-- Aspect -->
	<bean id="logAspect" class="com.ray.aspect.LoggingAspect"/>
	
	<aop:config>
		<aop:aspect id="aspectLogging" ref="logAspect">
			<!-- @Around -->
			<aop:pointcut expression="execution(* com.ray.customer.bo.CustomerBo.addCustomerAround(..))" id="pointCutAround"/>
			<aop:around method="logAround" pointcut-ref="pointCutAround"/>
		</aop:aspect>
	</aop:config>
</beans>

執行程式

public class Test {

	public static void main(String[] args) throws Exception {
		
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		CustomerBo customer = (CustomerBo) context.getBean("customerBo");
		customer.addCustomerAround("ray");
	}
}

執行結果

logAround() is running!
getName(): addCustomerAround
before is running!
addCustomerAround() is running, args: ray
after is running!
******

完整的 XML 例項

File:LoggingAspect.java

package com.ray.aspect;

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

public class LoggingAspect {

	public void logBefore(JoinPoint joinPoint) {

		System.out.println("logBefore() is running!");
		System.out.println("getName() : " + joinPoint.getSignature().getName());
		System.out.println("******");
	}

	public void logAfter(JoinPoint joinPoint) {

		System.out.println("logAfter() is running!");
		System.out.println("getName() : " + joinPoint.getSignature().getName());
		System.out.println("******");

	}
	
	public void logAfterReturning(JoinPoint joinPoint, Object result) {

		System.out.println("logAfterReturning() is running!");
		System.out.println("getName() : " + joinPoint.getSignature().getName());
		System.out.println("Method returned value is : " + result);
		System.out.println("******");

	}
	
	public void logAfterThrowing(JoinPoint joinPoint, Throwable error) {

		System.out.println("logAfterThrowing() is running!");
		System.out.println("getName() : " + joinPoint.getSignature().getName());
		System.out.println("Exception : " + error);
		System.out.println("******");

	}
	
	public void logAround(ProceedingJoinPoint joinPoint) throws Throwable {

		System.out.println("logAround() is running!");
		System.out.println("getName() : " + joinPoint.getSignature().getName());
		System.out.println("getArgs() : " + Arrays.toString(joinPoint.getArgs()));
		
		System.out.println("Around before is running!");
		joinPoint.proceed();
		System.out.println("Around after is running!");
		
		System.out.println("******");

	}
	
}

File:applicationContext.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:aop="http://www.springframework.org/schema/aop"	
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd">
	
	<aop:aspectj-autoproxy/>
	
	<bean id="customerBo" class="com.ray.customer.bo.impl.CustomerBoImpl"/>
	
	<!-- Aspect -->
	<bean id="logAspect" class="com.ray.aspect.LoggingAspect"/>
	
	<aop:config>
		<aop:aspect id="aspectLoggging" ref="logAspect" >

			<!-- @Before -->
			<aop:pointcut id="pointCutBefore"
				expression="execution(* com.ray.customer.bo.CustomerBo.addCustomer(..))" />

			<aop:before method="logBefore" pointcut-ref="pointCutBefore" />
			
			<!-- @After -->
			<aop:pointcut id="pointCutAfter"
				expression="execution(* com.ray.customer.bo.CustomerBo.addCustomer(..))" />

			<aop:after method="logAfter" pointcut-ref="pointCutAfter" />
			
			<!-- @AfterReturning -->
			<aop:pointcut id="pointCutAfterReturning"
				expression="execution(* com.ray.customer.bo.CustomerBo.addCustomerReturnValue(..))" />

			<aop:after-returning method="logAfterReturning" returning="result" 
				pointcut-ref="pointCutAfterReturning" />
			
			
			<!-- @AfterThrowing -->
			<aop:pointcut id="pointCutAfterThrowing"
				expression="execution(* com.ray.customer.bo.CustomerBo.addCustomerThrowException(..))" />
			
			<aop:after-throwing method="logAfterThrowing" throwing="error" 
				pointcut-ref="pointCutAfterThrowing"  />
			
			
			<!-- @Around -->
			<aop:pointcut id="pointCutAround"
				expression="execution(* com.ray.customer.bo.CustomerBo.addCustomerAround(..))" />
			<aop:around method="logAround" pointcut-ref="pointCutAround"  />
		</aop:aspect>

	</aop:config>
</beans>

測試程式

package com.ray.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ray.customer.bo.CustomerBo;

public class Test {

	public static void main(String[] args) throws Exception {

		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		CustomerBo customer = (CustomerBo) context.getBean("customerBo");

//		customer.addCustomer();

//		customer.addCustomerReturnValue();

//		customer.addCustomerThrowException();

		customer.addCustomerAround("ray");
	}
}

Spring AOP+AspectJ在XML配置例項(詳解)

在本教程中，我們將向你展示如何轉換上章節中轉成基於XML的配置。對於那些不喜歡註釋，使用JDK1.4，則可以基於XML，而不使用 AspectJ。再次回顧上個 customerBo 介面中的幾個方法，以後你將學會如何在 XML檔案實現 AspectJ 攔截。File:Cus

Spring Boot基礎教程 ( 四 ) ：Spring Boot 屬性配置檔案詳解

相信很多人選擇Spring Boot主要是考慮到它既能兼顧Spring的強大功能，還能實現快速開發的便捷。我們在Spring Boot使用過程中，最直觀的感受就是沒有了原來自己整合Spring應用時繁多的XML配置內容，替代它的是在pom.xml中引入模組化的Starter

Spring Boot 核心配置檔案詳解

用過 Spring Boot 的都知道在 Spring Boot 中有以下兩種配置檔案 bootstrap (.yml 或者 .properties) application (.yml 或者 .properties) 為什麼會有這兩種配置檔案呢？大家

Spring-boot-admin配置屬性詳解

使用到了springbootAdmin這個工具，但是有關它們的配置不太理解。下面是我對照著官網的說明以及自己的理解總結的，如果有不正確的地方歡迎大家指正。（我這裡只是在springboot中使用了SBA，還沒有涉及到其它更加高階的spring cloud等。這裡的屬性也只是最

Spring AOP面向切面程式設計詳解(基於XML方式註解方式注入Aspectj方式)

前言 AOP即面向切面程式設計，是一種程式設計思想，OOP的延續。在程式開發中主要用來解決一些系統層面上的問題，比如日誌，事務，許可權等等。在閱讀本文前希望您已經對Spring有一定的瞭解注:在能對程式碼進行添加註解方式實現AOP的話，並不推薦使用XML方

Spring Boot屬性配置檔案詳解

相信很多人選擇Spring Boot主要是考慮到它既能兼顧Spring的強大功能，還能實現快速開發的便捷。我們在Spring Boot使用過程中，最直觀的感受就是沒有了原來自己整合Spring應用時繁多的XML配置內容，替代它的是在pom.xml中引入模組化的Starte

Spring Boot 屬性配置檔案詳解

SpringBoot 配置檔案預設為application.properties，但現在的趨勢是使用yaml，它是類似於標準通用標記語言的子集XML的資料描述語言，語法比XML簡單很多。applicat

Nginx負載均衡配置例項詳解

負載均衡是我們大流量網站要做的一個東西，下面我來給大家介紹在Nginx伺服器上進行負載均衡配置方法。測試環境測試域名：www.threegroup.space A伺服器IP ：123.56.255.173 （主） B伺服器IP ：101.200.159.138 C

spring security 概述& 配置檔案詳解

通常，安全任務是由應用伺服器完成使用者認證和對資源的授權，這些任務也可以委託給Spring security處理這些任務從而減輕應用伺服器負擔，Spring安全基本上通過實施標準的javax.servlet.Filter來處理這些任務，您需要宣告下面的過濾器在web.xm

Spring AOP 例項詳解

目錄 AOP概念 AOP核心概念 Spring對AOP的支援基於Spring的AOP簡單實現基於Spring的AOP使用其他細節 AOP概念 AOP（Aspect Oriented Programming），即面向切面程式設計，可以說是OOP（Object Oriented

Spring學習----------AOP以及Spring配置檔案詳解

之前有寫了Spring的一個特性IOC，現在在來寫Spring的另一個特性AOP，AOP中個一些概念，看了網路上的講解AOP的文章，講的都很正確，可是不是很好理解，我在來寫一點，可能不太精確，但理解容易點。AOP是用動態代理（裝飾模式），解決橫切行問

轉：ssm spring+springmvc+mybatis中的xml配置檔案詳解

這幾天一直在整合SSM框架,雖然網上有很多已經整合好的,但是對於裡面的配置檔案並沒有進行過多的說明,很多人知其然不知其所以然,經過幾天的搜尋和整理,今天總算對其中的XML配置檔案有了一定的瞭解,所以拿出來一起分享一下,希望有不足的地方大家批評指正~~~ 首先這篇文章暫時只對框架中所要用到的配

Spring Boot（二）配置檔案詳解

簡介 Spring Boot使用“習慣由於配置”（專案中存在大量預設的配置，而且內建tomcat）的理念，讓你的無需手動進行配置就可以將專案執行起來。使用Spring Boot很容易建立一個獨立執行的、準生產級別的Spring框架的專案。同時，Spring Boot還提供一個全域性配置檔案對一些

spring配置檔案詳解--真的蠻詳細

spring配置檔案詳解--真的蠻詳細轉自： http://book.51cto.com/art/201004/193743.htm 此處詳細的為我們講解了spring2.5的實現原理，感覺非常有用

SpringBoot非官方教程｜第二篇：Spring Boot配置檔案詳解

springboot採納了建立生產就緒Spring應用程式的觀點。 Spring Boot優先於配置的慣例，旨在讓您儘快啟動和執行。在一般情況下，我們不需要做太多的配置就能夠讓spring boot正常執行。在一些特殊的情況下，我們需要做修改一些配置，或者需要有自己的配置屬性。當我們

Spring Boot中使用MyBatis註解配置開發詳解

Spring Boot中使用MyBatis註解配置詳解原創 2018-04-03 宗野 Spring Boot 最近專案原因可能會繼續開始使用

Spring boot 配置檔案詳解 (properties 和yml )

從其他框架來看我們都有自己的配置檔案， hibernate有hbm，mybatis 有properties，同樣， Spring boot 也有全域性配置檔案。 Springboot使用一個全域性的配置檔案，而且配置檔案的名字是固定的。有兩種 application.properties

Spring Boot 配置檔案詳解：自定義屬性、隨機數、多環境配置等

相信很多人選擇Spring Boot主要是考慮到它既能兼顧Spring的強大功能，還能實現快速開發的便捷。我們在Spring Boot使用過程中，最直觀的感受就是沒有了原來自己整合Spring應用時繁多的XML配置內容，替代它的是在pom.xml中引入模組化的Starter POMs，其中各個模組都有自己的預

SpringBoot學習第二篇：Spring Boot配置檔案詳解

原文首發於：https://www.fangzhipeng.com/springboot/2017/07/11/springboot2-config-file/ 本文出自方誌朋的部落格 springboot採納了建立生產就緒Spring應用程式的觀點。 Spring Boot優先於配置的慣例，旨

Spring Boot配置檔案詳解-ConfigurationProperties和Value優缺點-（轉）好文

文章轉自 http://www.cnblogs.com/itdragon/p/8686554.html Spring Boot提供了兩種常用的配置檔案，分別是properties檔案和yml檔案。他們的作用都是修改Spring Boot自動配置的預設值。相對於properties檔案而言，yml檔

Spring AOP+AspectJ在XML配置例項(詳解)

1. AspectJ <aop:before> = @Before

2. AspectJ <aop:after> = @After

3. AspectJ <aop:after-returning> = @AfterReturning

4. AspectJ <aop:after-throwing> = @AfterThrowing

5. AspectJ <aop:after-around> = @Around

完整的 XML 例項

相關推薦