node-web-mvc/dist/aop/CglibAopProxy.js

node spring mvc

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const OrderedHelper_1 = __importDefault(require("../ioc/factory/OrderedHelper"));
const RuntimeAnnotation_1 = __importDefault(require("../servlets/annotations/annotation/RuntimeAnnotation"));
const MethodAfterReturningAdviceInterceptor_1 = __importDefault(require("./advice/MethodAfterReturningAdviceInterceptor"));
const MethodAfterThrowingAdviceInterceptor_1 = __importDefault(require("./advice/MethodAfterThrowingAdviceInterceptor"));
const MethodAfterAdviceInterceptor_1 = __importDefault(require("./advice/MethodAfterAdviceInterceptor"));
const MethodBeforeAdviceInterceptor_1 = __importDefault(require("./advice/MethodBeforeAdviceInterceptor"));
const DefaultPointcutAdvisor_1 = __importDefault(require("./advisor/DefaultPointcutAdvisor"));
const PointcutAdvisor_1 = __importDefault(require("./advisor/PointcutAdvisor"));
const After_1 = __importDefault(require("./annotations/After"));
const AfterReturning_1 = __importDefault(require("./annotations/AfterReturning"));
const AfterThrowing_1 = __importDefault(require("./annotations/AfterThrowing"));
const Aspect_1 = __importDefault(require("./annotations/Aspect"));
const Before_1 = __importDefault(require("./annotations/Before"));
const ReflectiveMethodInvocation_1 = __importDefault(require("./invocation/ReflectiveMethodInvocation"));
const FunctionExpressionPointcut_1 = __importDefault(require("./pointcut/FunctionExpressionPointcut"));
const src_1 = __importDefault(require("../hmr/src"));
class CglibAopProxy {
    constructor(beanFactory) {
        this.beanFactory = beanFactory;
        registerHotUpdate(this.registerAllAdvisorts.bind(this));
    }
    registerAllAdvisorts() {
        var _a;
        this.advisors = [];
        const allInstances = this.beanFactory.getBeansOfType(Object);
        for (const instance of allInstances) {
            if (instance instanceof PointcutAdvisor_1.default) {
                this.advisors.push(instance);
                continue;
            }
            // 注册aspect注解类型的advisor
            const aspect = (_a = RuntimeAnnotation_1.default.getClassAnnotation(instance.constructor, Aspect_1.default)) === null || _a === void 0 ? void 0 : _a.nativeAnnotation;
            if (aspect) {
                this.registerAspectAdvisors(aspect, instance);
            }
        }
    }
    registerAspectAdvisors(aspect, instance) {
        const clazz = instance.constructor;
        const beforeAnnos = RuntimeAnnotation_1.default.getAnnotations(Before_1.default, clazz);
        const afterAnnos = RuntimeAnnotation_1.default.getAnnotations(After_1.default, clazz);
        const afterReturnAnnos = RuntimeAnnotation_1.default.getAnnotations(AfterReturning_1.default, clazz);
        const afterThrowingAnnos = RuntimeAnnotation_1.default.getAnnotations(AfterThrowing_1.default, clazz);
        this.registerAspectAdvisor(beforeAnnos, instance, MethodBeforeAdviceInterceptor_1.default);
        this.registerAspectAdvisor(afterAnnos, instance, MethodAfterAdviceInterceptor_1.default);
        this.registerAspectAdvisor(afterReturnAnnos, instance, MethodAfterReturningAdviceInterceptor_1.default);
        this.registerAspectAdvisor(afterThrowingAnnos, instance, MethodAfterThrowingAdviceInterceptor_1.default);
    }
    registerAspectAdvisor(annos, instance, Interceptor) {
        annos.forEach((anno) => {
            const handler = anno.method.bind(instance);
            const functionPointcut = new FunctionExpressionPointcut_1.default();
            const advisor = new DefaultPointcutAdvisor_1.default();
            functionPointcut.setExpression(anno.nativeAnnotation.value);
            advisor.setPointcut(functionPointcut);
            advisor.setAdvice(new Interceptor(handler));
            this.addAdvisor(advisor);
        });
    }
    tryRegistryAllAdvisors() {
        if (!this.advisors) {
            this.registerAllAdvisorts();
        }
        return this.advisors;
    }
    createChain(method) {
        var _a;
        const interceptors = [];
        const advisors = this.tryRegistryAllAdvisors();
        for (const advisor of advisors) {
            const pointcut = advisor.getPointcut();
            const advice = advisor.getAdvice();
            if ((_a = pointcut === null || pointcut === void 0 ? void 0 : pointcut.matches) === null || _a === void 0 ? void 0 : _a.call(pointcut, method.clazz, method)) {
                interceptors.push(advice);
            }
        }
        return OrderedHelper_1.default.sort(interceptors);
    }
    addAdvisor(advisor) {
        this.advisors.push(advisor);
    }
    intercept(proxy, target, method, args) {
        const chain = this.createChain(method);
        return new ReflectiveMethodInvocation_1.default(proxy, target, method, args, chain).proceed();
    }
}
exports.default = CglibAopProxy;
function registerHotUpdate(registerAllAdvisorts) {
    src_1.default
        .create(module)
        .clean()
        .allDone(() => {
        // 热更新后这里需要重新注册
        registerAllAdvisorts();
    });
}