打造属于自己的IOC注解框架

最新推荐文章于 2022-04-19 11:45:27 发布
最新推荐文章于 2022-04-19 11:45:27 发布
阅读量2.8k 收藏
点赞数
分类专栏： android学习 设计模式&架构 文章标签： android IOC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huangxiaoguo1/article/details/80753589
版权
  • 效果

这里写图片描述

  • java注解-ElementType详解

     java中元注解有四个： @Retention @Target @Document @Inherited；

 @Retention：注解的保留位置　（什么时候生效）　　　　　　　　

     //注解仅存在于源码中，在class字节码文件中不包含
　　　@Retention(RetentionPolicy.SOURCE) 
　　　　　　
　　 //编译时注解： 默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得，
　　 @Retention(RetentionPolicy.CLASS) 
　　　　　　   
　　 //运行时注解： 注解会在class字节码文件中存在，在运行时可以通过反射获取到
　　 @Retention(RetentionPolicy.RUNTIME)  

@Target:注解的作用目标
　　　　　　　　
　　　　　　　　@Target(ElementType.TYPE)   //接口、类、枚举、注解
　　　　　　　　@Target(ElementType.FIELD) //字段、枚举的常量
　　　　　　　　@Target(ElementType.METHOD) //方法
　　　　　　　　@Target(ElementType.PARAMETER) //方法参数
　　　　　　　　@Target(ElementType.CONSTRUCTOR)  //构造函数
　　　　　　　　@Target(ElementType.LOCAL_VARIABLE)//局部变量
　　　　　　　　@Target(ElementType.ANNOTATION_TYPE)//注解
　　　　　　　　@Target(ElementType.PACKAGE) ///包   

@Document：说明该注解将被包含在javadoc中

@Inherited：说明子类可以继承父类中的该注解
  • 布局注入注解
package tsou.cn.lib_hxgioc;

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

/**
 * Created by huangxiaoguo on 2018/6/20 0020.
 * <p>
 * View 注解的Annotation
 * <p>
 * ElementType.FIELD
 * 代表Annotation的位置，FIELD属性：字段、枚举的常量
 *
 * TYPE:接口、类、枚举、注解
 * <p>
 * RetentionPolicy.CLASS（什么时候生效）
 * 编译时注解： 默认的保留策略，注解会在class字节码文件中存在，
 * 但运行时无法获得
 * RetentionPolicy.RUNTIME：运行时注解
 * 注解会在class字节码文件中存在，在运行时可以通过反射获取到
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface HxgContentView {
    //@HxgContentView(R.layout.activity_main)
    int value();
}
  • 属性 id注入注解
package tsou.cn.lib_hxgioc;

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

/**
 * Created by huangxiaoguo on 2018/6/20 0020.
 * <p>
 * View 注解的Annotation
 * <p>
 * ElementType.FIELD
 * 代表Annotation的位置，FIELD属性：字段、枚举的常量
 * <p>
 * RetentionPolicy.CLASS（什么时候生效）
 * 编译时注解： 默认的保留策略，注解会在class字节码文件中存在，
 * 但运行时无法获得
 * RetentionPolicy.RUNTIME：运行时注解
 * 注解会在class字节码文件中存在，在运行时可以通过反射获取到
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface HxgBind {
    //@HxgBind(R.id.xxx)
    int value();
}
  • 方法注入注解（这里指的是点击事件）
package tsou.cn.lib_hxgioc;

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

/**
 * Created by huangxiaoguo on 2018/6/20 0020.
 * <p>
 * View 事件注解的Annotation
 * <p>
 * ElementType.FIELD
 * 代表Annotation的位置，FIELD属性：字段、枚举的常量
 * METHOD：方法
 * <p>
 * RetentionPolicy.CLASS（什么时候生效）
 * 编译时注解： 默认的保留策略，注解会在class字节码文件中存在，
 * 但运行时无法获得
 * RetentionPolicy.RUNTIME：运行时注解
 * 注解会在class字节码文件中存在，在运行时可以通过反射获取到
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface HxgOnClick {
    //@HxgOnClick(R.id.text_iv)
    //@HxgOnClick({R.id.text_iv,R.id.btn})
    int[] value();
}
  • 方法注入注解（这里指的是检查网络）
package tsou.cn.lib_hxgioc;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * Created by huangxiaoguo on 2018/6/20 0020.
 * <p>
 * View 事件注解的Annotation
 * <p>
 * ElementType.FIELD
 * 代表Annotation的位置，FIELD属性：字段、枚举的常量
 * METHOD：方法
 * <p>
 * RetentionPolicy.CLASS（什么时候生效）
 * 编译时注解： 默认的保留策略，注解会在class字节码文件中存在，
 * 但运行时无法获得
 * RetentionPolicy.RUNTIME：运行时注解
 * 注解会在class字节码文件中存在，在运行时可以通过反射获取到
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface HxgCheckNet {
    int value();
}
  • 定义注入接口
package tsou.cn.lib_hxgioc;

import android.app.Activity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

/**
 * Created by Administrator on 2018/6/20 0020.
 */

public interface HxgViewInjector {
    /**
     * 注入view
     *
     * @param view
     */
    void inject(View view);

    /**
     * 注入activity
     *
     * @param activity
     */
    void inject(Activity activity);

    /**
     * 注入view holder
     *
     * @param object view holder
     * @param view
     */
    void inject(View view,Object object);

    /**
     * 注入fragment
     *
     * @param fragment
     * @param inflater
     * @param container
     * @return
     */
    View inject(Object fragment, LayoutInflater inflater, ViewGroup container);
}
  • FindViewById的辅助类
package tsou.cn.lib_hxgioc;

import android.app.Activity;
import android.view.View;

/**
 * Created by Administrator on 2018/6/20 0020.
 * <p>
 * FindViewById的辅助类
 */

public class HxgViewHelper {
    private Activity mActivity;
    private View mView;

    public HxgViewHelper(Activity activity) {
        this.mActivity = activity;
    }

    public HxgViewHelper(View view) {
        this.mView = view;
    }

    public View findViewById(int viewId) {
        return mActivity != null ? mActivity.findViewById(viewId) : mView.findViewById(viewId);
    }
}
  • 实现注入方法
package tsou.cn.lib_hxgioc;

import android.app.Activity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Toast;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashSet;

import tsou.cn.lib_hxgioc.utils.NetUtils;

/**
 * Created by Administrator on 2018/6/20 0020.
 */

public class HxgViewInjectorImpl implements HxgViewInjector {
    private static final HashSet<Class<?>> IGNORED = new HashSet<Class<?>>();

    static {
        IGNORED.add(Object.class);
        IGNORED.add(Activity.class);
        IGNORED.add(android.app.Fragment.class);
        try {
            IGNORED.add(Class.forName("android.support.v4.app.Fragment"));
            IGNORED.add(Class.forName("android.support.v4.app.FragmentActivity"));
        } catch (Throwable ignored) {
        }
    }

    private static HxgViewInjectorImpl instance;

    private HxgViewInjectorImpl() {
    }

    public static void registerInstance() {
        if (instance == null) {
            synchronized (HxgViewInjectorImpl.class) {
                if (instance == null) {
                    instance = new HxgViewInjectorImpl();
                }
            }
        }
        HxgViewUtils.hxgExt.setViewInjector(instance);
    }

    /**
     * 注入view
     *
     * @param view
     */
    @Override
    public void inject(View view) {
        inject(new HxgViewHelper(view), view);
    }

    /**
     * 注入activity
     *
     * @param activity
     */
    @Override
    public void inject(Activity activity) {
        inject(new HxgViewHelper(activity), activity);
    }

    /**
     * 注入view holder
     *
     * @param object view holder
     * @param view
     */
    @Override
    public void inject(View view, Object object) {
        injectObject(new HxgViewHelper(view), object);
    }

    /**
     * 注入fragment
     *
     * @param fragment
     * @param inflater
     * @param container
     * @return
     */
    @Override
    public View inject(Object fragment, LayoutInflater inflater, ViewGroup container) {
        View view = null;
        Class<?> handlerType = fragment.getClass();
        try {
            HxgContentView contentView = findContentView(handlerType);
            if (contentView != null) {
                int viewId = contentView.value();
                if (viewId > 0) {
                    view = inflater.inflate(viewId, container, false);
                }
            }
        } catch (Throwable ex) {
            ex.printStackTrace();
        }
        injectObject(new HxgViewHelper(view), fragment);
        return view;
    }

    /**
     * 兼容上面三个方法
     * (注入view,注入activity,注入view holder)
     *
     * @param finder
     * @param object 反射需要执行的类
     */
    private static void inject(HxgViewHelper finder, Object object) {
        inContentView(finder, object);
    }


    /**
     * 注入ContentView
     *
     * @param finder
     * @param object
     */
    private static void inContentView(HxgViewHelper finder, Object object) {
        Class<?> handlerType = object.getClass();
        try {
            HxgContentView contentView = findContentView(handlerType);
            if (contentView != null) {
                int viewId = contentView.value();
                if (viewId > 0) {
                    Method setContentViewMethod = handlerType.getMethod("setContentView", int.class);
                    setContentViewMethod.invoke(object, viewId);
                }
            }
        } catch (Throwable ex) {
            ex.printStackTrace();
        }
        injectObject(finder, object);
    }


    /**
     * 从父类获取注解View
     */
    private static HxgContentView findContentView(Class<?> thisCls) {
        if (thisCls == null || IGNORED.contains(thisCls)) {
            return null;
        }
        HxgContentView contentView = thisCls.getAnnotation(HxgContentView.class);
        if (contentView == null) {
            return findContentView(thisCls.getSuperclass());
        }
        return contentView;
    }

    private static void injectObject(HxgViewHelper finder, Object object) {
        if (object == null || IGNORED.contains(object)) {
            return;
        }
        injectFiled(finder, object);
        injectEvent(finder, object);
    }

    /**
     * 注入属性
     *
     * @param finder
     * @param object
     */
    private static void injectFiled(HxgViewHelper finder, Object object) {
        //1、获取类里面所有的属性
        Class<?> aClass = object.getClass();
        //  获取所有的属性包括私有和公有
        Field[] fields = aClass.getDeclaredFields();
        //2、获取viewById里面的value值
        for (Field field : fields) {
            HxgBind viewById = field.getAnnotation(HxgBind.class);
            if (null != viewById) {
                //获取注解里面的id值—>R.id.xxx
                int viewId = viewById.value();
                //3、findViewById找到View
                View view = finder.findViewById(viewId);
                if (null != view) {
                    //能够注入所有修饰符：private，public
                    field.setAccessible(true);
                    //4、动态的注入找到View
                    try {
                        field.set(object, view);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    /**
     * 事件注入
     *
     * @param finder
     * @param object
     */
    private static void injectEvent(HxgViewHelper finder, Object object) {
        //1、获取类里面所有的方法
        Class<?> aClass = object.getClass();
        Method[] methods = aClass.getDeclaredMethods();
        //2、获取OnClick里面的value
        for (Method method : methods) {
            HxgOnClick onClick = method.getAnnotation(HxgOnClick.class);
            if (null != onClick) {
                int[] viewIds = onClick.value();
                //能够注入所有方法：private，public
                method.setAccessible(true);
                for (int viewId : viewIds) {
                    //3、findViewById找到View
                    View view = finder.findViewById(viewId);

                    /**
                     * 扩展，检查网络
                     */
                    HxgCheckNet checkNet = method.getAnnotation(HxgCheckNet.class);
                    int stringName = 0;
                    if (null != checkNet) {
                        stringName = checkNet.value();
                    }
                    boolean isCheckNet = checkNet != null;
                    if (null != view) {
                        //4、setOnClickListener
                        view.setOnClickListener(new DeclaredOnClickListner(method, object,
                                isCheckNet, stringName));
                    }
                }
            }
        }
    }

    private static class DeclaredOnClickListner implements View.OnClickListener {
        private Object mObject;
        private Method mMethod;
        private boolean mIsCheckNet;
        private int mStringName;

        public DeclaredOnClickListner(Method method, Object object, boolean isCheckNet, int stringName) {
            this.mMethod = method;
            this.mObject = object;
            this.mIsCheckNet = isCheckNet;
            this.mStringName = stringName;
        }

        @Override
        public void onClick(View view) {
            //检查网络
            if (mIsCheckNet) {
                if (!NetUtils.isNetworkConnected(view.getContext())) {
                    String context="网络不太给力~";
                    if (mStringName!=0){
                        context=view.getContext().getString(mStringName);
                    }
                    Toast.makeText(view.getContext(), context, Toast.LENGTH_LONG).show();
                    return;
                }
            }
            //5、反射注入方法
            try {
                mMethod.invoke(mObject, view);
            } catch (Exception e) {
                e.printStackTrace();
                //mMethod.invoke(mObject, null);
            }
        }
    }
}
  • 获得注入事件类
package tsou.cn.lib_hxgioc;

/**
 * Created by Administrator on 2018/6/20 0020.
 */

public class HxgViewUtils {
    private HxgViewUtils() {
    }

    public static HxgViewInjector getView() {
        if (hxgExt.viewInjector == null) {
            HxgViewInjectorImpl.registerInstance();
        }
        return hxgExt.viewInjector;
    }
     static class hxgExt{
         private static HxgViewInjector viewInjector;
        private hxgExt() {
        }
        public static void setViewInjector(HxgViewInjector viewInjector) {
            hxgExt.viewInjector = viewInjector;
        }

    }
}
  • Activity中使用
package tsou.cn.zidinyidemo;

import android.os.Bundle;
import android.support.v4.app.FragmentManager;
import android.support.v7.app.AppCompatActivity;
import android.widget.Button;
import android.widget.FrameLayout;
import android.widget.TextView;
import android.widget.Toast;

import tsou.cn.lib_hxgioc.HxgBind;
import tsou.cn.lib_hxgioc.HxgCheckNet;
import tsou.cn.lib_hxgioc.HxgContentView;
import tsou.cn.lib_hxgioc.HxgOnClick;
import tsou.cn.lib_hxgioc.HxgViewUtils;

@HxgContentView(R.layout.activity_main)
public class MainActivity extends AppCompatActivity {

    @HxgBind(R.id.text_iv)
    private TextView mTextIv;
    @HxgBind(R.id.fl_main)
    private FrameLayout mFlMain;
    private FragmentManager fragmentManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        HxgViewUtils.getView().inject(this);
        mTextIv.setText("haungxiaoguo");
        fragmentManager = getSupportFragmentManager();
        fragmentManager.beginTransaction().replace(R.id.fl_main, new MyFragment())
                .commitAllowingStateLoss();
    }

    @HxgOnClick(R.id.text_iv)
    @HxgCheckNet(R.string.net_net_string)
    private void onClick(TextView view) {
        Toast.makeText(this, "点击了TextView", Toast.LENGTH_LONG).show();
    }

    @HxgOnClick({R.id.btn})
    private void onClick(Button view) {
        Toast.makeText(this, "点击了Button", Toast.LENGTH_LONG).show();
    }
}
  • Fragment中使用
package tsou.cn.zidinyidemo;

import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;

import tsou.cn.lib_hxgioc.HxgBind;
import tsou.cn.lib_hxgioc.HxgCheckNet;
import tsou.cn.lib_hxgioc.HxgContentView;
import tsou.cn.lib_hxgioc.HxgOnClick;
import tsou.cn.lib_hxgioc.HxgViewUtils;

/**
 * Created by Administrator on 2018/6/20 0020.
 */
@HxgContentView(R.layout.layout_fragent)
public class MyFragment extends Fragment {

    @HxgBind(R.id.btn_frist)
    private Button mBtnFrist;
    @HxgBind(R.id.tv_frist)
    private TextView mTvFrist;

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
                             @Nullable Bundle savedInstanceState) {
        View mView = HxgViewUtils.getView().inject(this, inflater, container);
        mBtnFrist.setText("button");
        mTvFrist.setText("textView");
        return mView;
    }

    @HxgOnClick(R.id.btn_frist)
    @HxgCheckNet(R.string.net_net_string)
    private void onClick(Button button) {
        Toast.makeText(getContext(), "点击了button", Toast.LENGTH_LONG).show();
    }

    @HxgOnClick(R.id.tv_frist)
    private void onClick(TextView textView) {
        Toast.makeText(getContext(), "点击了textView", Toast.LENGTH_LONG).show();
    }
}
  • 另附检查网络方法
package tsou.cn.lib_hxgioc.utils;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;

/**
 * Created by Administrator on 2018/6/20 0020.
 */

public class NetUtils {
    /**
     * 判断网络是否可用
     *
     * @param context
     * @return
     */
    public static boolean isNetworkConnected(Context context) {
        if (context != null) {
            ConnectivityManager mConnectivityManager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo mNetworkInfo = mConnectivityManager.getActiveNetworkInfo();
            if (mNetworkInfo != null) {
                return mNetworkInfo.isAvailable();
            }
        }
        return false;
    }
}
晓果博客
关注
专栏目录
秒懂，Java 注解 （Annotation）你可以这样学
frank 的专栏
06-27 27万+
文章开头先引入一处图片。 这处图片引自老罗的博客。为了避免不必要的麻烦，首先声明我个人比较尊敬老罗的。至于为什么放这张图，自然是为本篇博文服务，接下来我自会说明。好了，可以开始今天的博文了。 Annotation 中文译过来就是注解、标释的意思，在 Java 中注解是一个很重要的知识点，但经常还是有点让新手不容易理解。 我个人认为，比较糟糕的技术文档主要特征之一就是：用专业名词来...
Spring IOC\AOP\事务\注解
最新发布
qq_45729025的博客
12-24 1245
Spring IOC\AOP\事务\注解 （不是我的笔记，看代码文件就行，代码满注解很齐全） （这个我自己参考就行）
模拟Spring的IoC容器实现注解自动装配
05-10
自己实现的简易的模拟Spring的IoC容器，实现注解自动装配
自己来实现一套IOC注解框架
weixin_33727510的博客
01-03 154
我们自己来实现一套IOC注解框架吧，采用的方式反射加注解和Xutils类似，但我们尽量不写那么麻烦，也不打算采用动态代理，我们扩展一个检测网络的注解，比如没网的时候我们不去执行方法而是给予没有网络的提示同时也不允许用户反复点击。 　　这个时候有人就开始喷了，明知道反射会影响性能为什么还要用？这里我就随便说说吧，我承认反射会影响性能但是问题不大我们可以自己去测试反射1万次大概会怎样，如果你非得去纠结...
自己动手打造一套IOC注解框架
weixin_45468727的博客
09-18 222
自己动手打造一套IOC注解框架1.概述2.框架实现  2.1.定义属性控件注解  2.2.定义点击事件注解+网络检查注解3.使用4.效果展示 1.概述   什么是IOC，控制反转（Inversion of Control，英文缩写为IOC），其实就是反射加注解，Android IOC框架，其实主要就是帮大家注入所有的控件，布局文件什么的。如果你用过xUtils，Butterkinfe等框架，你肯定...
使用注解打造自己的IOC框架
weixin_34191845的博客
11-28 105
一、简述 IoC和AOP可谓是后台开发入门必学的知识（Spring相关），但这两者都仅仅只是概念而已，并非具体技术实现，同样的，Android也可以使用IoC和AOP，之前已经写过如何在Android开发中使用AOP了，有兴趣的朋友可以看我之前的博客（顺便点个关注吧），所以，本文主题便是IoC。 控制反转（Inversion of Control，英文缩写为IoC）是框架的重要特征，并非面向对象...
各框架下的常用注解
L12131415L的博客
04-19 1319
Spring、Spring MVC、Mybatis、Spring Boot等框架常用注解
Spring+SpringMVC+MyBatis框架的整合+注解
thinkhi9999的博客
08-24 2324
标准主流现在编程方式都是采用MVC综合设计模式，MVC本身不属于设计模式的一种，它描述的是一种结构，最终目的达到解耦，解耦说的意思是你更改某一层代码，不会影响我其它层代码，如果你会像Spring这样的框架，你会了解面向接口编程，表示层调用控制层，控制层调用业务层，业务层调用数据访问层。如果不使用任何框架，而单纯使用Servlet和JDBC技术，甚至只用JSP技术，同样可以实现JAVAWEB的项目开发，但这样的项目具体工作码量大，代码之间的耦合性极强，如果需要调整某一功能 ，出于连锁反应，可能要修改所有的源代
Spring IOC、DI的概念和@Autowired注入
Resee_Z的博客
08-01 950
最近看到一位大神的视频讲解Spring的IOC、Bean的注入方式。打算整理一下，分享出来。 一、 Spring的IOC、DI概念 IOC 全称 Inversion of Control 控制反转，DI 全称 dependency injection 依赖注入。 很多博客文章都在表达一个意思 IOC：把创建实例的控制权交给框架，由框架创建实例（控制反转）并把实例分发给调用的程序（依赖注入）。 DI：把代码向对象属性或实例对象注入属性值或域属性的控制权限转给Spring容器进行控制。 从上面的文字描述结合实际
自己简易打造的IOC注解框架：SteadyoungIOC
默阳听风的博客
06-27 275
1 前言前面的文章注解框架源码分析（XUtils、ButterKnife）和ButterKnife编译时生成代码原理：butterknife-compiler源码分析，按照源码的思路我们自己打造一款IOC注解框架，因为ButterKnife的源码实现难度过大，我先仿照xUtils的源码方式，反射注解实现。虽说反射注解对性能有影响，但是影响是极小，相比I渲染和Bitmap以及Service和Hand...
打造自己的IOC注解框架------findViewById
ToastIt的博客
04-19 551
前言：IOC注解，目前已经有非常许多类似的jar包可以用了， 比如XUtils以及Butterkniful等这些框架都可以用来进行相应的开发。然而， 写着篇博客的目的并非让你去打造一款超过上面的框架，只是想让你了解 一下他们实现的原理，以后可以基于这个的基础上，对其进行扩展比如 目前的两款没有网络检查这一功能，可以加上，因为我们多数地方会用到。 如
IOC注解框架
OLDNUM7的博客
09-15 247
Butter Knife ViewUtils(Xutils)
写一套IOC注解框架
奋斗&努力
02-02 259
首先控件属性注入 //@Target(ElementType.FIELD) 代表Annotion的值 FIELD属性 TYPE类上 METHOD方法 CONSTRUCTOR构造函数 @Target(ElementType.FIELD) //@Retention(RetentionPolicy.RUNTIME) 运行时生效 CLASS编译时生效 SOURCE源码资源 @Retention(R...
打造一套IOC注解框架
weixin_39166019的博客
02-28 179
相信大家对findViewById()都不陌生，有人对这个很是苦恼，有时候往往要在一个类中写特别多的findViewById。好在后面有了xUtils，butterknife等框架让我们轻松很多。大家有没有看过这类第三方开源框架的源码。我们在这里就看一下xUtils的源码，看看是怎么实现的？这里给一下xUtils3  github地址点击打开链接先看一下使用方法public class MainA...
(源码阅读)自己动手打造一套属于自己想IOC注解框架
GuiM_007的博客
06-23 382
阅读过Xutils3和butterKnife的源码之后，稍微比对了一下，俩个都写的非常nb~~           Xutils3通过源码发现，主要是通过反射去 获得属性，函数进行注入。           而butterKnife通过将一系列的参数拼接起来重新生成一个.java文件打包到apk里面。          so，我们还是来通过反射的方式打造自己的IOC注解框架吧。 publi
Spring自定义实现IOC和依赖注入(注解方式)
qq_34898847的博客
03-25 3979
大致思路: 注解实现方式: 就是用 反射机制. 获取指定的包下使用了注解的类,存储在一个map容器, 然后获取map容器下类的属性, 利用反射给使用了注解的属性赋值对象. xml实现方式: 使用xml解析配置文件+反射机制 此处使用注解方式 1. 引入相关jar <dependencies> <!-- 引入Spring-AOP等相关Jar --> <depen...
关于监听网络状态变化，记录而已
Lynn
08-24 1584
在我们平常开发中，有很多场景需要监听网络状态的变化。今天，我们来实现该功能。大致效果如下： <!-- ---------------------卖萌的分割线--------------------- -->首先我们先看一下大概Demo结构： 接下来，贴一下NetUtils类的代码，该类主要用于判断目前网络状态，代码不复杂，直接上代码：package network;import android.
Android 检测网络是否真的有效isNetworkConnected() 和ping()
sky_brian的专栏
12-26 1839
1.isNetworkConnected() private boolean isNetworkConnected() { final ConnectivityManager connManager = (ConnectivityManager) mContext .getSystemService(Context.CONNECTI
Spring IOC注解实战：构建用户注册登录项目
"本文档是Spring学习系列的第一篇，主要关注Spring框架中的Inversion of Control (IoC)概念，并强调了注解的使用。作者通过实际项目——实现用户注册登录功能，引导读者逐步学习Spring的核心组件，如MyBatis用于数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值