AOP编程
01 AOP 概念
- AOP:面向切面编程 ,Aspect Oriented Programing
- 以切面为基本单位的程序开发,通过切面之间的彼此协作,相互调用,完成程序之间的构建
- 切面 = 切入点 + 额外功能
- 本质就是 Spring 的动态代理开发,通过代理类为原始类添加额外功能
- 好处:利于原始类的维护
- AOP是对OOP的补充
- OOP:面向对象编程
- 以对象为基本单位的程序开发,通过对象之间的彼此协作,相互调用,完成程序之间的构建
- POP:面向过程编程
- 以过程为基本单位的程序开发,通过过程之间的彼此协作,相互调用,完成程序的构建
- 以过程为基本单位的程序开发,通过过程之间的彼此协作,相互调用,完成程序的构建
02 AOP编程开发步骤
- 原始对象
- 额外功能
- 切入点
- 组装切面
03 切面的名词解释
切面 = 切入点 + 额外功能
04 AOP的底层实现原理
4.1 核心问题
问题一:AOP如何创建动态代理类
- 使用动态字节码技术
问题二:Spring的工厂是如何加工创建代理对象
- 通过原始对象的id值,获得的是代理对象
4.2 动态代理类的创建
JDK的动态代理
Proxy.newProxyInstance(classLoader, insterface, invocationHandler)
参数信息
InvocationHandler
- 用来书写额外功能,额外功能运行在原始方法执行之前,之后,前后,抛出异常
提供的方法:
Object invoke(Object proxy,Method method,Object[]args){
}
- proxy:代表的是代理对象
- Method:额外功能,所添加给的原始方法
- Object[] args : 原始方法的参数
insterface
- 原始类和代理类实现同一个接口
对象.getClass().getInstance()
classLoader
作用:借用一个类加载器,创建代理类的Class对象,进而创建代理对象
类加载器的作用
- 通过类加载器把对应类的字节码文件加载JVM
- 通过类加载器创建类的Class对象,进而创建这个类的对象
如何获得类加载器
- 每一个类的.class 文件,自动分配与之对应的ClassLoader
编码实现
package com.spring.jdk;
public class TestJDKProxy {
public static void main(String[] args) {
// 创建原始对象
final UserService userService = new UserServiceImpl();
// JDk 创建动态代理
InvocationHandler invocationhandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("------Proxy log----------------");
Object ret = method.invoke(userService,args);
return ret;
}
};
UserService userServiceTem = (UserService)Proxy.newProxyInstance(
TestJDKProxy.class.getClassLoader(),
userService.getClass().getInterfaces(),
invocationhandler);
userServiceTem.login(new User());
}
}
CGlib的动态代理
解决:原始类没有实现任何的接口, 但是仍然需要代理类
原理:父子继承关系创建代理对象, 原始类作为父类, 代理类作为子类, 这样既可以保证两者方法一致,同时可以在代理类中添加新的实现
- 原始类
public class UserService {
public void login(String username,String pass){
System.out.println("UserService.login");
}
public void register(String username){
System.out.println("UserService.register");
}
}
- Cglib动态代理
public class TestCglib {
public static void main(String[] args) {
final UserService userService = new UserService();
Enhancer enhancer = new Enhancer();
enhancer.setClassLoader(TestCglib.class.getClassLoader());
enhancer.setSuperclass(userService.getClass());
MethodInterceptor methodInterceptor = new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("-----------Cglib log--------------");
Object invoke = method.invoke(userService, objects);
return invoke;
}
};
enhancer.setCallback(methodInterceptor);
UserService service = (UserService) enhancer.create();
}
}
两种方式对比
- **JDK动态代理 **: **通过接口 **创建代理的实现类
- **Cglib动态代理 **: **通过继承 **父类创建的代理类
05 Spring对于代理的加工
<bean id="beanPostProcessorTest" class="com.spring.jdk.BeanPostProcessorTest" />
<bean id="userService" class="com.spring.jdk.UserServiceImpl" />
package com.spring.jdk;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class BeanPostProcessorTest implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
final Object tem = bean;
InvocationHandler invocationHandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("----------BeanPostProcessor-------------");
Object invoke = method.invoke(tem, args);
return invoke;
}
};
Proxy.newProxyInstance(BeanPostProcessorTest.class.getClassLoader(),tem.getClass().getInterfaces(),invocationHandler);
return tem;
}
}
06 基于AspectJ注解的AOP编程
6.1 AOP的开发步骤
- 原始对象
- 额外功能
- 切入点
- 组装切面
6.2 实现aop的步骤
底层仍然是JDK的动态代理
- 加入依赖
spring依赖 aspectj依赖
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.8.M1</version>
<scope>runtime</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/aspectj/aspectjrt -->
<dependency>
<groupId>aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.5.3</version>
</dependency>
- 创建目标类
@Data
public class UserServiceImpl implements UserService {
private UserDao userDao;
@Override
public void login(String username, String password) {
userDao.login(username,password);
}
}
- 创建切面类
- 定义了额外功能
@Arround
- 定义了切面类
@Aspect
- 定义了额外功能
@Aspect
public class MyAspect {
@Around("execution(* com.spring.aspect..login(..))")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("------------额外功能---------------");
Object ret = joinPoint.proceed();
return ret;
}
}
- 在Spring的配置文件中进行配置
<aop:aspectj-autoproxy/>
编程:告知Spring使用 基于注解的AOP
<?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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="userDao" class="com.spring.aspect.UserDaoImpl"></bean>
<bean id="userService" class="com.spring.aspect.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
<bean id="around" class="com.spring.aspect.MyAspect"></bean>
<aop:aspectj-autoproxy/>
</beans>
6.3 切入点复用
- 当我们想为 login方法添加其他的额外功能
@Aspect
public class MyAspect {
@Around("execution(* com.spring.aspect..login(..))")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("------------额外功能---------------");
Object ret = joinPoint.proceed();
return ret;
}
@Around("execution(* com.spring.aspect..login(..))")
public Object around1(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("------------日志功能---------------");
Object ret = joinPoint.proceed();
return ret;
}
}
我们发现了,切入点表达式冗余,对于冗余的代码,我们可以提取出去
@Aspect
public class MyAspect {
@Pointcut("execution(* com.spring.aspect..login(..))")
public void myPointCut(){}
@Around(value = "myPointCut()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("------------额外功能---------------");
Object ret = joinPoint.proceed();
return ret;
}
@Around(value = "myPointCut()")
public Object around1(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("------------日志功能---------------");
Object ret = joinPoint.proceed();
return ret;
}
}
6.4 动态代理的创建方式
- 默认情况下,是使用JDK的动态代理
- 如果说想使用Cglib的动态代理
<aop:aspectj-autoproxy proxy-target-class="true"/>
- 传统方式使用Cglib
<aop:config proxy-target-class="true">
<aop:pointcut id="pc" expression="@annotation(com.spring.proxy.Log)"/>
<aop:advisor advice-ref="around" pointcut-ref="pc"/>
</aop:config>
6.5 切面的执行时间
- 这个执行时间在规范中叫做通知,同时也可以在xml文件的标签中进行使用
- 常用的注解
- @Before
- @AfterReturning
- @Around
- @AfterThrowing
- @After
6.6 注意事项
- 在同一个业务类中,进行业务方法的相互调用,只有最外层的方法,才是加入了额外功能。如果说想让内层的方法同时加入,需要通过下面的方式
package com.spring.aspect;
import lombok.Data;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
@Data
public class UserServiceImpl implements UserService, ApplicationContextAware {
private UserDao userDao;
private ApplicationContext ac;
@Override
public void login(String username, String password) {
userDao.login(username,password);
UserService userService = (UserService) ac.getBean("userService");
userService.register(username,password);
}
@Override
public void register(String username, String password) {
userDao.register(username,password);
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.ac = applicationContext;
}
}