关键词：
昨天有个大牛说我啰嗦，眼光比较细碎，看不到重点。太他爷爷的有道理了!要说看人品，还是女孩子强一些。
原来记得看到一个男孩子的抱怨，说怎么两人刚刚开始在一起，女孩子在心里就已经和他过完了一辈子。哥哥们，不想这么远行吗?看看何洁，看看带着俩娃跳楼的妈妈。
所以现在的女孩子是很明白的，有些男孩子个子不高，其貌不扬，但是一看那人品气质就知道能找个不错的女盆友。不过要说看人的技术能力，男孩子确实更胜一筹，咱得努力了。
总结一下要形成的习惯：
有空时隔一段时间要做几道算法题，C语言和JAVA都可以，主要是训练思维。
定期阅读spring的源码。因为spring是框架，重设计，能够培养大局观
阅读底层的书籍，如linux方面，虚拟机方面，这是内功。越高级的语言只是招式。
不要忘记做了一半的东西，如搜索引擎方面，redis方面，可以过一段时间再做，因为到时候自己的境界有提升，深入程度也会有所增加。
下面是今天的正题。我也很菜，看源码也很费力，所以都会从最容易的入手。先了解其原理，再去看源码。
看源码看熟了，以后再遇到问题，就可以通过源码去了解原理了。
spring的AOP，原理懂了，代码相当简单。这也是为什么我记得我还是个菜鸟的时候，面试人家经常问我这个。
先有个大局观，画张整体的spring结构图。以下是备受吐槽的手绘时间：
如果你觉得我左手字写的实在是不能再难看了的话，我有空可以展示一下右手字
天生做不好的两件事：写不好字，梳不整齐头发。自我感觉最近梳头技术有所改观。
AOP面向切面编程是面向对象的补充。它利用一种横切技术，将一些公共行为封装成叫做“方面”的可重用模块，解耦，增加可维护性。
AOP将系统分为核心关注点和横切关注点两部分。核心关注点就是主业务流程，横切关注点就是上面提到的“方面”。
那么看AOP的源码就是要看横切关注点是怎样和核心关注点整合来发挥作用的。
主业务流程归根到底是一个java方法，而且是对象的方法。在AOP中被称为被通知或被代理对象POJO。
AOP的作用就是将核心关注点和横切关注点组合起来，术语叫做“增强”。最后实际用的是增强后的代理对象。
对核心关注点进行增强就涉及到在哪些地方增强的问题。如方法调用或者异常抛出时做增强这些时机叫做连接点Joinpoint。一个通知将被引发的连接点集合叫做切入点，理解时就可以想正则表达式，通配符来指定多个，而不是单单一个连接点。
在连接点都做了哪些增强呢?增强的内容AOP术语叫“通知”Advice。
Spring里定义了四种Advice:BeforeAdvice，AfterAdvice，ThrowAdvice，DynamicIntroducationAdvice。
许多AOP框架包括spring都是以拦截器作为通知模型。维护一个围绕连接点的拦截器链。其中DynamicIntroducationAdvice是可以引入方法或者字段到核心关注点。
这里有个Introduction，AOP术语叫引入。将增强后的AOP代理组装到系统叫做织入。
上面就是AOP的核心概念了。总结一下：
AOP要做的事情就是：生成代理对象，然后织入。
生成代理对象是经常会被问到的一个问题：Spring提供了两种方式来生成代理对象，JDKProxy和Cglib。
具体使用哪种方式由AopProxyFactory根据AdvisedSupport对象的配置来决定。
默认的策略是如果目标类是接口，则使用JDK动态代理技术，否则使用Cglib来生成代理。
Cglib是基于字节码技术的，使用的是ASM。asm是一个java字节码操纵框架，它能被用来动态生成类或者增强既有类的功能。
ASM可以直接产生二进制class文件，也可以在类被加载入JVM之前动态改变类行为。
下面重点来看看JDK动态代理技术。这是我还是个很菜很菜的菜鸟时为数不多能看懂的源码。因为之前看过Java设计模式，写过类似的例子，所以会比较顺畅。今天先讲这一部分。
下面是调用测试类：
package dynamic.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 实现自己的InvocationHandler
* @author zyb
* @since 2012-8-9
*
*/
public class MyInvocationHandler implements InvocationHandler
// 目标对象
private Object target;
/**
* 构造方法
* @param target 目标对象
*/
public MyInvocationHandler(Object target)
super();
this.target = target;
/**
* 执行目标对象的方法
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
// 在目标对象的方法执行之前简单的打印一下
System.out.println("------------------before------------------");
// 执行目标对象的方法
Object result = method.invoke(target, args);
// 在目标对象的方法执行之后简单的打印一下
System.out.println("-------------------after------------------");
return result;
/**
* 获取目标对象的代理对象
* @return 代理对象
*/
public Object getProxy()
return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
target.getClass().getInterfaces(), this);
package dynamic.proxy;
/**
* 目标对象实现的接口，用JDK来生成代理对象一定要实现一个接口
* @author zyb
* @since 2012-8-9
*
*/
public interface UserService
/**
* 目标方法
*/
public abstract void add();
package dynamic.proxy;
/**
* 目标对象
* @author zyb
* @since 2012-8-9
*
*/
public class UserServiceImpl implements UserService
/* (non-Javadoc)
* @see dynamic.proxy.UserService#add()
*/
public void add()
System.out.println("--------------------add---------------");
package dynamic.proxy;
import org.junit.Test;
/**
* 动态代理测试类
* @author zyb
* @since 2012-8-9
*
*/
public class ProxyTest
@Test
public void testProxy() throws Throwable
// 实例化目标对象
UserService userService = new UserServiceImpl();
// 实例化InvocationHandler
MyInvocationHandler invocationHandler = new MyInvocationHandler(userService);
// 根据目标对象生成代理对象
UserService proxy = (UserService) invocationHandler.getProxy();
// 调用代理对象的方法
proxy.add();
执行结果如下：
------------------before---------------
--------------------add---------------
-------------------after-----------------
很简单，核心就是 invocationHandler.getProxy();这个方法调用的Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),target.getClass().getInterfaces(), this); 怎么生成对象的。
/**
* Returns an instance of a proxy class for the specified interfaces
* that dispatches method invocations to the specified invocation
* handler.
*
*
@code Proxy.newProxyInstance throws
* @code IllegalArgumentException for the same reasons that
* @code Proxy.getProxyClass does.
*
* @param loader the class loader to define the proxy class
* @param interfaces the list of interfaces for the proxy class
* to implement
* @param h the invocation handler to dispatch method invocations to
* @return a proxy instance with the specified invocation handler of a
* proxy class that is defined by the specified class loader
* and that implements the specified interfaces
* @throws IllegalArgumentException if any of the restrictions on the
* parameters that may be passed to @code getProxyClass
* are violated
* @throws SecurityException if a security manager, s, is present
* and any of the following conditions is met:
*
*
the given @code loader is @code null and
* the caller‘s class loader is not @code null and the
* invocation of @link SecurityManager#checkPermission
* s.checkPermission with
* @code RuntimePermission("getClassLoader") permission
* denies access;
*
for each proxy interface, @code intf,
* the caller‘s class loader is not the same as or an
* ancestor of the class loader for @code intf and
* invocation of @link SecurityManager#checkPackageAccess
* s.checkPackageAccess() denies access to @code intf;
*
any of the given proxy interfaces is non-public and the
* caller class is not in the same @linkplain Package runtime package
* as the non-public interface and the invocation of
* @link SecurityManager#checkPermission s.checkPermission with
* @code ReflectPermission("newProxyInPackage.package name")
* permission denies access.
*
* @throws NullPointerException if the @code interfaces array
* argument or any of its elements are @code null, or
* if the invocation handler, @code h, is
* @code null
*/
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
Objects.requireNonNull(h);
final Class[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null)
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
/*
* Look up or generate the designated proxy class.
*/
Class cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try
if (sm != null)
checkNewProxyPermission(Reflection.getCallerClass(), cl);
final Constructor cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers()))
AccessController.doPrivileged(new PrivilegedAction()
public Void run()
cons.setAccessible(true);
return null;
);
return cons.newInstance(new Object[]h);
catch (IllegalAccessException|InstantiationException e)
throw new InternalError(e.toString(), e);
catch (InvocationTargetException e)
Throwable t = e.getCause();
if (t instanceof RuntimeException)
throw (RuntimeException) t;
else
throw new InternalError(t.toString(), t);
catch (NoSuchMethodException e)
throw new InternalError(e.toString(), e);
这个代码是JDK1.8中的，里面用到了1.8的一些语法，如果不太了解，建议先看看这本书。
代码看着不少，实际上都在进行一些安全校验，包装之类的，真正有用的就两句：
Class cl = getProxyClass0(loader, intfs);这句话查找或者生成代理类。跟进去：
/**
* Generate a proxy class. Must call the checkProxyAccess method
* to perform permission checks before calling this.
*/
private static Class getProxyClass0(ClassLoader loader,
Class... interfaces)
if (interfaces.length > 65535)
throw new IllegalArgumentException("interface limit exceeded");
// If the proxy class defined by the given loader implementing
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
return proxyClassCache.get(loader, interfaces);
对，就是从缓存里把接口拿将出来。然后用return cons.newInstance(new Object[]h) 这一句将接口用invocationHandler进行包装。
具体源码可以跟进去看，不详述。想必看到这里，JDK动态代理的原理都已经很明白了。
这里要说一点理论性的东西：郑州 不 孕 不 育 医 院:http://wapyyk.39.net/zz3/zonghe/1d427.html/
AOP解决的问题往往可以用代理模式来解决。Java开发中常说动态代理和静态代理，而AOP就是动态代理，因为代理的类是在运行时才生成的。
而一般说的代理模式写成的代码是编译期就已经生成的，叫静态代理。
springaop源码解析(代码片段)
...的有点长，看完需要点耐心。很多读者希望能写一写SpringAOP的源码分析文章，这样读者看完IOC+AOP也就对Spring会有比较深的理解了。今天终于成文了，可能很多读者早就不再等待了，不过主要为了后来者吧。本... 查看详情
springaop源码分析
核心类：AbstractAutoProxyCreator继续看： 流程说明1）AOP标签的定义解析刘彻骨肯定是从NamespaceHandlerSupport的实现类开始解析的，这个实现类就是AopNamespaceHandler。至于为什么会是从NamespaceHandlerSupport的实现类开始解析的，这个... 查看详情
springaop源码解析
以编程的方式使用spring提供的AOP功能，下面是一个简单的例子：package com.zws.spring.core.aop.springAop;import java.lang.reflect.Method;import org.springframework.aop.MethodBeforeAdvice;import org.springframe 查看详情
做一个合格的程序猿之浅析springaop源码（十八）springaop开发大作战源码解析
其实上一篇文章价值很小，也有重复造轮子的嫌疑，网上AOP的实例很多，不胜枚举，其实我要说的并不是这个，我想要说的就是上一节中spring的配置文件：我们这边并没有用到我们上几节分析的哪几个AOP的主要实现类：ProxyFa... 查看详情
springaop源码—＜aop:config/＞aop配置标签解析一万字(代码片段)
基于最新Spring5.x，对SpringAOP中的＜aop:config/＞标签的解析源码进行了详细分析，这是SpringAOP源码的入口！ 此前我们已经详细学习了SpringAOP的基本使用，现在我们来学习SpringAOP的源码，学习AOP源... 查看详情
android系统源码怎么看？android开发源码精编解析助你高效阅读源码
...作中，还是我们自己学习Android，总会用到Android的源码。Android源码中包含的库非常之多，下面列举我在看Android源码过程中涉及较多，也是比较常看的一些库：android/platform/packages/apps：Android自带的app，... 查看详情
曹工说springboot源码（18）--springaop源码分析三部曲，终于快讲完了(aop：config完整解析下)
写在前面的话相关背景及资源：曹工说SpringBoot源码（1）--BeanDefinition到底是什么，附spring思维导图分享曹工说SpringBoot源码（2）--BeanDefinition到底是什么，咱们对着接口，逐个方法讲解曹工说SpringBoot源码（3）--手动注册BeanDefinition... 查看详情
一文搞懂springaop源码底层原理
...落到代码的各个部分，难以维护。一键获取源码地址springaop面试题AOP就是把这些问题和主业务逻辑分开，达到与主业务逻辑解耦的目的。二、AOP的应用场景·日志记录·权限验证·效率检查·事务管理三、SpringAOP原理及其 查看详情
springaop介绍及源码分析
一、AOP介绍举个例子来说明一下吧！现在系统中有很多的业务方法，如上传产品信息、修改产品信息、发布公司库等；现在需要对这些方法的执行做性能监控，看每个业务方法的执行时间；在不改变原业务代码的基础上，也许我... 查看详情
深入源码解析springaop实现的三个过程(代码片段)
SpringAOP的面向切面编程，是面向对象编程的一种补充，用于处理系统中分布的各个模块的横切关注点，比如说事务管理、日志、缓存等。它是使用动态代理实现的，在内存中临时为方法生成一个AOP对象，这个对象包含目标对象的... 查看详情
spring源码高级笔记之——springaop应用
SpringAOP应用AOP本质:在不改变原有业务逻辑的情况下增强横切逻辑，横切逻辑代码往往是权限校验代码、日志代码、事务控制代码、性能监控代码。第1节AOP相关术语1.1业务主线在讲解AOP术语之前，我们先来看一下下面这... 查看详情
springaop源码分析之篇四：适配器模式
MethodInterceptorAdvisorAdapter和Advice之间实现了适配器模式首先增加方法的执行时通过拦截器链进行执行的，而配置文件配置的参数解析完以后是一增强对象的形式进行封装的拦截器要想调用增强Advice的增强方法，是无法直接方访问... 查看详情
koa源码解析，带你实现一个迷你版的koa
前言本文是我在阅读Koa源码后，并实现迷你版Koa的过程。如果你使用过Koa但不知道内部的原理，我想这篇文章应该能够帮助到你，实现一个迷你版的Koa不会很难。本文会循序渐进的解析内部原理，包括：基础版本的koacontext的实... 查看详情
【pinia源码】一、createpinia源码解析
参考技术A【pinia源码】系列文章主要分析pinia的实现原理。该系列文章源码参考piniav2.0.14。源码地址：https://github.com/vuejs/pinia官方文档：https://pinia.vuejs.org本篇文章将分析createPinia的实现。通过createPinia创建一个pinia实例，供应用... 查看详情
浅谈springaop功能源码执行逻辑
如题，该篇博文主要是对Spring初始化后AOP部分代码执行流程的分析，仅仅只是粗略的讲解整个执行流程，喜欢细的小伙伴请结合其他资料进行学习。在看本文之前请一定要有动态代理的基础，否则后后半部分内容... 查看详情
sparkstreaming运行流程及源码解析(代码片段)
...行jobJobGenerator介绍生成job提交执行job输出数据SparkStreaming源码流程解析。写在前面以下是我自己梳理了一遍SparkStreaming程序运行的流程，过程可能有点细、有点乱。大家可以一边看我写的流程、一边跟着步骤点进去看源码，这样... 查看详情
从源码入手，一文带你读懂springaop面向切面编程
之前《零基础带你看Spring源码——IOC控制反转》详细讲了Spring容器的初始化和加载的原理，后面《你真的完全了解Java动态代理吗？看这篇就够了》介绍了下JDK的动态代理。基于这两者的实现上，这次来探索下Spring的AOP原理。虽... 查看详情
spring从成神到升仙系列三2023年再不会aop源码，就要被淘汰了(代码片段)
...29520，和大家一起学习，一起进步👀文章目录SpringAOP源码解析一、引言二、适合人群三、SpringAOP配置四、SpringAOP组件分析1、Pointcut2、Advice3、Advisor4、Aspect5、总结五、SpringAOP源码剖析1、beanDefinition的注册1.1AspectJAwareAdvi... 查看详情