Android IOC模块，利用了Java反射和Java注解

最新推荐文章于 2021-05-31 12:15:55 发布
最新推荐文章于 2021-05-31 12:15:55 发布
阅读量488 收藏 1
点赞数
分类专栏： js与前端

一、整体工程图



二、BaseActivity.java

[java]  view plain copy
  1. package com.jltxgcy.framework;  
  2. import android.os.Bundle;  
  3.   
  4. public abstract class BaseActivity extends FrameActivity  
  5. {  
  6.   
  7.     private String moduleName = "";  
  8.     private String layoutName = "";//main  
  9.   
  10.     @Override  
  11.     protected void onCreate(Bundle savedInstanceState)  
  12.     {  
  13.         super.onCreate(savedInstanceState);  
  14.         initActivity();  
  15.         onAfterOnCreate(savedInstanceState);  
  16.     }  
  17.   
  18.   
  19.     private void initActivity()  
  20.     {  
  21.         getModuleName();  
  22.         getLayoutName();  
  23.         initInjector();  
  24.         loadDefautLayout();  
  25.     }  
  26.   
  27.     protected void onAfterOnCreate(Bundle savedInstanceState)  
  28.     {  
  29.           
  30.     }  
  31.   
  32.     private void initInjector()  
  33.     {  
  34.         getInjector().injectResource(this);  
  35.         getInjector().inject(this);  
  36.     }  
  37.   
  38.     private void loadDefautLayout()  
  39.     {  
  40.         try  
  41.         {  
  42.             int layoutResID = getLayoutLoader().getLayoutID(  
  43.                     layoutName);  
  44.             setContentView(layoutResID);  
  45.         } catch (Exception e)  
  46.         {  
  47.             e.printStackTrace();  
  48.         }  
  49.     }  
  50.   
  51.     @Override  
  52.     public void setContentView(int layoutResID)  
  53.     {  
  54.         super.setContentView(layoutResID);  
  55.         getInjector().injectView(this);  
  56.         onAfterSetContentView();  
  57.     }  
  58.   
  59.   
  60.     protected void onAfterSetContentView()  
  61.     {  
  62.   
  63.     }  
  64.   
  65.     public String getModuleName()  
  66.     {  
  67.         String moduleName = this.moduleName;  
  68.         if (moduleName == null || moduleName.equalsIgnoreCase(""))  
  69.         {  
  70.             moduleName = getClass().getName().substring(0,  
  71.                     getClass().getName().length() - 8);  
  72.             String arrays[] = moduleName.split("\\.");  
  73.             this.moduleName = moduleName = arrays[arrays.length - 1]  
  74.                     .toLowerCase();  
  75.         }  
  76.         return moduleName;  
  77.     }  
  78.   
  79.     public void setModuleName(String moduleName)  
  80.     {  
  81.         this.moduleName = moduleName;  
  82.     }  
  83.   
  84.     public String getLayoutName()  
  85.     {  
  86.         String layoutName = this.layoutName;  
  87.         if (layoutName == null || layoutName.equalsIgnoreCase(""))  
  88.         {  
  89.             this.layoutName = this.moduleName;  
  90.         }  
  91.         return layoutName;  
  92.     }  
  93.   
  94.     protected void setLayoutName(String layoutName)  
  95.     {  
  96.         this.layoutName = layoutName;  
  97.     }  
  98.   
  99. }  

三、FrameActivity.java

[java]  view plain copy
  1. package com.jltxgcy.framework;  
  2.   
  3.   
  4.   
  5.   
  6.   
  7. import android.app.Activity;  
  8.   
  9. import com.jltxgcy.framework.annotation.Injector;  
  10. import com.jltxgcy.framework.layoutloader.ILayoutLoader;  
  11. import com.jltxgcy.framework.layoutloader.LayoutLoader;  
  12.   
  13. public class FrameActivity extends Activity  
  14. {  
  15.       
  16.     private ILayoutLoader mLayoutLoader;  
  17.     private Injector mInjector;  
  18.   
  19.     public ILayoutLoader getLayoutLoader()  
  20.     {  
  21.         if (mLayoutLoader == null)  
  22.         {  
  23.             mLayoutLoader = LayoutLoader.getInstance(this);  
  24.         }  
  25.         return mLayoutLoader;  
  26.     }  
  27.   
  28.     public void setLayoutLoader(ILayoutLoader layoutLoader)  
  29.     {  
  30.         this.mLayoutLoader = layoutLoader;  
  31.     }  
  32.   
  33.     public Injector getInjector()  
  34.     {  
  35.         if (mInjector == null)  
  36.         {  
  37.             mInjector = Injector.getInstance();  
  38.         }  
  39.         return mInjector;  
  40.     }  
  41.   
  42.     public void setInjector(Injector injector)  
  43.     {  
  44.         this.mInjector = injector;  
  45.     }  
  46.       
  47.   
  48. }  

四、InjectObject.java

[java]  view plain copy
  1. package com.jltxgcy.framework.annotation;  
  2.   
  3. import static java.lang.annotation.RetentionPolicy.RUNTIME;  
  4.   
  5. import java.lang.annotation.ElementType;  
  6. import java.lang.annotation.Retention;  
  7. import java.lang.annotation.Target;  
  8.   
  9. @Retention(RUNTIME)  
  10. @Target(  
  11. { ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })  
  12. public @interface InjectObject  
  13. {  
  14.     boolean optional() default false;  
  15. }  

五、InjectResource.java

[java]  view plain copy
  1. package com.jltxgcy.framework.annotation;  
  2.   
  3. import java.lang.annotation.ElementType;  
  4. import java.lang.annotation.Retention;  
  5. import java.lang.annotation.RetentionPolicy;  
  6. import java.lang.annotation.Target;  
  7.   
  8. @Target(  
  9. { ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })  
  10. @Retention(RetentionPolicy.RUNTIME)  
  11. public @interface InjectResource  
  12. {  
  13.     int id() default -1;  
  14. }  

六、InjectView.java

[java]  view plain copy
  1. package com.jltxgcy.framework.annotation;  
  2.   
  3. import java.lang.annotation.ElementType;  
  4. import java.lang.annotation.Retention;  
  5. import java.lang.annotation.RetentionPolicy;  
  6. import java.lang.annotation.Target;  
  7.   
  8. @Target(ElementType.FIELD)  
  9. @Retention(RetentionPolicy.RUNTIME)  
  10. public @interface InjectView  
  11. {  
  12.   
  13.     public int id() default -1;  
  14.   
  15.     public String click() default "";  
  16.   
  17.     public String longClick() default "";  
  18.   
  19.     public String focuschange() default "";  
  20.   
  21.     public String key() default "";  
  22.   
  23.     public String Touch() default "";  
  24. }  

七、Injector.java

[java]  view plain copy
  1. package com.jltxgcy.framework.annotation;  
  2.   
  3. import java.lang.reflect.Field;  
  4.   
  5. import android.app.Activity;  
  6. import android.content.res.Resources;  
  7.   
  8. public class Injector  
  9. {  
  10.     private static Injector instance;  
  11.   
  12.     private Injector()  
  13.     {  
  14.   
  15.     }  
  16.   
  17.     public static Injector getInstance()  
  18.     {  
  19.         if (instance == null)  
  20.         {  
  21.             instance = new Injector();  
  22.         }  
  23.         return instance;  
  24.     }  
  25.   
  26.     public void inJectAll(Activity activity)  
  27.     {  
  28.         // TODO Auto-generated method stub  
  29.         Field[] fields = activity.getClass().getDeclaredFields();  
  30.         if (fields != null && fields.length > 0)  
  31.         {  
  32.             for (Field field : fields)  
  33.             {  
  34.                 if (field.isAnnotationPresent(InjectView.class))  
  35.                 {  
  36.                     injectView(activity, field);  
  37.                 } else if (field.isAnnotationPresent(InjectResource.class))  
  38.                 {  
  39.                     injectResource(activity, field);  
  40.                 } else if (field.isAnnotationPresent(InjectObject.class))  
  41.                 {  
  42.                     inject(activity, field);  
  43.                 }  
  44.             }  
  45.         }  
  46.     }  
  47.   
  48.     private void inject(Activity activity, Field field)  
  49.     {  
  50.         // TODO Auto-generated method stub  
  51.         try  
  52.         {  
  53.             field.setAccessible(true);  
  54.             field.set(activity, field.getType().newInstance());  
  55.         } catch (Exception e)  
  56.         {  
  57.             e.printStackTrace();  
  58.         }  
  59.     }  
  60.   
  61.     private void injectView(Activity activity, Field field)  
  62.     {  
  63.         // TODO Auto-generated method stub  
  64.         if (field.isAnnotationPresent(InjectView.class))  
  65.         {  
  66.             InjectView viewInject = field.getAnnotation(InjectView.class);  
  67.             int viewId = viewInject.id();  
  68.             try  
  69.             {  
  70.                 field.setAccessible(true);  
  71.                 field.set(activity, activity.findViewById(viewId));  
  72.             } catch (Exception e)  
  73.             {  
  74.                 e.printStackTrace();  
  75.             }  
  76.         }  
  77.     }  
  78.   
  79.     private void injectResource(Activity activity, Field field)  
  80.     {  
  81.         // TODO Auto-generated method stub  
  82.         if (field.isAnnotationPresent(InjectResource.class))  
  83.         {  
  84.             InjectResource resourceJect = field  
  85.                     .getAnnotation(InjectResource.class);  
  86.             int resourceID = resourceJect.id();  
  87.             try  
  88.             {  
  89.                 field.setAccessible(true);  
  90.                 Resources resources = activity.getResources();  
  91.                 String type = resources.getResourceTypeName(resourceID);  
  92.                 if (type.equalsIgnoreCase("string"))  
  93.                 {  
  94.                     field.set(activity,  
  95.                             activity.getResources().getString(resourceID));  
  96.                 } else if (type.equalsIgnoreCase("drawable"))  
  97.                 {  
  98.                     field.set(activity,  
  99.                             activity.getResources().getDrawable(resourceID));  
  100.                 } else if (type.equalsIgnoreCase("layout"))  
  101.                 {  
  102.                     field.set(activity,  
  103.                             activity.getResources().getLayout(resourceID));  
  104.                 } else if (type.equalsIgnoreCase("array"))  
  105.                 {  
  106.                     if (field.getType().equals(int[].class))  
  107.                     {  
  108.                         field.set(activity, activity.getResources()  
  109.                                 .getIntArray(resourceID));  
  110.                     } else if (field.getType().equals(String[].class))  
  111.                     {  
  112.                         field.set(activity, activity.getResources()  
  113.                                 .getStringArray(resourceID));  
  114.                     } else  
  115.                     {  
  116.                         field.set(activity, activity.getResources()  
  117.                                 .getStringArray(resourceID));  
  118.                     }  
  119.   
  120.                 } else if (type.equalsIgnoreCase("color"))  
  121.                 {  
  122.                     if (field.getType().equals(Integer.TYPE))  
  123.                     {  
  124.                         field.set(activity,  
  125.                                 activity.getResources().getColor(resourceID));  
  126.                     } else  
  127.                     {  
  128.                         field.set(activity, activity.getResources()  
  129.                                 .getColorStateList(resourceID));  
  130.                     }  
  131.   
  132.                 }  
  133.             } catch (Exception e)  
  134.             {  
  135.                 e.printStackTrace();  
  136.             }  
  137.         }  
  138.     }  
  139.   
  140.     public void inject(Activity activity)  
  141.     {  
  142.         // TODO Auto-generated method stub  
  143.         Field[] fields = activity.getClass().getDeclaredFields();  
  144.         if (fields != null && fields.length > 0)  
  145.         {  
  146.             for (Field field : fields)  
  147.             {  
  148.                 if (field.isAnnotationPresent(InjectObject.class))  
  149.                 {  
  150.                     inject(activity, field);  
  151.                 }  
  152.             }  
  153.         }  
  154.     }  
  155.   
  156.     public void injectView(Activity activity)  
  157.     {  
  158.         // TODO Auto-generated method stub  
  159.         Field[] fields = activity.getClass().getDeclaredFields();  
  160.         if (fields != null && fields.length > 0)  
  161.         {  
  162.             for (Field field : fields)  
  163.             {  
  164.                 if (field.isAnnotationPresent(InjectView.class))  
  165.                 {  
  166.                     injectView(activity, field);  
  167.                 }  
  168.             }  
  169.         }  
  170.     }  
  171.   
  172.     public void injectResource(Activity activity)  
  173.     {  
  174.         // TODO Auto-generated method stub  
  175.         Field[] fields = activity.getClass().getDeclaredFields();  
  176.         if (fields != null && fields.length > 0)  
  177.         {  
  178.             for (Field field : fields)  
  179.             {  
  180.                 if (field.isAnnotationPresent(InjectResource.class))  
  181.                 {  
  182.                     injectResource(activity, field);  
  183.                 }  
  184.             }  
  185.         }  
  186.     }  
  187.   
  188. }  

八、ILayoutLoader.java

[java]  view plain copy
  1. package com.jltxgcy.framework.layoutloader;  
  2.   
  3. import android.content.pm.PackageManager.NameNotFoundException;  
  4.   
  5. public interface ILayoutLoader  
  6. {  
  7.     public int getLayoutID(String resIDName) throws ClassNotFoundException,  
  8.             IllegalArgumentException, IllegalAccessException,  
  9.             NameNotFoundException;  
  10.   
  11. }  

九、LayoutLoader.java

[java]  view plain copy
  1. package com.jltxgcy.framework.layoutloader;  
  2.   
  3. import java.lang.reflect.Field;  
  4.   
  5. import android.content.Context;  
  6. import android.content.pm.PackageInfo;  
  7. import android.content.pm.PackageManager;  
  8. import android.content.pm.PackageManager.NameNotFoundException;  
  9. import android.util.Log;  
  10.   
  11. public class LayoutLoader implements ILayoutLoader  
  12. {  
  13.   
  14.     private static LayoutLoader instance;  
  15.     private Context mContext;  
  16.   
  17.     private LayoutLoader(Context context)  
  18.     {  
  19.         this.mContext = context;  
  20.     }  
  21.   
  22.     public static LayoutLoader getInstance(Context context)  
  23.     {  
  24.         if (instance == null)  
  25.         {  
  26.             instance = new LayoutLoader(context);  
  27.         }  
  28.         return instance;  
  29.     }  
  30.   
  31.     public int getLayoutID(String resIDName) throws NameNotFoundException,  
  32.             ClassNotFoundException, IllegalArgumentException,  
  33.             IllegalAccessException  
  34.     {  
  35.         int resID = readResID("layout", resIDName);  
  36.         if (resID == 0)  
  37.         {  
  38.               
  39.         }  
  40.         return resID;  
  41.     }  
  42.   
  43.     public int readResID(String type, String resIDName)  
  44.             throws NameNotFoundException, ClassNotFoundException,  
  45.             IllegalArgumentException, IllegalAccessException  
  46.     {  
  47.         String packageName;  
  48.         PackageManager pm = mContext.getPackageManager();  
  49.         PackageInfo pi = pm.getPackageInfo(mContext.getPackageName(), 0);  
  50.         packageName = pi.packageName;  
  51.         if (packageName == null || packageName.equalsIgnoreCase(""))  
  52.         {  
  53.             throw new NameNotFoundException("没有发现类");  
  54.         }  
  55.         packageName = packageName + ".R";  
  56.         Class<?> clazz = Class.forName(packageName);  
  57.         Class<?> cls = readResClass(clazz, packageName + "$" + type);  
  58.         if (cls == null)  
  59.         {  
  60.             throw new NameNotFoundException("没有发现类");  
  61.         }  
  62.         return readResID(cls, resIDName);  
  63.   
  64.     }  
  65.   
  66.     public Class<?> readResClass(Class<?> cls, String respackageName)  
  67.     {  
  68.         Class<?>[] classes = cls.getDeclaredClasses();  
  69.         for (int i = 0; i < classes.length; i++)  
  70.         {  
  71.             Class<?> tempClass = classes[i];  
  72.             Log.v("TAReadSystemRes", tempClass.getName());  
  73.             if (tempClass.getName().equalsIgnoreCase(respackageName))  
  74.             {  
  75.                 return tempClass;  
  76.             }  
  77.         }  
  78.         return null;  
  79.     }  
  80.   
  81.     public int readResID(Class<?> cls, String resIDName)  
  82.             throws IllegalArgumentException, IllegalAccessException  
  83.     {  
  84.   
  85.         Field[] fields = cls.getDeclaredFields();  
  86.         for (int j = 0; j < fields.length; j++)  
  87.         {  
  88.             if (fields[j].getName().equalsIgnoreCase(resIDName))  
  89.             {  
  90.                 return fields[j].getInt(cls);  
  91.             }  
  92.         }  
  93.         return 0;  
  94.     }  
  95.   
  96. }  

十、MainActivity.java

[java]  view plain copy
  1. package com.jltxgcy.iocdemo;  
  2.   
  3. import android.os.Bundle;  
  4. import android.view.View;  
  5. import android.view.View.OnClickListener;  
  6. import android.widget.Button;  
  7. import android.widget.TextView;  
  8.   
  9. import com.jltxgcy.framework.BaseActivity;  
  10. import com.jltxgcy.framework.annotation.InjectResource;  
  11. import com.jltxgcy.framework.annotation.InjectView;  
  12.   
  13. public class MainActivity extends BaseActivity {  
  14.     @InjectResource(id=R.string.app_name)  
  15.     String appNameString;  
  16.     @InjectView(id=R.id.tv_display)  
  17.     TextView tView;  
  18.     @InjectView(id=R.id.btn_imagecache)  
  19.     Button btnImagecache;  
  20.     @InjectView(id=R.id.btn_http)  
  21.     Button btnHttp;  
  22.   
  23.     @Override  
  24.     protected void onAfterOnCreate(Bundle savedInstanceState)  
  25.     {  
  26.         tView.setText(appNameString);  
  27.         super.onAfterOnCreate(savedInstanceState);  
  28.           
  29.     }  
  30.       
  31.     @Override  
  32.     protected void onAfterSetContentView()  
  33.     {  
  34.         // TODO Auto-generated method stub  
  35.         super.onAfterSetContentView();  
  36.         OnClickListener onClickListener = new OnClickListener()  
  37.         {  
  38.   
  39.             @Override  
  40.             public void onClick(View v)  
  41.             {  
  42.                 // TODO Auto-generated method stub  
  43.                 switch (v.getId())  
  44.                 {  
  45.                 case R.id.btn_imagecache:  
  46.                     tView.setText("图片缓存模块");  
  47.                     break;  
  48.                 case R.id.btn_http:  
  49.                     tView.setText("http模块");  
  50.                     break;  
  51.                 default:  
  52.                     break;  
  53.                 }  
  54.             }  
  55.         };  
  56.         btnImagecache.setOnClickListener(onClickListener);  
  57.         btnHttp.setOnClickListener(onClickListener);  
  58.     }  
  59.   
  60. }  

十一、main.xml

[java]  view plain copy
  1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  2.     xmlns:tools="http://schemas.android.com/tools"  
  3.     android:layout_width="match_parent"  
  4.     android:layout_height="match_parent"  
  5.     android:orientation="vertical"  
  6.     tools:context=".MainActivity" >  
  7.    
  8.     <TextView  
  9.         android:id="@+id/tv_display"  
  10.         android:layout_width="wrap_content"  
  11.         android:layout_height="wrap_content"  
  12.         android:text="@string/hello_world" />  
  13.        <Button  
  14.         android:id="@+id/btn_imagecache"  
  15.         android:layout_width="wrap_content"  
  16.         android:layout_height="wrap_content"  
  17.         android:text="图片缓存模块" />  
  18.        <Button  
  19.         android:id="@+id/btn_http"  
  20.         android:layout_width="wrap_content"  
  21.         android:layout_height="wrap_content"  
  22.         android:text="HTTP模块" />  
  23.   
  24. </LinearLayout>  

十二、解释

           field.isAnnotationPresent(InjectView.class)，判断该字段上是否有注解。如果有可以取得注解的内容。注解是动态解析的。

           @Override 

           @Deprecated 

           @SuppressWarnings 这些都是注解

            1、定义注解

[java]  view plain copy
  1. package com.jltxgcy.framework.annotation;  
  2.   
  3. import java.lang.annotation.ElementType;  
  4. import java.lang.annotation.Retention;  
  5. import java.lang.annotation.RetentionPolicy;  
  6. import java.lang.annotation.Target;  
  7.   
  8. @Target(  
  9. { ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })  
  10. @Retention(RetentionPolicy.RUNTIME)  
  11. public @interface InjectResource  
  12. {  
  13.     int id() default -1;  
  14. }  

            2、使用注解（@的方式）

[java]  view plain copy
  1. @InjectResource(id=R.string.app_name)  
  2.     String appNameString;  
           3、在程序中动态注入。Inject。

[java]  view plain copy
  1. private void injectResource(Activity activity, Field field)  
  2.     {  
  3.         // TODO Auto-generated method stub  
  4.         if (field.isAnnotationPresent(InjectResource.class))  
  5.         {  
  6.             InjectResource resourceJect = field  
  7.                     .getAnnotation(InjectResource.class);  
  8.             int resourceID = resourceJect.id();  
  9.             try  
  10.             {  
  11.                 field.setAccessible(true);  
  12.                 Resources resources = activity.getResources();  
  13.                 String type = resources.getResourceTypeName(resourceID);  
  14.                 if (type.equalsIgnoreCase("string"))  
  15.                 {  
  16.                     field.set(activity,  
  17.                             activity.getResources().getString(resourceID));  
  18.                 } else if (type.equalsIgnoreCase("drawable"))  
  19.                 {  
  20.                     field.set(activity,  
  21.                             activity.getResources().getDrawable(resourceID));  
  22.                 } else if (type.equalsIgnoreCase("layout"))  
  23.                 {  
  24.                     field.set(activity,  
  25.                             activity.getResources().getLayout(resourceID));  
  26.                 } else if (type.equalsIgnoreCase("array"))  
  27.                 {  
  28.                     if (field.getType().equals(int[].class))  
  29.                     {  
  30.                         field.set(activity, activity.getResources()  
  31.                                 .getIntArray(resourceID));  
  32.                     } else if (field.getType().equals(String[].class))  
  33.                     {  
  34.                         field.set(activity, activity.getResources()  
  35.                                 .getStringArray(resourceID));  
  36.                     } else  
  37.                     {  
  38.                         field.set(activity, activity.getResources()  
  39.                                 .getStringArray(resourceID));  
  40.                     }  
  41.   
  42.                 } else if (type.equalsIgnoreCase("color"))  
  43.                 {  
  44.                     if (field.getType().equals(Integer.TYPE))  
  45.                     {  
  46.                         field.set(activity,  
  47.                                 activity.getResources().getColor(resourceID));  
  48.                     } else  
  49.                     {  
  50.                         field.set(activity, activity.getResources()  
  51.                                 .getColorStateList(resourceID));  
  52.                     }  
  53.   
  54.                 }  
  55.             } catch (Exception e)  
  56.             {  
  57.                 e.printStackTrace();  
  58.             }  
  59.         }  
  60.     }  

            代码地址：https://github.com/jltxgcy/Demo

judyge
关注
专栏目录
Java 语言概述 -- Java 语言的介绍、现在、过去与将来
栗筝i的博客
06-09 3920
Java 语言是于 1991 年由 Sun（Sun Microsystems，美国）公司的 詹姆斯·高斯林（James Gosling）团队研发的一门面向对象的编程语言。最初命名为 Oak，并于 1995 年更名为 Java 后开始推广。如今，随着互联网的崛起，Java 已经成为目前世界上最流行、最重要的计算机编程语言之一。Java 作为一门面向对象的高级编程语言，在设计之初，借鉴了多种编程语言的特性和理念。
Java基础面试题02（多线程面试题（JUC面试题），注解和反射面试题，异常面试题，网络编程面试题）
weixin_45929082的博客
09-13 588
1.多线程 1.什么是线程和进程? 何为进程? 进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。 在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。 如下图所示，在 windows 中通过查看任务管理器的方式，我们就可以清楚看到 window 当前运行的进程（.exe 文件的运行）。 何为线程? 线程与进程相似，但线程是一个比进程更小
Android进阶——框架打造之IOC框架
10-20
Android进阶——框架打造之IOC框架 实现通过Id找到控件的功能 实现通过Id找到Color、String资源 实现绑定view的点击事件、长按事件 实现绑定SetContentView 实现绑定网络的检测功能
android ioc模块,Android IOC模块，利用了Java反射和Java注解
weixin_35297190的博客
05-31 87
一、整体工程图二、BaseActivity.java[java]package com.jltxgcy.framework;import android.os.Bundle;public abstract class BaseActivity extends FrameActivity{private String moduleName = "";private String layoutName...
Android应用setContentView与LayoutInflater加载解析机制源码分析
热门推荐
工匠若水
05-26 5万+
【工匠若水 http://blog.csdn.net/yanbober 转载烦请注明出处，尊重分享成果】1 背景其实之所以要说这个话题有几个原因： 理解xml等控件是咋被显示的原理，通常大家写代码都是直接在onCreate里setContentView就完事，没怎么关注其实现原理。 前面分析《Android触摸屏事件派发机制详解与源码分析三(Activity篇)》时提到了一些关于布局嵌套的问题，当
JAVA JAVA JAVA JAVA JAVA JAVA JAVA
最新发布
01-16
"JAVA JAVA JAVA JAVA JAVA JAVA JAVA" 这个标题可能是在强调Java在编程领域的广泛性和重要性，它在企业级应用、Web开发、移动应用（尤其是Android系统）以及大数据处理等领域都有广泛应用。 描述中的"JAVA JAVA ...
Java学习路线,Android学习路线,Java全套路线视频下载连接
12-27
以上就是针对Java和Android两个方向的学习路线介绍。通过系统地学习这些知识点，不仅可以打下坚实的编程基础，还能积累丰富的项目经验，为日后成为优秀的软件工程师奠定坚实的基础。此外，还提供了Java全套路线视频...
反射机制在Android开发中的应用.pdf
09-21
通过Java反射机制，开发者可以访问和调用这些隐藏的类和方法，从而实现更多功能。 依赖注入（Dependency Injection，DI）和控制反转（Inversion of Control，IOC）是降低程序耦合性的关键原则。传统编程中，调用者...
Android主流IOC框架浅析（Java注解反射原理）
coding
07-06 1825
Android主流IOC框架浅析
java.lang.IllegalArgumentException: eglChooseConfig failed EGL_NOT_INITIALIZED
Android/Linux的专栏
03-30 1万+
03-29 13:21:34.556: E/AndroidRuntime(4458): FATAL EXCEPTION: main 03-29 13:21:34.556: E/AndroidRuntime(4458): Process: com.example.news, PID: 4458 03-29 13:21:34.556: E/AndroidRuntime(4458): java.la
Unity错误（3）—— java.lang.IllegalArgumentException: ResClass is not initialized
yaya1943的专栏
11-12 2052
使用 Unity环境下的 buill and run 直接安装应用到android 设备，触发弹出通知栏操作，不能弹出，log提示： 11-12 10:52:49.338: W/System.err(11282): java.lang.IllegalArgumentException: ResClass is not initialized. Please make sure you h
使用友盟组件，android混淆后程序报错解决方案
小洋人最happy的专栏
04-21 7104
这几天在对程序进行混淆处理测试时，在程序中使用了友盟组件的地方会报错，比如自动更新，报错异常如:      解决思路： 使用了混淆， 请添加 -keepclassmembers class * {   public (org.json.JSONObject); } 这是由于SDK中的部分代码使用反射来调用构造函数， 如果被混淆掉， 在运行时会提示"NoSuchMethod"错误。 另外
手动释放你的资源(Please release resources manually)
weixin_34235105的博客
07-30 123
转载自风雪之隅: http://www.laruence.com/2012/07/25/2662.html 我从来不认为这个问题是个问题, 直到昨天. 昨天晚上的时候, 我提交了一个RFC, 关于引入finally到PHP, 实现这个功能的出发点很简单, 因为我看见不少人的需求, 另外还有就是Stas说, 一直只看到讨论, 没看到有人实现. 于是我就给实现了. 发到邮件组以后...
Dagger2与AndroidInjector
唯鹿的博客
06-11 1万+
使用过Dagger开发Android应用的小伙伴会知道我们会在Activity或Fragment的生命周期方法中执行成员注入。比如这样：
Java注解模拟Spring IoC容器详解与实例
总结来说，这篇教程展示了如何通过Java注解模拟Spring IoC容器的基本原理，包括创建自定义注解、扫描和注入属性值。这不仅有助于理解Spring IoC的工作原理，也是在不依赖完整Spring框架的情况下，利用Java语言的元...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值