Retrofit学习笔记

最新推荐文章于 2022-04-29 15:10:38 发布

原创最新推荐文章于 2022-04-29 15:10:38 发布 · 520 阅读

0 ·

CC 4.0 BY-SA版权

本文详细介绍了使用Retrofit进行网络请求的过程，包括自定义Adapter、ViewHolder等组件，并展示了如何通过Retrofit获取电影列表及天气信息。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

最近研究了一下Retrofit，也动手写了一些代码，今天整理一下，方便以后的学习

先看一张效果图
这里写图片描述

因为需要图片，我们先来看看adapter的写法
1.BasicAdapter

public abstract class BasicAdapter<T> extends BaseAdapter {
    private Context mContext;
    private List<T> mDatas;
    private LayoutInflater mInflater;
    private int mItemLayoutId;

    public BasicAdapter(Context context, List<T> mDatas, int itemLayoutId) {
        this.mContext = context;
        this.mDatas = mDatas;
        this.mItemLayoutId = itemLayoutId;
        mInflater = LayoutInflater.from(context);
    }

    @Override
    public int getCount() {
        return mDatas.size();
    }

    @Override
    public T getItem(int position) {
        return mDatas.get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        BasicViewHolder viewHolder = getViewHolder(position, convertView, parent);
        convert(viewHolder,getItem(position));
        return viewHolder.getConvertView();
    }
    public abstract void convert(BasicViewHolder helper,T item);

    private BasicViewHolder getViewHolder(int position,View convertView,ViewGroup parent){
        return BasicViewHolder.get(mContext,convertView,parent,mItemLayoutId,position);
    }
}

2.BasicViewHolder

public class BasicViewHolder {
    private View mConvertView;
    private int mPosition;
    private SparseArray<View> mViews;
    private BasicViewHolder(Context context, ViewGroup parent,int layoutId,int position){
        mConvertView = LayoutInflater.from(context).inflate(layoutId,parent,false);
        this.mPosition = position;
        mViews = new SparseArray<View>();
        mConvertView.setTag(this);
    }
    public static BasicViewHolder get(Context context,View convertView,ViewGroup parent,int layoutId,int position){
        if(convertView == null){
            return new BasicViewHolder(context,parent,layoutId,position);
        }else{
            return (BasicViewHolder) convertView.getTag();
        }
    }
    public View getConvertView(){
        return mConvertView;
    }

    public <T extends View> T getView(int viewId){
        View view = mViews.get(viewId);
        if(view == null){
            view = mConvertView.findViewById(viewId);
            mViews.put(viewId,view);
        }
        return (T)view;
    }
    public BasicViewHolder setText(int viewId,String text){
        TextView textView = getView(viewId);
        textView.setText(text);
        return this;
    }
    public BasicViewHolder setImageResource(int viewId,int resId){
        ImageView imageView = getView(viewId);
        imageView.setImageResource(resId);
        return this;
    }
    public BasicViewHolder setImageBitmap(int viewId, Bitmap bm) {
        ImageView view = getView(viewId);
        view.setImageBitmap(bm);
        return this;
    }
    public void setImageUri(int viewId,String url){
        ImageView imageView = getView(viewId);
        Uri uri = Uri.parse(url);
        imageView.setImageURI(uri);
    }

    public int getPosition() {
        return mPosition;
    }
}

3.MovieAdapter

public class MovieAdapter extends BasicAdapter<MovieInfo.MovieBean> {
    public MovieAdapter(Context context, List<MovieInfo.MovieBean> mDatas, int itemLayoutId) {
        super(context, mDatas, itemLayoutId);
    }
    @Override
    public void convert(BasicViewHolder helper, MovieInfo.MovieBean item) {
        helper.setImageUri(R.id.movie_item_view,Constant.IMAGE_URL+item.poster_path );
    }
}

然后是接口地址

public interface Constant {
    String API_KEY = "643e503c35816202926457ad7d535052";
    String BASE_URL = "http://api.themoviedb.org/3/discover/movie/";
    String POP_LIST =
            "?sort_by=popularity.desc&api_key=";
    String IMAGE_URL = "http://image.tmdb.org/t/p/w185";
    String SCORE_LIST = "movie?sort_by=vote_average.desc&api_key=";
}

因为我们要请求天气和电影信息，所以需要两个实体类

public class MovieInfo {
    public int page;
    public int total_results;
    public int total_pages;

    public List<MovieBean> results;

    public static class MovieBean {
        public String poster_path;
        public boolean adult;
        public String overview;
        public String release_date;
        public int id;
        public String original_title;
        public String original_language;
        public String title;
        public String backdrop_path;
        public double popularity;
        public int vote_count;
        public boolean video;
        public double vote_average;
        public List<Integer> genre_ids;
    }
}

public class WeatherInfo {
    public WeatherinfoBean weatherinfo;

    public static class WeatherinfoBean {
        public String city;
        public String cityid;
        public String temp;
        public String WD;
        public String WS;
        public String SD;
        public String WSE;
        public String time;
        public String isRadar;
        public String Radar;
        public String njd;
        public String qy;
        @Override
        public String toString() {
            return "WeatherinfoBean{" +
                    "city='" + city + '\'' +
                    ", cityid='" + cityid + '\'' +
                    ", temp='" + temp + '\'' +
                    ", WD='" + WD + '\'' +
                    ", WS='" + WS + '\'' +
                    ", SD='" + SD + '\'' +
                    ", WSE='" + WSE + '\'' +
                    ", time='" + time + '\'' +
                    ", isRadar='" + isRadar + '\'' +
                    ", Radar='" + Radar + '\'' +
                    ", njd='" + njd + '\'' +
                    ", qy='" + qy + '\'' +
                    '}';
        }
    }

    @Override
    public String toString() {
        return "WeatherInfo{" +
                "weatherinfo=" + weatherinfo +
                '}';
    }
}

加载图片使用的是Fresco，请求网络是Retrofit

Fresco使用要先初始化

 protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Fresco.initialize(this);
        setContentView(R.layout.activity_main);

注意要在setContentView之前。

下面给出请求部分的代码

public class RetrofitWrapper {

    private final Retrofit retrofit;

    private RetrofitWrapper(){
        //BASE_URL必须以/结尾，否则会出异常
        retrofit = new Retrofit.Builder().baseUrl(Constant.BASE_URL).addConverterFactory(GsonConverterFactory.create()).build();
    }
    public static RetrofitWrapper getInstance() {
        return RefrofitHolder.instance;
    }
    /**静态内部类*/
    public static class RefrofitHolder{
        private static RetrofitWrapper instance = new RetrofitWrapper();
    }
    public <T> T create(Class<T> service){
        return retrofit.create(service);
    }
}

public class AppClient {
    private static Retrofit mRetrofit;
    public static Retrofit retrofit(){
        if(mRetrofit == null){
            mRetrofit = new Retrofit.Builder().baseUrl("http://www.weather.com.cn/").addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                    .addConverterFactory(GsonConverterFactory.create()).build();
        }
        return mRetrofit;
    }
}

public class RxClient {
    private static Retrofit sRetrofit;

    public static Retrofit retrofit(){
        if(sRetrofit == null){
            sRetrofit = new Retrofit.Builder().baseUrl("http://www.weather.com.cn/")
                    .addConverterFactory(GsonConverterFactory.create())//添加gson转换
                    .addCallAdapterFactory(RxJavaCallAdapterFactory.create()).build();//添加rxjava支持
        }
        return sRetrofit;
    }
}

以上是对Retrofit的一些封装，下面我们看看请求的Service

/**
 * 不带参数，拼接好的
 */
public interface MovieService {
    @GET(Constant.POP_LIST+Constant.API_KEY)//拼接在BASE_URL后面的路径
    Call<MovieInfo> getPopMovieList();//无参数的方法,Call<T> 中的T为结果对应的实体类，如果是字符串，可以用ResponseBody
}

public interface MovieService2 {
    @GET(Constant.BASE_URL)//如果不需要在BASE_URL后面拼接其他路径，则再次写BASE_URLd的路径
    //@Query 指定参数的名称             "?sort_by=popularity.desc&api_key=";
    Call<ResponseBody> getMovieScoreList(@Query("sort_by")String sort_by,@Query("api_key") String api_key);
    //ResponseBody 代表要获取字符串
}

public interface WeatherService {
    @GET("adat/sk/{cityId}.html")//注意参数名称必须一样 @Path表示将参数进行匹配，与{}结合使用
    Observable<WeatherInfo> getWeatherInfo(@Path("cityId") String cityId);
    Observable<WeatherInfo> getWeatherInfo2(@Path("cityId") String cityId);
}

public interface RxWeatherService {
    @GET("adat/sk/{cityId}.html")
    Observable<WeatherInfo> getWeathInfoRxJava(@Path("cityId")String cityId);
}

准备工作已经做好了，看看在代码中如何使用

/**
 * 请求接口数据，封装成实体类，将图片显示在列表中
 */
public class MainActivity extends AppCompatActivity {

    private GridView mMovie_gridview;
    private List<MovieInfo.MovieBean> mData;
    private MovieAdapter mMovieAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Fresco.initialize(this);
        setContentView(R.layout.activity_main);
        mData = new ArrayList<>();
        mMovie_gridview = (GridView) findViewById(R.id.movie_gridview);
        mMovieAdapter = new MovieAdapter(this,mData,R.layout.movie_item_layout);
        mMovie_gridview.setAdapter(mMovieAdapter);
        MovieService movieService = RetrofitWrapper.getInstance().create(MovieService.class);
        Call<MovieInfo> movieInfoCall = movieService.getPopMovieList();
        movieInfoCall.enqueue(new Callback<MovieInfo>() {
            @Override
            public void onResponse(Call<MovieInfo> call, Response<MovieInfo> response) {
                MovieInfo movieInfo = response.body();
                mData.addAll(movieInfo.results);
                mMovieAdapter.notifyDataSetChanged();
            }
            @Override
            public void onFailure(Call<MovieInfo> call, Throwable t) {
                Toast.makeText(MainActivity.this, t.toString(), Toast.LENGTH_SHORT).show();
            }
        });
    }
}

/**
 * 请求接口，获取结果字符串，显示在界面上
 */
public class SecondActivity extends AppCompatActivity {

    private TextView mTextView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        mTextView = (TextView) findViewById(R.id.movie_content);
        MovieService2 movieService2 = RetrofitWrapper.getInstance().create(MovieService2.class);
        //同步调用，不能在主线程，会发生NetworkOnMainThreadException
        Call<ResponseBody> responseBodyCall = movieService2.getMovieScoreList("popularity.desc",Constant.API_KEY);
//        try {
//            Response<ResponseBody> result = responseBodyCall.execute();
//            mTextView.setText(result.body().string());
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
        //异步调用
        responseBodyCall.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                ResponseBody body = response.body();
                try {
                    mTextView.setText(body.string());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                Toast.makeText(SecondActivity.this, t.toString(), Toast.LENGTH_SHORT).show();
            }
        });
    }
}

/**
 * 请求城市信息
 */
public class ThirdActivity extends AppCompatActivity {
    private TextView mTextView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_third);
        mTextView = (TextView) findViewById(R.id.tv_weather);
        WeatherService weatherService = AppClient.retrofit().create(WeatherService.class);
        Observable<WeatherInfo> weatherInfo = weatherService.getWeatherInfo("101010100");
        weatherInfo.subscribeOn(Schedulers.io())//指定被观察者运行在IO线程，否则会在主线程操作网络
                .observeOn(AndroidSchedulers.mainThread())//指定观察者运行在主线程，否则会报错
                .subscribe(new Action1<WeatherInfo>() {
            @Override
            public void call(WeatherInfo weatherInfo) {
                mTextView.setText(weatherInfo.weatherinfo.cityid);
            }
        });
    }
}

public class FourThActivity extends AppCompatActivity {
    private static final String TAG = "FourThActivity";
    private TextView mTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_four_th);
        mTextView = (TextView) findViewById(R.id.text);
        RxWeatherService rxWeatherService = RxClient.retrofit().create(RxWeatherService.class);
        Observable<WeatherInfo> observable = rxWeatherService.getWeathInfoRxJava("101010100");
        observable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<WeatherInfo>() {
                    @Override
                    public void onCompleted() {
                        Log.d(TAG, "onCompleted: ");
                    }
                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, "onError: ",e );
                    }
                    @Override
                    public void onNext(WeatherInfo weatherInfo) {
                        mTextView.setText(weatherInfo.toString());
                    }
                });
    }
}