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();
                 }
          }

     }
 }