android——仿mybatis的半自动数据库映射的实现

旧城等待， 2022-07-11 07:38 210阅读 0赞

由于一直是做web端，最近接触android，操作数据库的时候怀念mybatis，因此很简单的做了个功能有限的仿造。在此来探讨一下。

mybatis对于sql还是需要写的，只是自动映射字段到结果对象，所以是半自动，以此来体现其灵活性。而对于sql的管控完全分离到了xml之中。其中最令人印象深刻的地方之一应该是通过一个mapper接口去和xml进行管理。而这个mapper接口你只需要定义方法，系统会自动实现你的接口。

动态实现接口，其实原理是动态代理。通过把该接口代理为一个操作数据库的工具类，并通过xml解析，把sql传入到工具类执行sql，再通过反射进行对象映射即可。

我们来看一下我的实现吧，为了理解，先看一下xml

1、用来建表，删除表的xml

2、sql操作的xml

<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>

3、动态代理核心代码

/**
     * 
     * 仿造mybaits，通过动态代理将xml和mapper绑定，并解析xml执行sql
     * 
     * @author 吴林峰
     *
     */
    public class Loader implements InvocationHandler{
    
    	private static String TAG="Loader";
    
    	private Helper 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 Loader(){
    		
    	}
    	
    	public Loader(Activity context){
    		this.helper=new Helper(context);
    		this.context=context;
    	}
    	
    	@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 Helper(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 Helper getHelper() {
    		return helper;
    	}
    
    	public void setHelper(Helper helper) {
    		this.helper = helper;
    	}
    	
    }

最后，使用mybatis的时候我们通过IOC将我们定义的mapper接口注入到service层，在其中已经将mapper换成了代理类。

我这里没有用IOC，通过一个父类，识别传入的泛型来替换代理

/**
     * 
     * 在实例化的时候自动实现mapper接口
     * 
     * @author 吴林峰
     *
     * @param <T> mapper接口
     */
    public class BaseService<T> {
    
    	protected Context context;
    	protected T t;
    	
    	protected BaseService(Context context,HelperCreator hc){
    		this.context=context;
    		Loader loader=new Loader();
    		loader.setXmlId(R.xml.task);
    		loader.setHelper(hc.getHelper());
    		loader.setContext(context);
    		try {
    			Object newProxyInstance = Proxy.newProxyInstance(
    					loader.getMapper().getClassLoader(),
    					new Class[] {loader.getMapper()}, loader);
    			this.t=(T) newProxyInstance;
    		} catch (Exception e) {
    			e.printStackTrace();
    		} 
    	}
    	
    }

最后见证一下奇迹，看看怎么使用

1、只需要定义一个接口，不需要实现，方法名和xml中的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);
    	
    }

2、需要调用该接口的类继承BaseService该类即可，泛型为你需要用到的mapper接口

public class TaskService extends BaseService<TaskMapper>

这个时候，TaskService中就有了一个名为t的成员变量，该变量已经自动实现了TaskMapper接口

如果我要执行xml的sql语句，只需要调用该接口方法即可，比如

public List<TaskVo> getTask() throws Exception{
    		TaskVo vo=new TaskVo();
    		vo.setRows(100000);
    		vo.setOffset(0);
    		List<TaskVo> vos=t.findTask(vo);
    		for(TaskVo v : vos){
    			Log.d(TAG, "requestCode:"+v.getRequestCode());
    		}
    		return vos;
    	}

由于我们的TaskMapper没有通过代码实现，而是在运行时自动实现，所以LogCat会抛一个异常警告我们有接口没有实现，不过完全没有关系