Gdev Blog

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public final class ExposeInvocationInterceptor implements MethodInterceptor, PriorityOrdered, Serializable {
	private static final ThreadLocal<MethodInvocation> invocation =
			new NamedThreadLocal<>("Current AOP method invocation");
	public static MethodInvocation currentInvocation() throws IllegalStateException {
		MethodInvocation mi = invocation.get();
        //...
    }
	@Override
	@Nullable
	public Object invoke(MethodInvocation mi) throws Throwable {
		MethodInvocation oldInvocation = invocation.get();
		invocation.set(mi);
		try {
			return mi.proceed();
		}
		finally {
			invocation.set(oldInvocation);
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// org.springframework.aop.Advisor
public interface Advisor {
	Advice getAdvice();
	boolean isPerInstance();
}

// org.springframework.aop.PointcutAdvisor
public interface PointcutAdvisor extends Advisor {
	Pointcut getPointcut();
}

// org.springframework.aop.aspectj.InstantiationModelAwarePointcutAdvisor
public interface InstantiationModelAwarePointcutAdvisor extends PointcutAdvisor {}

// org.springframework.aop.IntroductionAdvisor
public interface IntroductionAdvisor extends Advisor, IntroductionInfo {
	ClassFilter getClassFilter();
	void validateInterfaces() throws IllegalArgumentException;    
}

// org.springframework.aop.IntroductionInfo
public interface IntroductionInfo {
	Class<?>[] getInterfaces();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// org.aopalliance.aop.Advice
public interface Advice {}

// org.springframework.aop.BeforeAdvice
public interface BeforeAdvice extends Advice {}

// org.springframework.aop.MethodBeforeAdvice
public interface MethodBeforeAdvice extends BeforeAdvice {}

// org.springframework.aop.AfterAdvice
public interface AfterAdvice extends Advice {}

// org.springframework.aop.AfterReturningAdvice
public interface AfterReturningAdvice extends AfterAdvice {}

// org.springframework.aop.ThrowsAdvice
public interface ThrowsAdvice extends AfterAdvice {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// org.aopalliance.intercept.Interceptor
public interface Interceptor extends Advice {}

// org.aopalliance.intercept.MethodInterceptor
public interface MethodInterceptor extends Interceptor {}

// org.springframework.aop.DynamicIntroductionAdvice
public interface DynamicIntroductionAdvice extends Advice {}

// org.springframework.aop.IntroductionInterceptor
public interface IntroductionInterceptor extends MethodInterceptor, DynamicIntroductionAdvice {}

// org.aopalliance.intercept.ConstructorInterceptor
public interface ConstructorInterceptor extends Interceptor {}

 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

// org.springframework.aop.Pointcut
public interface Pointcut {
	ClassFilter getClassFilter();
	MethodMatcher getMethodMatcher();
}

// org.springframework.aop.ClassFilter
public interface ClassFilter {
	boolean matches(Class<?> clazz);
}

// org.springframework.aop.MethodMatcher
public interface MethodMatcher {
	/**
	 * Perform static checking whether the given method matches.
	 * <p>If this returns {@code false} or if the {@link #isRuntime()}
	 * method returns {@code false}, no runtime check (i.e. no
	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} call)
	 * will be made.
	 */    
	boolean matches(Method method, Class<?> targetClass);
	/**
	 * Is this MethodMatcher dynamic, that is, must a final call be made on the
	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} method at
	 * runtime even if the 2-arg matches method returns {@code true}?
	 * <p>Can be invoked when an AOP proxy is created, and need not be invoked
	 * again before each method invocation,
	 * @return whether a runtime match via the 3-arg
	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} method
	 * is required if static matching passed
	 */    
	boolean isRuntime();
	/**
	 * Check whether there a runtime (dynamic) match for this method,
	 * which must have matched statically.
	 * <p>This method is invoked only if the 2-arg matches method returns
	 * {@code true} for the given method and target class, and if the
	 * {@link #isRuntime()} method returns {@code true}. Invoked
	 * immediately before potential running of the advice, after any
	 * advice earlier in the advice chain has run.
     */
	boolean matches(Method method, Class<?> targetClass, Object... args);
}

1
2
3
4
5
6
7
8
9

String fileName =  fileNameStrMayBeZhCn + ".xlsx";
fileName = URLEncoder.encode(fileName, "UTF-8").replace("+", "%20");;
byte[] bytes = myservice.exportExcelFile();
return ResponseEntity.status(HttpStatus.OK)
        .contentType(MediaType.APPLICATION_OCTET_STREAM)
        .header(HttpHeaders.CONTENT_DISPOSITION,
                "attachment; filename=\"" + fileName + "\";filename*=utf-8''"+fileName)
        .header(HttpHeaders.CONTENT_LENGTH, String.valueOf(bytes.length))
        .body(bytes);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// org.springframework.context.annotation.EnableAspectJAutoProxy
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {}


// org.springframework.context.annotation.AspectJAutoProxyRegistrar
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    
	@Override
	public void registerBeanDefinitions(
			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        // ...
        
        // 注册 AnnotationAwareAspectJAutoProxyCreator.class
		// Order 设置为最高优先级。beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
    }
}