Spring注解驱动开发(四)

AOP面向切面编程

AOP(Aspect Oriented Programming),即面向切面编程,可以说是OOP(Object Oriented Programming,面向对象编程)的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构,用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系,但并不适合定义横向的关系,例如日志功能。日志代码往往横向地散布在所有对象层次中,而与它对应的对象的核心功能毫无关系对于其他类型的代码,如安全性、异常处理和透明的持续性也都是如此,这种散布在各处的无关的代码被称为横切(cross cutting),在OOP设计中,它导致了大量代码的重复,而不利于各个模块的重用。

底层实现

Spring 的 AOP 的底层用到两种代理机制:

  • JDK 的动态代理 :类必须实现接口,所以是针对实现了接口的类产生代理.
  • Cglib 的动态代理:针对没有实现接口的类产生代理,应用的是底层的字节码增强的技术生成当前类的子类对象

JDK 的动态代理

  • UserService接口,实现增删改查的功能
1
2
3
4
5
6
7
8
package com.cuzz.service;

public interface UserService {
void add();
void delete();
void update();
void get();
}
  • UserService接口的实现的类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class UserServiceImpl implements UserService {

@Override
public void add() {
System.out.println("添加一个user");
}

@Override
public void delete() {
System.out.println("删除一个user");
}

@Override
public void update() {
System.out.println("更新一个user");
}

@Override
public void get() {
System.out.println("查询一个user");
}
}
  • 实现动态代理
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.cuzz.service;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class UserServiceProxyFactory implements InvocationHandler{

private UserService us;

public UserServiceProxyFactory(UserService us) {
super();
this.us = us;
}

// 获得动态代理
public UserService getUserServiceProxy() {
// 生成动态代理
UserService usProxy = (UserService) Proxy.newProxyInstance(UserServiceProxyFactory.class.getClassLoader(),
UserServiceImpl.class.getInterfaces(),
this); // 这个 this 就是实现 InvocationHandler 的对象
return usProxy;
}

@Override
public Object invoke(Object arg0, Method method, Object[] arg2)
throws Throwable {
System.out.println("打开事务!");
Object invoke = method.invoke(us, arg2);
System.out.println("提交事务!");
return invoke;
}
}
  • 测试
1
2
3
4
5
6
7
8
9
public class TestDemo {    
@Test
public void test01(){
UserService us = new UserServiceImpl();
UserServiceProxyFactory factory = new UserServiceProxyFactory(us);
UserService usProxy = factory.getUserServiceProxy();
usProxy.add();
}
}
  • 输出
1
2
3
打开事务!
添加一个user
提交事务!

Cglib 的动态代理

  • Cglib 的动态代理的代码实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.cuzz.service;

import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class UserServiceProxyFactory2 implements MethodInterceptor {

public UserService getUserServiceProxy(){
// 帮我们生成代理对象
Enhancer en = new Enhancer();
// 设置对谁进行代理
en.setSuperclass(UserServiceImpl.class);
// 代理要做什么
en.setCallback(this);
// 创建代理对象
UserService us = (UserService) en.create();
return us;
}

@Override
public Object intercept(Object prxoyobj, Method method, Object[] arg, MethodProxy methodProxy) throws Throwable {
// 打开事务
System.out.println("打开事务!");
// 调用原有方法
Object returnValue = methodProxy.invokeSuper(prxoyobj, arg);
// 提交事务
System.out.println("提交事务!");

return returnValue;
}
}
  • 测试
1
2
3
4
5
6
@Test
public void test02() {
UserServiceProxyFactory2 factory = new UserServiceProxyFactory2();
UserService usProxy = factory.getUserServiceProxy();
usProxy.add();
}

Spring的AOP开发(基于AspectJ)

AOP的开发中的相关术语:

  • Joinpoint(连接点):所谓连接点是指那些被拦截到的点,在 spring 中这些点指的是方法,因为 spring 只支持方法类型的连接点
  • Pointcut(切入点):所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义
  • Advice(通知/增强):所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
  • Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field
  • Target(目标对象):代理的目标对象
  • Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程,spring 采用动态代理织入,而 AspectJ 采用编译期织入和类装在期织入
  • Proxy(代理):一个类被 AOP 织入增强后,就产生一个结果代理类
  • Aspect(切面):是切入点和通知(引介)的结合

通知类型

  • 前置通知 :在目标方法执行之前执行
  • 后置通知 :在目标方法执行之后执行
  • 环绕通知 :在目标方法执行前和执行后执行
  • 异常抛出通知:在目标方法执行出现异常的时候执行
  • 最终通知 :无论目标方法是否出现异常 最终通知都会执行

代码演示

通知类,给切面的目标方法标注何时地运行,必须告诉 Spring 哪个类是切面类,添加注解 @Aspect

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
@Aspect  // 表示该类是一个通知类
public class MyAdvice {

// 前置通知
@Before("execution(* com.cuzz.service..*ServiceImpl.*(..))")
public void before(){
System.out.println("这是前置通知!!");
}

// 后置通知
@AfterReturning("execution(* com.cuzz.service..*ServiceImpl.*(..))")
public void afterReturning(){
System.out.println("这是后置通知(如果出现异常不会调用)!!");
}
// 环绕通知
@Around("execution(* com.cuzz.service..*ServiceImpl.*(..))")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("这是环绕通知之前的部分!!");
// 调用目标方法
Object proceed = pjp.proceed();
System.out.println("这是环绕通知之后的部分!!");
return proceed;
}
// 异常通知
@AfterThrowing("execution(* com.cuzz.service..*ServiceImpl.*(..))")
public void afterException(){
System.out.println("出事啦!出现异常了!!");
}
// 后置通知
@After("execution(* com.cuzz.service..*ServiceImpl.*(..))")
public void after(){
System.out.println("这是后置通知(出现异常也会调用)!!");
}
}

配置类,将切面类和业务逻辑类都加入到容器中,给配置类加 @EnableAspectJAutoProxy 注解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
* @Author: cuzz
* @Date: 2019/2/10 20:43
* @Description:
*/
@Configuration
@EnableAspectJAutoProxy
public class MainConfigOfAOP {

@Bean
public UserService userService() {
return new UserServiceImpl();
}

@Bean
public MyAdvice myAdvice() {
return new MyAdvice();
}
}

测试

1
2
3
4
5
6
7
8
9
10
@Test
public void test03() {
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);

UserService userService = (UserService) applicationContext.getBean("userService");
userService.add();
userService.delete();
userService.update();
userService.get();
}

如果报错添加依赖

1
2
3
4
5
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.4</version>
</dependency>
-------------本文结束感谢您的阅读-------------

本文标题:Spring注解驱动开发(四)

文章作者:cuzz

发布时间:2019年02月10日 - 22:02

最后更新:2019年05月16日 - 11:05

原始链接:http://blog.cuzz.site/2019/02/10/Spring注解驱动开发(四)/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

请博主吃包辣条
0%