Sscon70
Sscon70

Spring AOP实现源码分析

Spring AOP实现

概念简介

  • Aspect：系统中，功能模块或者类的横切面的一种抽象。举例来说，web应用常见的事务管理即是典型的Aspect。各个服务功能（或类方法），都需要实现事务管理（一般指数据库事务），这种横跨多个功能的相同逻辑，可以称之为Aspect。
  • Join Point：系统功能的执行点，方法调用或者方法抛出的异常处理，都可以称之为Join Point。AOP的目的就是在方法某处执行自定义的功能，归纳为在【哪里】执行【什么功能】，这个【哪里】就是指Join Point。Spring中，Join Point指的是方法调用，从方法层级来切入。
  • Advice：在Join Point执行的具体动作，即【什么功能】。Advice分为多种类型，around、before、after等。通常，Advice以拦截器Interceptor的方式实现，某个方法的Advice的interceptor会组成一个链，来执行多个Advice的功能。
  • Pointcut：匹配Join Point的规则。例如，可以指定匹配带有【add】前缀的所有方法。Advice要关联Pointcut使用，来确定动作具体在哪里执行。Spring使用的是AspectJ的表达式。
  • Introduction：通常意义上的Advice都是附加在某个已有的方法上来指定额外的功能，Introduction可以在指定类上增加方法或者属性。通过Introduction可以帮指定bean引入新的接口，实现新的功能。

Spring代理实现技术

​ Spring代理的实现方式有两种：

JDK代理：如果代理目标类实现了至少一个接口，那么接口的方法代理就可以使用JDK代理来实现。如果目标类没有实现任何接口，那么将使用CGLIB来实现代理功能

CGLIB：主要实现方式是对生成一个目标类的子类，来对方法实行覆盖，所以不可覆盖的方法无法利用此方式来代理。

​ Spring内部依赖于这两种方式来实现代理，下面简单举例，说明一下二者的实现方式的区别

JDK代理

​ 由于JDK代理需要接口的实现，所以先自定义一个简单的接口：

public interface Fly {
    void fly();
}

​ 定义一个简单类实现接口：

public class Bird implements Fly{
    @Override
    public void fly() {
        System.out.println("this is bird flying");
    }
}

​ JDK代理主要使用InvocationHandler接口来实现方法的代理：

public class FlyInvocationHandler implements InvocationHandler {
    /**
     * 代理目标类
     */
    private Object target;

    public FlyInvocationHandler(Object target) {
        super();
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 代理方式执行前后，自定义逻辑
        System.out.println("invocation interceptor, before");
        Object invokeResult = method.invoke(target, args);
        System.out.println("invocation interceptor, after");
        return invokeResult;
    }
    /**
     * 返回代理类对象
     *
     * @return the proxy
     * @author liuxinxing5 2018年11月30日 11:05
     */
    public Object getProxy() {
        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                target.getClass().getInterfaces(), this);
    }
}

​ 测试代理类：

public class JdkProxyTest {
    public static void main(String[] args) {
        FlyInvocationHandler handler = new FlyInvocationHandler(new Bird());
        Fly fly = (Fly) handler.getProxy();
        fly.fly();
    }
}

​ 测试输出：

invocation interceptor, before
this is bird flying
invocation interceptor, after

CGLIB

public class EnhancerDemo {

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        // 设置代理目标
        enhancer.setSuperclass(EnhancerDemo.class);
        // 设置代理的action，即Advice
        enhancer.setCallback(new MethodInterceptorImpl());
        EnhancerDemo demo = (EnhancerDemo) enhancer.create();
        demo.test(100);
    }

    public void test(int i) {
        System.out.println("inside enhancer demo " + i);
    }

    private static class MethodInterceptorImpl implements MethodInterceptor {

        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("interceptor  begin   ");
            Object res = methodProxy.invokeSuper(o, objects);
            System.out.println("interceptor  end     ");
            return res;
        }
    }
}

​ 测试输出：

interceptor  begin   
inside enhancer demo 100
interceptor  end

Spring代理实现逻辑

简单示例

​ 首先先定义一个简单的Bean：

public class TestBean {
    // 被代理方法
    public void test() {
        System.out.println("inside test bean");
    }
}

​ test()方法是被代理的测试方法，下面需要定义代理的配置。Spring代理配置可以使用两种方式，XML配置和注解配置。

XML配置

​ 新增一个aop的配置类，XMLAop.java

public class XMLAop {
    // 用于before Advice测试
    public void before() {
        System.out.println("inside xml configured before method");
    }
    // 用于around Advice测试
    public Object around(ProceedingJoinPoint point) throws Throwable {
        System.out.println("inside xml configured around method 1");
        Object result = point.proceed(point.getArgs());
        System.out.println("inside xml configured around method 2");
        return result;
    }
}

​ XML配置aop.xml：

​ 测试test()方法输出:

public static void main(String[] args) {
    ApplicationContext c = new ClassPathXmlApplicationContext("aop.xml");
    // 获取test bean
    TestBean test = (TestBean)c.getBean("test");
    // 指定test方法
    test.test();
}

​ 测试输出：

inside xml configured around method 1
inside xml configured before method
inside test bean   
inside xml configured around method 2

注解配置

​ 注解配置方式就是对XMLAop类作简单修改，增加注解：

@Aspect
public class XMLAop {

    @Pointcut("execution(* com.sscon.aop.spring.*.test(..))")
    public void test() {
    }
    @Before("test()")
    public void before() {
        System.out.println("inside xml configured before method");
    }

    @Around("test()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        System.out.println("inside xml configured around method 1");
        Object result = point.proceed();
        System.out.println("inside xml configured around method 2");
        return result;
    }
}

​ 关键注解：

@Aspect:表明此类是一个Aspect配置

@Pointcut:注解于void返回值的方法，用于定义join point的匹配规则

@Before:定义before类型的Advice，方法内指定执行的逻辑

@Aroud:定义around类型的Advice，方法内指定执行的逻辑，注解的方法的参数第一个必须为ProceedingJoinPoint ，使用ProceedingJoinPoint.proceed方法类实现对被代理目标方法的调用

...

​ XML配置aop.xml移除aspect的相关配置：

​ 测试test()方法输出:

inside xml configured around method 1
inside xml configured before method
inside test bean   
inside xml configured around method 2

源码分析

AOP功能入口，创建ProxyCreator

​ Spring xml配置文件中，是开启aop功能的入口，所以我们从此xml标签的解析来分析Spring的处理流程。

​ 在AopNamespaceHandler类中，Spring注册了aop标签配置的解析器，AspectJAutoProxyBeanDefinitionParser：

// AopNamespaceHandler.java
public void init() {
    // In 2.0 XSD as well as in 2.1 XSD.
    registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
    // 注册处理aspectj-autoproxy标签的处理器
    registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
    registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

    // Only in 2.0 XSD: moved to context namespace as of 2.1
    registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
}

​ AspectJAutoProxyBeanDefinitionParser类实现了BeanDefinitionParser接口，BeanDefinitionParser是Spring用来解析直接子节点的接口，主要逻辑是parse方法：

// AspectJAutoProxyBeanDefinitionParser.java
public BeanDefinition parse(Element element, ParserContext parserContext) {
    AopNamespaceUtils.
    registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
    extendBeanDefinition(element, parserContext);
    return null;
}
// AopNamespaceUtils.java
public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
    ParserContext parserContext, Element sourceElement) {
    // 注册代理的creator
    BeanDefinition beanDefinition = AopConfigUtils.
        registerAspectJAnnotationAutoProxyCreatorIfNecessary(
        parserContext.getRegistry(), parserContext.extractSource(sourceElement));
    // 处理proxy-target-class 和 expose-proxy属性
    useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
    registerComponentIfNecessary(beanDefinition, parserContext);
}
// AopConfigUtils.java
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
    BeanDefinitionRegistry registry, Object source) {
    return registerOrEscalateApcAsRequired(
        AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}

​ 跟踪到AopConfigUtils的registerOrEscalateApcAsRequired方法，可以看到Spring注册代理creator的逻辑，其中参数cls是AnnotationAwareAspectJAutoProxyCreator.class,这个方法的主要逻辑是注册一个创建代理的工具类：

如果当前没有注册AUTO_PROXY_CREATOR_BEAN_NAME的代理Creator，那么使用cls参数指定的类作为工具创建

如果当前注册了AUTO_PROXY_CREATOR_BEAN_NAME的Creator，那么要进行优先级排序，确定具体使用AnnotationAwareAspectJAutoProxyCreator还是已经创建的Creator

Spring默认使用AnnotationAwareAspectJAutoProxyCreator

// AopConfigUtils.java
public static final String AUTO_PROXY_CREATOR_BEAN_NAME =
            "org.springframework.aop.config.internalAutoProxyCreator";

static {
    APC_PRIORITY_LIST.add(InfrastructureAdvisorAutoProxyCreator.class);
    APC_PRIORITY_LIST.add(AspectJAwareAdvisorAutoProxyCreator.class);
    APC_PRIORITY_LIST.add(AnnotationAwareAspectJAutoProxyCreator.class);
}

private static BeanDefinition registerOrEscalateApcAsRequired(
    Class cls, BeanDefinitionRegistry registry, Object source) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    // 如果当前已注册AUTO_PROXY_CREATOR_BEAN_NAME的creator，那么需要做一下选择
    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
        BeanDefinition apcDefinition = 
            registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
        if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
            // 已注册的creator和指定cls不同，根据优先级排序选择
            int currentPriority = 
                // 当前已注册的creator的优先级，优先级根据APC_PRIORITY_LIST中的
                // 序号来表示，AnnotationAwareAspectJAutoProxyCreator位于序号2
                // 是最高的优先级
                findPriorityForClass(apcDefinition.getBeanClassName());
            // cls指定的creator的优先级
            int requiredPriority = findPriorityForClass(cls);
            if (currentPriority < requiredPriority) {
                // 如果cls指定的优先级高，那么更换为cls的creator
                apcDefinition.setBeanClassName(cls.getName());
            }
        }
        return null;
    }
    RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
    beanDefinition.setSource(source);
    beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
    beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
    return beanDefinition;
}

代理配置处理

​ 注册完代理的Creator后，还需要处理指定的配置信息，读取用户的配置信息后，保存：

// AopNamespaceUtils.java
public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
    ParserContext parserContext, Element sourceElement) {
    // 注册代理的creator
    BeanDefinition beanDefinition = AopConfigUtils.
        registerAspectJAnnotationAutoProxyCreatorIfNecessary(
        parserContext.getRegistry(), parserContext.extractSource(sourceElement));
    // 处理proxy-target-class 和 expose-proxy属性
    useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
    registerComponentIfNecessary(beanDefinition, parserContext);
}
// AopConfigUtils.java
private static void useClassProxyingIfNecessary(
    BeanDefinitionRegistry registry, Element sourceElement) {
    if (sourceElement != null) {
        // PROXY_TARGET_CLASS_ATTRIBUTE = "proxy-target-class"
        boolean proxyTargetClass = Boolean.parseBoolean(
            sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
        if (proxyTargetClass) {
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
        }
        // EXPOSE_PROXY_ATTRIBUTE = "expose-proxy"
        boolean exposeProxy = Boolean.parseBoolean(
            sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
        if (exposeProxy) {
            AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
        }
    }
}
// AopConfigUtils.java
public static void forceAutoProxyCreatorToUseClassProxying(
    BeanDefinitionRegistry registry) {
    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
        BeanDefinition definition = 
            registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
        definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
    }
}
// AopConfigUtils.java
public static void forceAutoProxyCreatorToExposeProxy(
    BeanDefinitionRegistry registry) {
    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
        BeanDefinition definition = 
            registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
        definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
    }
}

​ proxy-target-class与expose-proxy属性：

proxy-target-class:Spring默认使用JDK代理来实现代理功能（前提是类至少实现了一个接口），该属性可以强制指定使用CGLIB来实现代理功能

expose-proxy:被代理对象如果存在自我调用，例如a方法调用b方法，两个方法都被代理，那么b方法是无法执行代理逻辑的。

被代理对象内部方法调用的问题

​ 拿一个简单的例子来描述这个问题，TestBean有方法被代理，test()与test2()，test内部调用test2，test2方法配置的代理逻辑不会执行：

public class TestBean {
    // 被代理方法
    public void test() {
        System.out.println("inside test bean");
        test2();
    }
    // 被代理方法
    public void test2() {
        System.out.println("inside test2 bean   ");
    }
}

​ 如果代理的配置如下：

@Aspect
public class XMLAop {
    // test test2方法都会匹配
    @Pointcut("execution(* com.sscon.aop.spring.*.test*(..))")
    public void test() {

    }
    @Before("test()")
    public void before() {
        System.out.println("inside xml configured before method");
    }
}

​ 输出如下：

inside xml configured before method
inside test bean   
inside test2 bean

​ 如果希望test2()方法也执行代理的逻辑，Spring给出一个解决办法是，将expose-proxy修改为true吗，暴露Spring生成的代理实体，且修改test()方法的逻辑：

public class TestBean {
    public void test() {
        System.out.println("inside test bean   ");
        // 拿到Spring生成的代理，指定test2()的方法，如果不修改expose-proxy配置，会报错
        ((TestBean)AopContext.currentProxy()).test2();
    }
    public void test2() {
        System.out.println("inside test2 bean   ");
    }
}

使用代理Creator创建代理

​ Spring默认使用AnnotationAwareAspectJAutoProxyCreator来对Spring管理的Bean做代理创建处理，此类实现了BeanPostProcessor，BeanPostProcessor的关键方法是postProcessAfterInitialization。Bean初始化完成之后会调用此方法对Bean进行处理。该方法的实现在抽象父类AbstractAutoProxyCreator：

// AbstractAutoProxyCreator.java
public Object postProcessAfterInitialization(Object bean, String beanName) 
    throws BeansException {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (!this.earlyProxyReferences.contains(cacheKey)) {
            // 没有缓存存在时，初始化代理
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

​ 从上面的逻辑可以看到，当没有缓存时，使用wrapIfNecessary方法进行代理初始化：

// AbstractAutoProxyCreator.java
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // 判断是否已经处理过
    if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    if (isInfrastructureClass(bean.getClass()) 
        || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }
    // 拿到Bean所有配置的interceptors
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(
        bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // 根据interceptors创建代理并缓存
        Object proxy = createProxy(
            bean.getClass(), beanName, specificInterceptors, 
            new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}
获取Bean所有配置的interceptors

​ Spring内部使用Advisor类来保存Advice和Pointcut的配置信息，获取Bean所有可用的Advisor的基本逻辑是：

首先拿到所有的advice配置，保留xml配置与注解配置

根据被代理类的实体，决定具体哪些advice可以应用于当前实体类

对advice排序，返回

// AbstractAdvisorAutoProxyCreator.java
protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass, String beanName,
                                                TargetSource targetSource) {
    List advisors = findEligibleAdvisors(beanClass, beanName);
    if (advisors.isEmpty()) {
        return DO_NOT_PROXY;
    }
    return advisors.toArray();
}

protected List findEligibleAdvisors(Class beanClass, String beanName) {
    // 查找所有可能的advice配置
    List candidateAdvisors = findCandidateAdvisors();
    // 过滤处理，拿到所有匹配的advice配置
    List eligibleAdvisors = findAdvisorsThatCanApply(
        candidateAdvisors, beanClass, beanName);
    extendAdvisors(eligibleAdvisors);
    if (!eligibleAdvisors.isEmpty()) {
        // 多个advisor需要进行排序，确定所有代理的advice逻辑的执行顺序
        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    }
    return eligibleAdvisors;
}

​ findCandidateAdvisors，主要负责读取所有配置的Advice，包括两个部分，一种是xml配置，一种的注解配置：

// AnnotationAwareAspectJAutoProxyCreator.java
protected List findCandidateAdvisors() {
    // 将父类读取的advisor也保存到结果中，这里主要是xml配置的advice
    List advisors = super.findCandidateAdvisors();
    // 读取注解配置的advice
    advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
    return advisors;
}

​ 查询注解配置的advice信息的基本逻辑是：

首先获取所有的Bean信息，遍历

判断Bean是否具有Aspect注解，如果有，获取Advisor信息，其中包括配置的Pointcut规则，Advice配置等

缓存查询结果，方便下次查询

// BeanFactoryAspectJAdvisorsBuilder.java
public List buildAspectJAdvisors() {
    List aspectNames = this.aspectBeanNames;

    if (aspectNames == null) {
        // 缓存结果
        synchronized (this) {
            aspectNames = this.aspectBeanNames;
            if (aspectNames == null) {
                List advisors = new LinkedList();
                aspectNames = new LinkedList();
                // 查询所有的bean
                String[] beanNames = 
                    BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                    this.beanFactory, Object.class, true, false);
                for (String beanName : beanNames) {
                    // 是否合法，默认返回true
                    if (!isEligibleBean(beanName)) {
                        continue;
                    }
                    // 拿到Bean的Class对象
                    Class beanType = this.beanFactory.getType(beanName);
                    if (beanType == null) {
                        continue;
                    }
                    // 如果有Aspect注解
                    if (this.advisorFactory.isAspect(beanType)) {
                        aspectNames.add(beanName);
                        AspectMetadata amd = new AspectMetadata(beanType, beanName);
                        if (amd.getAjType().getPerClause().getKind() 
                            == PerClauseKind.SINGLETON) {
                            MetadataAwareAspectInstanceFactory factory =
                                new BeanFactoryAspectInstanceFactory(
                                this.beanFactory, beanName);
                            // 获取所有的advice信息并保存到列表
                            List classAdvisors = 
                                this.advisorFactory.getAdvisors(factory);
                            if (this.beanFactory.isSingleton(beanName)) {
                                this.advisorsCache.put(beanName, classAdvisors);
                            }
                            else {
                                this.aspectFactoryCache.put(beanName, factory);
                            }
                            advisors.addAll(classAdvisors);
                        }
                        else {
                            // Per target or per this.
                            if (this.beanFactory.isSingleton(beanName)) {
                                throw new IllegalArgumentException(
                                    "Bean with name '" + beanName +
              "' is a singleton, but aspect instantiation model is not singleton");
                            }
                            MetadataAwareAspectInstanceFactory factory =
                                new PrototypeAspectInstanceFactory(
                                this.beanFactory, beanName);
                            this.aspectFactoryCache.put(beanName, factory);         
                            advisors.addAll(this.advisorFactory
                                          .getAdvisors(factory));
                        }
                    }
                }
                this.aspectBeanNames = aspectNames;
                return advisors;
            }
        }
    }

    if (aspectNames.isEmpty()) {
        return Collections.emptyList();
    }
    // 从缓存中获取advice信息并返回
    List advisors = new LinkedList();
    for (String aspectName : aspectNames) {
        List cachedAdvisors = this.advisorsCache.get(aspectName);
        if (cachedAdvisors != null) {
            advisors.addAll(cachedAdvisors);
        }
        else {
            MetadataAwareAspectInstanceFactory factory = 
                this.aspectFactoryCache.get(aspectName);
            advisors.addAll(this.advisorFactory.getAdvisors(factory));
        }
    }
    return advisors;
}

​ 获取Bean类的Advisor的逻辑：

遍历Bean的方法，带有@Pointcut注解的方法除外，因为@Pointcut配置的是join point的匹配规则，单独处理

如果该方法有配置@Before等注解，那么构造Advisor，放入结果列表中

如果属性有配置@DeclareParents，那么构造Advisor，放入结果列表中

// ReflectiveAspectJAdvisorFactory.java
public List getAdvisors(
    MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
    Class aspectClass = aspectInstanceFactory
        .getAspectMetadata().getAspectClass();
    String aspectName = aspectInstanceFactory
        .getAspectMetadata().getAspectName();
    validate(aspectClass);

    MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory = 
        new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory)；
    // 保存Advisor信息
    List advisors = new LinkedList();
    // 遍历当前Bean类的非Pointcut注解的方法，判断是否有@Before等注解配置
    for (Method method : getAdvisorMethods(aspectClass)) {
        // 尝试获取方法的Advisor，如果当前类没有@Pointcut配置或者方法没有任何Advice配置
        // 都会直接返回null
        Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 
                                     advisors.size(), aspectName);
        if (advisor != null) {
            advisors.add(advisor);
        }
    }
    if (!advisors.isEmpty() 
        && lazySingletonAspectInstanceFactory.
        getAspectMetadata().isLazilyInstantiated()) {
        Advisor instantiationAdvisor = new 
            SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
        advisors.add(0, instantiationAdvisor);
    }
    // 构造@DeclareParents注解的Advisor，这个配置是附加在属性上，所以单独处理
    // @DeclareParents主要是用于给Bean类增加新的方法，而不是在已有方法上附加行为
    for (Field field : aspectClass.getDeclaredFields()) {
        Advisor advisor = getDeclareParentsAdvisor(field);
        if (advisor != null) {
            advisors.add(advisor);
        }
    }
    return advisors;
}

​ 接着上述逻辑，获取方法的Advisor的逻辑为：

// ReflectiveAspectJAdvisorFactory.java
public Advisor getAdvisor(Method candidateAdviceMethod, 
                          MetadataAwareAspectInstanceFactory aspectInstanceFactory,
                          int declarationOrderInAspect, String aspectName) {
    validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
    // 获取Pointcut配置
    AspectJExpressionPointcut expressionPointcut = getPointcut(
        candidateAdviceMethod, 
        aspectInstanceFactory.getAspectMetadata().getAspectClass());
    if (expressionPointcut == null) {
        return null;
    }
    // 根据查询到的注解初初始化Advisor
    return new InstantiationModelAwarePointcutAdvisorImpl(
        expressionPointcut, candidateAdviceMethod,
        this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}

private AspectJExpressionPointcut getPointcut(
    Method candidateAdviceMethod, Class candidateAspectClass) {
    // 获取@Before等注解
    AspectJAnnotation aspectJAnnotation =
        AbstractAspectJAdvisorFactory
        .findAspectJAnnotationOnMethod(candidateAdviceMethod);
    if (aspectJAnnotation == null) {
        return null;
    }

    AspectJExpressionPointcut ajexp =
        new AspectJExpressionPointcut(
        candidateAspectClass, new String[0], new Class[0]);
    ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
    ajexp.setBeanFactory(this.beanFactory);
    return ajexp;
}
// AbstractAspectJAdvisorFactory.java
protected static AspectJAnnotation findAspectJAnnotationOnMethod(Method method) {
    Class[] classesToLookFor = new Class[] {
        Before.class, Around.class, After.class, 
        AfterReturning.class, AfterThrowing.class, Pointcut.class};
    for (Class c : classesToLookFor) {
        AspectJAnnotation foundAnnotation = 
            findAnnotation(method, (Class) c);
        if (foundAnnotation != null) {
            return foundAnnotation;
        }
    }
    return null;
}

​ 由查询到的注解配置信息构造Advisor（包含Advice，Pointcut等信息）：

// InstantiationModelAwarePointcutAdvisorImpl.java
public InstantiationModelAwarePointcutAdvisorImpl(
    AspectJExpressionPointcut declaredPointcut,     
    Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
    MetadataAwareAspectInstanceFactory aspectInstanceFactory, 
    int declarationOrder, String aspectName) {
        ...  
    if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
        ...
    }
    else {
        this.pointcut = this.declaredPointcut;
        this.lazy = false;
        // 根据@Before等初始化Advice
        this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
    }
}

private Advice instantiateAdvice(AspectJExpressionPointcut pcut) {
    return this.aspectJAdvisorFactory.getAdvice(
        this.aspectJAdviceMethod, pcut,
        this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
}

​ 初始化Advice的逻辑，可以看到是根据不同的注解生成不同的Advice对象，主要由工厂生成：

public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
            MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
    ....
    AbstractAspectJAdvice springAdvice;

    switch (aspectJAnnotation.getAnnotationType()) {
        case AtBefore:
            springAdvice = new AspectJMethodBeforeAdvice(
                candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            break;
        case AtAfter:
            springAdvice = new AspectJAfterAdvice(
                candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            break;
        case AtAfterReturning:
            springAdvice = new AspectJAfterReturningAdvice(
                candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            AfterReturning afterReturningAnnotation = 
                (AfterReturning) aspectJAnnotation.getAnnotation();
            if (StringUtils.hasText(afterReturningAnnotation.returning())) {
                springAdvice.setReturningName(afterReturningAnnotation.returning());
            }
            break;
        ...
            return null;
        default:
            throw new UnsupportedOperationException(
                "Unsupported advice type on method: " + candidateAdviceMethod);
    }
    ...
}

​ 到此逻辑，Spring已经可以拿到用户配置的所有Aspect，接下来是遍历这些配置，过滤出哪些Aspect配置可以应用于当前Bean类

过滤可应用于Bean的interceptors

​ 上一步查询出已经配置的所有的Aspect的配置，Advisor列表，根据Advisor中的Pointcut配置，来比对Bean中的方法，如果可以匹配，那么Advisor可应用于当前Bean：

// AbstractAdvisorAutoProxyCreator.java
protected List findAdvisorsThatCanApply(
    List candidateAdvisors, Class beanClass, String beanName) {
    ProxyCreationContext.setCurrentProxiedBeanName(beanName);
    try {
        return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
    }
    finally {
        ProxyCreationContext.setCurrentProxiedBeanName(null);
    }
}
// AopUtils.java
public static List findAdvisorsThatCanApply(
    List candidateAdvisors, Class clazz) {
    if (candidateAdvisors.isEmpty()) {
        return candidateAdvisors;
    }
    List eligibleAdvisors = new LinkedList();
    for (Advisor candidate : candidateAdvisors) {
        // @DeclareParents类型
        if (candidate instanceof IntroductionAdvisor 
            && canApply(candidate, clazz)) {
            eligibleAdvisors.add(candidate);
        }
    }
    boolean hasIntroductions = !eligibleAdvisors.isEmpty();
    for (Advisor candidate : candidateAdvisors) {
        if (candidate instanceof IntroductionAdvisor) {
            // introduction类型已经处理
            continue;
        }
        if (canApply(candidate, clazz, hasIntroductions)) {
            eligibleAdvisors.add(candidate);
        }
    }
    return eligibleAdvisors;
}

​ 主要判断逻辑处于canApply方法，主要逻辑是判断Bean的所有接口与Bean自己的所有方法是否可以应用Advisor中的Pointcut规则，如果任一方法可以，那就可以认为Advisor可以用于当前Bean：

// AopUtils.java
public static boolean canApply(Advisor advisor, Class targetClass, boolean hasIntroductions) {
    if (advisor instanceof IntroductionAdvisor) {
        return ((IntroductionAdvisor) advisor)
            .getClassFilter().matches(targetClass);
    }
    else if (advisor instanceof PointcutAdvisor) {
        PointcutAdvisor pca = (PointcutAdvisor) advisor;
        return canApply(pca.getPointcut(), targetClass, hasIntroductions);
    }
    else {
        return true;
    }
}

public static boolean canApply(Pointcut pc, Class targetClass, boolean hasIntroductions) {
    Assert.notNull(pc, "Pointcut must not be null");
    if (!pc.getClassFilter().matches(targetClass)) {
        return false;
    }
    // Pointcut配置的方法过滤为默认True类型，直接返回即可
    MethodMatcher methodMatcher = pc.getMethodMatcher();
    if (methodMatcher == MethodMatcher.TRUE) {
        return true;
    }
    IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
    if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
        introductionAwareMethodMatcher = 
            (IntroductionAwareMethodMatcher) methodMatcher;
    }
    // 存放代理目标类的所有接口类
    Set> classes = new LinkedHashSet>(
        ClassUtils.getAllInterfacesForClassAsSet(targetClass));
    // 把代理目标类也放入set
    classes.add(targetClass);
    // 上述所有类的任一方法可以匹配Pointcut，认为此Advisor可以应用于当前被代理类
    for (Class clazz : classes) {
        Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
        for (Method method : methods) {
            if ((introductionAwareMethodMatcher != null 
                 && introductionAwareMethodMatcher.matches(
                     method, targetClass, hasIntroductions)) 
                || methodMatcher.matches(method, targetClass)) {
                return true;
            }
        }
    }
    return false;
}

​ 至此，Spring已经拿到当前Bean可应用的Advisor列表，接下来就是利用Advisor和Bean来创建代理类

代理创建逻辑

​ 前文提到的AbstractAutoProxyCreator的wrapIfNecessary方法中包含了实际代理创建的逻辑：

// AbstractAutoProxyCreator.java
protected Object createProxy(
            Class beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {

    ... proxyFactory的初始化逻辑
    // 利用proxyFactory创建代理
    return proxyFactory.getProxy(getProxyClassLoader());
}
// ProxyFactory.java
public Object getProxy(ClassLoader classLoader) {
    return createAopProxy().getProxy(classLoader);
}
// ProxyCreatorSupport.java
protected final synchronized AopProxy createAopProxy() {
    if (!this.active) {
        activate();
    }
    return getAopProxyFactory().createAopProxy(this);
}
// DefaultAopProxyFactory.java
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    if (config.isOptimize() || config.isProxyTargetClass() 
        || hasNoUserSuppliedProxyInterfaces(config)) {
        Class targetClass = config.getTargetClass();
        if (targetClass == null) {
            throw new AopConfigException(
                "TargetSource cannot determine target class: " +                     
                "Either an interface or a target is required for proxy creation.");
        }
        // 这里判断使用哪一种代理创建方式
        if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
            return new JdkDynamicAopProxy(config);
        }
        // ObjenesisCglibAopProxy是CglibAopProxy子类，做了一些逻辑优化
        return new ObjenesisCglibAopProxy(config);
    }
    else {
        return new JdkDynamicAopProxy(config);
    }
}

​ 可以看到，Spring根据代理目标类是否实现接口，配置中是否强制开启CGLIB，来决定使用哪一种方式来创建代理。

JdkDynamicAopProxy

​ JdkDynamicAopProxy与JDK代理简单实例中的一致，实现了InvocationHandler接口，主要逻辑位于invoke方法中，主要是将所有interceptor组成一个链，然后调用链执行，最后执行被代理方法：

// JdkDynamicAopProxy.java
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    MethodInvocation invocation;
    ...
    try {
        Object retVal;
        ...
        // interceptor组成一个链，链式调用
        List chain = this.advised.
            getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
        if (chain.isEmpty()) {
            Object[] argsToUse = AopProxyUtils.
                adaptArgumentsIfNecessary(method, args);
            retVal = AopUtils.
                invokeJoinpointUsingReflection(target, method, argsToUse);
        }
        else {
            invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
            retVal = invocation.proceed();
        }
        ...
        Class returnType = method.getReturnType();
        if (retVal != null && retVal == target &&
            returnType != Object.class && returnType.isInstance(proxy) &&
            !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
            return retVal;
        }
        finally {
            ...
        }
    }
 
 
​ interceptor链执行：
 
 
// ReflectiveMethodInvocation.java
public Object proceed() throws Throwable {
    //  最后执行join point方法，也就是被代理方法
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        return invokeJoinpoint();
    }

    Object interceptorOrInterceptionAdvice =
        this.interceptorsAndDynamicMethodMatchers
        .get(++this.currentInterceptorIndex);
    if (interceptorOrInterceptionAdvice 
        instanceof InterceptorAndDynamicMethodMatcher) {
        // 匹配当前方法，执行拦截的代理逻辑
        InterceptorAndDynamicMethodMatcher dm =
            (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
        if (dm.methodMatcher.matches(this.method, 
                                     this.targetClass, this.arguments)) {
            return dm.interceptor.invoke(this);
        }
        else {
            // 不匹配当前方法，跳过
            return proceed();
        }
    }
    else {
        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    }
}

 
 
CglibAopProxy
 
 
​ CGLIB构造代理的方式与示例类似，都是利用Enhancer类来进行构造：
 
 
// CglibAopProxy.java
public Object getProxy(ClassLoader classLoader) {
    try {
        ...
        // 配置Enhancer...
        Enhancer enhancer = createEnhancer();
        ...
        enhancer.setSuperclass(proxySuperClass);
        enhancer.setInterfaces(
            AopProxyUtils.completeProxiedInterfaces(this.advised));
        enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
        enhancer.setStrategy(
            new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));
        // 获取关键的代理执行逻辑方法，callback方法
        Callback[] callbacks = getCallbacks(rootClass);
        Class[] types = new Class[callbacks.length];
        for (int x = 0; x < types.length; x++) {
            types[x] = callbacks[x].getClass();
        }
        // 设置CallBackFilter
        enhancer.setCallbackFilter(new ProxyCallbackFilter(
            this.advised.getConfigurationOnlyCopy(), 
            this.fixedInterceptorMap, this.fixedInterceptorOffset));
        enhancer.setCallbackTypes(types);
        // 设置CallBack方法
        return createProxyClassAndInstance(enhancer, callbacks);
    }...
}

 
 
​ 获取CallBack方法的主要逻辑为：
 
 
// CglibAopProxy.java
private Callback[] getCallbacks(Class rootClass) throws Exception {
    boolean exposeProxy = this.advised.isExposeProxy();
    boolean isFrozen = this.advised.isFrozen();
    boolean isStatic = this.advised.getTargetSource().isStatic();

    // 获取aop配置的CallBack
    Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);

    // 一些优化策略
    ...
    Callback[] mainCallbacks = new Callback[] {
        aopInterceptor,  // xml和注解配置的aop代理逻辑
        targetInterceptor,  // 优化
        new SerializableNoOp(),  // 优化
        targetDispatcher, this.advisedDispatcher,
        new EqualsInterceptor(this.advised),
        new HashCodeInterceptor(this.advised)
    };
    Callback[] callbacks;
    // 一些优化策略
    ...
    return callbacks;
}

 
 
​ DynamicAdvisedInterceptor实现了MethodInterceptor接口，也就是CGLIB示例中的CallBack方法的实现：
 
 
// DynamicAdvisedInterceptor.java
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    Object oldProxy = null;
    boolean setProxyContext = false;
    Class targetClass = null;
    Object target = null;
    try {
        if (this.advised.exposeProxy) {
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }
        target = getTarget();
        if (target != null) {
            targetClass = target.getClass();
        }
        List chain = this.advised
            .getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
        Object retVal;
        if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
            // 直接调用目标类的方法
            Object[] argsToUse = AopProxyUtils
                .adaptArgumentsIfNecessary(method, args);
            retVal = methodProxy.invoke(target, argsToUse);
        }
        else {
            // 同样是调用链的创建，CglibMethodInvocation直接继承JDK代理使用的
            // ReflectiveMethodInvocation，主要逻辑没有变化
            retVal = new CglibMethodInvocation(proxy, target, 
                                               method, args, targetClass, 
                                               chain, methodProxy).proceed();
        }
        retVal = processReturnType(proxy, target, method, retVal);
        return retVal;
    }
    finally {
        if (target != null) {
            releaseTarget(target);
        }
        if (setProxyContext) {
            AopContext.setCurrentProxy(oldProxy);
        }
    }
}

 
 
​ 使用JDK或CGLIB创建代理后，Bean在AOP的Postprocess的流程就结束了。后续调用Bean方法时，就可以实现AOP方法的调用。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Spring AOP实现源码分析)

        

            

                
    
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    
                    
    • 
                    
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    
                    
    • 
                    
  • 消息中间件有哪些常见类型
                        xmh-sxh-1314
java
                        
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
    
                    
    • 
                    
  • 腾讯云技术深度探索：构建高效云原生微服务架构
                        我的运维人生
云原生架构腾讯云运维开发技术共享
                        
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
    
                    
    • 
                    
  • 拥有断舍离的心态，过精简生活--《断舍离》读书笔记
                        爱吃丸子的小樱桃

                        
    不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
    
                    
    • 
                    
  • 从0到500+，我是如何利用自媒体赚钱？
                        一列脚印

                        
    运营公众号半个多月，从零基础的小白到现在慢慢懂了一些运营的知识。做好公众号是很不容易的，要做很多事情；排版、码字、引流…通通需要自己解决，业余时间全都花费在这上面涨这么多粉丝是真的不容易，对比知乎大佬来说，我们这种没资源，没人脉，还没钱的小透明来说，想要一个月涨粉上万，怕是今天没睡醒（不过你有的方法，算我piapia打脸）至少我是清醒的，自己慢慢努力，实现我的万粉目标！大家快来围观、支持我吧！孩子
    
                    
    • 
                    
  • 使用LLaVa和Ollama实现多模态RAG示例
                        llzwxh888
python人工智能开发语言
                        
    本文将详细介绍如何使用LLaVa和Ollama实现多模态RAG（检索增强生成），通过提取图像中的结构化数据、生成图像字幕等功能来展示这一技术的强大之处。安装环境首先，您需要安装以下依赖包：!pipinstallllama-index-multi-modal-llms-ollama!pipinstallllama-index-readers-file!pipinstallunstructured!p
    
                    
    • 
                    
  • 利用LangChain的StackExchange组件实现智能问答系统
                        nseejrukjhad
langchainmicrosoft数据库python
                        
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
    
                    
    • 
                    
  • MongoDB Oplog 窗口
                        喝醉酒的小白
MongoDB运维
                        
    在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
    
                    
    • 
                    
  • Faiss Tips：高效向量搜索与聚类的利器
                        焦习娜Samantha

                        
    FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
    
                    
    • 
                    
  • Python 实现图片裁剪（附代码） | Python工具
                        剑客阿良_ALiang

                        
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
    
                    
    • 
                    
  • 数据仓库——维度表一致性
                        墨染丶eye
背诵数据仓库
                        
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
    
                    
    • 
                    
  • ARM驱动学习之5 LEDS驱动
                        JT灬新一
嵌入式C底层arm开发学习单片机
                        
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
    
                    
    • 
                    
  • Low Power概念介绍-Voltage Area
                        飞奔的大虎

                        
    随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • 道阻且长，行则将至
                        sweet橘子

                        
    本文参与书香澜梦主题征文“行”文章原创首发，文责自负。我们每一个人都应该有属于自己的愿望或者是理想，人一但有了理想也就算是有了方向，它就会像灯塔一样指引我们前进的方向，哪怕是再远大的理想，如果坚持，那么我相信它就一定有收获。屈原是我最喜欢的一个浪漫主义的诗人，他曾今说过：“路漫漫其修远兮，吾将上下而求索。”人生的道路很长，但是为了实现自己的理想抱负我愿意付出我毕生的精力，只专注这一件事，因为“道阻
    
                    
    • 
                    
  • insert into select 主键自增_mybatis拦截器实现主键自动生成
                        weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
                        
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
    
                    
    • 
                    
  • 和自己结婚，是一种怎样的体验
                        只如初见_2020

                        
    一个17岁谈恋爱，19岁结婚，然后离了三次婚的女人，站在台上说：“现在我结婚了，和那个一直以来，真正想在一起的人结婚了，那个人就是我自己。”她说，在我9岁前，我已经在二十几个寄养家庭中待过。我从童年到成年，就只有一个目标，不要被落下。而我实现这一目标的方式就是，我要结婚。我第一次的结婚对象，是我17岁时遇到的人。我们两年之后结了婚，当时我19岁。他是个非常好的人，来自于非常棒的家庭，他是工商管理硕
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 网络编程基础
                        记得开心一点啊
网络
                        
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
    
                    
    • 
                    
  • xilinx vivado PULLMODE 设置思路
                        坚持每天写程序
fpga开发
                        
    1.xilinx引脚分类XilinxIO的分类：以XC7A100TFGG484为例，其引脚分类如下：1.UserIO(用户IO)：用户使用的普通IO1.1专用(Dedicated)IO：命名为IO_LXXY_#、IO_XX_#的引脚，有固定的特定用途，多为底层特定功能的直接实现，如差分对信号、关键控制信号等，不能随意变更。1.2多功能(Multi-Function)IO：命名为IO_LXXY_ZZ
    
                    
    • 
                    
  • Python实现简单的机器学习算法
                        master_chenchengg
pythonpython办公效率python开发IT
                        
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
    
                    
    • 
                    
  • C语言 判断回文数
                        Y雨何时停T
c语言学习
                        
    一，回文数概念“回文”是指正读反读都能读通的句子，它是古今中外都有的一种修辞方式和文字游戏，如“我为人人，人人为我”等。在数学中也有这样一类数字有这样的特征，成为回文数。设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等，则称n为一回文数。例如，若n=1234321，则称n为一回文数；但若n=1234567，则n不是回文数。二，判断回文数实现思路一：数组与字符串将数字每一位按顺序放
    
                    
    • 
                    
  • 九月班级管理工作反思
                        追梦蜂

                        
    这个月应该算是最难的一个月，我已N年没当班主任，然后我又开始当了。职称是一方面，想到我如果退休了，不能再接触学生了，那该是多么遗憾的事！我的学生梁*铭是我的榜样，她那么努力，那么拼，那么上进，为什么我不行？虽然我面临的工作很难，但是高考数学也不容易。她拿下来了！满分150分她考了146分！我目睹她的艰辛，她的拼搏！还有，我要为我的孩子做榜样，如何竭尽全力，实现梦想。还有，服务，为社会做事，也是会有
    
                    
    • 
                    
  • 2021-01-24
                        9ce517ee104c

                        
    【打卡素材】《香帅金融学讲义》【标题】公司治理：怎样同床异梦地过下去【日期】2021.1.24【字数】公司本质上是一连串的合约关系。降低合同执行中的各种摩擦是公司正常有效运行的基础。协同各方的利益、制衡各方的权力是关键。为解决利益冲突问题、协同各方利益，进行权力制衡的机制设计就是公司治理机制。001什么是公司治理治理是管理的基础，治理机制越好，权、责、利就越清晰，管理的目标也就会更容易实现。002
    
                    
    • 
                    
  • 读书笔记|《遇见孩子，遇见更好的自己》5
                        抹茶社长

                        
    为人父母意味着放弃自己的过去，不要对以往没有实现的心愿耿耿于怀，只有这样，孩子们才能做回自己。985909803.jpg孩子在与父母保持亲密的同时更需要独立，唯有这样，孩子才会成为孩子，父母才会成其为父母。有耐心的人生往往更幸福，给孩子留点余地。认识到养儿育女是对耐心的考验。为失败做好心理准备，教会孩子控制情绪。了解自己的底线，说到底线，有一点很重要，父母之所以发脾气，真正的原因往往在于他们自己，
    
                    
    • 
                    
  • 推荐算法_隐语义-梯度下降
                        _feivirus_
算法机器学习和数学推荐算法机器学习隐语义
                        
    importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                                
  • 多线程编程之存钱与取钱
                                    周凡杨
javathread多线程存钱取钱
                                    
      
生活费问题是这样的：学生每月都需要生活费，家长一次预存一段时间的生活费，家长和学生使用统一的一个帐号，在学生每次取帐号中一部分钱，直到帐号中没钱时 通知家长存钱，而家长看到帐户还有钱则不存钱，直到帐户没钱时才存钱。   
问题分析：首先问题中有三个实体，学生、家长、银行账户，所以设计程序时就要设计三个类。其中银行账户只有一个，学生和家长操作的是同一个银行账户，学生的行为是
    
                                
    • 
                                
  • java中数组与List相互转换的方法
                                    征客丶
JavaScriptjavajsonp
                                    
    1.List转换成为数组。（这里的List是实体是ArrayList) 
　　调用ArrayList的toArray方法。 
　　toArray 
　　public T[] toArray(T[] a)返回一个按照正确的顺序包含此列表中所有元素的数组；返回数组的运行时类型就是指定数组的运行时类型。如果列表能放入指定的数组，则返回放入此列表元素的数组。否则，将根据指定数组的运行时类型和此列表的大小分
    
                                
    • 
                                
  • Shell 流程控制
                                    daizj
流程控制if elsewhilecaseshell
                                    
    Shell 流程控制 
和Java、PHP等语言不一样，sh的流程控制不可为空，如(以下为PHP流程控制写法)： 
<?php
if(isset($_GET["q"])){
    search(q);}else{// 不做任何事情} 
在sh/bash里可不能这么写，如果else分支没有语句执行，就不要写这个else，就像这样  if else if 
if 语句语
    
                                
    • 
                                
  • Linux服务器新手操作之二
                                    周凡杨
Linux 简单 操作
                                    
    1.利用关键字搜寻Man Pages    man -k keyword  其中-k 是选项，keyword是要搜寻的关键字 如果现在想使用whoami命令，但是只记住了前3个字符who，就可以使用 man -k who来搜寻关键字who的man命令       [haself@HA5-DZ26 ~]$ man -k 
    
                                
    • 
                                
  • socket聊天室之服务器搭建
                                    朱辉辉33
socket
                                    
    因为我们做的是聊天室，所以会有多个客户端，每个客户端我们用一个线程去实现，通过搭建一个服务器来实现从每个客户端来读取信息和发送信息。 
   我们先写客户端的线程。 
public class ChatSocket extends Thread{ 
 Socket socket; 
 
 public ChatSocket(Socket socket){ 
 this.sock
    
                                
    • 
                                
  • 利用finereport建设保险公司决策分析系统的思路和方法
                                    老A不折腾
finereport金融保险分析系统报表系统项目开发
                                    
    决策分析系统呈现的是数据页面，也就是俗称的报表，报表与报表间、数据与数据间都按照一定的逻辑设定，是业务人员查看、分析数据的平台，更是辅助领导们运营决策的平台。底层数据决定上层分析，所以建设决策分析系统一般包括数据层处理（数据仓库建设）。 
  
项目背景介绍 
通常，保险公司信息化程度很高，基本上都有业务处理系统（像集团业务处理系统、老业务处理系统、个人代理人系统等）、数据服务系统（通过
    
                                
    • 
                                
  • 始终要页面在ifream的最顶层
                                    林鹤霄

                                    
    index.jsp中有ifream，但是session消失后要让login.jsp始终显示到ifream的最顶层。。。始终没搞定，后来反复琢磨之后，得到了解决办法，在这儿给大家分享下。。 
index.jsp--->主要是加了颜色的那一句 
<html> 
<iframe name="top" ></iframe> 
<ifram
    
                                
    • 
                                
  • MySQL binlog恢复数据
                                    aigo
mysql
                                    
    1，先确保my.ini已经配置了binlog： 
  
# binlog
log_bin = D:/mysql-5.6.21-winx64/log/binlog/mysql-bin.log
log_bin_index = D:/mysql-5.6.21-winx64/log/binlog/mysql-bin.index
log_error = D:/mysql-5.6.21-win
    
                                
    • 
                                
  • OCX打成CBA包并实现自动安装与自动升级
                                    alxw4616
ocxcab
                                    
    近来手上有个项目,需要使用ocx控件 
(ocx是什么? 
http://baike.baidu.com/view/393671.htm) 
在生产过程中我遇到了如下问题. 
1. 如何让 ocx 自动安装? 
    a) 如何签名? 
    b) 如何打包? 
    c) 如何安装到指定目录? 
2.
    
                                
    • 
                                
  • Hashmap队列和PriorityQueue队列的应用
                                    百合不是茶
Hashmap队列PriorityQueue队列
                                    
      
HashMap队列已经是学过了的,但是最近在用的时候不是很熟悉,刚刚重新看以一次, 
  HashMap是K,v键 ,值   
  
put()添加元素 
  
  
 //下面试HashMap去掉重复的 
package com.hashMapandPriorityQueue;

import java.util.H
    
                                
    • 
                                
  • JDK1.5 returnvalue实例
                                    bijian1013
javathreadjava多线程returnvalue
                                    
    Callable接口： 
返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做 call 的方法。 
Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。 
        
ExecutorService接口方
    
                                
    • 
                                
  • angularjs指令中动态编译的方法(适用于有异步请求的情况) 内嵌指令无效
                                    bijian1013
JavaScriptAngularJS
                                    
            在directive的link中有一个$http请求，当请求完成后根据返回的值动态做element.append('......');这个操作，能显示没问题，可问题是我动态组的HTML里面有ng-click，发现显示出来的内容根本不执行ng-click绑定的方法！ 
    
    
                                
    • 
                                
  • 【Java范型二】Java范型详解之extend限定范型参数的类型
                                    bit1129
extend
                                    
    在第一篇中，定义范型类时，使用如下的方式： 
  
public class Generics<M, S, N> {
   //M,S,N是范型参数
} 
 这种方式定义的范型类有两个基本的问题： 
  
1. 范型参数定义的实例字段，如private M m = null;由于M的类型在运行时才能确定，那么我们在类的方法中，无法使用m，这跟定义pri
    
                                
    • 
                                
  • 【HBase十三】HBase知识点总结
                                    bit1129
hbase
                                    
    1. 数据从MemStore flush到磁盘的触发条件有哪些？ 
   a.显式调用flush，比如flush 'mytable' 
   b.MemStore中的数据容量超过flush的指定容量，hbase.hregion.memstore.flush.size,默认值是64M 2. Region的构成是怎么样？ 
1个Region由若干个Store组成
    
                                
    • 
                                
  • 服务器被DDOS攻击防御的SHELL脚本
                                    ronin47

                                    
    mkdir /root/bin
vi /root/bin/dropip.sh
#!/bin/bash/bin/netstat -na|grep ESTABLISHED|awk ‘{print $5}’|awk -F:‘{print $1}’|sort|uniq -c|sort -rn|head -10|grep -v -E ’192.168|127.0′|awk ‘{if($2!=null&a
    
                                
    • 
                                
  • java程序员生存手册-craps 游戏-一个简单的游戏
                                    bylijinnan
java
                                    
    
import java.util.Random;


public class CrapsGame {

	/**
	 *
	 *一个简单的赌*博游戏，游戏规则如下：
	 *玩家掷两个骰子，点数为1到6，如果第一次点数和为7或11，则玩家胜，
	 *如果点数和为2、3或12，则玩家输，
	 *如果和为其它点数，则记录第一次的点数和，然后继续掷骰，直至点数和等于第一次掷出的点
    
                                
    • 
                                
  • TOMCAT启动提示NB: JAVA_HOME should point to a JDK not a JRE解决
                                    开窍的石头
JAVA_HOME
                                    
    当tomcat是解压的时候，用eclipse启动正常，点击startup.bat的时候启动报错; 
报错如下： 
  The JAVA_HOME environment variable is not defined correctly 
This environment variable is needed to run this program 
NB: JAVA_HOME shou
    
                                
    • 
                                
  • [操作系统内核]操作系统与互联网
                                    comsci
操作系统
                                    
     
 
     我首先申明：我这里所说的问题并不是针对哪个厂商的，仅仅是描述我对操作系统技术的一些看法 
 
 
      操作系统是一种与硬件层关系非常密切的系统软件，按理说，这种系统软件应该是由设计CPU和硬件板卡的厂商开发的，和软件公司没有直接的关系，也就是说，操作系统应该由做硬件的厂商来设计和开发
    
                                
    • 
                                
  • 富文本框ckeditor_4.4.7 文本框的简单使用 支持IE11
                                    cuityang
富文本框
                                    
    <html xmlns="http://www.w3.org/1999/xhtml"> 
<head> 
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> 
<title>知识库内容编辑</tit
    
                                
    • 
                                
  • Property null not found
                                    darrenzhu
datagridFlexAdvancedpropery null
                                    
    When you got error message like "Property null not found ***", try to fix it by the following way: 
 
1)if you are using AdvancedDatagrid, make sure you only update the data in the data prov
    
                                
    • 
                                
  • MySQl数据库字符串替换函数使用
                                    dcj3sjt126com
mysql函数替换
                                    
    需求：需要将数据表中一个字段的值里面的所有的  .   替换成  _   
原来的数据是  site.title  site.keywords  .... 
替换后要为     site_title  site_keywords 
  
使用的SQL语句如下： 
  
updat
    
                                
    • 
                                
  • mac上终端起动MySQL的方法
                                    dcj3sjt126com
mysqlmac
                                    
    首先去官网下载: http://www.mysql.com/downloads/ 
我下载了5.6.11的dmg然后安装,安装完成之后..如果要用终端去玩SQL.那么一开始要输入很长的:/usr/local/mysql/bin/mysql 
这不方便啊,好想像windows下的cmd里面一样输入mysql -uroot -p1这样...上网查了下..可以实现滴. 
打开终端,输入: 
1
    
                                
    • 
                                
  • Gson使用一（Gson）
                                    eksliang
jsongson
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2175401 一.概述 
从结构上看Json，所有的数据（data）最终都可以分解成三种类型： 
 
 第一种类型是标量（scalar），也就是一个单独的字符串（string）或数字（numbers），比如"ickes"这个字符串。 
 第二种类型是序列（sequence），又叫做数组（array）
    
                                
    • 
                                
  • android点滴4
                                    gundumw100
android
                                    
    Android 47个小知识 
 
http://www.open-open.com/lib/view/open1422676091314.html 
 
 Android实用代码七段（一） 
 
http://www.cnblogs.com/over140/archive/2012/09/26/2611999.html 
 
http://www.cnblogs.com/over140/arch
    
                                
    • 
                                
  • JavaWeb之JSP基本语法
                                    ihuning
javaweb
                                    
      
目录 
  
JSP模版元素  
JSP表达式  
JSP脚本片断  
EL表达式  
JSP注释  
特殊字符序列的转义处理  
如何查找JSP页面中的错误 
  
JSP模版元素  
  
JSP页面中的静态HTML内容称之为JSP模版元素，在静态的HTML内容之中可以嵌套JSP
    
                                
    • 
                                
  • App Extension编程指南（iOS8/OS X v10.10）中文版
                                    啸笑天
ext
                                    
      
  
  
  
 当iOS 8.0和OS X v10.10发布后，一个全新的概念出现在我们眼前，那就是应用扩展。顾名思义，应用扩展允许开发者扩展应用的自定义功能和内容，能够让用户在使用其他app时使用该项功能。你可以开发一个应用扩展来执行某些特定的任务，用户使用该扩展后就可以在多个上下文环境中执行该任务。比如说，你提供了一个能让用户把内容分
    
                                
    • 
                                
  • SQLServer实现无限级树结构
                                    macroli
oraclesqlSQL Server
                                    
     
 表结构如下： 
 数据库id path titlesort 排序 1 0 首页 0 2 0,1 新闻 1 3 0,2 JAVA 2 4 0,3 JSP 3 5 0,2,3 业界动态 2 6 0,2,3 国内新闻 1 
 创建一个存储过程来实现，如果要在页面上使用可以设置一个返回变量将至传过去 
   
 create procedure test
as
begin
decla
    
                                
    • 
                                
  • Css居中div，Css居中img，Css居中文本，Css垂直居中div
                                    qiaolevip
众观千象学习永无止境每天进步一点点css
                                    
    /**********Css居中Div**********/
div.center {
  width: 100px;
  margin: 0 auto;
}
/**********Css居中img**********/
img.center {
  display: block;
  margin-left: auto;
  margin-right: auto;
}


    
                                
    • 
                                
  • Oracle 常用操作(实用)
                                    吃猫的鱼
oracle
                                    
     
  SQL>select text from all_source where owner=user and name=upper('&plsql_name');
  SQL>select * from user_ind_columns where index_name=upper('&index_name');  将表记录恢复到指定时间段以前
    
                                
    • 
                                
  • iOS中使用RSA对数据进行加密解密
                                    witcheryne
iosrsaiPhoneobjective c
                                    
      
RSA算法是一种非对称加密算法,常被用于加密数据传输.如果配合上数字摘要算法, 也可以用于文件签名. 
本文将讨论如何在iOS中使用RSA传输加密数据. 本文环境 
 
 mac os  
 openssl-1.0.1j, openssl需要使用1.x版本, 推荐使用[homebrew](http://brew.sh/)安装. 
 Java 8 
 RSA基本原理 
RS
    
                                
    •