这篇文章主要介绍了两种spring aop的实现方式代码分享,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
1.手动实现aop编程(代理模式)
aop是面向切面的编程,主要功能就是实现业务代码和辅助业务代码的关注点代码分离.在一个方法中,出了核心的业务代码,其他的都叫做关注点代码.举个往数据库保存数据的例子:
// 保存一个用户
public void add(user user) {
session session = null;
transaction trans = null;
try {
session = hibernatesessionfactoryutils.getsession(); // 【关注点代码】
trans = session.begintransaction(); // 【关注点代码】
session.save(user); // 核心业务代码
trans.commit(); //…【关注点代码】
} catch (exception e) {
e.printstacktrace();
if(trans != null){
trans.rollback(); //..【关注点代码】
}
} finally{
hibernatesessionfactoryutils.closesession(session); ////..【关注点代码】
}
}
在上面的代码中,如果有多个方法,就需要写多个重复的关注点代码,这样做的不好的,可以把经常重复的代码抽取出来,然后在代码中只需要在在方法中写核心业务代码,在运行该方法时,会自动执行抽取出来的关注点代码.是实现这样的效果,最好的方法就是使用代理模式,而事实上,aop编程主要就是使用代理模式来实现核心代码和关注点代码的分离的.
手动的实现aop跟前面代理模式实现的方式是一样的,这样就不再贴出来了.
2.aop编程aop:aspect object programming 面向切面编程
功能是让关注点和业务无代码分离
关注点:重复的代码就叫做关注点.
切面:关注点形成的类,就叫切面(类)
面向切面编程,就是指对很多功能都有的重复的代码抽取,再在运行的时候往业务方法中动态植入"切面类代码"
切入点:
执行目标对象方法,动态植入切面代码.可以通过切入点表达式,指定拦截哪些类的哪些方法,给指定的类在运行的时候植入切面类代码
2.1.注解方式实现实现步骤:
1.引入aop相关jar包,一共四个
spring-aop-3.2.5.release.jar
aopalliance.jar
aspectjweaver.jar
aspectjrt.jar
注意:用到spring2.5版本中的jar文件时,如果再用jdk1.7可能会有问题,需要升级aspectj组件,即使用aspectj-1.8.2版本中提供的jar文件.
2.bean.xml中引入aop名称空间
xmlns:aop="http://www.springframework.org/schema/aop"
3.开始aop注解扫描
<!-- 开启注解扫描 -->
<context:component-scan base-package="e_aop_anno"></context:component-scan>
<!-- 开启aop注解方式 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
4.使用注解来实现
@aspect:指定当前类为切面类.
@pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))") :指定切入点表达式
@before("pointcut_()"): 前置通知:在目标方法之前执行
@after("pointcut_()"):后置通知:目标方法之后执行(如果拦截到,则始终执行)
@afterreturning("pointcut_()"):返回后通知:执行方法结束后执行(异常不执行),@after()之后执行.
@afterthrowing("pointcut_()"):异常通知:出现异常时候执行
@around("pointcut_()"):环绕通知:环绕目标方法执行
代码示例:
目标对象分两个,一个是实现接口iuserdao的userdao对象和一个没有实现接口的orderdao对象.然后是抽取出来的切面类aop,spring的配置文件bean.xml,以及测试类app
接口iuserdao.java
// 接口
public interface iuserdao {
void save();
}
实现接口的:userdao.java
/**
* 目标对象
*/
@component // 加入容器
public class userdao implements iuserdao{
@override
public void save() {
system.out.println("-----核心业务：保存！！！------");
}
}
不实现任何接口的orderdao.java
/**
* 目标对象
*/
@component // 加入容器
@scope("prototype")
public class orderdao{
public void save() {
system.out.println("-----核心业务：保存！！！------");
}
}
spring的配置文件bean.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/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">
<!-- 开启注解扫描 -->
<context:component-scan base-package="e_aop_anno"></context:component-scan>
<!-- 开启aop注解方式 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy></beans>
抽取出来的切面对象aop.java
@component
@aspect // 指定当前类为切面类
public class aop {
// 指定切入点表单式： 拦截哪些方法； 即为哪些类生成代理对象
@pointcut("execution(* e_aop_anno.*.*(..))")
// @pointcut("execution(* e_aop_anno.userdao.save(..))")//只拦截userdao中的save()方法
public void pointcut_(){
}
// 前置通知 : 在执行目标方法之前执行
@before("pointcut_()") public void begin(){
system.out.println("开始事务/异常");
}
// 后置/最终通知：在执行目标方法之后执行 【无论是否出现异常最终都会执行】
@after("pointcut_()") public void after(){
system.out.println("提交事务/关闭");
}
// 返回后通知： 在调用目标方法结束后执行 【出现异常不执行】
@afterreturning("pointcut_()") public void afterreturning() {
system.out.println("afterreturning()");
} // 异常通知： 当目标方法执行异常时候执行此关注点代码
@afterthrowing("pointcut_()")
public void afterthrowing(){
system.out.println("afterthrowing()");
}
// 环绕通知：环绕目标方式执行
@around("pointcut_()")
public void around(proceedingjoinpoint pjp) throws throwable{
system.out.println("环绕前....");
pjp.proceed(); // 执行目标方法
system.out.println("环绕后....");
}
}
测试类app.java
public class app {
applicationcontext ac =
new classpathxmlapplicationcontext("e_aop_anno/bean.xml");
// 目标对象有实现接口，spring会自动选择“jdk代理”,userdao是实现了接口
@test
public void testapp() {
iuserdao userdao = (iuserdao) ac.getbean("userdao");
system.out.println(userdao.getclass());//$proxy001
userdao.save();
} // 目标对象没有实现接口， spring会用“cglib代理”,orderdao没有实现接口
@test
public void testcglib() {
orderdao orderdao = (orderdao) ac.getbean("orderdao");
system.out.println(orderdao.getclass());
orderdao.save();
} @test
public void testgetobj() throws exception {
orderdao orderdao1 = (orderdao) ac.getbean("orderdao");
orderdao orderdao2 = (orderdao) ac.getbean("orderdao");
system.out.println(orderdao1);//e_aop_anno.orderdao@5b295b
system.out.println(orderdao2);//e_aop_anno.orderdao@1e5f737
system.out.println(orderdao1==orderdao2);//false
}
}
测试结果:
testapp()和testcglib()的测试结果为:
//测试输出环绕前....
开始事务/异常
-----核心业务：保存！！！------
环绕后....
提交事务/关闭afterreturning()
2.2.xml配置方式实现使用xml配置方法来实现aop编程的步骤:
1.引入jar文件
同注解实现aop中的四个一样
2.引入aop名称空间
同注解实现aop中
3.aop配置
配置主要有两部分组成,一个是各种实例对象的创建,一个是aop的配置(拦截哪些方法/拦截到方法后应用通知代码)
代码示例:
同注解方式中的代码是差不多的,两个对象,分别是实现了接口的userdao和没有实现任何接口的orderdao.这个两个类跟上面是一样的,没有做改变,改变是在aop切面类中以及bean.xml的配置中.测试类也没有做改变
userdao.java和orderdoa.java不在显示.
切面类aop.java代码:
// 切面类public class aop { public void begin(){
system.out.println("开始事务/异常");
} public void after(){
system.out.println("提交事务/关闭");
} public void afterreturning() {
system.out.println("afterreturning()");
} public void afterthrowing(){
system.out.println("afterthrowing()");
} public void around(proceedingjoinpoint pjp) throws throwable{
system.out.println("环绕前....");
pjp.proceed(); // 执行目标方法
system.out.println("环绕后....");
}
}
注意没有注解了.
配置文件bean.xml
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/xmlscheminstance" 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">
<!-- dao 实例 -->
<bean id="userdao" class="f_aop_xml.userdao"></bean>
<bean id="orderdao" class="f_aop_xml.orderdao"></bean>
<!-- 切面类 -->
<bean id="aop" class="f_aop_xml.aop"></bean>
<!-- aop配置 -->
<aop:config>
<!-- 定义一个切入点表达式： 拦截哪些方法 -->
<aop:pointcut expression="execution(* f_aop_xml.*.*(..))" id="pt"/>
<!-- 切面 -->
<aop:aspect ref="aop">
<!-- 环绕通知 -->
<aop:around method="around" pointcut-ref="pt"/>
<!-- 前置通知： 在目标方法调用前执行 -->
<aop:before method="begin" pointcut-ref="pt"/>
<!-- 后置通知： -->
<aop:after method="after" pointcut-ref="pt"/>
<!-- 返回后通知 -->
<aop:after-returning method="afterreturning" pointcut-ref="pt"/>
<!-- 异常通知 -->
<aop:after-throwing method="afterthrowing" pointcut-ref="pt"/>
</aop:aspect>
</aop:config></beans>
测试类:app.java
public class app {
applicationcontext ac = new classpathxmlapplicationcontext("f_aop_xml/bean.xml"); // 目标对象有实现接口，spring会自动选择“jdk代理”
@test
public void testapp() {
iuserdao userdao = (iuserdao) ac.getbean("userdao");
system.out.println(userdao.getclass());//$proxy001
userdao.save();
} // 目标对象没有实现接口， spring会用“cglib代理”
@test
public void testcglib() {
orderdao orderdao = (orderdao) ac.getbean("orderdao");
system.out.println(orderdao.getclass());
orderdao.save();
}
}
2.3.切入点表示式切入点表达式:可以对指定的方法进行拦截,从而给指定的方法所在的类生成代理对象.
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throes-pattern?)
从语法来看,只有返回类型和方法是必须要写的.返回类型一般用表示,写方法的时候可以通过匹配各种包或者类或者方法.
表示式使用示例:
<?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:p="http://www.springframework.org/schema/p" 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">
<!-- dao 实例 -->
<bean id="userdao" class="f_aop_xml.userdao"></bean>
<bean id="orderdao" class="f_aop_xml.orderdao"></bean>
<!-- 切面类 -->
<bean id="aop" class="f_aop_xml.aop"></bean>
<!-- aop配置 -->
<aop:config>
<!-- 定义一个切入点表达式： 拦截哪些方法 -->
<aop:pointcut expression="execution(* f_aop_xml.*.*(..))" id="pt"/>
<!-- 【拦截所有public方法】 -->
<aop:pointcut expression="execution(public * *(..))" id="pt"/>
<!-- 【拦截所有save开头的方法 】 -->
<aop:pointcut expression="execution(* save*(..))" id="pt"/>
<!-- 【拦截指定类的指定方法, 拦截时候一定要定位到方法】 -->
<aop:pointcut expression="execution(public * f_aop_xml.orderdao.save(..))" id="pt"/>
<!-- 【拦截指定类的所有方法】 -->
<aop:pointcut expression="execution(* f_aop_xml.userdao.*(..))" id="pt"/>
<!-- 【拦截指定包，以及其自包下所有类的所有方法】 -->
<aop:pointcut expression="execution(* cn..*.*(..))" id="pt"/>
<!-- 【多个表达式】 -->
<aop:pointcut expression="execution(* cn.itcast.g_pointcut.userdao.save()) || execution(* cn.itcast.g_pointcut.orderdao.save())" id="pt"/>
<aop:pointcut expression="execution(* cn.itcast.g_pointcut.userdao.save()) or execution(* cn.itcast.g_pointcut.orderdao.save())" id="pt"/>
<!-- 下面2个且关系的，没有意义 -->
<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.userdao.save()) && execution(* cn.itcast.g_pointcut.orderdao.save())" id="pt"/>-->
<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.userdao.save()) and execution(* cn.itcast.g_pointcut.orderdao.save())" id="pt"/>-->
<!-- 【取非值】 -->
<aop:pointcut expression="!execution(* cn.itcast.g_pointcut.orderdao.save())" id="pt"/>
<aop:pointcut expression=" not execution(* cn.itcast.g_pointcut.orderdao.save())" id="pt"/>
<!-- 切面 -->
<aop:aspect ref="aop">
<!-- 环绕通知 -->
<aop:around method="around" pointcut-ref="pt"/>
</aop:aspect>
</aop:config></beans>
以上就是两种spring aop的实现方式代码分享的详细内容。