南国_之恋
南国_之恋

Spring源码分析-深入浅出AOP(图文分析)

这篇文章主要解决三个问题

什么是AOP
Spring 中怎么实现的AOP
AOP的应用场景


首先我们看下 到底什么是AOP

AOP的基本概念
AOP 官方定义

    Aspect-Oriented Programming (AOP) complements Object-Oriented Programming (OOP) by providing another way of thinking about program structure.
1
( 面向方面的编程(AOP)是面向对象编程(OOP)的补充，它提供了另一种关于程序结构的思考方式)
1
这个解释听起来很抽象，如何理解呢?

我们知道面向对象编程关注的是对象和对象的行为，相同类似行为或属性的对象可以通过继承来实现，但是如果我们关注的是毫不相干的一组对象的特定方法 怎么办

如图，我们要关注的方法 散布在不同类中，如果想要在这些方法中加入相同的处理逻辑，过去我们采用的方法只能是硬编码，但是这样会造成大量的重复代码，不便于维护，AOP的出现就是解决针对这种问题的一种实现模式。

首先我们看下AOP中涉及到的几个重要的基本概念

Aspect：字面意思是切面，官方解释 a modularization of a concern that cuts across multiple classes ( 横切多个类的一个关注点模块)，简单说就是对类具体行为的关注点集合，这样解释还是太抽象

上图中 可以看到 对多个类关注的方法 形成的一个切面，就是Aspect

Join point: a point during the execution of a program, such as the execution of a method or the handling of an exception. In Spring AOP, a join point always represents a method execution（程序执行过程中的里连接点，比如 方法调用或者异常处理。在spring aop中，一个连接点通常代表一个方法的调用，我们可以认为一个方法的执行就是一个连接点）

Advice: action taken by an aspect at a particular join point. Different types of advice include “around,” “before” and “after” advice. (Advice types are discussed below.)（通知：切面在特定连接点上产生的动作，包括多种不同类型的通知，比如 环绕通知 aroud,前置通知before和后置通知after等）

简单的说就是我们要在切面上做什么事情(动作-action)

Pointcut: a predicate that matches join points. Advice is associated with a pointcut expression and runs at any join point matched by the pointcut (for example, the execution of a method with a certain name).(切入点，匹配连接点的断言，通知与切入点表达式相关联，并且在任何匹配该断言的连接点上执行(比如一个特定名称的方法执行))

用来描述我们要在哪些地方执行,也可以说成是 用表达式匹配(正则断言)的切入点

Target object: object being advised by one or more aspects. Also referred to as the advised object(目标对象 ，被一个或多个切面通知的对象，通常被称为被通知对象)

Proxy Pattern(代理模式)
GOF 定义
What problems can the Proxy design pattern solve? （代理模式能解决什么问题）

The access to an object should be controlled.(控制被访问对象)
Additional functionality should be provided when accessing an
object.(给被访问对象提供额外功能)
What solution does the Proxy design pattern describe?(代理模式的解决方案是如何描述的)
Define a separate Proxy object that can be used as substitute for another object (Subject) and implements additional functionality to control the access to this subject.
(定义一个单独的代理类，用来提供对目标对象的代理访问 如下图所示 代理类会默认实现目标对象的接口,并在此基础上提供其他功能)

Spring AOP Revolution(进化史)

详细内容可以参考 这里不再详述
http://cxis.me/2017/04/10/Spring%E4%B8%ADAOP%E7%9A%84%E9%85%8D%E7%BD%AE%E4%BB%8E1.0%E5%88%B05.0%E7%9A%84%E6%BC%94%E8%BF%9B/

Spring如何实现AOP
我们重点使用最新最简洁的spring 5 自动配置模式来进行讲解
这里我们通过一个性能拦截器来演示spring aop的代码流程，这个拦截器可以打印服务层所有方法的执行时间

CODE

业务接口定义

/**
 * 业务服务接口
 */
public interface IBusinessService {

    //业务执行方法A
    void executeBusinessA();

    //业务执行方法B
    void executeBusinessB();


}
1
2
3
4
5
6
7
8
9
10
11
12
13
业务实现类

/**
 * 业务实现类
 */
@Service("businessService")
public class BusinessServiceImpl implements IBusinessService {

    private  static final Logger logger = LogManager.getLogger(BusinessServiceImpl.class);

    /**
     * 常规业务方法（不超时）
     */
    public void executeBusinessA() {
        //模拟一个执行时间
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            System.out.println(e.getMessage());
        }

        logger.info("executing business in methodA");

    }


    /**
     * 超时业务方法
     */
    public void executeBusinessB() {
        //模拟一个超时执行时间
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            System.out.println(e.getMessage());
        }

        logger.info("executing business in methodB");

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
性能分析器

@Component
@Aspect
public class PerformanceAnalysisInterceptor {

    private static Logger logger = LogManager.getLogger(PerformanceAnalysisInterceptor.class);
    private static final long DELAY_MINUTE = 1000;

    public static final String POINTCUT = "execution (* aop.service.impl.BusinessServiceImpl.*(..))";

    @Around(POINTCUT)
    public Object analysisAround(ProceedingJoinPoint joinPoint) {
        Object obj = null;
        long startTime = System.currentTimeMillis();
        try {
            obj = joinPoint.proceed(joinPoint.getArgs());
        } catch (Throwable e) {
            logger.error(e.getMessage());
        }

        long endTime = System.currentTimeMillis();
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String methodName = signature.getDeclaringTypeName() + "." + signature.getName();
        long diffTime = endTime - startTime;

        logger.info("-----" + methodName + "执行时间 ：" + diffTime + " ms");
        if(diffTime > DELAY_MINUTE)
        delayWarning(methodName, diffTime-DELAY_MINUTE);

        return obj;
    }

    private void delayWarning(String methodName,long delayTime) {
            logger.warn("-----" + methodName + "超时 ：" + delayTime + " ms");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
xml自动化配置


       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

   
   


1
2
3
4
5
6
7
8
9
10
11
12
主函数调用执行

public class AopMain {

    public static void main(String[] args) {

        ClassPathXmlApplicationContext f = new ClassPathXmlApplicationContext("spring-aop.xml");
        IBusinessService businessService = (IBusinessService) f.getBean("businessService");
        businessService.executeBusinessA();
        businessService.executeBusinessB();

    }
}
1
2
3
4
5
6
7
8
9
10
11
concole打印结果

11:21:36.344 [main] INFO  org.springframework.context.support.ClassPathXmlApplicationContext - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@7dc222ae: startup date [Sat Dec 09 11:21:36 CST 2017]; root of context hierarchy
11:21:36.393 [main] INFO  org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loading XML bean definitions from class path resource [spring-aop.xml]
11:21:37.245 [main] INFO  aop.service.impl.BusinessServiceImpl - executing business in methodA
11:21:37.247 [main] INFO  aop.interceptor.PerformanceAnalysisInterceptor - -----aop.service.IBusinessService.executeBusinessA执行时间 ：203 ms
11:21:38.250 [main] INFO  aop.service.impl.BusinessServiceImpl - executing business in methodB
11:21:38.250 [main] INFO  aop.interceptor.PerformanceAnalysisInterceptor - -----aop.service.IBusinessService.executeBusinessB执行时间 ：1003 ms
11:21:38.250 [main] WARN  aop.interceptor.PerformanceAnalysisInterceptor - -----aop.service.IBusinessService.executeBusinessB超时 ：3 ms

Process finished with exit code 0
1
2
3
4
5
6
7
8
9
下边我们进行代码的详细分析

我们看到 xml配置文件里边只有两行配置信息，第一行配置是context自动扫描，作用是扫描制定范围的组件并注册到spring，第二行是注解Aspect自动发现

这样解释还是有点抽象，我们从两个问题入手（问题是揭开真相的火花）

第一个问题，spring怎么识别出需要代理的目标对象，也就是我们这里边实现了IBusinessService接口的BusinessServiceImpl对象

第二问题是  我们定义的这个切面(aspect注解的bean)怎么被发现并应用到目标对象(businessService)
1
2
3
第一个问题属于spring ioc的范围，看过ioc部分的同学基本应该能够理解，入手点就是对 context 这个标签的处理 我们全局搜索component-scan这个关键字，最后代码定位到 ContextNamespaceHandler类

spring加载完xml配置文件，会对配置文件中的标签进行解析，spring默认会加载自己的解析器，这些解析器散布在各个不同的jar包中

这些配置文件中的handlers就是spring对默认标签的处理器，我们看下context包下的spring.handlers文件

spring在解析标签时，通过实现NamespaceHandlerResolver接口的DefaultNamespaceHandlerResolver加载所有classpath下的spring.handlers文件中的映射，并在解析标签时，寻找这些标签对应的处理器，然后用这些处理器来处理标签。所以，当遇到component-scan标签，spring 容器就会使用ComponentScanBeanDefinitionParser标签进行解析，我们看下ComponentScanBeanDefinitionParser来的parse方法

public BeanDefinition parse(Element element, ParserContext parserContext) {
    //取base-package属性
   String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
   //解析base-packet属性(通配符)
   basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
   //转换成数组(用，或者；分割的定义)
   String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
         ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

   // Actually scan for bean definitions and register them.
   ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
    //扫描basepacket下所有的bean
   Set beanDefinitions = scanner.doScan(basePackages);
    //注册到spring中
   registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

   return null;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
进入扫描方法
protected Set doScan(String... basePackages) {
   Assert.notEmpty(basePackages, "At least one base package must be specified");
   Set beanDefinitions = new LinkedHashSet<>();
   for (String basePackage : basePackages) {
      Set candidates = findCandidateComponents(basePackage);
      for (BeanDefinition candidate : candidates) {
         ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
         candidate.setScope(scopeMetadata.getScopeName());
         String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
         if (candidate instanceof AbstractBeanDefinition) {
            postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
         }
         if (candidate instanceof AnnotatedBeanDefinition) {
            AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
         }
         if (checkCandidate(beanName, candidate)) {
            BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
            definitionHolder =
                  AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
            beanDefinitions.add(definitionHolder);
            registerBeanDefinition(definitionHolder, this.registry);
         }
      }
   }
   return beanDefinitions;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
这里我们看到，spring会扫描base-package指定资源路径下所有的java文件，并依次解析成对应的内部映射BeanDefinition，最后注册到spring容器中，方便后续调用 具体分析不再展开
可以参考 : http://www.cnblogs.com/question-sky/p/6953315.html

OK，我们已经知道spring怎么发现bean，那么第二问题是 我们定义的这个切面(aspect注解的bean)怎么被发现并应用到目标对象(businessService)，这也是我们
要分析的重点，这也是第二行标签的作用

我们看到 PerformanceAnalysisInterceptor类的注解有两个 一个是 @Component 一个是@Aspect Component标签刚才已经解释过，说明这是一个spring的组件，已经注册到spring中，那Aspect注解呢？根据刚才的分析 我们知道 spring对于不同的标签采用不同的处理器，同理，这里Aspect也有对应的标签处理器,进过全局搜索，我们发现在AopNamespaceHandler中

我们进入AspectJAutoProxyBeanDefinitionParser的parse方法

public BeanDefinition parse(Element element, ParserContext parserContext) {
//注册AspectJAnnotationAutoProxyCreator
   AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
   extendBeanDefinition(element, parserContext);
   return null;
}
1
2
3
4
5
6
进入registerAspectJAutoProxyCreatorIfNecessary方法
public static void registerAspectJAutoProxyCreatorIfNecessary(
      ParserContext parserContext, Element sourceElement) {

    //把应用了注解@Aspect的bean注册成BeanDefiniton
   BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary(
         parserContext.getRegistry(), parserContext.extractSource(sourceElement));
    //处理proxy-target-class和expose-proxy属性
   useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
    //注册组件并通知监听器
   registerComponentIfNecessary(beanDefinition, parserContext);
}
1
2
3
4
5
6
7
8
9
10
11
我们重点看下第一个流程 进入方法体
public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry,
      @Nullable Object source) {

   return registerOrEscalateApcAsRequired(AspectJAwareAdvisorAutoProxyCreator.class, registry, source);
}

private static BeanDefinition registerOrEscalateApcAsRequired(Class cls, BeanDefinitionRegistry registry,
      @Nullable Object source) {

   Assert.notNull(registry, "BeanDefinitionRegistry must not be null");

   if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
      BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
      if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
         int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
         int requiredPriority = findPriorityForClass(cls);
         if (currentPriority < requiredPriority) {
            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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
这里我们看到，spring会注册一个内部的BeanDefiniton key是 org.springframework.aop.config.internalAutoProxyCreator

从AspectJAwareAdvisorAutoProxyCreator结构图，我们看到它实现了BeanPostProcessor接口，意味着spring在加载整个bean时，实例化前会调用
postProcessAfterInitialization方法，我们进入这个方法（在父类AbstractAutoProxyCreator中）

public Object postProcessAfterInitialization(@Nullable 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;
}
1
2
3
4
5
6
7
8
9
重点是方法wrapIfNecessary,这个方法的作用就是 如果目标bean能够被代理，则使用代理进行包裹

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    //如果已经处理过，直接返回
   if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
      return bean;
   }
    //无需增强
   if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
      return bean;
   }
    //如果是基础类比如 advice pointcut advisor 这些基础aop类则直接返回
   if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
      this.advisedBeans.put(cacheKey, Boolean.FALSE);
      return bean;
   }

   // Create proxy if we have advice.
    //获取被代理类所有的拦截器
   Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
   if (specificInterceptors != DO_NOT_PROXY) {
      this.advisedBeans.put(cacheKey, Boolean.TRUE);
    //创建代理
      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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
这里我们看到了AOP逻辑的核心 ,整个流程很清晰，首先获取这个bean对应的所有拦截器 如果拦截为空，直接返回bean,否则 创建对应的代理 然后返回代理bean
这里有两个重点分析部分 一个是拦截器的获取，一个是如何代理

我们先开拦截器的获取

protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass, String beanName, @Nullable TargetSource targetSource) {
   List advisors = findEligibleAdvisors(beanClass, beanName);
   if (advisors.isEmpty()) {
      return DO_NOT_PROXY;
   }
   return advisors.toArray();
}
1
2
3
4
5
6
7
protected List findEligibleAdvisors(Class beanClass, String beanName) {
    //获取所有的拦截增强器
   List candidateAdvisors = findCandidateAdvisors();
    //看哪些拦截增强器可以应用到目标bean
   List eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
   extendAdvisors(eligibleAdvisors);
   if (!eligibleAdvisors.isEmpty()) {
      eligibleAdvisors = sortAdvisors(eligibleAdvisors);
   }
   return eligibleAdvisors;
}
1
2
3
4
5
6
7
8
9
10
11
protected List findCandidateAdvisors() {
   // Add all the Spring advisors found according to superclass rules.
   //通过父类来加载配置文件中的拦截器
   List advisors = super.findCandidateAdvisors();
   // Build Advisors for all AspectJ aspects in the bean factory.
   if (this.aspectJAdvisorsBuilder != null) {
     //获取AOP注解拦截器
      advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
   }
   return advisors;
}
1
2
3
4
5
6
7
8
9
10
11
从代码来看，拦截器分成两部分，一部分来源是配置文件，一部分是应用了注解的bean，在我们的演示案例中配置文件中没有对应的拦截器xml配置，只有注解的@Aspect，所以我们直接分析this.aspectJAdvisorsBuilder.buildAspectJAdvisors方法

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<>();
            //获取所有注册的beanName
            String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                  this.beanFactory, Object.class, true, false);
            for (String beanName : beanNames) {
                // 子类定义规则来过滤bean
               if (!isEligibleBean(beanName)) {
                  continue;
               }
               // We must be careful not to instantiate beans eagerly as in this case they
               // would be cached by the Spring container but would not have been weaved.
                //获取bean类型
               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);

                        //解析Aspect注解中的拦截器方法(比如 @After @Before @Aroud等)
                     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();
   }
    //缓存
   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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
到这里其实已经找到了 我们的性能拦截器 PerformanceAnalysisInterceptor 因为它上边的@Aspect注解标识了它就是一个拦截器切面 ，下边就是解析这个切面中的规则(Pointcut定义)和拦截方法(Advice)

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

   // We need to wrap the MetadataAwareAspectInstanceFactory with a decorator
   // so that it will only instantiate once.
   MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
         new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);

   List advisors = new LinkedList<>();

// 获取切面拦截器的所有拦截方法
   for (Method method : getAdvisorMethods(aspectClass)) {
    //获取拦截器方法(增强)并包装成advisor
      Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
      if (advisor != null) {
         advisors.add(advisor);
      }
   }

   // If it's a per target aspect, emit the dummy instantiating aspect.
   if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
      Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
      advisors.add(0, instantiationAdvisor);
   }

   // Find introduction fields
    //获取DeclareParents注解 
   for (Field field : aspectClass.getDeclaredFields()) {
      Advisor advisor = getDeclareParentsAdvisor(field);
      if (advisor != null) {
         advisors.add(advisor);
      }
   }

   return advisors;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
进入getAdvisor方法
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;
   }

//根据pointcut生成拦截器对象
   return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
         this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
这里getPointcut方法就是如何解析 PerformanceAnalysisInterceptor中的@Around(POINTCUT)

具体看下实现

private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class candidateAspectClass) {
   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());
   if (this.beanFactory != null) {
      ajexp.setBeanFactory(this.beanFactory);
   }
   return ajexp;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//获取制定方法上的注解
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
这里是从spring提供的所有候选注解类中寻找 当前方法上的注解 并封装成 AspectJAnnotation对象 对于我们定义的性能拦截器PerformanceAnalysisInterceptor
上边只有一个@Around注解，所以这里的Advisor也就只有一个(Advisor可以看成advice和pointcut的集合),下边就是这些找到的拦截器中哪些可以应用到目标对象的方法上

List eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
1
public static List findAdvisorsThatCanApply(List candidateAdvisors, Class clazz) {
   if (candidateAdvisors.isEmpty()) {
      return candidateAdvisors;
   }
   List eligibleAdvisors = new LinkedList<>();
   for (Advisor candidate : candidateAdvisors) {
      if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
         eligibleAdvisors.add(candidate);
      }
   }
   boolean hasIntroductions = !eligibleAdvisors.isEmpty();
   for (Advisor candidate : candidateAdvisors) {
      if (candidate instanceof IntroductionAdvisor) {
         // already processed
         continue;
      }
      if (canApply(candidate, clazz, hasIntroductions)) {
         eligibleAdvisors.add(candidate);
      }
   }
   return eligibleAdvisors;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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 {
      // It doesn't have a pointcut so we assume it applies.
      return true;
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
我们定义的是PointcutAdvisor
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;
   }

   MethodMatcher methodMatcher = pc.getMethodMatcher();
   if (methodMatcher == MethodMatcher.TRUE) {
      // No need to iterate the methods if we're matching any method anyway...
      return true;
   }

   IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
   if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
      introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
   }

   Set> classes = new LinkedHashSet<>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
   classes.add(targetClass);
   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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
这里的大体逻辑是 用找到的切点断言匹配当前bean的所有方法，过滤 找到匹配的切点 到此为止我们已经看到spring是如何一步一步的解析我们声明的注解@Aspect的切面spring会把这些注解@Aspect的类当成拦截器 找到了目标bean(BusinessServiceImpl)的拦截器，下一步就是判断拦截器是否为空，为空说明不需要生成代理，直接返回bean，否则就需要创建一个目标bean的代理，这也就是我们常说的代理模式的应用，如图所示，所有对目标对象的访问都通过代理来实现，这样我们就可以把拦截器应用到目标对象上

下边我们重点分析第二步流程，spring中如何创建代理

Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
1
protected Object createProxy(Class beanClass, @Nullable String beanName,
      @Nullable Object[] specificInterceptors, TargetSource targetSource) {

   if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
      AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
   }

   ProxyFactory proxyFactory = new ProxyFactory();
   proxyFactory.copyFrom(this);

   if (!proxyFactory.isProxyTargetClass()) {
      if (shouldProxyTargetClass(beanClass, beanName)) {
         proxyFactory.setProxyTargetClass(true);
      }
      else {
         evaluateProxyInterfaces(beanClass, proxyFactory);
      }
   }

   Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
   proxyFactory.addAdvisors(advisors);
   proxyFactory.setTargetSource(targetSource);
   customizeProxyFactory(proxyFactory);

   proxyFactory.setFrozen(this.freezeProxy);
   if (advisorsPreFiltered()) {
      proxyFactory.setPreFiltered(true);
   }

   return proxyFactory.getProxy(getProxyClassLoader());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
我们看到，spring把创建代理的责任交给了**ProxyFactory**，我们看下getPorxy主流程
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);
      }
      return new ObjenesisCglibAopProxy(config);
   }
   else {
      return new JdkDynamicAopProxy(config);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
从这里我们可以很清楚的看到，spring通过两种方式创建代理，分别是JdkDynamicAopProxy和ObjenesisCglibAopProxy，这两个就是我们常说的jdk动态代理和cglib代理(基于字节码)

spring怎么区分通过哪种代理是通过三个判断

 isOptimeiz         对CGlib代理的创建优化

 isProxyTargetClass 表示使用CGLib进行代理

 hasNoUserSuppliedProxyInterfaces 是否存在代理接口
1
2
3
4
5
三个条件之一后，还有两个判断 是否实现了接口或是否是代理类型，通过上述判断我们可以知道spring选择代理的策略

 如果目标类实现了接口，默认采用jdk动态代理来实现AOP
 如果目标类实现了接口，可以通过配置文件强行使用CGLib来实现AOP代理
 如果目标类没有实现接口，只能使用CGlib来实现AOP代理
1
2
3
这说明CGlib可以为那些没有实现接口的类增强行为，原理是为目标类生成一个子类，并覆盖其中的方法

下边我们重点看下jdk动态代理部分的实现，如果采用jdk动态代理获取代理，关键的调用方法就是invoke调用

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   MethodInvocation invocation;
   Object oldProxy = null;
   boolean setProxyContext = false;

   TargetSource targetSource = this.advised.targetSource;
   Object target = null;

   try {
      if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
         // The target does not implement the equals(Object) method itself.
         return equals(args[0]);
      }
      else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
         // The target does not implement the hashCode() method itself.
         return hashCode();
      }
      else if (method.getDeclaringClass() == DecoratingProxy.class) {
         // There is only getDecoratedClass() declared -> dispatch to proxy config.
         return AopProxyUtils.ultimateTargetClass(this.advised);
      }
      else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
            method.getDeclaringClass().isAssignableFrom(Advised.class)) {
         // Service invocations on ProxyConfig with the proxy config...
         return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
      }

      Object retVal;

      if (this.advised.exposeProxy) {
         // Make invocation available if necessary.
         oldProxy = AopContext.setCurrentProxy(proxy);
         setProxyContext = true;
      }

      // Get as late as possible to minimize the time we "own" the target,
      // in case it comes from a pool.
        //获取目标对象和对象类型
      target = targetSource.getTarget();
      Class targetClass = (target != null ? target.getClass() : null);

      // Get the interception chain for this method.
    //获取目标对象上当前方法的的所有拦截器链(已经注入到代理类的属性中，直接可以获取)
      List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

      // Check whether we have any advice. If we don't, we can fallback on direct
      // reflective invocation of the target, and avoid creating a MethodInvocation.
      if (chain.isEmpty()) {
         // We can skip creating a MethodInvocation: just invoke the target directly
         // Note that the final invoker must be an InvokerInterceptor so we know it does
         // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
        //如果没有任何拦截器，则直接调用目标对象的切点方法
         Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
         retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
      }
      else {

         // We need to create a method invocation…
        //执行拦截器的proceed方法
         invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
         // Proceed to the joinpoint through the interceptor chain.
         retVal = invocation.proceed();
      }

      // Massage return value if necessary.
      Class returnType = method.getReturnType();
      if (retVal != null && retVal == target &&
            returnType != Object.class && returnType.isInstance(proxy) &&
            !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
         // Special case: it returned "this" and the return type of the method
         // is type-compatible. Note that we can't help if the target sets
         // a reference to itself in another returned object.
         retVal = proxy;
      }
      else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
         throw new AopInvocationException(
               "Null return value from advice does not match primitive return type for: " + method);
      }
      return retVal;
   }
   finally {
      if (target != null && !targetSource.isStatic()) {
         // Must have come from TargetSource.
         targetSource.releaseTarget(target);
      }
      if (setProxyContext) {
         // Restore old proxy.
         AopContext.setCurrentProxy(oldProxy);
      }
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
进入拦截器的proceed方法

public Object proceed() throws Throwable {
   // We start with an index of -1 and increment early.
    //如果已经执行到最后一个拦截器，就执行切点上的方法
   if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
      return invokeJoinpoint();
   }

    //获取下一个拦截器
   Object interceptorOrInterceptionAdvice =
         this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
   if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
      // Evaluate dynamic method matcher here: static part will already have
      // been evaluated and found to match.
      InterceptorAndDynamicMethodMatcher dm =
            (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
        //匹配当前方法
      if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
         return dm.interceptor.invoke(this);
      }
      else {
         // Dynamic matching failed.
         // Skip this interceptor and invoke the next in the chain.
            //不匹配直接跳过
         return proceed();
      }
   }
   else {
      // It's an interceptor, so we just invoke it: The pointcut will have
      // been evaluated statically before this object was constructed.
    //普通拦截器直接调用
      return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
在这里我们看到spring会循环递归调用代理的invoke方法 这里从代码上看不够直观 下边我们用图形来进行分析 初始状态

这里 proxy bean就是上边的JdkDynamicAopProxy ,里边包含已经解析完的拦截器链和 目标对象 ，当调用目标对象的指定方法时，其实就是调用代理类的processed方法，processed方法先取出拦截器链中第一个拦截器，然后执行第一个拦截器的拦截方法


进入after拦截器后，会先调用目标对象的方法，现在对于目标对象的调用，都有代理对象来处理


这样会再次递归调用代理的invoke方法，下一个拦截器Around开始被调用


进入Around拦截器方法，会默认先执行around前置逻辑，然后在调用目标对象方法，最后执行后置逻辑


当执行Around拦截器的目标对象方法时，会再次递归调用代理的invoke方法，这时会执行最后一个拦截器Before

最后进入Before拦截器，会先执行before逻辑方法，最后调用目标对象方法


调用目标对象的方法会调用代理的invoke方法，这时候代理的所有拦截器都已经调用完毕，所以会直接执行目标对象的方法


执行完目标对象的方法后，会依次回归调用之前的方法

从上边的分析，我们可以知道 最后执行的顺序其实交给了每个要执行的拦截器，通过拦截器中的调用来决定拦截顺序，至此spring aop jdk代理就分析完了，有关CGLib代理方式，这里就不再展开分析，流程大同小异，有兴趣的可以自行研究

文字版

SPRING 通过注解实现AOP的过程的文字描述 - xml配置文件中声明自动发现注解(),spring默认启动时会注册注解解析器(AspectJAutoProxyBeanDefinitionParser)，在注解解析器解析（parse）的过程中，会注册一个实现了BeanPostProcessor的后处理器(AspectJAwareAdvisorAutoProxyCreator),这个后处理器在目标对象实例化后进行拦截处理，拦截的流程是，先搜索所有已经注册的BeanDefiniton,从中找到标记了注解(@Aspect)的切面组成拦截器链，选择那些可以应用到目标对象的拦截器（过滤），如果拦截器链不为空，则为目标对象生成代理(JdkDynamicAopProxy或CglibAopProxy)，当调用目标对象的指定拦截方法时，就会默认调用对应代理类的代理方法(invoke)，这样就完成了AOP的整个流程，

PS 其实在使用过程中，我们都是基于接口进行编程，所以用的最多的也是jdk动态代理，但是当我们目标对象没有实现任何接口，但是我们还想给它增加新的行为，这时候我们就需要CGLib方式，所以具体选择哪种代理方法还要看具体的业务场景

spring AOP应用场景
企业开发里边用的最后的就是 事务拦截器，日志拦截器 性能拦截器 还有 权限拦截器 等等 后边我们分析spring mvc还会介绍spring 拦截器的使用 尽请关注

参考

Spring源码深度解析 https://book.douban.com/subject/25866350/
Spring Partten https://en.wikipedia.org/wiki/Proxy_pattern#cite_note-2
AOP Git source https://github.com/spring-projects/spring-framework
GOF Porxy wiki https://en.wikipedia.org/wiki/Aspect-oriented_programming
 

你可能感兴趣的:(sping)

  • 讨论视频系统架构 Robin-LV MVCJDBC
    今天接到一个业务，领导让我搭建一个视频系统架构。架构采用MVC的模式这个大家都知道，技术采用Sping，hibernate3，数据层采用Sping提供的的jdbc模板。我知道要提供一些公共的的类和接口。还有一些封装好的方法。这个架构要考虑现在老系统的数据，等新系统完成要把数据导过去，还要考虑多平台融合的问题。由于我们公司有多套系统，领导想做底层统一以后好管理。现在晕晕的，请高手谈谈如何搭建一个好的
  • springmvc用配置类替换xml配置 码里法 其他javamvcspring
    ssm基础项目整合前言xml配置mybatis.xmlspingmvc.xmlweb.xml配置类jdbc配置类mybatis配置SpringConfig配置SpringMvcConfig配置shiro配置WebInit前言其实这中间用配置类，发现问题还挺多的，所以记录一下，尤其是针对shiro的配置。xml配置mybatis.xmlArchetypeCreatedWebApplicationdi
  • 干货含源码！如何用Java后端操作Docker（命令行篇） watermelo37 Docker与云原生JavaEE/SpringBootjava开发语言docker云原生容器devopsspringboot
    目录干货含源码！如何用Java后端操作Docker（命令行篇）一、为什么要用后端程序操作Docker二、安装Docker1、安装Docker2、启动Docker三、使用Java后端操作docker1、构建docker镜像并生成容器2、执行完毕后删除容器和镜像3、在此基础上开发其他功能四、总结作者：watermelo37涉及领域：Vue、SpingBoot、Docker、LLM、python等---
  • 架构师面试题系列之Spring MVC面试专题及答案（31题） cesske springmvc面试
    目录1、什么是SpringMvc？说一下你对它的理解2、SpringMVC的优点：3、SpringMVC工作原理？4、SpringMVC的主要组件？5、讲下SpringMvc的执行流程6、SpingMvc中的控制器的注解一般用那个,有没有别的注解可以替代？7、如果在拦截请求中，想拦截get方式提交的方法,怎么配置？8、怎样在控制器方法里面得到request或者session？9、如果想在拦截的方法
  • Spring超硬核笔记———全是干货 Java小羊 spring
    为什么用spring？Spring的核心功能IOC(控制反转，依赖注入)，AOP(面向切面的编程)IOC：我们在使用过程中不用关注于对象是怎么创建的，只用应用过去，sping自动帮我们完成注入，对象的创建，spring默认创建对象是单例，这样减少了频繁创建对象，让对象重复利用，所有的对象都是放在BeanFactory工厂的AOP：面向切面的编程，我们可以把一些公共的东西模块化，做成一个切面，在方法
  • Spring 集成 MyBatis 花下的晚风 java后端转后厨springmybatisjava
    sping6,mybatis3.5.10,maven3.6.1第一步，引入依赖，引入sping6仓库若引入失败可以手动下载好jar包粘贴到本地maven仓库的对应位置org.springframeworkspring-context6.0.0-M2org.springframeworkspring-jdbc6.0.0-M2mysqlmysql-connector-java8.0.31org.myb
  • 解决IDEA2023版本创建Sping项目只能勾选17和21，无法使用Java8的问题 Chen-GW intellij-idea
    前言想创建一个springboot的项目，本地安装的是1.8，但是在使用SpringInitializr创建项目时，发现版本只有17和21。Java17和Java8(JDK1.8)的区别版本号：Java17是JavaSE17的版本，而JDK1.8是JavaSE8的版本。发布时间：Java17发布于2021年，而JDK1.8发布于2014年.新特性：Java17相对于JDK1.8，新增了很多特性和改
  • Unit 2 复盘作业 02成雅轩_人文1班
    Part11，从本单元中我学到的最重要的理念（精读和视听说分别总结）精读：我们不能仅仅只了解一个英文单词的一种词意，反而，我们应该了解英文单词的多种词性词意，这样可以更加有利于我们去理解英语文章视听说：听长句时，没必要强迫自己都听懂，要捕捉关键词，关键信息，发到事半功倍的效果2，我在本片文章／音频／视频中学到的怦然心动的单词（精读和视听说分别总结）视听说：occassionallspingangs
  • JavaWeb：SpingBoot原理 --黑马笔记 DaveVV javawebjavatomcatspringmavenintellij-ideajava-eespringboot
    1.配置优先级在我们前面的课程当中，我们已经讲解了SpringBoot项目当中支持的三类配置文件：application.propertiesapplication.ymlapplication.yaml在SpringBoot项目当中，我们要想配置一个属性，可以通过这三种方式当中的任意一种来配置都可以，那么如果项目中同时存在这三种配置文件，且都配置了同一个属性，如：Tomcat端口号，到底哪一份配
  • SSM框架中Dao层，Mapper层，controller层，service层，model层，entity层介绍 zhang菜鸟 笔记JAVASSM
    SSM是sping+springMVC+mybatis集成的框架。MVC即modelviewcontroller。MyBatis是一款优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis可以使用简单的XML或注解来配置和映射原生信息，将接口和Java的POJOs(PlainOrdinaryJavaObje
  • springboot+vue留守儿童信息管理系统idea项目 QQ402205496 springbootvue.jsintellij-idea
    本留守儿童信息管理系统有管理员和用户两个角色。管理员功能有个人中心，用户管理，留守儿童管理，医院信息管理，医疗服务管理，爱心捐赠管理，留言板管理，系统管理。用户可以注册登录，查看留守儿童信息，对留守儿童信息进行联系医生和爱心捐赠。因而具有一定的实用性。本技术是java平台的开源应用框架，其目的是简化Sping的初始搭建和开发过程。默认配置了很多框架的使用方式，自动加载Jar包，为了让用户尽可能快的
  • 为什么学Spring Boot jiangmo
    Spring历史说起SpringBoot我们不得不先了解一下Spring这个企业，不仅因为SpringBoot来源于Spirng大家族，而且SpringBoot的诞生和Sping框架的发展息息相关。时间回到2002年，当时正是JavaEE和EJB大行其道的时候，很多知名公司都是采用此技术方案进行项目开发。这时候有一个美国的小伙子认为EJB太过臃肿，并不是所有的项目都需要使用EJB这种大型框架，应该
  • SpingBoot项目使用@Validated和@Valid参数校验 Java技术攻略 springjavahibernate
    一、什么是参数校验？我们在后端开发中，经常遇到的一个问题就是入参校验。简单来说就是对一个方法入参的参数进行校验，看是否符合我们的要求。比如入参要求是一个金额，你前端没做限制，用户随便过来一个负数，或者一个字母，那么我们的接口就会报错。所以，通常我们需要在方法的开始处，对入参的参数进行校验，不符合要求就报错返回，不往下进行。这个校验的过程就是参数校验。二、为什么需要统一参数校验？明白了什么是参数校验
  • Sping Cloud Hystrix 花开不合阳春暮 #分布式
    SpringCloudHystrix防雪崩利器基于Netflix对应的Hystrix具备的功能：1.服务降级2.依赖隔离3.服务熔断4.监控（HystrixDashboard）服务降级优先核心服务，非核心服务不可用或弱可用通过HystrixCommand注解指定fallbackMethod（回退函数）中具体实现降级逻辑使用RestTemplate的简单实例：1.引入依赖org.springfram
  • 【Sping Cloud】04--Hystrix dashboard 断路器仪表盘 DRHJ SpringClouddashboardspringcloudnetflix
    一，介绍1）Hystrix数据监控仪表盘2）Hystrix日志，是通过Actuator工具来暴露出来二，Actuator1.介绍springboot提供的一个项目指标工具，可以通过Actuator获取项目的各种日志数据健康状态spring容器中所有的对象springmvc映射的所有路径jvm堆内存镜像2.依赖Zuul中默认含有Actuator,所以无需添加3.暴露日志设置m.e.w.e.i="*"
  • Sping Cloud Hystrix 参数配置、简单使用、DashBoard 山风wind spring-cloudhystrixjava熔断spring-cloud
    SpingCloudHystrix文章目录SpingCloudHystrix一、Hystrix服务降级二、Hystrix使用示例三、OpenFeignHystrix四、Hystrix参数HystrixCommand.Setter核心参数CommandPropertiesFallback降级配置CircuitBreaker熔断器配置Metrix健康统计配置RequestContext相关参数Coll
  • IDEA2023SpingBoot只能勾选17和21 无心睡眠s springboot
    解决我们只知道IDEA页面创建Spring项目，其实是访问springinitializr去创建项目。故我们可以通过阿里云国服去间接创建Spring项目。将https://start.spring.io/或者http://start.springboot.io/替换为https://start.aliyun.com/
  • （已解决）vueQQ邮箱注册发送验证码前端设计，如何发送验证码设计倒计时 BrianGriffin 前端
    我们之前已经通过前端测试成功完成qq邮箱动态验证码发送（未使用redis，我准备自己了解完后，后期有时间补上）衔接文章：1：spingboot后端发送QQ邮箱验证码2：这段代码建设图形化界面发送中..{{countdown}}s发送(效果如图)js代码：importrouterfrom"../../router";importaxiosfrom"axios";exportdefault{data(
  • Sping常见注解使用方法----持续更新中20240116 默默编码的Fxdll java前端服务器
    持续更新中~可以关注哦底下也有博主碰到这些问题的项目具体操作时的原文。目录@Data：@requestbody@ExceptionHandler@ResponseBody@WebFilter(filterName="loginCheckFilter",urlPatterns="/*")@Data：通用返回结果,服务的相应的数据最终都会封装成此对象@requestbody要返回json@Except
  • 【多数据源系列】在Sping Cloud（Spring Boot）中基于AbstractRoutingDataSource 实现多数据源动态切换 后端小肥肠 JAVAspringcloudspringbootjava
    本文将以代码示例介绍在SpringCloud中基于AbstractRoutingDataSource实现多数据源动态切换。如文章中有明显错误或者用词不当的地方，欢迎大家在评论区批评指正，我看到后会及时修改。如想要和博主进行技术栈方面的讨论和交流可私信我。目录1.前言1.1.背景1.2.原理1.2.1核心原理1.2.2.源码解析1.2.3.AbstractRoutingDataSource类结构2.
  • SpringMVC默认欢迎页面的问题 songhuageini spring-mvcspringmvc
    1.默认tomcat容器的默认页面。index.jspindex.html这种方式适合访问静态的页面（也包括JSP）或者说是没有任何参数的页面。2.SpingMVC配置控制器的代码web.xml配置MVCDispatcherServletorg.springframework.web.servlet.DispatcherServletcontextConfigLocationclasspath:s
  • 机器人抓取 [ 题目/摘要 ] 更新中.. cocapop 机器人机器人
    题目：RoboticGraspingofNovelObjectsusingVisionl链接：机器人抓取新物体|IEEEXplore（IEEE的Xplore）【端到端】摘要：我们考虑抓取新物体的问题，特别是第一次通过视觉看到的物体。抓取以前未知的物体，一个没有3D模型的物体，是一个具有挑战性的问题。此外，即使给定一个模型，人们仍然必须决定在哪里抓住物体。我们提出了一种学习算法，它既不需要也不尝试构
  • （已解决）spingboot项目如何做QQ邮箱注册功能，如何在邮箱注册中进行随机数添加作为动态验证码，并满足分层解耦 BrianGriffin java开发语言
    前面我们已经完成了发送静态验证码，现在用随机数作为动态验证码。文章地址：spingboot后端发送QQ邮箱验证码使用注解@Component进行分层解耦加入ioc容器，方便调用。packagecom.example.tianyidemo.utils;importorg.springframework.stereotype.Component;importjava.util.Random;@Comp
  • （已解决）sping boot maven构建项目 添加jwt令牌 BrianGriffin mavenjava开发语言
    前言：需要工具：MySQL数据库（且默认已连接完成），idea，maven构建项目（其他的可以换方法下jar包）参考：项目结构：pom文件：4.0.0org.springframework.bootspring-boot-starter-parent3.2.1com.exampleTianyiDemo0.0.1-SNAPSHOTTianyiDemoTianyiDemo17org.mybatis.s
  • （已解决）spingboot 后端发送QQ邮箱验证码 BrianGriffin 运维服务器springboot
    打开QQ邮箱pop3请求服务：（按照QQ邮箱引导操作）导入依赖（不是maven项目就自己添加jar包）：org.springframework.bootspring-boot-starter-mail3.2.1application.properties配置：注：需要yml的，推荐转换工具或者下载idea插件yamlsyml，properties互转工具：yaml和proper互转工具#邮箱配置s
  • Date和LocalDate的相互转换 匆匆321 个人
    简述Date对象表示特定的日期和时间，而LocalDate(Java8)对象只包含没有任何时间信息的日期。Date转LocalDate步骤如下：1.将java.util.Date转换为ZonedDateTime。2.使用它的toLocalDate()方法从ZonedDateTime获取LocalDate。packageinsping;importjava.time.Instant;importja
  • SpingSecurity + SpringSession 整合 40岁资深老架构师尼恩 java
    SpingSecurity+SpringSession整合疯狂创客圈Java高并发【亿级流量聊天室实战】实战系列【博客园总入口】架构师成长+面试必备之高并发基础书籍【NettyZookeeperRedis高并发实战】疯狂创客圈高并发环境视频，陆续上线：WindowsRedis安装（带视频）LinuxRedis安装（带视频）WindowsZookeeper安装（带视频）LinuxZookeeper安
  • SpringBoot笔记（一）————第一个SpringBoot项目 多冷啊、我在东北玩泥巴 SpringBoot学习笔记springbootjavaintellijidea
    文章目录SSM基础第一个SpringBoot项目（Maven）使用官网构建（目前Eclipse只能用官网构建）使用IDEA构建（其实也是内置的官网链接）解决Maven下载太慢启动！写个controller试试约定大于配置原理初探SSM基础学习SpringBoot之前必须要熟悉Spring，SpingBoot不是一个完全重新写的东西，他是基于Spring来开发的，有很多默认的配置由SpringBoo
  • (Sping Xml方式整合第三方框架)学习Spring的第十天 y3131954546 xml学习spring
    Spring整合mybatis1.导入Mybatis整合Spring的相关坐标org.springframeworkspring-jdbc5.2.13.RELEASEorg.mybatismybatis-spring2.0.52.编写Mapper和文件在此给出Mapper.xml文件如下selectid,username,passwordfromtb_user3.在Applicationconte
  • oracle服务器ssh连不上,SSH服务突然连接不了案例总结 王亚昌 oracle服务器ssh连不上
    一台Oracle数据库服务器(Linux版本为OracleLinuxServerrelease5.7)今天中午突然出现短暂的ssh连接不上的情况，ssh连接不上的时候，ping服务器正常，使用psping检测端口22也是正常(只返回5个包，没有持续ping)，使用SQLDeveloper可以登录数据库进行任何操作，另外，通过DPA工具发现该服务器的CPU等资源消耗很低(发现数据库服务都正常后，就出
  • java的(PO,VO,TO,BO,DAO,POJO) Cb123456 VOTOBOPOJODAO
    转: http://www.cnblogs.com/yxnchinahlj/archive/2012/02/24/2366110.html   -------------------------------------------------------------------  O/R Mapping 是 Object Relational Mapping（对象关系映
  • spring ioc原理（看完后大家可以自己写一个spring） aijuans spring
             最近，买了本Spring入门书：spring In Action 。大致浏览了下感觉还不错。就是入门了点。Manning的书还是不错的，我虽然不像哪些只看Manning书的人那样专注于Manning,但怀着崇敬 的心情和激情通览了一遍。又一次接受了IOC 、DI、AOP等Spring核心概念。 先就IOC和DI谈一点我的看法。IO
  • MyEclipse 2014中Customize Persperctive设置无效的解决方法 Kai_Ge MyEclipse2014
    高高兴兴下载个MyEclipse2014，发现工具条上多了个手机开发的按钮，心生不爽就想弄掉他！ 结果发现Customize Persperctive失效！！ 有说更新下就好了，可是国内Myeclipse访问不了，何谈更新... so~这里提供了更新后的一下jar包，给大家使用！ 1、将9个jar复制到myeclipse安装目录\plugins中 2、删除和这9个jar同包名但是版本号较
  • SpringMvc上传 120153216 springMVC
      @RequestMapping(value = WebUrlConstant.UPLOADFILE) @ResponseBody public Map<String, Object> uploadFile(HttpServletRequest request,HttpServletResponse httpresponse) { try { //
  • Javascript----HTML DOM 事件 何必如此 JavaScripthtmlWeb
    HTML DOM 事件允许Javascript在HTML文档元素中注册不同事件处理程序。 事件通常与函数结合使用，函数不会在事件发生前被执行！ 注：DOM： 指明使用的 DOM 属性级别。 1.鼠标事件 属性               
  • 动态绑定和删除onclick事件 357029540 JavaScriptjquery
    因为对JQUERY和JS的动态绑定事件的不熟悉，今天花了好久的时间才把动态绑定和删除onclick事件搞定!现在分享下我的过程。      在我的查询页面，我将我的onclick事件绑定到了tr标签上同时传入当前行(this值)参数，这样可以在点击行上的任意地方时可以选中checkbox，但是在我的某一列上也有一个onclick事件是用于下载附件的，当
  • HttpClient|HttpClient请求详解 7454103 apache应用服务器网络协议网络应用Security
    HttpClient 是 Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。本文首先介绍 HTTPClient，然后根据作者实际工作经验给出了一些常见问题的解决方法。HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需
  • 递归 逐层统计树形结构数据 darkranger 数据结构
    将集合递归获取树形结构: /** * * 递归获取数据 * @param alist:所有分类 * @param subjname:对应统计的项目名称 * @param pk:对应项目主键 * @param reportList: 最后统计的结果集 * @param count:项目级别 */ public void getReportVO(Arr
  • 访问WEB-INF下使用frameset标签页面出错的原因 aijuans struts2
    <frameset rows="61,*,24" cols="*" framespacing="0" frameborder="no" border="0">        
  • MAVEN常用命令 avords
    Maven库： http://repo2.maven.org/maven2/ Maven依赖查询： http://mvnrepository.com/ Maven常用命令： 1. 创建Maven的普通java项目：    mvn archetype:create    -DgroupId=packageName 
  • PHP如果自带一个小型的web服务器就好了 houxinyou apache应用服务器WebPHP脚本
    最近单位用PHP做网站，感觉PHP挺好的，不过有一些地方不太习惯，比如，环境搭建。PHP本身就是一个网站后台脚本，但用PHP做程序时还要下载apache，配置起来也不太很方便，虽然有好多配置好的apache+php+mysq的环境，但用起来总是心里不太舒服，因为我要的只是一个开发环境，如果是真实的运行环境，下个apahe也无所谓，但只是一个开发环境，总有一种杀鸡用牛刀的感觉。如果php自己的程序中
  • NoSQL数据库之Redis数据库管理(list类型) bijian1013 redis数据库NoSQL
    3.list类型及操作         List是一个链表结构，主要功能是push、pop、获取一个范围的所有值等等，操作key理解为链表的名字。Redis的list类型其实就是一个每个子元素都是string类型的双向链表。我们可以通过push、pop操作从链表的头部或者尾部添加删除元素，这样list既可以作为栈，又可以作为队列。   &nbs
  • 谁在用Hadoop？ bingyingao hadoop数据挖掘公司应用场景
    Hadoop技术的应用已经十分广泛了，而我是最近才开始对它有所了解，它在大数据领域的出色表现也让我产生了兴趣。浏览了他的官网，其中有一个页面专门介绍目前世界上有哪些公司在用Hadoop，这些公司涵盖各行各业，不乏一些大公司如alibaba,ebay,amazon,google,facebook,adobe等，主要用于日志分析、数据挖掘、机器学习、构建索引、业务报表等场景,这更加激发了学习它的热情。
  • 【Spark七十六】Spark计算结果存到MySQL bit1129 mysql
    package spark.examples.db import java.sql.{PreparedStatement, Connection, DriverManager} import com.mysql.jdbc.Driver import org.apache.spark.{SparkContext, SparkConf} object SparkMySQLInteg
  • Scala: JVM上的函数编程 bookjovi scalaerlanghaskell
        说Scala是JVM上的函数编程一点也不为过，Scala把面向对象和函数型编程这两种主流编程范式结合了起来，对于熟悉各种编程范式的人而言Scala并没有带来太多革新的编程思想，scala主要的有点在于Java庞大的package优势，这样也就弥补了JVM平台上函数型编程的缺失，MS家.net上已经有了F#，JVM怎么能不跟上呢？     对本人而言
  • jar打成exe bro_feng java jar exe
    今天要把jar包打成exe，jsmooth和exe4j都用了。 遇见几个问题。记录一下。 两个软件都很好使，网上都有图片教程，都挺不错。 首先肯定是要用自己的jre的，不然不能通用，其次别忘了把需要的lib放到classPath中。 困扰我很久的一个问题是，我自己打包成功后，在一个同事的没有装jdk的电脑上运行，就是不行，报错jvm.dll为无效的windows映像，如截图 最后发现
  • 读《研磨设计模式》-代码笔记-策略模式-Strategy bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /* 策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化 简单理解： 1、将不同的策略提炼出一个共同接口。这是容易的，因为不同的策略，只是算法不同，需要传递的参数
  • cmd命令值cvfM命令 chenyu19891124 cmd
         cmd命令还真是强大啊。今天发现jar -cvfM aa.rar @aaalist 就这行命令可以根据aaalist取出相应的文件   例如：      在d：\workspace\prpall\test.java 有这样一个文件，现在想要将这个文件打成一个包。运行如下命令即可比如在d：\wor
  • OpenJWeb(1.8) Java Web应用快速开发平台 comsci java框架Web项目管理企业应用
        OpenJWeb(1.8) Java Web应用快速开发平台的作者是我们技术联盟的成员，他最近推出了新版本的快速应用开发平台  OpenJWeb(1.8)，我帮他做做宣传   OpenJWeb快速开发平台以快速开发为核心，整合先进的java 开源框架，本着自主开发+应用集成相结合的原则，旨在为政府、企事业单位、软件公司等平台用户提供一个架构透
  • Python 报错：IndentationError: unexpected indent daizj pythontab空格缩进
        IndentationError: unexpected indent 是缩进的问题，也有可能是tab和空格混用啦     Python开发者有意让违反了缩进规则的程序不能通过编译，以此来强制程序员养成良好的编程习惯。并且在Python语言里，缩进而非花括号或者某种关键字，被用于表示语句块的开始和退出。增加缩进表示语句块的开
  • HttpClient 超时设置 dongwei_6688 httpclient
    HttpClient中的超时设置包含两个部分： 1. 建立连接超时，是指在httpclient客户端和服务器端建立连接过程中允许的最大等待时间 2. 读取数据超时，是指在建立连接后，等待读取服务器端的响应数据时允许的最大等待时间   在HttpClient 4.x中如下设置：   HttpClient httpclient = new DefaultHttpC
  • 小鱼与波浪 dcj3sjt126com
    一条小鱼游出水面看蓝天，偶然间遇到了波浪。　　小鱼便与波浪在海面上游戏，随着波浪上下起伏、汹涌前进。　　小鱼在波浪里兴奋得大叫：“你每天都过着这么刺激的生活吗？简直太棒了。”　　波浪说：“岂只每天过这样的生活，几乎每一刻都这么刺激！还有更刺激的，要有潮汐变化，或者狂风暴雨，那才是兴奋得心脏都会跳出来。”　　小鱼说：“真希望我也能变成一个波浪，每天随着风雨、潮汐流动，不知道有多么好！”　　很快，小鱼
  • Error Code: 1175 You are using safe update mode and you tried to update a table dcj3sjt126com mysql
    快速高效用：SET SQL_SAFE_UPDATES = 0；下面的就不要看了！ 今日用MySQL Workbench进行数据库的管理更新时，执行一个更新的语句碰到以下错误提示： Error Code: 1175 You are using safe update mode and you tried to update a table without a WHERE that
  • 枚举类型详细介绍及方法定义 gaomysion enumjavaee
    转发 http://developer.51cto.com/art/201107/275031.htm 枚举其实就是一种类型，跟int, char 这种差不多，就是定义变量时限制输入的，你只能够赋enum里面规定的值。建议大家可以看看，这两篇文章，《java枚举类型入门》和《C++的中的结构体和枚举》，供大家参考。 枚举类型是JDK5.0的新特征。Sun引进了一个全新的关键字enum
  • Merge Sorted Array hcx2013 array
    Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array. Note:You may assume that nums1 has enough space (size that is
  • Expression Language 3.0新特性 jinnianshilongnian el 3.0
    Expression Language 3.0表达式语言规范最终版从2013-4-29发布到现在已经非常久的时间了；目前如Tomcat 8、Jetty 9、GlasshFish 4已经支持EL 3.0。新特性包括：如字符串拼接操作符、赋值、分号操作符、对象方法调用、Lambda表达式、静态字段/方法调用、构造器调用、Java8集合操作。目前Glassfish 4/Jetty实现最好，对大多数新特性
  • 超越算法来看待个性化推荐 liyonghui160com 超越算法来看待个性化推荐
             一提到个性化推荐，大家一般会想到协同过滤、文本相似等推荐算法，或是更高阶的模型推荐算法，百度的张栋说过，推荐40%取决于UI、30%取决于数据、20%取决于背景知识，虽然本人不是很认同这种比例，但推荐系统中，推荐算法起的作用起的作用是非常有限的。       就像任何
  • 写给Javascript初学者的小小建议 pda158 JavaScript
    　　一般初学JavaScript的时候最头痛的就是浏览器兼容问题。在Firefox下面好好的代码放到IE就不能显示了，又或者是在IE能正常显示的代码在firefox又报错了。 　　如果你正初学JavaScript并有着一样的处境的话建议你：初学JavaScript的时候无视DOM和BOM的兼容性，将更多的时间花在 了解语言本身（ECMAScript）。只在特定浏览器编写代码（Chrome/Fi
  • Java 枚举 ShihLei javaenum枚举
    注：文章内容大量借鉴使用网上的资料，可惜没有记录参考地址，只能再传对作者说声抱歉并表示感谢！   一 基础 1）语法      枚举类型只能有私有构造器（这样做可以保证客户代码没有办法新建一个enum的实例）      枚举实例必须最先定义 2）特性     &nb
  • Java SE 6 HotSpot虚拟机的垃圾回收机制 uuhorse javaHotSpotGC垃圾回收VM
    官方资料，关于Java SE 6 HotSpot虚拟机的garbage Collection，非常全，英文。 http://www.oracle.com/technetwork/java/javase/gc-tuning-6-140523.html   Java SE 6 HotSpot[tm] Virtual Machine Garbage Collection Tuning &