基于spring的可扩展性

最新推荐文章于 2024-05-05 23:03:58 发布

xujieyang4j

最新推荐文章于 2024-05-05 23:03:58 发布

阅读量1.8k

点赞数 2

分类专栏： spring 文章标签： spring

本文链接：https://blog.csdn.net/xujieyang4j/article/details/50815789

版权

spring 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

从一个日志功能开始说起

1. v1 : spring aop 实现日志

代码示例:

@Aspect
@Deprecated
public class MysqlLogAspect {
    private static final Logger log = LoggerFactory.getLogger(MysqlLogAspect.class);
    @Around("execution(* *(..))")
    public void aroundPerformance(ProceedingJoinPoint joinPoint, MysqlLog mysqlLog) throws Throwable {
        // 方法的签名
        Signature signature = joinPoint.getSignature();
        log.info("start execute [{}]", signature);
        long start = System.currentTimeMillis();
        // 方法名
        try {
            joinPoint.proceed();
        } catch (Throwable e) {
            log.error("", e);
            throw e;
        }
        long end = System.currentTimeMillis();
        log.info("end execute [{}], cost {} ms", signature, (end - start));
    }

}

可以看到通过spring的@Aspect、@Around、@Before、@After…等注解可以轻易的实现日志功能。
可是这样的就达到了要求了吗？
我希望更加精细一些的控制，类的某些方法需要日志，某些不需要，该怎么做？

2. v2 : 再精细一些的控制，添加注解支持

代码示例:

@Aspect
@Deprecated
public class MysqlLogAspect {
    private static final Logger log = LoggerFactory.getLogger(MysqlLogAspect.class);
    @Around("execution(* *(..)) && @annotation(mysqlLog)")
    public void aroundPerformance(ProceedingJoinPoint joinPoint, MysqlLog mysqlLog) throws Throwable {
        // 方法的签名
        Signature signature = joinPoint.getSignature();
        log.info("start execute [{}]", signature);
        long start = System.currentTimeMillis();
        // 方法名
        try {
            joinPoint.proceed();
        } catch (Throwable e) {
            log.error("", e);
            throw e;
        }
        long end = System.currentTimeMillis();
        log.info("end execute [{}], cost {} ms", signature, (end - start));
    }

}

这样你就可以在类的方法的注解上添加日志注解，然后就可以精细到方法了。
这样就够了吗？
如果我希望，在类上使用注解，默认这个类的所有方法便开启日志功能，要怎么做呢？
aop的切入点表达式可以实现吗？反正我是不知道？除此之外，切入点需要指定范围，而我更想把日志功能做成一个通用spring插件，就想 @Async 一样。那应该怎么做？

3. v3 : 实现spring注解日志插件

代码示例:

package com.xjy.log.core;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 日志注解，默认的日志处理器只是简单的打印了耗时
 * @author freeman.xu
 *
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {
    /** key，如果不指定则是'被标注类的全包名#方法签名' */
    String key() default "";
    /** 日志描述 */
    String desc() default "";
    /** 日志处理器 */
    String logProcessor() default "";
}

package com.xjy.log.core;

import org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;

@SuppressWarnings("serial")
public class LogAnnotationBeanPostProcessor extends AbstractAdvisingBeanPostProcessor implements BeanFactoryAware {

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        LogAnnotationAdvisor advisor = new LogAnnotationAdvisor(new DefaultLogProcessor());
        advisor.setBeanFactory(beanFactory);
        this.advisor = advisor;
    }

}

package com.xjy.log.core;

import java.lang.annotation.Annotation;
import java.util.LinkedHashSet;
import java.util.Set;

import org.aopalliance.aop.Advice;
import org.springframework.aop.Pointcut;
import org.springframework.aop.support.AbstractPointcutAdvisor;
import org.springframework.aop.support.ComposablePointcut;
import org.springframework.aop.support.annotation.AnnotationMatchingPointcut;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;

@SuppressWarnings("serial")
public class LogAnnotationAdvisor extends AbstractPointcutAdvisor implements BeanFactoryAware {

    private Advice advice;

    private Pointcut pointcut;

    public LogAnnotationAdvisor(LogProcessor logProcessor) {
        Set<Class<? extends Annotation>> logAnnotationTypes = new LinkedHashSet<Class<? extends Annotation>>(2);
        logAnnotationTypes.add(Log.class);
        this.advice = buildAdvice(logProcessor);
        this.pointcut = buildPointcut(logAnnotationTypes);
    }

    protected Advice buildAdvice(LogProcessor logProcessor) {
        return new LogInterceptor(logProcessor);
    }

    protected Pointcut buildPointcut(Set<Class<? extends Annotation>> logAnnotationTypes) {
        ComposablePointcut result = null;
        for (Class<? extends Annotation> logAnnotationType : logAnnotationTypes) {
            Pointcut cpc = new AnnotationMatchingPointcut(logAnnotationType, true);
            Pointcut mpc = AnnotationMatchingPointcut.forMethodAnnotation(logAnnotationType);
            if (result == null) {
                result = new ComposablePointcut(cpc).union(mpc);
            }
            else {
                result.union(cpc).union(mpc);
            }
        }
        return result;
    }

    @Override
    public Pointcut getPointcut() {
        return this.pointcut;
    }

    @Override
    public Advice getAdvice() {
        return this.advice;
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        if (this.advice instanceof BeanFactoryAware) {
            ((BeanFactoryAware) this.advice).setBeanFactory(beanFactory);
        }
    }

}

package com.xjy.log.core;

import java.lang.reflect.Method;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.annotation.BeanFactoryAnnotationUtils;
import org.springframework.core.BridgeMethodResolver;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;

@Component
public class LogInterceptor implements MethodInterceptor, Ordered, BeanFactoryAware {

    private final Map<Method, LogProcessor> logProcessors = new ConcurrentHashMap<Method, LogProcessor>(16);
    private BeanFactory beanFactory;
    private LogProcessor defaultLogProcessor;

    public LogInterceptor() {
    }

    @Override
    public int getOrder() {
        return Ordered.LOWEST_PRECEDENCE;
    }

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Class<?> targetClass = getTargetClass(invocation);
        Method specificMethod = getSpecificMethod(invocation);
        String logDesc = getLogDesc(targetClass, specificMethod);
        logger.info("start execute [{}] method [{}]，desc is [{}]", targetClass, specificMethod, logDesc);
        long start = System.currentTimeMillis();
        Object result = null;
        try {
            result = invocation.proceed();
        } catch (Throwable e) {
            logger.error("execute [" + targetClass + "] method [" + specificMethod + "] error", e);
            throw e;
        }
        long end = System.currentTimeMillis();
        logger.info("end execute [{}] method [{}]，desc is [{}]，cost[{}] ms", targetClass, specificMethod, logDesc, (end - start));
        return result;
    }

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

}

4. 为什么是这样实现的呢

1.  spring源码解析

spring源码示例:

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            postProcessBeanFactory(beanFactory);

            // Invoke factory processors registered as beans in the context.
            invokeBeanFactoryPostProcessors(beanFactory);

            // Register bean processors that intercept bean creation.
            registerBeanPostProcessors(beanFactory);

            // Initialize message source for this context.
            initMessageSource();

            // Initialize event multicaster for this context.
            initApplicationEventMulticaster();

            // Initialize other special beans in specific context subclasses.
            onRefresh();

            // Check for listener beans and register them.
            registerListeners();

            // Instantiate all remaining (non-lazy-init) singletons.
            finishBeanFactoryInitialization(beanFactory);

            // Last step: publish corresponding event.
            finishRefresh();
        }

        catch (BeansException ex) {
            logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex);

            // Destroy already created singletons to avoid dangling resources.
            destroyBeans();

            // Reset 'active' flag.
            cancelRefresh(ex);

            // Propagate exception to caller.
            throw ex;
        }
    }
}

我知道的步骤分析:

// Tell the subclass to refresh the internal bean factory.
// 这一步会加载你在spring.xml中定义的bean
// 其中又分普通的<bean>标签以及自定义的标签,比如<task:annoatation-driven/>
// 自定义的标签会有相应的NameHandler和BeanDefinitionParser
// NameHandler的定义在spring的jar包的META-INF下面，文件名是spring.handlers、spring.schemas、spring.tooling
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

示例:

// 解析xml的类,org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    if (delegate.isDefaultNamespace(root)) {
        NodeList nl = root.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (node instanceof Element) {
                Element ele = (Element) node;
                if (delegate.isDefaultNamespace(ele)) {
                    // DefaultElement,eg:http://www.springframework.org/schema/beans 
                    parseDefaultElement(ele, delegate);
                }
                else {
                    // CustomElement, eg:http://www.springframework.org/schema/task等
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    else {
        delegate.parseCustomElement(root);
    }
}
// CustomElement的bean有NameHandler和BeanDefinitionParser, 以及NameHandler的定义在spring的jar包的META-INF下面，文件名是spring.handlers、spring.schemas
// org.springframework.scheduling.config.TaskNamespaceHandler
public class TaskNamespaceHandler extends NamespaceHandlerSupport {

    public void init() {
        this.registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
        this.registerBeanDefinitionParser("executor", new ExecutorBeanDefinitionParser());
        this.registerBeanDefinitionParser("scheduled-tasks", new ScheduledTasksBeanDefinitionParser());
        this.registerBeanDefinitionParser("scheduler", new SchedulerBeanDefinitionParser());
    }

}
// org.springframework.scheduling.config.AnnotationDrivenBeanDefinitionParser
public BeanDefinition parse(Element element, ParserContext parserContext) {
    Object source = parserContext.extractSource(element);
    // Register component for the surrounding <task:annotation-driven> element.
    CompositeComponentDefinition compDefinition = new CompositeComponentDefinition(element.getTagName(), source);
    parserContext.pushContainingComponent(compDefinition);
    // Nest the concrete post-processor bean in the surrounding component.
    BeanDefinitionRegistry registry = parserContext.getRegistry();
    String mode = element.getAttribute("mode");
    if ("aspectj".equals(mode)) {
        // mode="aspectj"
        registerAsyncExecutionAspect(element, parserContext);
    }
    else {
        // mode="proxy"
        if (registry.containsBeanDefinition(AnnotationConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            parserContext.getReaderContext().error(
                    "Only one AsyncAnnotationBeanPostProcessor may exist within the context.", source);
        }
        else {
            BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(
                    "org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessor");
            builder.getRawBeanDefinition().setSource(source);
            String executor = element.getAttribute("executor");
            if (StringUtils.hasText(executor)) {
                builder.addPropertyReference("executor", executor);
            }
            if (Boolean.valueOf(element.getAttribute(AopNamespaceUtils.PROXY_TARGET_CLASS_ATTRIBUTE))) {
                builder.addPropertyValue("proxyTargetClass", true);
            }
            registerPostProcessor(parserContext, builder, AnnotationConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME);
        }
    }
    if (registry.containsBeanDefinition(AnnotationConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        parserContext.getReaderContext().error(
                "Only one ScheduledAnnotationBeanPostProcessor may exist within the context.", source);
    }
    else {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(
                "org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor");
        builder.getRawBeanDefinition().setSource(source);
        String scheduler = element.getAttribute("scheduler");
        if (StringUtils.hasText(scheduler)) {
            builder.addPropertyReference("scheduler", scheduler);
        }
        registerPostProcessor(parserContext, builder, AnnotationConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME);
    }
    // Finally register the composite component.
    parserContext.popAndRegisterContainingComponent();

    return null;
}

// Register bean processors that intercept bean creation.
// 这一步会注册BeanPostProcessors
// 所谓的BeanPostProcessors就是在创建bean的时候，拦截bean的创建，有前置拦截和后置拦截
// 也是通过BeanPostProcessors对原始的bean进行动态代理，生成代理bean
registerBeanPostProcessors(beanFactory);

示例:

// 注册BeanPostProcessors,注册的时候有优先级顺序.org.springframework.context.supportAbstractApplicationContext#registerBeanPostProcessors
// BeanPostProcessors拦截bean的创建.org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
        throws BeansException {

    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}
// 动态代理拦截.org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor
public Object postProcessAfterInitialization(Object bean, String beanName) {
    if (bean instanceof AopInfrastructureBean) {
        // Ignore AOP infrastructure such as scoped proxies.
        return bean;
    }

    if (bean instanceof Advised) {
        Advised advised = (Advised) bean;
        if (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) {
            // Add our local Advisor to the existing proxy's Advisor chain...
            if (this.beforeExistingAdvisors) {
                advised.addAdvisor(0, this.advisor);
            }
            else {
                advised.addAdvisor(this.advisor);
            }
            return bean;
        }
    }

    if (isEligible(bean, beanName)) {
        ProxyFactory proxyFactory = new ProxyFactory(bean);
        // Copy our properties (proxyTargetClass etc) inherited from ProxyConfig.
        proxyFactory.copyFrom(this);
        proxyFactory.addAdvisor(this.advisor);
        return proxyFactory.getProxy(this.beanClassLoader);
    }

    // No async proxy needed.
    return bean;
}
// 动态代理的部分实现
// jdk
public Object getProxy(ClassLoader classLoader) {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
    }
    Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
// cglib
public Object getProxy(ClassLoader classLoader) {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating CGLIB proxy: target source is " + this.advised.getTargetSource());
    }

    try {
        Class<?> rootClass = this.advised.getTargetClass();
        Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");

        Class<?> proxySuperClass = rootClass;
        if (ClassUtils.isCglibProxyClass(rootClass)) {
            proxySuperClass = rootClass.getSuperclass();
            Class<?>[] additionalInterfaces = rootClass.getInterfaces();
            for (Class<?> additionalInterface : additionalInterfaces) {
                this.advised.addInterface(additionalInterface);
            }
        }

        // Validate the class, writing log messages as necessary.
        validateClassIfNecessary(proxySuperClass);

        // Configure CGLIB Enhancer...
        Enhancer enhancer = createEnhancer();
        if (classLoader != null) {
            enhancer.setClassLoader(classLoader);
            if (classLoader instanceof SmartClassLoader &&
                    ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
                enhancer.setUseCache(false);
            }
        }
        enhancer.setSuperclass(proxySuperClass);
        enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
        enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
        enhancer.setStrategy(new MemorySafeUndeclaredThrowableStrategy(UndeclaredThrowableException.class));
        enhancer.setInterceptDuringConstruction(false);

        Callback[] callbacks = getCallbacks(rootClass);
        Class<?>[] types = new Class<?>[callbacks.length];
        for (int x = 0; x < types.length; x++) {
            types[x] = callbacks[x].getClass();
        }
        enhancer.setCallbackFilter(new ProxyCallbackFilter(
                this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
        enhancer.setCallbackTypes(types);
        enhancer.setCallbacks(callbacks);

        // Generate the proxy class and create a proxy instance.
        Object proxy;
        if (this.constructorArgs != null) {
            proxy = enhancer.create(this.constructorArgTypes, this.constructorArgs);
        }
        else {
            proxy = enhancer.create();
        }

        return proxy;
    }
    catch (CodeGenerationException ex) {
        throw new AopConfigException("Could not generate CGLIB subclass of class [" +
                this.advised.getTargetClass() + "]: " +
                "Common causes of this problem include using a final class or a non-visible class",
                ex);
    }
    catch (IllegalArgumentException ex) {
        throw new AopConfigException("Could not generate CGLIB subclass of class [" +
                this.advised.getTargetClass() + "]: " +
                "Common causes of this problem include using a final class or a non-visible class",
                ex);
    }
    catch (Exception ex) {
        // TargetSource.getTarget() failed
        throw new AopConfigException("Unexpected AOP exception", ex);
    }
}

这是比较通用的代理bean的方法，当然有些BeanPostProcessors会重写这个方法，比如定时任务的BeanPostProcessors，它并不需要生成代理bean，而是启动调度线程。
从上面的代码可以很明显的看出代理bean的生成、代理链，以及代理链的顺序（有时候需要注意顺序）。

5. 再进一步，更加透明化，自定义标签

让人着迷的spring标签

xmlns:task="http://www.springframework.org/schema/task"
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.2.xsd
<task:scheduler id="scheduler" pool-size="10"/>
<task:executor id="executor" pool-size="10"/>
<!-- 开启自动调度和异步方法 -->
<task:annotation-driven executor="executor" scheduler="scheduler"/>

自定义标签实现(未经过测试):
需要定义在META-INF下面定义spring.handlers和spring.schemas

spring.handlers
http\://www.springframework.org/schema/log=com.xjy.core.log.LogNamespaceHandler
spring.schemas
http\://www.springframework.org/schema/log/spring-log-3.2.xsd=com/xjy/core/log/config/spring-log-3.2.xsd

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<xsd:schema xmlns="http://www.springframework.org/schema/log"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        xmlns:beans="http://www.springframework.org/schema/beans"
        xmlns:tool="http://www.springframework.org/schema/tool"
        targetNamespace="http://www.springframework.org/schema/log"
        elementFormDefault="qualified"
        attributeFormDefault="unqualified">

    <xsd:annotation>
        <xsd:documentation><![CDATA[
    Defines the elements used in the Spring Framework's support for task execution and scheduling.
        ]]></xsd:documentation>
    </xsd:annotation>

    <xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans-3.2.xsd"/>
    <xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool-3.2.xsd"/>

    <xsd:element name="annotation-driven">
        <xsd:annotation>
            <xsd:documentation><![CDATA[
    Enables the detection of @Async and @Scheduled annotations on any Spring-managed
    object. If present, a proxy will be generated for executing the annotated methods
    asynchronously.

    See Javadoc for the org.springframework.scheduling.annotation.EnableAsync and
    org.springframework.scheduling.annotation.EnableScheduling annotations for information
    on code-based alternatives to this XML element.
            ]]></xsd:documentation>
        </xsd:annotation>
...其他
<!-- 定义log -->
<log:annotation-driven />

package com.xjy.log.core;

import org.springframework.beans.factory.xml.NamespaceHandlerSupport;

public class LogNamespaceHandler extends NamespaceHandlerSupport {

    @Override
    public void init() {
        this.registerBeanDefinitionParser("annotation-driven", new LogBeanDefinitionParser());
    }

}

package com.xjy.log.core;

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.parsing.BeanComponentDefinition;
import org.springframework.beans.factory.parsing.CompositeComponentDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.xml.BeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
import org.w3c.dom.Element;

public class LogBeanDefinitionParser implements BeanDefinitionParser {
    private static final String logAnnotationProcessorBeanName = "com.xjy.core.log.internalLogAnnotationBeanPostProcessor";

    @Override
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        Object source = parserContext.extractSource(element);

        // Register component for the surrounding <task:annotation-driven> element.
        CompositeComponentDefinition compDefinition = new CompositeComponentDefinition(element.getTagName(), source);
        parserContext.pushContainingComponent(compDefinition);

        // Nest the concrete post-processor bean in the surrounding component.
        BeanDefinitionRegistry registry = parserContext.getRegistry();

        if (registry.containsBeanDefinition(logAnnotationProcessorBeanName)) {
            parserContext.getReaderContext().error(
                    "Only one LogAnnotationProcessorBeanName may exist within the context.", source);
        } else {
            BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(
                    "com.xjy.core.log.LogAnnotationBeanPostProcessor");
            builder.getRawBeanDefinition().setSource(source);
            registerPostProcessor(parserContext, builder, logAnnotationProcessorBeanName);
        }
        // Finally register the composite component.
        parserContext.popAndRegisterContainingComponent();

        return null;
    }

    private static void registerPostProcessor(
            ParserContext parserContext, BeanDefinitionBuilder builder, String beanName) {

        builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        parserContext.getRegistry().registerBeanDefinition(beanName, builder.getBeanDefinition());
        BeanDefinitionHolder holder = new BeanDefinitionHolder(builder.getBeanDefinition(), beanName);
        parserContext.registerComponent(new BeanComponentDefinition(holder));
    }

}

其实说白了，就是不用手动在去定义bean了，更方便，更透明了。
至此，一个spring插件就定义完了

6. 再进一步，抽象日志处理器，这一步和spring没啥关系

注解中可以选择使用哪个日志处理器:

package com.xjy.log.core;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 日志注解，默认的日志处理器只是简单的打印了耗时
 * @author freeman.xu
 *
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {
    /** key，如果不指定则是'被标注类的全包名#方法签名' */
    String key() default "";
    /** 日志描述 */
    String desc() default "";
    /** 日志处理器 */
    String logProcessor() default "";
}

代理方法执行的时候选择对应的日志处理器即:

private LogProcessor determineLogProcessor(Method method) {

        LogProcessor logProcessor = this.logProcessors.get(method);
        if (logProcessor == null) {
            logProcessor = this.defaultLogProcessor;
            String qualifier = getExecutorQualifier(method);
            if (StringUtils.hasLength(qualifier)) {
                Assert.notNull(this.beanFactory, "BeanFactory must be set on " + getClass().getSimpleName()
                        + " to access qualified logProcessor '" + qualifier + "'");
                logProcessor = BeanFactoryAnnotationUtils.qualifiedBeanOfType(this.beanFactory, LogProcessor.class, qualifier);
            } else if (logProcessor == null) {
                return null;
            }
            this.logProcessors.put(method, logProcessor);
        }
        return logProcessor;
    }


    private String getExecutorQualifier(Method method) {
        Log log = AnnotationUtils.findAnnotation(method, Log.class);
        if (log == null) {
            log = AnnotationUtils.findAnnotation(method.getDeclaringClass(), Log.class);
        }
        return (log != null ? log.logProcessor() : null);
    }

日志处理器:

package com.xjy.log.core;

import org.aopalliance.intercept.MethodInvocation;

/**
 * 日志处理器
 * @author freeman.xu
 *
 */
public interface LogProcessor {

    Object log(MethodInvocation invocation) throws Throwable;

}

package com.xjy.log.core;

import java.lang.reflect.Method;

import org.aopalliance.intercept.MethodInvocation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DefaultLogProcessor extends AbstractLogProcessor {
    private static final Logger logger = LoggerFactory.getLogger(DefaultLogProcessor.class);

    @Override
    public Object log(MethodInvocation invocation) throws Throwable {
        Class<?> targetClass = getTargetClass(invocation);
        Method specificMethod = getSpecificMethod(invocation);
        String logDesc = getLogDesc(targetClass, specificMethod);
        logger.info("start execute [{}] method [{}]，desc is [{}]", targetClass, specificMethod, logDesc);
        long start = System.currentTimeMillis();
        Object result = null;
        try {
            result = invocation.proceed();
        } catch (Throwable e) {
            logger.error("execute [" + targetClass + "] method [" + specificMethod + "] error", e);
            throw e;
        }
        long end = System.currentTimeMillis();
        logger.info("end execute [{}] method [{}]，desc is [{}]，cost[{}] ms", targetClass, specificMethod, logDesc, (end - start));
        return result;
    }


}

package com.xjy.web.log;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import javax.servlet.http.HttpServletRequest;

import org.aopalliance.intercept.MethodInvocation;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.thrift.TException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.ModelAttribute;

import com.xjy.log.core.AbstractLogProcessor;
import com.xjy.log.core.Log;
import com.xjy.log.service.ILogService;
import com.xjy.log.service.thrift.LogServiceThrift;
import com.xjy.log.service.thrift.LogThrift;

/**
 * 用户处理web请求的日志处理器。<br>
 * 一般来说，这类的日志建议把{@link Log}的key设置为访问的url，如果url是动态的。<br>
 * 那么建议方法的参数传递一个HttpServletRequest，或者使用{@link ModelAttribute}初始化HttpServletRequest，便于处理器获取url。
 * @author xujieyang
 *
 */
@Component("webLogProcessor")
public class WebLogProcessor extends AbstractLogProcessor {

    private static final Logger logger = LoggerFactory.getLogger(WebLogProcessor.class);

    @Autowired(required = false)
    @Qualifier("logServiceRmi")
    private ILogService logServiceRmi;

    @Autowired
    @Qualifier("logExecutor")
    private ThreadPoolTaskExecutor logExecutor;

    @Override
    public Object log(MethodInvocation invocation) throws Throwable {
        Class<?> targetClass = getTargetClass(invocation);
        Method specificMethod = getSpecificMethod(invocation);
        String url = getUrl(invocation, targetClass, specificMethod);
        long start = System.currentTimeMillis();
        logger.info("user start visis page [{}]", url);
        Object result = null;
        try {
            result = invocation.proceed();
            long end = System.currentTimeMillis();
            Log log = this.getLog(targetClass, specificMethod);
            addLog(url , log.desc(), (end -start), "xujieyang_blog", true);
            logger.info("use end visit page [{}], cost {} ms", url, (end -start));
        } catch (Throwable e) {
            // 异步添加失败日志
            Log log = this.getLog(targetClass, specificMethod);
            addLog(url, log.desc(), -1L, "xujieyang_blog", false);
            logger.error("execute [" + targetClass + "] method [" + specificMethod + "] error", e);
            throw e;
        }
        return result;
    }

    private String getUrl(MethodInvocation invocation, Class<?> targetClass, Method specificMethod) {
        Log log = this.getLog(targetClass, specificMethod);
        String url = log.key();
        if(StringUtils.isNotBlank(url)) {
            return url;
        }
        HttpServletRequest request = this.getHttpServletRequest(invocation);
        if(request != null) {
            url = request.getRequestURI();
        } else {
            logger.warn("Can not get HttpServletRequest, but this is a web log processor, "
                    + "so you should provide HttpServletRequest, then logProcessor can log url.");
            url = getLogDesc(targetClass, specificMethod);
        }
        return url;
    }

    private HttpServletRequest getHttpServletRequest(MethodInvocation invocation) {
        Object traget = invocation.getThis();
        HttpServletRequest request = null;
        try {
            // 从class中获取
            request = (HttpServletRequest) PropertyUtils.getProperty(traget, "request");
        } catch (IllegalAccessException | InvocationTargetException
                | NoSuchMethodException e) {
            logger.warn("can not get request property");
        }
        if(request == null) {
            // 从方法参数中获取
            Object[] args = invocation.getArguments();
            if(ArrayUtils.isEmpty(args)) {
                return request;
            }
            for(Object arg : args) {
                // Class1.isAssignableFrom(Class2)  
                // isAssignableFrom   是用来判断一个类Class1和另一个类Class2是否相同或是另一个类的超类或接口
                if(HttpServletRequest.class.isAssignableFrom(arg.getClass())) {
                    return (HttpServletRequest) arg;
                }
            }
        }
        return request;
    }

    private void addLog(String key, String desc, long costMs, String systemKey, boolean success) {
        if(logServiceRmi == null) {
            logger.warn("logServiceRmi is null");
            return;
        }
        logExecutor.execute(new Runnable() {

            @Override
            public void run() {
                com.xjy.log.model.Log log = new com.xjy.log.model.Log();
                log.setCostMs(costMs);
                log.setDesc(desc);
                log.setKey(key);
                log.setSystemKey(systemKey);
                log.setSuccess(success);
                logServiceRmi.add(log);
            }
        });
    }

}

7. 举一反三，锁实现

package com.xjy.core.lock;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 定时任务锁，也支持分布式锁，锁的默认实现为单机锁。<br>
 * @author xujieyang
 *
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Lock {
    /** 锁的key */
    String key();
    /** 锁的value */
    String value();
    /** key过期的时间，使用秒为单位 */
    long expireTime() default 0L;
    String locker() default "";
}

package com.xjy.core.lock;

import org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;

@SuppressWarnings("serial")
public class LockAnnotationBeanPostProcessor extends AbstractAdvisingBeanPostProcessor implements BeanFactoryAware {

    public LockAnnotationBeanPostProcessor() {
        this.beforeExistingAdvisors = true;
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        LockAnnotationAdvisor advisor = new LockAnnotationAdvisor(new DefaultLocker());
        advisor.setBeanFactory(beanFactory);
        this.advisor = advisor;
    }

    @Override
    public int getOrder() {
        return HIGHEST_PRECEDENCE;
    }

}

package com.xjy.core.lock;

import java.lang.annotation.Annotation;
import java.util.LinkedHashSet;
import java.util.Set;

import org.aopalliance.aop.Advice;
import org.springframework.aop.Pointcut;
import org.springframework.aop.support.AbstractPointcutAdvisor;
import org.springframework.aop.support.ComposablePointcut;
import org.springframework.aop.support.annotation.AnnotationMatchingPointcut;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;

@SuppressWarnings("serial")
public class LockAnnotationAdvisor extends AbstractPointcutAdvisor implements BeanFactoryAware {

    private Advice advice;

    private Pointcut pointcut;

    public LockAnnotationAdvisor(Locker locker) {
        Set<Class<? extends Annotation>> lockAnnotationTypes = new LinkedHashSet<Class<? extends Annotation>>(2);
        lockAnnotationTypes.add(Lock.class);
        this.advice = this.buildAdvice(locker);
        this.pointcut = buildPointcut(lockAnnotationTypes);
    }

    protected Advice buildAdvice(Locker locker) {
        return new LockInterceptor(locker);
    }

    protected Pointcut buildPointcut(Set<Class<? extends Annotation>> redisLockAnnotationTypes) {
        ComposablePointcut result = null;
        for (Class<? extends Annotation> redisLockAnnotationType : redisLockAnnotationTypes) {
            Pointcut cpc = new AnnotationMatchingPointcut(redisLockAnnotationType, true);
            Pointcut mpc = AnnotationMatchingPointcut.forMethodAnnotation(redisLockAnnotationType);
            if (result == null) {
                result = new ComposablePointcut(cpc).union(mpc);
            }
            else {
                result.union(cpc).union(mpc);
            }
        }
        return result;
    }

    @Override
    public Pointcut getPointcut() {
        return this.pointcut;
    }

    @Override
    public Advice getAdvice() {
        return this.advice;
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        if (this.advice instanceof BeanFactoryAware) {
            ((BeanFactoryAware) this.advice).setBeanFactory(beanFactory);
        }
    }

}

package com.xjy.core.lock;

import java.lang.reflect.Method;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.annotation.BeanFactoryAnnotationUtils;
import org.springframework.core.BridgeMethodResolver;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;

public class LockInterceptor implements MethodInterceptor, Ordered, BeanFactoryAware {

    private final Map<Method, Locker> lockers = new ConcurrentHashMap<Method, Locker>(16);
    private BeanFactory beanFactory;
    private Locker defaultLocker;

    public LockInterceptor() {
    }

    public LockInterceptor(Locker defaultLocker) {
        this.defaultLocker = defaultLocker;
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
        Method specificMethod = ClassUtils.getMostSpecificMethod(invocation.getMethod(), targetClass);
        specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
        Locker locker = determineLocker(specificMethod);
        return locker.lock(invocation);
    }

    private Locker determineLocker(Method method) {

        Locker locker = this.lockers.get(method);
        if (locker == null) {
            locker = this.defaultLocker;
            String qualifier = getExecutorQualifier(method);
            if (StringUtils.hasLength(qualifier)) {
                Assert.notNull(this.beanFactory, "BeanFactory must be set on " + getClass().getSimpleName()
                        + " to access qualified logProcessor '" + qualifier + "'");
                locker = BeanFactoryAnnotationUtils.qualifiedBeanOfType(this.beanFactory, Locker.class, qualifier);
            } else if (locker == null) {
                return null;
            }
            this.lockers.put(method, locker);
        }
        return locker;
    }

    private String getExecutorQualifier(Method method) {
        Lock lock = AnnotationUtils.findAnnotation(method, Lock.class);
        if (lock == null) {
            lock = AnnotationUtils.findAnnotation(method.getDeclaringClass(), Lock.class);
        }
        return (lock != null ? lock.locker() : null);
    }

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

}

8. spring之代理的代理

java rmi和spring
只需要配置就可以发布为rmi服务，示例:

<!-- 发布为rmi服务 -->
<bean id="registry" class="org.springframework.remoting.rmi.RmiRegistryFactoryBean">
    <property name="port" value="${log.rmi.port}" />
</bean>
<bean class="org.springframework.remoting.rmi.RmiServiceExporter"
    p:service-ref="logService"
    p:serviceName="logServiceRmi"
    p:serviceInterface="com.xjy.log.service.ILogService"
    p:registry-ref="registry"
    p:registryHost="${log.rmi.host}"/>

<!-- rmi客户端 -->
<bean id="logServiceRmi" 
    class="org.springframework.remoting.rmi.RmiProxyFactoryBean"
    p:serviceUrl="${logServiceRmi}"
    p:serviceInterface="com.xjy.log.service.ILogService"
    p:cacheStub="false"
    p:refreshStubOnConnectFailure="true" />

现在你只需要在需要rmi服务的地方注入logServiceRmi就可以了。这看起来很完美，但我现在用的是thrift呀，rmi已经没落了。
10. #### spring和thrift ####
实现类似的rmi服务:

package com.xjy.core.remoting.thrift;

import java.lang.reflect.InvocationTargetException;

import org.apache.commons.lang.ClassUtils;
import org.apache.commons.lang.reflect.ConstructorUtils;
import org.apache.thrift.TProcessor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.util.Assert;

// TODO 改造成一次可以发布多个server服务
public abstract class AbstractThriftServer implements InitializingBean {
    private static final Logger log = LoggerFactory.getLogger(AbstractThriftServer.class);
    /** thrift生成的service中Processor内部类的名称 */
    private static final String processorInnerClassName = "Processor";

    /** 发布service的端口号 */
    protected Integer port;
    /** thrift生成的service的实现类 */
    protected Object service;
    /** thrift生成的service的包名 */
    protected String triftServicePackageName;

    public Integer getPort() {
        return port;
    }
    public void setPort(Integer port) {
        this.port = port;
    }
    public Object getService() {
        return service;
    }
    public void setService(Object service) {
        this.service = service;
    }
    public String getTriftServicePackageName() {
        return triftServicePackageName;
    }
    public void setTriftServicePackageName(String triftServicePackageName) {
        this.triftServicePackageName = triftServicePackageName;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        Assert.notNull(port, "port property required");
        Assert.notNull(service, "service property required");
        Assert.notNull(triftServicePackageName, "triftServicePackageName property required");
        TProcessor tProcessor = initTprocessor();
        // 一个tProcessor对应一个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                startThriftServer(tProcessor);
            }
        }).start();
    }

    /**
     * 初始化TProcessor
     * @return
     * @throws Exception
     */
    protected TProcessor initTprocessor() throws Exception {
        log.info("start initTprocessor, triftServicePackageName is {}", triftServicePackageName);
        TProcessor tProcessor = null;
        try {
            Class<?> processorClass = ClassUtils.getClass(triftServicePackageName + "$" + processorInnerClassName);
//                  async ? ClassUtils.getClass(triftServicePackageName + "$" + asyncProcessorInnerClassName) : 
//              ClassUtils.getClass(triftServicePackageName + "$" + processorInnerClassName);
            // TODO 验证service的正确性
//          Class<?> ifaceClass = ClassUtils.getClass(genTriftServicePackName + "$Iface");
            tProcessor = (TProcessor) ConstructorUtils.invokeConstructor(processorClass, service);
        } catch (ClassNotFoundException
                | NoSuchMethodException | IllegalAccessException
                | InvocationTargetException | InstantiationException e) {
            log.error("initTprocessor error, triftServicePackageName is " + triftServicePackageName, e);
            throw e;
        }
        log.info("end initTprocessor, triftServicePackageName is {}", triftServicePackageName);
        return tProcessor;
    }

    /**
     * 启动服务，子类选择使用不同的方式启动thrift服务
     * @param tProcessor
     */
    protected abstract void startThriftServer(TProcessor tProcessor);

}

package com.xjy.core.remoting.thrift;

import org.apache.thrift.TProcessor;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.server.TServer;
import org.apache.thrift.server.TSimpleServer;
import org.apache.thrift.transport.TServerSocket;
import org.apache.thrift.transport.TTransportException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SimpleThriftServer extends AbstractThriftServer {
    private static final Logger log = LoggerFactory.getLogger(SimpleThriftServer.class);

    @Override
    protected void startThriftServer(TProcessor tProcessor) {
        log.info("startThriftServer type is simple, port is {}, triftServicePackageName is {}", port, triftServicePackageName);
        TServerSocket serverTransport;
        try {
            serverTransport = new TServerSocket(port);
            TServer.Args tArgs = new TServer.Args(serverTransport);
            tArgs.processor(tProcessor);
            tArgs.protocolFactory(new TBinaryProtocol.Factory());
            // simple sever 用于测试
            TServer server = new TSimpleServer(tArgs);
            // 此处会阻塞
            server.serve();
        } catch (TTransportException e) {
            log.error("startThriftServer error type is simple, port is " + port + "triftServicePackageName is " + triftServicePackageName, e);
        }
    }

}

package com.xjy.core.remoting.thrift;

import org.apache.thrift.TProcessor;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.server.TServer;
import org.apache.thrift.server.TThreadPoolServer;
import org.apache.thrift.transport.TServerSocket;
import org.apache.thrift.transport.TTransportException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ThreadPoolThriftServer extends AbstractThriftServer {
    private static final Logger log = LoggerFactory.getLogger(ThreadPoolThriftServer.class);

    @Override
    protected void startThriftServer(TProcessor tProcessor) {
        log.info("startThriftServer type is ThreadPool, port is {}, triftServicePackageName is {}", port, triftServicePackageName);
        TServerSocket serverTransport;
        try {
            serverTransport = new TServerSocket(port);
            TThreadPoolServer.Args ttpsArgs = new TThreadPoolServer.Args(serverTransport);
            ttpsArgs.processor(tProcessor);
            ttpsArgs.protocolFactory(new TBinaryProtocol.Factory());
            // 线程池服务模型，使用标准的阻塞式IO，预先创建一组线程处理请求。
            TServer server = new TThreadPoolServer(ttpsArgs);
            // 此处会阻塞
            server.serve();
        } catch (TTransportException e) {
            log.error("startThriftServer error type is ThreadPool, port is " + port + "triftServicePackageName is " + triftServicePackageName, e);
        }
    }

}

package com.xjy.core.remoting.thrift;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.commons.lang.reflect.ConstructorUtils;
import org.apache.commons.lang.reflect.MethodUtils;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.util.ClassUtils;

public class ThriftClientProxyFactoryBean implements FactoryBean<Object>, InitializingBean, MethodInterceptor {
    private static final Logger log = LoggerFactory.getLogger(ThriftClientProxyFactoryBean.class);
    /** thrift生成的service中Iface内部类的名称 */
    private static final String iFaceInnerClassName = "Iface";
    /** thrift生成的service中Client内部类的名称 */
    private static final String clientInnerClassName = "Client";

    /** ThriftClientProxyFactoryBean产生的bean */
    private Object serviceProxy;
    /** 连接到thrift的端口号 */
    private Integer port;
    /** 连接到thrift的host */
    private String host;
    /** thrift生成的service的包名 */
    private String triftServicePackageName;
    /** 连接超时时间 */
    private Integer timeout = 3000;

    public String getTriftServicePackageName() {
        return triftServicePackageName;
    }

    public void setTriftServicePackageName(String triftServicePackageName) {
        this.triftServicePackageName = triftServicePackageName;
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public Integer getPort() {
        return port;
    }

    public void setPort(Integer port) {
        this.port = port;
    }

    public Integer getTimeout() {
        return timeout;
    }

    public void setTimeout(Integer timeout) {
        this.timeout = timeout;
    }

    @Override
    public Object getObject() throws Exception {
        return this.serviceProxy;
    }

    @Override
    public Class<?> getObjectType() {
        if(triftServicePackageName == null) {
            return null;
        }
        Class<?> objectType = null;
        try {
            objectType = org.apache.commons.lang.ClassUtils.getClass(triftServicePackageName + "$" + iFaceInnerClassName);
        } catch (ClassNotFoundException e) {
            log.error("getObjectType error", e);
        }
        return objectType;
    }

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

    @Override
    public void afterPropertiesSet() throws Exception {
        this.serviceProxy = new ProxyFactory(org.apache.commons.lang.ClassUtils.getClass(triftServicePackageName + "$" + iFaceInnerClassName), this).getProxy(ClassUtils.getDefaultClassLoader());
    }

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        TTransport transport = null;
        if(timeout.equals(new Integer(-1))) {
            transport = new TSocket(host, port);
        } else {
            transport = new TSocket(host, port, timeout);
        }
        Object result = null;
        // 协议要和服务端一致
        TProtocol protocol = new TBinaryProtocol(transport);
        try {
            Class<?> clientClass = org.apache.commons.lang.ClassUtils.getClass(triftServicePackageName + "$" + clientInnerClassName);
            transport.open();
            Method method = invocation.getMethod();
            result = MethodUtils.invokeMethod(ConstructorUtils.invokeConstructor(clientClass, protocol), 
                    method.getName(), invocation.getArguments());
        } catch (ClassNotFoundException | TTransportException
                | NoSuchMethodException | IllegalAccessException
                | InvocationTargetException | InstantiationException e) {
            if(e instanceof TTransportException) {
                log.error("open transport error. host is " + host + " port is " + port, e);
            } else {
                log.error("MethodInvocation error", e);
            }
            throw e;
        } catch (Exception e) {
            log.error("error", e);
            throw e;
            // TODO 异常的处理
        } finally {
            if (null != transport && transport.isOpen()) {
                transport.close();
            }
        }
        return result;
    }

}

好了，你现在可以像使用本地的bean一样，直接在需要的地方注入thrift的客户端了

@Autowired
@Qualifier("blogServiceThrift")
private BlogService.Iface blogServiceThrift;

核心的原理其实还是动态代理，server其实没什么说的，主要是客户端，客户端是个MethodInterceptor、FactoryBean，而且在产生bean的时候使用了动态代理，而你代理的bean可能已经是被动态代理的bean了，就是代理的代理了。

xujieyang4j

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
基于spring的可扩展性

从一个日志功能开始说起#### v1.0 : spring aop 实现日志 #### 代码示例:@Aspect@Deprecatedpublic class MysqlLogAspect { private static final Logger log = LoggerFactory.getLogger(MysqlLogAspect.class); @Around("e
复制链接

扫一扫