彻彻底底解决Spring中@EnableAsync、@Async异步调用的使用、原理及源码分析

前言：

基于Spring框架的业务系统中由于一些业务场景的要求，我们经常使用异步方法的方式来提高系统的处理性能，Spring框架为我们提供了默认的线程池，当然我们也可以对线程池进行自定义，本篇文章基于spring-context:5.1.6与大家进行探讨，建议一边看源码一遍看我的文章。

写这篇文章出于两个原因，一是前一段时间和工作的小伙伴做一个新的项目，在项目中我们自然的使用到了异步方法，而且通过之前的经验也对线程池的参数进行了自定义设置，在应用上生产之前小伙伴对Spring异步的原理以及线程池参数调优等方面与我进行了讨论，这让我又有了一次温习异步的想法， 二是本人也没有在网上搜集到比较满意的Spring异步源码解析的文章。

一、@EnabelAsync与@Asyn注解的使用

1.@EnabelAsync注解的使用。如不指定自定义异步线程池直接使用@EnableAsync即可使用，若自定义线程池可以使用下面的方法进行自定义，这种方法我认为可读性比较好，当然你可以利用@Bean("taskExecutor")申明一个Executor类型的实例，至于为什么可以生效后面的文章会进行介绍。

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor threadPool = new ThreadPoolTaskExecutor();
        threadPool.setCorePoolSize(1);
        threadPool.setMaxPoolSize(1);
        threadPool.setWaitForTasksToCompleteOnShutdown(true);
        threadPool.setAwaitTerminationSeconds(60 * 15);
        threadPool.setThreadNamePrefix("MyAsync-");
        threadPool.initialize();
        return threadPool;
    }

}

2.@Asyn注解的使用。在下方代码中在AsynMethodInvocation类中对使用@Asyn注解的异步方法进行了调用，再使用上其实很简单，只要在想要实现异步的方法上使用@Asyn注解即可，值得注意的是调用方法与目标方法不能在一个类中，在一个类中异步不会生效，这与代理模式有一定的关系。

@RestController
public class AsynMethodInvocation {
    @Autowired
    AsynMethod asynMethod;
    @RequestMapping(value = "/test")
    public void doService() {
        System.out.println("调用线程:"+Thread.currentThread().getName());
        asynMethod.doService();
    }
}

@Service
public class AsynMethod {
    @Async
    public void doService() {
        System.out.println("异步线程:" + Thread.currentThread().getName());
    }
}

3.异步方法调用的验证。我们可以看到上面的代码执行结果如下，异步方法在一个新的线程中完成。

调用线程:http-nio-8080-exec-2
2019-05-15 17:19:51.120  INFO 23368 --- [nio-8080-exec-2] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService
异步线程:ThreadPoolTaskExecutor-1

二、自动配置@EnableAsync的代理选择

@EnableAsync自动配置类关系图

1.从@EnableAsync注解入手，可以的得到@EnableAsync自动配置类之间的关系图，在@EnableAsync中除了一些属性以外（属性通过看源码的注释应该很清楚）还有一个注解@Import(AsyncConfigurationSelector.class)，项目启动时通过读取注解可以将该类引入，AsyncConfigurationSelector主要是用来选择代理方式是由JDK还是AspectJ实现代理，默认使用JDK的代理。


@Import(AsyncConfigurationSelector.class)

public @interface EnableAsync {

Classannotation()default Annotation.class;

//当AdviceModemode为PROXY时，选择代理是基于接口实现还是cglib实现

boolean proxyTargetClass()default false;

//代理方式是由JDK实现还是AspectJ实现

AdviceModemode()default AdviceMode.PROXY;

int order()default Ordered.LOWEST_PRECEDENCE;

}

2.从关系图可以看出通过抽象类与实现类的方式（敲黑板：Java基础知识不经常使用容易忘）实现了selectImports方法，决定是返回ProxyAsyncConfiguration还是AspectJAsyncConfiguration。

public abstract class AdviceModeImportSelector<A extends Annotation> implements ImportSelector {
    @Override
    public final String[] selectImports(AnnotationMetadata importingClassMetadata) {
        Class<?> annType = GenericTypeResolver.resolveTypeArgument(getClass(), AdviceModeImportSelector.class);
        Assert.state(annType != null, "Unresolvable type argument for AdviceModeImportSelector");
        //获得注解类读取其中的配置，就是上图代码中的注解的属性
        AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
        if (attributes == null) {
            throw new IllegalArgumentException(String.format(
                    "@%s is not present on importing class '%s' as expected",
                    annType.getSimpleName(), importingClassMetadata.getClassName()));
        }

        AdviceMode adviceMode = attributes.getEnum(getAdviceModeAttributeName());
        //该方法由AsyncConfigurationSelector类实现，参数为注解的AdviceModemode属性
        String[] imports = selectImports(adviceMode);
        if (imports == null) {
            throw new IllegalArgumentException("Unknown AdviceMode: " + adviceMode);
        }
        return imports;
    }
}

public class AsyncConfigurationSelector extends AdviceModeImportSelector<EnableAsync> {
    private static final String ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME =
            "org.springframework.scheduling.aspectj.AspectJAsyncConfiguration";
    @Override
    @Nullable
    public String[] selectImports(AdviceMode adviceMode) {
        switch (adviceMode) {
            case PROXY:
                return new String[] {ProxyAsyncConfiguration.class.getName()};
            case ASPECTJ:
                return new String[] {ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME};
            default:
                return null;
        }
    }
}

3.截止到现在即可实现ProxyAsyncConfiguration配置类的引入，这项工作其实是在org.springframework.context.annotation.ConfigurationClassParser#processImports中完成，从而实现ProxyAsyncConfiguration的自动配置

三、ProxyAsyncConfiguration的自动配置

在注解中定义了两种代理的方式后，有不同的自动配置类进行加载，我们这里只对JDK的代理方式进行说明，主要是理解一下整个原理与流程，有兴趣的同学也可以去了解AspectJ的具体做法，下面我们来看一下ProxyAsyncConfiguration。


ProxyAsyncConfiguration自动配置类关系图

1.ProxyAsyncConfiguration 类主要就是通过自动配置，读取注解中的相关属性，从而实例化AsyncAnnotationBeanPostProcessor，代码中的注释设置bbp对象的过程（敲黑板:Spring代码的名字其实很有讲究，通过名字就可以大概知道对象的作用，如看到BeanPostProcessor大家应该就会想到Spring中的Bean生命周期中的后置处理器，如不熟悉请自行补课，其实我也有似乎有一些忘记了）。

@Configuration
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class ProxyAsyncConfiguration extends AbstractAsyncConfiguration {
    @Bean(name = TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME)
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public AsyncAnnotationBeanPostProcessor asyncAdvisor() {
        Assert.notNull(this.enableAsync, "@EnableAsync annotation metadata was not injected");
        //整个方法就是在Spring上下文中实例化一个AsyncAnnotationBeanPostProcessor，这个Bean主要是实现方法或者类上使用@Async注解从而达到异步的效果
        AsyncAnnotationBeanPostProcessor bpp = new AsyncAnnotationBeanPostProcessor();
        //设置执行器与异常执行器
        bpp.configure(this.executor, this.exceptionHandler);
        //注解annotation是否指定了自定义的注解，如果没有指定默认@Async和 @javax.ejb.Asynchronous注解生效，若自定义需要加入到bbp中
        Class<? extends Annotation> customAsyncAnnotation = this.enableAsync.getClass("annotation");
        if (customAsyncAnnotation != AnnotationUtils.getDefaultValue(EnableAsync.class, "annotation")) {
            bpp.setAsyncAnnotationType(customAsyncAnnotation);
        }
        //注解ProxyTargetClass、setOrder属性的设置  
        bpp.setProxyTargetClass(this.enableAsync.getBoolean("proxyTargetClass"));
        bpp.setOrder(this.enableAsync.<Integer>getNumber("order"));
        return bpp;
    }
}

2.在ProxyAsyncConfiguration中我们可以看到它继承了抽象类AbstractAsyncConfiguration，它是一个基础的配置类提供了异步的一些公共功能，可以通过实现AsyncConfigurer接口或者继承AsyncConfigurerSupport类来实现自定义异步线程池执行器与异常执行器，如果自定义了则会设置到bpp对象中，若没有自定义Spring会找实现TaskExecutor接口或bean的名字为taskExecutor的执行器。

@Configuration
public abstract class AbstractAsyncConfiguration implements ImportAware {
    @Override
    public void setImportMetadata(AnnotationMetadata importMetadata) {
        //获得@EnableAsync注解及其属性
        this.enableAsync = AnnotationAttributes.fromMap(
                importMetadata.getAnnotationAttributes(EnableAsync.class.getName(), false));
        if (this.enableAsync == null) {
            throw new IllegalArgumentException(
                    "@EnableAsync is not present on importing class " + importMetadata.getClassName());
        }
    }
    @Autowired(required = false)
    void setConfigurers(Collection<AsyncConfigurer> configurers) {
        if (CollectionUtils.isEmpty(configurers)) {
            return;
        }
        if (configurers.size() > 1) {
            throw new IllegalStateException("Only one AsyncConfigurer may exist");
        }
        AsyncConfigurer configurer = configurers.iterator().next();
        //设置自定义执行器与异常执行器，若没有自定义则不会执行setConfigurers方法
        this.executor = configurer::getAsyncExecutor;
        this.exceptionHandler = configurer::getAsyncUncaughtExceptionHandler;
    }
}

四、AsyncAnnotationBeanPostProcessor 初始化

在第二节我们主要讲解了如何初始化AsyncAnnotationBeanPostProcessor对象，但是大家可能对这个对象是干什么的在什么时候使用存在一定的疑虑，这节我们就重点来说一下Spring是如何生成代理类，首先我们看一下AsyncAnnotationBeanPostProcessor类的关系图，看起来的确很可怕（从前的我看到这种图几乎也会放弃查看源码的奢望），但是我们我们不用过多的担心，主要看下一下蓝色箭头的类。


AsyncAnnotationBeanPostProcessor类关系图

1.，由于AsyncAnnotationBeanPostProcessor类在父类AbstractBeanFactoryAwareAdvisingPostProcessor中实现了BeanFactoryAware接口，所以在初始化后，会执行setBeanFactory方法，在该方法中，实例化了AsyncAnnotationAdvisor。

public class AsyncAnnotationBeanPostProcessor extends AbstractBeanFactoryAwareAdvisingPostProcessor {
    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        super.setBeanFactory(beanFactory);
        //实例化AsyncAnnotationAdvisor对象，初始化异步切面，该对象通过注解实现AOP的通知，使其在使用注解时能够触发异步方法的执行
        AsyncAnnotationAdvisor advisor = new AsyncAnnotationAdvisor(this.executor, this.exceptionHandler);
        if (this.asyncAnnotationType != null) {
            advisor.setAsyncAnnotationType(this.asyncAnnotationType);
        }
        advisor.setBeanFactory(beanFactory);
        this.advisor = advisor;
    }
}

2.AbstractAdvisingBeanPostProcessor类中实现了BeanPostProcessor方法，在AsyncAnnotationBeanPostProcessor类初始化完后，会执行postProcessAfterInitialization方法，在该方法中会生成目标类的代理类，从而实现在调用该方法时能后达到异步的效果。

public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSupport implements BeanPostProcessor {
    private final Map<Class<?>, Boolean> eligibleBeans = new ConcurrentHashMap<>(256);

    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (this.advisor == null || bean instanceof AopInfrastructureBean) {
            // Ignore AOP infrastructure such as scoped proxies.
            return bean;
        }
        //第一次进入到这个方法时bean是注解了异步的那个原始类，因为那时候还没有生成代理类bean instanceof Advised为false，所以该端代码不会执行。还有可能进入到这个方法是生成代理类后实例化CglibAopProxy时会进入到这个类，bean为该类的代理类，这不做过多的介绍，感兴趣的可以去查看一下Spring Aop的源码部分
        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;
            }
        }
        //由于在初始化AsyncAnnotationBeanPostProcessor，该方法并没有调用本类中的，而是调用了下方类的isEligible方法，主要判断改类是否为原始类，而不是该类的代理类，如果是原始类则进入方法。
        if (isEligible(bean, beanName)) {
            //创建目标类的代理工厂，在AbstractBeanFactoryAwareAdvisingPostProcessor中重写了该方法
            ProxyFactory proxyFactory = prepareProxyFactory(bean, beanName);
            //判断代理使用的是JDK代理还是使用的CGLIB代理，默认false，使用JDK创建代理
            if (!proxyFactory.isProxyTargetClass()) {
                //检查bean是接口还是类，如果是接口默认使用JDK创建代理，如果为类则修改为使用CGLIB来创建代理
                evaluateProxyInterfaces(bean.getClass(), proxyFactory);
            }
            //代理工厂应用自定义的Advisor（AsynAnnotationAdvisor）
            proxyFactory.addAdvisor(this.advisor);
            customizeProxyFactory(proxyFactory);
            //返回该类的代理类
            return proxyFactory.getProxy(getProxyClassLoader());
        }
        // No proxy needed.
        return bean;
    }
}

public abstract class AbstractBeanFactoryAwareAdvisingPostProcessor extends AbstractAdvisingBeanPostProcessor implements BeanFactoryAware {
@Override
    protected boolean isEligible(Object bean, String beanName) {
        return (!AutoProxyUtils.isOriginalInstance(beanName, bean.getClass()) &&
                super.isEligible(bean, beanName));
    }
}

3.在这里简单的介绍一下是proxyFactory是如何生成代理的，创建Aop代理的过程是在DefaultAopProxyFactory中完成，根据Config不同的属性条件，来决定不同类型的AOP代理（JDK动态代理、CGLIB代理），然后根据创建的代理getProxy方法生成代理类，如CglibAopProxy#getProxy。

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                return new JdkDynamicAopProxy(config);
            }
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }
}

总结：到这里我们应该对@EnableAsync自动配置有一个比较清晰的认识，回顾一下这部分的内容主要从两方面来入手。首先，@EnableAsync注解-->配置选择-->ProxyAsyncConfiguration自动配置-->初始化AsyncAnnotationBeanPostProcessor对象。其次，AsyncAnnotationBeanPostProcessor自定义Advisor-->AbstractAdvisingBeanPostProcessor实现代理类的生成。

五、@Asyn注解实现异步的过程

在之前的部分我们一笔带过了AsyncAnnotationAdvisor对象的初始化是因为这部分与Spring Aop有很大关系，所以这没有做重点的介绍（其实这部分我也没有去关注），但是它的类的关系图中我们可以注意到AsyncAnnotationAdvisor类中有一个buildAdvice方法，生成了AnnotationAsyncExecutionInterceptor对象，它的父类AsyncExecutionInterceptor重写了AsyncExecutionInterceptor接口的invoke方法，通过委托实现@Async异步方法的调用。


AsyncAnnotationAdvisor类关系图

当我们使用@Async注解在方法或者类上面时，在进行方法调用时，代理类会进行拦截，如CglibAopProxy.DynamicAdvisedInterceptor的intercept方法，在这里我们不会仔细的去分析这个方法的源码，大家只要知道在该方法中retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed()这行代码的proceed方法时会被
AsyncExecutionInterceptor拦截器进行拦截，在该拦截器中完成了异步方法的调用。

org.springframework.aop.interceptor.AsyncExecutionInterceptor#invoke
public Object invoke(final MethodInvocation invocation) throws Throwable {
        //该方法的参数为异步要调用的方法
        Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
        //获得方法的详细信息，如参数、返回值等
        Method specificMethod = ClassUtils.getMostSpecificMethod(invocation.getMethod(), targetClass);
        final Method userDeclaredMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
        //确定异步执行器，在spring上下文中找到实现TaskExecutor的实例
        AsyncTaskExecutor executor = determineAsyncExecutor(userDeclaredMethod);
        if (executor == null) {
            throw new IllegalStateException(
                    "No executor specified and no default executor set on AsyncExecutionInterceptor either");
        }
        //建立一个线程，用于执行目标异步方法，该段代码只是线程的生命，而没有直接的调用
        Callable<Object> task = () -> {
            try {
                Object result = invocation.proceed();
                if (result instanceof Future) {
                    return ((Future<?>) result).get();
                }
            }
            catch (ExecutionException ex) {
                handleError(ex.getCause(), userDeclaredMethod, invocation.getArguments());
            }
            catch (Throwable ex) {
                handleError(ex, userDeclaredMethod, invocation.getArguments());
            }
            return null;
        };
        //结合目标方法、异步执行器对目标方法进行调用
        return doSubmit(task, executor, invocation.getMethod().getReturnType());
    }

在上述的代码中determineAsyncExecutor方法用于确定异步执行器，在执行defaultExecutor.get()方法时，最终会执行AsyncExecutionAspectSupport的getDefaultExecutor方法，该方法会查找实现TaskExecutor接口的实例作为执行器，在该文中没有特别实现TaskExecutor接口，故默认的执行器为ThreadPoolTaskExecutor。

org.springframework.aop.interceptor.AsyncExecutionAspectSupport#determineAsyncExecutor
protected AsyncTaskExecutor determineAsyncExecutor(Method method) {
        //executors的类型为Map<Method, AsyncTaskExecutor>，用于缓存方法的执行器，第一次加载时executor为null，调用过一次后对应关系缓存在Map中
        AsyncTaskExecutor executor = this.executors.get(method);
        if (executor == null) {
            Executor targetExecutor;
            String qualifier = getExecutorQualifier(method);
            if (StringUtils.hasLength(qualifier)) {
                targetExecutor = findQualifiedExecutor(this.beanFactory, qualifier);
            }
            else {
                //指定执行器
                targetExecutor = this.defaultExecutor.get();
            }
            if (targetExecutor == null) {
                return null;
            }
            executor = (targetExecutor instanceof AsyncListenableTaskExecutor ?
                    (AsyncListenableTaskExecutor) targetExecutor : new TaskExecutorAdapter(targetExecutor));
            this.executors.put(method, executor);
        }
        return executor;
    }

在invoke方法的最后一行是submit方法，最后的执行要落在线程池的执行，spring线程池的实现这里不做过多的介绍，大家只要知道在这里利用其他线程实现了异步方法的调用即可。

org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor#submit
public <T> Future<T> submit(Callable<T> task) {
        ExecutorService executor = getThreadPoolExecutor();
        try {
            return executor.submit(task);
        }
        catch (RejectedExecutionException ex) {
            throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
        }
    }

总结：在上一部分我们了解了@EnableAsync注解，这一部分我们重点对@Asyn注解在调用时是如何实现异步的进行了分析，主要是两个方面。一是在方法调用是对其进行拦截，然后指定方法执行的执行器；二是在方法的调用过程中应用了线程池，由线程池执行task从而达到异步的作用。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,590评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 86,808评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,151评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,779评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,773评论 5赞 367
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,656评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,022评论 3赞 398
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,678评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 41,038评论 1赞 299
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,659评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,756评论 1赞 330
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,411评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,005评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,973评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,203评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,053评论 2赞 350
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,495评论 2赞 343