异步消息处理机制
Android异步消息处理机制完全解析，带你从源码的角度彻底理解
之前也是由于周末通宵看TI3比赛，一直没找到时间写博客，导致已经有好久没更新了。惭愧！后面还会恢复进度，尽量保证每周都写吧。这里也是先恭喜一下来自瑞典的Alliance 战队夺得了TI3的冠军，希望明年中国战队能够虎起！
开始进入正题，我们都知道，Android UI是线程不安全的，如果在子线程中尝试进行UI操作，程序就有可能会崩溃。相信大家在日常的工作当中都会经常遇到这个问题，解决的方案应该也是早已烂熟于心，即创建一个Message对象，然后借助Handler发送出去，之后在Handler的handleMessage()方法中获得刚才发送的Message对象，然后在这里进行UI操作就不会再出现崩溃了。
这种处理方式被称为异步消息处理线程，虽然我相信大家都会用，可是你知道它背后的原理是什么样的吗？今天我们就来一起深入探究一下Handler和Message背后的秘密。
首先来看一下如何创建Handler对象。你可能会觉得挺纳闷的，创建Handler有什么好看的呢，直接new一下不就行了？确实，不过即使只是简单new一下，还是有不少地方需要注意的，我们尝试在程序中创建两个Handler对象，一个在主线程中创建，一个在子线程中创建，代码如下所示：
[java]view plaincopy
1.public class MainActivity extends Activity {
2.
3.private Handler handler1;
4.
5.private Handler handler2;
6.
7.@Override
8.protected void onCreate(Bundle savedInstanceState) {
9.super.onCreate(savedInstanceState);
10. setContentView(https://www.360docs.net/doc/ca18006353.html,yout.activity_main);
11. handler1 = new Handler();
12.new Thread(new Runnable() {
13.@Override
14.public void run() {
15. handler2 = new Handler();
16. }
17. }).start();
18. }
19.
20.}
如果现在运行一下程序，你会发现，在子线程中创建的Handler是会导致程序崩溃的，提示的错误信息为 Can't create handler inside thread that has not called Looper.prepare() 。说是不能在没有调用Looper.prepare() 的线程中创建Handler，那我们尝试在子线程中先调用一下Looper.prepare()呢，代码如下所示：
[java]view plaincopy
1.new Thread(new Runnable() {
2.@Override
3.public void run() {
4. Looper.prepare();
5. handler2 = new Handler();
6. }
7.}).start();
果然这样就不会崩溃了，不过只满足于此显然是不够的，我们来看下Handler的源码，搞清楚为什么不调用Looper.prepare()就不行呢。Handler的无参构造函数如下所示：
[java]view plaincopy
1.public Handler() {
2.if (FIND_POTENTIAL_LEAKS) {
3.final Class klass = getClass();
4.if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLo
calClass()) &&
5. (klass.getModifiers() & Modifier.STATIC) == 0) {
6. Log.w(TAG, "The following Handler class should be static or leak
s might occur: " +
7. klass.getCanonicalName());
8. }
9. }
10. mLooper = Looper.myLooper();
11.if (mLooper == null) {
12.throw new RuntimeException(
13."Can't create handler inside thread that has not called Looper.p
repare()");
14. }
15. mQueue = mLooper.mQueue;
16. mCallback = null;
17.}
可以看到，在第10行调用了Looper.myLooper()方法获取了一个Looper对象，如果Looper 对象为空，则会抛出一个运行时异常，提示的错误正是 Can't create handler inside thread that has not called Looper.prepare()！那什么时候Looper对象才可能为空呢？这就要看看Looper.myLooper()中的代码了，如下所示：
[java]view plaincopy
1.public static final Looper myLooper() {
2.return (Looper)sThreadLocal.get();
3.}
这个方法非常简单，就是从sThreadLocal对象中取出Looper。如果sThreadLocal中有Looper存在就返回Looper，如果没有Looper存在自然就返回空了。因此你可以想象得到是在哪里给sThreadLocal设置Looper了吧，当然是Looper.prepare()方法！我们来看下它的源码：
[java]view plaincopy
1.public static final void prepare() {
2.if (sThreadLocal.get() != null) {
3.throw new RuntimeException("Only one Looper may be created per threa
d");
4. }
5. sThreadLocal.set(new Looper());
6.}
可以看到，首先判断sThreadLocal中是否已经存在Looper了，如果还没有则创建一个新的Looper设置进去。这样也就完全解释了为什么我们要先调用Looper.prepare()方法，才能创建Handler对象。同时也可以看出每个线程中最多只会有一个Looper对象。
咦？不对呀！主线程中的Handler也没有调用Looper.prepare()方法，为什么就没有崩溃呢？细心的朋友我相信都已经发现了这一点，这是由于在程序启动的时候，系统已经帮我们自动调用了Looper.prepare()方法。查看ActivityThread中的main()方法，代码如下所示：
[java]view plaincopy
1.public static void main(String[] args) {
2. SamplingProfilerIntegration.start();
3. CloseGuard.setEnabled(false);
4. Environment.initForCurrentUser();
5. EventLogger.setReporter(new EventLoggingReporter());
6. Process.setArgV0("
7. Looper.prepareMainLooper();
8. ActivityThread thread = new ActivityThread();
9. thread.attach(false);
10.if (sMainThreadHandler == null) {
11. sMainThreadHandler = thread.getHandler();
12. }
13. AsyncTask.init();
14.if (false) {
15. Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "Activ
ityThread"));
16. }
17. Looper.loop();
18.throw new RuntimeException("Main thread loop unexpectedly exited");
19.}
可以看到，在第7行调用了Looper.prepareMainLooper()方法，而这个方法又会再去调用Looper.prepare()方法，代码如下所示：
[java]view plaincopy
1.public static final void prepareMainLooper() {
2. prepare();
3. setMainLooper(myLooper());
4.if (Process.supportsProcesses()) {
5. myLooper().mQueue.mQuitAllowed = false;
6. }
7.}
因此我们应用程序的主线程中会始终存在一个Looper对象，从而不需要再手动去调用Looper.prepare()方法了。
这样基本就将Handler的创建过程完全搞明白了，总结一下就是在主线程中可以直接创建Handler对象，而在子线程中需要先调用Looper.prepare()才能创建Handler对象。
看完了如何创建Handler之后，接下来我们看一下如何发送消息，这个流程相信大家也已经非常熟悉了，new出一个Message对象，然后可以使用setData()方法或arg参数等方式为消息携带一些数据，再借助Handler将消息发送出去就可以了，示例代码如下：
[java]view plaincopy
1.new Thread(new Runnable() {
2.@Override
3.public void run() {
4. Message message = new Message();
5. message.arg1 = 1;
6. Bundle bundle = new Bundle();
7. bundle.putString("data", "data");
8. message.setData(bundle);
9. handler.sendMessage(message);
10. }
11.}).start();
可是这里Handler到底是把Message发送到哪里去了呢？为什么之后又可以在Handler的handleMessage()方法中重新得到这条Message呢？看来又需要通过阅读源码才能解除我们心中的疑惑了，Handler中提供了很多个发送消息的方法，其中除了sendMessageAtFrontOfQueue()方法之外，其它的发送消息方法最终都会辗转调用到sendMessageAtTime()方法中，这个方法的源码如下所示：
[java]view plaincopy
1.public boolean sendMessageAtTime(Message msg, long uptimeMillis)
2.{
3.boolean sent = false;
4. MessageQueue queue = mQueue;
5.if (queue != null) {
6. msg.target = this;
7. sent = queue.enqueueMessage(msg, uptimeMillis);
8. }
9.else {
10. RuntimeException e = new RuntimeException(
11.this + " sendMessageAtTime() called with no mQueue");
12. Log.w("Looper", e.getMessage(), e);
13. }
14.return sent;
15.}
sendMessageAtTime()方法接收两个参数，其中msg参数就是我们发送的Message对象，而uptimeMillis参数则表示发送消息的时间，它的值等于自系统开机到当前时间的毫秒数再加上延迟时间，如果你调用的不是sendMessageDelayed()方法，延迟时间就为0，然后将这两个参数都传递到MessageQueue的enqueueMessage()方法中。这个MessageQueue 又是什么东西呢？其实从名字上就可以看出了，它是一个消息队列，用于将所有收到的消息以队列的形式进行排列，并提供入队和出队的方法。这个类是在Looper的构造函数中创建的，因此一个Looper也就对应了一个MessageQueue。
那么enqueueMessage()方法毫无疑问就是入队的方法了，我们来看下这个方法的源码：
[java]view plaincopy
1.final boolean enqueueMessage(Message msg, long when) {
2.if (msg.when != 0) {
3.throw new AndroidRuntimeException(msg + " This message is already in
use.");
4. }
5.if (msg.target == null && !mQuitAllowed) {
6.throw new RuntimeException("Main thread not allowed to quit");
7. }
8.synchronized (this) {
9.if (mQuiting) {
10. RuntimeException e = new RuntimeException(msg.target + " sending
message to a Handler on a dead thread");
11. Log.w("MessageQueue", e.getMessage(), e);
12.return false;
13. } else if (msg.target == null) {
14. mQuiting = true;
15. }
16. msg.when = when;
17. Message p = mMessages;
18.if (p == null || when == 0 || when < p.when) {
19. msg.next = p;
20. mMessages = msg;
21.this.notify();
22. } else {
23. Message prev = null;
24.while (p != null && p.when <= when) {
25. prev = p;
26. p = p.next;
27. }
28. msg.next = prev.next;
29. prev.next = msg;
30.this.notify();
31. }
32. }
33.return true;
34.}
首先你要知道，MessageQueue并没有使用一个集合把所有的消息都保存起来，它只使用了一个mMessages对象表示当前待处理的消息。然后观察上面的代码的16~31行我们就可以看出，所谓的入队其实就是将所有的消息按时间来进行排序，这个时间当然就是我们刚才介绍的uptimeMillis参数。具体的操作方法就根据时间的顺序调用msg.next，从而为每一个消息指定它的下一个消息是什么。当然如果你是通过sendMessageAtFrontOfQueue()方法来发送消息的，它也会调用enqueueMessage()来让消息入队，只不过时间为0，这时会把mMessages赋值为新入队的这条消息，然后将这条消息的next指定为刚才的mMessages，这样也就完成了添加消息到队列头部的操作。
现在入队操作我们就已经看明白了，那出队操作是在哪里进行的呢?这个就需要看一看Looper.loop()方法的源码了，如下所示：
[java]view plaincopy
1.public static final void loop() {
2. Looper me = myLooper();
3. MessageQueue queue = me.mQueue;
4.while (true) {
5. Message msg = queue.next(); // might block
6.if (msg != null) {
7.if (msg.target == null) {
8.return;
9. }
10.if (me.mLogging!= null) me.mLogging.println(
11.">>>>> Dispatching to " + msg.target + " "
12. + msg.callback + ": " + msg.what
13. );
14. msg.target.dispatchMessage(msg);
15.if (me.mLogging!= null) me.mLogging.println(
16."<<<<< Finished to " + msg.target + " "
17. + msg.callback);
18. msg.recycle();
19. }
20. }
21.}
可以看到，这个方法从第4行开始，进入了一个死循环，然后不断地调用的MessageQueue 的next()方法，我想你已经猜到了，这个next()方法就是消息队列的出队方法。不过由于这个方法的代码稍微有点长，我就不贴出来了，它的简单逻辑就是如果当前MessageQueue 中存在mMessages(即待处理消息)，就将这个消息出队，然后让下一条消息成为mMessages，否则就进入一个阻塞状态，一直等到有新的消息入队。继续看loop()方法的第14行，每当有一个消息出队，就将它传递到msg.target的dispatchMessage()方法中，那这里msg.target又是什么呢？其实就是Handler啦，你观察一下上面sendMessageAtTime()方法的第6行就可以看出来了。接下来当然就要看一看Handler中dispatchMessage()方法的源码了，如下所示：
[java]view plaincopy
1.public void dispatchMessage(Message msg) {
2.if (msg.callback != null) {
3. handleCallback(msg);
4. } else {
5.if (mCallback != null) {
6.if (mCallback.handleMessage(msg)) {
7.return;
8. }
9. }
10. handleMessage(msg);
11. }
12.}
在第5行进行判断，如果mCallback不为空，则调用mCallback的handleMessage()方法，否则直接调用Handler的handleMessage()方法，并将消息对象作为参数传递过去。这样我相信大家就都明白了为什么handleMessage()方法中可以获取到之前发送的消息了吧！
因此，一个最标准的异步消息处理线程的写法应该是这样：
[java]view plaincopy
1.class LooperThread extends Thread {
2.public Handler mHandler;
3.
4.public void run() {
5. Looper.prepare();
6.
7. mHandler = new Handler() {
8.public void handleMessage(Message msg) {
9.// process incoming messages here
10. }
11. };
12.
13. Looper.loop();
14. }
15. }
当然，这段代码是从Android官方文档上复制的，不过大家现在再来看这段代码，是不是理解的更加深刻了？
那么我们还是要来继续分析一下，为什么使用异步消息处理的方式就可以对UI进行操作了呢？这是由于Handler总是依附于创建时所在的线程，比如我们的Handler是在主线程中创建的，而在子线程中又无法直接对UI进行操作，于是我们就通过一系列的发送消息、入队、出队等环节，最后调用到了Handler的handleMessage()方法中，这时的handleMessage()方法已经是在主线程中运行的，因而我们当然可以在这里进行UI操作了。整个异步消息处理流程的示意图如下图所示：
另外除了发送消息之外，我们还有以下几种方法可以在子线程中进行UI操作：
1. Handler的post()方法
2. View的post()方法
3. Activity的runOnUiThread()方法
我们先来看下Handler中的post()方法，代码如下所示：
[java]view plaincopy
1.public final boolean post(Runnable r)
2.{
3.return sendMessageDelayed(getPostMessage(r), 0);
4.}
原来这里还是调用了sendMessageDelayed()方法去发送一条消息啊，并且还使用了getPostMessage()方法将Runnable对象转换成了一条消息，我们来看下这个方法的源码：
[java]view plaincopy
1.private final Message getPostMessage(Runnable r) {
2. Message m = Message.obtain();
3. m.callback = r;
4.return m;
5.}
在这个方法中将消息的callback字段的值指定为传入的Runnable对象。咦？这个callback 字段看起来有些眼熟啊，喔！在Handler的dispatchMessage()方法中原来有做一个检查，如果Message的callback等于null才会去调用handleMessage()方法，否则就调用handleCallback()方法。那我们快来看下handleCallback()方法中的代码吧：
[java]view plaincopy
1.private final void handleCallback(Message message) {
2. message.callback.run();
3.}
也太简单了！竟然就是直接调用了一开始传入的Runnable对象的run()方法。因此在子线程中通过Handler的post()方法进行UI操作就可以这么写：
[java]view plaincopy
1.public class MainActivity extends Activity {
2.
3.private Handler handler;
4.
5.@Override
6.protected void onCreate(Bundle savedInstanceState) {
7.super.onCreate(savedInstanceState);
8. setContentView(https://www.360docs.net/doc/ca18006353.html,yout.activity_main);
9. handler = new Handler();
10.new Thread(new Runnable() {
11.@Override
12.public void run() {
13. handler.post(new Runnable() {
14.@Override
15.public void run() {
16.// 在这里进行UI操作
17. }
18. });
19. }
20. }).start();
21. }
22.}
虽然写法上相差很多，但是原理是完全一样的，我们在Runnable对象的run()方法里更新UI，效果完全等同于在handleMessage()方法中更新UI。
然后再来看一下View中的post()方法，代码如下所示：
[java]view plaincopy
1.public boolean post(Runnable action) {
2. Handler handler;
3.if (mAttachInfo != null) {
4. handler = mAttachInfo.mHandler;
5. } else {
6. ViewRoot.getRunQueue().post(action);
7.return true;
8. }
9.return handler.post(action);
10.}
原来就是调用了Handler中的post()方法，我相信已经没有什么必要再做解释了。
最后再来看一下Activity中的runOnUiThread()方法，代码如下所示：
[java]view plaincopy
1.public final void runOnUiThread(Runnable action) {
2.if (Thread.currentThread() != mUiThread) {
3. mHandler.post(action);
4. } else {
5. action.run();
6. }
7.}
如果当前的线程不等于UI线程(主线程)，就去调用Handler的post()方法，否则就直接调用Runnable对象的run()方法。还有什么会比这更清晰明了的吗？
通过以上所有源码的分析，我们已经发现了，不管是使用哪种方法在子线程中更新UI，其实背后的原理都是相同的，必须都要借助异步消息处理的机制来实现，而我们又已经将这个机制的流程完全搞明白了，真是一件一本万利的事情啊。
基于Struts2 Result Type为chain 的Action之间数据传递
chain:基本用途是构造成一条动作链。前一个Action将控制权转交给后一个Action，而前一个Action的状态在后一个Action里仍然保持着。 我现在有一个场景，FirstAction 通过chain的方式，将控制权交给SecondAction。FirstAction对应的页面代码为first.ftl，SecondAction对应的页面代码为second.ftl。 假设我们的FirstAction如下定义： public class SecondAction extends ActionSupport{ private CustomUser user = null; public String execute() throws Exception { // 利用user做事情或显示在页面上 } // getter setter } 意思很明确了，通过first.ftl的输入，到DB中或其他，生成了我们的CustomUser对象，这个CustomUser对象将要在SecondAction使用。 于是我们想到了要配置FirstAction 的name为toSecond的Result type为chain，将生成的CustomUser对象传递到SecondAction中， 我们也这样做了，但是经过调试，发现在SecondAction中没有得到FirstAction中的CustomUser对象。 SecondAction是这样实现的： public class SecondAction extends ActionSupport{ private CustomUser user = null; public String execute() throws Exception { // 利用user做事情或显示在页面上 } // getter setter } 看一下ChainingInterceptor.java的实现，发现有这样的注释： An interceptor that copies all the properties of every object in the value stack to t he currently executing object.
AJAX案例
div 部分用于显示来自服务器的信息。当按钮被点击时，它负责调用名为loadXMLDoc() 的函数：
Let AJAX change this text
所有现代浏览器（IE7+、Firefox、Chrome、Safari 以及 Opera）均内建XMLHttpRequest 对象。 创建 XMLHttpRequest 对象的语法： variable=new XMLHttpRequest(); 老版本的 Internet Explorer （IE5 和 IE6）使用 ActiveX 对象： variable=new ActiveXObject("Microsoft.XMLHTTP"); 为了应对所有的现代浏览器，包括 IE5 和 IE6，请检查浏览器是否支持XMLHttpRequest 对象。如果支持，则创建 XMLHttpRequest 对象。如果不支持，则创建 ActiveXObject ： var xmlhttp; if (window.XMLHttpRequest) {// code for IE7+, Firefox, Chrome, Opera, Safari xmlhttp=new XMLHttpRequest(); } else {// code for IE6, IE5 xmlhttp=new ActiveXObject("Microsoft.XMLHTTP"); } 在下一章中，您将学习发送服务器请求的知识。 AJAX - 向服务器发送请求 ?Previous Page ?Next Page XMLHttpRequest 对象用于和服务器交换数据。 向服务器发送请求 如需将请求发送到服务器，我们使用 XMLHttpRequest 对象的 open() 和 send() 方法： xmlhttp.open("GET","test1.txt",true); xmlhttp.send();
舆情信息处置机制制度精编版
舆情信息处置机制制度 为积极响应上级通知精神，进一步加强对舆情的引导与监控，建立健全舆情快速响应和处理机制，促进和保障幼儿园各项工作的有序开展，根据我园实际情况，采取以下措施：一、加强领导，构建全方位舆情监控网络 幼儿园舆情监控工作由保教处牵头，全面负责互联网及各大媒体的舆情引导与监控工作。设兼职舆情管理员一名，由保教主任担任。各部门、各年级组兼职舆情监督员，并邀请家委会主任担任社会舆情反馈员。进一步加强与地方各级新闻媒体的沟通协作，构建全方位舆情监控网络，密切配合，共同应对幼儿园舆情的引导与监控工作。 二、实行舆情监控巡查制度 1、实行舆情信息处置日值班制度，建立舆情信息处置每日记录。制定舆情监控负责制，每天由舆情监督员利用中午1点-2点，下午4点-5点两个时段负责监测跟踪网上涉及幼儿园工作的各种论坛、帖吧言论，掌握舆情热点，密切关注网络信息动态，捕捉带有苗头性、倾向性、群众性的问题。采取多种方式进行引导和疏通，并做好记录。 2、保教处舆情管理员每天向各处室了解一天舆情。 3、加强沟通，拓宽舆情监控渠道。加强与家委会负责人和地方其他媒体的沟通联系，及时了解来自各方面信息，及时扑捉舆情线索。
三、实行疏导、控制制度 每天舆情管理员整理舆情信息及时向园领导反馈情况，并对可能出现的突发事件进行早期预报，确保有关的重大舆情和负面信息早发现、早报告、早处置。对于有可能给幼儿园造成负面影响的舆论报道和评论，幼儿园组织协调有关力量及时进行舆情处置和舆论引导，有效疏导和控制负面舆情。 四、加强宣传，建立正确舆论导向 充分利用幼儿园网络、报纸、园信通等宣传平台，通过多种手段和渠道做正确的舆论方向引导，同时建立防控体系，积极消除不和谐、不稳定隐患。 化隆县第二幼儿园 2019年10月
JAVA之struts2+ajax实现echats柱状图
说明：本实例使用的是echart3，jquery1.8.1 1）struts的web.xml配置代码如下：
校园网络舆情信息监测处置机制
校园网络舆情信息监测处置机制为进一步加强网络舆情监测，特别是加强校园网络舆情的引导和监控，防止不良信息对校园的侵害，掌握网络舆情主动权，加强对网络舆情的预警防范和监测引导，形成积极向上的主流舆论，营造良好的舆论环境，促进和保障校园网络信息服务健康、有序发展，根据国家有关法律法规，现结合我校实际情况，特制定本办法。 一、工作目标 加强网上舆情监控，及时掌握舆情动态，坚决封堵、删除各种有害信息，及时掌握学校学生在各种网络媒介中的言论和动态，加强正面引导，释疑解惑，化解矛盾，消除不良影响，营造积极、健康的舆论氛围。 二、主要内容 本办法中的网络舆情，特指可能或已经对学生思想政治教育工作产生影响的网上负面报道或网络负面言论。网络舆情的管理与处置，是指对涉及宣传思政工作的新闻报道或评论在互联网上刊发、扩散后，所引发的反应、言论、评论和后续报道等综合舆论情况的监测、控制和化解等具体措施。 三、组织结构 成立网络舆情管理与处置工作领导小组，指定教导处为领导小组办公室，在领导小组的领导下牵头开展网络舆情管 理与处置的组织、监督、实施、考核工作。
四、工作职责 网络舆情监督员负责监测学校的微博、微信，学生个人人人通、微博、微信的舆情情况，了解各网站当前的舆情，及时将舆情通报网络舆情管理员，督促及时控制和引导，并作好日志记录和备案工作；负责跟踪各单位的舆情控制及引导情况，及时上报学校。 五、工作原则 按照“谁主管、谁负责”的原则将监测到的舆情信息进行分转交办，按照“快速反应、确认事实、妥善处理”的原则及时对网络舆情进行分析、判断、评估，准确查找舆情信息产生的原因，认真核实舆情反映的问题，对舆情走向作出正确的判断，对舆情可能产生的影响进行客观、全面评估，及时准备好跟（回）帖材料。 在处置网络舆情事件时，一定要端正工作态度，多渠道、多方法全面了解事件真相，不推卸责任，勇于承担应负的责任；在回应时不要只站在如何消除对学校和学校形象的影响上，而要站在师生或受害者的立场上。第一时间告知学生和当事人事情真相，进行真诚、公开、及时的沟通，不使矛盾进一步激化，赢得学生的理解和信任。根据某一重大舆情事件的发展态势和走向，最大程度地争取媒介的公信力和权威性，适时转移目标，发布最及时权威的信息，左右网络舆情的走向，把噪音杂音压下来，使该网络舆情信息关注度逐渐转冷。要加强正面宣传，树立良好风气。 六、操作流程
Struts2+JQuery+JSON实现AJAX
Struts2 + JQuery + JSON实现AJAX 网上关于这方面的资料也不少，但多半是struts1的，在Struts2中使用JSON 可以更容易实现数据的异步传输。 先做好准备工作: 1.Struts2相关lib, 注意将struts2 lib下面的以json开头的包也加入到工程。 2.JSON Plugin，它可以将Struts2 Action中的结果直接返回为JSON。下载地址： https://www.360docs.net/doc/ca18006353.html,/files/jsonplugin-0.34.jar（支持struts2.1.6及以上版本）。 3.JQuery，JS的一个lib. 下载地址：https://www.360docs.net/doc/ca18006353.html,（最新版本为1.3.2）。 准备工作都做好之后，我们可以开始了。建一个WEB工程，把相关的包加入到工程。我们需要做的就是三件事： 一、准备一个JSP页面用于提交ajax请求，这里我使用了JQuery的$.getJSON(url,params,function callback(data))函数提交ajax请求到指定url，并且携带参数params，最后用一个回调函数callback处理请求返回结果data； 二、一个处理请求的Action类，并在struts.xml文件中做相应配置：写一个action类处理ajax请求数据，并将返回结果封装成一个JSONObject对象返回给请求页面。同时在struts.xml中配置对应action，指明其返回类型为json 并使其package的extends为json-default，并将要返回请求页面的数据放在名为root的param中，如result。 三、接受请求返回结果：使用JS的eval方法将返回结果data转换成JSON 对象，并处理返回结果。 具体参见以下代码： // login.jsp 使用getJSON方法提交ajax请求，并处理请求返回结果。注意请求的url为login.html这是因为我将struts2.preperties中的 struts.action.extension改成了htm，默认为action。l Html代码
Ajax的实现步骤
AJAX基本实现步骤 AJAX是异步通信的一种技术，主要实现技术是javascript+xml+html+css+服务端。在这里主要讨论客户端的操作。以下是客户端的实现步骤： 1、创建XMLHttpRequest对象(需要考虑各浏览器兼容的问题) 2、使用XMLHttpRequest对象打开一个连接(指定连接方式
} catch (ee) { try { xmlHttp = new ActiveXObject("Microsoft.XMLHTTP"); } catch (err) { xmlHttp = false; } } } if(!xmlHttp) alert("不能创建XMLHttpRequest对象"); } createXMLHttpRequest(); 基本上，上面的码就能够实现在大部分浏览器中创建XMLHttpRequest对象。这一步的作用就是为了创建XMLHttpRequest对象，所以基本上不需要进行更改。 (2)、使用XMLHttpRequest对象打开一个连接(指定连接方式
Handler消息处理机制
Handler消息处理机制 1.概述。 Handler消息处理机制对于初学者来说，应该算是一块心病，几乎每次面试都会被问到，今天我抽时间从源码的角度总结一下相关知识点。先看一下我们平时是怎么用的，如下代码实例： public class MainActivity extends AppCompatActivity { private TextView text; private Handler mHandler; int i=0; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(https://www.360docs.net/doc/ca18006353.html,yout.activity_main); text = (TextView) findViewById(R.id.text); mHandler = new Handler(){ @Override public void handleMessage(Message msg) { super.handleMessage(msg); text.setText("变为："+msg.what); } }; } public void sendMes(View view){ mHandler.sendEmptyMessage(i); i++; } } 很简单，onCreat()方法中实例化了一个Handler实例，实现其handlerMessage(Message msg)方法，在方法中改变TextView的显示内容，在布局文件中放了一个Button设置其android:onClick="sendMes"，看一下效果：
struts2+json+jquery实现ajax登录和注册功能
在上一篇博文中已经学习了如何整合mybatis和spring，实现持久层的CRUD操作、业务层的事务管理和spring的IoC。 现在我们这个demo的基础上，继续整合struts2，并利用json插件和jquery实现ajax，完成后系统将实现登录与注册的简单功能。 浏览器端如何简单、高效地与服务器端进行数据交互是web开发者最为关心的内容。在客户端构造intput表单数据或者拼凑URL参数名称/参数值，然后在服务器端笨拙地用request.getParameter(“参数名称”)获取参数显然已经过时了，在struts2中，只要在action 里定义了input表单名称/URL参数名称对应的String类型属性，并设置getter和setter 方法，struts2在调用action的时候就可以根据参数值自动帮你设置好action中对应的属性值供你使用，这极大地方便了开发者。 但是json更为强大——它可以根据浏览器端上传的符合格式的数据设置action中对象的值，也就是说，struts2自动封装的数据只有一层，而json是无限层。 json给页面参数的传递带来极大的方便，结合jquery来使用，可以轻易地做到页面局部刷新、页面无跳转进行友好的系统异常提示等，其中后者是我觉得最有必要做到的一点，在action中定义一个message变量，把action方法执行的结果或者系统异常信息放到里面以json的方式返回给客户端，客户端根据这个变量的结果来进行下一步的操作或者提示系统异常信息，非常地好用。 json由javascript中的对象和数组构成，基本形式是{key:value}，key为属性名称，value 为属性值，value可以为数字、字符串、数组、对象，value可以为数组和对象是json可以封装无限层数据的关键所在。至于如何建构和解析json不是本篇博文的详细表述范围，请参考其他资料。 现在就让我们利用struts2作为MVC框架，整合json插件，在浏览器端使用jquery解析和系列化json数据，由此制作一个具有登陆/注册功能的小demo。本demo中的数据持久层的实现用到了mybatis3和spring3，请参考本人的上一篇博文。 首先我们需要在eclipse中新建一个web工程，并把以下jar包拷贝到工程WEB-INF/lib 下： aopalliance-1.0.jar asm-3.3.1.jar asm-commons-3.3.jar asm-tree-3.3.jar aspectjweaver.jar cglib-2.2.2.jar commons-dbcp-1.2.1.jar
jQuery调用AJAX异步操作超清晰教程
JQUERY AJAX异步操作详细说明 AJAX 全称 Asynchronous JavaScript and XML（异步的 JavaScript 和XML）。它并非一种新的技术，而是以下几种原有技术的结合体。 1)使用CSS和XHTML来表示。 2)使用DOM模型来交互和动态显示。 3)使用XMLHttpRequest来和服务器进行异步通信。 4)使用javascript来绑定和调用。 通过AJAX异步技术，可以在客户端脚本与web服务器交互数据的过程中使用XMLHttpRequest对象来完成HTTP请求(Request)/应答(Response)模型： 1)不需要用户等待服务端响应。在异步派发XMLHttpRequest请求后控制 权马上就被返回到浏览器。界面不会出现白板，在得到服务器响应之前 还可以友好的给出一个加载提示。 2)不需要重新加载整个页面。为XMLHttpRequest注册一个回调函数，待 服务器响应到达时，触发回调函数，并且传递所需的少量数据。“按需 取数据”也降低了服务器的压力。 3)不需要使用隐藏或内嵌的框架。在XHR对象之前，模拟Ajax通信通常 使用hack手段，如使用隐藏的或内嵌的框架(