这篇文章主要介绍了两种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注解扫描
<!-- 开启注解扫描 --> <component-scan></component-scan> <!-- 开启aop注解方式 --> <aspectj-autoproxy></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> <!-- 开启注解扫描 --> <component-scan></component-scan> <!-- 开启aop注解方式 --> <aspectj-autoproxy></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> <!-- dao 实例 --> <bean></bean> <bean></bean> <!-- 切面类 --> <bean></bean> <!-- Aop配置 --> <config> <!-- 定义一个切入点表达式: 拦截哪些方法 --> <pointcut></pointcut> <!-- 切面 --> <aspect> <!-- 环绕通知 --> <around></around> <!-- 前置通知: 在目标方法调用前执行 --> <before></before> <!-- 后置通知: --> <after></after> <!-- 返回后通知 --> <after-returning></after-returning> <!-- 异常通知 --> <after-throwing></after-throwing> </aspect> </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> <!-- dao 实例 --> <bean></bean> <bean></bean> <!-- 切面类 --> <bean></bean> <!-- Aop配置 --> <config> <!-- 定义一个切入点表达式: 拦截哪些方法 --> <pointcut></pointcut> <!-- 【拦截所有public方法】 --> <pointcut></pointcut> <!-- 【拦截所有save开头的方法 】 --> <pointcut></pointcut> <!-- 【拦截指定类的指定方法, 拦截时候一定要定位到方法】 --> <pointcut></pointcut> <!-- 【拦截指定类的所有方法】 --> <pointcut></pointcut> <!-- 【拦截指定包,以及其自包下所有类的所有方法】 --> <pointcut></pointcut> <!-- 【多个表达式】 --> <pointcut></pointcut> <pointcut></pointcut> <!-- 下面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"/>--> <!-- 【取非值】 --> <pointcut></pointcut> <pointcut></pointcut> <!-- 切面 --> <aspect> <!-- 环绕通知 --> <around></around> </aspect> </config></beans>











