从零开始实现一个 mini-Retrofit 框架

news2024/10/7 10:23:33

前言

本篇文章将采用循序渐进的编码方式,从零开始实现一个Retorift框架,在实现过程中不断提出问题并分析实现,最终开发出一个mini版的Retrofit框架

img

演示一个使用OkHttp的项目Demo

为了更好的演示框架的实现过程,这里我先创建了一个简单的Demo项目

这个Demo项目中主要包含3个部分

  1. Json数据对应JavaEntity类
  2. 项目中包装网络请求回调的Callback
  3. 一个包含项目所有网络接口请求的管理类RestService

JavaBean

@Data
@ToString
public class BaseResponse<T> {
    private boolean error;
    private T results;
}
package com.knight.sample.entity;

import java.util.List;
import java.util.Map;

public class XianduResponse extends BaseResponse<List<GankEntity>> {
}

NetCallback

package com.knight.sample;

import java.io.IOException;

/**
 * 项目封装的统一网络请求的回调
 * @param <T>
 */
public interface NetCallback<T> {
    void onFailure(Exception e);

    void onSuccess(T data);
}

NetWorkService

package com.knight.sample;

import android.util.Log;

import com.google.gson.Gson;
import com.google.gson.stream.JsonReader;

import java.io.IOException;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class RestService {
    private static OkHttpClient okHttpClient;
    public static void init() {
        okHttpClient = new OkHttpClient.Builder()
                .build();
    }

    public static<T>  void todayGank(Class<T> responseClazz,NetCallback<T> callback) {
        Request request = new Request.Builder().url("http://gank.io/api/today")
                .get()
                .build();
        okHttpClient.newCall(request).enqueue(new WrapperOkHttpCallback<>(responseClazz,callback));
    }

    public static<T>  void xianduGank(int count, int page,Class<T> responseClazz,NetCallback<T> callback) {
        Request request = new Request.Builder()
                .url("http://gank.io/api/xiandu/data/id/appinn/count/" + count + "/page/" + page)
                .get().build();
        okHttpClient.newCall(request).enqueue(new WrapperOkHttpCallback<>(responseClazz,callback));
    }

    static class WrapperOkHttpCallback<T> implements Callback {
        private static Gson gson = new Gson();
        private Class<T> clazz;
        private NetCallback<T> callback;

        public WrapperOkHttpCallback(Class<T> responseClazz, NetCallback<T> netCallback) {
            this.clazz = responseClazz;
            this.callback = netCallback;
        }

        @Override
        public void onFailure(Call call, IOException e) {
            Log.e("WrapperOkHttpCallback", "onFailure");
            e.printStackTrace();
            callback.onFailure(e);
        }

        @Override
        public void onResponse(Call call, Response response) throws IOException {
            JsonReader jsonReader = gson.newJsonReader(response.body().charStream());
            T entity = gson.getAdapter(clazz).read(jsonReader);
            Log.d("response", entity.toString());
            callback.onSuccess(entity);

        }
    }

}

在NetworkService类中我们目前定义了2个Http 请求 todayGankxianduGank ,目前两个请求方式都是 Get 其中xianduGank 需要传入 countpage参数分别表示每页数据的数据以及请求的页码,除此之外这两个网络请求都需要传入 一个Class对象表示响应的Json数据对应的Model,以便在内部使用Gson来解析,以及网络请求的异步回调 NetCallback

我们不直接使用OkHttp提供的Callback 而是在内部简单的做了封装转换成项目自己的NetCallback,因为对项目的开发人员来说,更希望的是能够直接在Callback的success回调中直接得到响应的Json数据对应的JavaBean.

本次提交详细代码:https://github.com/Knight-ZXW/MiniRetrofit/commit/8c5443b752bd85706b4290c0b54b35a13e58c4e2

思考项目现状

上文模拟的代码只是一个简单的例子,可能会有更好的封装方式,但这并不是我们这篇文章想要讨论的重点。我们回到示例中RestService类中的代码部分,看下目前网络请求的写法

因为我们项目中已经有了OKHttp这个网络库了,有关Http具体的连接及通信的脏话累活都可以交给他来处理,对于项目开发者,事实上我们只需要配置以下Http请求部分

  • 请求的url 地址
  • 请求的方式 (GET、POST、PUT…)
  • 请求内容

假设我们已经具备了 Java注解 以及 动态代理的相关知识,知道以下信息

  • 注解可以添加在方法上
  • Retention为RUNTIME的注解可以在虚拟机运行时也获取到注解上的信息
  • Java的动态代理可以运行时生成原接口类型的代理实现类并hook方法的调用

每一个网络接口调用请求的url地址和请求方式都是唯一的 ,那么对于一个简单的网络请求 我们能不能使用 注解 + 动态代理来简化这一过程,改为声明式的编程方式来实现网络调用,比如就像这样

/**
 * Created by zhuoxiuwu
 * on 2019/4/25
 * email nimdanoob@gmail.com
 */
public interface NetRestService {

    @GET("http://gank.io/api/today")
    public Call todayGank();
}

我们在一个抽象接口类中添加了一个方法,在方法上添加了注解**@GET** 表示这是一个Http GET请求的调用,注解中GET带的默认参数表示GET请求的地址。声明这个方法后,我们再通过Java动态代理技术在运行时解析这个方法上的注解的信息,内部通过调用OKHttp的相关方法生成一个 Call对象

有了大概思路了,我们接下来先简单的实现这样一个小例子来验证我们的想法是否可行

编码实现


3.1 简单实现一个支持GET、POST请求的Retrofit

新建一个注解类@GET

package retrofit2.http;

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


/**
 * Created by zhuoxiuwu
 * on 2019/4/25
 * email nimdanoob@gmail.com
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface GET {
    //注解中 方法名写成value 这样的话,在使用注解传入参数时就不用带key了,它会作为一个默认的调用
    String value();
}

新建一个处理Http接口类的动态代理的类Retrofit,因为我们实际网络请求的调用是依赖OKHttp,所以我们要求构造函数传入OkHttp对象 目前Retrofit 类只有一个方法publicT createService(final Classservice) 它接收一个抽象类,并生成该抽象类的代理实现。

package retrofit2;



import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import okhttp3.OkHttpClient;
import okhttp3.Request;
import retrofit2.http.GET;

public class Retrofit {

    private OkHttpClient mOkHttpClient;

    public Retrofit(OkHttpClient mOkHttpClient) {
        this.mOkHttpClient = mOkHttpClient;
    }

    @SuppressWarnings("unchecked")
    public <T> T createService(final Class<T> service) {
        return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[]{service},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method,
                                         Object[] args) throws Throwable {
                        //获取方法所有的注解
                        final Annotation[] annotations = method.getAnnotations();
                        for (int i = 0; i < annotations.length; i++) {
                            if (annotations[i] instanceof GET) { //如果注解是GET类型

                                final GET annotation = (GET) annotations[i];
                                final String url = annotation.value();
                                final Request request = new Request.Builder()
                                        .url(url)
                                        .get().build();
                                return mOkHttpClient.newCall(request);
                            }
                        }
                        return null;
                    }
                });
    }
}

目前我们主要的目标是为了验证这个方案的可行性,因此createService方法内部的逻辑很简单

1.获取方法上的所有注解

  //获取方法所有的注解
                        final Annotation[] annotations = method.getAnnotations();

2.判断如果存在@GET注解则获取注解内的值作为请求的地址

if (annotations[i] instanceof GET) { //如果注解是GET类型

    final GET annotation = (GET) annotations[i];
    final String url = annotation.value();

3.根据url构造GET请求的Request对象,并作为参数调用OkHttpClient的newCall方法生成Call对象作为该方法调用的返回值

 final Request request = new Request.Builder()
                                        .url(url)
                                        .get().build();
                                return mOkHttpClient.newCall(request);

以上完成了一个对@GET注解申明的Http请求的动态代理封装,下面我们在自己的项目中验证一下

3.2 在项目中验证

1.创建一个接口类,并添加一个方法,方法的返回类型为Call,方法是添加了@GET注解

package com.knight.sample;

import okhttp3.Call;
import retrofit2.http.GET;

/**
 * Created by zhuoxiuwu
 * on 2019/4/25
 * email nimdanoob@gmail.com
 */
public interface NetRestService {

    @GET("http://gank.io/api/today")
    public Call todayGank();
}

2.在项目中添加测试方法并调用

private void getToDayGankByRetrofit() {
        final Retrofit retrofit = new Retrofit(new OkHttpClient());
        retrofit.createService(NetRestService.class).todayGank().enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                JsonReader jsonReader = gson.newJsonReader(response.body().charStream());
                TodayGankResponse todayGankResponse = gson.getAdapter(TodayGankResponse.class).read(jsonReader);
                showHttpResult(todayGankResponse.toString());
                 Log.d("RetrofitTest","调用成功,结果为"+todayGankResponse.toString());
            }
        });
    }

运行之后,方法调用成功并得到了响应结果

 D/RetrofitTest: 调用成功,结果为BaseResponse(error=false, results={Android=[GankEntity(url=https://github.com/iqiyi/Neptune, desc=适用于Android的灵活,强大且轻量级的插件框架...

通过简单的一个实现,我们成功验证了使用注解加动态代理的方式实现一个声明式的网络请求框架是可行的,那么后续我们需要继续完善这个项目,提供对更多请求方式 以及参数的支持

对于其他请求方式的支持,我们可以添加更多的表示请求方式的注解,当用户设置了不同的注解,在内部我们使用OKHttp调用相应的方法。Http的请求方式大概如下

  • @DELETE
  • @GET
  • @HEAD
  • @PATCH
  • @POST
  • @PUT
  • @OPTIONS

3.3 继续实现POST注解

为了加深理解,我们继续简单的实现一个POST请求,并支持传入一个参数对象,作为POST请求的JSON数据

首先我们添加一个POST注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface POST {
    String value();
}
package retrofit2;


import com.google.gson.Gson;

import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;

import okhttp3.Call;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import retrofit2.http.GET;
import retrofit2.http.POST;

public class Retrofit {

    private OkHttpClient mOkHttpClient;

    public Retrofit(OkHttpClient mOkHttpClient) {
        this.mOkHttpClient = mOkHttpClient;
    }

    @SuppressWarnings("unchecked")
    public <T> T createService(final Class<T> service) {
        return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[]{service},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method,
                                         Object[] args) throws Throwable {
                        //获取方法所有的注解
                        final Annotation[] annotations = method.getAnnotations();

                        for (int i = 0; i < annotations.length; i++) {
                            if (annotations[i] instanceof GET) { //如果注解是GET类型
                                final GET annotation = (GET) annotations[i];
                                return parseGet(annotation.value(), method, args);
                            } else if (annotations[i] instanceof POST) {
                                final POST annotation = (POST) annotations[i];
                                return parsePost(annotation.value(), method, args);
                            }
                        }
                        return null;
                    }
                });
    }


    private Call parseGet(String url, Method method, Object args[]) {
        final Request request = new Request.Builder()
                .url(url)
                .get().build();
        return mOkHttpClient.newCall(request);
    }

    private Gson gson = new Gson();
    private static final MediaType MEDIA_TYPE = MediaType.get("application/json; charset=UTF-8");

    private Call parsePost(String url, Method method, Object args[]) {
        final Type[] genericParameterTypes = method.getGenericParameterTypes();
        if (genericParameterTypes.length > 0) {
            final Class<?> clazz = Utils.getRawType(genericParameterTypes[0]);
            final String jsonBody = gson.toJson(args[0], clazz);
            final Request request = new Request.Builder()
                    .url(url)
                    .post(RequestBody.create(MEDIA_TYPE, jsonBody))
                    .build();
            return mOkHttpClient.newCall(request);
        }
        return null;
    }


}

在 paresePost方法中我们首先通过Method的getGenericParameterTypes方法获取所有参数的Type类型,并且通过Type类获得参数的原始Class类型,之后就可以使用Gson转换成对应的Json对象了。

3.4 实现ConverterFactory 解耦Json转换

在上面的例子中,我们直接在框架Retrofit中使用了Gson库做Json转换,但作为一个框架来说 我们不希望直接强耦合一个第三方Json转换库,这部分更希望交由开发者根据具体情况自由选择;因此我们可以对这部分做下抽象封装,提取成一个负责Json转换的接口 由应用层传入具体的实现.

package retrofit2;

import java.lang.reflect.Type;

import javax.annotation.Nullable;

import okhttp3.RequestBody;

/**
 * Created by zhuoxiuwu
 * on 2019/4/25
 * email nimdanoob@gmail.com
 */
public interface Converter<F, T> {
    @Nullable
    T convert(F value);

    abstract class Factory {
        public @Nullable
        Converter<?, RequestBody> requestBodyConverter(Type type) {
            return null;
        }

    }
}

应用层需要传入一个ConverterFactory,该工厂类负责根据传入的Type类型,返回一个能够将该Type类型的对象转换成RequestBody的Converter

我们对Retrofit的构造函数以及paresePost方法做下修改,要求构造函数中传入一个ConverterFactory的实现,并在paresePost方法中使用这个ConverterFactory来做Java对象到ReqeustBody的转换

public class Retrofit {

    private OkHttpClient mOkHttpClient;

    private Converter.Factory mConverterFactory;

    public Retrofit(OkHttpClient mOkHttpClient, Converter.Factory mConverterFactory) {
        this.mOkHttpClient = mOkHttpClient;
        this.mConverterFactory = mConverterFactory;
    }
    //..省略部分代码

    private Call parsePost(String url, Method method, Object args[]) {
        final Type[] genericParameterTypes = method.getGenericParameterTypes();
        if (genericParameterTypes.length > 0) {
            //直接调用得到RequestBody
            final RequestBody requestBody = requestBodyConverter(genericParameterTypes[0]).convert(args[0]);
            final Request request = new Request.Builder()
                    .url(url)
                    .post(requestBody)
                    .build();
            return mOkHttpClient.newCall(request);
        }
        return null;
    }


    public <T> Converter<T, RequestBody> requestBodyConverter(Type type) {
        return (Converter<T, RequestBody>) mConverterFactory.requestBodyConverter(type);
    }

在应用层,我们实现并传入一个Gson的ConvertFactory的实现

package com.knight.sample;

import com.google.gson.Gson;
import com.google.gson.TypeAdapter;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonWriter;

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.lang.reflect.Type;
import java.nio.charset.Charset;

import okhttp3.MediaType;
import okhttp3.RequestBody;
import okio.Buffer;
import retrofit2.Converter;

/**
 * Created by zhuoxiuwu
 * on 2019/4/25
 * email nimdanoob@gmail.com
 */
public class GsonConverterFactory extends Converter.Factory {
    public static GsonConverterFactory create() {
        return create(new Gson());
    }

    public static GsonConverterFactory create(Gson gson) {
        if (gson == null) throw new NullPointerException("gson == null");
        return new GsonConverterFactory(gson);
    }

    private final Gson gson;

    private GsonConverterFactory(Gson gson) {
        this.gson = gson;
    }

    @Override
    public Converter<?, RequestBody> requestBodyConverter(Type type) {
        //通过Type 转换成Gson的TypeAdapter
        //具体类型的json转换依赖于这个TypeAdapter
        TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
        return new GsonRequestBodyConverter<>(gson, adapter);

    }


    final static class GsonRequestBodyConverter<T> implements Converter<T, RequestBody> {
        private static final MediaType MEDIA_TYPE = MediaType.get("application/json; charset=UTF-8");
        private static final Charset UTF_8 = Charset.forName("UTF-8");

        private final Gson gson;
        private final TypeAdapter<T> adapter;

        GsonRequestBodyConverter(Gson gson, TypeAdapter<T> adapter) {
            this.gson = gson;
            this.adapter = adapter;
        }

        @Override
        public RequestBody convert(T value) {
            Buffer buffer = new Buffer();
            Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
            JsonWriter jsonWriter = null;
            try {
                jsonWriter = gson.newJsonWriter(writer);
                adapter.write(jsonWriter, value);
                jsonWriter.close();
                return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
            } catch (IOException e) {
                e.printStackTrace();
                return null;
            }

        }
    }

}

3.5 实现CallAdapter 支持方法返回类型

继续回到Http请求的声明中,目前我们方法所支持的返回类型都是OKHttp的Call对象,而Call对象从使用上来说,目前还是有些繁琐,原生的Call对象返回的是ResponseBody还需要开发者自己处理并做转换。

public interface NetRestService {

    @GET("http://gank.io/api/today")
    public Call todayGank();
}

也许我们希望这个方法可以这样定义

public interface NetRestService {

    @GET("http://gank.io/api/today")
    public TodayGankResponse todayGank();
}

也许我们可以在框架内部通过判断方法的返回类型是不是Call对象,如果不是,就在框架内部直接同步调用网络请求得到响应的Json内容后直接转换成JavaBean对象作为方法的返回值,但是这个设想存在这样几个问题

  1. 要实现直接返回Http结果则方法调用是同步调用,如果在主线程做IO请求肯定是不合理的
  2. 如果内部IO异常了,或者JSON转换失败了方法返回的是什么呢?为null吗?

因此更合理的话,在应用我们希望的是返回一个包装的支持异步调用的类型

比如我们的项目自己新增了一个支持异步调用的NetCall抽象接口

/**
 * Created by zhuoxiuwu
 * on 2019/4/26
 * email nimdanoob@gmail.com
 */
public interface NetCall<T> {
    public void execute(NetCallback<T> netCallback);
}

我们希望我们的方法可以这样申明

public interface NetRestService {

    @GET("http://gank.io/api/today")
    public NetCall<TodayGankResponse> todayGank();
}

这样的话在应用层我们调用的时候就可以像这样使用

        retrofit.createService(NetRestService.class).todayGank()
                .execute(new NetCallback<TodayGankResponse>() {
                    @Override
                    public void onFailure(Exception e) {

                    }

                    @Override
                    public void onSuccess(TodayGankResponse data) {
                        Log.d("RetrofitTest","调用成功,结果为"+data.toString());
                        showHttpResult(data.toString());
                    }
                });

那么具体要怎么实现呢,这个功能相当于让Retrofit框架支持 对方法返回类型的自定义适配,和Converter接口一样的思路,我们在框架可以定义一个 CallAdapter接口,让应用层来具体实现并传入

package retrofit2;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import okhttp3.Call;

/**
 * Created by zhuoxiuwu
 * on 2019/4/26
 * email nimdanoob@gmail.com
 */
public interface CallAdapter<T> {

    T adapt(Call call);


    abstract class Factory {

        public abstract CallAdapter<?> get(Type returnType,Retrofit retrofit);

        /**
         * 这是一个框架提供给开发者的util方法
         * 用于获取类型的泛型上的类型
         * 比如 Call<Response> 则 第0个泛型是Response.class
         */
        protected static Type getParameterUpperBound(int index, ParameterizedType type) {
            return Utils.getParameterUpperBound(index, type);
        }

        /**
         * 获取Type对应的Class
         * @param type
         * @return
         */
        protected static Class<?> getRawType(Type type) {
            return Utils.getRawType(type);
        }
    }
}

在应用层我们可以实现一个NetCallAdapter,支持Call对象到 NetCall对象的转换

package com.knight.sample;

import java.io.IOException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.Response;
import retrofit2.CallAdapter;
import retrofit2.Retrofit;

/**
 * Created by zhuoxiuwu
 * on 2019/4/26
 * email nimdanoob@gmail.com
 */
package com.knight.sample;

import java.io.IOException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.Response;
import retrofit2.CallAdapter;
import retrofit2.Retrofit;

/**
 * Created by zhuoxiuwu
 * on 2019/4/26
 * email nimdanoob@gmail.com
 */
public class NetCallAdapterFactory extends CallAdapter.Factory {

    /**
     * returnType参数 和 retroift参数 由底层框架传递给开发者
     * @param returnType
     * @param retrofit
     * @return
     */
    @Override
    public CallAdapter<?> get(final Type returnType, final Retrofit retrofit) {
        //判断返回类型是否是 NetCall
        if (getRawType(returnType) != NetCall.class) {
            return null;
        }
        //要求开发者方法的返回类型必须写成 NetCall<T> 或者NetCall<? extends Foo> 的形式,泛型内的类型就是Json数据对应的Class
        if (!(returnType instanceof ParameterizedType)) {
            throw new IllegalStateException(
                    "NetCall return type must be parameterized as NetCall<Foo> or NetCall<? extends Foo>");
        }
        final Type innerType = getParameterUpperBound(0, (ParameterizedType) returnType);

        return new CallAdapter<NetCall>() {

            @Override
            public NetCall adapt(final Call call) {

                return new NetCall() {
                    @Override
                    public void execute(final NetCallback netCallback) {
                        call.enqueue(new Callback() {
                            @Override
                            public void onFailure(Call call, IOException e) {
                                netCallback.onFailure(e);
                            }

                            @Override
                            public void onResponse(Call call, Response response) throws IOException {
                                //由retrofit 提供 ResponseBody 到 某个Type Class的转换
                                final Object value = retrofit.responseBodyTConverter(innerType).convert(response.body());
                                netCallback.onSuccess(value);
                            }
                        });
                    }
                };
            }
        };
    }
}

框架的后续实现及优化

到目前为止我们已经实现了一个简单的Retrofit框架,也许代码不够精简,边界处理没有十分严谨,但已经初具雏形。我们可以继续思考现有项目的不足,添加更多的支持。

比如在网络请求方面目前只支持GET、POST,那么我们后续需要添加更多请求方式的支持。

以上提出的一些优化点,大家可以自己先思考实现并重新阅读写Retrofit源码来加深自己的理解。从整个思考流程及实现上来看Retrofit的实现并不复杂,但是从实现一个简单可用的网络封装库到实现一个拓展性强、职责分离的框架,中间的过程还是有很多细节的,如果你看完了这篇文章,可以再抽1个小时左右的时间重新看下Retorift框架的源码,相信从中还会有更多的收获。

更多Android进阶指南 可以扫码 解锁 《Android十大板块文档》

1.Android车载应用开发系统学习指南(附项目实战)

2.Android Framework学习指南,助力成为系统级开发高手

3.2023最新Android中高级面试题汇总+解析,告别零offer

4.企业级Android音视频开发学习路线+项目实战(附源码)

5.Android Jetpack从入门到精通,构建高质量UI界面

6.Flutter技术解析与实战,跨平台首要之选

7.Kotlin从入门到实战,全方面提升架构基础

8.高级Android插件化与组件化(含实战教程和源码)

9.Android 性能优化实战+360°全方面性能调优

10.Android零基础入门到精通,高手进阶之路

敲代码不易,关注一下吧。ღ( ´・ᴗ・` ) 🤔

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/842242.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

关于echarts遇到的一些问题

1.echarts监听legend&#xff0c;动态设置legend属性无效 动态更改legend中的icon&#xff0c; myChart.setOption(option&#xff09;失效&#xff0c;但是设置局部就生效 myChart.on(legendselectchanged, function (params) {if (params.selected[params.name]) {data1[dat…

SSM项目-博客系统

在线体验项目&#xff1a;登陆页面 项目连接&#xff1a;huhublog_ssm: 个人博客系统 技术栈&#xff1a;SpringBoot、SpringMVC、Mybatis、Redis、JQuery、Ajax、Json (gitee.com) 1.项目技术点分析 SpringBoot、SpringWeb(SpringMVC)、MyBatis、MySQL(8.x)、Redis(存储验…

Elastic的下载

文章目录 ElasticSearch的下载扩展1&#xff08;ElasticSearch 与 JDK 版本 适配&#xff09;扩展2&#xff08;访问 http://192.168.1.200:9200 没有显示信息&#xff09;扩展3&#xff08;免密登录&#xff09; ElasticSearch的下载 官方下载网址&#xff1a;https://www.el…

antd design 多个弹框设置区分状态的技巧

可以使用 enum 枚举的方式去做区分 // 置管状态区分 // eslint-disable-next-line no-shadow export enum catheteringType {ADD add,EDIT edit,EXAMINE examine, } 引入上述代码接着设置状态 // 置管记录弹框/状态区分const [catheteringModalTypeConfig, setCatheterin…

全志D1-H (MQ-Pro)驱动 OV5640 摄像头

内核配置 运行 m kernel_menuconfig 勾选下列驱动 Device Drivers ---><*> Multimedia support --->[*] V4L platform devices ---><*> Video Multiplexer[*] SUNXI platform devices ---><*> sunxi video input (camera csi/mipi…

DP与EDP接口协议学习

文章目录 一、概念介绍DP----DisplayPort&#xff0c;一种标准化数字式视频接口&协议EDP---Embedded DisplayPort&#xff0c;DP协议在嵌入式领域拓展DP和HDMI对比----HDMI当前应用更广&#xff0c;DP是PC领域推出协议 二、DP&EDP相关协议分析三条数据通路Manlink 、Au…

赛码网-打字100%AC代码(C语言)

———————————————————————————————————— ⏩ 大家好哇&#xff01;我是小光&#xff0c;嵌入式爱好者&#xff0c;一个想要成为系统架构师的大三学生。 ⏩最近在准备秋招&#xff0c;一直在练习编程。 ⏩本篇文章对赛码网的打字题目做一个详…

ViSQOL、PESQ、mosnet等mos分打分工具和Polqa语音感知音质打分测评

原创&#xff1a;转载需附链接&#xff1a; https://blog.csdn.net/qq_37100442/article/details/132057139?spm1001.2014.3001.5502 一、背景 Mos分评价音质重要指标&#xff0c;最近也有很多机构和公司在研究适合自己的评价体系。目前Mos分主要分为主观评测和客观感知评价。…

49. 海豚记账簿软件(b站的一个小项目)

闲着也是闲着就跟着别人做了一个小项目 目录 1.需求和目标 2.整体功能描述 3.核心思路 4.全部代码 1.需求和目标 项目的需求&#xff0c;实现一个叫做“海豚记账簿”的基于命令行界面的家庭记账软件。 2.整体功能描述 这个软件相对简单&#xff0c;只需要基于命令行做纯…

【数据结构OJ题】移除元素

原题链接&#xff1a;https://leetcode.cn/problems/remove-element/ 目录 1. 题目描述 2. 思路分析 3. 代码实现 1. 题目描述 2. 思路分析 方法一&#xff1a;暴力删除&#xff0c;挪动数据覆盖。即遍历整个nums[ ]数组&#xff0c;遇到值等于val的元素&#xff0c;就将整…

Eclipse如何自动添加作者、日期等注释

一、创建类时自动添加注释 1、Window->Preferences 2、Java->Code Syle->Code Templates->Code->New Java files->Edit->要添加的注释->Apply 二、选中要添加的类或者方法通过AltShiftJ快捷键添加 1、Window->Preferences 2、Java->Code Syle…

IP地址、网关、子网掩码

通过SSH将Ubuntu的盘映射到Windows下面去&#xff0c;以及在VsCode通过SSH Server或者在MobaXterm中通过SSH连接到远程ubuntu服务器&#xff0c;但由于之前Ubuntu的网络是自动连接的&#xff0c;IPv4经常会改变&#xff0c;就会导致上述三个远程连接都需要重新配置。 故由DHCP自…

ETHERCAT转PROFIBUS网关连接安川伺服支持EtherCAT总线吗

捷米JM-DP-ECT&#xff0c;是自主研发的一款PROFIBUS从站功能的通讯网关&#xff0c;它的主要功能是将ETHERCAT设备接入到PROFIBUS网络中。 JM-DP-ECT这个小小的网关可不简单&#xff0c;连接到PROFIBUS总线中做为从站使用&#xff0c;连接到ETHERCAT总线中做为从站使用。 1.2…

DAY03_Spring—SpringAOPAOP切入点表达式AOP通知类型Spring事务管理

目录 一 AOP1 AOP简介问题导入1.1 AOP简介和作用1.2 AOP中的核心概念 2 AOP入门案例问题导入2.1 AOP入门案例思路分析2.2 AOP入门案例实现【第一步】导入aop相关坐标【第二步】定义dao接口与实现类【第三步】定义通知类&#xff0c;制作通知方法【第四步】定义切入点表达式、配…

kafka-保证数据不重复-生产者开启幂等性和事务的作用?

1. 生产者开启幂等性为什么能去重&#xff1f; 1.1 场景 适用于消息在写入到服务器日志后&#xff0c;由于网络故障&#xff0c;生产者没有及时收到服务端的ACK消息&#xff0c;生产者误以为消息没有持久化到服务端&#xff0c;导致生产者重复发送该消息&#xff0c;造成了消…

SpringMVC -- REST风格开发,RESTful快速开发、RESTful注解开发

&#x1f40c;个人主页&#xff1a; &#x1f40c; 叶落闲庭 &#x1f4a8;我的专栏&#xff1a;&#x1f4a8; c语言 数据结构 javaweb 石可破也&#xff0c;而不可夺坚&#xff1b;丹可磨也&#xff0c;而不可夺赤。 REST 一、REST简介1.1REST风格简介 二、RESTful入门案例2.…

SpringBoot集成Logback日志

SpringBoot集成Logback日志 文章目录 SpringBoot集成Logback日志一、什么是日志二、Logback简单介绍三、SpringBoot项目中使用Logback四、概念介绍一、日志记录器Logger1.1、日志记录器对象生成1.2、记录器的层级结构1.3、过滤器1.4、logger设置日志级别1.5、java代码演示1.6、…

【资料分享】全志科技T507-H工业核心板规格书

1 核心板简介 创龙科技SOM-TLT507是一款基于全志科技T507-H处理器设计的4核ARM Cortex-A53全国产工业核心板&#xff0c;主频高达1.416GHz。核心板CPU、ROM、RAM、电源、晶振等所有元器件均采用国产工业级方案&#xff0c;国产化率100%。 核心板通过邮票孔连接方式引出MIPI C…

防火墙第四次作业

1. 什么是IDS&#xff1f; IDS是&#xff1a;入侵检测系统&#xff08;intrusion detection system&#xff0c;简称“IDS”&#xff09;是一种对网络传输进行即时监视&#xff0c;在发现可疑传输时发出警报或者采取主动反应措施的网络安全设备。它与其他网络安全设备的不同之…

K8s中的核心技术Helm

1.helm的引入 &#xff08;1&#xff09;编写yaml文件 &#xff08;2&#xff09;编写deployment文件 &#xff08;3&#xff09;编写service文件 &#xff08;4&#xff09;编写Ingress文件 2.helm的引入解决的问题&#xff1f; &#xff08;1&#xff09;使用helm可以把…