mybatis generator生成mapper接口后的代理类，很方便使用。

1.spring 配置：

<bean id="superMapperProxy" class="com.qws.v1.daoImpl.MapperProxy">
<property name="mapperPackagePrifix" value="com.qws.v1.mapper."></property>
</bean>

package com.qsw.v1.daoImpl;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;

import org.apache.ibatis.annotations.Param;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

import com.qsw.v1.util.BaseClass;

/**
 * mapper proxy,结合pageHelper+MyBatisGenerator简直所向无敌
 * 后期将加入redis缓存功能，结合nginx转发组成高并发后端
 * @author Administrator
 *
 */
public class MapperProxy extends BaseClass implements ApplicationContextAware {

    /**************************************    代理方法名 start     ***************************************/
    public static final String COUNT_BY_EXAMPLE_METHOD_NAME = "countByExample";
    public static final String DELETE_BY_EXAMPLE_METHOD_NAME = "deleteByExample";
    public static final String DELETE_BY_PRIMARY_KEY_METHOD_NAME = "deleteByPrimaryKey";
    public static final String INSERT_METHOD_NAME = "insert";
    public static final String INSERT_SELECTIVE_METHOD_NAME = "insertSelective";
    public static final String SELECT_BY_EXAMPLE_METHOD_NAME = "selectByExample";
    public static final String SELECT_BY_PRIMARY_KEY_METHOD_NAME = "selectByPrimaryKey";
    public static final String UPDATE_BY_EXAMPLE_SELECTIVE_METHOD_NAME = "updateByExampleSelective";
    public static final String UPDATE_BY_EXAMPLE_METHOD_NAME = "updateByExample";
    public static final String UPDATE_BY_PRIMARYKEY_SELECTIVE_METHOD_NAME = "updateByPrimaryKeySelective";
    public static final String UPDATE_BY_PRIMARYKEY_METHOD_NAME = "updateByPrimaryKey";
    /**************************************    代理方法名 end     ***************************************/
    
    /**
     * mapper所在包的前缀
     */
    private String mapperPackagePrifix;
    
    /**
     * application 实例
     */
    private ApplicationContext ctx;

    public void setMapperPackagePrifix(String name) {
        this.mapperPackagePrifix = name;
    }

    /**
     * 根据一个对象查找Mapper，对象要么是实体类，要么是example
     * @param obj
     * @return
     */
    public Object findMapper(Object obj) {
        try {
            if (obj == null) {
                logger.warn("the param obj instance can not be null !");
                return null;
            }
            Class<?> clazz = obj.getClass();
            String name = clazz.getSimpleName();
            String mapperClassName = "";
            if (name.endsWith("Example")) {
                int index = name.indexOf("Example");
                mapperClassName = mapperPackagePrifix + name.substring(0, index) + "Mapper";
            } else {
                mapperClassName = mapperPackagePrifix + name + "Mapper";
            }
            logger.debug("mapper class name is :" + mapperClassName );
            Class<?> mapperClazz = Class.forName(mapperClassName);
            logger.debug("mapper is found :" + mapperClazz );
            return ctx.getBean(mapperClazz);
        } catch (Exception e) {
            logger.error("find mapper failed : " + e.getMessage());
        }
        return null;
    }

    /**
     * 查找方法
     * @param obj
     * @return
     */
    public Method findMethod(Object mapper, String methodName, Object... parameters) {
        try {
            if (mapper == null) {
                logger.warn("the mapper can not be null ! ");
            }
            Class<?> clazz = mapper.getClass();
            Class<?>[] clazzArray = new Class[parameters.length];
            for (int i = 0; i < parameters.length; i++) {
                if (parameters[i] == null) {
                    continue;
                }
                clazzArray[i] = parameters[i].getClass();
            }
            logger.debug("the clazz array is " + Arrays.toString(clazzArray));
            return clazz.getDeclaredMethod(methodName, clazzArray);
        } catch (Exception e) {
            logger.error(" find method : " + methodName + " is error," + e.getMessage());
        }
        return null;
    }

    /**
     * 查询数量
     * 
     * @param example
     * @return
     */
    public int countByExample(Object example) {
        try {
            if (example == null) {
                logger.warn("countByExample failed,the example can not be null !");
                return -1;
            }

            Object mapper = findMapper(example);
            logger.debug("mapper instance found for " + mapper.getClass());

            Method method = findMethod(mapper, COUNT_BY_EXAMPLE_METHOD_NAME, example);
            logger.debug("mapper instance found for " + mapper.getClass());

            return (int) method.invoke(mapper, example);
        } catch (Exception e) {
            logger.error("countByExample failed, " + e.getMessage() );
        }
        return -1;
    }

    /**
     * 代理方法
     * @param example
     * @return
     */
    public int deleteByExample(Object example) {
        try {
            if (example == null) {
                logger.warn("deleteByExample failed,the example can not be null !");
                return -1;
            }

            Object mapper = findMapper(example);
            logger.debug("mapper instance found for " + mapper.getClass());

            Method method = findMethod(mapper, DELETE_BY_EXAMPLE_METHOD_NAME, example);
            logger.debug("mapper instance found for " + mapper.getClass());

            return (int) method.invoke(mapper, example);
        } catch (Exception e) {
            logger.error("deleteByExample failed, " + e.getMessage() );
        }
        return -1;
    }

    /**
     * 代理方法
     * @param id
     * @param beanClazz
     * @return
     */
    public int deleteByPrimaryKey(Object id, Class<?> beanClazz) {
        String mapperClassName = "";
        try {
            if (id == null) {
                logger.warn("deleteByPrimaryKey failed,the id can not be null !");
                return -1;
            }

            if (beanClazz == null) {
                logger.warn("deleteByPrimaryKey failed,the beanClazz can not be null !");
                return -1;
            }

            mapperClassName = mapperPackagePrifix + beanClazz.getSimpleName() + "Mapper";
            Class<?> clazz = Class.forName(mapperClassName);
            logger.debug("Mapper class  found for " + mapperClassName);

            Object mapper = ctx.getBean(mapperClassName);
            logger.debug("mapper instance found for " + mapper.getClass());

            Method method = clazz.getMethod(DELETE_BY_PRIMARY_KEY_METHOD_NAME, id.getClass());
            logger.debug("mapper instance found for " + mapper.getClass());

            return (int) method.invoke(mapper, id);
        } catch (Exception e) {
            logger.error("deleteByPrimaryKey failed, " + e.getMessage() );
        }
        return -1;
    }

    /**
     * 代理方法
     * @param record
     * @return
     */
    public int insert(Object record) {
        try {
            if (record == null) {
                logger.warn("insert faild,the object can not be null !");
                return -1;
            }

            Object mapper = findMapper(record);
            logger.debug("mapper instance found for " + mapper.getClass());

            Method insertMethod = findMethod(mapper, INSERT_METHOD_NAME, record);
            logger.debug("method  found in " + mapper.getClass());

            if (insertMethod == null) {
                logger.warn("insert faild,the method dose not exits !");
                return -1;
            }

            Object value = insertMethod.invoke(mapper, record);
            logger.info("insert success,the return value is: " + value );
            ValueOperations<String, Object> values = ctx.getBean(RedisTemplate.class).opsForValue();
            List<Object> lst=(List<Object>) values.get("INSERT_LIST");
            if (lst==null) {
                lst=new ArrayList<Object>();
            }
            values.set("INSERT_LIST", lst, 3, TimeUnit.DAYS);
            return (int) value;
        } catch (Exception e) {
            logger.error("insert faild," + e.getMessage() );
        }
        return -1;
    }

    /**
     * 代理方法
     * @param record
     * @return
     */
    public int insertSelective(Object record) {

        try {
            if (record == null) {
                logger.warn("insertSelective faild,the object can not be null !");
                return -1;
            }

            Object mapper = findMapper(record);
            logger.debug("mapper instance found for " + mapper.getClass());

            Method insertMethod = findMethod(mapper, INSERT_SELECTIVE_METHOD_NAME, record);
            logger.debug("method  found in " + mapper.getClass());

            if (insertMethod == null) {
                logger.warn("insertSelective faild,the method dose not exits !");
                return -1;
            }

            Object value = insertMethod.invoke(mapper, record);
            ValueOperations<String, Object> values = ctx.getBean(RedisTemplate.class).opsForValue();
            List<Object> lst=(List<Object>) values.get(record.getClass().getSimpleName()+"_List");
            if (lst==null) {
                lst=new ArrayList<Object>();
            }
            values.set(record.getClass().getSimpleName()+"_List", lst, 3, TimeUnit.DAYS);
            logger.info("insertSelective success,the return value is: " + value );
            return (int) value;
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("insertSelective faild," + e.getMessage() );
        }
        return -1;
    }

    /**
     * 代理方法
     * @param example
     * @return
     */
    public List<?> selectByExample(Object example) {
        try {
            if (example == null) {
                logger.warn("selectByExample failed,the example can not be null !");
                return null;
            }

            Object mapper = findMapper(example);
            logger.debug("mapper instance found for " + mapper.getClass());

            Method method = findMethod(mapper, SELECT_BY_EXAMPLE_METHOD_NAME, example);
            logger.debug("mapper instance found for " + mapper.getClass());

            return (List<?>) method.invoke(mapper, example);
        } catch (Exception e) {
            logger.error("deleteByExample failed, " + e.getMessage() );
        }
        return null;
    }

    /**
     * 代理方法,代理原selectByPrimaryKey方法，由于原方法只需要主键，此处无法只需要一个主键，故加入一个Type
     * @param id
     * @param clazz
     * @return
     */
    @SuppressWarnings("unchecked")
    public <T> T selectByPrimaryKey(Object id, Class<T> clazz) {
        String mapperClassName = "";
        try {
            if (id == null) {
                logger.warn("selectByPrimaryKey failed,the id can not be null !");
                return null;
            }

            if (clazz == null) {
                logger.warn("selectByPrimaryKey failed,the param clazz can not be null !");
                return null;
            }
            mapperClassName = mapperPackagePrifix + clazz.getSimpleName() + "Mapper";
            Class<?> clazzMapper = Class.forName(mapperClassName);
            logger.debug("Mapper class  found for " + mapperClassName);

            Object mapper = ctx.getBean(clazzMapper);
            logger.debug("mapper instance found for " + mapper.getClass());

            Method method = clazzMapper.getMethod(SELECT_BY_PRIMARY_KEY_METHOD_NAME, id.getClass());
            logger.debug("mapper instance found for " + mapper.getClass());

            return (T) method.invoke(mapper, id);
        } catch (Exception e) {
            logger.error("selectByPrimaryKey failed, " + e.getMessage() );
        }
        return null;
    }

    /**
     * 代理方法
     * @param record
     * @param example
     * @return
     */
    public int updateByExampleSelective(@Param("record") Object record, @Param("example") Object example) {

        try {
            if (record == null) {
                logger.warn("updateByExampleSelective faild,the object can not be null !");
                return -1;
            }

            Object mapper = findMapper(record);
            logger.debug("mapper instance found for " + mapper.getClass());

            Method updateByExampleSelectiveMethod = findMethod(mapper, UPDATE_BY_EXAMPLE_SELECTIVE_METHOD_NAME, record,
                    example);
            logger.debug("method  found in " + mapper.getClass());

            if (updateByExampleSelectiveMethod == null) {
                logger.warn("updateByExampleSelectiveMethod faild,the method dose not exits !");
                return -1;
            }

            Object value = updateByExampleSelectiveMethod.invoke(mapper, record, example);
            logger.debug("updateByExampleSelective success,the return value is: " + value );
            return (int) value;
        } catch (Exception e) {
            logger.error("updateByExampleSelective faild," + e.getMessage() );
        }
        return -1;
    }

    /**
     * 代理方法
     * @param record
     * @param example
     * @return
     */
    public int updateByExample(@Param("record") Object record, @Param("example") Object example) {

        try {
            if (record == null) {
                logger.warn("updateByExample faild,the record can not be null !");
                return -1;
            }
            if (example == null) {
                logger.warn("updateByExample faild,the example can not be null !");
                return -1;
            }

            Object mapper = findMapper(record);
            logger.debug("mapper instance found for " + mapper.getClass());

            Method updateByExampleSelectiveMethod = findMethod(mapper, UPDATE_BY_EXAMPLE_METHOD_NAME, record, example);
            logger.debug("method  found in " + mapper.getClass());

            if (updateByExampleSelectiveMethod == null) {
                logger.warn("updateByExample faild,the method dose not exits !");
                return -1;
            }

            Object value = updateByExampleSelectiveMethod.invoke(mapper, record, example);
            logger.debug("updateByExample success,the return value is: " + value );
            return (int) value;
        } catch (Exception e) {
            logger.error("updateByExample faild," + e.getMessage() );
        }
        return -1;
    }

    /**
     * 代理方法
     * @param record
     * @return
     */
    public int updateByPrimaryKeySelective(Object record) {

        try {
            if (record == null) {
                logger.warn("updateByPrimaryKeySelective faild,the object can not be null !");
                return -1;
            }

            
            Object mapper =findMapper(record);
            logger.debug("mapper instance found for " + mapper.getClass());

            Method updateByExampleSelectiveMethod = findMethod(mapper,UPDATE_BY_PRIMARYKEY_SELECTIVE_METHOD_NAME, record);
            logger.debug("method  found in " + mapper.getClass());

            if (updateByExampleSelectiveMethod == null) {
                logger.warn("updateByExampleSelectiveMethod faild,the method dose not exits !");
                return -1;
            }

            Object value = updateByExampleSelectiveMethod.invoke(mapper, record);
            logger.info("updateByExampleSelectiveMethod success,the return value is: " + value );
            return (int) value;
        } catch (Exception e) {
            logger.error("updateByExampleSelectiveMethod faild," + e.getMessage() );
        }
        return -1;
    }

    /**
     * 代理方法
     * @param record
     * @return
     */
    public int updateByPrimaryKey(Object record) {

        try {
            if (record == null) {
                logger.warn("updateByPrimaryKey faild,the object can not be null !");
                return -1;
            }

            Object mapper = findMapper(record);
            logger.debug("mapper instance found for " + mapper.getClass());

            Method updateByExampleSelectiveMethod =findMethod(mapper,UPDATE_BY_PRIMARYKEY_METHOD_NAME, record);
            logger.debug("method  found in " + mapper.getClass());

            if (updateByExampleSelectiveMethod == null) {
                logger.warn("updateByPrimaryKey faild,the method dose not exits !");
                return -1;
            }

            Object value = updateByExampleSelectiveMethod.invoke(mapper, record);
            logger.info("updateByPrimaryKey success,the return value is: " + value );
            return (int) value;
        } catch (Exception e) {
            logger.error("updateByPrimaryKey faild," + e.getMessage() );
        }
        return -1;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        ctx = applicationContext;
    }

}

2.使用，如图：