这篇文章主要介绍了两种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); ////..【关注点代码】
}
}Salin selepas log masuk
在上面的代码中,如果有多个方法,就需要写多个重复的关注点代码,这样做的不好的,可以把经常重复的代码抽取出来,然后在代码中只需要在在方法中写核心业务代码,在运行该方法时,会自动执行抽取出来的关注点代码.是实现这样的效果,最好的方法就是使用代理模式,而事实上,AOP编程主要就是使用代理模式来实现核心代码和关注点代码的分离的.
手动的实现AOP跟前面代理模式实现的方式是一样的,这样就不再贴出来了.
2.AOP编程
AOP:Aspect Object Programming 面向切面编程
功能是让关注点和业务无代码分离
关注点:重复的代码就叫做关注点.
切面:关注点形成的类,就叫切面(类)
面向切面编程,就是指对很多功能都有的重复的代码抽取,再在运行的时候往业务方法中动态植入"切面类代码"
切入点:
执行目标对象方法,动态植入切面代码.可以通过切入点表达式,指定拦截哪些类的哪些方法,给指定的类在运行的时候植入切面类代码
2.1.注解方式实现
实现步骤:
1.引入aop相关jar包,一共四个
注意:用到Spring2.5版本中的jar文件时,如果再用jdk1.7可能会有问题,需要升级aspectj组件,即使用aspectj-1.8.2版本中提供的jar文件.
2.bean.xml中引入aop名称空间
xmlns:aop="http://www.springframework.org/schema/aop"
Salin selepas log masuk
3.开始aop注解扫描
<!-- 开启注解扫描 -->
<context:component-scan base-package="e_aop_anno"></context:component-scan>
<!-- 开启aop注解方式 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>Salin selepas log masuk
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();
}Salin selepas log masuk
实现接口的:UserDao.java
/**
* 目标对象
*/
@Component // 加入容器
public class UserDao implements IUserDao{
@Override
public void save() {
System.out.println("-----核心业务：保存！！！------");
}
}Salin selepas log masuk
不实现任何接口的OrderDao.java
/**
* 目标对象
*/
@Component // 加入容器
@Scope("prototype")
public class OrderDao{
public void save() {
System.out.println("-----核心业务：保存！！！------");
}
}Salin selepas log masuk
Spring的配置文件bean.xml
抽取出来的切面对象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("环绕后....");
}
}Salin selepas log masuk
测试类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
}
}Salin selepas log masuk
测试结果:
testApp()和testCglib()的测试结果为:
//测试输出环绕前....
开始事务/异常
-----核心业务：保存！！！------
环绕后....
提交事务/关闭afterReturning()
Salin selepas log masuk
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("环绕后....");
}
}Salin selepas log masuk
注意没有注解了.
配置文件bean.xml
测试类: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();
}
}Salin selepas log masuk
2.3.切入点表示式
切入点表达式:可以对指定的方法进行拦截,从而给指定的方法所在的类生成代理对象.
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throes-pattern?)
Salin selepas log masuk
从语法来看,只有返回类型和方法是必须要写的.返回类型一般用表示,写方法的时候可以通过匹配各种包或者类或者方法.
表示式使用示例:
Atas ialah kandungan terperinci 两种Spring AOP的实现方式代码分享. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
