原创文章，转载注明出处
从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 {
}
129
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
