安卓开发笔记——打造属于自己的博客园APP（二）

　　在上一篇文章《安卓开发笔记——打造属于自己的博客园APP（一）》中，我们基本上实现了博客园的主体UI框架（后面可能会有些小变化，等遇到了再说）。今天来讲讲博客园首页模块的大体实现，国际惯例，先来看下效果图：

整体UI效果：

下拉刷新和上拉加载的动画效果：

　　

　　在上篇文章中，我们定义的Tabs主题文字分别是（首页，精华，候选，推荐），这边的命名我是根据博客园网站首页的栏目来命名的，那时候我还没仔细看过博客园的开放接口，后来才发现原来博客园没有对应开放这些栏目的接口，博客园只开放了（文章列表，48小时阅读排行，10天内推荐排行，推荐博客列表）等接口，所以我对应的在Tabs标签主题上改动了下文字。由于是随性开发，没有做过多的前期准备，嘿嘿O(∩_∩)O~

　　PS：其实不按照接口来也是可以的，我们可以采用数据采集的方式来获取数据，有兴趣的朋友可以看看我之前写的一些列关于JAVA采集数据的文章：

　　《基于Java数据采集入库（一）》：http://www.cnblogs.com/lichenwei/p/3904715.html

　　《基于Java数据采集入库（二）》：http://www.cnblogs.com/lichenwei/p/3905370.html

　　《基于Java数据采集入库（三）》：http://www.cnblogs.com/lichenwei/p/3907007.html

　　《基于Java的数据采集（终结篇）》：http://www.cnblogs.com/lichenwei/p/3910492.html

 

　　现在已经实现的效果：主UI效果的基本搭建，网络框架的搭建，各博客列表页面的展示包括更新效果，对图片做了三级缓存处理（后面会把文章，新闻做成离线闪存，实现无网络也能照常浏览）等，功能还有很多，慢慢去实现，然后对各细节的优化也会慢慢迭代去完成。

　　好了，进入主题，由于文章篇幅问题，我这里只会对第一个页面进行讲解，其他大同小异了。

 

1、解析XML数据

这里是博客园对博客内容的开放接口：http://wcf.open.cnblogs.com/blog/help

　　很无奈的发现，博客园的接口是用XML编写的，需要我们去解析XML，挺麻烦的，如果是Json不管在效率上或是我们代码编写上都会来得方便许多。

下面是对首页博文列表：http://wcf.open.cnblogs.com/blog/help/operations/GetSitHomeRecentPagedPosts的XML解析代码

其中第一个参数PAGEINDEX代表页数（默认1），第二个参数PAGESIZE代表每页显示的文章条数（默认20）

package com.lcw.rabbit.myblog.parser;

import com.lcw.rabbit.myblog.entity.Blog;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

/**
 * 对博客列表xml数据的解析
 * Created by Lichenwei
 * Date: 2015-08-17
 * Time: 13:32
 */
public class BlogsListXmlParser {


    /**
     * 用于解析博客列表的xml，返回Blog的List集合对象
     *
     * @param inputStream
     * @param encode
     * @return
     * @throws XmlPullParserException
     * @throws IOException
     */
    public static List<Blog> getListBlogs(InputStream inputStream, String encode) throws XmlPullParserException, IOException {

        List<Blog> mBlogs = null;
        Blog mBlog = null;

        //获取XmlPullParser实例
        XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
        XmlPullParser parser = factory.newPullParser();
        parser.setInput(inputStream, encode);
        //获取解析事件
        int eventType = parser.getEventType();
        //当xml文档未到尾端时
        while (eventType != XmlPullParser.END_DOCUMENT) {
            switch (eventType) {
                //解析根标签的时候，实例化集合
                case XmlPullParser.START_DOCUMENT:
                    mBlogs = new ArrayList<Blog>();
                    mBlog = new Blog();

                    break;
                case XmlPullParser.START_TAG:
                    //当解析到entry标签的时候，实例化Blog对象
                    if ("entry".equals(parser.getName())) {
                        mBlog = new Blog();
                    }
                    if ("id".equals(parser.getName())) {
                        parser.next();
                        mBlog.setBlogId(parser.getText());
                    } else if ("title".equals(parser.getName())) {
                        parser.next();
                        //特殊处理
                        if (!"博客园".equals(parser.getText())) {
                            mBlog.setBlogTitle(parser.getText());
                        }
                    } else if ("summary".equals(parser.getName())) {
                        parser.next();
                        mBlog.setBlogSummary(parser.getText());
                    } else if ("published".equals(parser.getName())) {
                        parser.next();
                        mBlog.setBlogPublished(parser.getText());
                    } else if ("name".equals(parser.getName())) {
                        parser.next();
                        mBlog.setAuthorName(parser.getText());
                    } else if ("uri".equals(parser.getName())) {
                        parser.next();
                        mBlog.setAuthorUri(parser.getText());
                    } else if ("avatar".equals(parser.getName())) {
                        parser.next();
                        mBlog.setAuthorAvatar(parser.getText());
                    } else if ("link".equals(parser.getName())) {
                        //特殊处理
                        if (parser.getAttributeName(0).equals("rel")) {
                            mBlog.setBlogLink(parser.getAttributeValue(1));
                        }
                    } else if ("diggs".equals(parser.getName())) {
                        parser.next();
                        mBlog.setBlogDiggs(parser.getText());
                    } else if ("views".equals(parser.getName())) {
                        parser.next();
                        mBlog.setBlogViews(parser.getText());
                    } else if ("comments".equals(parser.getName())) {
                        parser.next();
                        mBlog.setBlogComments(parser.getText());
                    }
                    break;
                case XmlPullParser.END_TAG:
                    //当解析到entry标签结束的时候添加入Blogs集合，清空Blog对象
                    if ("entry".equals(parser.getName())) {
                        mBlogs.add(mBlog);
                        mBlog = null;
                    }
                    break;

            }
            //手动跳转第一次遍历
            eventType = parser.next();
        }


        return mBlogs;

    }

}

　　在JAVA中解析XML一般有三种方式（SAX,DOM,PULL），上面代码采用的是最后一种PULL方式的解析，前面两种SAX,DOM一般用于JAVAEE里，PULL方式的解析相对前两者来得比较轻量，安卓内部对XML的解析也是采用的PULL，所以没必要引入新的JAR包，关于这三种方式的解析，这里就不再多说了，不是今天的重点。（PS：之前一直做的是Json解析，XML解析几乎没用过，可能大家有更好的更有效率的解析方式，如果有可以在文章评论里帮我指点下迷津）。

　　好了，上面的代码已经对XML解析封装完成，我们只需要传入一个输入流和编码格式，就可以把我们想要的数据装在到List集合了。

这里是List集合里的实体类：

package com.lcw.rabbit.myblog.entity;

/**
 * 博客实体类
 * Created by Lichenwei
 * Date: 2015-08-17
 * Time: 13:34
 */
public class Blog {
    //文章id
    private String blogId;
    //文章标题
    private String blogTitle;
    //文章概要
    private String blogSummary;
    //更新时间
    private String blogPublished;
    //博主昵称
    private String authorName;
    //博主头像地址
    private String authorAvatar;
    //博主博客地址
    private String authorUri;
    //博文链接
    private String blogLink;
    //博文评论数
    private String blogComments;
    //博文浏览数
    private String blogViews;
    //博文推荐数
    private String blogDiggs;

    public Blog() {
    }

    public Blog(String blogId, String blogTitle, String blogSummary, String blogPublished, String authorName, String authorAvatar, String authorUri, String blogLink, String blogComments, String blogViews, String blogDiggs) {
        this.blogId = blogId;
        this.blogTitle = blogTitle;
        this.blogSummary = blogSummary;
        this.blogPublished = blogPublished;
        this.authorName = authorName;
        this.authorAvatar = authorAvatar;
        this.authorUri = authorUri;
        this.blogLink = blogLink;
        this.blogComments = blogComments;
        this.blogViews = blogViews;
        this.blogDiggs = blogDiggs;
    }

    public String getBlogId() {
        return blogId;
    }

    public void setBlogId(String blogId) {
        this.blogId = blogId;
    }

    public String getBlogTitle() {
        return blogTitle;
    }

    public void setBlogTitle(String blogTitle) {
        this.blogTitle = blogTitle;
    }

    public String getBlogSummary() {
        return blogSummary;
    }

    public void setBlogSummary(String blogSummary) {
        this.blogSummary = blogSummary;
    }

    public String getBlogPublished() {
        return blogPublished;
    }

    public void setBlogPublished(String blogPublished) {
        this.blogPublished = blogPublished;
    }

    public String getAuthorName() {
        return authorName;
    }

    public void setAuthorName(String authorName) {
        this.authorName = authorName;
    }

    public String getAuthorAvatar() {
        return authorAvatar;
    }

    public void setAuthorAvatar(String authorAvatar) {
        this.authorAvatar = authorAvatar;
    }

    public String getAuthorUri() {
        return authorUri;
    }

    public void setAuthorUri(String authorUri) {
        this.authorUri = authorUri;
    }

    public String getBlogLink() {
        return blogLink;
    }

    public void setBlogLink(String blogLink) {
        this.blogLink = blogLink;
    }

    public String getBlogComments() {
        return blogComments;
    }

    public void setBlogComments(String blogComments) {
        this.blogComments = blogComments;
    }

    public String getBlogViews() {
        return blogViews;
    }

    public void setBlogViews(String blogViews) {
        this.blogViews = blogViews;
    }

    public String getBlogDiggs() {
        return blogDiggs;
    }

    public void setBlogDiggs(String blogDiggs) {
        this.blogDiggs = blogDiggs;
    }

    @Override
    public String toString() {
        return "Blog{" +
                "blogId='" + blogId + '\'' +
                ", blogTitle='" + blogTitle + '\'' +
                ", blogSummary='" + blogSummary + '\'' +
                ", blogPublished='" + blogPublished + '\'' +
                ", authorName='" + authorName + '\'' +
                ", authorAvatar='" + authorAvatar + '\'' +
                ", authorUri='" + authorUri + '\'' +
                ", blogLink='" + blogLink + '\'' +
                ", blogComments='" + blogComments + '\'' +
                ", blogViews='" + blogViews + '\'' +
                ", blogDiggs='" + blogDiggs + '\'' +
                '}';
    }
}

 

2、获取XML数据

　　我们需要对博客园开放接口的各种数据进行获取，不管是下拉刷新还是上拉加载的文字信息还是对用户头像的图片信息获取，这边需要对网络进行频繁的操作，这里我进入了Volley框架，并对图片做了三级缓存（内存，磁盘，网络）使得在没有网络的情况下也可以看到对应的图片。

对三级缓存封装不熟悉的朋友，可以参考我之前写过的文章《安卓开发笔记——关于图片的三级缓存策略（内存LruCache+磁盘DiskLruCache+网络Volley）》，当然你也可以用你自己的方法，这里就不再详细去说了，一篇文章写不下哈。

看下LogCat打印的日志信息：

 

3、页面布局

　　这里的布局我采用了安卓5.0推出的新控件（未来之星RecyclerView和卡片CardView），谷歌也推出了向下兼容，大家可以在Support-V7包下找到这2个控件。为了便于代码的复用，我这里把每一部分都分开成不同的XML，下面是详细代码：

 这里是博文列表栏目的主界面：（关于下拉刷新和上拉加载，下面会提到）

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:gravity="center">

    <android.support.v4.widget.SwipeRefreshLayout
        android:id="@+id/swipe_refresh"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_margin="4dp">

        <android.support.v7.widget.RecyclerView
            android:id="@+id/rv_view"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:background="@color/md_grey_200"
            android:scrollbars="vertical"
           />
    </android.support.v4.widget.SwipeRefreshLayout>

    <com.lcw.rabbit.myblog.view.MyProgressBar
        android:id="@+id/progressbar"
        android:layout_width="match_parent"
        android:layout_height="20dp"
        android:layout_gravity="bottom"
        android:visibility="gone"
        />
</LinearLayout>

这里是RecyclerView的item布局：

<android.support.v7.widget.CardView xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/cv_cardview"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_margin="8dp"
    android:gravity="center"
    app:cardCornerRadius="6dp">

    <include layout="@layout/recyclerview_item_bloglist_content" />

</android.support.v7.widget.CardView>

这里是item里的详细布局：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal"
    android:padding="3dp">
    <!--头像-->
    <com.makeramen.roundedimageview.RoundedImageView
        android:id="@+id/iv_userhead"
        android:layout_width="60dp"
        android:layout_height="60dp"
        android:layout_gravity="center_vertical"
        android:layout_marginRight="5dp"
        android:src="@mipmap/avatar_default"
        app:riv_border_color="#ffffff"
        app:riv_border_width="2dip"
        app:riv_corner_radius="30dip"
        app:riv_mutate_background="true"
        app:riv_oval="true"
        app:riv_tile_mode="repeat" />
    <!--信息内容-->
    <LinearLayout
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:layout_marginLeft="3dp"
        android:orientation="vertical">

        <TextView
            android:id="@+id/tv_title"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginTop="2dp"
            android:layout_weight="1"
            android:text="测试标题"
            android:ellipsize="end"
            android:singleLine="true"
            android:textColor="@color/md_grey_900"
            android:textSize="14sp"
            android:textStyle="bold" />

        <TextView
            android:id="@+id/tv_description"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:maxLines="3"
            android:text="浏览器类型判断方法有两种：根据浏览器特性来判断根据来检测具体使用哪种方法要看具体需求的场景场景一：为了让用户有较流畅完整的体验，在站点提示用户使用或者，这种场景对浏览器类型的判断并非特别严格，可以使用检测的方法。（因为很多浏览器厂商会篡改标识）。场景二...."
            android:textSize="12sp" />

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_margin="1dp"
            android:layout_weight="1"
            android:orientation="horizontal">

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:gravity="center_vertical"
                android:text="发表:"
                android:textColor="@color/md_grey_500"
                android:textSize="11sp" />

            <TextView
                android:id="@+id/tv_time"
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:layout_marginRight="5dp"
                android:gravity="center_vertical"
                android:textColor="@color/md_grey_500"
                android:textSize="11sp" />

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:gravity="center_vertical"
                android:text="推荐:"
                android:textColor="@color/md_grey_500"
                android:textSize="11sp" />

            <TextView
                android:id="@+id/tv_best"
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:layout_marginRight="5dp"
                android:textColor="@color/md_grey_500"
                android:textSize="11sp" />

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:gravity="center_vertical"
                android:text="评论:"
                android:textColor="@color/md_grey_500"
                android:textSize="11sp" />

            <TextView
                android:id="@+id/tv_comment"
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:layout_marginRight="5dp"
                android:gravity="center_vertical"
                android:textColor="@color/md_grey_500"
                android:textSize="11sp" />

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:gravity="center_vertical"
                android:text="浏览:"
                android:textColor="@color/md_grey_500"
                android:textSize="11sp" />

            <TextView
                android:id="@+id/tv_browse"
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:gravity="center_vertical"
                android:textColor="@color/md_grey_500"
                android:textSize="11sp" />

        </LinearLayout>


    </LinearLayout>

    <!--操作按钮-->
    <ImageButton
        android:id="@+id/ib_more"
        android:layout_width="wrap_content"
        android:layout_height="match_parent"
        android:layout_gravity="center"
        android:background="?android:selectableItemBackground"
        android:paddingLeft="5dp"
        android:paddingRight="5dp"
        android:src="@mipmap/ic_more_dark" />
</LinearLayout>

 

4、详细代码

　　既然用到了RecyclerView，和ListView一样需要一个适配器，它的适配器和我们以往使用ListView的，它不是继承实现BaseAdapter而是去继承RecyclerView.Adapter<RecyclerViewViewHolder>，这里谷歌已经强制开发者使用ViewHolder了，RecyclerView嘛，顾名思义，为了效率而生，看下详细代码吧。

package com.lcw.rabbit.myblog.adapter;

import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageButton;
import android.widget.TextView;

import com.lcw.rabbit.myblog.R;
import com.lcw.rabbit.myblog.entity.Blog;
import com.lcw.rabbit.myblog.utils.ImageCacheManager;
import com.lcw.rabbit.myblog.utils.TimeUtil;
import com.makeramen.roundedimageview.RoundedImageView;

import java.util.List;

/**
 * 博文列表适配器
 * Created by Lichenwei
 * Date: 2015-08-16
 * Time: 22:34
 */
public class BlogListAdapter extends RecyclerView.Adapter<BlogListAdapter.RecyclerViewViewHolder> {

    private Context mContext;
    private List<Blog> mBlogs;

    public BlogListAdapter(Context context, List<Blog> blogs) {
        this.mContext = context;
        this.mBlogs = blogs;
    }

    /**
     * 设置新的数据源，提醒adatper更新
     *
     * @param blogs
     */
    public void refreshData(List<Blog> blogs) {
        this.mBlogs = blogs;
        this.notifyDataSetChanged();
    }


    /**
     * 创建ViewHolder
     *
     * @param viewGroup
     * @param i
     * @return
     */
    @Override
    public RecyclerViewViewHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
        View view = LayoutInflater.from(viewGroup.getContext()).inflate(R.layout.recyclerview_item_bloglist, viewGroup, false);
        return new RecyclerViewViewHolder(view);
    }

    /**
     * 根据资源ID返回Bitmap对象
     *
     * @param resId
     * @return
     */
    public Bitmap getBitmapFromRes(int resId) {
        Resources res = mContext.getResources();
        return BitmapFactory.decodeResource(res, resId);

    }

    /**
     * 绑定数据
     *
     * @param viewholder
     * @param i
     */
    @Override
    public void onBindViewHolder(RecyclerViewViewHolder viewholder, int i) {
        //设置头像
        if (mBlogs.get(i).getAuthorAvatar() != null && !"".equals(mBlogs.get(i).getAuthorAvatar())) {
            ImageCacheManager.loadImage(mBlogs.get(i).getAuthorAvatar(), viewholder.mUserhead, getBitmapFromRes(R.mipmap.avatar_default), getBitmapFromRes(R.mipmap.avatar_default));
        } else {
            viewholder.mUserhead.setImageResource(R.mipmap.avatar_default);
        }
        viewholder.mTitle.setText(mBlogs.get(i).getBlogTitle());
        viewholder.mDescription.setText(mBlogs.get(i).getBlogSummary());
        viewholder.mBest.setText(mBlogs.get(i).getBlogDiggs());
        viewholder.mComment.setText(mBlogs.get(i).getBlogComments());
        viewholder.mBrowse.setText(mBlogs.get(i).getBlogViews());
        //处理日期特殊格式
        String date = TimeUtil.DateToChineseString(TimeUtil.ParseUTCDate(mBlogs.get(i).getBlogPublished()));
        viewholder.mTime.setText(date);
    }

    @Override
    public int getItemCount() {
        return mBlogs.size();
    }

    /**
     * 自定义ViewHolder
     */
    public static class RecyclerViewViewHolder extends RecyclerView.ViewHolder {
        private RoundedImageView mUserhead;
        private TextView mTitle;
        private TextView mDescription;
        private TextView mTime;
        private TextView mBest;
        private TextView mComment;
        private TextView mBrowse;
        private ImageButton mMore;

        public RecyclerViewViewHolder(View view) {
            super(view);
            mUserhead = (RoundedImageView) view.findViewById(R.id.iv_userhead);
            mTitle = (TextView) view.findViewById(R.id.tv_title);
            mDescription = (TextView) view.findViewById(R.id.tv_description);
            mTime = (TextView) view.findViewById(R.id.tv_time);
            mBest = (TextView) view.findViewById(R.id.tv_best);
            mComment = (TextView) view.findViewById(R.id.tv_comment);
            mBrowse = (TextView) view.findViewById(R.id.tv_browse);
            mMore = (ImageButton) view.findViewById(R.id.ib_more);

        }


    }
}

　　然后下拉刷新我采用了谷歌官方推出的SwipeRefreshLayout（Support-V4包下），上拉加载我采用了GitHub上的开源组件mugen（这里是开源项目地址：http://www.open-open.com/lib/view/open1431414846747.html）

这里是博文列表页面的主代码：

package com.lcw.rabbit.myblog.fragment;

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v4.widget.SwipeRefreshLayout;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Toast;

import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.StringRequest;
import com.lcw.rabbit.myblog.R;
import com.lcw.rabbit.myblog.adapter.BlogListAdapter;
import com.lcw.rabbit.myblog.entity.Blog;
import com.lcw.rabbit.myblog.parser.BlogsListXmlParser;
import com.lcw.rabbit.myblog.utils.VolleyRequestQueueManager;
import com.lcw.rabbit.myblog.view.MyProgressBar;
import com.mugen.Mugen;
import com.mugen.MugenCallbacks;
import com.mugen.attachers.BaseAttacher;

import org.xmlpull.v1.XmlPullParserException;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by Lichenwei
 * Date: 2015-08-16
 * Time: 13:57
 */
public class BlogListFragment extends Fragment {
    private View mView;
    //下拉刷新
    private SwipeRefreshLayout mRefreshLayout;
    //无限滚动
    private BaseAttacher mBaseAttacher;

    private MyProgressBar myProgressBar;
    private RecyclerView mRecyclerView;
    private BlogListAdapter mBlogListAdapter;

    //数据源
    private List<Blog> mBlogs;

    //是否正在加载
    private boolean isLoading = false;
    //当前页数
    private int currentPage = 1;


    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        mView = inflater.inflate(R.layout.fragment_bloglist, null);
        initView();
        initData();
        initAction();
        return mView;
    }

    /**
     * 初始化控件监听
     */
    private void initAction() {
        mRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
            @Override
            public void onRefresh() {
                getData(1, 20);
            }
        });
        //设置无限滚动，上拉加载
        mBaseAttacher = Mugen.with(mRecyclerView, new MugenCallbacks() {
            @Override
            public void onLoadMore() {
                //加载更多
                isLoading = true;
                myProgressBar.setVisibility(View.VISIBLE);
                getData((currentPage + 1), 20);
            }

            @Override
            public boolean isLoading() {
                return isLoading;
            }

            @Override
            public boolean hasLoadedAllItems() {
                return false;
            }
        }).start();


    }

    /**
     * 初始化数据
     */
    private void initData() {
        mBlogs = new ArrayList<Blog>();
        //设置空数据给RecyclerView
        mBlogListAdapter = new BlogListAdapter(getActivity(), mBlogs);
        mRecyclerView.setAdapter(mBlogListAdapter);
        //显示下拉刷新样式
        mRefreshLayout.setRefreshing(true);
        //刚开始加载20条数据
        getData(1, 20);

    }


    /**
     * 初始化控件
     */

    private void initView() {
        mRefreshLayout = (SwipeRefreshLayout) mView.findViewById(R.id.swipe_refresh);
        mRecyclerView = (RecyclerView) mView.findViewById(R.id.rv_view);
        myProgressBar = (MyProgressBar) mView.findViewById(R.id.progressbar);

        //设置拉下刷新滚动条颜色
        mRefreshLayout.setColorSchemeResources(android.R.color.holo_blue_light, android.R.color.holo_red_light, android.R.color.holo_orange_light, android.R.color.holo_green_light);
        //设置RecyclerView显示样式
        mRecyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));

    }

    public void getData(final int page, int num) {
        //更新当前页数
        this.currentPage = page;
        String url = "http://wcf.open.cnblogs.com/blog/sitehome/paged/" + page + "/" + num;
        StringRequest request = new StringRequest(Request.Method.GET, url, new Response.Listener<String>() {
            @Override
            public void onResponse(String s) {
                try {
                    isLoading = false;
                    myProgressBar.setVisibility(View.GONE);
                    ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes());
                    //获取List数据集合
                    List<Blog> blogs = BlogsListXmlParser.getListBlogs(inputStream, "utf-8");
                    if (page == 1) {
                        //清空之前的数据预防重复加载
                        mBlogs.clear();
                    }
                    for (Blog blog : blogs) {
                        //整理数据源
                        mBlogs.add(blog);
                    }

                    if (mBlogListAdapter == null) {
                        //如果Adapter不存在
                        mBlogListAdapter = new BlogListAdapter(getActivity(), mBlogs);
                        mRecyclerView.setAdapter(mBlogListAdapter);
                    } else {
                        //存在通知adatper数据源更新
                        mBlogListAdapter.refreshData(mBlogs);
                    }


                    //关闭下拉刷新样式
                    mRefreshLayout.setRefreshing(false);

                } catch (XmlPullParserException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {
                Toast.makeText(getActivity(), volleyError.getMessage(), Toast.LENGTH_SHORT).show();
            }
        });

        //加入Volley请求队列
        VolleyRequestQueueManager.addRequest(request, "getBlogList");


    }
}

　　这里有个小技巧，对于上拉加载，为了避免重复加载数据，我们可以一开始就给RecyclerView设置一个空的Adapter，然后根据加载页码的不同来做不同的操作，如果是第一页，那么就是进行下拉刷新，我们直接清空原来的数据源加载新的即可。如果不是第一页，那就是上拉加载，我们把新的数据追加到旧数据源后面即可，这样就避免了上拉加载滚动条置顶了。

然后这里的底部上拉加载的无限滚动，我采用了自定义View圆圈滚动，你也可以用项目自带的彩色线装，下面是自定义View的具体代码：

package com.lcw.rabbit.myblog.view;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ObjectAnimator;
import android.animation.TimeInterpolator;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;

/**
 * Created by Lichenwei
 * Date: 2015-08-19
 * Time: 10:59
 */
public class MyProgressBar extends View {


    private Paint paint;
    private Paint paint1;
    private Paint paint2;
    private Paint paint3;
    private Paint paint4;

    private float cx0 = -10;
    private float cx1 = -10;
    private float cx2 = -10;
    private float cx3 = -10;
    private float cx4 = -10;

    private long delay = 100;
    private long duration = 1500;
    private float start = -10;
    private float end;
    private int desiredWidth = 500;
    private int desiredHeight = 10;

    private ObjectAnimator animator;
    private ObjectAnimator animator1;
    private ObjectAnimator animator2;
    private ObjectAnimator animator3;
    private ObjectAnimator animator4;
    private boolean isRunning = false;

    public MyProgressBar(Context context) {
        super(context);
//        init();
    }

    public MyProgressBar(Context context, AttributeSet attrs) {
        super(context, attrs);
//        init();
    }

    public MyProgressBar(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);


//        init();
    }

    private void init() {

        paint = new Paint(Paint.ANTI_ALIAS_FLAG);
        paint.setColor(getResources().getColor(android.R.color.holo_red_light));

        paint1 = new Paint(Paint.ANTI_ALIAS_FLAG);
        paint1.setColor(getResources().getColor(android.R.color.holo_orange_light));

        paint2 = new Paint(Paint.ANTI_ALIAS_FLAG);
        paint2.setColor(getResources().getColor(android.R.color.holo_green_light));

        paint3 = new Paint(Paint.ANTI_ALIAS_FLAG);
        paint3.setColor(getResources().getColor(android.R.color.holo_blue_light));

        paint4 = new Paint(Paint.ANTI_ALIAS_FLAG);
        paint4.setColor(getResources().getColor(android.R.color.holo_purple));

        animator = ObjectAnimator.ofFloat(this, "cx0", start, end);
        animator.setDuration(duration);
        animator.setInterpolator(new DecelerateAccelerateInterpolator());
        animator.start();

        animator1 = ObjectAnimator.ofFloat(this, "cx1", start, end);
        animator1.setDuration(duration);
        animator1.setStartDelay(delay);
        animator1.setInterpolator(new DecelerateAccelerateInterpolator());


        animator2 = ObjectAnimator.ofFloat(this, "cx2", start, end);
        animator2.setDuration(duration);
        animator2.setStartDelay(delay * 2);
        animator2.setInterpolator(new DecelerateAccelerateInterpolator());

        animator3 = ObjectAnimator.ofFloat(this, "cx3", start, end);
        animator3.setDuration(duration);
        animator3.setStartDelay(delay * 3);
        animator3.setInterpolator(new DecelerateAccelerateInterpolator());

        animator4 = ObjectAnimator.ofFloat(this, "cx4", start, end);
        animator4.setDuration(duration);
        animator4.setStartDelay(delay * 4);
        animator4.setInterpolator(new DecelerateAccelerateInterpolator());
        animator4.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                if (isRunning) {
                    start();
                }
            }
        });
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);

        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
        int heightSize = MeasureSpec.getSize(heightMeasureSpec);
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int heightMode = MeasureSpec.getMode(widthMeasureSpec);

        Log.i("widthSize ", widthSize + "");
        int measuredWidth, measuredHeight;


        measuredWidth = widthSize;

        measuredHeight = heightSize;

        setMeasuredDimension(measuredWidth, measuredHeight);

        end = -start + measuredWidth;
        init();
    }


    @Override
    protected void onDraw(Canvas canvas) {
        if (!isRunning) {
            start();
            isRunning = true;
        }

        canvas.drawCircle(cx0, 12, 10, paint);
        canvas.drawCircle(cx1, 12, 10, paint1);
        canvas.drawCircle(cx2, 12, 10, paint2);
        canvas.drawCircle(cx3, 12, 10, paint3);
        canvas.drawCircle(cx4, 12, 10, paint4);
    }

    public void start() {

        if (animator != null && animator1 != null && animator2 != null && animator3 != null && animator4 != null) {
            animator.start();
            animator1.start();
            animator2.start();
            animator3.start();
            animator4.start();

            isRunning = true;
        }


    }

    public void cancel() {
        if (animator != null && animator1 != null && animator2 != null && animator3 != null && animator4 != null) {
            animator.cancel();
            animator1.cancel();
            animator2.cancel();
            animator3.cancel();
            animator4.cancel();
            isRunning = false;
        }

    }


    @Override
    protected void onWindowVisibilityChanged(int visibility) {
        super.onWindowVisibilityChanged(visibility);
        if (visibility == View.VISIBLE && !isRunning) {
            Log.i("ProgressBar_Modern", "可见,运行");
            start();
        } else if (visibility == View.GONE && isRunning) {
            Log.i("ProgressBar_Modern", "不可见，暂停");
            cancel();
        }
    }


    @Override
    protected void onVisibilityChanged(View changedView, int visibility) {
        super.onVisibilityChanged(changedView, visibility);
        if (visibility == View.VISIBLE && !isRunning) {
            Log.i("ProgressBar_Modern", "可见,运行");
            start();
        } else if (visibility == View.GONE && isRunning) {
            Log.i("ProgressBar_Modern", "不可见，暂停");
            cancel();
        }
    }

    public float getCx0() {
        return cx0;
    }

    public void setCx0(float cx0) {
        this.cx0 = cx0;
        invalidate();
    }

    public float getCx1() {
        return cx1;
    }

    public void setCx1(float cx1) {
        this.cx1 = cx1;
        invalidate();
    }

    public float getCx2() {
        return cx2;
    }

    public void setCx2(float cx2) {
        this.cx2 = cx2;
        invalidate();
    }

    public float getCx3() {
        return cx3;
    }

    public void setCx3(float cx3) {
        this.cx3 = cx3;
        invalidate();
    }

    public float getCx4() {
        return cx4;
    }

    public void setCx4(float cx4) {
        this.cx4 = cx4;
        invalidate();
    }

//    @Override
//    public boolean onTouchEvent(MotionEvent event) {
//        switch (event.getAction()) {
//            case MotionEvent.ACTION_DOWN:
//                this.start();
//        }
//        return true;
//    }

    private class DecelerateAccelerateInterpolator implements TimeInterpolator {

        private DecelerateAccelerateInterpolator() {

        }

        @Override
        public float getInterpolation(float input) {

//            if (input < 0.5) {
//                return (float) Math.sqrt(0.25 - (input - 0.5) * (input - 0.5));
//            } else {
//                return (float) (1 - Math.sqrt(0.25 - (input - 0.5) * (input - 0.5)));
//            }
            return (float) (Math.asin(2 * input - 1) / Math.PI + 0.5);
        }
    }
}

最后附上一个时间转换工具类：

package com.lcw.rabbit.myblog.utils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

/**
 * 时间转换工具类
 */
public class TimeUtil {
    /**
     * String转换为时间
     *
     * @param str
     * @return
     */
    public static Date ParseDate(String str) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        Date addTime = null;
        try {
            addTime = dateFormat.parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return addTime;
    }

    /**
     * 将日期转换为字符串
     *
     * @param date
     * @return
     */
    public static String ParseDateToString(Date date) {
        return ParseDateToString(date, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 将日期转换为字符串（重载）
     *
     * @param date
     * @param format:时间格式，必须符合yyyy-MM-dd hh:mm:ss
     * @return
     */
    public static String ParseDateToString(Date date, String format) {
        SimpleDateFormat dateFormat = new SimpleDateFormat(format);

        return dateFormat.format(date);
    }

    /**
     * 将UMT时间转换为本地时间
     *
     * @param str
     * @return
     * @throws ParseException
     */
    public static Date ParseUTCDate(String str) {
        //格式化2012-03-04T23:42:00+08:00
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ", Locale.CHINA);
        try {
            Date date = formatter.parse(str);

            return date;
        } catch (ParseException e) {
            //格式化Sat, 17 Mar 2012 11:37:13 +0000
            //Sat, 17 Mar 2012 22:13:41 +0800
            try {
                SimpleDateFormat formatter2 = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss Z", Locale.CHINA);
                Date date2 = formatter2.parse(str);

                return date2;
            } catch (ParseException ex) {
                return null;
            }
        }
    }

    /**
     * 将时间转换为中文
     *
     * @param datetime
     * @return
     */
    public static String DateToChineseString(Date datetime) {
        Date today = new Date();
        long seconds = (today.getTime() - datetime.getTime()) / 1000;

        long year = seconds / (24 * 60 * 60 * 30 * 12);// 相差年数
        long month = seconds / (24 * 60 * 60 * 30);//相差月数
        long date = seconds / (24 * 60 * 60);     //相差的天数
        long hour = (seconds - date * 24 * 60 * 60) / (60 * 60);//相差的小时数
        long minute = (seconds - date * 24 * 60 * 60 - hour * 60 * 60) / (60);//相差的分钟数
        long second = (seconds - date * 24 * 60 * 60 - hour * 60 * 60 - minute * 60);//相差的秒数

        if (year > 0) {
            return year + "年前";
        }
        if (month > 0) {
            return month + "月前";
        }
        if (date > 0) {
            return date + "天前";
        }
        if (hour > 0) {
            return hour + "小时前";
        }
        if (minute > 0) {
            return minute + "分钟前";
        }
        if (second > 0) {
            return second + "秒前";
        }
        return "未知时间";
    }
}

 

这样第一个列表界面就完成了，后面页面的实现基本一致，这里就不重复再讲了，今天先写到这里，改天继续更新，有什么建议或疑问，可以在文章评论给我留言。

 

接下一篇《安卓开发笔记——打造属于自己的博客园APP（三）》

作者：李晨玮
出处：http://www.cnblogs.com/lichenwei/
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文链接。
正在看本人博客的这位童鞋，我看你气度不凡，谈吐间隐隐有王者之气，日后必有一番作为！旁边有“推荐”二字，你就顺手把它点了吧，相得准，我分文不收；相不准，你也好回来找我！