首页

当前位置：网站首页 > 技术资源 > 正文

Springboot使用过程中总结的一些问题及技巧应用(一)

lipiwang 2024-10-31 15:24 16 浏览 0 评论

环境：springboot2.3.10

1 @Configuration注解

该注解有个proxyBeanMethods属性默认值为true。

当为true时：所有方法上带有@Bean注解的Bean会被CGLIB代理，在该类中或者是在外部类中都可以直接调用该方法，返回的都是共享的同一个Bean对象。

2 @Import注解

当注解上添加有@Import注解，该注解上配置的类如下：

Bash

@Import({RWImportSelector.class})

Bash

public class RWImportSelector implements ImportSelector, EnvironmentAware {

    private static final String RW_CONFIG_ENABLED = "rw.config.enabled" ;
    private static final Boolean RW_CONFIG_ENABLED_DEFAULE = Boolean.TRUE ;
    
    private Environment env ;
    
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        Map<String, Object> attributesMap = importingClassMetadata.getAnnotationAttributes(EnableRW.class.getName());
        AnnotationAttributes attrs = AnnotationAttributes.fromMap(attributesMap);
        System.out.println(attrs.get("value")) ;
        if (!env.getProperty(RW_CONFIG_ENABLED, Boolean.class, RW_CONFIG_ENABLED_DEFAULE)) {
            return new String[] {} ;
        }
        return new String[] {RWConfig.class.getName()} ;
    }

    @Override
    public void setEnvironment(Environment environment) {
        this.env = environment ;
    }

}

ImportSelector可以实现相应的*Aware接口。
selectImports返回的结果类中，在类上配置的@ConditionOn*注解同样会生效。 如下@ConditionalOnProperty(prefix = "rw.config", name = "enabled", havingValue = "true", matchIfMissing = false)
public class RWConfig implements ApplicationContextAware, EnvironmentAware {
}

3 自定义Advisor失效问题

现在有如下需求：类中的方法只要标有@DS注解的都进行拦截（代理）。

// 注解类
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface DS {
}
// DAO接口
public interface CustomDAO {
  public void update() ;
}
// DAO接口实现类
@Component
public class CustomerDAOImpl implements CustomDAO { 
  @DS
  public void update() {
    System.out.println("更新数据...") ;
  } 
}

自定义Advisor（管理Advice和Pointcut）

@Component
public class CustomAdvisor implements PointcutAdvisor {

  @Override
  public Advice getAdvice() {
    return new MethodInterceptor() {
        @Override
        public Object invoke(MethodInvocation invocation) throws Throwable {
          System.out.println("我被调用了...") ;
          return invocation.proceed() ;
        }
    } ;
  }

  @Override
  public boolean isPerInstance() {
    return true ;
  }

  @Override
  public Pointcut getPointcut() {
    return new Pointcut() {
        @Override
        public MethodMatcher getMethodMatcher() {
          return new MethodMatcher() {
            @Override
            public boolean matches(Method method, Class<?> targetClass, Object... args) {
              return false;
            }
            @Override
            public boolean matches(Method method, Class<?> targetClass) {
              return method.isAnnotationPresent(DS.class) ;
            }
            @Override
            public boolean isRuntime() {
              return false ;
            }
          };
       }
       @Override
       public ClassFilter getClassFilter() {
         return ClassFilter.TRUE;
       }
    } ;
  }

}

开启AOP功能

@Configuration
@EnableAspectJAutoProxy
public class AnnoConfig {
}

测试

public class App {
  public static void main(String[] args) {
    System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "d://cglib");  
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext("com.pack.anno", "com.pack.dao", "com.pack.advisor") ;
    ctx.getBean(CustomDAO.class).update() ; 
    ctx.close();
  }
}

运行结果

class com.pack.dao.CustomerDAOImpl  update  false
更新数据...

只打印了update中的输出，我们定义的Advice并没有执行。

当我们需要代理的类实现了接口那么Spring默认会使用JDK的代理。那我们这里的CustomerDAOImpl会使用JDK的Proxy进行代理。而使用JDK的代理应用的InvocationHandler是：

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    Object oldProxy = null;
    boolean setProxyContext = false;

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

    try {
      // other code
      Object retVal;
      if (this.advised.exposeProxy) {
        // Make invocation available if necessary.
        oldProxy = AopContext.setCurrentProxy(proxy);
        setProxyContext = true;
      }
      target = targetSource.getTarget();
      Class<?> targetClass = (target != null ? target.getClass() : null);
      // Get the interception chain for this method.
      List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
      if (chain.isEmpty()) {
        Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
        retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
      } else {
        // We need to create a method invocation...
        MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
        // Proceed to the joinpoint through the interceptor chain.
        retVal = invocation.proceed();
      }
      // other code
      return retVal;
    }
  }
}

关键是下面这行代码：

List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

动态获取我们的拦截器，请注意此时我们的Method对象是谁？

接下来我们进入上面的那行关键代码

public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {
  MethodCacheKey cacheKey = new MethodCacheKey(method);
  List<Object> cached = this.methodCache.get(cacheKey);
  if (cached == null) {
    cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(this, method, targetClass);
    this.methodCache.put(cacheKey, cached);
  }
  return cached;
}

继续进入getInterceptorsAndDynamicInterceptionAdvice方法，该方法通过名称知道获取通知Advice

public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
            Advised config, Method method, @Nullable Class<?> targetClass) {
  AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
  Advisor[] advisors = config.getAdvisors();
  List<Object> interceptorList = new ArrayList<>(advisors.length);
  Class<?> actualClass = (targetClass != null ? targetClass :method.getDeclaringClass());
  Boolean hasIntroductions = null;
  for (Advisor advisor : advisors) {
    if (advisor instanceof PointcutAdvisor) {
      PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
      if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
        MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
        boolean match;
        if (mm instanceof IntroductionAwareMethodMatcher) {
          if (hasIntroductions == null) {
            hasIntroductions = hasMatchingIntroductions(advisors, actualClass);
          }
          match = ((IntroductionAwareMethodMatcher) mm).matches(method, actualClass, hasIntroductions);
        } else {
          match = mm.matches(method, actualClass);
        }
        if (match) {
          MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
          if (mm.isRuntime()) {
            for (MethodInterceptor interceptor : interceptors) {
              interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
            }
          } else {
            interceptorList.addAll(Arrays.asList(interceptors));
          }
        }
      }  
    } else if (advisor instanceof IntroductionAdvisor) {
      IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
      if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
        Interceptor[] interceptors = registry.getInterceptors(advisor);
        interceptorList.addAll(Arrays.asList(interceptors));
      }
    } else {
      Interceptor[] interceptors = registry.getInterceptors(advisor);
      interceptorList.addAll(Arrays.asList(interceptors));
    }
  }
  return interceptorList;
}

查看该方法中的advisors属性值

有我们定义的切面CustomAdvisor

继续向下执行

在这里你应该能够知道了Method对象指向的接口的update，而在接口的update方法是我们并没有添加@DS注解，所以这里不会匹配。最终这个方法会返回一个空集合。

接下来回到InvocationHandler中的invoke方法中继续执行下面的代码


if (chain.isEmpty()) {
  Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
  retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
}

也就是直接就带我们的target目标方法了。

如何解决这问题呢？有2种方法

第一种：

在接口方法上添加@DS注解

第二种：

强制使用cglib代码，如下配置：

@EnableAspectJAutoProxy(proxyTargetClass = true)

proxyTargetClass属性值是如何与AnnotationAwareAspectJAutoProxyCreator关联的？

@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
}
@Override
public void registerBeanDefinitions(
  AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

  // 注册AnnotationAwareAspectJAutoProxyCreator Bean
  AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

  AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata,EnableAspectJAutoProxy.class);
  if (enableAspectJAutoProxy != null) {
    // 如果proxyTargetClass设置为true，那么强制修改AnnotationAwareAspectJAutoProxyCreator的proxyTargetClass 属性值
    if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
      AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
    }
    if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
      AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
    }
  }
}

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);
  }
}

4 引介增强的应用

含义：假设某个类没有实现A接口，在不修改源码的情况下使其具有接口A的功能；是不是很强大。

示例：

一个普通的类没有实现任何的接口

@Component
public class Apple {
  public void color() {
    System.out.println("red color...") ;
  }
}

使上面的Apple具有下面接口的能力

public interface FruitDAO {
  public void eat() ;   
}

方法拦截器（引介拦截器）

public class CustomIntroductionInterceptor implements IntroductionInterceptor, FruitDAO {

  @Override
  public Object invoke(MethodInvocation invocation) throws Throwable {
    if (implementsInterface(invocation.getMethod().getDeclaringClass())) {
      System.out.println("我是Introduction增强...") ;
      return invocation.getMethod().invoke(this, invocation.getArguments()) ;
    }
    return invocation.proceed() ;
  }

  @Override
  public boolean implementsInterface(Class<?> intf) {
    return FruitDAO.class.isAssignableFrom(intf) ;
  }

  @Override
  public void eat() {
    System.out.println("这是一个合格的水果") ;
  }

}

当前拦截器实现了FruitDAO接口，意味着当某个类不具有FruitDAO能力的时候，那么当它具有其能力的时候就是在当前拦截器中实现的方法。（也可理解为增强的部分）

implementsInterface 方法判断当前执行的方法所在的类是否实现了指定的接口。

创建代理的处理器

@Component
public class IntroductionAopProxy extends AbstractAutoProxyCreator {

  private static final long serialVersionUID = 1L;

  @Override
  protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource customTargetSource) throws BeansException {
    return new Object[] {new DefaultIntroductionAdvisor(new CustomIntroductionInterceptor(), FruitDAO.class)} ;
  }
    
  @Override
  protected boolean shouldSkip(Class<?> beanClass, String beanName) {
    return !Apple.class.isAssignableFrom(beanClass) ;
  }

}

这里只对Apple进行处理，其它的都跳过。

未完待续

公众：Springboot实战案例锦集

SpringCloud Nacos 服务提供者

SpringCloud Nacos 服务动态配置

Spring Cloud Sentinel整合Feign

Spring Cloud Gateway应用详解1之谓词

Spring Cloud Nacos 开启权限验证

Spring Cloud全链路追踪SkyWalking及整合Elasticsearch

Spring Cloud 微服务日志收集管理Elastic Stack完整详细版

Spring Cloud Sentinel 热点参数限流

SpringCloud zuul 动态网关配置