Retrofit在项目中的应用

定义一个注解，用来对bean进行要序列化的字段

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用于Gson命名策略的注解
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface ParamName {

    String value();
}

将注解对需要网络传输bean进行标注：

public class requestBean implements Parcelable {
public static final int RESPONSE_OK = 1;
@ParamName("id") 
private String mId;
@ParamName("name") 
private String mName;
@ParamName("result")
private int mResult;
@ParamName("message")
private String mMessage;
public int getResult() {
return mResult;
}
public String getMessage() {
return mMessage;
}
public String getId() 
{
return mId;
} 
public String getName() 
{ 
return mName; 
}
public boolean succeed() {
return getResult() == RESPONSE_OK;
}
}

把定义好的注解封装进gson

import com.google.gson.FieldNamingPolicy;
import com.google.gson.FieldNamingStrategy;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import com.newandbie.privatecustomize.Config;
import com.newandbie.privatecustomize.annotate.ParamName;
import com.newandbie.privatecustomize.model.Gender;

import java.lang.reflect.Field;

/**
 * 自定义的Gson
 */
public class GsonUtils {

    public static Gson newInstance() {
        GsonBuilder builder = new GsonBuilder();

        builder.setFieldNamingStrategy(new AnnotateNaming());
       
        return builder.create();
    }

    private static class AnnotateNaming implements FieldNamingStrategy {

        @Override
        public String translateName(Field field) {
            ParamName a = field.getAnnotation(ParamName.class);
            return a != null ? a.value() : FieldNamingPolicy.IDENTITY.translateName(field);
        }
    }
}

import com.squareup.okhttp.Cache;
import com.squareup.okhttp.OkHttpClient;

import android.content.Context;

import java.io.File;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

/**
 * OkHttpClient自定义工具类
 */
public class OkHttpUtils {

    private static OkHttpClient singleton;

    public static OkHttpClient getInstance(Context context) {
        if (singleton == null) {
            synchronized (OkHttpUtils.class) {
                if (singleton == null) {
                    File cacheDir = new File(context.getCacheDir(), Config.RESPONSE_CACHE);

                    singleton = new OkHttpClient();
                    try {
                        singleton.setCache(new Cache(cacheDir, Config.RESPONSE_CACHE_SIZE));
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    singleton.setConnectTimeout(Config.HTTP_CONNECT_TIMEOUT, TimeUnit.MILLISECONDS);
                    singleton.setReadTimeout(Config.HTTP_READ_TIMEOUT, TimeUnit.MILLISECONDS);
                }
            }
        }
        return singleton;
    }
}

定义Retrofit工具将以上两个工具配置到RetrofitUtils

import android.content.Context;

import retrofit.RestAdapter;
import retrofit.client.OkClient;
import retrofit.converter.GsonConverter;

public class RetrofitUtils {

    private static RestAdapter singleton;

    public static <T> T createApi(Context context, Class<T> clazz) {
        if (singleton == null) {
            synchronized (RetrofitUtils.class) {
                if (singleton == null) {
                    RestAdapter.Builder builder = new RestAdapter.Builder();
                    builder.setEndpoint(ip地址);//设置远程地址
                    builder.setConverter(new GsonConverter(GsonUtils.newInstance()));
                    builder.setClient(new OkClient(OkHttpUtils.getInstance(context)));
                    builder.setLogLevel(
                            Config.DEBUG ? RestAdapter.LogLevel.FULL : RestAdapter.LogLevel.NONE);
                    singleton = builder.build();
                }
            }
        }
        return singleton.create(clazz);
    }
}

那么工具集准备好了，

使用retrofit放在父类以便子类调用

import retrofit.Callback;
import retrofit.RetrofitError;
import retrofit.client.Response;/**
 * 界面的基类
 */
public class BaseActivity extends ActionBarActivity {

....

    /**
     * 创建API实例
     *
     * @param cls Api定义类的类型
     * @param <T> 范型
     * @return API实例
     */
    public  <T> T  createApi(Class<T> cls) {
        return RetrofitUtils.createApi(this, cls);
    }


    public static abstract class ActivityCallback<T>
            implements Callback<T> {
 <span style="white-space:pre">	</span>//软引用，缓存引用对象
        private final WeakReference<BaseActivity> mRef;


        public ActivityCallback(BaseActivity activity) {
            mRef = new WeakReference<BaseActivity>(activity);
        }


        public Activity getActivity() {
            return mRef.get();
        }


        @Override
        public void failure(RetrofitError error) {
            final BaseActivity activity = mRef.get();
           
               
                Response response = error.getResponse();
                if (response != null) {
                    Toast.makeText(activity, activity.getString(R.string.server_error),
                            Toast.LENGTH_SHORT).show();
                    Log.e(getLogTag(),
                            "code:" + response.getStatus() + ", reason:" + response.getReason());
                    error.printStackTrace();
                }
            
        }


    }

.....
  
}

定义下面的一个REST API接口。 该接口定义了一个函数 ask,  该函数会通过HTTP post请求去访问服务器的//ellassy/teacher/ask
路径并把返回的结果封装为requestBean Java对象返回。

import retrofit.Callback;
import retrofit.http.Field;
import retrofit.http.FormUrlEncoded;
import retrofit.http.Header;
import retrofit.http.POST;

public interface ExpertApi {

    @FormUrlEncoded
    @POST("/ellassy/teacher/ask")
    void ask(@Header("token") String token, @Field("member_id") String memberId,
            @Field("title") String title, @Field("description") String description,
            @Field("teacher_id") String expertId,
            Callback<requestBean> cb);
}

rect客户端请求服务端

import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

import retrofit.client.Response;

public class AskActivity extends implements View.OnClickListener {

    private ExpertApi mExpertApi;

   //...


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

       // ...

        mExpertApi = createApi(ExpertApi.class);
    }

    @Override
    public void onClick(View v) {
       //...调用rest 接口
        mExpertApi.ask(getToken(), mUserInfo.getId(), title, question, mExpertId,
                new AskCallback(AskActivity.this));
    }
//回调接口返回从服务器返回的数据
    private static final class AskCallback extends ActivityCallback<requestBean> {


        public AskCallback(AskActivity activity) {
            super(activity);
        }

     
        @Override
        public void success(requestBean requestbean, Response response) {
            AskActivity activity = (AskActivity) getActivity();
            
                
                if (requestbean.succeed()) {
                    Toast.makeText(activity, "成功返回数据", Toast.LENGTH_SHORT).show();
                    activity.finish();
                } else {
                    Toast.makeText(activity, askResponse.getMessage(), Toast.LENGTH_SHORT).show();
                }
         }   
         
    }
}