qq_27620587
qq_27620587

Retrofit核心类分析和调用流程源码分析

基于retrofit2.1.0

核心类介绍
ParameterHandler      解析方法参数的注解获取他们信息，然后调用转换器，然后设置到RequestBuilder
不同的注解有不同的ParameterHandler      实现

Converter    转换器接口，我们自定义一些实现，可以通过它自定义，进行请求参数数据转换，相应参数自定义解析，还有设置数据，把数据转化为String

Converter.Factory 
核心方法：responseBodyConverter                    根据adapter中的ResponseType，类型来解析数据
    requestBodyConverter    Body ，PartMap，Part方法参数中的这三个注解，都是需要把数据，转化为RequestBody类型的
    stringConverter    //把各种类型的数据转化为String,主要用在，对于方法的请求参数，的注解的数据类型进行转换，转换为String,然后设置到RequestBuilder

ServiceMethod：指责很多
        1.获取方法和参数的注解
        2.根据adapter返回值的类型，和根据参数的类型获取就行的Converter.Factory ，创建对应的Converter  
        3.然后解析方法的注解，解析参数的注解（ParameterHandler），很多都要依赖Converter  ，
        4.根据解析的数据，配合ParameterHandler，创建RequestBuilder
        5.创建请求Request
        6.使用responseBodyConverter解析请求
CallAdapter.Factory：根据定义的接口中返回的类型，返回指定的Factory
        可以把Call转化为任意的返回值，让我们以自定义的方式，触发请求，并且可以自定义对相应的统一处理，然后给出自定义的回调。

 

 

方法参数注解概述

Query   设置查询参数，key=value

Path     用来替换相对路径中的值

Url      再参数中设置相对路径

QueryMap    设置多个查询参数，设置一个map子类   ，并且key必须要是String,value的值不限制，但是要负责转化为String

Header  添加请求头

HeaderMap   设置多个请求头，设置一个map子类   ，并且key必须要是String,value的值不限制，但是要负责转化为String

Field     添加表单字段     type 也是可以是任意类型，只要可以转换为String 就可以

FieldMap    添加多个表单字段，key必须为String ,value可以是任意类型

Part             请求Multipart下的一个请求体，和请求头，如果设置了value,就不要使用Okhttp的Part，如果没有设置，就必须要是Okhttp的Part

PartMap      上面的请求的Map形式

Body  直接设置给请求体，需要我们自定义ReuqestBody转换器


上面的注解涵盖了Http请求的各个部分，我们可以通过这些注解标识数据，然后设置他们，并且Retrofit做的非常好的是，只是用注解标识数据再http中的位置，但是注解标识的数据类型，不做限制，可以是任意数据类型，然后我们只要设置对应类型的的数据转换器，就可以了，极大的提高了扩展性，再后面方法参数解析为ParameterHandler的步骤会体现。

 

        
代码流程分析
    Retrofit retrofit = new Retrofit.Builder()
        .baseUrl(NetConfiguration.getInstance().getBaseUrl())//设置BaseUrl
        .addConverterFactory(GsonConverterFactory.create(gson))//添加转换器工厂
        .addCallAdapterFactory(new ExecutorCallAdapterFactory1())//添加CallAdapter工厂
        .client(getGenericClient())//设置CallFactory
        .callbackExecutor(null)//设置CallBack执行的线程，可以再主线程或者子线程，再测试的时候很有用
        .build();
->构建Retrofit   
-》retrofit.create(clazz);
  public T create(final Class service) {
    Utils.validateServiceInterface(service);                   //检查接口是否合法，不能有继承接口
    if (validateEagerly) {//是否提前解析每一个方法，默认是false,可以再构建的时候设置，会占用内存，但是会提高执行请求的效率
      eagerlyValidateMethods(service);                       //会在内部把Method解析成ServiceMethod
    }
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class[] { service },               //为接口生成动态代理类
        new InvocationHandler() {
          private final Platform platform = Platform.get();

          @Override public Object invoke(Object proxy, Method method, Object... args)
              throws Throwable {
            // If the method is a method from Object then defer to normal invocation.
            if (method.getDeclaringClass() == Object.class) {           //如果类是Object定义的，就原样执行
              return method.invoke(this, args);
            }
            if (platform.isDefaultMethod(method)) {//根据平台特性判断，如果是默认方法，就调用对应平台的执行方式
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            ServiceMethod serviceMethod = loadServiceMethod(method);//根据Method信息构建ServiceMethod ，核心类，一会具体分析
            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);//实现Call,内部会使用serviceMethod，来生成request,并且解析相应
            return serviceMethod.callAdapter.adapt(okHttpCall);//调用callAdapter,再适配返回值类型，返回执行类型
          }
        });
  }
分析个对象的构建
-》  ServiceMethod serviceMethod = loadServiceMethod(method);
ServiceMethod loadServiceMethod(Method method) {
    ServiceMethod result;
    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);//从缓存中获取，缓存可以太高效率
      if (result == null) {
        result = new ServiceMethod.Builder(this, method).build();//如果没有重新构建
        serviceMethodCache.put(method, result);//并且放入缓存
      }
    }
    return result;
  }
-》 new ServiceMethod.Builder(this, method).build();
-》 new ServiceMethod.Builder(this, method)
    public Builder(Retrofit retrofit, Method method) {
      this.retrofit = retrofit;
      this.method = method;
      this.methodAnnotations = method.getAnnotations();//获取方法的注解
      this.parameterTypes = method.getGenericParameterTypes();//获取方法参数数组
      this.parameterAnnotationsArray = method.getParameterAnnotations();//获取方法参数对应位置的注解，二维数组
    }
-》  public ServiceMethod build()
    public ServiceMethod build() {
      callAdapter = createCallAdapter();//根据接口中定义的返回值类型，从Factory中寻找合适的CallAdapter
      responseType = callAdapter.responseType();//CallAdapter，返回，按照这个类型来解析http的相应
      if (responseType == Response.class || responseType == okhttp3.Response.class) {
        throw methodError("'"
            + Utils.getRawType(responseType).getName()
            + "' is not a valid response body type. Did you mean ResponseBody?");
      }
      responseConverter = createResponseConverter();//根据responseType 返回解析ResponBody的responseConverter

      for (Annotation annotation : methodAnnotations) {//遍历方法的注解，然后解析方法的注解，参数保存到Builder
        parseMethodAnnotation(annotation);//解析方法注解
      }

      if (httpMethod == null) {
        throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");
      }

      if (!hasBody) {
        if (isMultipart) {
          throw methodError(
              "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
        }
        if (isFormEncoded) {
          throw methodError("FormUrlEncoded can only be specified on HTTP methods with "
              + "request body (e.g., @POST).");
        }
      }

      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler[parameterCount];//每一个 parameterHandler负责设置对应注解的相关类型到RequestBuiler，保存了所有的参数的设置器
      for (int p = 0; p < parameterCount; p++) {
        Type parameterType = parameterTypes[p];
        if (Utils.hasUnresolvableType(parameterType)) {
          throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
              parameterType);
        }

        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
        if (parameterAnnotations == null) {
          throw parameterError(p, "No Retrofit annotation found.");
        }

        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);//感觉注解类型生成对应的参数设置器
      }

      if (relativeUrl == null && !gotUrl) {
        throw methodError("Missing either @%s URL or @Url parameter.", httpMethod);
      }
      if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
        throw methodError("Non-body HTTP method cannot contain @Body.");
      }
      if (isFormEncoded && !gotField) {
        throw methodError("Form-encoded method must contain at least one @Field.");
      }
      if (isMultipart && !gotPart) {
        throw methodError("Multipart method must contain at least one @Part.");
      }

      return new ServiceMethod<>(this);//把解析的参数设置到ServiceMethod
    }

-》 createCallAdapter();
  private CallAdapter createCallAdapter() {
      Type returnType = method.getGenericReturnType();
      if (Utils.hasUnresolvableType(returnType)) {
        throw methodError(
            "Method return type must not include a type variable or wildcard: %s", returnType);
      }
      if (returnType == void.class) {
        throw methodError("Service methods cannot return void.");
      }
      Annotation[] annotations = method.getAnnotations();
      try {
        return retrofit.callAdapter(returnType, annotations);//根据返回值类型，返回CallAdapter
      } catch (RuntimeException e) { // Wide exception range because factories are user code.
        throw methodError(e, "Unable to create call adapter for %s", returnType);
      }
    }
-》 createResponseConverter();
    private Converter createResponseConverter() {
      Annotation[] annotations = method.getAnnotations();
      try {
        return retrofit.responseBodyConverter(responseType, annotations);//根据返回值类型创建这个返回执行的，相应解析器
      } catch (RuntimeException e) { // Wide exception range because factories are user code.
        throw methodError(e, "Unable to create converter for %s", responseType);
      }
    }

-》parseMethodAnnotation(Annotation annotation)
 private void parseMethodAnnotation(Annotation annotation) {//根绝注解类型，解析方法上的注解
      if (annotation instanceof DELETE) {
        parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
      } else if (annotation instanceof GET) {
        parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
      } else if (annotation instanceof HEAD) {
        parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
        if (!Void.class.equals(responseType)) {
          throw methodError("HEAD method must use Void as response type.");
        }
      } else if (annotation instanceof PATCH) {
        parseHttpMethodAndPath("PATCH", ((PATCH) annotation).value(), true);
      } else if (annotation instanceof POST) {
        parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
      } else if (annotation instanceof PUT) {
        parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
      } else if (annotation instanceof OPTIONS) {
        parseHttpMethodAndPath("OPTIONS", ((OPTIONS) annotation).value(), false);
      } else if (annotation instanceof HTTP) {
        HTTP http = (HTTP) annotation;
        parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
      } else if (annotation instanceof retrofit2.http.Headers) {
        String[] headersToParse = ((retrofit2.http.Headers) annotation).value();
        if (headersToParse.length == 0) {
          throw methodError("@Headers annotation is empty.");
        }
        headers = parseHeaders(headersToParse);
      } else if (annotation instanceof Multipart) {
        if (isFormEncoded) {
          throw methodError("Only one encoding annotation is allowed.");
        }
        isMultipart = true;
      } else if (annotation instanceof FormUrlEncoded) {
        if (isMultipart) {
          throw methodError("Only one encoding annotation is allowed.");
        }
        isFormEncoded = true;
      }
    }
-》parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody)//设置解析的请求方法，并且设置相对url
private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
      if (this.httpMethod != null) {
        throw methodError("Only one HTTP method is allowed. Found: %s and %s.",
            this.httpMethod, httpMethod);
      }
      this.httpMethod = httpMethod;
      this.hasBody = hasBody;

      if (value.isEmpty()) {
        return;
      }

      // Get the relative URL path and existing query string, if present.
      int question = value.indexOf('?');
      if (question != -1 && question < value.length() - 1) {
        // Ensure the query string does not have any named parameters.
        String queryParams = value.substring(question + 1);
        Matcher queryParamMatcher = PARAM_URL_REGEX.matcher(queryParams);
        if (queryParamMatcher.find()) {
          throw methodError("URL query string \"%s\" must not have replace block. "
              + "For dynamic query parameters use @Query.", queryParams);
        }
      }

      this.relativeUrl = value;
      this.relativeUrlParamNames = parsePathParameters(value);
    }
-》        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
 private ParameterHandler parseParameter(
        int p, Type parameterType, Annotation[] annotations) {
      ParameterHandler result = null;
      for (Annotation annotation : annotations) {//遍历方法的参数和注解，然后解析出对应的参数设置器
        ParameterHandler annotationAction = parseParameterAnnotation(
            p, parameterType, annotations, annotation);//根据注解，解析出对应的参数设置器

        if (annotationAction == null) {
          continue;
        }

        if (result != null) {
          throw parameterError(p, "Multiple Retrofit annotations found, only one allowed.");
        }

        result = annotationAction;
      }

      if (result == null) {
        throw parameterError(p, "No Retrofit annotation found.");
      }

      return result;
    }
-》 parseParameterAnnotation(
            p, parameterType, annotations, annotation);//各注解解析类似，我们只分析一个
 private ParameterHandler parseParameterAnnotation(
        int p, Type type, Annotation[] annotations, Annotation annotation) {
      if (annotation instanceof Url) {
        if (gotUrl) {
          throw parameterError(p, "Multiple @Url method annotations found.");
        }
        if (gotPath) {
          throw parameterError(p, "@Path parameters may not be used with @Url.");
        }
        if (gotQuery) {
          throw parameterError(p, "A @Url parameter must not come after a @Query");
        }
        if (relativeUrl != null) {
          throw parameterError(p, "@Url cannot be used with @%s URL", httpMethod);
        }

        gotUrl = true;

        if (type == HttpUrl.class
            || type == String.class
            || type == URI.class
            || (type instanceof Class && "android.net.Uri".equals(((Class) type).getName()))) {
          return new ParameterHandler.RelativeUrl();
        } else {
          throw parameterError(p,
              "@Url must be okhttp3.HttpUrl, String, java.net.URI, or android.net.Uri type.");
        }

      } else if (annotation instanceof Path) {
        if (gotQuery) {
          throw parameterError(p, "A @Path parameter must not come after a @Query.");
        }
        if (gotUrl) {
          throw parameterError(p, "@Path parameters may not be used with @Url.");
        }
        if (relativeUrl == null) {
          throw parameterError(p, "@Path can only be used with relative url on @%s", httpMethod);
        }
        gotPath = true;

        Path path = (Path) annotation;
        String name = path.value();
        validatePathName(p, name);

        Converter converter = retrofit.stringConverter(type, annotations);
        return new ParameterHandler.Path<>(name, converter, path.encoded());

      } else if (annotation instanceof Query) {
        Query query = (Query) annotation;//获取注解
        String name = query.value();//返回注解的值
        boolean encoded = query.encoded();//是否需要url编码

        Class rawParameterType = Utils.getRawType(type);//获取主类型
        gotQuery = true;
        if (Iterable.class.isAssignableFrom(rawParameterType)) {//判断是否传递的是一个迭代器类型
          if (!(type instanceof ParameterizedType)) {//如果传递了迭代器类型，就一定要传递泛型的具体类型，否则报错，因为要设置数据，所以必须要是具体类型
            throw parameterError(p, rawParameterType.getSimpleName()
                + " must include generic type (e.g., "
                + rawParameterType.getSimpleName()
                + ")");
          }
          ParameterizedType parameterizedType = (ParameterizedType) type;
          Type iterableType = Utils.getParameterUpperBound(0, parameterizedType);
          Converter converter =
              retrofit.stringConverter(iterableType, annotations);//对迭代器中的类型，调用stringConvert转化为String类型
          return new ParameterHandler.Query<>(name, converter, encoded).iterable();//内部会迭代执行，把数据设置到RequestBuilder
        } else if (rawParameterType.isArray()) {
          Class arrayComponentType = boxIfPrimitive(rawParameterType.getComponentType());
          Converter converter =
              retrofit.stringConverter(arrayComponentType, annotations);
          return new ParameterHandler.Query<>(name, converter, encoded).array();
        } else {
          Converter converter =
              retrofit.stringConverter(type, annotations);
          return new ParameterHandler.Query<>(name, converter, encoded);
        }

      } else if (annotation instanceof QueryMap) {
        Class rawParameterType = Utils.getRawType(type);
        if (!Map.class.isAssignableFrom(rawParameterType)) {
          throw parameterError(p, "@QueryMap parameter type must be Map.");
        }
        Type mapType = Utils.getSupertype(type, rawParameterType, Map.class);
        if (!(mapType instanceof ParameterizedType)) {
          throw parameterError(p, "Map must include generic types (e.g., Map)");
        }
        ParameterizedType parameterizedType = (ParameterizedType) mapType;
        Type keyType = Utils.getParameterUpperBound(0, parameterizedType);
        if (String.class != keyType) {
          throw parameterError(p, "@QueryMap keys must be of type String: " + keyType);
        }
        Type valueType = Utils.getParameterUpperBound(1, parameterizedType);
        Converter valueConverter =
            retrofit.stringConverter(valueType, annotations);

        return new ParameterHandler.QueryMap<>(valueConverter, ((QueryMap) annotation).encoded());

      } else if (annotation instanceof Header) {
        Header header = (Header) annotation;
        String name = header.value();

        Class rawParameterType = Utils.getRawType(type);
        if (Iterable.class.isAssignableFrom(rawParameterType)) {
          if (!(type instanceof ParameterizedType)) {
            throw parameterError(p, rawParameterType.getSimpleName()
                + " must include generic type (e.g., "
                + rawParameterType.getSimpleName()
                + ")");
          }
          ParameterizedType parameterizedType = (ParameterizedType) type;
          Type iterableType = Utils.getParameterUpperBound(0, parameterizedType);
          Converter converter =
              retrofit.stringConverter(iterableType, annotations);
          return new ParameterHandler.Header<>(name, converter).iterable();
        } else if (rawParameterType.isArray()) {
          Class arrayComponentType = boxIfPrimitive(rawParameterType.getComponentType());
          Converter converter =
              retrofit.stringConverter(arrayComponentType, annotations);
          return new ParameterHandler.Header<>(name, converter).array();
        } else {
          Converter converter =
              retrofit.stringConverter(type, annotations);
          return new ParameterHandler.Header<>(name, converter);
        }

      } else if (annotation instanceof HeaderMap) {
        Class rawParameterType = Utils.getRawType(type);
        if (!Map.class.isAssignableFrom(rawParameterType)) {
          throw parameterError(p, "@HeaderMap parameter type must be Map.");
        }
        Type mapType = Utils.getSupertype(type, rawParameterType, Map.class);
        if (!(mapType instanceof ParameterizedType)) {
          throw parameterError(p, "Map must include generic types (e.g., Map)");
        }
        ParameterizedType parameterizedType = (ParameterizedType) mapType;
        Type keyType = Utils.getParameterUpperBound(0, parameterizedType);
        if (String.class != keyType) {
          throw parameterError(p, "@HeaderMap keys must be of type String: " + keyType);
        }
        Type valueType = Utils.getParameterUpperBound(1, parameterizedType);
        Converter valueConverter =
            retrofit.stringConverter(valueType, annotations);

        return new ParameterHandler.HeaderMap<>(valueConverter);

      } else if (annotation instanceof Field) {
        if (!isFormEncoded) {
          throw parameterError(p, "@Field parameters can only be used with form encoding.");
        }
        Field field = (Field) annotation;
        String name = field.value();
        boolean encoded = field.encoded();

        gotField = true;

        Class rawParameterType = Utils.getRawType(type);
        if (Iterable.class.isAssignableFrom(rawParameterType)) {
          if (!(type instanceof ParameterizedType)) {
            throw parameterError(p, rawParameterType.getSimpleName()
                + " must include generic type (e.g., "
                + rawParameterType.getSimpleName()
                + ")");
          }
          ParameterizedType parameterizedType = (ParameterizedType) type;
          Type iterableType = Utils.getParameterUpperBound(0, parameterizedType);
          Converter converter =
              retrofit.stringConverter(iterableType, annotations);
          return new ParameterHandler.Field<>(name, converter, encoded).iterable();
        } else if (rawParameterType.isArray()) {
          Class arrayComponentType = boxIfPrimitive(rawParameterType.getComponentType());
          Converter converter =
              retrofit.stringConverter(arrayComponentType, annotations);
          return new ParameterHandler.Field<>(name, converter, encoded).array();
        } else {
          Converter converter =
              retrofit.stringConverter(type, annotations);
          return new ParameterHandler.Field<>(name, converter, encoded);
        }

      } else if (annotation instanceof FieldMap) {
        if (!isFormEncoded) {
          throw parameterError(p, "@FieldMap parameters can only be used with form encoding.");
        }
        Class rawParameterType = Utils.getRawType(type);
        if (!Map.class.isAssignableFrom(rawParameterType)) {
          throw parameterError(p, "@FieldMap parameter type must be Map.");
        }
        Type mapType = Utils.getSupertype(type, rawParameterType, Map.class);
        if (!(mapType instanceof ParameterizedType)) {
          throw parameterError(p,
              "Map must include generic types (e.g., Map)");
        }
        ParameterizedType parameterizedType = (ParameterizedType) mapType;
        Type keyType = Utils.getParameterUpperBound(0, parameterizedType);
        if (String.class != keyType) {
          throw parameterError(p, "@FieldMap keys must be of type String: " + keyType);
        }
        Type valueType = Utils.getParameterUpperBound(1, parameterizedType);
        Converter valueConverter =
            retrofit.stringConverter(valueType, annotations);

        gotField = true;
        return new ParameterHandler.FieldMap<>(valueConverter, ((FieldMap) annotation).encoded());

      } else if (annotation instanceof Part) {
        if (!isMultipart) {
          throw parameterError(p, "@Part parameters can only be used with multipart encoding.");
        }
        Part part = (Part) annotation;
        gotPart = true;

        String partName = part.value();
        Class rawParameterType = Utils.getRawType(type);
        if (partName.isEmpty()) {
          if (Iterable.class.isAssignableFrom(rawParameterType)) {
            if (!(type instanceof ParameterizedType)) {
              throw parameterError(p, rawParameterType.getSimpleName()
                  + " must include generic type (e.g., "
                  + rawParameterType.getSimpleName()
                  + ")");
            }
            ParameterizedType parameterizedType = (ParameterizedType) type;
            Type iterableType = Utils.getParameterUpperBound(0, parameterizedType);
            if (!MultipartBody.Part.class.isAssignableFrom(Utils.getRawType(iterableType))) {
              throw parameterError(p,
                  "@Part annotation must supply a name or use MultipartBody.Part parameter type.");
            }
            return ParameterHandler.RawPart.INSTANCE.iterable();
          } else if (rawParameterType.isArray()) {
            Class arrayComponentType = rawParameterType.getComponentType();
            if (!MultipartBody.Part.class.isAssignableFrom(arrayComponentType)) {
              throw parameterError(p,
                  "@Part annotation must supply a name or use MultipartBody.Part parameter type.");
            }
            return ParameterHandler.RawPart.INSTANCE.array();
          } else if (MultipartBody.Part.class.isAssignableFrom(rawParameterType)) {
            return ParameterHandler.RawPart.INSTANCE;
          } else {
            throw parameterError(p,
                "@Part annotation must supply a name or use MultipartBody.Part parameter type.");
          }
        } else {
          Headers headers =
              Headers.of("Content-Disposition", "form-data; name=\"" + partName + "\"",
                  "Content-Transfer-Encoding", part.encoding());

          if (Iterable.class.isAssignableFrom(rawParameterType)) {
            if (!(type instanceof ParameterizedType)) {
              throw parameterError(p, rawParameterType.getSimpleName()
                  + " must include generic type (e.g., "
                  + rawParameterType.getSimpleName()
                  + ")");
            }
            ParameterizedType parameterizedType = (ParameterizedType) type;
            Type iterableType = Utils.getParameterUpperBound(0, parameterizedType);
            if (MultipartBody.Part.class.isAssignableFrom(Utils.getRawType(iterableType))) {
              throw parameterError(p, "@Part parameters using the MultipartBody.Part must not "
                  + "include a part name in the annotation.");
            }
            Converter converter =
                retrofit.requestBodyConverter(iterableType, annotations, methodAnnotations);
            return new ParameterHandler.Part<>(headers, converter).iterable();
          } else if (rawParameterType.isArray()) {
            Class arrayComponentType = boxIfPrimitive(rawParameterType.getComponentType());
            if (MultipartBody.Part.class.isAssignableFrom(arrayComponentType)) {
              throw parameterError(p, "@Part parameters using the MultipartBody.Part must not "
                  + "include a part name in the annotation.");
            }
            Converter converter =
                retrofit.requestBodyConverter(arrayComponentType, annotations, methodAnnotations);
            return new ParameterHandler.Part<>(headers, converter).array();
          } else if (MultipartBody.Part.class.isAssignableFrom(rawParameterType)) {
            throw parameterError(p, "@Part parameters using the MultipartBody.Part must not "
                + "include a part name in the annotation.");
          } else {
            Converter converter =
                retrofit.requestBodyConverter(type, annotations, methodAnnotations);
            return new ParameterHandler.Part<>(headers, converter);
          }
        }

      } else if (annotation instanceof PartMap) {
        if (!isMultipart) {
          throw parameterError(p, "@PartMap parameters can only be used with multipart encoding.");
        }
        gotPart = true;
        Class rawParameterType = Utils.getRawType(type);
        if (!Map.class.isAssignableFrom(rawParameterType)) {
          throw parameterError(p, "@PartMap parameter type must be Map.");
        }
        Type mapType = Utils.getSupertype(type, rawParameterType, Map.class);
        if (!(mapType instanceof ParameterizedType)) {
          throw parameterError(p, "Map must include generic types (e.g., Map)");
        }
        ParameterizedType parameterizedType = (ParameterizedType) mapType;

        Type keyType = Utils.getParameterUpperBound(0, parameterizedType);
        if (String.class != keyType) {
          throw parameterError(p, "@PartMap keys must be of type String: " + keyType);
        }

        Type valueType = Utils.getParameterUpperBound(1, parameterizedType);
        if (MultipartBody.Part.class.isAssignableFrom(Utils.getRawType(valueType))) {
          throw parameterError(p, "@PartMap values cannot be MultipartBody.Part. "
              + "Use @Part List or a different value type instead.");
        }

        Converter valueConverter =
            retrofit.requestBodyConverter(valueType, annotations, methodAnnotations);

        PartMap partMap = (PartMap) annotation;
        return new ParameterHandler.PartMap<>(valueConverter, partMap.encoding());

      } else if (annotation instanceof Body) {
        if (isFormEncoded || isMultipart) {
          throw parameterError(p,
              "@Body parameters cannot be used with form or multi-part encoding.");
        }
        if (gotBody) {
          throw parameterError(p, "Multiple @Body method annotations found.");
        }

        Converter converter;
        try {
          converter = retrofit.requestBodyConverter(type, annotations, methodAnnotations);
        } catch (RuntimeException e) {
          // Wide exception range because factories are user code.
          throw parameterError(e, p, "Unable to create @Body converter for %s", type);
        }
        gotBody = true;
        return new ParameterHandler.Body<>(converter);
      }

      return null; // Not a Retrofit annotation.
    }


现在数据已经准备好了，开始执行，执行是由请求接口中返回的数据来触发的，虽然返回的类型多种多样
但是，最终内部触发请求，就是调用Retrifit 的OkHttpCall（实现了Call接口）的方法
分析异步请求
OkHttpCall.enqueue(final Callback callback)
  @Override public void enqueue(final Callback callback) {
    if (callback == null) throw new NullPointerException("callback == null");

    okhttp3.Call call;
    Throwable failure;

    synchronized (this) {
      if (executed) throw new IllegalStateException("Already executed.");
      executed = true;

      call = rawCall;
      failure = creationFailure;
      if (call == null && failure == null) {
        try {
          call = rawCall = createRawCall();//创建Call，创建的是Okhttp的Call
        } catch (Throwable t) {
          failure = creationFailure = t;//创建失败
        }
      }
    }

    if (failure != null) {
      callback.onFailure(this, failure);//创建失败直接走失败回调
      return;
    }

    if (canceled) {
      call.cancel();//如果调用了取消请求，就取消请求
    }

    call.enqueue(new okhttp3.Callback() {
      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
          throws IOException {
        Response response;
        try {
          response = parseResponse(rawResponse);//解析响应
        } catch (Throwable e) {
          callFailure(e);
          return;
        }
        callSuccess(response);//解析成功，走成功回调
      }

      @Override public void onFailure(okhttp3.Call call, IOException e) {
        try {
          callback.onFailure(OkHttpCall.this, e);//走失败回调
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }

      private void callFailure(Throwable e) {
        try {
          callback.onFailure(OkHttpCall.this, e);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }

      private void callSuccess(Response response) {
        try {
          callback.onResponse(OkHttpCall.this, response);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }
    });
  }
-》  call = rawCall = createRawCall();//创建Call，创建的是Okhttp的Call
  private okhttp3.Call createRawCall() throws IOException {
    Request request = serviceMethod.toRequest(args);//调用serviceMethod.toRequest（方法参数）创建请求
    okhttp3.Call call = serviceMethod.callFactory.newCall(request);//根据请求，调用CallFactory(创建Retrifit的时候设置)，生成一个Okhttp的Call
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;//返回Call
  }
->Request request = serviceMethod.toRequest(args);//调用serviceMethod.toRequest（方法参数）创建请求
 Request toRequest(Object... args) throws IOException {
    RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl, headers,
        contentType, hasBody, isFormEncoded, isMultipart);//根据已经解析的一些基本信息，创建RequestBuilder

    @SuppressWarnings("unchecked") // It is an error to invoke a method with the wrong arg types.
    ParameterHandler[] handlers = (ParameterHandler[]) parameterHandlers;//这里是根据参数解析成的请求参数设置器

    int argumentCount = args != null ? args.length : 0;
    if (argumentCount != handlers.length) {
      throw new IllegalArgumentException("Argument count (" + argumentCount
          + ") doesn't match expected count (" + handlers.length + ")");
    }

    for (int p = 0; p < argumentCount; p++) {
      handlers[p].apply(requestBuilder, args[p]);//遍历执行请求参数设置器，让设置器把数据设置到，RequestBuilder
    }

    return requestBuilder.build();//生成请求
  }
-》     response = parseResponse(rawResponse);//解析响应

Response parseResponse(okhttp3.Response rawResponse) throws IOException {
    ResponseBody rawBody = rawResponse.body();

    // Remove the body's source (the only stateful object) so we can pass the response along.
    rawResponse = rawResponse.newBuilder()
        .body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
        .build();

    int code = rawResponse.code();
    if (code < 200 || code >= 300) {
      try {
        // Buffer the entire body to avoid future I/O.
        ResponseBody bufferedBody = Utils.buffer(rawBody);
        return Response.error(bufferedBody, rawResponse);
      } finally {
        rawBody.close();
      }
    }

    if (code == 204 || code == 205) {
      return Response.success(null, rawResponse);
    }

    ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
    try {
      T body = serviceMethod.toResponse(catchingBody);//调用serviceMethod.toResponse(catchingBody);转换响应
      return Response.success(body, rawResponse);//返回成功响应
    } catch (RuntimeException e) {
      // If the underlying source threw an exception, propagate that rather than indicating it was
      // a runtime exception.
      catchingBody.throwIfCaught();
      throw e;
    }
  }
-》serviceMethod.toResponse(catchingBody);转换响应
  T toResponse(ResponseBody body) throws IOException {
    return responseConverter.convert(body);//调用之前根据adapter返回的responseType获取的ResponeConvert
  }

-》返回到最初的create方法，动态代理中
         OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.callAdapter.adapt(okHttpCall);//会从 serviceMethod中获取根据接口方法返回值类型解析得到的CallAdapter


调用结束。

扩展使用，根据动态代理的思想，我们可以再接口方法上自定义我们自己的注解，然后是动态代理的时候，我们自己再包一层然后设置一些自己的参数。

 

你可能感兴趣的:(android源码)

  • React Native通讯原理 zbl_zbl androidReactNativ
    之前写过一篇文章ReactNativeAndroid源码分析，在此文章的基础上分析和总结下RN与Native的通讯流程。本文基于Android代码分析，iOS实现原理类似。1.通讯框架图先来解析下各个模块的角色与作用：Java层，这块的实现在ReactAndroid中-ReactContext:Android上下文子类，包含一个CatalystInstance实例，用于获取NativeModule
  • Android 源码中jni项目 加载so目录小结 峥嵘life JniAndroid系统androidandroid
    Android源码中jni项目加载so目录小结文章目录Android源码中jni项目加载so目录小结一、前言二、so目录验证测试1、jniso文件错误报错（1）报错1-未找到so文件：（2）报错2-so文件中未找到native方法：2、验证的几种情况（1）apk下面的lib/arm64/放置正确的so文件（2）apk下面的lib/arm64/放置错误的so文件所以上面两个测试，验证了lib/arm
  • VSCode查看Android源码，从入门到放弃 阳哥说全栈 Androidandroidvscodejava
    VSCode查看Android源码比较简单，首先下载Android源码，我用的Mac，所以比较方便，对了repo在homebrew里面就有，直接brewinstallrepo就可以，但是版本比官方的略低，但是可以用，只是有警告。下载之后直接用VSCode加载文件夹即可，直接可以在目录里面打开文件，对于非jdk的类能定位到文件位置，但是jdk的源码无法定位，显示的是.class文件反编译出来的代码，
  • AS高版本SDK编译生成的apk放入低版本android源码中集成编译错误 辉色投像
    android系统中内置app：LOCAL_PATH:=$(callmy-dir)include$(CLEAR_VARS)#ModulenameshouldmatchapknametobeinstalledLOCAL_MODULE:=DemoLOCAL_MODULE_TAGS:=optionalLOCAL_SRC_FILES:=$(LOCAL_MODULE).apkLOCAL_MODULE_CLA
  • android:configChanges分析 l309681481 androidgitee
    android:configChanges如果要在android源码确认是否是configChanges导致了Activity重启，建议把ActivityThread.DEBUG_CONFIGURATION改为true。Activity无法内部消化此次配置改变时，会调用relaunchActivityLocked方法。不同的是，如果此Activity正在前台，那立即调用；在后台的，则等切到前台后再
  • 学习GPG stxinu GPG
    0.前言在使用repo下载android源码和git下载kernel源码里会使用到gpg，那gpg是什么？该如何使用？这里说到的GPG是GnuPG，是GnuPrivacyGuard的缩写，它提供钥匙管理、加解密和数字签名等功能，其涉及到非对称加密算法，在学习每一项新技术时都先学会用再去深究其实现，故而我们在这里简说原理后立马学习如何用，品尝非对称加密算法应用下的GPG味道。非对称加密算法使用公钥和
  • Android源码分析--启动时序图 linuxMinx Android源码分析Android源码分析
    为什么Android系统启动比较慢Build的产物中最重要的是三个镜像文件，位于/out/target/product//目录下ramdisk.img:在启动时将被Linux内核挂载为只读分区，它包含了/init文件和一些配置文件。它用来挂载其他系统镜像并启动init进程。解析步骤：Init.c(system\core\init)Init.c{main(......init_parse_confi
  • 下载Android源码 赛非斯
    repoinit-uhttps://mirrors.tuna.tsinghua.edu.cn/git/AOSP/platform/manifest-bandroid-10.0.0_r411.首先下载repo：a）终端运行gitclonegit://codeaurora.org/tools/repo.gitb）mkdir~/binc）拷贝repo到~/bin下面，修改repo权限，chmoda+x~
  • Android源码剖析----EventBus的工作原理 简书不简单iiii
    现实开发中用到的框架为了方便更好的理解加深记忆，归纳如下：在开发中使用eventbus主要是为了进行传值和传递一些意图，第一次使用后就被这个框架的灵活和解耦性给折服。。。去熟悉eventbus的工作原理之前得首先知道一个设计模式那就是观察者模式，什么是观察者模式呢？就是为了定义对象间的一种一对多的依赖关系，即当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。整个eventbus
  • 【最全面】Android静默安装的两种方案 凉亭下 Androidandroidjava开发语言
    一些产品要求APP在升级时能够实现静默安装，而无需弹出安装界面让用户确认。这里提出两种实现方案：方案一：通过pm命令安装APP调用『pm』命令实现静默安装，此方案无须修改Android源码，但需要root权限。实现如下：/***Silentinstall**@parampathPackage*@returntrue:successfalse:failed*/publicstaticbooleani
  • java 串行线程_Java并发之串行线程池实例解析 笨zhu java串行线程
    前言做Android的这两年时间，通过研究Android源码，也会Java并发处理多线程有了自己的一些理解。那么问题来了，如何实现一个串行的线程池呢？思路何为串行线程池呢？也就是说，我们的Runnable对象应该有个排队的机制，它们顺序从队列尾部进入，并且从队列头部选择Runnable进行执行。既然我们有了思路，那我们就考虑一下所需要的数据结构？既然是从队列尾部插入Runnable对象，从队列头部
  • Android AOSP源码研究之万事开头难----经验教训记录 职场007 AndoridAOSPAndroidAOSPandroid源码下载编译Android源码烧录AOSP避坑指南
    文章目录1.概述2.Android源下载1.配置环境变量2.安装curl3.下载repo并授权4.创建一个文件夹保存源码5.设置repo的地址并配置为清华源6.初始化仓库7.指定我们需要下载的源码分支并初始化2.1使用移动硬盘存放Android源码的坑2.2解决方法3.Android源码编译4.Android源烧录1.概述做了四五年的android应用层开发后，想研究下底层源码的实现，所以想下载源
  • 【转载】原生社区交友婚恋视频即时通讯双端APP源码 ONE兔2.0版 ms3_ishenglu 交友微信小程序小程序
    原生社区交友婚恋视频即时通讯双端APP源码下载ONE兔2.0版包含后端、H5源码源码，Android源码，IOS源码
  • Adb显示第3方应用的包名原理 亚瑟-小郎 adblistframeworkandroid
    Android早期版本实现原理请看Android源码分析-pm命令的实现，列出包名pmlistpackage，列出系统库pmlistlibraries_pmlistpackages-CSDN博客Android12对adbshellpm实现原理做了重构：改成了template模式PackageManagerShellCommandextendsShellCommandadbshellpmlistpa
  • Android Jack Server Build Nothing_655f
    从AndroidM(6.0)之后，Android源码build引入了jack官方文档Jack工具的主要优势•完全开放源码源码均在AOSP中，合作伙伴可贡献源码•加快编译源码Jack提供特殊的配置，减少编译时间：pre-dexing,增量编译和Jack编译服务器.•支持代码压缩，混淆，重打包和multidex不在使用额外单独的包，例如ProGuard。1The.jacklibraryformatJa
  • Android 系统apk源码目录结构匹配成Android Studio目录 峥嵘life androidAndroid系统apkandroidandroidstudiogradle
    Android系统apk源码目录结构匹配成AndroidStudio目录本文针对系统源码apk开发，一般是拥有整个Android源码的开发。系统apk源码目录结构匹配成AndroidStudio目录的好处：1、能够方便使用Studio查看代码、修改代码；2、并且修改后容易对比，不用错开目录对比；3、导入相关类库和系统签名文件，可以直接编译出系统应用。一、Android系统源码默认目录结构和Stud
  • Android源码分析之消息机制 AN_9c94
    说明：本文是基于Android6.0源码来分析的这片文章主要是从源码的角度来分析Android中的消息机制是如何运行的，并不会介绍如何使用Handler。Android的消息机制可以说是Android的血液，流淌在不同的app之间，催动这各种事件有序的执行。Android进程在启动的时候会调用ThreadActivity的main方法,从main方法中我们可以看出，Android的app进程启动以
  • Android13源码下载及全编译流程 demodashi666 Android系统
    目录一、源码下载1.1、配置要求1.1.1、硬件配置要求1.1.2、软件要求1.2、下载环境搭建1.2.1、依赖安装1.2.2、工具安装1.2.3、git配置1.2.4、repo配置1.3、源码下载1.3.1、明确下载版本1.3.2、替换为清华源1.3.3、初始化仓库并指定分支1.3.4、同步全部源码二、Android源码编译2.1、编译环境搭建2.2、全编译2.2.1、初始化编译环境2.2.2、
  • Android源码中示例代码的查看方式 Mr_Tony JetPackandroid
    一、前言在实际开发中查看官方api定义的时候会看到如下内容其中如下内容是代码示例:Samples:androidx.compose.runtime.samples.rememberUpdatedStateSampleWithDisposableEffect//Unresolvedandroidx.compose.runtime.samples.rememberUpdatedStateSampleW
  • 消息机制--Handler、Looper、MessageQueue机制 erki_stwee
    songmiaomiaoAndroid中一切皆为消息，包括触摸事件和试图绘制机制，刷新，显示都是消息。Android源码查询消息机制总览Handler机制发送和处理消息。Handler的创建Handler()Handler(Callbackcallback)Handler(Looperlooper)Handler(Looperlooper,Callbackcallback)Handler(bool
  • Android源码分析：Activity启动流程 LeaYw
    分析流程基于Android8.0源码一般情况下我们通过Activity中的startActivity方法启动一个Activity。这个流程中涉及一下几个类：android.app.Activityandroid.app.Instrumentationcom.android.server.am.ActivityManagerServicecom.android.server.am.ActivityS
  • 自定义 ADB 指令 kkklzc adbandroid
    adb命令源码位于frameworks\base\cmds\在编译Android源码的时候，build/make/target/product/base.mk文件下将指令编译进去。PRODUCT_PACKAGES+=\20-dns.conf\95-configured\org.apache.http.legacy.boot\appwidget\appops\am\android.policy\an
  • Android SystemUI的客制化 (2) poulwalker Android系统的客制化开发androidSystemUIsystemui客制化
    本章主要探讨SYstemUI如何将从源码中拷贝出来，放在AndroidStudio中编译上前我们了解了Android源码如何下载，以及对SystemUI有个大概的了解，这期我们主要讲解上期抛出来的问题，即如何将AndroidSystemUI应用转成AndroidStudio工程项目文章目录前言一、第一步：编译源码的SystemUI应用1、编译源码SystemUI模块2、编译Android源码二、第
  • android源码--view创建原理总结 神迹12
    一、android界面构成android窗口组成.pngActivity：控制模型，控制Window。Window：承载模型，负责承载视图(View)。View：显示模型，用于显示。ViewRoot(ViewRootImpl)：是连接WindowManager和DecorView的纽带。二、View创建整体流程总结1、在ActivityThread的performLaunchActivity中调用
  • AOSP 源码整编单编 迷途小码农h
    《AOSP源码下载》完成后，就可以开编了。整编整编，顾名思义就是编译整个Android源码，最终out目录会生成几个重要的镜像文件，其中有system.img、userdata.img、ramdisk.img等，这些是可以刷机的。初始化编译环境项目目录，打开终端，输入命令：sourcebuild/envsetup.sh选择编译目标命令：lunch输出：You'rebuildingonLinuxLu
  • Android源码设计模式解析与实战第2版笔记（五） VaIOReTto1 设计模式笔记设计模式笔记javaandroid
    第七章时势造英雄–策略模式策略模式的定义策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。策略模式的使用场景针对同一类型问题的多种处理方式，仅仅是具体行为有差别时。需要安全地封装多种同一类型的操作时。出现同一抽象类有多个子类，而又需要使用if-else或者switch-case来选择具体子类时。策略模式的UML类图Contex
  • Android源码设计模式解析与实战第2版笔记（四） VaIOReTto1 设计模式笔记android设计模式笔记java
    第三章自由扩展你的项目–Builder模式Builder模式的定义将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。Builder模式的使用场景相同的方法，不同的执行顺序，产生不同的事件结果时多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时产品类非常复杂，或者产品类中的调用顺序不同产生了不同的作用，这个时候使用建造者模式非常合适初始化一个对象特别复杂，如
  • Android定位backtrace地址 bug猎人 linux运维服务器
    一，backtrace地址定位方式shell指令如下：#cd[Android源码根目录]#./prebuilts/clang/host/linux-x86/llvm-binutils-stable/llvm-addr2line[address]-e[symbolsso]-f-c注意：一定要使用symbol库。二，新手用例示范手写一个空指针访问内存简单样例，如下：#includevoidtest_s
  • 《Android源码设计模式解析与实战》读书笔记（六）——抽象工厂模式 禽兽先生不禽兽 Android书籍读书笔记android读书笔记
    一不小心都看了十种设计模式了，准备好好整理下，才发现还有个抽象工厂模式是被之前搁置下来的，是时候理解真正的抽象工厂模式了。第六章创建型设计模式——抽象工厂模式抽象工厂模式起源于以前对不同操作系统的图形化解决方案，如不同的操作系统中的按钮和文本框其实现不同，展现效果也不一样，对每一个操作系统而言，其本身就可以构成一个产品类，而按钮和文本框控件又是其下属的产品类。1.定义为创建一组相关或者是相互依赖的
  • 《Android源码设计模式解析与实战》读书笔记（三）——建造者模式 禽兽先生不禽兽 Android书籍读书笔记
    在使用别人的框架的时候，总觉得那些链式调用的写法看起来很厉害很优雅，一直以为挺难的呢，在书上看到之后才发现也是一种基本设计模式。第三章自由扩展你的项目——Builder模式Builder模式是一步一步创建一个复杂对象的创建型模式，它允许用户在不知道内部构建细节的情况下，可以更精细地控制对象的构造流程。1.定义将一个复杂对象的构建与它的表示分离开，使同样的构建过程可以创建不同的表示。2.使用场景1）
  • redis学习笔记——不仅仅是存取数据 Everyday都不同 returnSourceexpire/delincr/lpush数据库分区redis
    最近项目中用到比较多redis，感觉之前对它一直局限于get/set数据的层面。其实作为一个强大的NoSql数据库产品，如果好好利用它，会带来很多意想不到的效果。（因为我搞java，所以就从jedis的角度来补充一点东西吧。PS：不一定全，只是个人理解，不喜勿喷）   1、关于JedisPool.returnSource(Jedis jeids)   这个方法是从red
  • SQL性能优化-持续更新中。。。。。。 atongyeye oraclesql
    1 通过ROWID访问表--索引 你可以采用基于ROWID的访问方式情况,提高访问表的效率, , ROWID包含了表中记录的物理位置信息..ORACLE采用索引(INDEX)实现了数据和存放数据的物理位置(ROWID)之间的联系. 通常索引提供了快速访问ROWID的方法,因此那些基于索引列的查询就可以得到性能上的提高. 2 共享SQL语句--相同的sql放入缓存 3 选择最有效率的表
  • [JAVA语言]JAVA虚拟机对底层硬件的操控还不完善 comsci JAVA虚拟机
         如果我们用汇编语言编写一个直接读写CPU寄存器的代码段，然后利用这个代码段去控制被操作系统屏蔽的硬件资源，这对于JVM虚拟机显然是不合法的，对操作系统来讲，这样也是不合法的，但是如果是一个工程项目的确需要这样做，合同已经签了，我们又不能够这样做，怎么办呢？ 那么一个精通汇编语言的那种X客，是否在这个时候就会发生某种至关重要的作用呢？ &n
  • lvs- real 男人50 LVS
    #!/bin/bash # # Script to start LVS DR real server. # description: LVS DR real server # #.  /etc/rc.d/init.d/functions VIP=10.10.6.252 host='/bin/hostname' case "$1" in sta
  • 生成公钥和私钥 oloz DSA安全加密
    package com.msserver.core.util; import java.security.KeyPair; import java.security.PrivateKey; import java.security.PublicKey; import java.security.SecureRandom; public class SecurityUtil {
  • UIView 中加入的cocos2d，背景透明 374016526 cocos2dglClearColor
    要点是首先pixelFormat:kEAGLColorFormatRGBA8，必须有alpha层才能透明。然后view设置为透明glView.opaque = NO;[director setOpenGLView:glView];[self.viewController.view setBackgroundColor:[UIColor clearColor]];[self.viewControll
  • mysql常用命令 香水浓 mysql
    连接数据库 mysql -u troy -ptroy 备份表 mysqldump -u troy -ptroy mm_database mm_user_tbl > user.sql 恢复表（与恢复数据库命令相同） mysql -u troy -ptroy mm_database < user.sql 备份数据库 mysqldump -u troy -ptroy
  • 我的架构经验系列文章 - 后端架构 - 系统层面 agevs JavaScriptjquerycsshtml5
    系统层面： 高可用性 所谓高可用性也就是通过避免单独故障加上快速故障转移实现一旦某台物理服务器出现故障能实现故障快速恢复。一般来说，可以采用两种方式，如果可以做业务可以做负载均衡则通过负载均衡实现集群，然后针对每一台服务器进行监控，一旦发生故障则从集群中移除；如果业务只能有单点入口那么可以通过实现Standby机加上虚拟IP机制，实现Active机在出现故障之后虚拟IP转移到Standby的快速
  • 利用ant进行远程tomcat部署 aijuans tomcat
    在javaEE项目中，需要将工程部署到远程服务器上，如果部署的频率比较高，手动部署的方式就比较麻烦，可以利用Ant工具实现快捷的部署。这篇博文详细介绍了ant配置的步骤（http://www.cnblogs.com/GloriousOnion/archive/2012/12/18/2822817.html），但是在tomcat7以上不适用，需要修改配置，具体如下： 1.配置tomcat的用户角色
  • 获取复利总收入 baalwolf 获取
           public static void main(String args[]){         int money=200;         int year=1;         double rate=0.1; &
  • eclipse.ini解释 BigBird2012 eclipse
    大多数java开发者使用的都是eclipse，今天感兴趣去eclipse官网搜了一下eclipse.ini的配置，供大家参考，我会把关键的部分给大家用中文解释一下。还是推荐有问题不会直接搜谷歌，看官方文档，这样我们会知道问题的真面目是什么，对问题也有一个全面清晰的认识。 Overview 1、Eclipse.ini的作用 Eclipse startup is controlled by th
  • AngularJS实现分页功能 bijian1013 JavaScriptAngularJS分页
            对于大多数web应用来说显示项目列表是一种很常见的任务。通常情况下，我们的数据会比较多，无法很好地显示在单个页面中。在这种情况下，我们需要把数据以页的方式来展示，同时带有转到上一页和下一页的功能。既然在整个应用中这是一种很常见的需求，那么把这一功能抽象成一个通用的、可复用的分页（Paginator）服务是很有意义的。   &nbs
  • [Maven学习笔记三]Maven archetype bit1129 ArcheType
    archetype的英文意思是原型，Maven archetype表示创建Maven模块的模版，比如创建web项目，创建Spring项目等等.   mvn archetype提供了一种命令行交互式创建Maven项目或者模块的方式，   mvn archetype   1.在LearnMaven-ch03目录下，执行命令mvn archetype:gener
  • 【Java命令三】jps bit1129 Java命令
    jps很简单，用于显示当前运行的Java进程，也可以连接到远程服务器去查看   [hadoop@hadoop bin]$ jps -help usage: jps [-help] jps [-q] [-mlvV] [<hostid>] Definitions: <hostid>: <hostname>[:
  • ZABBIX2.2 2.4 等各版本之间的兼容性 ronin47
    zabbix更新很快，从2009年到现在已经更新多个版本，为了使用更多zabbix的新特性，随之而来的便是升级版本，zabbix版本兼容性是必须优先考虑的一点 客户端AGENT兼容 zabbix1.x到zabbix2.x的所有agent都兼容zabbix server2.4：如果你升级zabbix server，客户端是可以不做任何改变，除非你想使用agent的一些新特性。 Zabbix代理（p
  • unity 3d还是cocos2dx哪个适合游戏？ brotherlamp unity自学unity教程unity视频unity资料unity
    unity 3d还是cocos2dx哪个适合游戏？ 问：unity 3d还是cocos2dx哪个适合游戏？ 答：首先目前来看unity视频教程因为是3d引擎，目前对2d支持并不完善，unity 3d 目前做2d普遍两种思路，一种是正交相机，3d画面2d视角，另一种是通过一些插件，动态创建mesh来绘制图形单元目前用的较多的是2d toolkit，ex2d，smooth moves，sm2，
  • 百度笔试题：一个已经排序好的很大的数组，现在给它划分成m段，每段长度不定，段长最长为k，然后段内打乱顺序，请设计一个算法对其进行重新排序 bylijinnan java算法面试百度招聘
    import java.util.Arrays; /** * 最早是在陈利人老师的微博看到这道题： * #面试题#An array with n elements which is K most sorted，就是每个element的初始位置和它最终的排序后的位置的距离不超过常数K * 设计一个排序算法。It should be faster than O(n*lgn)。
  • 获取checkbox复选框的值 chiangfai checkbox
    <title>CheckBox</title> <script type = "text/javascript"> doGetVal: function doGetVal() { //var fruitName = document.getElementById("apple").value;//根据
  • MySQLdb用户指南 chenchao051 mysqldb
    原网页被墙，放这里备用。 MySQLdb User's Guide Contents Introduction Installation _mysql MySQL C API translation MySQL C API function mapping Some _mysql examples MySQLdb
  • HIVE 窗口及分析函数 daizj hive窗口函数分析函数
    窗口函数应用场景： （1）用于分区排序 （2）动态Group By （3）Top N （4）累计计算 （5）层次查询 一、分析函数 用于等级、百分点、n分片等。 函数             说明 RANK()     &nbs
  • PHP ZipArchive 实现压缩解压Zip文件 dcj3sjt126com PHPzip
    PHP ZipArchive 是PHP自带的扩展类，可以轻松实现ZIP文件的压缩和解压，使用前首先要确保PHP ZIP 扩展已经开启，具体开启方法就不说了，不同的平台开启PHP扩增的方法网上都有，如有疑问欢迎交流。这里整理一下常用的示例供参考。 一、解压缩zip文件 01 02 03 04 05 06 07 08 09 10 11
  • 精彩英语贺词 dcj3sjt126com 英语
    I'm always here              我会一直在这里支持你                &nb
  • 基于Java注解的Spring的IoC功能 e200702084 javaspringbeanIOCOffice
                                      
  • java模拟post请求 geeksun java
    一般API接收客户端（比如网页、APP或其他应用服务）的请求，但在测试时需要模拟来自外界的请求，经探索，使用HttpComponentshttpClient可模拟Post提交请求。 此处用HttpComponents的httpclient来完成使命。 import org.apache.http.HttpEntity ; import org.apache.http.HttpRespon
  • Swift语法之 ---- ?和!区别 hongtoushizi ?swift!
    转载自： http://blog.sina.com.cn/s/blog_71715bf80102ux3v.html   Swift语言使用var定义变量，但和别的语言不同，Swift里不会自动给变量赋初始值，也就是说变量不会有默认值，所以要求使用变量之前必须要对其初始化。如果在使用变量之前不进行初始化就会报错： var stringValue : String //
  • centos7安装jdk1.7 jisonami jdkcentos
    安装JDK1.7 步骤1、解压tar包在当前目录 [root@localhost usr]#tar -xzvf jdk-7u75-linux-x64.tar.gz 步骤2：配置环境变量 在etc/profile文件下添加 export JAVA_HOME=/usr/java/jdk1.7.0_75 export CLASSPATH=/usr/java/jdk1.7.0_75/lib
  • 数据源架构模式之数据映射器 home198979 PHP架构数据映射器datamapper
    前面分别介绍了数据源架构模式之表数据入口、数据源架构模式之行和数据入口数据源架构模式之活动记录，相较于这三种数据源架构模式，数据映射器显得更加“高大上”。   一、概念 数据映射器（Data Mapper）：在保持对象和数据库（以及映射器本身）彼此独立的情况下，在二者之间移动数据的一个映射器层。概念永远都是抽象的，简单的说，数据映射器就是一个负责将数据映射到对象的类数据。 &nb
  • 在Python中使用MYSQL pda158 mysqlpython
    缘由 　　近期在折腾一个小东西须要抓取网上的页面。然后进行解析。将结果放到 数据库中。 　　了解到 Python在这方面有优势，便选用之。 　　由于我有台 server上面安装有 mysql，自然使用之。在进行数据库的这个操作过程中遇到了不少问题，这里 记录一下，大家共勉。 　　 python中mysql的调用 　　 百度之后能够通过MySQLdb进行数据库操作。
  • 单例模式 hxl1988_0311 java单例设计模式单件
    package com.sosop.designpattern.singleton; /* * 单件模式：保证一个类必须只有一个实例，并提供全局的访问点 * * 所以单例模式必须有私有的构造器，没有私有构造器根本不用谈单件 * * 必须考虑到并发情况下创建了多个实例对象 * */ /** * 虽然有锁，但是只在第一次创建对象的时候加锁，并发时不会存在效率
  • 27种迹象显示你应该辞掉程序员的工作 vipshichg 工作
    1、你仍然在等待老板在2010年答应的要提拔你的暗示。 2、你的上级近10年没有开发过任何代码。 3、老板假装懂你说的这些技术，但实际上他完全不知道你在说什么。 4、你干完的项目6个月后才部署到现场服务器上。 5、时不时的，老板在检查你刚刚完成的工作时，要求按新想法重新开发。 6、而最终这个软件只有12个用户。 7、时间全浪费在办公室政治中，而不是用在开发好的软件上。 8、部署前5分钟才开始测试。