sublime实用功能和常用快捷键[Windows]

下面是sublime Text3的一些实用功能和常用快捷键介绍。ST3在Mac OX与Windows不同平台下的快捷键差别很大。注意下面是针对windows平台的解说。

1. 可以直接打开图片

版本3有个很好的特性（对于前端来说）：可以直接在ST3中打开图片。

2. Goto Anything功能 — 快速查找（ctrl + P）

  • 输入@+函数名可以快速找到函数。
  • 输入#+文本可以快速进行文件内文本匹配。

    3. 多行游标功能（ctrl + D，非常实用）

    如何将文件中的某个单词更改为另一个？
    方法一：利用查找替换功能：ctrl + H（类似于很多编辑器，如NotePad++）
    方法二：多行游标功能，选中一个后，按ctrl+D可以同时选中另一个，同时多了另一个光标。
    但多行游标能完成查找替换功能不能完成的工作。
    比如在某些符合条件的语句后面添加新行，同时加入一些新的文本，如何快速的达到这一目的？
  • 可以选中某一个模式，然后ctrl+D选中另一个，如果有某些不想添加新行的模式则按ctrl+K，ctrl+D跳过这个进入下一个符合条件的模式行。
  • 还可以按Alt + F3快捷键全选所有符合条件的单词，产生多个光标，而不用一个个ctrl+D选中。
  • 如果要在每行都加入光标，可以先ctrl+A然后ctrl+shift+L即可。
  • 如果想在某个字符的多行后面加上光标，可以将光标放在这个字符后面，按住shift键，然后右键可以向下拖动产生多个光标。

    4. 命令模式（推荐）

    比如用ctrl+N新建一个文件后，默认是plain text，没有语法高亮功能，如何设置语法模式？
  • 可以通过右下角的语法选择区选择希望设置的语法模式。
  • 还有另一种更好的办法，即使用ctrl + shift + P打开命令模式，然后输入set syntax [language]设置为某种语言的语法模式，比如set syntax java则设置为java语法高亮。
  • st3支持模糊匹配，你也可以直接输入syntax java或ssjava。
  • 若当前已经是某种语言的语法模式，则可以直接输入其它语言进行切换（而不用输入set syntax或syntax了），比如当然为java语法模式，那么直接输入js就可以马上切换为javascript语法模式。
    还可以输入minimap隐藏或显示右边的minimap缩影

    5. 快速跳转到某一行

    按下Ctrl + G，输入行号，可以快速跳转到该行。（NotePad也是一样）

    6. 快速添加新行

  • Ctrl + Enter可以在当前行下新建一行。
  • Ctrl + Shift + Enter可以在当前行上面添加一行。

    7. 多行缩进

    选中多行后按Ctrl + ]可以增加缩进，按Ctrl + [可以减少缩进。
    PS：发现用Tab和Shift + Tab也是可以的。

    8. 完整拷贝，避免格式错乱

    我们发现，在从别的文件中拷贝一段代码过来的时候，多半只是第一行缩进，后面都乱了，这时可以使用Ctrl + Shift + V进行粘贴，可以在粘贴的过程中保持缩进，这时格式都是正确的。

    9. 重新打开关闭的标签

    在Chrome里面，如果你不小心关闭了某个标签页并想恢复它，你可以按下Shift + Ctrl + T重新打开它。
    在ST3中也一样，如果你不小心关闭了某个文件，可以按下Shift + Ctrl + T快速恢复。连续重复该按键，ST将会按照关闭的先后顺序重新打开标签页。

    10. 按住shift + ctrl然后按←或→可快速选中一行中的某一部分，连续按扩大选择范围。

    比如你需要将某一部分进行注释(ctrl+/)或删除，使用这个功能就很方便。

    11. 上下移动行

    定位光标或选中某块区域，然后按shift+ctrl+↑↓可以上下移动该行。

    12. shift + ctrl + d可快速复制光标所在的一整行，并复制到该行之前。

    13. Ctrl+Shift+M：选中花括号里面的全部内容不包括{}。

    14. Ctrl+Shift+K：删除整行。

    15. 快速关闭HTML里的标签

    写html文件时利用快捷键Alt + .可以快速关闭某个标签，如写后按Alt+.可以快速得到。
    但这样还是挺繁琐，可以使用前端插件Emmet插件，直接在新建的html文件里（首先得设置语法模式为html）直接输入!（代表html5格式的html文档）然后按下ctrl+E即可。

附：如何安装package control

通过快捷键ctrl+` 或者View > Show Console 菜单打开控制台，输入下面Python执行代码（适用于Python3.x解释器）：

1
import urllib.request,os; pf='Package Control.sublime-package'; ipp = sublime.installed_packages_path(); os.makedirs( ipp ) if not os.path.exists(ipp) else None; urllib.request.install_opener( urllib.request.build_opener( urllib.request.ProxyHandler( ))); open( os.path.join( ipp, pf), 'wb' ).write( urllib.request.urlopen( 'http://sublime.wbond.net/' +pf.replace( ' ','%20' )).read()); print( 'Please restart Sublime Text to finish installation')

参考资料

展开全文 >>

Android Handler机制 (二)

在android中提供了一种异步回调机制Handler,使用它，我们可以在完成一个很长时间的任务后做出相应的通知。

handler基本使用：

在主线程中，使用handler很简单，new一个Handler对象实现其handleMessage方法，在handleMessage中提供收到消息后相应的处理方法即可，这里不对handler使用进行详细说明，在看本博文前，读者应该先掌握handler的基本使用，我这里主要深入描述handler的内部机制。现在我们首先就有一个问题，我们使用myThreadHandler.sendEmptyMessage(0);发送一个message对象，那么Handler是如何接收该message对象并处理的呢？我先画一个数据结构图：
数据结构图

从这个图中我们很清楚可以看到调用sendEmptyMessage后，会把 Message对象放入一个MessageQueue队列，该队列属于某个Looper对象，每个Looper对象通过 ThreadLocal.set(new Looper())跟一个Thread绑定了，Looper对象所属的线程在Looper.Loop方法中循环执行从MessageQueue队列读取 Message对象，并把Message对象交由Handler处理，调用Handler的dispatchMessage方法。
现在我们再来看一下使用Handler的基本实现代码：

1
2
3
4
5
6
7
8
9
10
11
               // 主线程中新建一个handler
                normalHandler = new Handler() {
                        public void handleMessage(android.os.Message msg) {
                                btnSendMsg2NormalHandler.setText("normalHandler");
                                Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]--normalHandler handleMessage run...", Thread.currentThread()
                                                .getName()));
                        }
                };
...
//发送消息到hanlder
myThreadHandler.sendEmptyMessage(0);

你现在已经很清楚了sendEmptyMessage到handleMessage的过程，途中经过Looper.MessageQueue队列，转由Looper所在的线程去处理了，这是一个异步的过程，当然Looper所在的线程也可以是sendEmptyMessage所在的线程。看了上面你也许还是迷惑不解，那么什么要Looper了，跟我们要用的Handler又有啥鸟关系呢？

我在前面一直强调在主线程中使用handler，为什么要这么说呢，因为你在自己new一个新线程中去像我前面那样简单建立一个Handler，程序执行是会报错的：

1
2
3
4
java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
 at android.os.Handler.<init>(Handler.java:121)
 at com.cao.android.demos.handles.HandleTestActivity$MyThread$1.<init>(HandleTestActivity.java:86)
 at com.cao.android.demos.handles.HandleTestActivity$MyThread.run(HandleTestActivity.java:86)

为什么在主线程中不会报错，而在自己新建的线程中就会报这个错误呢？很简单，因为主线程它已经建立了Looper，你可以打开ActivityThread的源码看一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static final void main(String[] args) {
    SamplingProfilerIntegration.start();
    Process.setArgV0("<pre-initialized>");
    Looper.prepareMainLooper();
    ActivityThread thread = new ActivityThread();
    thread.attach(false);
    Looper.loop();
    if (Process.supportsProcesses()) {
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }
    thread.detach();
    String name = (thread.mInitialApplication != null)
        ? thread.mInitialApplication.getPackageName()
        : "<unknown>";
    Slog.i(TAG, "Main thread of " + name + " is now exiting");
}

在main函数中它已经做了这个事情了，为什么要调用Looper.prepareMainLooper();Looper.loop();我们可以进去看一下，在prepareMainLooper方法中新建了一个looper对象，并与当前进程进行了绑定，而在Looper.loop方法中，线程建立消息循环机制，循环从MessageQueue获取Message对象，调用msg.target.dispatchMessage(msg);进行处理msg.target在myThreadHandler.sendEmptyMessage(0)设置进去的，因为一个Thead中可以建立多个Hander，通过msg.target保证MessageQueue中的每个msg交由发送message的handler进行处理，那么Handler又是怎样与 Looper建立联系的呢，在Handler构造函数中有这样一段代码：

1
2
3
4
5
6
mLooper = Looper.myLooper();
 if (mLooper == null) {
     throw new RuntimeException(
         "Can't create handler inside thread that has not called Looper.prepare()");
 }
 mQueue = mLooper.mQueue;

在新建Handler时需要设置mLooper成员，Looper.myLooper是从当前线程中获取绑定的Looper对象：

1
2
3
public static final Looper myLooper() {
        return (Looper)sThreadLocal.get();
    }

若Looper对象没有创建，就会抛异常”Can’t create handler inside thread that has not called Looper.prepare()”这跟我前面讲的是一致的。所以我们在一个新线程中要创建一个Handler就需要这样写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class MyThread extends Thread {
        public void run() {                
                Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]-- run...", Thread
                                .currentThread().getName()));
                // 其它线程中新建一个handler
                Looper.prepare();// 创建该线程的Looper对象，用于接收消息,在非主线程中是没有looper的所以在创建handler前一定要使用prepare()创建一个Looper
                myThreadHandler = new Handler() {
                        public void handleMessage(android.os.Message msg) {
                                Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]--myThreadHandler handleMessage run...", Thread
                                                .currentThread().getName()));
                        }
                };
                Looper.myLooper().loop();//建立一个消息循环，该线程不会退出
        }
}

现在，你应该对Handler的机制有所了解了吧，若有什么疑问，欢迎在评论中提出在其它线程中Handler使用主线程的Looper,前面我说了在新线程中要新建一个Handler需要调用Looper.prepare();也有另一种方法就是使用主线程中的Looper,那就不必新建Looper对象了:

1
2
3
4
5
6
7
threadMainLoopHandler =new Handler(Looper.getMainLooper()){
        public void handleMessage(android.os.Message msg) {
                Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]--threadMainLoopHandler handleMessage run...", Thread
                                .currentThread().getName()));                                        
        }
        //该handleMessage方法将在mainthread中执行
};

这时候注意不要在handleMessage做太多的操作，因为它在主线程中执行，会影响主线程执行ui更新操作。使用Message.callback回调

1
2
3
4
5
6
7
8
9
10
11
12
public void dispatchMessage(Message msg) {
     if (msg.callback != null) {
         handleCallback(msg);
     } else {
         if (mCallback != null) {
             if (mCallback.handleMessage(msg)) {
                 return;
             }
         }
         handleMessage(msg);
     }
 }

从dispatchMessage定义可以看出，如果Message对象自带callback对象，handler不会执行handleMessage方法而是执行message.callback中定义的run方法，当然callback还是在handler关联的looper所绑定的线程中执行的。实 际上Handler.post(Runnable r)方法就是把r添加到一个msg.callback的,也就是说，下面两种写法，没有什么区别：

1.使用Message.callback

1
2
3
4
5
6
7
8
9
Message msg = Message.obtain(myThreadHandler,new Runnable() {  
      
    @Override  
    public void run() {  
        Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]--myThreadHandler.Message.callback.run",  
                Thread.currentThread().getName()));   
    }  
});  
myThreadHandler.sendMessage(msg);

2.使用Handler.post

1
2
3
4
5
6
7
8
myThreadHandler.post(new Runnable() {  
                      
                    @Override  
                    public void run() {  
                        Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]--myThreadHandler.Message.callback.run",  
                                Thread.currentThread().getName()));   
                    }  
                });

注：对于Handler机制相关测试，我写了一个测试类：
链接：http://pan.baidu.com/s/1o61Vgnw 密码：hqkp

3.Handler对Activity finish影响。

在开发的过程中碰到一个棘手的问题，调用Activity.finish函数Acitivity没有执行生命周期的ondestory函数，后面查找半天是因为有一个handler成员，因为它有一个delay消息没有处理，调用 Activity.finish，Activity不会马上destory，所以记得在Ativity finish前清理一下handle中的未处理的消息，这样Activity才会顺利的destory。

参考文档：

http://blog.csdn.net/stonecao/article/details/6417364

展开全文 >>

android中handler用法总结 (一)

一、Handler的定义:

Handler主要接收子线程发送的数据,并用此数据配合主线程更新UI，用来跟UI主线程交互用。比如可以用handler发送一个message，然后在handler的线程中来接收、处理该消息，以避免直接在UI主线程中处理事务导致影响UI主线程的其他处理工作，Android提供了Handler作为主线程和子线程的纽带；也可以将handler对象传给其他进程，以便在其他进程中通过handler给你发送事件；还可以通过handler的延时发送message，可以延时处理一些事务的处理。

通常情况下，当应用程序启动时，Android首先会开启一个主线程(也就是UI线程),主线程为管理界面中的UI控件，进行事件分发。如果此时需要一个耗时的操作，例如:联网读取数据，或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，如果你放在主线程中的话，界面会出现假死现象,如果5秒钟还没有完成的话，会收到Android系统的一个错误提示”强制关闭”。这个时候我们需要把这些耗时的操作，放在一个子线程中,因为子线程涉及到UI更新，但是当子线程中有涉及到操作UI的操作时，就会对主线程产生危险，也就是说，更新UI只能在主线程中更新，在子线程中操作是危险的。这个时候，Handler就出现了来解决这个复杂的问题，由于Handler运行在主线程中(UI线程中)，它与子线程可以通过Message对象来传递数据，这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传递)Message对象，(里面包含数据),把这些消息放入主线程队列中，配合主线程进行更新UI。

二、Handler一些特点

handler可以分发Message对象和Runnable对象到主线程中,每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程),也就是说Handler对象初始化后，就默认与对它初始化的进程的消息队列绑定，因此可以利用Handler所包含的消息队列，制定一些操作的顺序。

三、Handler中分发消息的一些方法

  • post(Runnable)
  • postAtTime(Runnable,long)

  • postDelayed(Runnable long)
    (post类方法允许你排列一个Runnable对象到主线程队列中。)

  • sendEmptyMessage(int)

  • sendMessage(Message)
  • sendMessageAtTime(Message,long)
  • sendMessageDelayed(Message,long)
    (sendMessage类方法, 允许你安排一个带数据的Message对象到队列中，等待更新。)

四、应用实例：

1，传递Message。用于接受子线程发送的数据, 并用此数据配合主线程更新UI。

在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到消息队列中，然后，主线程用Handler中的handlerMessge方法处理传过来的数据信息，并操作UI。类sendMessage(Message msg)方法实现发送消息的操作。 在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操作。

2，传递Runnable对象。用于通过Handler绑定的消息队列，安排不同操作的执行顺序。

Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，可以将Runnable对象发送到消息队列中，按照队列的机制按顺序执行不同的Runnable对象中的run方法。

另外，Android的CPU分配的最小单元是线程，Handler一般是在某个线程里创建的，因而Handler和Thread就是相互绑定的，一一对应。而Runnable是一个接口，Thread是Runnable的子类。所以说，他俩都算一个进程。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 public class HandlerActivity extends Activity {  
      
     //声明两个按钮控件  
     private Button startButton = null;  
     private Button endButton = null;  
     @Override 
     public void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         setContentView(R.layout.main);  
        //根据控件的ID得到代表控件的对象，并为这两个按钮设置相应的监听器  
        startButton = (Button)findViewById(R.id.startButton);  
        startButton.setOnClickListener(new StartButtonListener());  
        endButton = (Button)findViewById(R.id.endButton);  
        endButton.setOnClickListener(new EndButtonListener());  
          
    }  
    class StartButtonListener implements OnClickListener{  
 
        @Override 
        public void onClick(View v) {  
            //调用Handler的post方法，将要执行的线程对象添加到队列当中  
            handler.post(updateThread);  
        }  
         
    }  
      
    class EndButtonListener implements OnClickListener{  
 
        @Override 
        public void onClick(View v) {  
            handler.removeCallbacks(updateThread);  
        }  
          
    }  
    //创建一个Handler对象  
    Handler handler  = new Handler();  
    //将要执行的操作写在线程对象的run方法当中  
    Runnable updateThread =  new Runnable(){  
 
        @Override 
        public void run() {  
            System.out.println("UpdateThread");  
            //在run方法内部，执行postDelayed或者是post方法  
            handler.postDelayed(updateThread, 3000);  
        }  
          
    };  
}

程序的运行结果就是每隔3秒钟，就会在控制台打印一行UpdateTread。这是因为实现了Runnable接口的updateThread对象进入了空的消息队列即被立即执行run方法，而在run方法的内部，又在3000ms之后将其再次发送进入消息队列中。

3， Handler和多线程

post方法虽然发送的是一个实现了Runnable接口的类对象，但是它并非创建了一个新线程，而是执行了该对象中的run方法。也就是说，整个run中的操作和主线程处于同一个线程。这样对于那些简单的操作，似乎并不会影响。但是对于耗时较长的操作，就会出现“假死”。为了解决这个问题，就需要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 public class HandlerTest2 extends Activity {  
  
     @Override 
     protected void onCreate(Bundle savedInstanceState) {  
         // TODO Auto-generated method stub  
     super.onCreate(savedInstanceState);  
     setContentView(R.layout.main);  
     //打印了当前线程的ID  
     System.out.println("Activity-->" + Thread.currentThread().getId());  
    //生成一个HandlerThread对象  
    HandlerThread handlerThread = new HandlerThread("handler_thread");  
    //在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程;  
    handlerThread.start();
    //将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。  
    // HandlerThread顾名思义就是可以处理消息循环的线程，它是一个拥有Looper的线程
    //，可以处理消息循环；  其实与其说Handler和一个线程绑定，倒不如说Handler和Looper是
    //一一对应的。
    MyHandler myHandler = new MyHandler(handlerThread.getLooper());  
    Message msg = myHandler.obtainMessage();  
    //将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象  
    Bundle b = new Bundle();  
    b.putInt("age", 20);  
    b.putString("name", "Jhon");  
    msg.setData(b);  
    msg.sendToTarget();  //将msg发送到myHandler
    }  
      
    //定义类
    class MyHandler extends Handler{  
    public MyHandler(){  
              
    }  
    
    public MyHandler(Looper looper){  
        super(looper);  
    }  
    @Override 
    public void handleMessage(Message msg) {  
        Bundle b = msg.getData();  
        int age = b.getInt("age");  
        String name = b.getString("name");  
        System.out.println("age is " + age + ", name is" + name);  
        System.out.println("Handler--->" + Thread.currentThread().getId());  
        System.out.println("handlerMessage");  
        }  
    }  
}

这样，当使用sendMessage方法传递消息或者使用post方法传递Runnable对象时，就会把它们传递到与handler对象绑定的处于另外一个线程的消息队列中，它们将在另外的消息队列中被处理。而主线程还会在发送操作完成时候继续进行，不会影响当前的操作。
这里需要注意，这里用到的多线程并非由Runnable对象开启的，而是ThreadHandler对象开启的。Runnable对象只是作为一个封装了操作的对象被传递，并未产生新线程。
另外再强调一遍，在UI线程（主线程）中：

1
2
3
4
5
6
mHandler=new Handler();
mHandler.post(new Runnable(){
void run(){
   //执行代码..
 }
});

这个线程其实是在UI线程之内运行的，并没有新建线程。

常见的新建线程的方法是：

1
2
Thread thread = new Thread();
thread.start();
1
2
HandlerThread thread = new HandlerThread("string");
thread.start();

参考资料：

http://blog.sina.com.cn/s/blog_77c6324101016jp8.html

展开全文 >>

贾樟柯说，我的电影无暇顾及中国牛不牛逼

[转自端传媒 撰稿人 廖伟棠]

港产江湖片透露出來的情义，变成了我们这一代人的情感追求。我的工作不是要拍中国牛逼，也不是要拍中国不牛逼。我的全部注意力都在人们的命运上，都在人们的情感生活上，是人在迁移。

导演贾樟柯又出新片了！《山河故人》是他在《三峡好人》之後又一部终於能在商业院线上映的电影。《山河故人》既是现实主义的， 又是科幻的现实。它既被誉为2015年度最有深度的情感片，又招来影迷两极化的评论。趁贾樟柯和《山河故人》团队今次应香港亚洲电影节邀请，来港出席开幕 礼兼宣传的时机，作家廖伟棠和贾樟柯聊一聊——这部电影怎样呈现了贾樟柯对中国人命运的独特理解，对中国未来的预测，而香港这个城市，怎样隐秘而深久地参 与了他和这部电影的精神世界。
贾樟柯
《山河故人》导演贾樟柯。摄：王嘉豪/端传媒

廖：《山河故人》比起《天注定》有一个比较明显的反差，首先是全底层的关注角度转向更多其他阶层、尤其是新贵的关注，而对富裕阶层的剖析也不止于批判，有更复杂的认识在 里面，是什么原因促使你加强对后者的观察与呈现的呢？
我记得十年前采访你，你说你广泛结交各阶层的朋友，是否十年来的酝酿终于可以结果？为何在现在这个时机拿出来，呈现一个富人的选择？

我一直在感受人与人之间的分化

贾：从写剧本说起吧，我写剧本不会有过多大纲性的规划，都是信马由缰，写到他们仨的关系确立的时候我自己吓了一 跳，怎么写了一个三角关系？我有点想否定它想重写，但后来又想，我为什么从感性出发写了一个三角关系？我突然发现这关系的出现是对的，我这些年感受到生活 里很多同一起点的人，怎么样在这个中国社会的变革中被分化了。他们过去本来同属一个阶层、一个地方，本来差异很少，但随着不同的道路，每人拥有不同的资 源，他们就开始分化，且越来越大。
最后形成一个个阶层的固化，过去一个班的同学可能很难再坐在一个桌子吃饭了。以我一个老朋友为例，我拍《天注定》的时候，我们之前一直有来往，也知 道他富有了，但不知道他富有到什么程度。当时我们要拍一架飞机落地的镜头，剧组一直在联系飞机，他在旁边听到笑了，说找我嘛，我有三架飞机，平时停在香 港，你需要的话我就给你调一架过来。

命运是一样的，并不会因为拥有更多财富就拥有更多自由和自主权。

这种反差是非常大的，我一直在感受人与人之间的分化。其实它也是我的现实的一部分，我的朋友两边都有、都没有失去联络，这两年山西的新富阶层突然有 一个命运的转折，他们又跟起点上的人一样，要跑路、要从头开始了。你会发现命运是一样的，并不会因为拥有更多财富就拥有更多自由和自主权。我不去做道德评 判，只是这个落差的现实使我感兴趣。最好笑的是很多朋友会躲到四季酒店住很久，其实他没事，就是怕。

廖：和《天注定》里那些底层反抗者相比，梁子更多选择了认命，在第三个时期故事里压根没有了他的存在，好像在说未来没有底层的生存空间一样，这是你故意这样做的吗？是否拍摄《天注定》带来的绝望感，感受到这种抗争的不可为。
花絮
贾樟柯电影《山河故人》拍摄花絮。

人其实并不知道自己的结局是怎样的

贾：其实和抗争无关，我笔下的人物一般都没有超越自己真实的处境，或者说我比较喜欢他们这样。大多数人其实并不 知道自己的结局是怎样的，结局出现才会明白。像梁子他离开故乡的时候，他不一定是绝望的，只是有情伤而已，他为此离开。但他没想到自己一步步陷入更糟糕的 处境，他本来是“井上”负责发矿灯的，后来变成“井下”的了。我喜欢不自知的人物，他们对现实没有自知的反应，大多数人都是这样的。
第三部分完全没有拍过梁子的戏份，其中有几个因素：99年到14年，他们都有一个断裂，比如说只字不提沈涛和晋生为什么离婚，因为我觉得情感上这种 分离太可以理解了，我们可以有无数种想像他们之间发生了什么。另外梁子他已经要化疗了，那么重的病，最终人可能就没了，没有了也就没有了，生活就是这么残 酷的。

廖：未来好像没有了他那一阶层的位置。

贾：晋生的上海老婆也是，我想像过她也可能跑掉了。

廖：跟梁子的老婆形成对比，梁子的老婆是跟他共患难的，晋生的上海老婆却只能同富贵。

贾：我觉得也是。

廖：你写剧本就这么开放吗？有的导演是事后剪掉很多东西形成留白的。

因为她恒定，就像故乡一样，最能映衬飘泊。

贾：我不是，我在写的时候就觉得不应该写它，我需要一个很大的留白就是14年到25年，这之间发生了什么？关于 过去我们可以留白，因为留白的前提是我们经历过，像99年到14年那样，我们可以用经验来填补。14年到25年在这个结构上是一个很重要的空隙，它不是留 白是空隙。我们一年年的度过，2016年会怎样，大家可以想像吗？

廖：你的电影的时间线跟现实的时间线有一点相像，就是越来越急促、越来越紧迫，这种紧迫感，造成一种心情越来越沉重的感觉。
父亲的去世是沈涛真正的转折点，在经历丧夫失子之痛后，她选择的也是一种接受命运的态度，她与晋生对命运态度截然不同，与梁子仿佛殊途同归，这是否导演情感上对失败者的一种默默倾斜。

贾：当然沈涛是电影最中心的人物，她是唯一没有离开的人。我们说这些年外在的飘泊是电影的一个主题，但对沈涛来 说更大的一个飘泊是情感上的，因为她恒定，就像故乡一样，最能映衬飘泊。如果你在故乡一直生活，你就能看到总是有人离开有人回来，所以她像一个人心的站台 一样。她的内心因为人来人往而被拉扯得更厉害。

廖：最后的镜头是非常感人的，听到儿子的一声呼唤，可以是幻听，也可以是真的有这么一个声音。
科幻的部分我自己特别喜欢，在没看电影前我最担心的就是这个部分，因为中国导演处理科幻要么特别过火要么特别土，但你非常克制，跟现实的藕断丝连看得人会心一笑。正因为这种克制，连张艾嘉的忘年恋我也看得非常自然。
在对中国现况和未来图景的描述上，你也选择了最大的中立和克制，把批评压抑在叙事底下，但即使如此还是有很多观众说你在黑中国，你想辩白一下吗？
剧照
电影《山河故人》剧照。

时代的准确性应该存在模糊

我的工作不是要拍中国牛逼，也不是要拍中国不牛逼。我的全部注意力都在人们的命运上，都在人们的情感生活上，是人在迁移。

贾：最早说《山河故人》在黑中国的，实际是康城的几个中国留学生，他们当时在电影节看到反应就比较激烈，当时我 就觉得很搞笑，我拍电影不是为了给谁面子的（他们觉得很没面子）。事实上在我拍电影的时候，我觉得中国牛逼不牛逼跟我没有任何关系，我的工作不是要拍中国 牛逼，也不是要拍中国不牛逼。我的全部注意力都在人们的命运上，都在人们的情感生活上，是人在迁移。
关于未来的部分，一开始我的思路也有走偏过，我曾经想把它拍得特别科幻，比如说到乐会爱上一个外星人，那个外星人没有性别，比较为难，怎么跟它做爱 呢？后来还是从生活经验出发，我突然想到一个东西，这个时间点不过是十年后，十年是近未来而已，比如说今年买的一辆车，保养得好的话25年还会在街上走， 所以不应该是那种颠覆性的科幻世界。另一方面我觉得可变的东西里电子产品是比较重要的，因为它一直在迅速更新，我都嫌我自己对电影里的电子通讯产品设计得 有点保守，应该再更超现实一点。
但也有往回走的，比如说他们还在开六十年代澳洲流行的车，还听黑胶唱片，这就跟我们现在有人玩古家具一样。我喜欢这种混杂的感觉，这有点像拍《站 台》时的经验，《站台》的十年是中国巨变的十年，城市外观和衣着都变化极大，我设计第一稿的时候，每到一年人物的衣着都要全部变掉，中山装时代、风衣时 代、西装时代、夹克时代……但后来发现这是导演的主观，为了强调时代跨越，你仔细看那时候的纪实照片会发现时代实际上是混杂的，到了夹克时代一样有人在穿 中山装。对我来说，时代的准确性应该存在模糊，而不是存在刻意的时代区分，所以未来部分也让他混合起来。

“个人的解放”其实还是中国人的一个很重要的事情，是还要去做的，所以我想像了他的未来。

廖：涉及反贪的部分是怎样过审的，现在播出版本和最初版本相比删节大吗？

贾：审查真没有问题，唯一的是忘年恋那处有一个接吻镜头，他们建议我剪掉，但在我的坚持下也没有剪。据我所知，这电影在审查的时候，审查员很多都哭了，他们被感动了。现在的版本和海外电影节版本是一模一样的，一刀没剪。

廖：你一直对类型片有很大兴趣，这次的三分一部科幻片出乎意料，但又很克制，让人觉得还是贾樟柯签名式的，拿捏得宜，感觉是现实主义的未来。以后还想拍科幻题材吗？会更直接天马行空吗？

贾：其实我对科幻片兴趣不大，只是在我写剧本写到当代部分的时候，我觉得那个孩子的未来我应该想下去，因为他那 么小，命运像被上一代人决定了，父母离婚、移民、抚养权什么他都没有发言权，我就想他长大以后有没有自由，能否自己做主，在生活和情感领域他有没有一个自 我解放，可以说这才是我一直着迷的、人的话题。“个人的解放”其实还是中国人的一个很重要的事情，是还要去做的，所以我想像了他的未来。我个人最着迷的类 型片是黑帮片、武侠片，它跟我的性格更贴切一些。
贾樟柯
《山河故人》导演贾樟柯。摄：王嘉豪/端传媒

港产片里的情义成了我这代人的情感追求

廖：那么传说中的武侠片《在清朝》怎样了？

贾：《在清朝》真的要拍了，筹备七年了，剧本早就完成，忙完《山河故人》就马上开工拍。我们的美术设计也完成，就差服装设计了，因为演员没定下，服装才没动。

廖：以前你还说过想拍一个以香港为背景的间谍片呢？

贾：那是《双雄会》，《双雄会》有重大进展，它刚刚确定了制片人，我会跟英国的Jimmy Thomas（《末代皇帝》的制片人）合作。

廖：那里面的香港与《山河故人》里作为潜台词的香港应该是很不一样的。

我一直喜欢听叶倩文的歌就是因为她有情有义，这几年很多情歌，但义却很薄了。

贾：不一样，香港在那个电影里面是一个交叉路口，人们必须经过的一个地方，各种离散的人，无论往大陆走还是往台湾走还是待在香港观望。
廖：这是《双雄会》的设定，实际上《山河故人》里面香港也是这么一个出发点吧，香港以潜台词的形式出现在山河故 人，但无论是《珍重》还是张艾嘉的角色都好像寄情甚深，欲言又止。你曾在一个电影节开幕式提到“情义”，我觉得这正是香港电影的核心价值，它是怎样作用于 你和你的电影的？

贾：某种程度上八十年代大陆开始进入录像厅时代那时的香港电影，如江湖片，它透露出来的情义，变成了我们这一代人的情感追求，让我们变得特别看重情感里面情义相连的部分。至于说过去大陆电影有没有我倒不知道，反正我们是在录像厅里知道这种情义的。
从流行音乐来看，我一直喜欢听叶倩文的歌就是因为她有情有义，这几年很多情歌，但义却很薄了，情义相连这个概念跟关公也很有关系，最初的时候我对情 义二字也没有掰开看，直到有一次在山西一个武术家跟我聊天，他说关公跟曹操是有义无情，跟刘备才是有情有义，我才知道情义是可以掰开来说的。就像你说的， 情义是港产片里很吸引人的核心价值。
花絮
贾樟柯电影《山河故人》拍摄花絮。

时间让我们变成了古人

廖：目前对山河、故人的诠释，你最喜欢哪一种。 正如山河有对山西山河的呼应；我更关心的是故人，前阵子有位编剧柏邦妮说：故人就是过去价值观的褒有者，我非常同意。故人是否也呼应你自己某种私人记忆和 情感，感觉很沉郁，这次你自己以什么方式折射其中呢？我第一次听到这个名字，想到的是梅艳芳的《似是故人来》，它就像这部电影的一个没出现的配乐。

贾：在梁子身上，你会发现他是一个有古意的人，我这部电影的情感方法其实也挺古意的，它对我来说也许是失散的、丢失的东西。时间让我们变成了古人，故人本身也有失散的、离别的含义在里面。很复杂的一种感情。

生活解构了她的幻想，她年轻时还可以编出几句好词，但当时间告诉了她生活是怎么个样子的时候，她就把这样一个幻想解构掉了。

廖：但最后实际上大多数的相会都没有完成，沈涛与梁子重遇时没有一个很动情的刹那，跟儿子也没有真正重逢，这个留白是你不确定呢还是故意的？
贾：并非不确定，我一直是在按正常的人在情感情景中的反应去体会人物。涛跟梁子的再次相遇的时候，对我来说中心 词是“再也写不出那个好词了”。因为梁子问她你还唱“伞头”吗？“伞头”秧歌在我们那边是即兴表演的，给你出一个题目你就要马上编成四句八句。这里的沧桑 感在于生活解构了她的幻想，她年轻时还可以编出几句好词，但当时间告诉了她生活是怎么个样子的时候，她就把这样一个幻想解构掉了。
这电影里的时间始终处于一个解构的过程中，14年是对99年的解构，25年是对14年的解构。这不是一个理性的想法，而是时间交给我们的东西，就像隔夜茶一样，转眼味道就变了。
总体上来说，这个电影重情重义，拍得也动情动心，所以根本无暇去想中国牛逼不牛逼的问题，只能说他们想多了。

鸣谢访问场地提供︰尖沙嘴隆堡丽景酒店AVA Restaurant Slash Bar

山河故人

导演/编剧 : 贾樟柯
演员 : 赵涛、张艾嘉、董子健、张译、梁景东
片长 : 126 分钟
剧情简介：1999年，小城汾阳，涛儿徘徊在煤矿老板晋生和矿工梁子的三角关系之中，在新世纪来临前，涛儿选择嫁给晋生，梁子远走他 乡。2014年，梁子重病缠身，离家15年后带着妻儿回到故乡，等待生命最后一刻的停摆；病床前涛儿与梁子相望唏嘘，涛儿已经离婚，前夫晋生准备带儿子移 民澳洲。2025年，涛的儿子长大成人，住在澳洲A城，他不讲中文，只记得母亲的名字叫：Tao，波浪的意思。横越三十年，山河不再，人面亦非。

展开全文 >>

SQLite数据库框架ORMLite与GreenDao的简单比较

笔记摘要

最近准备使用数据库做个缓存，以前因为项目中的实时性要求比较高，所以在整体的框架中就没有加缓存，有些地方只是简单的将对象保存到了 Preference中，所以并没有对数据库方面有所研究，既然准备使用数据库了，那就深入了解下吧，对以后也有好处。现在开源社区也有很多的ORM框 架，但不知道哪个好用些，所以就上网查了一下，简单的总结了下，现在分享给大家。

先介绍一下ORM的概念，以前也一直听说，不过没详细了解啥意思。其全称叫做对象关系映射（Object Relation Mapping），是一种程序设计技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的 “虚拟对象数据库”。
面向对象是从软件工程基本原则(如耦合、聚合、封装)的基础上发展起来的，而关系数据库则是从数学理论发展而来的. 两者之间是不匹配的.而ORM作为项目中间件形式实现数据在不同场景下数据关系映射. 对象关系映射是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术.ORM就是这样而来的。

下面先列出几个ORM框架：ORMLite、greendao、ormndroid、androrm、ActiveAndroid
其中以前最早接触过ormlite，GreenDao了解过，其他的几个真没怎么见过。所以这里主要介绍ormlite和GreenDao。
最开始现在stackoverflow输入sqlite orm关键字，搜索出了一些相关的文章：http://stackoverflow.com/search?q=sqlite+orm ，你会发现很有趣的是，ormlite的作者Gray和greenDao的开发团队green robot同时出现在一些帖子中，向提问者推荐他们的框架。当然也会有一些热心的朋友推荐ormdroid。其实不论在stackoverflow上还是官网上，greenDao的团队的比较都是针对ORMLite的，可见，其主要的竞争对手，或许称互相促进者更合适，毕竟他们没有什么商业利益，完全开源。所以开源的ORM框架中，ormLite和greenDao是最火的。其它几种就不做比较，有兴趣的朋友可以到官网看下。下面对ORMLite和GreenDao做个简单的比较：

ormlite

基于注解和反射的的方式,导致ormlite性能有着一定的损失(注解其实也是利用了反射的原理)

优点：

  • 文档较全面，社区活跃，有好的维护，使用简单，易上手。

    缺点：

  • 基于反射，效率较低

GreenDao

官网中明确指明了其首要设计目标:

  • Maximum performance (probably the fastest ORM for Android):系能最大化
  • Easy to use APIs：便于使用
  • Highly optimized for Android：对于Android高度优化
  • Minimal memory consumption：最小化内存开销
  • Small library size, focus on the essentials：较小的文件体积，只集中在必要的部分上。

优点：

  • 效率很高，插入和更新的速度是sqlite的2倍，加载实体的速度是ormlite的4.5倍。官网测试结果：http://greendao-orm.com/features/
  • 文件较小（<100K），占用更少的内存 ，但是需要create Dao，
  • 操作实体灵活：支持get，update，delete等操作

缺点：

学习成本较高。其中使用了一个java工程根据一些属性和规则去generate一些基础代码，类似于javaBean但会有一些规则，另外还有QueryBuilder、Dao等API，所以首先要明白整个过程，才能方便使用。没有ORMLite那样封装的完整，不过greenDao的官网上也提到了这一点，正是基于generator而不是反射，才使得其效率高的多。

另外GreenDao支持Protocol buffers协议数据的直接存储 ，如果通过protobuf协议和服务器交互，不需要任何的映射。

Protocol Buffers协议：以一种高效可扩展的对结构化数据进行编码的方式。google内部的RPC协议和文件格式大部分都是使用它。
RPC：远程过程调用（Remote Procedure Call，RPC）是一个计算机通信协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。

可能因为GreenDao的效率高，而且需要学习成本高点，所以个人还是有兴趣学一学的。接下来会发布一些GreenDao更详细的文章，有对官方文档的翻译还有代码的简单讲解。
或许以上内容很简单，只是简单的介绍了下，对其它几个框架并没有做更多的介绍，有了解的朋友可以提出来，可以提出来，大家一起探讨下。

展开全文 >>

java编程代码样式的xml模板

前言：编码的规范性便于自己和他人后续对代码的维护和更新，现在贴一份codetemplates.xml的模板样式，在eclipse中可以导入使用。

参考如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
<?xml version="1.0" encoding="UTF-8" standalone="no"?><templates>
<template autoinsert="true" context="filecomment_context" deleted="false" description="Comment for created Java files" enabled="true" id="org.eclipse.jdt.ui.text.codetemplates.filecomment" name="filecomment">
/**
 * 
 * @author aresxiong
 * @date ${date}
 * @Copyright: Copyright (c) ${year} JIUDU Technology All rights reserved.
 */
</template>
<template autoinsert="false" context="fieldcomment_context" deleted="false" description="Comment for fields" enabled="true" id="org.eclipse.jdt.ui.text.codetemplates.fieldcomment" name="fieldcomment">
 /** */
</template>
<template autoinsert="false" context="typecomment_context" deleted="false" description="Comment for created types" enabled="true" id="org.eclipse.jdt.ui.text.codetemplates.typecomment" name="typecomment">
/**
 * 
 * @author aresxiong
 * @date ${date}
 * @Copyright: Copyright (c) ${year} JIUDU Technology All rights reserved.
 */
</template>
<template autoinsert="true" context="overridecomment_context" deleted="false" description="Comment for overriding methods" enabled="true" id="org.eclipse.jdt.ui.text.codetemplates.overridecomment" name="overridecomment">
/* (non-Javadoc)
 * ${see_to_overridden}
 */
</template>
<template autoinsert="true" context="settercomment_context" deleted="false" description="Comment for setter method" enabled="true" id="org.eclipse.jdt.ui.text.codetemplates.settercomment" name="settercomment">
/**
 * @param  ${param}
 */
</template>
<template autoinsert="true" context="gettercomment_context" deleted="false" description="Comment for getter method" enabled="true" id="org.eclipse.jdt.ui.text.codetemplates.gettercomment" name="gettercomment">
/**
 * @return the ${bare_field_name}
 */
</template>
<template autoinsert="false" context="methodcomment_context" deleted="false" description="Comment for non-overriding methods" enabled="true" id="org.eclipse.jdt.ui.text.codetemplates.methodcomment" name="methodcomment">
/**
 *
 * @version 1.0
 * @createTime ${date},${time}
 * @createAuthor aresxiong
 * @updateInfo ()
 * ${tags}
 */
</template>
<template autoinsert="true" context="constructorcomment_context" deleted="false" description="Comment for created constructors" enabled="true" id="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name="constructorcomment">
/**
 *
 * @version 1.0
 * @createTime ${date},${time}
 * @createAuthor aresxiong
 * @updateInfo ()
 * ${tags}
 */
</template>
<template autoinsert="true" context="delegatecomment_context" deleted="false" description="Comment for delegate methods" enabled="true" id="org.eclipse.jdt.ui.text.codetemplates.delegatecomment" name="delegatecomment">
/**
 *
 * @version 1.0
 * @createTime ${date},${time}
 * @createAuthor aresxiong
 * @updateInfo ()
 * ${tags}
 */
</template>
</templates>

展开全文 >>

PullToRefresh使用详解（一）--构建下拉刷新的listView

前言

前几天写了篇关于 PullToRefresh控件的DEMO导入的博客，但由于当时没有用到，所以就没细往下讲，现在开始到了实战阶段，用到了PullToRefresh 的listView样式，网上有讲的，但讲的不多，而且没有详细的例子来说，下面我讲讲这个东东的实现方法。这个例子对应 PullToRefreshDemo里的第一个选项ListView；

注意：本篇仅写的如何实现下拉刷新，对于上拉加载的问题，参见《使用PullToRefresh实现下拉刷新和上拉加载》

相关文章：

效果图:


一、导入Library

下载源码后，里面有个Library工程，添加工程到Eclipse中。

另外extras文件夹还有两个工程：PullToRefreshListFragment和PullToRefreshViewPager，由于我们的这个用不到他们的库文件，所以不必导入了；

二、实战

1、新建工程，添加Libray库到工程中
新建工程（try_PullToRefresh）后，右键-》Properties-》Android-》Add 选择上面的Library，然后就是这个样子的

2、重写activity_main.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >
<!--     The PullToRefreshListView replaces a standard ListView widget. -->
    <com.handmark.pulltorefresh.library.PullToRefreshListView
        android:id="@+id/pull_refresh_list"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:cacheColorHint="#00000000"
        android:divider="#19000000"
        android:dividerHeight="4dp"
        android:fadingEdge="none"
        android:fastScrollEnabled="false"
        android:footerDividersEnabled="false"
        android:headerDividersEnabled="false"
        android:smoothScrollbar="true" />
</LinearLayout>

其中中间那一大段就是相当于ListView控件，用这段来代替原是ListView控件的代码

3、JAVA代码讲解
全部代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
package com.example.try_pulltorefresh;
import java.util.Arrays;
import java.util.LinkedList;
import com.handmark.pulltorefresh.library.PullToRefreshBase;
import com.handmark.pulltorefresh.library.PullToRefreshListView;
import com.handmark.pulltorefresh.library.PullToRefreshBase.OnRefreshListener;
import android.os.AsyncTask;
import android.os.Bundle;
import android.app.Activity;
import android.text.format.DateUtils;
import android.widget.ArrayAdapter;
import android.widget.ListView;
public class MainActivity extends Activity {
	private String[] mStrings = { "Abbaye de Belloc", "Abbaye du Mont des Cats", "Abertam", "Abondance", "Ackawi",
			"Acorn", "Adelost", "Affidelice au Chablis", "Afuega'l Pitu", "Airag", "Airedale", "Aisy Cendre",
			"Allgauer Emmentaler", "Abbaye de Belloc", "Abbaye du Mont des Cats", "Abertam", "Abondance", "Ackawi",
			"Acorn", "Adelost", "Affidelice au Chablis", "Afuega'l Pitu", "Airag", "Airedale", "Aisy Cendre",
			"Allgauer Emmentaler" };
	private LinkedList<String> mListItems;
	private PullToRefreshListView mPullRefreshListView;
	private ArrayAdapter<String> mAdapter;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		mPullRefreshListView = (PullToRefreshListView) findViewById(R.id.pull_refresh_list);
		// Set a listener to be invoked when the list should be refreshed.
		mPullRefreshListView.setOnRefreshListener(new OnRefreshListener<ListView>() {
			@Override
			public void onRefresh(PullToRefreshBase<ListView> refreshView) {
				String label = DateUtils.formatDateTime(getApplicationContext(), System.currentTimeMillis(),
						DateUtils.FORMAT_SHOW_TIME | DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_ABBREV_ALL);
				// Update the LastUpdatedLabel
				refreshView.getLoadingLayoutProxy().setLastUpdatedLabel(label);
				// Do work to refresh the list here.
				new GetDataTask().execute();
			}
		});
		mListItems = new LinkedList<String>();
		mListItems.addAll(Arrays.asList(mStrings));
		mAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, mListItems);
		//这两个绑定方法用其一
		// 方法一
//		 mPullRefreshListView.setAdapter(mAdapter);
		//方法二
		ListView actualListView = mPullRefreshListView.getRefreshableView();
		actualListView.setAdapter(mAdapter);
	}
	private class GetDataTask extends AsyncTask<Void, Void, String> {
		//后台处理部分
		@Override
		protected String doInBackground(Void... params) {
			// Simulates a background job.
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
			}
			String str="Added after refresh...I add";
			return str;
		}
		//这里是对刷新的响应，可以利用addFirst（）和addLast()函数将新加的内容加到LISTView中
		//根据AsyncTask的原理，onPostExecute里的result的值就是doInBackground()的返回值
		@Override
		protected void onPostExecute(String result) {
			//在头部增加新添内容
			mListItems.addFirst(result);
			
			//通知程序数据集已经改变，如果不做通知，那么将不会刷新mListItems的集合
			mAdapter.notifyDataSetChanged();
			// Call onRefreshComplete when the list has been refreshed.
			mPullRefreshListView.onRefreshComplete();
			super.onPostExecute(result);
		}
	}
}

代码讲解：

1、变量定义

1
2
3
private LinkedList<String> mListItems;    //显示的列表对应原字符串
private PullToRefreshListView mPullRefreshListView;  //PullToRefreshListView实例
private ArrayAdapter<String> mAdapter;  //ListView的适配器

2、在OnCreate()中主要分为两步
（1）初始化mPullRefreshListView并设置监听器，以执行当需要刷新时，应该怎么办，至于真正执行刷新的类GetDataTask（）我们后面再细讲，对应代码为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
mPullRefreshListView = (PullToRefreshListView) findViewById(R.id.pull_refresh_list);
// Set a listener to be invoked when the list should be refreshed.
mPullRefreshListView.setOnRefreshListener(new OnRefreshListener<ListView>() {
	@Override
	public void onRefresh(PullToRefreshBase<ListView> refreshView) {
		String label = DateUtils.formatDateTime(getApplicationContext(), System.currentTimeMillis(),
				DateUtils.FORMAT_SHOW_TIME | DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_ABBREV_ALL);
		// Update the LastUpdatedLabel
		refreshView.getLoadingLayoutProxy().setLastUpdatedLabel(label);
		// Do work to refresh the list here.
		new GetDataTask().execute();
	}
});

（2）设置适配器列表内容，并与ListView绑定以显示出来，对应代码为：

1
2
3
4
5
6
7
8
9
10
11
//设置列表内容  
mListItems = new LinkedList<String>();  
mListItems.addAll(Arrays.asList(mStrings));  
mAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, mListItems);  
  
//这两个绑定方法用其一  
// 方法一  
//       mPullRefreshListView.setAdapter(mAdapter);  
//方法二  
ListView actualListView = mPullRefreshListView.getRefreshableView();  
actualListView.setAdapter(mAdapter);

3、执行刷新的类GetDataTask（）
先贴出这段代码来：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
private class GetDataTask extends AsyncTask<Void, Void, String> {//定义返回值的类型  
	// 后台处理部分  
	@Override  
	protected String doInBackground(Void... params) {  
		// Simulates a background job.  
		try {  
			Thread.sleep(1000);  
		} catch (InterruptedException e) {  
		}  
		String str="Added after refresh...I add";  
		return str;  
	}  
 
	//这里是对刷新的响应，可以利用addFirst（）和addLast()函数将新加的内容加到LISTView中  
	//根据AsyncTask的原理，onPostExecute里的result的值就是doInBackground()的返回值  
	@Override  
	protected void onPostExecute(String result) {  
		//在头部增加新添内容  
		mListItems.addFirst(result);  
		
		//通知程序数据集已经改变，如果不做通知，那么将不会刷新mListItems的集合  
		mAdapter.notifyDataSetChanged();  
		// Call onRefreshComplete when the list has been refreshed.  
		mPullRefreshListView.onRefreshComplete();  
		super.onPostExecute(result);//这句是必有的，AsyncTask规定的格式  
	}  
}

（1）派生自AsyncTask
由于派生自AsyncTask，所以下面的那个函数doInBackground和onPostExecute就不难理解了，这两个函数是AsyncTask必须是重写的两个函数
（2）doInBackground函数
doInBackground 执行要于后台执行的语句，返回的值可以是任意类型，但要提前在extends AsyncTask 中定义，这个返回值会做为onPostExecute的参数result传到onPostExecute函数中；如果对于网络访问程 序，doInBackground就执行访问网络的代码，然后讲返回值存在result中传给onPostExecute函数，以刷新列表；
（3）onPostExecute函数
onPostExecute（）是对返回的值进行操作，并添加到ListView的列表中，有两种添加方式添加到头部—-mListItems.addFirst(result);和添加在尾部—-mListItems.addLast(result);

至于 AsyncTask，下面是几个网页，讲的还可以，大家可以参考下：

注意：这只是一个精简版，在源码中还有一些可借签的代码，可以在看懂这个以后，可以回过头来再看看源码，我相信肯定会有收获的。

相关文章

相关链接

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

ARESXIONG 程序猿一枚 爱生活，爱CODING 永远年轻！永远热泪盈眶！