【天星技術團隊】從自定義Annotation、APT、JavaPoet再到Butterknife原理

天星技術團隊發表於2018-06-30

作者: 張德帥, 時間: 2018.6.30 星期六天氣晴

一眨眼功夫又到週末，總覺得小日子過得不夠充實(其實是王者榮耀不好玩了...)。

【天星技術團隊】從自定義Annotation、APT、JavaPoet再到Butterknife原理

不過我可以跟Butterknife談情說愛（RTFSC：Read The Fucking Source Code），本篇文章便是“愛的結晶” 。

1、Butterknife是什麼？

Android大神JakeWharton的作品（其它還有OKHttp、Retrofit等）。Butterknife使用註解代替findViewById()等，可讀性高、優雅、開發效率提高等。這裡就不再列舉Butterknife優點，相信各位老司機早就精通Butterknife使用。本篇主要學習Butterknife核心原始碼，萬丈高樓平地起，直接殺入原始碼難免無頭蒼蠅，一臉懵逼，文章從以下幾個部分聊起（瞎扯）。

自定義註解
反射解析註解
APT解析註解
JavaPoet生成Java原始檔
淺析Butterknife原始碼

（強行插入表情包）

來不及解釋了快上車滴... 學生卡。

Butterknife 基本使用姿勢

1、在App build.gradle配置依賴

dependencies {
    implementation 'com.jakewharton:butterknife:8.8.1'
    annotationProcessor 'com.jakewharton:butterknife-compiler:8.8.1'
}
複製程式碼

2、在Activity使用

public class MainActivity extends AppCompatActivity {
    @BindView(R.id.tv_name)
    TextView tvName;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);
    }
}

複製程式碼

2、註解

上面看到使用非常簡單，幾個註解就搞定之前一大堆findViewById()等程式碼，那麼它是怎麼做到的？答案是：butterknife會掃描這些自定義註解，根據註解資訊生成Java檔案，ButterKnife.bind(this)實際會執行自動生成的程式碼。紅色框選部分文章後面會詳細分析，可以瞭解到在讀Butterknife原始碼之前得先回顧Java基礎-註解。

目錄：app\build\generated\source\apt\ （APT掃描解析註解生成的程式碼）。

註解

註解可以理解為程式碼的標識，不會對執行有直接影響。

1、內建註解

Java內建幾個常用註解，這部分標識原始碼，會被編譯器識別，提示錯誤等。

@Override 標記覆蓋方法

@Deprecated 標記為過時

@SuppressWarnings 忽略警告

2、元註解

假設我們要自定義一個註解，這時候就需要用元註解去宣告自定義註解，包括像註解作用域、生命週期等。

@Documented 可以被javadoc文件化。

@Target 註解用在哪

CONSTRUCTOR 建構函式
FIELD 域宣告
LOCAL_VARIABLE 區域性變數
METHOD 方法
PACKAGE 包宣告
PARAMETER 引數
TYPE 類、介面

@Inherited

允許子類繼承父類註解

@Retention

SOURCE：編譯時剔除
CLASS：在CLASS檔案保留標識，執行時剔除
RUNTIME 執行時保留標識

3、自定義註解

使用元註解建立自定義註解

//直到執行時還保留註解
@Retention(RetentionPolicy.RUNTIME)
//作用域 類
@Target(ElementType.TYPE)
public @interface BindV {
    int resId() default 0;
}

複製程式碼

4、解析註解

在程式碼中定義了標識，現在想拿到這些資訊，可以通過反射、APT獲取註解的值。

1、反射

通過反射解析註解（這裡也不闡述什麼是反射）

BindV.java 檔案

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface BindV {
    int resId() default 0;
}
複製程式碼

MainActivity.java 檔案

@BindV(resId = R.layout.activity_main)
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        
        //這裡是舉個栗子反射當前類，設定佈局檔案，當然在實際中這部分程式碼可能是經過封裝的。
        Class clz = MainActivity.class;
        BindV bindV = (BindV) clz.getAnnotation(BindV.class);//拿到佈局檔案id
        setContentView(bindV.resId());
    }
}
複製程式碼

2、APT

APT（Annotation Processing Tool）註解處理器，是在編譯期間讀取註解，生成Java檔案。反射解析註解是損耗效能的，接下來通過APT來生成java原始碼，從而避免反射。

1、首先新建專案，再新建JavaLibrary。

JavaLibrary的Gradle配置，要想Java識別註解處理器，需要註冊到META-INF，這裡使用auto-service這個庫實現自動註冊。

apply plugin: 'java-library'

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.google.auto.service:auto-service:1.0-rc2'
}

sourceCompatibility = "1.7"
targetCompatibility = "1.7"

複製程式碼

2、新建BindLayout註解

package com.example.abstractprocessorlib;

public @interface BindLayout {
    int viewId();
}

複製程式碼

3、新建AbstractProcessor子類

package com.example.abstractprocessorlib;

@AutoService(Processor.class)
public class MyProcessor extends AbstractProcessor {
    private Types typesUtils;//型別工具類
    private Elements elementsUtils;//節點工具類
    private Filer filerUtils;//檔案工具類
    private Messager messager;//處理器訊息輸出（注意它不是Log工具）

    //init初始化方法，processingEnvironment會提供很多工具類，這裡獲取Types、Elements、Filer、Message常用工具類。
    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
        typesUtils = processingEnvironment.getTypeUtils();
        elementsUtils = processingEnvironment.getElementUtils();
        filerUtils = processingEnvironment.getFiler();
        messager = processingEnvironment.getMessager();
    }

    //這裡掃描、處理註解，生成Java檔案。
    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        //拿到所有被BindLayout註解的節點
        Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(BindLayout.class);
        for (Element element : elements) {
            //輸出警告資訊
            processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, "element name：" + element.getSimpleName(), element);

            //判斷是否 用在類上
            if (element.getKind().isClass()) {
                //新檔名  類名_Bind.java
                String className = element.getSimpleName() + "_Bind";
                try {
                    //拿到註解值
                    int viewId = element.getAnnotation(BindLayout.class).viewId();

                    //建立檔案 包名com.example.processor.    
                    JavaFileObject source = filerUtils.createSourceFile("com.example.processor." + className);
                    Writer writer = source.openWriter();
                    
                    //檔案內容
                    writer.write("package com.example.processor;\n" +
                            "\n" +
                            "import android.app.Activity;\n" +
                            "\n" +
                            "public class " + className + " {  \n" +
                            "\n" +
                            "    public static void init(Activity activity){\n" +
                            "        activity.setContentView(" + viewId + ");\n" +
                            "    }\n" +
                            "}");
                    writer.flush();
                    //完成寫入
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return false;
    }

    //要掃描哪些註解
    @Override
    public Set<String> getSupportedAnnotationTypes() {
        Set<String> annotationSet = new HashSet<>();
        annotationSet.add(BindLayout.class.getCanonicalName());
        return annotationSet;
    }

    //支援的JDK版本，建議使用latestSupported()
    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }
}

複製程式碼

2、在App的Gradle檔案新增配置

dependencies {
    annotationProcessor project(path: ':AbstractProcessorLib')
    implementation project(path: ':AbstractProcessorLib') 
}
複製程式碼

3、在app\build\generated\source\apt\debug 目錄下，可以看到APT 生成的檔案。

可以在Activity使用剛才生成的檔案

假設遇到這個錯誤，可以參考修改Grandle配置

Gradle配置

1、JavaPoet

從上面APT可以看到拼接Java檔案是比較複雜的，好在Square開源了JavPoet這個庫，不然整個檔案全靠字串拼接... 有了這個庫生成程式碼，就像寫詩一樣。修改剛才process()方法

@Override
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
    Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(BindLayout.class);
    for (Element element : elements) {
        processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, "element name：" +element.getSimpleName(), element);
        if (element.getKind().isClass()) {
            String className = element.getSimpleName() + "_Bind";
            try {
                int viewId = element.getAnnotation(BindLayout.class).viewId();
                
                //得到android.app.Activity這個類
                ClassName activityClass = ClassName.get("android.app", "Activity");
                
                //建立一個方法
                MethodSpec initMethod = MethodSpec.methodBuilder("init")
                        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)//修飾符
                        .addParameter(activityClass, "activity")//引數
                        .returns(TypeName.VOID)//返回值
                        .addStatement("activity.setContentView(" + viewId + ");")//方法體
                        .build();
                
                //建立一個類        
                TypeSpec typeSpec = TypeSpec.classBuilder(className)//類名 
                        .addModifiers(Modifier.PUBLIC)//修飾符
                        .addMethod(initMethod)//將方法加入到這個類
                        .build();
                        
                //建立java檔案，指定包名類        
                JavaFile javaFile = JavaFile.builder("com.example.processor", typeSpec)
                        .build();
                        
                javaFile.writeTo(filerUtils);
                
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    return false;
}
複製程式碼

Butterknife 原始碼分析

先到gayhub 下載原始碼，butterknife、butterknife-annotations、butterknife-compiler三個核心模組，也是主要閱讀的部分。

1、首先來分析一下build\generated\source\apt**\MainActivity_ViewBinding.java 這個檔案生成大概過程，之前我們是用註解處理器生成程式碼，在butterknife-compiler模組的ButterKnifeProcessor.java類負責生成 ClassName_ViewBinding.java檔案。過程如下：

掃描註解資訊
生成ClassName_ViewBinding.java檔案
Butterknife.init()方法找到對於ViewBinding檔案並執行繫結方法。

（為了方便快速閱讀程式碼，把註釋或程式碼強壯性判斷移除）首先是init方法，沒有過多複雜的，主要是工具類獲取。

 @Override 
 public synchronized void init(ProcessingEnvironment env) {
   super.init(env);
   elementUtils = env.getElementUtils();
   typeUtils = env.getTypeUtils();
   filer = env.getFiler();
   trees = Trees.instance(processingEnv);
 }
複製程式碼

getSupportedSourceVersion、getSupportedAnnotationTypes方法。

@Override 
public SourceVersion getSupportedSourceVersion() {
  return SourceVersion.latestSupported();
}

@Override
public Set<String> getSupportedAnnotationTypes() {
  Set<String> types = new LinkedHashSet<>();
  for (Class<? extends Annotation> annotation : getSupportedAnnotations()) {
    types.add(annotation.getCanonicalName());
  }
  return types;
}

private Set<Class<? extends Annotation>> getSupportedAnnotations() {
  Set<Class<? extends Annotation>> annotations = new LinkedHashSet<>();
  annotations.add(BindAnim.class);
  annotations.add(BindArray.class);
  ...
  return annotations;
}
複製程式碼

接下來重點是process方法


@Override 
public boolean process(Set<? extends TypeElement> elements, RoundEnvironment env) {
  Map<TypeElement, BindingSet> bindingMap = findAndParseTargets(env);
  for (Map.Entry<TypeElement, BindingSet> entry : bindingMap.entrySet()) {
    TypeElement typeElement = entry.getKey();
    BindingSet binding = entry.getValue();
    JavaFile javaFile = binding.brewJava(sdk, debuggable);
    try {
      javaFile.writeTo(filer);
    } catch (IOException e) {
      error(typeElement, "Unable to write binding for type %s: %s", typeElement, e.getMessage());
    }
  }
  return false;
}
複製程式碼

分析findAndParseTargets(env)這行，找到這個private Map<TypeElement, BindingSet> findAndParseTargets(RoundEnvironment env)這個方法核心部分

省略...
// Process each @BindView element.
for (Element element : env.getElementsAnnotatedWith(BindView.class)) {
  // we don't SuperficialValidation.validateElement(element)
  // so that an unresolved View type can be generated by later processing rounds
  try {
    parseBindView(element, builderMap, erasedTargetNames);
  } catch (Exception e) {
    logParsingError(element, BindView.class, e);
  }
}
省略...
複製程式碼

繼續往下找 parseBindView()方法

private void parseBindView(Element element, Map<TypeElement, BindingSet.Builder> builderMap,
    Set<TypeElement> erasedTargetNames) {
    
  //當前註解所在的類
  TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();

  //校驗類、要繫結的欄位 修飾符 private static，不可以在Framework層使用已java. android.開始的包名  
  boolean hasError = isInaccessibleViaGeneratedCode(BindViews.class, "fields", element)
      || isBindingInWrongPackage(BindViews.class, element);
      
  // 要繫結的欄位是否View的子類、或介面
  TypeMirror elementType = element.asType();
  if (elementType.getKind() == TypeKind.TYPEVAR) {
    TypeVariable typeVariable = (TypeVariable) elementType;
    elementType = typeVariable.getUpperBound();
  }
  Name qualifiedName = enclosingElement.getQualifiedName();
  Name simpleName = element.getSimpleName();
  if (!isSubtypeOfType(elementType, VIEW_TYPE) && !isInterface(elementType)) {
    if (elementType.getKind() == TypeKind.ERROR) {
      note(element, "@%s field with unresolved type (%s) "
              + "must elsewhere be generated as a View or interface. (%s.%s)",
          BindView.class.getSimpleName(), elementType, qualifiedName, simpleName);
    } else {
      error(element, "@%s fields must extend from View or be an interface. (%s.%s)",
          BindView.class.getSimpleName(), qualifiedName, simpleName);
      hasError = true;
    }
  }
  
  //校驗不通過
  if (hasError) {
    return;
  }

  // Assemble information on the field.
  //儲存View ID之間對映
  int id = element.getAnnotation(BindView.class).value();
  BindingSet.Builder builder = builderMap.get(enclosingElement);//從快取取出來
  Id resourceId = elementToId(element, BindView.class, id);
  if (builder != null) {//說明之前被繫結過
    String existingBindingName = builder.findExistingBindingName(resourceId);
    if (existingBindingName != null) {
      error(element, "Attempt to use @%s for an already bound ID %d on '%s'. (%s.%s)",
          BindView.class.getSimpleName(), id, existingBindingName,
          enclosingElement.getQualifiedName(), element.getSimpleName());
      return;
    }
  } else {
    //構建要繫結View的對映關係，繼續看getOrCreateBindingBuilder方法資訊
    builder = getOrCreateBindingBuilder(builderMap, enclosingElement);
  }

  String name = simpleName.toString();
  TypeName type = TypeName.get(elementType);
  boolean required = isFieldRequired(element);

  //我們Activity類有很多 BindView註解的控制元件，是以類包含欄位，這裡的builder相當於類，判斷如果類存在就往裡加欄位。
  builder.addField(resourceId, new FieldViewBinding(name, type, required));

  // Add the type-erased version to the valid binding targets set.
  erasedTargetNames.add(enclosingElement);
}



//直接看newBuilder
private BindingSet.Builder getOrCreateBindingBuilder(
      Map<TypeElement, BindingSet.Builder> builderMap, TypeElement enclosingElement) {
    BindingSet.Builder builder = builderMap.get(enclosingElement);
    if (builder == null) {
      builder = BindingSet.newBuilder(enclosingElement);
      builderMap.put(enclosingElement, builder);
    }
    return builder;
  }
 
//相當於建立一個類，類名是一開始看到的 類名_ViewBinding 
static Builder newBuilder(TypeElement enclosingElement) {
  TypeMirror typeMirror = enclosingElement.asType();
  
  boolean isView = isSubtypeOfType(typeMirror, VIEW_TYPE);
  boolean isActivity = isSubtypeOfType(typeMirror, ACTIVITY_TYPE);
  boolean isDialog = isSubtypeOfType(typeMirror, DIALOG_TYPE);

  TypeName targetType = TypeName.get(typeMirror);
  if (targetType instanceof ParameterizedTypeName) {
    targetType = ((ParameterizedTypeName) targetType).rawType;
  }
  
  String packageName = getPackage(enclosingElement).getQualifiedName().toString();
  String className = enclosingElement.getQualifiedName().toString().substring(
      packageName.length() + 1).replace('.', '$');
  ClassName bindingClassName = ClassName.get(packageName, className + "_ViewBinding");
  boolean isFinal = enclosingElement.getModifiers().contains(Modifier.FINAL);
  
  return new Builder(targetType, bindingClassName, isFinal, isView, isActivity, isDialog);
}  



回到process方法，這行就是將剛掃描的資訊寫入到檔案
JavaFile javaFile = binding.brewJava(sdk, debuggable, useAndroidX);


複製程式碼

至此我們知道*_ViewBinding檔案生成過程，接下來看怎麼使用，從Butterknife.bind()方法檢視

public static Unbinder bind(@NonNull Activity target) {
    View sourceView = target.getWindow().getDecorView();//拿到decorView
    return createBinding(target, sourceView);
}
複製程式碼

進入createBinding()方法

private static Unbinder createBinding(@NonNull Object target, @NonNull View source) {
    Class<?> targetClass = target.getClass();
    if (debug) Log.d(TAG, "Looking up binding for " + targetClass.getName
    //拿到類_ViewBinding的構造方法
    Constructor<? extends Unbinder> constructor = findBindingConstructorForClass(targetClass);

    if (constructor == null) {
      return Unbinder.EMPTY;
    }

    //noinspection TryWithIdenticalCatches Resolves to API 19+ only type.
    try {
      return constructor.newInstance(target, source);//執行構造方法。
    } catch (IllegalAccessException e) {
      throw new RuntimeException("Unable to invoke " + constructor, e);
    } catch (InstantiationException e) {
      throw new RuntimeException("Unable to invoke " + constructor, e);
    } catch (InvocationTargetException e) {
      Throwable cause = e.getCause();
      if (cause instanceof RuntimeException) {
        throw (RuntimeException) cause;
      }
      if (cause instanceof Error) {
        throw (Error) cause;
      }
      throw new RuntimeException("Unable to create binding instance.", cause);
    }
  }
複製程式碼

繼續看findBindingConstructorForClass（）方法，根據當前類先從快取找構造方法，沒有的話根據類名_ViewBinding找到構造方法。

 private static Constructor<? extends Unbinder> findBindingConstructorForClass(Class<?> cls) {
    Constructor<? extends Unbinder> bindingCtor = BINDINGS.get(cls);
    if (bindingCtor != null) {
      if (debug) Log.d(TAG, "HIT: Cached in binding map.");
      return bindingCtor;
    }
    String clsName = cls.getName();
    if (clsName.startsWith("android.") || clsName.startsWith("java.")) {
      if (debug) Log.d(TAG, "MISS: Reached framework class. Abandoning search.");
      return null;
    }
    try {
      Class<?> bindingClass = cls.getClassLoader().loadClass(clsName + "_ViewBinding");
      //noinspection unchecked
      bindingCtor = (Constructor<? extends Unbinder>) bindingClass.getConstructor(cls, View.class);
      if (debug) Log.d(TAG, "HIT: Loaded binding class and constructor.");
    } catch (ClassNotFoundException e) {
      if (debug) Log.d(TAG, "Not found. Trying superclass " + cls.getSuperclass().getName());
      bindingCtor = findBindingConstructorForClass(cls.getSuperclass());
    } catch (NoSuchMethodException e) {
      throw new RuntimeException("Unable to find binding constructor for " + clsName, e);
    }
    BINDINGS.put(cls, bindingCtor);
    return bindingCtor;
  }
複製程式碼

//到這一步我們清楚，是先生成檔案，然後Butterknife.bind()方法關聯生成的檔案並執行構造。接下來看看生成的檔案構造做了什麼 //我在apt目錄下找到一個檔案SimpleActivity_ViewBinding.java檔案，程式碼量多我簡化一下，直接看findRequireViewAsType()方法。

 @UiThread
  public SimpleActivity_ViewBinding(SimpleActivity target) {
    this(target, target.getWindow().getDecorView());
  }

  @UiThread
  public SimpleActivity_ViewBinding(final SimpleActivity target, View source) {
    this.target = target;

    View view;
    target.title = Utils.findRequiredViewAsType(source, R.id.title, "field 'title'", TextView.class);
  }
  
  //繼續看findRequiredView
  public static <T> T findRequiredViewAsType(View source, @IdRes int id, String who,
      Class<T> cls) {
    View view = findRequiredView(source, id, who);
    return castView(view, id, who, cls);
  }
  
  
  //findRequiredView()方法，可以看到其實還是使用findViewByID()查詢View只不過是自動生成。
  public static View findRequiredView(View source, @IdRes int id, String who) {
    View view = source.findViewById(id);
    if (view != null) {
      return view;
    }
    String name = getResourceEntryName(source, id);
    throw new IllegalStateException("Required view '"
        + name
        + "' with ID "
        + id
        + " for "
        + who
        + " was not found. If this view is optional add '@Nullable' (fields) or '@Optional'"
        + " (methods) annotation.");
  }
複製程式碼

//以上就是Butterknife基本原理，第一部分apt掃描註解資訊生成檔案，第二部分Butterknife.bind方法找到對於檔案，執行構造，並執行findView獲取view。

推薦一篇文章：Android主專案和Module中R類的區別 https://www.imooc.com/article/23756

最後：其實在MVVM、Kotlin等出來之後，Butterknife熱度慢慢下降，但這根本不影響我們去了解這如此優秀的框架。

炮友們有問題，請留言感謝！這是粉絲QQ群

關於作者 Android-張德帥

1996年，就讀於德國慕尼黑特種兵學校。
1998年，在美國賓夕法尼亞大學心理系進修。
2000年，加入海波突擊隊。
2003年，攻破日本情報系統，獲取10份絕密檔案，令其戰爭陰謀破產。
2005年，前往敘利亞執行任務，成功解救三千人質。
2006年，獲得諾貝爾和平獎提名。
2008年，參加美國總統選舉，以一票只差落選。
2011年，被奧巴馬跪請回到海波突擊隊，同年擊斃拉登。
2015年，被提名為全球最有影響力人物。
2018年，放棄一生榮譽加入"天星技術團隊"，持續更新文章。

參考資料

Butterknife： https://github.com/JakeWharton/butterknife
《Java程式設計思想第四版》： https://item.jd.com/10058164.html
Auto-Service： https://github.com/google/auto-service （上面什麼都沒有，奇怪） 'com.google.auto.service:auto-service:1.0-rc2'
Java註解處理器：https://race604.com/annotation-processing/
JavaPoet 看這一篇就夠了：https://juejin.im/entry/58fefebf8d6d810058a610de/

自定義Annotation
2016-10-14
技術團隊
2018-08-22
Java自定義Annotation,通過反射解析Annotation
2015-03-27
Java反射
團隊的技術形象
2015-02-11
中小團隊的技術負責人如何做好技術團隊建設
2022-04-07
小團隊的技術管理
2019-05-11
團隊專案必備神器——自定義Lint
2016-12-16
從技術到工具再到落地，Pivotal多位技術專家詳解Greenplum
2018-12-28
團隊技術資訊流建設
2019-02-17
團隊溝通技術(轉載)
2007-07-30
團隊管理、團隊人員技術培養的思考和交流
2021-09-08
團隊自定義 tslint & eslint 詳細規則
2018-07-01
EsLint
大檔案上傳原理及實現方案 | 京東物流技術團隊
2024-02-12
【譯】React團隊的技術準則
2020-01-06
React
技術團隊管理筆記(三)-用人
2019-01-06
筆記
淺談LocalCache | 京東雲技術團隊
2024-02-12
技術團隊的情緒與效率
2014-12-25
初創團隊的技術選擇
2014-09-05
如何才能做好技術團隊管理
2011-11-17
ButterKnife原理分析
2018-01-18
技術團隊管理筆記(一)-識人
2018-12-31
筆記
技術團隊管理筆記(二)-帶人
2019-01-06
筆記
技術團隊為什麼要開源？
2014-08-26
Android技術分享| 自定義LayoutManager
2022-06-14
Android
《技術管理之巔：如何從零打造高質效網際網路技術團隊？》
2020-04-07
袋鼠雲數棧技術團隊入選開源中國“2021年度優秀開源技術團隊”
2021-12-20
技術管理之路三、團隊建設：怎麼帶隊伍？
2021-11-11
Spring 定時器的使用—Xml、Annotation、自定義
2019-03-02
Spring定時器XML
Spring 定時器的使用---Xml、Annotation、自定義
2018-06-10
Spring定時器XML
喜訊+1！袋鼠雲數棧技術團隊獲“2022年度優秀開源技術團隊”
2022-12-15
apt技術手段防禦
2013-11-07
APT
前阿里技術團隊尋求專案合作
2019-08-18
阿里
小團隊招聘 PHP技術員工作輕鬆
2020-09-17
PHP
技術管理進階——如何規劃團隊的技術發展方向
2022-06-20
技術管理進階——如何提升團隊的合作和技術氛圍
2022-06-21
好的技術團隊和差的技術團隊的區別在於技術架構前瞻性和適應變化的能力
2015-01-14
架構
Android APT(Annotation Processing Tool) 實踐
2019-03-04
AndroidAPT
大家所在測試團隊有固定技術交流或者技術比拼活動麼？
2020-11-02