android——框架的实现系列(依赖注入的实现)

- 日理万妓 2022-07-12 03:40 238阅读 0赞

原创文章，转载注明出处

从web开发转入andorid开发，苦于没有框架不习惯，自己动手搭建简单框架。该系列框架将提供spring的依赖注入，mybatis的半自动化映射，sql管理，资源文件的注入，一套android界面跳转机制。

首先来看一下依赖注入。

实现目标：

用户通过assets文件夹下的config.propertites文件配置需要依赖注入管理的包名，比如

scan=com.xf.ztime.task.service,com.xf.ztime.base.helper

从而可以对该包下的类进行依赖注入管理

类似于spring的<context:component-scan base-package>配置

通过对该包的类上使用@Component告诉框架该类可以被依赖注入

在其它的类中使用@Component标注在成员变量上完成依赖注入，比如

@Component  
        public class TaskService

然后在AddTaskView类中

@Layout(value=R.layout.view\_add\_task)  
       public class AddTaskView extends BaseLayout\{

@Component  
                    private TaskService taskService;

自动实例化taskService

注意：因为该框架还提供了一套界面管理功能，做了一个限制，只有继承了BaseLayout且有@Layout注释的才能实例化

要实现依赖注入，我们需要什么呢？

我们需要实现获得需要依赖注入的类，实例化的对象（没有考虑lazy的功能）。

为了方便用户定义，还需要自定义相应的注释。

另外，由于是android应用，很多地方需要用到Context，这里为了方便，框架里面实现了一个全局的Context

因此，我们需要实现这几样东西

1、ApplicationSelf类

用来提供全局的context

实现思路为继承android的Application类

2、ClassUtil类

该类为一个工具类，作用为类加载器，对android的app包进行扫描，将需要管理的类放入一个集合中返回

扫描app包可以用如下方法

DexFile df = new DexFile(ApplicationSelf.getContext().getPackageCodePath());  
             Enumeration<String> urls=df.entries();

接下来就可以遍历urls加载类了

加载方法为

Class.forName(className, true, getClassLoader());

classLoader的获得方法为

public static ClassLoader getClassLoader()\{  
                     return Thread.currentThread().getContextClassLoader();  
             \}

3、ClassHelper类

该类维护一个CLASS\_SET，该集合保存需要依赖注入的Class类型的对象，类加载则通过ClassUtil类

哪些包的类需要被管理，这个需要用户配置，配置文件名为config.propertites，保存在assets文件夹下。这个配置类似于spring配置文件的<context:component-scan base-package>标签

需要注意的是，扫描功能应该放在static静态块中，在应用启动的时候调用

另外一个功能为将@Component标注的类放入Class类型的集合中。该功能用反射即可实现

4、BeanHelper类

该类完成实例化过程，由于没有考虑懒加载机制，实例化在应用启动时开始。因此需要在static静态块中完成

从ClassHelper中获取@Component标注的类，通过反射进行实例化，并将实例化的对象放入一个集合中，该集合名为BEAN\_MAP

另一个功能是扫描目标类的field，如果有@Component标注，则从BEAN\_MAP返回对象，该功能是通过InjectHelper实现的，下面会说到

5、InjectHelper类

实现依赖注入的类，通过反射寻找field上是否有@Component标注，如果有，则从BEAN\_MAP返回对象，完成依赖注入

下面看一下关键代码，由于存在其他功能，这里把用到的关键代码进行了注释

ApplicationSelf类

public class ApplicationSelf extends Application{
    
    	public static Context context;
    	
        @Override
        public void onCreate(){
            context=getApplicationContext();
        }
        
        public static Context getContext(){
            return context;
        }
    	
    }

ClassUtil类

public class ClassUtil {
    
    	private static final String TAG="ClassUtil";
    	
    	public static ClassLoader getClassLoader(){
                  //获得类加载器
                  return Thread.currentThread().getContextClassLoader();
    	}
    	
    	public static Class<?> loadClass(String className,boolean isInitialized){
    		Class<?> cls = null;
    		try{
    			//加载类					
    			cls=Class.forName(className, true, getClassLoader());
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    		return cls;
    	}
    	
    	public static Set<Class<?>> getClassSet(String packageName){
    		Set<Class<?>> classSet=new HashSet<Class<?>>();
    		try{
    			//Enumeration<URL> urls=getClassLoader().getResources(packageName.replaceAll("\\.", "/"));
                            //获得app包环境，然后遍历加载类
                            DexFile df = new DexFile(ApplicationSelf.getContext().getPackageCodePath());
    			Enumeration<String> urls=df.entries();
    			while(urls.hasMoreElements()){
    				String url=urls.nextElement();
    				if(url!=null){
    					/*
    					String protocol=url.getProtocol();
    					if(protocol.equals("file")){
    					*/
    						//String packagePath=url.getPath().replaceAll("%20"," ");
    						if (url.contains(packageName)) {
    							addClass(classSet,url);
    						}
    					 	//String packagePath=url.replaceAll("%20"," ");
    						//addClass(classSet,packagePath,packageName);
    					/*
    					}else if(protocol.equals("jar")){
    						JarURLConnection jarUrlConnection=(JarURLConnection) url.openConnection();
    						if(jarUrlConnection!=null){
    							JarFile jarFile=jarUrlConnection.getJarFile();
    							if(jarFile!=null){
    								Enumeration<JarEntry> jarEntries=jarFile.entries();
    								while(jarEntries.hasMoreElements()){
    									JarEntry jarEntry=jarEntries.nextElement();
    									String jarEntryName=jarEntry.getName();
    									if(jarEntryName.endsWith(".class")){
    										String className=jarEntryName.substring(0,jarEntryName.lastIndexOf(".")).replaceAll(".", "/");
    										doAddClass(classSet,className);
    									}
    								}
    							}
    						}
    					}
    					*/
    				}
    			}
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    		return classSet;
    	}
    	
    	private static void addClass(Set<Class<?>> classSet,String className){
    		doAddClass(classSet,className);
    	}
    	
    	private static void addClass(Set<Class<?>> classSet,String packagePath,String packageName){
    		File[] files=new File(packagePath).listFiles(new FileFilter(){
    
    			@Override
    			public boolean accept(File file) {
    				return ((file.isFile() && file.getName().endsWith(".class")) || file.isDirectory());
    			}
    			
    		});
    		
    		for(File file : files){
    			if(file.isFile()){
    				String className=file.getName().substring(0,file.getName().lastIndexOf("."));
    				if(!packageName.isEmpty())
    					className=packageName+"."+className;
    				doAddClass(classSet,className);
    			}else{
    				String subPackagePath=file.getName();
    				String subPackageName=file.getName();
    				if(!packagePath.isEmpty())
    					subPackagePath=packagePath+"/"+subPackagePath;
    				if(!packageName.isEmpty())
    					subPackageName=packageName+"."+subPackageName;
    				addClass(classSet,packagePath,packageName);
    			}
    		}
    	}
    	
    	private static void doAddClass(Set<Class<?>> classSet,String className){
    		Class<?> cls=loadClass(className,false);
    		classSet.add(cls);
    	}
    	
    }

ClassHelper类

public class ClassHelper extends Application{
    
    	private static final String TAG="ClassHelper";
    	
    	private static final String BASE_PACKAGE="com.my.assist.helper";
    	private static final String SCAN_PACKAGE="scan";
            //类集合
            private static Set<Class<?>> CLASS_SET=new HashSet<Class<?>>();
    	
    	static{
    		Log.d(TAG, "class scan");
                    //assets文件夹
                    AssetManager assets = ApplicationSelf.getContext().getAssets();
    		InputStream input=null;
    		try {
                            //获得配置文件
                            input=assets.open("config.propertites");
    			Properties p=new Properties();
    			p.load(new BufferedInputStream(input));
    			String scanPackage=(String) p.get(SCAN_PACKAGE);
    			String[] ps=scanPackage.split(",");
    			for(String sp : ps){
                                //加载类
                                CLASS_SET.addAll(ClassUtil.getClassSet(sp));
    			}
    
                            //加载类
    
                            CLASS_SET.add(ClassUtil.loadClass(DaoHelper.class.getName(), false));
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			if(input!=null){
    				try {
    					input.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    	
    	public static Set<Class<?>> getClassSet(){
    		return CLASS_SET;
    	}
    	
    	public static Set<Class<?>> getComponent(){
    		Set<Class<?>> classSet=new HashSet<Class<?>>();
    		for(Class<?> cls : CLASS_SET){
                            //判断类上是否有Component注释 
                            if(cls.isAnnotationPresent(Component.class)){
    				classSet.add(cls);
    			}
    		}
    		return classSet;
    	}
    
            //与本文无关
    
    	private static Set<Class<?>> getDB(){
    		Set<Class<?>> classSet=new HashSet<Class<?>>();
    		for(Class<?> cls : CLASS_SET){
                            if(cls.isAnnotationPresent(DB.class)){
    				classSet.add(cls);
    			}
    		}
    		return classSet;
    	}
     
            //与本文无关
    
    	public static Set<Class<?>> getBeanClassSet(){
    		Set<Class<?>> classSet=getComponent();
    		classSet.addAll(getDB());
    		return classSet;
    	}
    	
    }

BeanHelper类

public class BeanHelper<T> {
    
            //用来保存实例化后的对象
    	private static final Map<Class<?>,Object> BEAN_MAP=new HashMap<Class<?>,Object>();
    	
    	static{
                    //获得类集合
                    Set<Class<?>> classSet=ClassHelper.getBeanClassSet();
    		for(Class<?> c : classSet){
    			try {
                                    //封装了数据库管理，和本文无关
                                    if(DBHelper.class.isAssignableFrom(c)){
    					if(c.isAnnotationPresent(DB.class)){
    						DB db=c.getAnnotation(DB.class);
    						String dbName=db.db_name();
    						int dbVersion=db.db_version();
    						int resourceId=db.db_xml_id();
    						DBHelper.DB_NAME=dbName;
    						DBHelper.DB_VERSION=dbVersion;
    						DBHelper.DB_RESOURCE=resourceId;
    					}
    				}else{
                                           //实例化
                                           BEAN_MAP.put(c,c.newInstance());
    				}
    			} catch (InstantiationException e) {
    				e.printStackTrace();
    			} catch (IllegalAccessException e) {
    				e.printStackTrace();
    			} catch (IllegalArgumentException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    	
    	public static Map<Class<?>,Object> getBeanMap(){
    		return BEAN_MAP;
    	}
    	
    	/**
    	 * 
    	 * 由于在service之中，动态代理的实例莫名其妙为null，因此先判断一下，如果为null就先依赖注入
    	 * 
    	 * @param cls
    	 * @return
    	 */
    	public static <T> T getBean(Class<T> cls){
                    //获得实例化后的对象，该方法可以手动调用，类似于spring从BeanFactory中获取对象
                    T bean=(T) BEAN_MAP.get(cls);
                    //这里判断动态代理的实例是否null，如果未null，则从新注入
                    bean=(T) IocHelper.mapperInject(cls,bean,BEAN_MAP);
    		return bean;
    	}
    	
    	/*
    	@SuppressWarnings("unchecked")
    	public <T> T getBean(Class<T> c){
    		return (T) BEAN_MAP.get(c);
    	}
    	*/
    	
    }

InjectHelper类

public class InjectHelper {
    
    	public InjectHelper(){
    		inject(this);
    	}
    	
    	public static void inject(Object o){
    		Class<?> cls=o.getClass();
    		try{
    			Field[] fields=cls.getDeclaredFields();
    			for(Field field : fields){
    				Class<?> fcls=field.getType();
                                    //动态注入resource，和本文无关
                                    if(View.class.isAssignableFrom(fcls)){
    					if(field.isAnnotationPresent(Resource.class) && !Modifier.isStatic(field.getModifiers())){
    						field.setAccessible(true);
    						Resource resource=field.getAnnotation(Resource.class);
    						int rid=resource.value();
    						Method m=cls.getMethod("findViewById", int.class);
    						View v=(View) m.invoke(o, rid);
    						field.set(o, v);
    					}
    				}
                                    //如果字段上有@Component注释，则依赖注入
                                    else if(field.isAnnotationPresent(Component.class) && !Modifier.isStatic(field.getModifiers())){
    					field.setAccessible(true);
    					Object fbean=BeanHelper.getBean(fcls);
    					field.set(o, fbean);
    				}
    			}
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    	}
    	
    }

因为限制了只有继承BaseLayout才能依赖注入，因此InjectHelper类会在BaseLayout类中调用，如果不想如此，可将其放到其他地方。

@Componet注释

@Target({ElementType.TYPE,ElementType.FIELD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Component {
    	
    }