mybatis对java自定义注解的使用

转自：https://www.cnblogs.com/sonofelice/p/4980161.html

最近在学习spring和ibatis框架。

以前在天猫实习时做过的一个小项目用到的mybatis，在其使用过程中，不加思索的用了比较原始的一种持久化方式：

在一个包中写一个DAO的接口，在另一个包里面写DAO的实现，使用sqlMapClient来从***-sql.xml中读取相应的sql。

 public interface IBaseDaoiBatis {
      Object get(String statementName);
 }
 public class BaseDaoiBatis implements IBaseDaoiBatis {
  public Object get(String statementName) {
         return getSqlMapClientTemplate().queryForObject(statementName);
     }
 }
 //对应的mybatis配置文件里面的sql：
 <sqlMap>
     <typeAlias alias="sonarBean" type="com.**--**.SonarScanDataDisplayBean" />
     <select id="getSonarScanData" parameterClass="java.lang.Integer" resultClass="java.lang.String">
         <![CDATA[
             SELECT  name FROM mm_test  where id=#id#;
         ]]>
     </select>
 </sqlMap>

最近搭建了一个spring+ibatis的项目，发现了一种新的持久化方式：

只写一个dao的接口，在接口的方法中直接注解上用到的sql语句，觉得蛮巧妙的。借来用一下。注意，接口上方多了一个@Mapper注解。而每个方法上都是@Select() 注解，值为对应的sql。

 @Mapper
 public interface TestDao {
     @Select("select id, name, name_pinyin from mm_test; ")
     List<MmTest> selectAll();
 
     @Insert("insert into mm_test(id, name) values(#{id}, #{name})")
     public void insertUser(MmTest mmtTestS);
 }

那么这个@Mapper注解究竟是个什么东西，是怎么起到注解的作用的？ibatis是怎么来识别这种注解的呢？对我这个java小白来说，注解，是spring特有的东西嘛？自学java的时候好像很少接触注解啊。不过竟然有java.lang.annotation 这个包，这到底是怎么回事？

那我们先来看一下Mapper这个自定义注解的定义：

 import org.springframework.stereotype.Component;
 
 import java.lang.annotation.*;
 @Target({ ElementType.TYPE })
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 @Component
 public @interface Mapper {
     String value() default "";
 }

关于自定义注解：（查的别人的博客：http://www.cnblogs.com/mandroid/archive/2011/07/18/2109829.html）博客里面写的非常详细，并且注解的使用机制很容易理解。

拿上述的@Mapper来说，Retention选择的是RUNTIME策略，就是运行时注入。那么要在运行时获得注入的值，必然要用到java的反射机制。通过反射，拿到一个类运行时的方法变量等，来进行一系列的操作。

那我要考虑的下一个问题是，我定义的@Mapper，在我的工程里面是怎么识别的呢？

来看一下我spring的配置文件中关于mybatis的配置

 <!--mybatis-->
     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
         <property name="dataSource" ref="dataSource" />
         <property name="configLocation">
             <value>classpath:myBatis/mapper.xml</value>
         </property>
     </bean>
     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
         <property name="basePackage" value="com.**.**.**.dao" />
         <property name="annotationClass" value="com.nuomi.crm.annotation.Mapper"/>
         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
     </bean>

在org.mybatis.spring.mapper.MapperScannerConfigurer这个类里面，应该是会去扫描我自定义的com.nuomi.crm.annotation.Mapper这个类的。

 <configuration>
     <settings>
         <!-- 将下划线字段名称映射为驼峰变量  -->
         <setting name="mapUnderscoreToCamelCase" value="true" />
         <!-- 进制mybatis进行延迟加载 -->
         <setting name="lazyLoadingEnabled" value="false"/>
     </settings>
     <mappers>
     </mappers>
 </configuration>

在我的mapper.xml里面只需要进行这一简单的配置就可以了（配置的含义后续补充）

接下来看一下mybatis自带的这个MapperScannerConfigurer究竟怎么实现的，来使用我这个自定义的注解@Mapper呢。

 public class MapperScannerConfigurer implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware {
 private Class<? extends Annotation> annotationClass;
   public void setAnnotationClass(Class<? extends Annotation> annotationClass) {
     this.annotationClass = annotationClass;
   }/**
    * {@inheritDoc}
    *
    * @since 1.0.2
    */
   public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
     if (this.processPropertyPlaceHolders) {
       processPropertyPlaceHolders();
     }
 
     ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
     scanner.setAddToConfig(this.addToConfig);
     scanner.setAnnotationClass(this.annotationClass);
     scanner.setMarkerInterface(this.markerInterface);
     scanner.setSqlSessionFactory(this.sqlSessionFactory);
     scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
     scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
     scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
     scanner.setResourceLoader(this.applicationContext);
     scanner.setBeanNameGenerator(this.nameGenerator);
     scanner.registerFilters();
     scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
   }
 
   /*
    * BeanDefinitionRegistries are called early in application startup, before
    * BeanFactoryPostProcessors. This means that PropertyResourceConfigurers will not have been
    * loaded and any property substitution of this class' properties will fail. To avoid this, find
    * any PropertyResourceConfigurers defined in the context and run them on this class' bean
    * definition. Then update the values.
    */
   private void processPropertyPlaceHolders() {
     Map<String, PropertyResourceConfigurer> prcs = applicationContext.getBeansOfType(PropertyResourceConfigurer.class);
 
     if (!prcs.isEmpty() && applicationContext instanceof GenericApplicationContext) {
       BeanDefinition mapperScannerBean = ((GenericApplicationContext) applicationContext)
           .getBeanFactory().getBeanDefinition(beanName);
 
       // PropertyResourceConfigurer does not expose any methods to explicitly perform
       // property placeholder substitution. Instead, create a BeanFactory that just
       // contains this mapper scanner and post process the factory.
       DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
       factory.registerBeanDefinition(beanName, mapperScannerBean);
 
       for (PropertyResourceConfigurer prc : prcs.values()) {
         prc.postProcessBeanFactory(factory);
       }
 
       PropertyValues values = mapperScannerBean.getPropertyValues();
 
       this.basePackage = updatePropertyValue("basePackage", values);
       this.sqlSessionFactoryBeanName = updatePropertyValue("sqlSessionFactoryBeanName", values);
       this.sqlSessionTemplateBeanName = updatePropertyValue("sqlSessionTemplateBeanName", values);
     }
   }
 
 }

上面只是截取的关于annotation的代码片段.

scanner.setAnnotationClass(this.annotationClass);
这里会去扫描配置的那个注解类。

mybatis的内部实现会使用java反射机制来在运行时去解析相应的sql。