什么是AOP我们先来看一张图
图中A就是通知，比如你要给每个方法前都加一个before()方法，目标类的每一个方法叫joinpoint（切入点），每个切入点都会用到通知，把通知和切入点连起来，点成线，线成面，这就是切面，也就是AOP，下面我们来简单写个小例子来实现一下
目标类的接口
public interface UserService {
public void addUser() ;
public void updateUser();
public void deleteUser();
}
目标类接口的实现
public class UserServiceImpl implements UserService {
@Override
public void addUser() {
System.out.println("addUser");
}
@Override
public void updateUser() {
System.out.println("updateUser");
}
@Override
public void deleteUser() {
System.out.println("deleteUser");
}
}
通知类
public class MyAspect {
public void before(){
System.out.println("before");
}
public void after(){
System.out.println("after");
}
}
代理类
public class MyBeanFactory {
public static UserService createService(){
//1.目标类
final UserService userService = new UserServiceImpl() ;
//2.切面类
final MyAspect myAspect = new MyAspect();
// 切入点和切面类结合
// 三个参数
// 1. loader ,类加载器 运行是加载，用类加载器将其加载到内存
// 2. interfaces 代理类需要实现的所有接口
// 3. invocationHandler 处理类，一般采用匿名内部类
// 提供了invoke方法 代理类每个方法执行时都将调用一次invoke ,又有三个参数
// 1. Object proxy 代理对象
// 2. Method method 代理对象方法的反射
// 3. Object[] args 方法的实际参数
UserService proxyService = (UserService) Proxy.newProxyInstance(MyBeanFactory.class.getClassLoader(),
userService.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(method.getName());
myAspect.before();
Object obj = method.invoke(userService, args);
myAspect.after();
return obj ;
}
});
return proxyService ;
}
}
测试类
public class UserServiceImplTest {
@org.junit.jupiter.api.Test
public void demo() throws Exception {
UserService userService = MyBeanFactory.createService();
userService.addUser();
userService.deleteUser();
userService.updateUser();
}
}
结果
addUser
before
addUser
after
deleteUser
before
deleteUser
after
updateUser
before
updateUser
after
Process finished with exit code 0
我们可以看到每个方法都执行了通知，用了动态代理就不用手动的给每个方法前后加入通知，这样既节省了时间，也保证了主体代码不被改变
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对服务器之家的支持。
