AOP面向切面编程的四种实现

一.AOP(面向切面编程)的四种实现分别为最原始的经典AOP、代理工厂bean(ProxyFacteryBean)和默认自动代理DefaultAdvisorAutoProxyCreator以及BeanNameAutoProxyCreator代理、Aspectj的注解和xml配置文件。

1.代理工厂bean(ProxyFacteryBean)的方式

1.1 接口(Interface)

1 package cn.happy.interfaces;
2
3 public interface Advice {
4
5     public void fristMethod();
6
7     public String secondMethod();
8 }

1.2 接口的实现类

1 package cn.happy.impl;
2
3 import cn.happy.interfaces.Advice;
4
5 public class AdviceImpl implements Advice {
6
7     public void fristMethod() {
8          System.out.println("==fristMethod==");
9     }
10
11     public String secondMethod() {
12         System.out.println("==secondMethod==");
13         return "abc";
14     }
15
16 }

1.3 各种通知增强

1.3.1 前置增强

1 package cn.happy.advice;
2
3 import java.lang.reflect.Method;
4
5 public class MethodBeforeAdvice implements
6         org.springframework.aop.MethodBeforeAdvice {
7
8     public void before(Method arg0, Object[] arg1, Object arg2)
9             throws Throwable {
10         System.out.println("==Before==");
11
12     }
13
14 }

1.3.2 后置增强

1 package cn.happy.advice;
2
3 import java.lang.reflect.Method;
4
5 import org.springframework.aop.AfterReturningAdvice;
6
7 public class AfterReturningAdvie implements AfterReturningAdvice {
8
9     public void afterReturning(Object arg0, Method arg1, Object[] arg2,
10             Object arg3) throws Throwable {
11         System.out.println("==After==");
12
13     }
14
15 }

1.3.3 环绕增强

package cn.happy.aroundadvice;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class MyInterceptor implements MethodInterceptor{

public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("==before==");
String result= (String)invocation.proceed();
System.out.println("==after==");
return result;
}
}

1.3.4 异常增强

package cn.happy.exception;

import org.springframework.aop.ThrowsAdvice;

public class MyException implements ThrowsAdvice {
public void afterThrowing(Exception ex){
System.out.println("异常通知");
}
}

1.4 配置文件

<?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"
xsi:schemaLocation=" 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.xsd">

<!-- 实现类的引入 -->
<bean id="adviceimpl" class="cn.happy.impl.AdviceImpl"></bean>
<!-- 前置增强  通知-->
<bean id="advicebefore" class="cn.happy.advice.MethodBeforeAdvice"></bean>
<!-- 后置增强  通知-->
<bean id="adviceafter" class="cn.happy.advice.AfterReturningAdvie"></bean>

<!-- 环绕增强 -->
<bean id="around" class="cn.happy.aroundadvice.MyInterceptor"></bean>

<!-- 关联  代理工厂bean ProxyFacteryBean 通知 -->
<!--<bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

<property name="targetName" value="adviceimpl"></property>
<property name="interceptorNames" value="advicebefore,adviceafter"></property>

</bean>-->

<!-- 环绕增强 代理工厂 顾问包装通知 -->
<bean id="aroundserviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

<property name="target" ref="adviceimpl"></property>
<property name="interceptorNames" value="beforeadvisor"></property>

</bean>

<!-- 切面  通知  -->
<bean id="beforeadvice" class="cn.happy.mymethodbefore.MyMethodBeforeAdvice"></bean>

<!-- 顾问  包装advice -->
<bean id="beforeadvisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
<property name="advice" ref="beforeadvice"></property>
<property name="mappedNames" value="fristMethod,secondMethod"></property>
</bean>

<!-- 顾问  包装advice 正则表达式-->
<!--<bean id="beforeadvisor1" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice" ref="beforeadvice"></property>
<property name="pattern" value=".*Method.*"></property>
</bean>-->

<!-- 默认自动代理  默认只找通知-->
<!--<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>-->

<!-- beanname自动代理 可以选择顾问或者通知-->
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames" value="adviceimpl"></property>
<property name="interceptorNames" value="beforeadvisor"></property>
</bean>

</beans>

1.5 测试类

package cn.happy.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.happy.interfaces.Advice;

public class Test {
/**
* 通知的前置和后置测试
*/
public static void main(String[] args) {
//解析配置文件
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
Advice advice= (Advice)ctx.getBean("adviceimpl"); //自动代理beanname的方式
advice.fristMethod();
advice.secondMethod();
}
}

2. 最原始的经典AOP

2.1 最基本分层模式dao、biz、service以及最后测试Test

2.1.1DAO层

package cn.happy.dao;

import cn.happy.entity.User;

//接口
public interface UDao {

//保存方法
public void save(User user);
}

//实现类
package cn.happy.dao;

import cn.happy.entity.User;

public class UserDaoImpl implements UDao{

public void save(User user) {
System.out.println("保存成功");
}

}

2.1.2 BIZ层

package cn.happy.biz;

import cn.happy.entity.User;

//业务接口
public interface UBiz {

//保存方法
public void save2(User user);
}

//业务实现类
package cn.happy.biz;

import cn.happy.dao.UDao;
import cn.happy.entity.User;

public class UserBiz implements UBiz{

//dao的对象
private UDao udao;
public void save2(User user) {
udao.save(user);

}
public UDao getUdao() {
return udao;
}
public void setUdao(UDao udao) {
this.udao = udao;
}

}

2.1.3 AOP模块即service层

package cn.happy.logger;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

//前置内容
public class LoggerBefore implements MethodBeforeAdvice {

public void before(Method arg0, Object[] arg1, Object arg2)
throws Throwable {
System.out.println("save前置内容");
}
}

//后置内容
package cn.happy.logger;
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;

public class LoggerAfter implements AfterReturningAdvice{

public void afterReturning(Object arg0, Method arg1, Object[] arg2,
Object arg3) throws Throwable {
System.out.println("save后置内容");
}
}

2.1.4 经典的配置文件

<?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-4.1.xsd">
<!-- 业务biz与dao接口对象的实现 -->
<bean id="dao" class="cn.happy.dao.UserDaoImpl"></bean>
<bean id="biz" class="cn.happy.biz.UserBiz">
<property name="udao" ref="dao"></property>
</bean>
<!-- 前置与后置内容的配置 -->
<bean id="before" class="cn.happy.logger.LoggerBefore"></bean>
<bean id="after" class="cn.happy.logger.LoggerAfter"></bean>
<!-- aop的配置 -->
<aop:config>
<aop:pointcut expression="execution(public void save2(cn.happy.entity.User))" id="pointcut"/>
<!-- 在切入点处插入增强处理、完成"织入" -->
<aop:advisor advice-ref="before" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="after" pointcut-ref="pointcut"/>
</aop:config>
</beans>

2.1.5 测试类

package cn.happy.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.happy.biz.UBiz;
import cn.happy.entity.User;

public class AOPTest {

public static void main(String[] args) {
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
UBiz ubiz=(UBiz)context.getBean("biz");
User user=new User();
ubiz.save2(user);
System.out.println("save~ok");
}
}

3. 然后就是Aspectj的注解以及xml配置文件的两种方式了。

3.1 Aspectj注解

3.1.1 接口和实现类

package cn.happy.impl;
//接口
public interface AspectDao {

public void add();
public void delete();
}

//实现类
package cn.happy.impl;

public class AspectjIpml implements AspectDao{
//添加
public void add() {
System.out.println("==ADD==");
}
//删除
public void delete() {
System.out.println("==DELETE==");
}
}

3.1.2 注解类Aspect

package cn.happy.aspectj;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Before;

@org.aspectj.lang.annotation.Aspect
public class Aspect {
//前置增强
@Before(value="execution(public * *(..))")
public void asBefore(){
System.out.println("这是前置增强");
}
//后置增强
@AfterReturning(value="execution(public * *(..))")
public void asAfterReturning(){
System.out.println("这是后置增强");
}
//环绕增强
@Around(value="execution(public * *(..))")
public void asAround(ProceedingJoinPoint pj){
System.out.println("这是环绕前置增强");
try {
pj.proceed();
} catch (Throwable e) {
//抓捕异常
e.printStackTrace();
}
System.out.println("这是环绕后置增强");
}
//异常增强
@AfterThrowing(value="execution(public * *(..))")
public void asThorws(){
System.out.println("这是异常增强");
}
//最终增强
@After(value="execution(public * *(..))")
public void asAfter(){
System.out.println("这是最终增强");
}
}

3.1.3 注解的配置文件

<?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/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 目标对象 -->
<bean id="aspectimpl" class="cn.happy.impl.AspectjIpml"></bean>
<!-- 增强类 -->
<bean id="aspectj" class="cn.happy.aspectj.Aspect"></bean>
<!-- 扫描整个项目 关联注解类和实现类 -->
<aop:aspectj-autoproxy />

</beans>

3.1.4 测试类

package cn.happy.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.happy.impl.AspectDao;

public class AspectjTest {
/**
* 注解测试 */
public static void main(String[] args) {
// 解析配置文件
ApplicationContext ctx = new ClassPathXmlApplicationContext(
"applicationContext.xml");
AspectDao aspect = (AspectDao) ctx.getBean("aspectimpl");
aspect.add();
aspect.delete();
}
}

4. Aspectj的XML配置法,其他的基本都一样只要修改Aspectj增强类和配置文件就行了

4.1 Aspect增强类只需将那些注解消去即可

package cn.happy.aspectj;
import org.aspectj.lang.ProceedingJoinPoint;

public class Aspect {
//前置增强
public void asBefore(){
System.out.println("这是前置增强");
}
//后置增强
public void asAfterReturning(){

System.out.println("这是后置增强");
}
//环绕增强
public void asAround(ProceedingJoinPoint pj){
System.out.println("这是环绕前置增强");
try {
pj.proceed();
} catch (Throwable e) {
//抓捕异常
e.printStackTrace();
}
System.out.println("这是环绕后置增强");
}
//异常增强
public void asThorws(){

System.out.println("这是异常增强");
}
//最终增强
public void asAfter(){

System.out.println("这是最终增强");
}
}

4.2 XML的配置文件会稍微会复杂一点,但大致的还是跟对原始的经典aop实现方式相同

<?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/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 目标对象 -->
<bean id="aspectimpl" class="cn.happy.impl.AspectjIpml"></bean>
<!-- 增强类 -->
<bean id="aspectj" class="cn.happy.aspectj.Aspect"></bean>
<!-- Aspectj的XML配置文件 -->
<aop:config>
<aop:pointcut expression="execution(public * *(..))" id="pointcut"/>
<aop:aspect ref="aspectj">
<aop:before method="asBefore" pointcut-ref="pointcut"/>
<aop:after-returning method="asAfterReturning" pointcut-ref="pointcut"/>
<aop:after-returning method="asAround(org.aspectj.lang.ProceedingJoinPoint)" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
</beans>

好了，这就是AOP(面向切面编程)的四种实现方式了。希望你们看了之后能让你们对AOP面向切面编程思想有更深的了解。