package org.denger.mapper;  
  
import org.apache.ibatis.annotations.Param;  
import org.apache.ibatis.annotations.Select;  
import org.denger.po.User;  
  
public interface UserMapper {  
  
    @Select("select * from tab_uc_account where id=#{userId}")  
    User getUser(@Param("userId") Long userId);  
}

package org.denger.mapper;  
  
import org.junit.Assert;  
import org.junit.Test;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.test.context.ContextConfiguration;  
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;  
  
@ContextConfiguration(locations = { "/application-context.xml"})  
public class UserMapperTest extends AbstractJUnit4SpringContextTests{  
  
    @Autowired  
    public UserMapper userMapper;  
      
    @Test  
    public void testGetUser(){  
        Assert.assertNotNull(userMapper.getUser(300L));  
    }  
}

/**
 * BeanDefinitionRegistryPostProcessor that searches recursively starting from a base package for
 * interfaces and registers them as {@code MapperFactoryBean}. Note that only interfaces with at
 * least one method will be registered; concrete classes will be ignored.
 * <p>

/** 
 1. Calls the parent search that will search and register all the candidates. Then the 
 2. registered objects are post processed to set them as MapperFactoryBeans 
*/  
@Override  
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {  
        // #1  
    Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);  
    if (beanDefinitions.isEmpty()) {  
            logger.warn("No MyBatis mapper was found in '" + MapperScannerConfigurer.this.basePackage  
                        + "' package. Please check your configuration.");  
    } else {  
         // #2  
         for (BeanDefinitionHolder holder : beanDefinitions) {  
                GenericBeanDefinition definition = (GenericBeanDefinition) holder.getBeanDefinition();  
            if (logger.isDebugEnabled()) {  
                logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '"+ definition.getBeanClassName() + "' mapperInterface");  
            }  
           // #3  
          definition.getPropertyValues().add("mapperInterface", definition.getBeanClassName());  
          definition.setBeanClass(MapperFactoryBean.class);  
     }  
    return beanDefinitions;  
}

/** 
     * {@inheritDoc} 
     */  
    public void afterPropertiesSet() throws Exception {  
        Assert.notNull(this.sqlSession, "Property 'sqlSessionFactory' or 'sqlSessionTemplate' are required");  
        Assert.notNull(this.mapperInterface, "Property 'mapperInterface' is required");  
  
        Configuration configuration = this.sqlSession.getConfiguration();  
        if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {  
            configuration.addMapper(this.mapperInterface);  
        }  
    }

/** 
    * {@inheritDoc} 
    */  
   public T getObject() throws Exception {  
       return this.sqlSession.getMapper(this.mapperInterface);  
   }

/** 
     * {@inheritDoc} 
     */  
    public <T> T getMapper(Class<T> type) {  
        return getConfiguration().getMapper(type, this);  
    }

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {  
    return mapperRegistry.getMapper(type, sqlSession);  
}

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {  
	//  #1
    if (!knownMappers.contains(type))  
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");  
    try {  
	  // #2
      return MapperProxy.newMapperProxy(type, sqlSession);  
    } catch (Exception e) {  
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);  
    }  
}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
   try {  
     //如果调用不是 object 中默认的方法(如equals之类的)  
     if (!OBJECT_METHODS.contains(method.getName())) {  
       //因为当前MapperProxy代理了所有 Mapper，所以需要根据当前拦截到的方法及代理对象获取 MapperInterface  class，也就是UserMapper.class  
       final Class declaringInterface = findDeclaringInterface(proxy, method);  
       //然后再根据UserMapper.class、及当前调用的Method(也就是getUser)及SqlSession构造一个 MapperMethod，在这里面会获取到getUser方法上的 @Select()的SQL，然后再通过sqlSession来进行执行  
       final MapperMethod mapperMethod = new MapperMethod(declaringInterface, method, sqlSession);  
       //execute执行数据库操作，并返回结果集  
       final Object result = mapperMethod.execute(args);  
       if (result == null && method.getReturnType().isPrimitive()) {  
         throw new BindingException("Mapper method '" + method.getName() + "' (" + method.getDeclaringClass() + ") attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");  
       }  
       return result;  
     }  
   } catch (SQLException e) {  
     e.printStackTrace();  
   }  
   return null;  
 }

protected void checkDaoConfig() {
    super.checkDaoConfig();

    notNull(this.mapperInterface, "Property 'mapperInterface' is required");

    Configuration configuration = getSqlSession().getConfiguration();
    if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {
      try {
        configuration.addMapper(this.mapperInterface);
      } catch (Exception e) {
        logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", e);
        throw new IllegalArgumentException(e);
      } finally {
        ErrorContext.instance().reset();
      }
    }
  }

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    if (Object.class.equals(method.getDeclaringClass())) {
      try {
        return method.invoke(this, args);
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
  }