怎么打开
点击联系发帖人
时间：2018-02-18 02:16
Spring的事件和监听器-同步与异步 - 菜鸟之家 - CSDN博客
Spring的事件和监听器-同步与异步
Java Develop
Application下抽象子类ApplicationContextEvent的下面有4个已经实现好的事件&
ContextClosedEvent（容器关闭时）&ContextRefreshedEvent（容器刷新是）&ContextStartedEvent（容器启动时候）&ContextStoppedEvent（容器停止的时候）&
同样，这四个事件都继承了ApplicationEvent，如果我们想自定义事件，也可以通过继承ApplicationEvent来实现
1: 首先新建StartWorkflowEvent.java,&继承ApplicationEvent抽象类
public class StartWorkflowEvent extends ApplicationEvent {
//存放构造器送入的值
//构造器参数可以随意设置，这里为了方便调试，设置为字符串
public StartWorkflowEvent (String msg) {
super(msg);
//自定义一个方法，这个方法也可以随意写，这里也是测试用
public void myevent(){
System.out.println(&********My event**************&);
System.out.println(msg);
System.out.println(&*******************************&);
2:新建一个监听器StartWorkflowListener.java, 实现ApplicationListener&StartWorkflowEvent&
* 发起流程事件监听
@Component(&startWorkflowListener&)
public class StartWorkflowListener implements ApplicationListener&StartWorkflowEvent& {
@Autowired
private OaWorkflowHepler oaWorkflowH
//@Async注解异步调用时使用, 异步调用时, 需要在xml配置文件中添加 &task:annotation-driven /&
public void onApplicationEvent(StartWorkflowEvent event) {
oaWorkflowHepler.start(event.getMsg());
3:创建一个事件发布类EventPublisher.java
* 发布事件
@Component(&eventPublisher&)
public class EventPublisher {
@Autowired
private ApplicationContext applicationC
* 发布事件
* @param event
public void publishEvent(ApplicationEvent event) {
applicationContext.publishEvent(event);
4.相关的配置：
&task:annotation-driven /&配置：
executor：指定一个缺省的executor给@Async使用。
&task:annotation-driven executor=&asyncExecutor& /&
&task:executor /&配置参数：
id：当配置多个executor时，被@Async(&id&)指定使用；也被作为线程名的前缀。
pool-size：
core size：最小的线程数，缺省：1
max size：最大的线程数，缺省：Integer.MAX_VALUE
queue-capacity：当最小的线程数已经被占用满后，新的任务会被放进queue里面，当这个 queue的capacity也被占满之后，pool里面会创建新线程处理这个任务，直到总线程数达到了max size，这时系统会拒绝这个任务并抛出TaskRejectedException异常（缺省配置的情况下，可以通过rejection-policy 来决定如何处理这种情况）。缺省值为：Integer.MAX_VALUE
keep-alive：超过core size的那些线程，任务完成后，再经过这个时长（秒）会被结束掉
rejection-policy：当pool已经达到max size的时候，如何处理新任务
ABORT（缺省）：抛出TaskRejectedException异常，然后不执行
DISCARD：不执行，也不抛出异常
DISCARD_OLDEST：丢弃queue中最旧的那个任务
18CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行
我的热门文章
即使是一小步也想与你分享SpringBoot之异步事件 - flappy tortoise - ITeye博客
博客分类：
为什么要使用异步事件呢？就是为了快速响应前端的请求，让那些耗时较长的任务在后台独立执行，比如大量数据的导出，邮件发送等等。使用异步事件，可以很好地提高用户的体验。那么异步事件该如何使用呢，分为如下几步：
1.定义事件
定义一个事件类，继承ApplicationEvent；
import org.springframework.context.ApplicationE
import lombok.G
import lombok.S
import lombok.ToS
* 自定义spring事件基类，所有的事件继承该基类
public class CommonEvent extends ApplicationEvent {
private static final long serialVersionUID = -9348221L;
/** 事件的内容（具有实际业务意义的内容） */
private String eventC
public CommonEvent(Object source) {
super(source);
public CommonEvent(Object source, String eventContent) {
super(source);
this.eventContent = eventC
* spring容器事件，封装所有的运行时异常事件
public class BatchSendExMsgEmailEvent extends CommonEvent {
public BatchSendExMsgEmailEvent(Object source) {
super(source);
private static final long serialVersionUID = -4523969L;
2.发布事件
发布一个事件，使用ApplicationContext.publish(event)；
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
ex.printStackTrace(pw);
// 发布运行时异常事件
BatchSendExMsgEmailEvent event = new BatchSendExMsgEmailEvent(this);
event.setEventContent(sw.toString());
applicationContext.publishEvent(event);
3.监听事件并且进行处理
import org.slf4j.L
import org.slf4j.LoggerF
import org.springframework.beans.factory.annotation.A
import org.springframework.beans.factory.annotation.V
import org.springframework.context.event.EventL
import org.springframework.scheduling.annotation.A
import org.
@Component
public class ContainerEventListener {
private static final Logger logger = LoggerFactory.getLogger(ContainerEventListener.class);
@Autowired
private EmailService emailS
@Value("${email_receivers}")
@Value("${email_subject}")
private String emailS
／／@Async注解指定该事件异步执行，必须配合启动类的@EnableAsync
@EventListener
public void handleBatchSendExMsgEmailEvent(BatchSendExMsgEmailEvent event) {
("监听到了运行时异常事件");
emailService.batchSendSimpleMail(receivers, emailSubject, "具体的异常信息为: " + event.getEventContent());
wuhoujian322
浏览: 21579 次
来自: 杭州
那么完美的实现方式应该是怎样的呢？
这样防止不了反射侵入
Redis我也是刚开始学习，它是一个内存数据库，不像传统的关系 ...
Redis不熟悉,主要的应用场景是什么?
大家遇到的问题也可以发出来，共同研究研究，一起进步。在Spring中使用异步事件实现同步事务
& & & &&& & &
结合Scala+Spring，我们将采取一个很简单的场景：下订单，然后发送一封电子邮件。
编制一个服务：
class OrderService @Autowired() (orderDao:
OrderDao, mailNotifier: OrderMailNotifier) {
@Transactional
def placeOrder(order: Order) {
orderDao save order //保存订单
&&& &&&&mailNotifier sendMail order //发送邮件
上面代码是在保存订单和发送邮件两个同步执行，发送邮件需要连接邮件服务器，比较耗时，拖延了整个性能，我们采取异步发送电子邮件，利用Spring内置的自定义事件，与JMS或其他生产者 - 消费者类似。
case class OrderPlacedEvent(order: Order)
extends ApplicationEvent
class OrderService @Autowired() (orderDao:
OrderDao, eventPublisher: ApplicationEventPublisher) {
@Transactional
def placeOrder(order: Order) {
orderDao save order
eventPublisher publishEvent OrderPlacedEvent(order)
区别是继承了ApplicationEvent 之前是直接用&OrderMailNotifier&直接发送，而现在我们使用&发送发邮件事件了。
事件监听者代码如下：
class OrderMailNotifier extends
ApplicationListener[OrderPlacedEvent] {
def onApplicationEvent(event: OrderPlacedEvent) {
//sending e-mail...
在监听者方法中真正实现邮件发送。
但是Spring的ApplicationEvents是同步事件，意味着我们并没有真正实现异步，程序还会在这里堵塞，如果希望异步，我们需要重新定义一个ApplicationEventMulticaster，实现类型SimpleApplicationEventMulticaster和TaskExecutor：
def applicationEventMulticaster() = {
val multicaster = new SimpleApplicationEventMulticaster()
multicaster.setTaskExecutor(taskExecutor())
multicaster
def taskExecutor() = {
val pool = new ThreadPoolTaskExecutor()
pool.setMaxPoolSize(10)
pool.setCorePoolSize(10)
pool.setThreadNamePrefix(&Spring-Async-&)
Spring通过使用TaskExecutor已经支持广播事件了，对onApplicationEvent()&标注&
def onApplicationEvent(event: OrderPlacedEvent) {
如果你希望使用@Async，可以编制自己的异步执行器：
@Configuration
@EnableAsync
class ThreadingConfig extends
AsyncConfigurer {
def getAsyncExecutor = taskExecutor()
def taskExecutor() = {
val pool = new ThreadPoolTaskExecutor()
pool.setMaxPoolSize(10)
pool.setCorePoolSize(10)
pool.setThreadNamePrefix(&Spring-Async-&)
@ EnableAsync是足够了。，默认情况下，Spring使用SimpleAsyncTaskExecutor类创建新的线程。
以上所有设置暴露一个真正的问题。现在，我们虽然使用其他线程发送一个异步消息处理。不幸的是，我们引入竞争条件。
存储order到数据库
发送一个包装order的消息
异步线程获得OrderPlacedEvent并开始处理。现在的问题是，它发生（3）之后，还是（4）之前或者（4）之后？这有一个很大的区别！在前者的情况下，交易也尚未提交订单所以不存在于数据库中。另一方面，延迟加载可能已经在工作，致使订单对象仍然然绑定在 PersistenceContext（缺省我们使用JPA）。
解决办法是使用&.，可以注册很多监听者&，它对于事务的提交或回滚都有事件发送。
@Transactional
def placeOrder(order: Order) {
orderDao save order
afterCommit {
eventPublisher publishEvent OrderPlacedEvent(order)
private def afterCommit[T](fun: =& T) {
TransactionSynchronizationManager.registerSynchronization(new
TransactionSynchronizationAdapter {
override def afterCommit() {
&&&&&&&&&&&
当前事务提交后 afterCommit（）接受调用，可以安全地调用registerSynchronization（）多次 - 监听器存储在Set并且本地保存到当前事务中，事务提交后消失。
我们将afterCommit方法单独抽象成一个类，分离关注。
TransactionAwareApplicationEventPublisher(delegate: ApplicationEventPublisher)
extends ApplicationEventPublisher {
override def publishEvent(event: ApplicationEvent) {
if (TransactionSynchronizationManager.isActualTransactionActive) {
&&&&&&&&&&&
TransactionSynchronizationManager.registerSynchronization(
&&&&&&&&&&&&&&& new
TransactionSynchronizationAdapter {
&&&&&&&&&&&&&&&&&&& override def afterCommit()
&&&&&&&&&&&&&&&&&&&&&&& delegate publishEvent
&&&&&&&&&&&&&&&&&&& }
&& &&&&&&&&&&&&&})
&&&&&&&&&&&
delegate publishEvent event
TransactionAwareApplicationEventPublisher是实现Spring的ApplicationEventPublisher。
我们要将这个新的实现告诉Spring替换掉旧的，用@Primary：
val applicationContext: ApplicationContext
transactionAwareApplicationEventPublisher() =
new TransactionAwareApplicationEventPublisher(applicationContext)
再看看原来的订单服务：
class OrderService @Autowired() (orderDao:
OrderDao, eventPublisher: ApplicationEventPublisher) {
@Transactional
def placeOrder(order: Order) {
orderDao save order
eventPublisher publishEvent OrderPlacedEvent(order)
注意这里ApplicationEventPublisher已经是我们自己实现的TransactionAwareApplicationEventPublisher，将被自动注入这个服务。
最后，要在真正订单保存的业务代码上放置事务：
def placeOrder(order: Order) {
storeOrder(order)
eventPublisher publishEvent OrderPlacedEvent(order)
@Transactional
def storeOrder(order: Order) = orderDao
save order
当然这没有根本解决问题，如果placeOrder有一个更大的事务怎么办？
| 网站地图 | 设为首页}
Spring的事件和监听器-同步与异步
Java Develop
Application下抽象子类ApplicationContextEvent的下面有4个已经实现好的事件&
ContextClosedEvent（容器关闭时）&ContextRefreshedEvent（容器刷新是）&ContextStartedEvent（容器启动时候）&ContextStoppedEvent（容器停止的时候）&
同样，这四个事件都继承了ApplicationEvent，如果我们想自定义事件，也可以通过继承ApplicationEvent来实现
1: 首先新建StartWorkflowEvent.java,&继承ApplicationEvent抽象类
public class StartWorkflowEvent extends ApplicationEvent {
//存放构造器送入的值
//构造器参数可以随意设置，这里为了方便调试，设置为字符串
public StartWorkflowEvent (String msg) {
super(msg);
//自定义一个方法，这个方法也可以随意写，这里也是测试用
public void myevent(){
System.out.println(&********My event**************&);
System.out.println(msg);
System.out.println(&*******************************&);
2:新建一个监听器StartWorkflowListener.java, 实现ApplicationListener&StartWorkflowEvent&
* 发起流程事件监听
@Component(&startWorkflowListener&)
public class StartWorkflowListener implements ApplicationListener&StartWorkflowEvent& {
@Autowired
private OaWorkflowHepler oaWorkflowH
//@Async注解异步调用时使用, 异步调用时, 需要在xml配置文件中添加 &task:annotation-driven /&
public void onApplicationEvent(StartWorkflowEvent event) {
oaWorkflowHepler.start(event.getMsg());
3:创建一个事件发布类EventPublisher.java
* 发布事件
@Component(&eventPublisher&)
public class EventPublisher {
@Autowired
private ApplicationContext applicationC
* 发布事件
* @param event
public void publishEvent(ApplicationEvent event) {
applicationContext.publishEvent(event);
4.相关的配置：
&task:annotation-driven /&配置：
executor：指定一个缺省的executor给@Async使用。
&task:annotation-driven executor=&asyncExecutor& /&
&task:executor /&配置参数：
id：当配置多个executor时，被@Async(&id&)指定使用；也被作为线程名的前缀。
pool-size：
core size：最小的线程数，缺省：1
max size：最大的线程数，缺省：Integer.MAX_VALUE
queue-capacity：当最小的线程数已经被占用满后，新的任务会被放进queue里面，当这个 queue的capacity也被占满之后，pool里面会创建新线程处理这个任务，直到总线程数达到了max size，这时系统会拒绝这个任务并抛出TaskRejectedException异常（缺省配置的情况下，可以通过rejection-policy 来决定如何处理这种情况）。缺省值为：Integer.MAX_VALUE
keep-alive：超过core size的那些线程，任务完成后，再经过这个时长（秒）会被结束掉
rejection-policy：当pool已经达到max size的时候，如何处理新任务
ABORT（缺省）：抛出TaskRejectedException异常，然后不执行
DISCARD：不执行，也不抛出异常
DISCARD_OLDEST：丢弃queue中最旧的那个任务
18CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行
我的热门文章
即使是一小步也想与你分享SpringBoot之异步事件 - flappy tortoise - ITeye博客
博客分类：
为什么要使用异步事件呢？就是为了快速响应前端的请求，让那些耗时较长的任务在后台独立执行，比如大量数据的导出，邮件发送等等。使用异步事件，可以很好地提高用户的体验。那么异步事件该如何使用呢，分为如下几步：
1.定义事件
定义一个事件类，继承ApplicationEvent；
import org.springframework.context.ApplicationE
import lombok.G
import lombok.S
import lombok.ToS
* 自定义spring事件基类，所有的事件继承该基类
public class CommonEvent extends ApplicationEvent {
private static final long serialVersionUID = -9348221L;
/** 事件的内容（具有实际业务意义的内容） */
private String eventC
public CommonEvent(Object source) {
super(source);
public CommonEvent(Object source, String eventContent) {
super(source);
this.eventContent = eventC
* spring容器事件，封装所有的运行时异常事件
public class BatchSendExMsgEmailEvent extends CommonEvent {
public BatchSendExMsgEmailEvent(Object source) {
super(source);
private static final long serialVersionUID = -4523969L;
2.发布事件
发布一个事件，使用ApplicationContext.publish(event)；
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
ex.printStackTrace(pw);
// 发布运行时异常事件
BatchSendExMsgEmailEvent event = new BatchSendExMsgEmailEvent(this);
event.setEventContent(sw.toString());
applicationContext.publishEvent(event);
3.监听事件并且进行处理
import org.slf4j.L
import org.slf4j.LoggerF
import org.springframework.beans.factory.annotation.A
import org.springframework.beans.factory.annotation.V
import org.springframework.context.event.EventL
import org.springframework.scheduling.annotation.A
import org.
@Component
public class ContainerEventListener {
private static final Logger logger = LoggerFactory.getLogger(ContainerEventListener.class);
@Autowired
private EmailService emailS
@Value("${email_receivers}")
@Value("${email_subject}")
private String emailS
／／@Async注解指定该事件异步执行，必须配合启动类的@EnableAsync
@EventListener
public void handleBatchSendExMsgEmailEvent(BatchSendExMsgEmailEvent event) {
("监听到了运行时异常事件");
emailService.batchSendSimpleMail(receivers, emailSubject, "具体的异常信息为: " + event.getEventContent());
wuhoujian322
浏览: 21579 次
来自: 杭州
那么完美的实现方式应该是怎样的呢？
这样防止不了反射侵入
Redis我也是刚开始学习，它是一个内存数据库，不像传统的关系 ...
Redis不熟悉,主要的应用场景是什么?
大家遇到的问题也可以发出来，共同研究研究，一起进步。在Spring中使用异步事件实现同步事务
& & & &&& & &
结合Scala+Spring，我们将采取一个很简单的场景：下订单，然后发送一封电子邮件。
编制一个服务：
class OrderService @Autowired() (orderDao:
OrderDao, mailNotifier: OrderMailNotifier) {
@Transactional
def placeOrder(order: Order) {
orderDao save order //保存订单
&&& &&&&mailNotifier sendMail order //发送邮件
上面代码是在保存订单和发送邮件两个同步执行，发送邮件需要连接邮件服务器，比较耗时，拖延了整个性能，我们采取异步发送电子邮件，利用Spring内置的自定义事件，与JMS或其他生产者 - 消费者类似。
case class OrderPlacedEvent(order: Order)
extends ApplicationEvent
class OrderService @Autowired() (orderDao:
OrderDao, eventPublisher: ApplicationEventPublisher) {
@Transactional
def placeOrder(order: Order) {
orderDao save order
eventPublisher publishEvent OrderPlacedEvent(order)
区别是继承了ApplicationEvent 之前是直接用&OrderMailNotifier&直接发送，而现在我们使用&发送发邮件事件了。
事件监听者代码如下：
class OrderMailNotifier extends
ApplicationListener[OrderPlacedEvent] {
def onApplicationEvent(event: OrderPlacedEvent) {
//sending e-mail...
在监听者方法中真正实现邮件发送。
但是Spring的ApplicationEvents是同步事件，意味着我们并没有真正实现异步，程序还会在这里堵塞，如果希望异步，我们需要重新定义一个ApplicationEventMulticaster，实现类型SimpleApplicationEventMulticaster和TaskExecutor：
def applicationEventMulticaster() = {
val multicaster = new SimpleApplicationEventMulticaster()
multicaster.setTaskExecutor(taskExecutor())
multicaster
def taskExecutor() = {
val pool = new ThreadPoolTaskExecutor()
pool.setMaxPoolSize(10)
pool.setCorePoolSize(10)
pool.setThreadNamePrefix(&Spring-Async-&)
Spring通过使用TaskExecutor已经支持广播事件了，对onApplicationEvent()&标注&
def onApplicationEvent(event: OrderPlacedEvent) {
如果你希望使用@Async，可以编制自己的异步执行器：
@Configuration
@EnableAsync
class ThreadingConfig extends
AsyncConfigurer {
def getAsyncExecutor = taskExecutor()
def taskExecutor() = {
val pool = new ThreadPoolTaskExecutor()
pool.setMaxPoolSize(10)
pool.setCorePoolSize(10)
pool.setThreadNamePrefix(&Spring-Async-&)
@ EnableAsync是足够了。，默认情况下，Spring使用SimpleAsyncTaskExecutor类创建新的线程。
以上所有设置暴露一个真正的问题。现在，我们虽然使用其他线程发送一个异步消息处理。不幸的是，我们引入竞争条件。
存储order到数据库
发送一个包装order的消息
异步线程获得OrderPlacedEvent并开始处理。现在的问题是，它发生（3）之后，还是（4）之前或者（4）之后？这有一个很大的区别！在前者的情况下，交易也尚未提交订单所以不存在于数据库中。另一方面，延迟加载可能已经在工作，致使订单对象仍然然绑定在 PersistenceContext（缺省我们使用JPA）。
解决办法是使用&.，可以注册很多监听者&，它对于事务的提交或回滚都有事件发送。
@Transactional
def placeOrder(order: Order) {
orderDao save order
afterCommit {
eventPublisher publishEvent OrderPlacedEvent(order)
private def afterCommit[T](fun: =& T) {
TransactionSynchronizationManager.registerSynchronization(new
TransactionSynchronizationAdapter {
override def afterCommit() {
&&&&&&&&&&&
当前事务提交后 afterCommit（）接受调用，可以安全地调用registerSynchronization（）多次 - 监听器存储在Set并且本地保存到当前事务中，事务提交后消失。
我们将afterCommit方法单独抽象成一个类，分离关注。
TransactionAwareApplicationEventPublisher(delegate: ApplicationEventPublisher)
extends ApplicationEventPublisher {
override def publishEvent(event: ApplicationEvent) {
if (TransactionSynchronizationManager.isActualTransactionActive) {
&&&&&&&&&&&
TransactionSynchronizationManager.registerSynchronization(
&&&&&&&&&&&&&&& new
TransactionSynchronizationAdapter {
&&&&&&&&&&&&&&&&&&& override def afterCommit()
&&&&&&&&&&&&&&&&&&&&&&& delegate publishEvent
&&&&&&&&&&&&&&&&&&& }
&& &&&&&&&&&&&&&})
&&&&&&&&&&&
delegate publishEvent event
TransactionAwareApplicationEventPublisher是实现Spring的ApplicationEventPublisher。
我们要将这个新的实现告诉Spring替换掉旧的，用@Primary：
val applicationContext: ApplicationContext
transactionAwareApplicationEventPublisher() =
new TransactionAwareApplicationEventPublisher(applicationContext)
再看看原来的订单服务：
class OrderService @Autowired() (orderDao:
OrderDao, eventPublisher: ApplicationEventPublisher) {
@Transactional
def placeOrder(order: Order) {
orderDao save order
eventPublisher publishEvent OrderPlacedEvent(order)
注意这里ApplicationEventPublisher已经是我们自己实现的TransactionAwareApplicationEventPublisher，将被自动注入这个服务。
最后，要在真正订单保存的业务代码上放置事务：
def placeOrder(order: Order) {
storeOrder(order)
eventPublisher publishEvent OrderPlacedEvent(order)
@Transactional
def storeOrder(order: Order) = orderDao
save order
当然这没有根本解决问题，如果placeOrder有一个更大的事务怎么办？
| 网站地图 | 设为首页}
我要回帖
更多推荐
- ·龙腾世纪的推荐配置对处理器有玩大型网游什么配置的电脑要求？
- ·目前考虑购买复古木质做音箱用什么木材最好，ALATS和马歇尔哪个品牌更适合中国家庭？
- ·FC24这是什么意思怎么是两个控制器故障代码如何还原？
- ·那种直播间字幕怎么弄烟花改字的视频怎么弄？
- ·立创广场商城最近有什么大活动吗？
- ·OPPO公司是不是放弃加拿大永久居留权OPPOR9了系统这么久
- ·4.22m流量移动物联卡2m一个月多少钱钱
- ·侄女检测得了轮状病毒能吃什么食物，请问能给药吃吗
- ·次是被QJ了，我该我相信她下集吗
- ·直播间字幕软件这个字幕是什么软件打上去的呢？谢谢
- ·为啥手机微信视频时对方听不到我的声音收藏的视频播放时没有声音
- ·QQ会下架吗？
- ·我叫皇太极 游戏黄吗万岁爷要wifi吗
- ·魅蓝e2最新系统无法完成系统更新是怎么回事，下载完升级包，点击更新，就相当于重启。
- ·请问可否告诉下密码呢？非常感谢您的回复
- ·Python为什么这么火，都进高中生《高中生信息技术课本
- ·微信红包情人节微信可以发口令红包吗多少
- ·U盘插进u盘强拔插电脑没反应应。
- ·U盘插进电脑w7电脑耳机插孔没反应。
- ·现在的qq安全中心真lj，我改个密码都改不了，非得我用忘记密码用手机发短信改
- ·怎么打开
- ·大型游戏1070显存问题题，求大神
- ·二代妖精2hd1080p
- ·我有一个1649780298卖qq号平台哪个最好可以卖多少钱
- ·qq的这种泡泡宝盒会员账号分享怎么设置出来啊，不是会员也能弄到，怎么弄的啊
- ·qq的这种泡泡怎么设置出来啊，不是qq会员上线铃声设置也能弄到，怎么弄的啊
- ·电脑开机一半蓝屏重启，WindowsXPfm2018对徽标刷不出来出来是硬盘有“咔咔”声然后蓝屏重启
- ·手机怎么看 电脑内屏碎了外屏没坏 外屏 坏了啊？
- ·怎样可以秒杀妻子成为一群人性奴
- ·怎么使用这种联通充值卡怎么使用充Q币
- ·器的原因吗，有国外大神用纸做武器知道吗
- ·《反垄断法》对微软英特尔和微软什么关系们有影响吗
- ·绝地求生刺激战场下载流量包怎么用
- ·手老人机开不了机怎么办办？
- ·重庆您好搬家有限公司。看了您在百度知道上的一个解答，甚是信服，在这里想和您请教一个问题，不知可否。
