인프런 커뮤니티 질문&답변

네 음...

이 부분은 조금 복잡한데요..

전반적으로 AOP 와 관련된 내용들이 주를 이루고 있고 스프링 시큐리티가 초기화 되는 과정속에서 여러 단계들을 거치면서 프록시 객체 기술을 통한 권한 설정을 하고 있습니다.

또한 초기화 시점에서 생성되는 프록시 객체는 스프링이 자동으로 해 주고 있습니다.
그 기준이 되는 것은 MapBasedMethodSecurityMetadataSource 에 설정한 클래스와 메소드를 통해 프록시 대상이 되는지 여부를 검사하게 되고 검사가 통과하게 되면 해당 클래스는 프록시 객체가 되고 해당 메소드는 권한을 체크하는 MethodInterceptor 대상으로 등록되게 됩니다.

그렇기 때문에 MethodSecurityConfig  설정클래스에서

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration {

    @Autowired
    private SecurityResourceService securityResourceService;

    @Override
    protected MethodSecurityMetadataSource customMethodSecurityMetadataSource() {
        return mapBasedMethodSecurityMetadataSource();
    }

    @Bean
    public MapBasedMethodSecurityMetadataSource mapBasedMethodSecurityMetadataSource() {
        return new MapBasedMethodSecurityMetadataSource(methodResourcesMapFactoryBean().getObject());
    }

    @Bean
    public MethodResourcesMapFactoryBean methodResourcesMapFactoryBean(){
        MethodResourcesMapFactoryBean methodResourcesMapFactoryBean = new MethodResourcesMapFactoryBean();
        methodResourcesMapFactoryBean.setSecurityResourceService(securityResourceService);
        methodResourcesMapFactoryBean.setResourceType("method");
        return methodResourcesMapFactoryBean;
    }

위의 구문에서 

@Override
protected MethodSecurityMetadataSource customMethodSecurityMetadataSource() {
    return mapBasedMethodSecurityMetadataSource();
}

이 부분이 Override 되고 있는데 이 규칙은 임의로 변경할 수 있는 부분이 아닙니다.

이 구문으로 인해 MapBasedMethodSecurityMetadataSource 를 통해 AOP 대상이 되는 클래스와 메소드를 찾게 됩니다. 

그리고 내부적으로 CglibAopProxy 클래스에 의해 프록시 객체가 생성되게 됩니다.

그래서 

@EventListener(ContextRefreshedEvent.class)
   @Transactional
   public void onContextRefreshed(ContextRefreshedEvent event) {
      ApplicationContext ctx = event.getApplicationContext();
      
      var customMapBasedMethodSecurityMetadataSource =
            ctx.getBean(CustomMapBasedMethodSecurityMetadataSource.class);
      
      customMapBasedMethodSecurityMetadataSource.reload();
   }

위의 구문은 스프링 시큐리티가 메소드 권한을 위한 내부 프로세스의 과정과 흐름에서 벗어나 있기 때문에 스프링 시큐리티가 해당 클래스와 메소드를 프록시로 생성해야 하는지에 대한 인식을 하지 못합니다.

만약 CustomMapBasedMethodSecurityMetadataSource 를 꼭 사용해야 한다면

@Bean
    public MapBasedMethodSecurityMetadataSource mapBasedMethodSecurityMetadataSource() {
        return new MapBasedMethodSecurityMetadataSource(methodResourcesMapFactoryBean().getObject());
    }

구문을

@Bean
    public MapBasedMethodSecurityMetadataSource mapBasedMethodSecurityMetadataSource() {
        return new CustomMapBasedMethodSecurityMetadataSource (methodResourcesMapFactoryBean().getObject());
    }

와 같은 방법으로 변경해서 사용해 볼 수는 있을 것 같은데 정확하게 동작할지는 잘 모르겠습니다.

 

참고하실 클래스는 다음과 같습니다.

MethodSecurityMetadataSourceAdvisor 클래스는 메소드 권한을 AOP 방식으로 적용하기 위한 내용을 담고 있습니다.

PointCut 과 MethodInterceptor 를 동시에 가지고 있는 Advisor 입니다.

public class MethodSecurityMetadataSourceAdvisor extends AbstractPointcutAdvisor
      implements BeanFactoryAware {
   // ~ Instance fields
   // ================================================================================================

   private transient MethodSecurityMetadataSource attributeSource;
   private transient MethodInterceptor interceptor;
   private final Pointcut pointcut = new MethodSecurityMetadataSourcePointcut();
   private BeanFactory beanFactory;
   private final String adviceBeanName;
   private final String metadataSourceBeanName;
   private transient volatile Object adviceMonitor = new Object();

   // ~ Constructors
   // ===================================================================================================

   /**
    * Alternative constructor for situations where we want the advisor decoupled from the
    * advice. Instead the advice bean name should be set. This prevents eager
    * instantiation of the interceptor (and hence the AuthenticationManager). See
    * SEC-773, for example. The metadataSourceBeanName is used rather than a direct
    * reference to support serialization via a bean factory lookup.
    *
    * @param adviceBeanName name of the MethodSecurityInterceptor bean
    * @param attributeSource the SecurityMetadataSource (should be the same as the one
    * used on the interceptor)
    * @param attributeSourceBeanName the bean name of the attributeSource (required for
    * serialization)
    */
   public MethodSecurityMetadataSourceAdvisor(String adviceBeanName,
         MethodSecurityMetadataSource attributeSource, String attributeSourceBeanName) {
      Assert.notNull(adviceBeanName, "The adviceBeanName cannot be null");
      Assert.notNull(attributeSource, "The attributeSource cannot be null");
      Assert.notNull(attributeSourceBeanName,
            "The attributeSourceBeanName cannot be null");

      this.adviceBeanName = adviceBeanName;
      this.attributeSource = attributeSource;
      this.metadataSourceBeanName = attributeSourceBeanName;
   }

   // ~ Methods
   // ========================================================================================================

   public Pointcut getPointcut() {
      return pointcut;
   }

   public Advice getAdvice() {
      synchronized (this.adviceMonitor) {
         if (interceptor == null) {
            Assert.notNull(adviceBeanName,
                  "'adviceBeanName' must be set for use with bean factory lookup.");
            Assert.state(beanFactory != null,
                  "BeanFactory must be set to resolve 'adviceBeanName'");
            interceptor = beanFactory.getBean(this.adviceBeanName,
               MethodInterceptor.class);
         }
         return interceptor;
      }
   }

   public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
      this.beanFactory = beanFactory;
   }

   private void readObject(ObjectInputStream ois) throws IOException,
         ClassNotFoundException {
      ois.defaultReadObject();
      adviceMonitor = new Object();
      attributeSource = beanFactory.getBean(metadataSourceBeanName,
            MethodSecurityMetadataSource.class);
   }

   // ~ Inner Classes
   // ==================================================================================================

   class MethodSecurityMetadataSourcePointcut extends StaticMethodMatcherPointcut
         implements Serializable {
      @SuppressWarnings("unchecked")
      public boolean matches(Method m, Class targetClass) {
         Collection attributes = attributeSource.getAttributes(m, targetClass);
         return attributes != null && !attributes.isEmpty();
      }
   }
}

보시면

class MethodSecurityMetadataSourcePointcut extends StaticMethodMatcherPointcut
         implements Serializable {
      @SuppressWarnings("unchecked")
      public boolean matches(Method m, Class targetClass) {
         Collection attributes = attributeSource.getAttributes(m, targetClass);
         return attributes != null && !attributes.isEmpty();
      }
   }

위 구문 실행 후 MapBasedMethodSecurityMetadataSource 에 설정한 클래스와 메소드를 찾게 되면 해당 클래스는 프록시 객체의 대상으로 간주되고 메소드에는 MethodInterceptor 가 작용되도록 설정됩니다. 
즉
attributes != null && !attributes.isEmpty();
구문인데 이것은 우리가 DB 에서 설정한 메소드명 리소스에 해당하는 권한값이 존재할 경우 참을 반환하게 됩니다.
attributes 은 List<ConfigAttribute> 라고 볼 수 있습니다

위 구문에서 참을 리턴하게 되면 해당 메소드에는 다음과 같이 메소드 권한을 위한 Advice 즉 MethodInterceptor 가 적용이 됩니다. 다음 구문입니다.

public Advice getAdvice() {
      synchronized (this.adviceMonitor) {
         if (interceptor == null) {
            Assert.notNull(adviceBeanName,
                  "'adviceBeanName' must be set for use with bean factory lookup.");
            Assert.state(beanFactory != null,
                  "BeanFactory must be set to resolve 'adviceBeanName'");
            interceptor = beanFactory.getBean(this.adviceBeanName,
               MethodInterceptor.class);
         }
         return interceptor;
      }
   }

결론적으로 메소드 권한이 대상이 되는 클래스의 프록시 생성 과정은 스프링 시큐리티의 초기와 과정속에서 여러 클래스들의 참조를 통해 이루어지기 때문에 커스텀하게 임의로 설정할 수 있는 성격은 아닙니다.
조금이나마 도움이 되셨길 바랍니다.

만약 런타임에서 실시간 적으로 메소드 권한 설정이 필요하다면 아래 소스를 참고해 보셔도 됩니다.
제가 강의에서 번외로 설명한 부분인데 코드가 약간 업그레이드 된 버전입니다.
스프링 시큐리티에서 사용하고 있는 MethodSecurityMetadataSourceAdvisor 를 참조해서 만든 것인데 추가 및 삭제가 런타임때 실시간 적으로 정상 동작하고 있습니다.
참고용으로 하시면 될 것 같습니다.

@Component
public class MethodSecurityService {

    private MapBasedMethodSecurityMetadataSource mapBasedMethodSecurityMetadataSource;
    private AbstractApplicationContext applicationContext;
    private CustomMethodSecurityInterceptor methodSecurityInterceptor;
    private DefaultPointcutAdvisor defaultPointcutAdvisor = new DefaultPointcutAdvisor();
    private MethodSecurityMetadataSourceAdvisor methodSecurityMetadataSourceAdvisor;

    private Map<String, Object> proxyMap = new HashMap<>();
    private Map<String, ProxyFactory> advisedMap = new HashMap<>();
    private Map<String, Object> targetMap = new HashMap<>();

    public MethodSecurityService(MethodSecurityMetadataSourceAdvisor methodSecurityMetadataSourceAdvisor, MapBasedMethodSecurityMetadataSource mapBasedMethodSecurityMetadataSource, AnnotationConfigServletWebServerApplicationContext applicationContext, CustomMethodSecurityInterceptor methodSecurityInterceptor) {
        this.methodSecurityMetadataSourceAdvisor = methodSecurityMetadataSourceAdvisor;
        this.mapBasedMethodSecurityMetadataSource = mapBasedMethodSecurityMetadataSource;
        this.applicationContext = applicationContext;
        this.methodSecurityInterceptor = methodSecurityInterceptor;
    }

    public void addMethodSecured(String className, String roleName) throws Exception{

        int lastDotIndex = className.lastIndexOf(".");
        Class<?> type = getType(className, lastDotIndex);
        String beanName = type.getSimpleName().substring(0, 1).toLowerCase() + type.getSimpleName().substring(1);
        String methodName = className.substring(lastDotIndex + 1);

        ProxyFactory proxyFactory = advisedMap.get(beanName);
        Object target = targetMap.get(beanName);
        Object proxy = proxyMap.get(beanName);
        Object advised = applicationContext.getBean(beanName);

        if(proxyFactory == null && !(advised instanceof Advised)) {

            proxyFactory = new ProxyFactory();

            if (target == null) {
                proxyFactory.setTarget(type.getDeclaredConstructor().newInstance());

            } else {
                proxyFactory.setTarget(target);
            }

            defaultPointcutAdvisor.setAdvice(methodSecurityInterceptor);
            proxyFactory.addAdvisor(defaultPointcutAdvisor);
            advisedMap.put(beanName, proxyFactory);

            if(proxy == null){

                proxy = proxyFactory.getProxy();
                proxyMap.put(beanName, proxy);

                List<ConfigAttribute> attr = Arrays.asList(new SecurityConfig(roleName));
                mapBasedMethodSecurityMetadataSource.addSecureMethod(type,methodName, attr);

                DefaultSingletonBeanRegistry registry = (DefaultSingletonBeanRegistry)applicationContext.getBeanFactory();
                registry.destroySingleton(beanName);
                registry.registerSingleton(beanName, proxy);
            }

        }else if(proxyFactory == null && (advised instanceof Advised)){
            defaultPointcutAdvisor.setAdvice(methodSecurityInterceptor);
            ((Advised) advised).addAdvisor(defaultPointcutAdvisor);

        }else if(proxyFactory != null){
            proxyFactory.addAdvisor(defaultPointcutAdvisor);
        }
    }

    public void removeMethodSecured(String className) throws Exception{

        int lastDotIndex = className.lastIndexOf(".");
        Class<?> type = getType(className, lastDotIndex);
        String beanName = type.getSimpleName().substring(0, 1).toLowerCase() + type.getSimpleName().substring(1);

        ProxyFactory proxyFactory = advisedMap.get(beanName);

        if(proxyFactory != null){
            proxyFactory.removeAdvisor(defaultPointcutAdvisor);

        }else{
            Object bean = applicationContext.getBean(beanName);
            Advisor[] advisors = ((Advised) bean).getAdvisors();

            for(Advisor advisor : advisors) {
                if (advisor instanceof MethodSecurityMetadataSourceAdvisor) {
                    ((Advised) bean).removeAdvisor(methodSecurityMetadataSourceAdvisor);

                } else if (advisor instanceof DefaultPointcutAdvisor) {
                    ((Advised) bean).removeAdvisor(defaultPointcutAdvisor);
                }
                Object singletonTarget = AopProxyUtils.getSingletonTarget(bean);
                targetMap.put(beanName, singletonTarget);
            }
        }
    }

    private Class<?> getType(String className, int lastDotIndex) {
        String typeName = className.substring(0, lastDotIndex);
        return ClassUtils.resolveClassName(typeName, ClassUtils.getDefaultClassLoader());
    }
}

그리고 질문하신 내용과 관련해서 전반적인 AOP 의 흐름과 스프링 시큐리티가 내부적으로 어떤 단계로 메소드 권한을 위한 프록시 객체를 활용하는지에 대한 내용을 설명드리고 싶지만 부득이 현 지면에 담기에는 내용이 많고 복잡도가 있고 스프링 시큐리티에 대한 주제를 벗어나기 때문에 상세한 내용을 드리기가 어려운점 양해 부탁드립니다.