android——框架的实现系列(数据库操作)

矫情吗；* 2022-07-12 03:46 198阅读 0赞

原创文章，转载请注明出处

请先阅读[《android——仿mybatis的半自动数据库映射的实现 》][android_mybatis_]

[ 《 android——框架的实现系列(依赖注入的实现) 》][_ android_]

这里在实现了依赖注入的基础上，对之前的仿mybatis实现进行改进。

**实现目标**

1、通过注释指定数据库，建表，更新版本，比如：

@DB(db_name="myTask.db",db_version=13,db_xml_id=R.xml.db)
    public class BaseHelper extends DBHelper{
    
    	public BaseHelper(Context context) {
    		super(context);
    	}
    
    }

只需要添加该注释，并且继承DBHelper类即可

这里的db\_name表示数据库名，db\_version表示版本，如果版本增加会自动更新数据库表，db\_xml\_id为一个xml，用来说明表结构，需要用户自行配置

表结构配置文件举例说明，我们看一下R.xml.db的内容

<?xml version="1.0" encoding="UTF-8"?>
    <db>
        
        <table name="t_task">
    	    <colunm name="id" type="varchar(64)" primaryKey="true"/>
    	    <colunm name="title" type="varchar(30)"/>
    	    <colunm name="brief" type="text"/>
    	    <colunm name="beginTime" type="datetime"/>
    	    <colunm name="repeat" type="varchar(30)"/>
    	    <colunm name="requestCode" type="varchar(30)"/>
    	    <colunm name="isRun" type="varchar(8)"/>
    	</table>
        
    </db>

2、对sql进行管理，并且将查询的结果封装为对象。调用sql的工具类可以依赖注入

所有的sql可以用一个xml文件进行管理

比如一个叫R.xml.task的xml文件如下

<?xml version="1.0" encoding="UTF-8"?>
    
    <mapper namespace="com.xf.ztime.task.mapper.TaskMapper">
    
    	<select id="findTask" resultType="com.xf.ztime.task.model.TaskVo">
    	    select id,title,brief,isRun,beginTime,repeat,requestCode
    	    from t_task
    	    limit ${rows} offset ${offset}
    	</select>
    	
    	<select id="findById" resultType="com.xf.ztime.task.model.TaskVo">
    	    select id,title,brief,isRun,beginTime,repeat,requestCode
    	    from t_task
    		where id='${id}'
    	</select>
    	
    	<select id="findByRequestCode" resultType="com.xf.ztime.task.model.TaskVo">
    	    select id,title,brief,isRun,beginTime,repeat,requestCode
    	    from t_task
    		where requestCode='${requestCode}'
    	</select>
    	
    	<insert id="insert">
    	    insert into t_task
    	    (id,title,brief,beginTime,repeat,requestCode,isRun)
    	    values('${id}','${title}','${brief}','${beginTime}','${repeat}','${requestCode}','${isRun}')
    	</insert>
    	
    	<update id="update">
    	    update t_task
    	    set title='${title}',
    	        brief='${brief}',
    	        beginTime='${beginTime}',
    	        repeat='${repeat}'
    	    where id='${id}'
    	</update>
    	
    	<update id="updateRun">
    	    update t_task
    	    set isRun='${isRun}'
    	    where id='${id}'
    	</update>
    	
    	<delete id="delete">
    	    delete from t_task
    	    where id='${id}'
    	</delete>
    	
    </mapper>

这里和mybatis很类似，就不解释了。mapper标签指定了工具类，该工具类用户只需要定义其接口即可，方法名为语句的id，比如：

public interface TaskMapper {
    
    	List<TaskVo> findTask(TaskVo vo);
    	List<TaskVo> findById(TaskVo vo);
    	List<TaskVo> findByRequestCode(TaskVo vo);
    	void insert(TaskVo vo);
    	void update(TaskVo vo);
    	void updateRun(TaskVo vo);
    	void delete(TaskVo vo);
    	
    }

在需要操作数据库的地方可以依赖注入mapper，比如在TaskService类中：

public class TaskService implements Serializable{
    @Table(value=R.xml.task)
    	private TaskMapper taskMapper;
    }

@Table注释的value指定sql语句管理的xml

到此为止，就可以用taskMapper进行数据库操作了，而不需要像之前那样需要继承BaseService类

**实现方法**

如何实现以上功能呢？

1、DaoHelper类

该类是真正做事情的劳动力，所有数据库的操作将由它来完成。因此它也是所有类中最核心的类。

它完成如下工作：

a、对xml进行解析，获得sql语句进行建表，删表。增删改查操作。

b、对查询结果封装成对象。

c、通过动态代理，把自己绑定成用户定义的mapper接口，从而自动实现接口。

2、DBHelper类

该类用于管理数据库的创建，版本升级，它继承自SQLiteOpenHelper类

对于建表，删表工作，它将转交给DaoHelper类来完成

那么，@DB注释中的数据库名，版本号和表配置文件如何获得呢，请看下面的类

3、BeanHelper类

还记得该类吗，上篇文章中介绍过，它负责所有依赖注入的类的实例化工作。

在这里，它将会有一个新的工作，把@DB注释中指定的数据库名，版本号，表配置文件告诉DBHelper类。

同样，该工作将在static静态块中进行，保证框架一开始就能保证数据库的状态。

4、IocHelper类

最后一个问题，如何通过@Table注释依赖注入mapper，则将由IocHelper类负责。

该类的类名起的有问题，因为我们还有一个类叫做InjectHelper类。

在上一篇文章中我们知道InjectHelper类负责标注了@Compoent的注释的依赖注入。为什么这里又有一个类似的类。原因是刚开始写框架的时候只想着做数据库方面的，因此定义了IocHelper类，后来又做了@Compoent，没有把关系处理好。

题外话说完，该类通过反射扫描字段中是否有@Table注释，如果有则通过动态代理把daoHelper做为mapper进行注入。

到此为止就已经把思路完全介绍完了

看一下代码吧

DaoHelper类

@Component
    public class DaoHelper implements InvocationHandler{
    
    	private static String TAG="Loader";
    
    	private DBHelper helper;
    	public static String dbPath;
    	private static final String MAPPER_NAMESPACE="namespace";
    	private static final String ID="id";
    	private static final String TABLE_NAME="name";
    	private static final String COLUNM_NAME="name";
    	private static final String COLUNM_TYPE="type";
    	private static final String COLUNM_PRIMARY="primaryKey";
    	private static final String COLUNM_AUTOINCREMENT="autoincrement";
    	private static final String RESULT_TYPE="resultType";
    	
    	private Context context;
    	private XmlResourceParser xmlParser;
    	private int xmlId;
    	public static int dbXmlId;
    	private SQLiteDatabase db;
    	private Dao dao;
    
    	public DaoHelper(){
    		
    	}
    	
    	public DaoHelper(Activity context){
    		this.helper=new DBHelper(context);
    		this.context=context;
    	}
    	
    	/**
    	 * 
    	 * 动态代理，实际执行的是Dao类的操作
    	 * 
    	 */
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args)
    			throws Throwable {
    		Object result=null;
    		if (Object.class.equals(method.getDeclaringClass())) {
    			try {
    				result=method.invoke(this, args);
    			} catch (Throwable t) {
    				t.printStackTrace();
    			}
    		} else {
    			result=run(method, args);
    		}
    		return result;
    	}
    	
    	/**
    	 * 
    	 * 获得xml关联的接口
    	 * 
    	 * @return
    	 * @throws XmlPullParserException
    	 * @throws ClassNotFoundException
    	 * @throws IOException
    	 */
    	public Class getMapper() throws XmlPullParserException, ClassNotFoundException, IOException{
    		Class c=null;
    		Resources res = context.getResources();     
    		xmlParser = res.getXml(xmlId);
    		int eventType = xmlParser.getEventType();  
    	    while (eventType != XmlResourceParser.END_DOCUMENT) {  
    	    	 if (eventType == XmlResourceParser.START_TAG) {
    	    		 String tagName = xmlParser.getName();
    	    		 if(tagName.equals("mapper")){
    	    			 int count=xmlParser.getAttributeCount();
    	    			 for(int i=0;i<count;i++){
    	    				if(xmlParser.getAttributeName(i).equals(MAPPER_NAMESPACE)) {
    	    					c=Class.forName(xmlParser.getAttributeValue(i));
    	    				}
    	    			 }
    	    		 }
    	    	 }
    	    	 eventType = xmlParser.next();  
    	    }
    	    return c;
    	}
    	
    	public Object run(Method method,Object[] args) throws Exception{
    		if(dao==null)
    			dao=new Dao();
    		Object result=null;
    		String name=method.getName();
    		//初始化数据库表，如果存不存在则建表
    		openDB();
    		result=dao.exec(name,args);
    		return result;
    	}
    	
    	public void initTable(SQLiteDatabase db) throws XmlPullParserException, IOException{
    		Resources res = context.getResources();   
    		xmlParser = res.getXml(dbXmlId);
    		int eventType = xmlParser.getEventType();  
    		    // 判断是否到了文件的结尾    
                while (eventType != XmlResourceParser.END_DOCUMENT) {  
                	//启始标签
                	 if (eventType == XmlResourceParser.START_TAG) {
                		 String tagName = xmlParser.getName();
                		 if(tagName.equals("table")){
                	   		 StringBuffer sb=new StringBuffer();
    	            		 sb.append("create table if not exists ");
                			 int count=xmlParser.getAttributeCount();
                			 for(int i=0;i<count;i++){
                				 //表名
                				 if(xmlParser.getAttributeName(i).equals(TABLE_NAME)){
                					 sb.append(xmlParser.getAttributeValue(i)+"( ");
                				 }
                			 }
                			 int e=xmlParser.next();
                			 if(e==XmlResourceParser.START_TAG){
                				 tagName = xmlParser.getName();
                				 //字段
                				 while(tagName.equals("colunm")){
                					if(e==XmlResourceParser.START_TAG){
    	    	            			sb.append(xmlParser.getAttributeValue(null, COLUNM_NAME)+" ");
    	    	            			sb.append(xmlParser.getAttributeValue(null, COLUNM_TYPE)+" ");
    	    	            			String isPrimary=xmlParser.getAttributeValue(null, COLUNM_PRIMARY);
    	    	            			if(isPrimary!=null && isPrimary.equals("true"))
    	    	            				sb.append("primary key ");
    	    	            			String isAutoIncrement=xmlParser.getAttributeValue(null, COLUNM_AUTOINCREMENT);
    	    	            			if(isAutoIncrement!=null && isAutoIncrement.equals("true"))
    	    	            				sb.append("autoincrement ");
    	    	            			sb.append(",");
                					}
        	            			e=xmlParser.next();
        	            			tagName = xmlParser.getName();
                				 }
                				 String s=sb.substring(0,sb.length()-1);
                				 s=s+")";
                		         Log.d(TAG, "建表语句为:"+s);
                		         db.execSQL(s);
                			 }
                		 }
                	 }
                	 //移到下一个标签
                	 eventType = xmlParser.next();    
                }
    	}
    	
    	public void dropTable(SQLiteDatabase db) throws XmlPullParserException, IOException{
    		Resources res = context.getResources();   
    		xmlParser = res.getXml(dbXmlId);
    		int eventType = xmlParser.getEventType();  
    		    // 判断是否到了文件的结尾    
                while (eventType != XmlResourceParser.END_DOCUMENT) {  
                	//启始标签
                	 if (eventType == XmlResourceParser.START_TAG) {
                		 String tagName = xmlParser.getName();
                		 if(tagName.equals("table")){
                	   		 StringBuffer sb=new StringBuffer();
    	            		 sb.append("drop table if exists ");
                			 int count=xmlParser.getAttributeCount();
                			 for(int i=0;i<count;i++){
                				 //表名
                				 if(xmlParser.getAttributeName(i).equals(TABLE_NAME)){
                					 sb.append(xmlParser.getAttributeValue(i));
                				 }
                			 }
                			 db.execSQL(sb.toString());
                		 }
                	 }
                	 //移到下一个标签
                	 eventType = xmlParser.next();    
                }
    	}
    	
    	private void openDB(){
    		if(helper==null)
    			this.helper=new DBHelper(context);
    		db=helper.getReadableDatabase();
    	}
    	
    	class Dao{
    		public Object exec(String name,Object[] args) throws Exception{
    			Object result = null;
    			//解析xml
    			Resources res = context.getResources();   
    			xmlParser = res.getXml(xmlId);
    		    int eventType = xmlParser.getEventType();  
    		    // 判断是否到了文件的结尾    
                while (eventType != XmlResourceParser.END_DOCUMENT) {  
                	//启始标签
                	 if (eventType == XmlResourceParser.START_TAG) {
                		 String tagName = xmlParser.getName();
                		 if(tagName.equals("select")){
                			 //id
                			 String id=xmlParser.getAttributeValue(null, ID);
                			 if(name.equals(id)){
    	            			 //返回类型
    	        				 String type=xmlParser.getAttributeValue(null, RESULT_TYPE);
    	            			 //获得sql语句
    	            			 eventType = xmlParser.next();  
    	            			 String sql=xmlParser.getText();
    	            			 //绑定参数
    	            			 sql=bindArgs(sql,args);
    	            			 Cursor cursor=db.rawQuery(sql,new String[]{});
    	        				 //映射结果
    	        				 if(!type.equals("java.util.Map")){
    	        					 List list=new ArrayList();
    	        					 Class c=Class.forName(type);
    	        					 while(cursor.moveToNext()){
    		        					 Object o=c.newInstance();
    		        					 List<Field> fs=getDeclaredField(o);
    		        					 for(Field f : fs){
    		        						 String fName=f.getName();
    		        						 if(fName.equals("serialVersionUID"))
    		        							 continue;
    		        						 Method m=getDeclaredMethod(o,"set"+fName.substring(0,1).toUpperCase()+fName.substring(1),f.getType());
    		        						 if(f.getType()==String.class){
    		        							 try{
    		        								 m.invoke(o, cursor.getString(cursor.getColumnIndexOrThrow(fName)));
    		        							 }catch(Exception e){
    		        								 m.invoke(o, "");
    		        							 }
    		        						 }
    		        						 if(f.getType()==Integer.class){
    		        							 try{
    		        							 	m.invoke(o, cursor.getInt(cursor.getColumnIndexOrThrow(fName)));
    			        						 }catch(Exception e){
    		        								 m.invoke(o, 0);
    		        							 }
    		        						 }
    		        						 if(f.getType()==Float.class){
    		        							 try{
    		        							 	m.invoke(o, cursor.getFloat(cursor.getColumnIndexOrThrow(fName)));
    			        						 }catch(Exception e){
    		        								 m.invoke(o, 0);
    		        							 }
    		        						 }
    		        						 if(f.getType()==Double.class){
    		        							 try{
    		        							 	m.invoke(o, cursor.getDouble(cursor.getColumnIndexOrThrow(fName)));
    			        						 }catch(Exception e){
    		        								 m.invoke(o, 0);
    		        							 }
    		        						 }
    		        					 }
    		        					 list.add(o);
    	        					 }
    	        					 result=list;
    	        				 }
    	        				 else{
    	        					 
    	        				 }
    	        				 return result;
                			 }
                		 }else if(tagName.equals("insert")){
                			 String id=xmlParser.getAttributeValue(null, ID);
                			 if(name.equals(id)){
    	            			 //获得sql语句
    	            			 eventType = xmlParser.next();  
    	            			 String sql=xmlParser.getText();
    	            			 //绑定参数
    	            			 sql=bindArgs(sql,args);
    	            			 db.execSQL(sql);
                			 }
                		 }else if(tagName.equals("update")){
                			 String id=xmlParser.getAttributeValue(null, ID);
                			 if(name.equals(id)){
    	            			 //获得sql语句
    	            			 eventType = xmlParser.next();  
    	            			 String sql=xmlParser.getText();
    	            			 //绑定参数
    	            			 sql=bindArgs(sql,args);
    	            			 db.execSQL(sql);
                			 }
                		 }else if(tagName.equals("delete")){
                			 String id=xmlParser.getAttributeValue(null, ID);
                			 if(name.equals(id)){
    	            			 //获得sql语句
    	            			 eventType = xmlParser.next();  
    	            			 String sql=xmlParser.getText();
    	            			 //绑定参数
    	            			 sql=bindArgs(sql,args);
    	            			 db.execSQL(sql);
                			 }
                		 }
                	 }
                	 //移到下一个标签
                	 eventType = xmlParser.next();    
                }
    			return result;
    		}
    		
    		public Cursor query(){
    			return null;
    		}
    	}
    	
    	/**
    	 * 
    	 *  绑定参数
    	 * 
    	 * @param sql
    	 * @param args
    	 * @return
    	 * @throws IllegalAccessException
    	 * @throws IllegalArgumentException
    	 * @throws InvocationTargetException
    	 */
    	private String bindArgs(String sql,Object[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException{
    		 if(!args[0].getClass().getName().equals(Map.class.getName())){
    			 Class argc=args[0].getClass();
    			 List<Field> fs=getDeclaredField(args[0]);
    			 for(Field f: fs){
    				 String fName=f.getName();
    				 Method m=getDeclaredMethod(args[0],"get"+fName.substring(0,1).toUpperCase()+fName.substring(1));
    				 //Log.d(TAG, "解析字段："+fName);
    				 String fValue="";
    				 if(!fName.equals("serialVersionUID"))
    					fValue=String.valueOf(m.invoke(args[0]));
    				 sql=sql.replace("${"+fName+"}", fValue);
    			 }
    		 }
    		 //绑定参数，参数类型为map
    		 else{
    			 
    		 }
    		 return sql;
    	}
    	
    	private List<Field> getDeclaredField(Object object){  
            List<Field> fa = new ArrayList<Field>() ;  
              
            Class<?> clazz = object.getClass() ;  
              
            for(; clazz != Object.class ; clazz = clazz.getSuperclass()) {  
                try {  
                    Field[] fs=clazz.getDeclaredFields();
                    for(Field f : fs){
                    	fa.add(f);
                    }
                } catch (Exception e) {  
                	
                }   
            }  
          
            return fa;  
        }     
    	
    	private Method getDeclaredMethod(Object object, String methodName, Class<?> ... parameterTypes){  
            Method method = null ;  
              
            for(Class<?> clazz = object.getClass() ; clazz != Object.class ; clazz = clazz.getSuperclass()) {  
                try {  
                    method = clazz.getDeclaredMethod(methodName, parameterTypes) ;  
                    return method ;  
                } catch (Exception e) {   
                  
                }  
            }  
              
            return null;  
        }  
    
    	public Context getContext() {
    		return context;
    	}
    
    	public void setContext(Context context) {
    		this.context = context;
    	}
    
    	public int getXmlId() {
    		return xmlId;
    	}
    
    	public void setXmlId(int xmlId) {
    		this.xmlId = xmlId;
    	}
    
    	public DBHelper getHelper() {
    		return helper;
    	}
    
    	public void setHelper(DBHelper helper) {
    		this.helper = helper;
    	}
    	
    }

DBHelper类

public class DBHelper extends SQLiteOpenHelper {
    
    	public static String DB_NAME = "myTask.db";
        public static int DB_VERSION = 1; 
        public static int DB_RESOURCE;
        private Context context;
        private DaoHelper daoHelper;
        
        public DBHelper(Context context) {
            this(context, DB_NAME, null, DB_VERSION);
        }
    
        private DBHelper(Context context, String name, CursorFactory factory, int version) {
            super(context, name, factory, version);
            this.context=context;
        }
    
        @Override
        public void onCreate(SQLiteDatabase db) {
        	try {
        		createTable(db);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
        }
    
        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        	try {
        		dropTable(db);
        		createTable(db);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
        }
        
        @Override
        protected void finalize() throws Throwable {
            this.close();
            super.finalize();
        }
    
    	public DaoHelper getDaoHelper() {
    		return daoHelper;
    	}
    
    	public void setDaoHelper(DaoHelper daoHelper) {
    		this.daoHelper = daoHelper;
    	}
    	
    	private void createTable(SQLiteDatabase db) throws XmlPullParserException, IOException{
    		DaoHelper.dbXmlId=DB_RESOURCE;
    		daoHelper=new DaoHelper();
    		daoHelper.setContext(context);
    		daoHelper.initTable(db);
    	}
    
    	private void dropTable(SQLiteDatabase db) throws XmlPullParserException, IOException{
    		DaoHelper.dbXmlId=DB_RESOURCE;
    		daoHelper=new DaoHelper();
    		daoHelper.setContext(context);
    		daoHelper.dropTable(db);
    	}
    	
    }

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)){
    					//把数据库名，版本信息，配置文件交给DBHelper，从而使数据库就绪
    					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){
    		T bean=(T) BEAN_MAP.get(cls);
    		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);
    	}
    	*/
    	
    }

IocHelper类

public class IocHelper {
    
    	private static final String TAG="IocHelper";
    	
    	static{
    		Map<Class<?>,Object> beanMap=BeanHelper.getBeanMap();
    		if(!beanMap.isEmpty()){
    			for(Map.Entry<Class<?>, Object> beanEntry : beanMap.entrySet()){
    				Class<?> cls=beanEntry.getKey();
    				Object bean=beanEntry.getValue();
    				mapperInject(cls,bean,beanMap);
    			}
    			for(LoadHelper.IocLinstener linstener : LoadHelper.getLinstener()){
    				Log.d(TAG, "--------------completeInject---------------------");
    				linstener.onInjectComplete();
    			}
    		}
    	}
    	
    	public static Object mapperInject(Class<?> cls,Object bean,Map<Class<?>,Object> beanMap){
    		Field[] beanFields=cls.getDeclaredFields();
    		for(Field beanField : beanFields){
    			//依赖注入@Table注释的mapper
    			if(beanField.isAnnotationPresent(Table.class)){
    				beanField.setAccessible(true);
    				try {
    					//获取注解
    					Table table=beanField.getAnnotation(Table.class);
    					int tableResource=table.value();
    					//通过动态代理实现mapper接口
    					DaoHelper daoHelper=(DaoHelper) beanMap.get(DaoHelper.class);
    					daoHelper.setXmlId(tableResource);
    					daoHelper.setContext(ApplicationSelf.getContext());
    					daoHelper.setHelper(new DBHelper(ApplicationSelf.getContext()));
    					Object newProxyInstance = Proxy.newProxyInstance(
    							daoHelper.getMapper().getClassLoader(),
    							new Class[] {daoHelper.getMapper()}, daoHelper);
    					beanField.set(bean, newProxyInstance);
    				} catch (Exception e) {
    					e.printStackTrace();
    				} 
    			}
    		}
    		return bean;
    	}
    	
    }

DB注释类

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface DB {
    
        String db_name() default "myTask.db";
        int db_version() default 1;
        int db_xml_id();
        
    }

Table注释类

@Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Table {
    
    	int value();
    	
    }

[android_mybatis_]: http://blog.csdn.net/guduyishuai/article/details/54616743
[_ android_]: http://blog.csdn.net/guduyishuai/article/details/54946238