MHttp

KO | EN

gitlite — search

#typescript #ai-agents #ai #dsh-plugin #deepseek-harness #open-source #cli #claude-code #codex #developer-tools #react #windows

★ 80 Open GitHub ↗

okhttp wrapper for Android Http.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# MHttp
okhttp wrapper for Android Http.
### Gradle:
```gradle
  compile 'im.wangchao:mhttp:1.10.1'
  annotationProcessor 'im.wangchao:mhttp-compiler:0.5.2'
```
you can use `implementation` replace of `compile`.

If you use RxJava
```gradle
  compile 'io.reactivex.rxjava2:rxjava:2.x.y'
```

### PROGUARD
ProGuard rules now ship inside of the library and are included automatically.
```java
    -keep class im.wangchao.** { *; }
    -dontwarn im.wangchao.**
    -keep class **_HttpBinder { *; }
    -keepclasseswithmembernames class * {
        @im.wangchao.* <fields>;
    }
    -keepclasseswithmembernames class * {
        @im.wangchao.* <methods>;
    }
    -keepclassmembers class * implements java.io.Serializable {  
        static final long serialVersionUID;  
        private static final java.io.ObjectStreamField[] serialPersistentFields;  
        !static !transient <fields>;  
        private void writeObject(java.io.ObjectOutputStream);  
        private void readObject(java.io.ObjectInputStream);  
        java.lang.Object writeReplace();  
        java.lang.Object readResolve();  
    }
    # If you do not use Rx:
    -dontwarn rx.**
```
### How to use
#### 1.Normal Get
```java
     Request.builder().url("https://www.baidu.com")
                    .callback(new TextCallbackHandler(){
                        @Override public void onSuccess(String data, Response response) {
                            Log.e(MainActivity.TAG, data);
                        }
                    })
                    .build()
                    .enqueue();
```
#### 2.Normal Post
```java
    Request.builder().url("url")
                    .addHeader("key", "value")
                    .addParameter("key", "value")
                    .callback(new JSONCallbackHandler(){
                        @Override public void onSuccess(JSON data, Response response) {
                            //TODO
                        }
                    })
                    .build()
                    .enqueue();
```
#### 3.Annotation (Support Post and Get)
Turns your HTTP API into a Java interface or abstract Class.
```java
    public interface GetBaidu{
            @Get(url = "https://www.baidu.com")
           void baidu(@Callback TextCallbackHandler callback);
    }

public interface PostApi{

@Post(url = "http://www.baidu.com")
           Request postRequest(String param0, String param1, @Callback TextCallbackHandler callback);

@Post(url = "http://www.baidu.com")
           void autoExecuteRequest(String param0, String param1, @Callback TextCallbackHandler callback);
    }
```

The MHttp class generates an implementation of this interface(abstract).
```java
    GetBaidu api = MHttp.create(GetBaidu.class);
    api.baidu(new TextCallbackHandler(){
              @Override protected void onSuccess(String data, OkResponse response) {
                  Log.e(MainActivity.TAG, data);
              }
    });

//auto send
    PostApi api = MHttp.create(PostApi.class);
    api.autoExecuteRequest("aa", "bb", new TextCallbackHandler(){
             @Override protected void onSuccess(String data, OkResponse response) {
                 //Todo
             }
    );

//obtain request
    PostApi api = MHttp.create(PostApi.class);
    Request request =  api.postRequest("aa", "bb", new TextCallbackHandler(){
             @Override protected void onSuccess(String data, OkResponse response) {
                 //Todo
             }
    });
    request.enqueue();
```

Automatically generated classes when you use the Annotation.
```java

/**
 * Implementation GetBaidu interface
 */
public class GetExample$GetBaidu$$HttpBinder implements GetBaidu {
    public GetExample$GetBaidu$$HttpBinder() {
    }

public void baidu(TextCallbackHandler callback) {
        RequestParams params = new RequestParams();
        Builder builder = new Builder();
        builder.requestParams(params);
        builder.url("https://www.baidu.com");
        MHttp.instance().timeout(30);
        okhttp3.Headers.Builder headerBuilder = new okhttp3.Headers.Builder();
        builder.headers(headerBuilder.build());
        builder.method("GET");
        builder.callback(callback);
        builder.build().enqueue();
    }
}

/**
 * Implementation PostApi interface
 */
public class PostExample$PostApi$$HttpBinder implements PostApi {
    public PostExample$PostApi$$HttpBinder() {
    }

public Request postRequest(String param0, String param1, TextCallbackHandler callback) {
        String FIELD_PARAM0 = "param0";
        String FIELD_PARAM1 = "param1";
        RequestParams params = new RequestParams();
        params.put("param0", param0);
        params.put("param1", param1);
        Builder builder = new Builder();
        builder.requestParams(params);
        builder.url("http://www.baidu.com");
        MHttp.instance().timeout(30);
        okhttp3.Headers.Builder headerBuilder = new okhttp3.Headers.Builder();
        builder.headers(headerBuilder.build());
        builder.method("POST");
        builder.callback(callback);
        return builder.build();
    }

public void autoExecuteRequest(String param0, String param1, TextCallbackHandler callback) {
        String FIELD_PARAM0 = "param0";
        String FIELD_PARAM1 = "param1";
        RequestParams params = new RequestParams();
        params.put("param0", param0);
        params.put("param1", param1);
        Builder builder = new Builder();
        builder.requestParams(params);
        builder.url("http://www.baidu.com");
        MHttp.instance().timeout(30);
        okhttp3.Headers.Builder headerBuilder = new okhttp3.Headers.Builder();
        builder.headers(headerBuilder.build());
        builder.method("POST");
        builder.callback(callback);
        builder.build().enqueue();
    }
}
```

If you want to set default configuration. You can create a Java abstract Class.
```java
public abstract class SampleDefaultApi {

@RootURL("https://www.baidu.com/") String baseURL;
    @Timeout(40) String timeout;
    @RequestContentType(RequestParams.APPLICATION_JSON) String Content_Type;
    @Header("Android") String User_Agent;

@CommonParamsMethod public Map<String, String> getCommonParams() {
        Map<String, String> params = new HashMap<>();
        // TODO
        return params;
    }

}
```
And you can turns your HTTP API into a Java abstract Class, and extend this abstract Class.
Example below:
```java
public abstract class SampleApi extends SampleDefaultApi{
    public static SampleApi instance() {
        return MHttp.create(SampleApi.class);
    }

@Get(url = "https://www.baidu.com/")
    public abstract void baidu(@Callback TextCallbackHandler callback);

@Get(url = "s", tag = "aaa")
    public abstract Request search(String wd, @Callback TextCallbackHandler callback);

@Get(url = "s", tag = "aaa")
    public abstract Request search1(String wd, @Callback TextCallbackHandler callback, @Tag Object a);
}

```
#### 4.Callback
Several common methods are provided. as follows:
```
JSONCallbackHandler
TextCallbackHandler
BinaryCallbackHandler
BitmapCallbackHandler
FileCallbackHandler
GSONCallbackHandler
```
If you want to customize the Callback Method, you can inherit AbsCallbackHandler like the method above.

#### 5.ThreadMode
 * SENDING -- Callback will be called in the same thread, which is sending the request.
 * MAIN -- Callback will be called in Android's main thread (UI thread).
 * BACKGROUND -- Callback will be called in a background thread. That is, work on the request thread(okhttp thread).

Now you can make your own thread. Only need to implement java.util.concurrent.Executor, and set it to your request.

#### 6.Custom okHttpClient
```java
CookieJar cookieJar = new PersistentCookieJar(new SetCookieCache(), new SharedPrefsCookiePersistor(this));
OkHttpClient okHttpClient = new OkHttpClient.Builder()
        .cookieJar(cookieJar)
        .build();
MHttp.instance()
        .customOkHttpClient(okHttpClient) // custom client
        .cache(/*context*/, /*cache dir*/)
        .setURLInterceptor(new URLInterceptor() {
            @Override public String interceptor(String origin) {
                // handle url
                return origin;
            }

@Override public HttpUrl interceptor(HttpUrl origin) {
                return origin;
            }

@Override public URL interceptor(URL origin) {
                return origin;
            }
        });
```
Please set before calling the request.

#### 7.RxRequest
```java
Disposable disposable = RxRequest.<String>builder()
        .get()
        .url("https://www.baidu.com")
        .callback(new TextCallbackHandler(){
            @Override public void onStart() {
                Log.e("wcwcwc", "onStart");
            }

@Override public void onFinish() {
                Log.e("wcwcwc", "onFinish");
            }

@Override public void onCancel() {
                Log.e("wcwcwc", "onCancel");
            }
        }).build()
        .enqueue()
        .observeOn(Schedulers.io())
        .doOnDispose(()->{
            Log.e("wcwcwc", "cancel");
        })
        .subscribe(result -> {
            Log.e("wcwcwc", Thread.currentThread().getName() + " result: " + result);
        }, throwable -> {
            Log.e("wcwcwc", Thread.currentThread().getName() + " throwable: " + throwable.getMessage());
        });

...
// dispose
disposable.dispose();
```

### Contact Me
- Email:  magician.of.technique@aliyun.com

### TODO
- optmize annotation

### License

Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

MHttp

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README