EasyAnnotation框架界面跳转注解(一)

·  阅读 309

如何成为T型人才，垂直在一个行业中，必须要有一整套知识体系，在这里，就一个字坚持~

前言

Android中提供了四大组件(Activity/Service/BroadCast Recevicer/Content provider)，组件之间存在着交互。在Activity组件中，可以使用startActivityz启动一个Activity视图,并且数据通过Bundle序列化传递给视图，那如何通过APT技术实现Activity视图跳转？接下来直接代码编码，注解理论知识，请移步到 细聊注解知识点。谢谢~

Contents

一、定义界面跳转注解

  • @IntentField：该注解主要修饰成员变量,标记Activity数据交互变量类型。@Retention(RetentionPolicy.CLASS)：表示编译时注解，@Target(ElementType.FIELD)：表示修饰成员变量，注解参数定义为String类型value值，表示目标Activiy类名。

    @Retention(RetentionPolicy.CLASS)
@Target(ElementType.FIELD)
public @interface IntentField {

    /**
     * 目标对象标识,如{@code MainActivity}
     *
     * @return
     */
    String value() default "";
}
复制代码

  • @IntentParameter：该注解主要修饰方法形式参数，标记Activity数据交互变量类型。@Retention(RetentionPolicy.CLASS)：表示编译时注解，

    @Target(ElementType.PARAMETER)：表示修饰方法形式参数，注解参数定义为String类型value值，表示目标Activiy类名。

    @Retention(RetentionPolicy.CLASS)
@Target(ElementType.PARAMETER)
public @interface IntentParameter {
    /**
     * 目标对象标识,如{@code MainActivity}
     *
     * @return
     */
    String value() default "";
}
复制代码

  • @IntentMethod：该注解主要修饰方法，根据标识获取方法参数用于Activty交互。@Retention(RetentionPolicy.CLASS)：表示编译时注解，@Target({ElementType.METHOD, ElementType.CONSTRUCTOR})：表示修饰方法，构造函数，注解参数定义为String类型value值，表示目标Activiy类名。

    @Retention(RetentionPolicy.CLASS)
@Target({ElementType.METHOD, ElementType.CONSTRUCTOR})
public @interface IntentMethod {
    /**
     * 目标对象标识,如{@code MainActivity}
     *
     * @return
     */
    String value() default "";
}
复制代码

二、自定义注解处理器

不同注解类型，对应不同注解处理器，注解处理器主要作用就是注解解析。在定义编译时注解，我们需要通过继承AbstractProcessor这个类来创建注解处理器，并重写父类方法，一般只需要重新几个重要方法分别：

1、注解初始化
public synchronized void init(ProcessingEnvironment processingEnvironment)
2、注解解析
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
3、注解版本
public SourceVersion getSupportedSourceVersion()
4、解析类型
public Set<String> getSupportedAnnotationTypes()
复制代码

2.1、注解处理器初始化

AbstractProcessor注解处理器每次初始化只会调用一次init(ProcessingEnvironment processingEnvironment)方法，所以可以用来初始化工具类。

  @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        //注解处理器工具类
        mProcessorUtils = ProcessorUtils.getInstance(processingEnv);
        //解析注解信息类
        mJumpIntentGroupedClasses = new JumpIntentGroupedClasses();
        //生产模板对象
        initGenerated();
    }
    
    /**
     * 初始化Generated
     */
    private void initGenerated() {
        mGenerators = new LinkedList<>();
        mGenerators.add(new ActivityEnterGenerator());
        mGenerators.add(new ActivityOutGenerator());
    }
复制代码

2.2、绑定注解到注解处理器

getSupportedAnnotationTypes()方法是注解处理器能够识别注解类型。这里把注解@ObjectFactory存储到LinkedHashSet数据结构中，并返回集合，标识注解处理器识别目标注解对象。

 @Override
    public Set<String> getSupportedAnnotationTypes() {
        LinkedHashSet<String> types = new LinkedHashSet<>(2);
        types.add(IntentField.class.getCanonicalName());
        types.add(IntentMethod.class.getCanonicalName());
        return types;
    }
复制代码

2.3、注解解析处理

RoundEnvironment这个类中提供#getElementsAnnotatedWith()方法,可以根据注解类型返回该类型注解所有信息，通过Element可以获取注解信息。首先，获取@IntentMethod、@IntentField注解信息，把注解信息交给JumpIntentGroupedClasses#loanAnnotation(),进行注解信息解析封装成一个Map<String,Element> 数据结构，通过循环Map调用不同功能generator()方法，生成样板代码。这里需要定义两种模板代码，ActivityEnterGenerator.java:跳转起始模板生成,ActivityOutGenerator.java:跳转终点模板生成。process()方法生成的数据，在最后需要回收资源，避免循环调用。

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        //获取IntentMethod跳转方法所有注解信息
        Set<? extends Element> methodElement = roundEnv.getElementsAnnotatedWith(IntentMethod.class);
        //获取IntentField跳转成员变量所有注解信息
        Set<? extends Element> fieldElement = roundEnv.getElementsAnnotatedWith(IntentField.class);

        //解析注解信息
        mJumpIntentGroupedClasses.loanAnnotation(fieldElement,methodElement);

        Map<String, ExecutableElement> executableElementLists = mJumpIntentGroupedClasses.getExecutableElementLists();

        Map<String, List<VariableElement>> variableElementLists = mJumpIntentGroupedClasses.getVariableElementLists();


        //根据获取注解信息，进行代码文件生成
        ExecutableElement executableElement;
        for (Map.Entry<String, List<VariableElement>> entry : variableElementLists.entrySet()) {
            if (!mProcessorUtils.isNotEmpty(entry.getKey())) continue;
            executableElement = executableElementLists.get(entry.getKey());
            for (ActivityGenerator generator : mGenerators) {
                generator.generator(entry.getKey(), entry.getValue(),
                        executableElement, mProcessorUtils, processingEnv);
            }
        }

        //process()多次调用处理，所以配置信息及时释放
        variableElementLists.clear();
        executableElementLists.clear();
        return true;
    }
复制代码

三、解析注解信息，生成样板代码

3.1、解析注解信息

  1. loanParameterAnnotation():方法解析@IntentParameter注解信息，通过获取注解value值，跟methodValue字段比较并存储到相应组里。methodValue表示目标Activity类名，parameter表示传递给目标Activity参数。

     /**
  * 获取对应标识方法参数注解信息,并进行判断
  *
  * @param executableElement
  * @param methodValue
  */
 Map<String, List<VariableElement>> (Map<String, List<VariableElement>> variableElementLists,
                                                            ExecutableElement executableElement, String methodValue) {
     if (executableElement != null) {
         List<? extends VariableElement> parameterElement = executableElement.getParameters();
         for (Element parameter : parameterElement) {
             IntentParameter intentParameter = parameter.getAnnotation(IntentParameter.class);
             if (intentParameter != null) {
                 String parameterValue = intentParameter.value();
                 if ("".equals(parameterValue)) continue;
                 //方法同一标识判断
                 if (parameterValue.equals(methodValue)) {
                     //IntentField是应用在一般成员变量上的注解
                     variableElementLists.get(methodValue).add((VariableElement) parameter);
                 }
             }
         }
     }
  return variableElementLists;
 }
复制代码

  2. loadFieldAnnotation():方法解析@IntentField注解信息，根据注解信息value确定传递目标对象，并根据methodValue标识存储参数。

    /**
     * 获取对应标识中成员变量注解信息,并进行判断
     *
     * @param fieldElement
     * @param methodValue
     */
    Map<String, List<VariableElement>> loadFieldAnnotation(Map<String, List<VariableElement>> variableElementLists,
                                                           Set<? extends Element> fieldElement, String methodValue) {
        if (fieldElement != null && fieldElement.size() > 0) {
            VariableElement variableElement;
            for (Element field : fieldElement) {
                ElementKind fieldKind = field.getKind();
                if (fieldKind == ElementKind.FIELD) {
                    //判断Elements类型，并获取Filed参数值
                    variableElement = (VariableElement) field;
                    String filedValue = variableElement.getAnnotation(IntentField.class).value();

                    if ("".equals(filedValue)) continue;
                    //方法同一标识判断
                    if (filedValue.equals(methodValue)) {
                        //IntentField是应用在一般成员变量上的注解
                        variableElementLists.get(methodValue).add((VariableElement) field);
                    }
                }
            }
        }
        return variableElementLists;
    }
复制代码

3.2、封装注解信息

JumpIntentGroupedClasses.java中对解析注解信息进行封装控制流程。mVariableElementLists中存储了所有不同methodValue类型VariableElement注解信息，mExecutableElementLists中存储了所有不同methodValue类型ExecutableElement注解信息。这里VariableElement代表@IntentField、@IntentParameter注解转换为Element子类，ExecutableElement代表@IntentMethod注解转换为Element子类。首先获取@IntentMethod修饰方法注解value值，根据value来区分注解信息。在解析过程中，value标识对应@IntentField解析数据为空，会切换解析@IntentParameter注解，所有数据解决完成后，全都存储到数据结构Map中，并通过方法暴露出去，在生成样本代码时方便调用。

public class JumpIntentGroupedClasses {
    private JumpIntentClasses mJumpIntentClasses;

    //保存指定类型,所有VariableElement数据
    private Map<String, List<VariableElement>> mVariableElementLists = new HashMap<>();

    //保存指定类型，对应ExecutableElement数据
    private Map<String, ExecutableElement> mExecutableElementLists = new HashMap<>();

    public JumpIntentGroupedClasses(){
        mJumpIntentClasses=new JumpIntentClasses();
    }

    /**
     * 获取ExecutableElement集合数据
     * @return
     */
    public Map<String,ExecutableElement> getExecutableElementLists(){
        return mExecutableElementLists;
    }

    /**
     * 获取VariableElement集合数据
     * @return
     */
    public Map<String,List<VariableElement>> getVariableElementLists(){
        return mVariableElementLists;
    }

    /**
     * 获取注解信息
     * @param fieldElement
     * @param methodElement
     */
    public void loanAnnotation(Set<? extends Element> fieldElement, Set<? extends Element> methodElement){

        ExecutableElement executableElement = null;
        String methodValue = "";

        for (Element method : methodElement) {
            ElementKind methodKind = method.getKind();
            if (methodKind == ElementKind.METHOD) {
                //判断Elements类型，并获取Method参数值
                executableElement = (ExecutableElement) method;
                methodValue = executableElement.getAnnotation(IntentMethod.class).value();
            }

            //主要获取ElementType 是不是null，即class，interface，enum或者注解类型
            Element typeElement = method.getEnclosingElement();
            //判断方法参数，classFlag跳转标识判断
            if (!"".equals(methodValue)) {
                //如果mVariableElementLists的key不存在，则添加一个key
                if (mVariableElementLists.get(methodValue) == null) {
                    mVariableElementLists.put(methodValue, new LinkedList<VariableElement>());
                }

                mExecutableElementLists.put(methodValue, executableElement);

                //获取对应标识中成员变量注解信息,并进行判断
                mVariableElementLists=mJumpIntentClasses.loadFieldAnnotation(mVariableElementLists,fieldElement, methodValue);

                if (mVariableElementLists.get(methodValue).size() <= 0) {
                    //获取对应标识方法参数注解信息,并进行判断
                    mVariableElementLists= mJumpIntentClasses.loanParameterAnnotation(mVariableElementLists,executableElement, methodValue);
                }
            }
        }
    }
}
复制代码

3.3、生成样板代码

  1. ActivityGenerator.java：生成样板代码接口，clazzType标识注解修饰目标对象类名。

    /**
 * @Author: WeiShuai
 * @Time: 2020/4/30
 * @Description: Activity生成模板代码接口
 */
public interface ActivityGenerator {

    /**
     * 根据注解配置信息，{{@link VariableElement}}生成“样板”代码
     *
     * @param clazzType
     * @param variableElements
     * @param processingEnv
     */
    void generator(String clazzType,
                   List<VariableElement> variableElements,
                   ExecutableElement executableElement,
                   ProcessorUtils processorUtils,
                   ProcessingEnvironment processingEnv);
}
复制代码

  2. ActivityEnterGenerator.java:表示Activity跳转起始模板生成类，主要构建一个启动Activity视图逻辑代码，通过获取Element信息，来确定传递参数类型。

    /**
 * @Author: WeiShuai
 * @Time: 2020/4/30
 * @Description: Activity跳转起始模板生成
 */
public class ActivityEnterGenerator implements ActivityGenerator {


    /**
     * @param clazzType        类
     * @param variableElements 字段
     * @param processorUtils   工具
     * @param processingEnv
     */
    @Override
    public void generator(String clazzType,
                          List<VariableElement> variableElements,
                          ExecutableElement executableElement,,
                          ProcessorUtils processorUtils,
                          ProcessingEnvironment processingEnv) {
        MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(Constant.METHOD_JUMP_ACTIVITY)
                .addModifiers(Modifier.PUBLIC)
                .returns(void.class);


        methodBuilder.addParameter(Object.class, "context");
        methodBuilder.addStatement("android.content.Intent intent = new android.content.Intent()");
        for (VariableElement element : variableElements) {
            //Element 只是一种语言元素，本身并不包含信息，所以我们这里获取TypeMirror
            TypeMirror typeMirror = element.asType();
            //获取注解字段变量类型
            TypeName typeName = TypeName.get(typeMirror);
            //获取注解字段变量名称
            String fieldName = element.getSimpleName().toString();

            methodBuilder.addParameter(typeName, fieldName);
            methodBuilder.addStatement("intent.putExtra(\"" + fieldName + "\"," + fieldName + ")");

        }

        if (!processorUtils.isNotEmpty(clazzType)) {
            processingEnv.getMessager().printMessage(
                    Diagnostic.Kind.ERROR,
                    "IntentClass注解定义不明确,无法进行界面跳转!"
            );
        }


        methodBuilder.addStatement("intent.setClass((android.content.Context)context, " + clazzType + ".class)");
        methodBuilder.addStatement("((android.content.Context)context).startActivity(intent)");


        TypeElement typeElement = (TypeElement)
                executableElement.getEnclosingElement();

        processorUtils.writeToFile(clazzType + Constant.JUMP_SUFFIX,
                processorUtils.getPackageName(typeElement),
                methodBuilder.build(), processingEnv, null);

    }
}
复制代码

  3. ActivityOutGenerator.java:表示Activity跳转终点模板生成类,主要构建一个解析Activity传递参数逻辑代码，通过获取Element信息，来确定传递参数类型。

    /**
 * @Author: WS
 * @Time: 2020/5/4
 * @Description: Activity跳转终点模板生成
 */
public class ActivityOutGenerator implements ActivityGenerator {

    @Override
    public void generator(String clazzType,
                          List<VariableElement> variableElements,
                          ExecutableElement executableElement,
                          ProcessorUtils processorUtils,
                          ProcessingEnvironment processingEnv) {
        //存储成员变量信息
        ArrayList<FieldSpec> listField = new ArrayList<>();

        MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(Constant.METHOD_INIT_ACTIVITY)
                .addModifiers(Modifier.PUBLIC)
                .returns(Object.class);


        if (!processorUtils.isNotEmpty(clazzType)) {
            processingEnv.getMessager().printMessage(
                    Diagnostic.Kind.ERROR,
                    "IntentClass注解定义不明确,无法进行界面跳转!"
            );
        }

        methodBuilder.addParameter(Object.class, "activity");
        methodBuilder.addStatement(clazzType + " nextActivity = (" + clazzType + ") activity");
        methodBuilder.addStatement("android.content.Intent intent=nextActivity.getIntent()");

        for (VariableElement element : variableElements) {
            //Element 只是一种语言元素，本身并不包含信息，所以我们这里获取TypeMirror
            TypeMirror typeMirror = element.asType();
            //获取注解字段变量类型
            TypeName typeName = TypeName.get(typeMirror);
            //获取注解字段变量名称
            String fieldName = element.getSimpleName().toString();
            //注解类型转换为Intent传输类型
            String intentTypeName = processorUtils.getIntentTypeName(typeName.toString());
            //创建成员变量
            FieldSpec fieldSpec = FieldSpec.builder(typeName, fieldName)
                    .addModifiers(Modifier.PUBLIC)
                    .build();
            listField.add(fieldSpec);

            if (processorUtils.isElementNoDefaultValue(typeName.toString())) {
                methodBuilder.addStatement("this." + fieldName + "=intent.get" + intentTypeName + "Extra(\"" + fieldName + "\")");
            } else {
                if (intentTypeName == null) {
                    processingEnv.getMessager().printMessage(
                            Diagnostic.Kind.ERROR,
                            "the type:" + element.asType().toString() + " is not support"
                    );
                } else {
                    String defaultValue = "default" + fieldName;
                    if ("".equals(intentTypeName)) {
                        //序列化数据获取
                        methodBuilder.addStatement("this." + fieldName + "=(" + typeName + ")intent.getSerializableExtra(\"" + fieldName + "\")");
                    } else {
                        methodBuilder.addParameter(typeName, defaultValue);
                        methodBuilder.addStatement("this." + fieldName + "= intent.get"
                                + intentTypeName + "Extra(\"" + fieldName + "\", " + defaultValue + ")");
                    }
                }
            }
        }
        methodBuilder.addStatement("return this");

        TypeElement typeElement = (TypeElement)
                executableElement.getEnclosingElement();

        processorUtils.writeToFile(clazzType + Constant.INIT_SUFFIX,
                processorUtils.getPackageName(typeElement),
                methodBuilder.build(), processingEnv, listField);
    }
}
复制代码

四、功能点测试

4.1、测试代码

  1. 定义启动Activity代码，参数类型。

    public class OneActivity extends AppCompatActivity {

    //@IntentField("MainActivity")
    String name = "Activity";

    //@IntentField("MainActivity")
    int count = 0;

    @IntentField("TwoActivity")
    String title = "OneActivity";

    @IntentField("TwoActivity")
    UserInfo userInfo;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_one);
    }

    public void click(View view) {
        int id = view.getId();
        switch (id) {
            case R.id.mBtOneMain:
                jumpOneToMainActivity(name, count, "title");
                break;
            case R.id.mBtOneTwo:
                jumpOneToTwoActivity();
                break;
        }
    }

    @IntentMethod("MainActivity")
    public void jumpOneToMainActivity(@IntentParameter("MainActivity") String name,
                                      @IntentParameter("MainActivity") int count,
                                      String title) {
        new MainActivity$Jump().jumpActivity(OneActivity.this, name, count);
    }

    @IntentMethod("TwoActivity")
    public void jumpOneToTwoActivity() {
        userInfo = new UserInfo("username", "password");
        new TwoActivity$Jump().jumpActivity(OneActivity.this, title, userInfo);
    }
}
复制代码

  2. 获取Activity传递参数信息。

    public class MainActivity extends AppCompatActivity {

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

    /**
     * 获取数据
     */
    private void initData() {
        MainActivity$Init activity = (MainActivity$Init)
                new MainActivity$Init().initActivity(this, 0);
        int count = activity.count;
        String name = activity.name;
        Toast.makeText(this,
                "count=" + count + ";name=" + name, Toast.LENGTH_SHORT).show();
    }
}


public class TwoActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_two);
        initData();
    }

    /**
     * 获取数据
     */
    private void initData() {
        TwoActivity$Init activity = (TwoActivity$Init)
                new TwoActivity$Init().initActivity(this);
        String title = activity.title;
        UserInfo userInfo = activity.userInfo;
        Toast.makeText(this, "title=" + title + ";username=" +
                        userInfo.username + ";password" + userInfo.password,
                Toast.LENGTH_LONG).show();
    }
}
复制代码

4.2、样板代码

public final class MainActivity$Init {
  public String name;

  public int count;

  public Object initActivity(Object activity, int defaultcount) {
    MainActivity nextActivity = (MainActivity) activity;
    android.content.Intent intent=nextActivity.getIntent();
    this.name=intent.getStringExtra("name");
    this.count= intent.getIntExtra("count", defaultcount);
    return this;
  }
}

public final class MainActivity$Jump {
  public void jumpActivity(Object context, String name, int count) {
    android.content.Intent intent = new android.content.Intent();
    intent.putExtra("name",name);
    intent.putExtra("count",count);
    intent.setClass((android.content.Context)context, MainActivity.class);
    ((android.content.Context)context).startActivity(intent);
  }
}

public final class TwoActivity$Init {
  public String title;

  public UserInfo userInfo;

  public Object initActivity(Object activity) {
    TwoActivity nextActivity = (TwoActivity) activity;
    android.content.Intent intent=nextActivity.getIntent();
    this.title=intent.getStringExtra("title");
    this.userInfo=(com.linwei.annotation.bean.UserInfo)intent.getSerializableExtra("userInfo");
    return this;
  }
}

public final class TwoActivity$Jump {
  public void jumpActivity(Object context, String title, UserInfo userInfo) {
    android.content.Intent intent = new android.content.Intent();
    intent.putExtra("title",title);
    intent.putExtra("userInfo",userInfo);
    intent.setClass((android.content.Context)context, TwoActivity.class);
    ((android.content.Context)context).startActivity(intent);
  }
}
复制代码

About me

分类：
阅读
标签：
AndroidAnnotations
分类：
阅读
标签：
AndroidAnnotations
相关推荐
  • Zuo
    1年前
    Android
    Android修炼系列（五），写一篇超全面的annotation讲解
    不学注解，也许是因为平时根本不需要没事自定义个这玩意玩，可随着Android形势越来越内卷，不学点东西是真不行了。而通过本文的学习，可以让你对于注解有个全面的认识，你会发现，小小的注解，大有可为，编不下去了.. 注解不同于注释，注释的作用是为了方便自己或者别人的阅读，能够利用 …
    • 2433
    • 3
  • 码眼
    6月前
    后端
    阿里EasyExcel让你彻底告别easypoi
    为什么说EasyExcel可以让你告别easypoi呢？在说这个问题之前我们先来了解下easypoi easypoi 这是easypoi官方给出的定义，使用这个工具后发现在进行excel的导入导出时，
    • 4915
    • 9
    阿里EasyExcel让你彻底告别easypoi
  • 编程的平行世界
    7月前
    前端 Flutter
    我为大家带来了二十张登录界面😎！！！
    上次给大家分享了15张的移动端登录界面,这次给大家带来了20张Web登录界面，真的是辛辛苦苦收集了好久，如果有喜欢的不妨给我点个赞吧，感谢！！！
    • 8.9w
    • 151
    我为大家带来了二十张登录界面😎！！！
  • android的那点事
    4年前
    Android AndroidAnnotations Android Wear
    android高级自定义控件（超炫加载过渡特效）
    直接上图吧，先看一下效果先：看了效果是不是觉得超炫，想了解是怎么做的，从往下看；先看xml布局：从上面布局看，很简单，用了FrameLayout，先放了ImageView，就是我们看到动画执行到最后的
    • 243
    • 评论
  • 程序员依扬
    2年前
    面试 前端
    【1 月最新】前端 100 问：能搞懂 80% 的请把简历给我
    半年时间，几千人参与，精选大厂前端面试高频 100 题，这就是「壹题」。 在 2019 年 1 月 21 日这天，「壹题」项目正式开始，在这之后每个工作日都会出一道高频面试题，主要涵盖阿里、腾讯、头条、百度、网易等大公司和常见题型。得益于大家热情参与，现在每道题都有很多答案，提…
    • 53.9w
    • 310
  • 王晨彦
    2年前
    AndroidAnnotations
    手撸一个 Router 框架（上）：熟悉 APT
    ARouter 过于强大，很多功能我们不一定用得上，而且不一定适合我们的项目，自己撸一个，可以在满足项目需求的情况下，功能上去繁就简。 实践出真知，我想这也是很多开发者重复造轮子的主要原因吧。我们经常阅读许多大牛对于优秀框架的剖析，但那也只是大牛的理解，我们自己的呢？ 便于排查…
    • 2458
    • 3
    手撸一个 Router 框架（上）：熟悉 APT
  • Ccww
    2年前
    Spring Boot
    推荐收藏系列：Spring boot 2.x注解Annotation大全（持续更新....）
    为了方便我们在日常开发注解的使用，本文将开发所需要的注解统一并进行归类起来,并结合用例进行解析，这样收藏起来以便日后使用。最主要本文将持续更新日常使用的注解，也可以评论中告知其他注解。 @component，而其余 @Controller、@Service、@Repositor…
    • 7148
    • 10
  • zxhtom
    10月前
    后端
    基于注解解耦POI导出繁琐映射 l 早点落地就没easyexcel啥事了
    这是我参与更文挑战的第30天，活动详情查看： 更文挑战 前提 相信很多小伙伴刚入行时都是流水性的编程!遇到需求直接开发就完事了。但是这样带了的结果就是代码不易维护。稍微需求变动可能带来的就是灾难性的复
    • 3644
    • 14
    基于注解解耦POI导出繁琐映射 l 早点落地就没easyexcel啥事了
  • zz
    10月前
    前端 面试
    后端一次给你10万条数据,如何优雅展示，面试官到底考察我什么?
    背景 面试题:后台传给前端十万条数据,你作为前端如何渲染到页面上? 回答者A：我有句话不知当讲不当讲,这什么鬼需求。
    • 18.5w
    • 326
  • TravelingLight_
    2年前
    AndroidAnnotations
    Android 注解（Annotation）的自定义和解析方式
    找到 Annotation 这个接口，然后 Control + H 可以发现 Override 继承自 Annotation。 查看 Annotation的文档得知所有的注解类型都继承自此接口。 注解就是用来标记 SourceCode 中的 Class,Field,Method…
    • 2107
    • 1
  • 火狼1
    2年前
    JavaScript 前端
    JS 原生面经从初级到高级【近1.5W字】
    调整文章格式 调整文章格式 调整文章格式 调整文章格式 调整文章格式 调整文章格式 调整文章格式 调整文章格式
    • 12.3w
    • 188
    JS 原生面经从初级到高级【近1.5W字】
  • 7ommy
    3年前
    Android AndroidAnnotations
    分享一个简单的画刷动画效果：🖌️BrushEffect
    前一阵子刷 即刻 的时候，在UI Movement主题下看到了这个动画效果。 当时觉得挺简单的而且效果不错，就自己试了试。
    • 1778
    • 2
  • Frank909
    4年前
    Android Java
    秒懂，Java 注解 （Annotation）你可以这样学
    Java 注解是一个让初学者稍微难于理解的概念。本文从独特的角度出发，通过特别形象的比喻让读者以极快的速度去认识注解这个概念的意义所在。
    • 4307
    • 4
    秒懂，Java 注解 （Annotation）你可以这样学
  • 未来靠打拼
    5年前
    Android
    Android 注解使用之使用 Support Annotations 注解优化代码
    Android 注解使用之使用 Support Annotations 注解优化代码
    • 1579
    • 评论
  • 赖一鸣
    9月前
    Node.js
    文件直传 OSS 实践（一）：服务端篇
    本文以阿里云 OSS（Object Storage Service，对象存储服务）为例，详细说明将文件从客户端直传 OSS 的整体流程，并提供了完整的代码演示。
    • 37.6w
    • 4
    文件直传 OSS 实践（一）：服务端篇
  • 极乐君
    5年前
    Java Spring Boot
    Spring Boot 整合 Mybatis Annotation 注解的完整 Web 案例
    距离第一篇 Spring Boot 系列的博文 3 个月了。《Springboot 整合 Mybatis 的完整 Web 案例》第一篇出来是 XML 配置 SQL 的形式。虽然 XML 形式是我比较推荐的，但是注解形式也是方便的。尤其一些小系统，快速的 CRUD 轻量级的系统。
    • 1876
    • 评论
  • 酸奶过期差一天
    5月前
    后端
    Java-注解(Annotation)
    了解注解 注解是什么 进一步理解注解 注解语法 注解接口(注解类型)的定义 注解接口定义Demo @interface 注意 所有的注解接口都隐式的扩展自java.lang.annotation.An
    • 155
    • 评论
  • oden
    5年前
    Android
    Annotation常用注解使用说明
    简介 AndroidAnnotations是一个开源框架，通过使用它开放出来的注解api，可以大大的减少无关痛痒的代码量，简洁代码。 官方文档_github链接 第三方库导入 目前最新版本为4.1.0 在app/目录下的build.gradle（局部gradle）中添加下面配置…
    • 1544
    • 评论
  • DrkCore在掘金
    4年前
    Android
    Android：写一个专注的编译时注解框架——ContentViewAnnotation
    ButterKnife什么都好，就是没有ContentView注解。没有轮子，那就自己写一个吧！
    • 422
    • 评论
  • 后端码匠
    1年前
    Spring Boot
    Java常用注解(Annotation)详解汇总
    @Documented 会被javadoc工具动态提取成文档。 @Inherited 允许子类继承父类中的注解。 这些注解描述的类 Spring会创建原生对象或代理对象并交给 IOC容器 管理，这些对象称之为bean。用时直接 @Autowired 注入即可。 @RestCon…
    • 651
    • 评论
    Java常用注解(Annotation)详解汇总
    • 全干工程师
    获得点赞 1
    文章被阅读 5,499
    下载稀土掘金APP
    一个帮助开发者成长的社区
    相关文章
    从手写ButterKnife到掌握注解、AnnotationProcessor
    22点赞
     · 
    5评论
    Java 注解（Annotation）：带你一步步探索神秘的注解（Annotation）
    71点赞
     · 
    2评论
    Java 注解 （Annotation）浅入深出
    18点赞
     · 
    0评论
    easyExcel中的注解
    7点赞
     · 
    0评论
    Java注解(Annotation)详解
    34点赞
     · 
    0评论
    收藏成功！
    已添加到「」， 点击更改