Spring AOP面向切面编程底层原理及使用
本帖最后由 二饭 于 2020-11-27 16:31 编辑# AOP面向切面编程
通过预编译方式和运行期间动态代{过}{滤}理实现程序功能的统一维护的一种技术。
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率，提供了程序的扩展性。
## 总结
**AOP是在不修改源码的情况下，对功能进行横向扩展。**
AOP是通过创建目标对象的代{过}{滤}理对象，在代{过}{滤}理对象调用方法时，进行增强，从而实现了功能的扩展。
JDK的动态代{过}{滤}理：只能代{过}{滤}理生成实现过接口的实例。
字节码的动态代{过}{滤}理：可以代{过}{滤}理生成任何类的实例。
## 基于JDK动态代{过}{滤}理的缺陷：
spring提供了两种代{过}{滤}理方式：
### 1、基于JDK的动态代{过}{滤}理
当目标对象实现过接口时，在使用AOP时使用JDK的动态代{过}{滤}理来生成代{过}{滤}理对象。
### 2、基于字节码的增强
## AOP常用概念
#### ①目标类（target）
需要进行功能扩展的类
#### ②连接点（joinPoint）
目标类中的所有方法的称为连接点。
#### ③切入点（pointCut）
连接点中需要增强的方法称为切入点。
#### ④增强/通知（advise）
需要进行扩展的功能。
#### ⑤织入（weaving）
将增强应用到切入点的过程。
#### ⑥代{过}{滤}理对象（proxy）
织入完成后生成的代{过}{滤}理对象。
#### ⑦切面（aspect）
多个切入点组成切面。
## AOP底层原理
### 基于JDK动态代{过}{滤}理(写法)
**注意：没有实现过结果的类，不能通过JDK动态代{过}{滤}理来生成代{过}{滤}理对象。**
#### ①确定目标类，实现了接口
```java
public class RoleServiceImpl implements RoleService{
@Override
public void save() {
// TODO Auto-generated method stub
System.out.println("RoleServiceImp的save方法");
}
@Override
public void delete() {
// TODO Auto-generated method stub
System.out.println("RoleServiceImp的delete方法");
}
@Override
public void update() {
// TODO Auto-generated method stub
System.out.println("RoleServiceImp的update方法");
}
}
```
#### ②连接点（所有个方法）
#### ③切入点（你要增强的方法）
#### ④增强（用于增强的类）
```java
public class TransactionUtil {
public static void begin() {
System.out.println("开启事务");
}
public static void commit() {
System.out.println("提交事务");
}
}
```
#### ⑤创建工厂类，用于生成目标对象的代{过}{滤}理对象，并且在代{过}{滤}理对象中使用增强的方法。
```java
public class ProxyBeanFactory {
public static RoleService getRoleServiceProxy(RoleService roleService) {
/**
* 参数1，类加载器：自定义类，所有的自定义类都使用的是同一种类加载器
* 参数2，目标类实现的接口的类对象数组
* 参数3，InvocationHandler 对目标对象的方法的回调
*/
RoleService proxy=(RoleService) Proxy.newProxyInstance(RoleService.class.getClassLoader(),
roleService.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 确定切入点
String methodName=method.getName();//获取到方法名
if("save".equals(methodName)) {
TransactionUtil.begin();
}
//目标方法的执行并获取返回值
Object obj=method.invoke(roleService, args);
if("save".equals(methodName)) {
TransactionUtil.commit();
}
return obj;
}
});
return proxy;
}
}
```
#### ⑥测试
创建RoleService的实例，调用save方法，看执行情况。再通过工厂类，调用静态方法生成RoleService对象的代{过}{滤}理对象，再去调用save方法，看执行情况。
```
public class Main3 {
@Test
public void testSave() {
RoleService service =new RoleServiceImpl();
service.save();
service.delete();
RoleService proxy=ProxyBeanFactory.getRoleServiceProxy(service);
//判断proxy是不是RoleService类型
System.out.println(proxy instanceof RoleService);
proxy.save();
proxy.delete();
}
}
```
执行结果：
!(C:\Users\stad\AppData\Roaming\Typora\typora-user-images\image-20200824164901985.png)
#### ⑦隐藏测试类中代码
```java
public class ProxyBeanFactory {
public static RoleService getRoleServiceProxy(RoleService roleService) {
/**
* 将本应该写在测试类中的生成对象写在了工厂类中
* 下面就可以直接使用这个对象
* 参数直接传入null
* 执行结果是相同的
*/
RoleService service =new RoleServiceImpl();
/**
* 参数1，类加载器：自定义类，所有的自定义类都使用的是同一种类加载器
* 参数2，目标类实现的接口的类对象数组
* 参数3，InvocationHandler 对目标对象的方法的回调
*/
RoleService proxy=(RoleService) Proxy.newProxyInstance(RoleService.class.getClassLoader(),
service.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 确定切入点
String methodName=method.getName();//获取到方法名
if("save".equals(methodName)) {
TransactionUtil.begin();
}
//目标方法的执行并获取返回值
Object obj=method.invoke(service, args);
if("save".equals(methodName)) {
TransactionUtil.commit();
}
return obj;
}
});
return proxy;
}
}
```
**注意：**上面代码中通过工厂方法生成的RoleService对象已经变成了$Proxy类型的，不再是RoleServiceImpl了。
### 基于cglib字节码增强
cglib作为字节码增强的框架，早期的**Hibernate**就使用了cglib。一般使用cglib我们需要下载cglib的依赖。在高版本spring中已经将cglib的依赖打包在``spring-core.jar``中，所以可以直接去使用。
## 基于aspectj的AOP
需要加入aspectj的依赖包。
一般在自定义增强时使用aspectj。
### xml
确定目标类
确定连接点
确定切入点
确定增强（可以是普通的Java类）
### 注解
① 开启注解驱动
```
<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
```
② 开启组件扫描
```
<context:component-scan base-package="com"></context:component-scan>
```
③ 将目标类交给Spring管理
```java
@Service
public class RoleServiceImpl implements RoleService{
@Override
public void saveUser() {
System.out.println("save方法");
}
}
```
④ 在增强类上使用@Aspects注解标识
```java
@Component("ddo")
@Aspect
public class Ddo {
@Before(value = "execution(* com.service.impl.*.saveUser())")
public void before() {
System.out.println("开始");
}
@After(value = "execution(* com.service.impl.*.saveUser())")
public void after() {
System.out.println("结束");
}
}
```
⑤ 在增强类方法上加入注解指定增强类型
```java
@Before(value = "execution(* com.service.impl.*.saveUser())")
public void before() {
System.out.println("开始");
}
```
⑥ 测试类中调用
```java
@ContextConfiguration(locations = "classpath:applicationContext.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class Test {
@Autowired
private RoleServiceImpl roleServiceImpl;
@org.junit.Test
public void test1() {
roleServiceImpl.saveUser();
System.out.println(1);
}
}
``` 支持一下，最近也在学spring 很有用多学习下吧 学习安排上 谢谢楼主的分享 写帖子吗 总结的特别简洁精炼{:1_921:}感谢楼主 谢谢楼主的分享 不错不错,写的很好
页:
[1]