`

mybatis使用心得(mark一下)

mybatis 
阅读更多

mybatis使用心得

博客分类：
mybatis物理分页mybatis nullmybatis spring 

一、mybatis版本
个人建议使用：

Java代码  收藏代码
  1. <dependency>  
  2.     <groupId>org.mybatis</groupId>  
  3.     <artifactId>mybatis</artifactId>  
  4.     <version>3.1.1</version>  
  5. </dependency>  


在mybatis3.1.1中优化了批量处理的效率
在底层statementHandle中提供了更加灵活的扩展性
主要是体现在插件，拦截器能做的，能够获取到的参数更多的方面

二、与spring集合的配置

Java代码  收藏代码
  1. <bean id="sqlSessionFactory"   
  2.     class="org.mybatis.spring.SqlSessionFactoryBean">  
  3.     <property name="dataSource" ref="datasource"></property>  
  4.     <property name="configLocation" value="classpath:context/mybatis-config.xml"></property>  
  5.     <property name="mapperLocations" value="classpath*:/com/tx/demo/**/*SqlMap.xml" />      
  6.     <property name="typeHandlersPackage" value="com.tx.core.mybatis.handler"></property>  
  7.     <property name="failFast" value="true"></property>  
  8.     <property name="plugins">  
  9.         <array>  
  10.             <bean class="com.tx.core.mybatis.interceptor.PagedDiclectStatementHandlerInterceptor">  
  11.                 <property name="dialect">  
  12.                     <bean class="org.hibernate.dialect.PostgreSQLDialect"></bean>  
  13.                 </property>  
  14.             </bean>  
  15.         </array>  
  16.     </property>  
  17. </bean>  
  18.   
  19. <bean id="myBatisExceptionTranslator" class="org.mybatis.spring.MyBatisExceptionTranslator">  
  20.     <property name="dataSource">  
  21.         <ref bean="datasource"></ref>  
  22.     </property>  
  23. </bean>  
  24.   
  25. <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">  
  26.     <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"></constructor-arg>  
  27.     <constructor-arg name="executorType" ref="SIMPLE"></constructor-arg>  
  28.     <constructor-arg name="exceptionTranslator" ref="myBatisExceptionTranslator"></constructor-arg>  
  29. </bean>  
  30.   
  31. <bean id="myBatisDaoSupport" class="com.tx.core.mybatis.support.MyBatisDaoSupport">  
  32.     <property name="sqlSessionTemplate">  
  33.         <ref bean="sqlSessionTemplate"/>  
  34.     </property>  
  35. </bean>  



这里对配置进行一下说明
mapperLocations： 通过正则表达式，支持mybatis动态扫描添加mapper不用像ibatis，用一个还要蛋疼滴添加一个include
typeHandlersPackage: 由于mybatis默认入参如果为空，又没有指定jdbcType时会抛出异常，在这里通过配置一些默认的类型空值插入的handle，以便处理mybatis的默认类型为空的情况
例如NullAbleStringTypeHandle通过实现当String字符串中为null是调用ps.setString(i,null)其他常用类型雷同
failFast：开启后将在启动时检查设定的parameterMap,resultMap是否存在，是否合法。个人建议设置为true,这样可以尽快定位解决问题。不然在调用过程中发现错误，会影响问题定位。

myBatisExceptionTranslator：用以支持spring的异常转换，通过配置该translatro可以将mybatis异常转换为spring中定义的DataAccessException

三、mybatis的批量处理功能，
由于在3.1.1升级后，可直接通过batchExcutor实现具体的批量执行。在该excutor中会重用上一次相同的prepareStatement。
具体实现这里贴一个：

Java代码  收藏代码
  1. /** 
  2.  * 批量插入数据 <br/> 
  3.  * 1、数据批量插入，默认一次提交100条，当发生异常后继续提交异常行以后的数据，待集合全部进行提交后返回批量处理结果<br/> 
  4.  * 2、数据批量插入，如果需要回滚，当发生异常后，数据库异常即向外抛出，不会进行至全部执行后再抛出异常 <br/> 
  5.  * <功能详细描述> 
  6.  *  
  7.  * @param statement 
  8.  * @param objectCollection 
  9.  * @param isRollback 
  10.  * @return [参数说明] 
  11.  *  
  12.  * @return BatchResult<T> [返回类型说明] 
  13.  * @exception throws [异常类型] [异常说明] 
  14.  * @see [类、类#方法、类#成员] 
  15.  */  
  16. public BatchResult batchInsert(String statement, List<?> objectList,  
  17.         boolean isStopWhenFlushHappenedException) {  
  18.     return batchInsert(statement,  
  19.             objectList,  
  20.             defaultDoFlushSize,  
  21.             isStopWhenFlushHappenedException);  
  22. }  
  23.   
  24. /** 
  25.  * 批量插入数据 
  26.  *  
  27.  * @param statement 
  28.  * @param objectList 
  29.  *            对象列表 
  30.  * @param doFlushSize 
  31.  * @param isStopWhenFlushHappenedException 
  32.  *            当在flush发生异常时是否停止，如果在调用insert时抛出的异常，不在此设置影响范围内 
  33.  * @return void [返回类型说明] 
  34.  * @exception throws [异常类型] [异常说明] 
  35.  * @see [类、类#方法、类#成员] 
  36.  */  
  37. // 批量插入  
  38. public BatchResult batchInsert(String statement, List<?> objectList,  
  39.         int doFlushSize, boolean isStopWhenFlushHappenedException) {  
  40.     BatchResult result = new BatchResult();  
  41.     if (CollectionUtils.isEmpty(objectList)) {  
  42.         return result;  
  43.     }  
  44.     if (doFlushSize <= 0) {  
  45.         doFlushSize = defaultDoFlushSize;  
  46.     }  
  47.     //设置总条数  
  48.     result.setTotalNum(objectList.size());  
  49.       
  50.     //从当前环境中根据connection生成批量提交的sqlSession  
  51.     SqlSession sqlSession = this.sqlSessionTemplate.getSqlSessionFactory()  
  52.             .openSession(ExecutorType.BATCH);  
  53.       
  54.     try {  
  55.         // 本次flush的列表开始行行索引  
  56.         int startFlushRowIndex = 0;  
  57.         for (int index = 0; index < objectList.size(); index++) {  
  58.             // 插入对象  
  59.             insertForBatch(sqlSession,  
  60.                     statement,  
  61.                     objectList.get(index),  
  62.                     null);  
  63.             if ((index > 0 && index % doFlushSize == 0)  
  64.                     || index == objectList.size() - 1) {  
  65.                 try {  
  66.                     List<org.apache.ibatis.executor.BatchResult> test = flushBatchStatements(sqlSession);  
  67.                     System.out.println(test);  
  68.                     startFlushRowIndex = index + 1;  
  69.                 }  
  70.                 catch (Exception ex) {  
  71.                     if (!(ex.getCause() instanceof BatchExecutorException)  
  72.                             || isStopWhenFlushHappenedException) {  
  73.                         DataAccessException translated = this.sqlSessionTemplate.getPersistenceExceptionTranslator()  
  74.                                 .translateExceptionIfPossible((PersistenceException) ex);  
  75.                         throw translated;  
  76.                     }  
  77.                       
  78.                     BatchExecutorException e = (BatchExecutorException) ex.getCause();  
  79.                     // 如果为忽略错误异常则记录警告日志即可，无需打印堆栈，如果需要堆栈，需将日志级别配置为debug  
  80.                     logger.warn("batchInsert hanppend Exception:{},the exception be igorned.",  
  81.                             ex.toString());  
  82.                     if (logger.isDebugEnabled()) {  
  83.                         logger.debug(ex.toString(), ex);  
  84.                     }  
  85.                       
  86.                     // 获取错误行数，由于错误行发生的地方  
  87.                     int errorRownumIndex = startFlushRowIndex  
  88.                             + e.getSuccessfulBatchResults().size();  
  89.                     result.addErrorInfoWhenException(objectList.get(index),  
  90.                             errorRownumIndex,  
  91.                             ex);  
  92.                       
  93.                     //将行索引调整为错误行的行号，即从发生错误的行后面一行继续执行  
  94.                     index = errorRownumIndex;  
  95.                     startFlushRowIndex = errorRownumIndex + 1;  
  96.                 }  
  97.             }  
  98.         }  
  99.     }  
  100.     finally {  
  101.         sqlSession.close();  
  102.     }  
  103.     return result;  
  104. }  



这里的实现写得稍微复杂一些，
主要是，针对有些情况如果其中某条失败，还想后续数据能够继续成功提交的情况进行支持。

四、数据库物理分页，这个网上的文章也比较多，这里也提一下。在前人的基础上，我的物理分页类实现为：

Java代码  收藏代码
  1. <coding-3 lang="as">  
  2. /* 
  3.  * 描          述:  <描述> 
  4.  * 修  改   人:  PengQingyang 
  5.  * 修改时间:  2012-11-5 
  6.  * <修改描述:> 
  7.  */  
  8. package com.tx.core.mybatis.interceptor;  
  9.   
  10. import java.lang.reflect.Method;  
  11. import java.sql.Connection;  
  12. import java.sql.PreparedStatement;  
  13. import java.sql.Statement;  
  14. import java.util.Properties;  
  15.   
  16. import org.apache.ibatis.executor.statement.PreparedStatementHandler;  
  17. import org.apache.ibatis.executor.statement.RoutingStatementHandler;  
  18. import org.apache.ibatis.executor.statement.SimpleStatementHandler;  
  19. import org.apache.ibatis.executor.statement.StatementHandler;  
  20. import org.apache.ibatis.mapping.BoundSql;  
  21. import org.apache.ibatis.plugin.Interceptor;  
  22. import org.apache.ibatis.plugin.Intercepts;  
  23. import org.apache.ibatis.plugin.Invocation;  
  24. import org.apache.ibatis.plugin.Plugin;  
  25. import org.apache.ibatis.plugin.Signature;  
  26. import org.apache.ibatis.reflection.MetaObject;  
  27. import org.apache.ibatis.session.RowBounds;  
  28. import org.hibernate.dialect.Dialect;  
  29. import org.slf4j.Logger;  
  30. import org.slf4j.LoggerFactory;  
  31.   
  32. /** 
  33.  * <数据库分页容器处理器> 
  34.  * <功能详细描述> 
  35.  *  
  36.  * @author  PengQingyang 
  37.  * @version  [版本号, 2012-11-5] 
  38.  * @see  [相关类/方法] 
  39.  * @since  [产品/模块版本] 
  40.  */  
  41. @Intercepts({  
  42.         @Signature(type = StatementHandler.class, method = "prepare", args = { Connection.class }),  
  43.         @Signature(type = StatementHandler.class, method = "parameterize", args = { Statement.class }) })  
  44. public class PagedDiclectStatementHandlerInterceptor implements Interceptor {  
  45.       
  46.     private Logger logger = LoggerFactory.getLogger(PagedDiclectStatementHandlerInterceptor.class);  
  47.       
  48.     private Dialect dialect;  
  49.       
  50.     /** 
  51.      * 物理分页插件拦截 
  52.      * @param invocation 
  53.      * @return 
  54.      * @throws Throwable 
  55.      */  
  56.     public Object intercept(Invocation invocation) throws Throwable {  
  57.         Method m = invocation.getMethod();  
  58.         if ("prepare".equals(m.getName())) {  
  59.             return prepare(invocation);  
  60.         } else if ("parameterize".equals(m.getName())) {  
  61.             return parameterize(invocation);  
  62.         }  
  63.         return invocation.proceed();  
  64.     }  
  65.       
  66.     /** 
  67.      * @param target 
  68.      * @return 
  69.      */  
  70.     public Object plugin(Object target) {  
  71.         return Plugin.wrap(target, this);  
  72.     }  
  73.       
  74.     /** 
  75.      * @param properties 
  76.      */  
  77.     public void setProperties(Properties properties) {  
  78.           
  79.     }  
  80.       
  81.     /** 
  82.       * 拦截prepare修改分页 
  83.       * <功能详细描述> 
  84.       * @param invocation 
  85.       * @return 
  86.       * @throws Throwable [参数说明] 
  87.       *  
  88.       * @return Object [返回类型说明] 
  89.       * @exception throws [异常类型] [异常说明] 
  90.       * @see [类、类#方法、类#成员] 
  91.      */  
  92.     private Object prepare(Invocation invocation) throws Throwable {  
  93.         if (!(invocation.getTarget() instanceof RoutingStatementHandler)) {  
  94.             return invocation.proceed();  
  95.         }  
  96.           
  97.         //提取statement  
  98.         RoutingStatementHandler statementHandler = (RoutingStatementHandler) invocation.getTarget();  
  99.           
  100.         MetaObject metaStatementHandler = MetaObject.forObject(statementHandler);  
  101.           
  102.           
  103.         StatementHandler statement = (StatementHandler) metaStatementHandler.getValue("delegate");  
  104.         //如果不为两种statement则不继续进行处理  
  105.         if (!(statement instanceof SimpleStatementHandler)  
  106.                 && !(statement instanceof PreparedStatementHandler)) {  
  107.             return invocation.proceed();  
  108.         }  
  109.           
  110.         RowBounds rowBounds = (RowBounds) metaStatementHandler.getValue("delegate.rowBounds");  
  111.         //根据rowBounds判断是否需要进行物理分页  
  112.         if (rowBounds == null  
  113.                 || rowBounds.equals(RowBounds.DEFAULT)  
  114.                 || (rowBounds.getOffset() <= RowBounds.NO_ROW_OFFSET && rowBounds.getLimit() == RowBounds.NO_ROW_LIMIT)) {  
  115.             return invocation.proceed();  
  116.         }  
  117.           
  118.         //进行处理  
  119.         BoundSql boundSql = statementHandler.getBoundSql();  
  120.         String sql = boundSql.getSql();  
  121.         String limitSql = dialect.getLimitString(sql,  
  122.                 rowBounds.getOffset(),  
  123.                 rowBounds.getLimit());  
  124.           
  125.         if (statement instanceof SimpleStatementHandler) {  
  126.             limitSql.replaceAll("rownum <= ?", "rownum <= " + rowBounds.getLimit());  
  127.             limitSql.replaceAll("rownum_ > ?", "rownum_ > " + rowBounds.getOffset());  
  128.         }  
  129.           
  130.         //如果为PreparedStatementHandler则无需替换即可  
  131.         metaStatementHandler.setValue("delegate.boundSql.sql",limitSql);  
  132.           
  133.         if (logger.isDebugEnabled()) {  
  134.             logger.debug("生成分页SQL : " + boundSql.getSql());  
  135.         }  
  136.           
  137.         return invocation.proceed();  
  138.     }  
  139.       
  140.     /** 
  141.       * 设置分页参数 
  142.       * <功能详细描述> 
  143.       * @param invocation 
  144.       * @return 
  145.       * @throws Throwable [参数说明] 
  146.       *  
  147.       * @return Object [返回类型说明] 
  148.       * @exception throws [异常类型] [异常说明] 
  149.       * @see [类、类#方法、类#成员] 
  150.      */  
  151.     private Object parameterize(Invocation invocation) throws Throwable {  
  152.         //先执行系统默认的参数设置  
  153.         Object returnObj = invocation.proceed();  
  154.           
  155.           
  156.         //提取statement  
  157.         RoutingStatementHandler routingStatementHandler = (RoutingStatementHandler) invocation.getTarget();  
  158.         MetaObject metaStatementHandler = MetaObject.forObject(routingStatementHandler);  
  159.           
  160.           
  161.         StatementHandler statementHandler = (StatementHandler) metaStatementHandler.getValue("delegate");  
  162.         //如果不为两种statement则不继续进行处理  
  163.         if (!(statementHandler instanceof PreparedStatementHandler)) {  
  164.             return returnObj;  
  165.         }  
  166.           
  167.         RowBounds rowBounds = (RowBounds) metaStatementHandler.getValue("delegate.rowBounds");  
  168.         //根据rowBounds判断是否需要进行物理分页  
  169.         if (rowBounds == null  
  170.                 || rowBounds.equals(RowBounds.DEFAULT)  
  171.                 || (rowBounds.getOffset() <= RowBounds.NO_ROW_OFFSET && rowBounds.getLimit() == RowBounds.NO_ROW_LIMIT)) {  
  172.             return returnObj;  
  173.         }  
  174.           
  175.         //提取参数设置statement  
  176.         Statement statement = (Statement) invocation.getArgs()[0];   
  177.         if (!(statement instanceof PreparedStatement)) {    
  178.             //如果对应statement不为PreparedStatement则直接返回  
  179.             return returnObj;  
  180.         }  
  181.           
  182.         //设置分页的参数  
  183.         PreparedStatement ps = (PreparedStatement) statement;  
  184.         int parameterSize = statementHandler.getBoundSql().getParameterMappings().size();  
  185.         if(rowBounds.getOffset() > RowBounds.NO_ROW_OFFSET   
  186.                 || rowBounds.getLimit() < RowBounds.NO_ROW_LIMIT){  
  187.             ps.setInt(parameterSize + 1, rowBounds.getLimit());  
  188.             parameterSize++;  
  189.             if(rowBounds.getOffset() > RowBounds.NO_ROW_OFFSET){  
  190.                 ps.setInt(parameterSize + 1, rowBounds.getOffset());  
  191.             }  
  192.         }  
  193.           
  194.         //替换rowBounds  
  195.         metaStatementHandler.setValue("delegate.rowBounds",  
  196.                 RowBounds.DEFAULT);  
  197.           
  198.         return returnObj;  
  199.     }  
  200.       
  201.     /** 
  202.      * @return 返回 dialect 
  203.      */  
  204.     public Dialect getDialect() {  
  205.         return dialect;  
  206.     }  
  207.       
  208.     /** 
  209.      * @param 对dialect进行赋值 
  210.      */  
  211.     public void setDialect(Dialect dialect) {  
  212.         this.dialect = dialect;  
  213.     }  
  214. }  
  215. </coding>  



五、jpa注解的支持，mybatis本来优势就在于其sql可控，
个人不太倾向用太多的注解，mybatis的resultMap已经在ibatis基础上改进了很多，已经非常好用了，个人倾向于，利用表生成对应的model
然后根据实际业务将model改写，如需要oneToOne manyToOne时，添加jpa注解，调整bean属性命名后，根据model直接生成，dao,service,daoImpl,sqlMap,以及单元测试类
这个我现在有一个初步实现：
已经可以用了，大家可以一起使用一下，如果有问题，可以在这里回帖，我再进行逐步优化：
具体代码请在github上下载，建议使用eclipse版本为spring的sts
sqlMap后来考虑重用statemen有关null处已经进行调整，将于明天更新于github
有兴趣的可以从github下载相关代码：
https://github.com/txteam/tx-core/tree/1.0.x

这里贴一下自动生成的代码：

Java代码  收藏代码
  1. public static void main(String[] args) throws Exception{  
  2.     JpaEntityFreeMarkerGenerator g = new JpaEntityFreeMarkerGenerator();  
  3.       
  4.     g.generate(Demo.class, "d:/mybatis");  
  5. }  


Java代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8" ?>    
  2. <!DOCTYPE mapper   
  3.     PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"   
  4.     "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
  5. <mapper namespace="demo">  
  6.   
  7.     <!-- auto generate default resultMap -->  
  8.     <resultMap id="demoMap"   
  9.         type="com.tx.core.mybatis.data.Demo">  
  10.         <result column="subDemo_id" property="subDemo.id"/>  
  11.     </resultMap>  
  12.       
  13.     <!-- auto generate default find -->  
  14.     <select id="findDemo"   
  15.         parameterType="com.tx.core.mybatis.data.Demo"  
  16.         resultMap="demoMap">  
  17.         SELECT   
  18.                 TW.ID,  
  19.                 TW.INTTEST,  
  20.                 TW.BOOLEANTEST,  
  21.                 TW.PASSOWRD,  
  22.                 TW.ENDDATE,  
  23.                 TW.ISBOOLEANOBJTEST,  
  24.                 TW.LASTUPDATEDATE,  
  25.                 TW.TESTBIGDECEIMAL,  
  26.                 TW.INTEGERTEST,  
  27.                 TW.EMAIL,  
  28.                 TW.NEWNAME AS name,  
  29.                 TW.SUBDEMO AS subDemo_id,  
  30.                 TW.TESTINTEGER,  
  31.                 TW.CREATEDATE  
  32.           FROM WD_DEMO TW  
  33.          WHERE  
  34.         <trim prefixOverrides="AND | OR">  
  35.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(id)">    
  36.                 AND TW.ID = #{id}  
  37.             </if>  
  38.         </trim>  
  39.     </select>  
  40.       
  41.     <!-- auto generate default query -->  
  42.     <select id="queryDemo"   
  43.         parameterType="com.tx.core.mybatis.data.Demo"  
  44.         resultMap="demoMap">  
  45.         SELECT   
  46.                 TW.ID,  
  47.                 TW.INTTEST,  
  48.                 TW.BOOLEANTEST,  
  49.                 TW.PASSOWRD,  
  50.                 TW.ENDDATE,  
  51.                 TW.ISBOOLEANOBJTEST,  
  52.                 TW.LASTUPDATEDATE,  
  53.                 TW.TESTBIGDECEIMAL,  
  54.                 TW.INTEGERTEST,  
  55.                 TW.EMAIL,  
  56.                 TW.NEWNAME AS name,  
  57.                 TW.SUBDEMO AS subDemo_id,  
  58.                 TW.TESTINTEGER,  
  59.                 TW.CREATEDATE  
  60.           FROM WD_DEMO TW  
  61.         <trim prefix="WHERE" prefixOverrides="AND | OR">  
  62.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(id)">    
  63.                 AND TW.ID = #{id}  
  64.             </if>  
  65.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(intTest)">    
  66.                 AND TW.INTTEST = #{intTest}  
  67.             </if>  
  68.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(booleanTest)">    
  69.                 AND TW.BOOLEANTEST = #{booleanTest}  
  70.             </if>  
  71.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(passowrd)">    
  72.                 AND TW.PASSOWRD = #{passowrd}  
  73.             </if>  
  74.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(endDate)">    
  75.                 AND TW.ENDDATE = #{endDate}  
  76.             </if>  
  77.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(isBooleanObjTest)">    
  78.                 AND TW.ISBOOLEANOBJTEST = #{isBooleanObjTest}  
  79.             </if>  
  80.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(lastUpdateDate)">    
  81.                 AND TW.LASTUPDATEDATE = #{lastUpdateDate}  
  82.             </if>  
  83.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(testBigDeceimal)">    
  84.                 AND TW.TESTBIGDECEIMAL = #{testBigDeceimal}  
  85.             </if>  
  86.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(integerTest)">    
  87.                 AND TW.INTEGERTEST = #{integerTest}  
  88.             </if>  
  89.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(email)">    
  90.                 AND TW.EMAIL = #{email}  
  91.             </if>  
  92.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(name)">    
  93.                 AND TW.NEWNAME = #{name}  
  94.             </if>  
  95.             <if test="subDemo != null">  
  96.                 <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(subDemo.id)">    
  97.                     AND TW.SUBDEMO = #{subDemo.id}  
  98.                 </if>  
  99.             </if>  
  100.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(testInteger)">    
  101.                 AND TW.TESTINTEGER = #{testInteger}  
  102.             </if>  
  103.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(createDate)">    
  104.                 AND TW.CREATEDATE = #{createDate}  
  105.             </if>  
  106.         </trim>  
  107.         <choose>    
  108.             <when test="@com.tx.core.util.OgnlUtils@isNotEmpty(orderSql)">    
  109.                 ORDER BY #{orderSql}  
  110.             </when>  
  111.             <otherwise>    
  112.                 <!-- //TODO:ADD DEFAULT ORDER COLUMN OR DONOTHING! -->  
  113.             </otherwise>    
  114.         </choose>  
  115.     </select>  
  116.       
  117.         <!-- auto generate default count -->  
  118.     <select id="queryDemoCount"   
  119.         parameterType="com.tx.core.mybatis.data.Demo"  
  120.         resultType="java.lang.Integer">  
  121.         SELECT COUNT(1)  
  122.           FROM WD_DEMO TW  
  123.         <trim prefix="WHERE" prefixOverrides="AND | OR">  
  124.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(id)">    
  125.                 AND TW.ID = #{id}  
  126.             </if>  
  127.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(intTest)">    
  128.                 AND TW.INTTEST = #{intTest}  
  129.             </if>  
  130.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(booleanTest)">    
  131.                 AND TW.BOOLEANTEST = #{booleanTest}  
  132.             </if>  
  133.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(passowrd)">    
  134.                 AND TW.PASSOWRD = #{passowrd}  
  135.             </if>  
  136.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(endDate)">    
  137.                 AND TW.ENDDATE = #{endDate}  
  138.             </if>  
  139.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(isBooleanObjTest)">    
  140.                 AND TW.ISBOOLEANOBJTEST = #{isBooleanObjTest}  
  141.             </if>  
  142.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(lastUpdateDate)">    
  143.                 AND TW.LASTUPDATEDATE = #{lastUpdateDate}  
  144.             </if>  
  145.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(testBigDeceimal)">    
  146.                 AND TW.TESTBIGDECEIMAL = #{testBigDeceimal}  
  147.             </if>  
  148.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(integerTest)">    
  149.                 AND TW.INTEGERTEST = #{integerTest}  
  150.             </if>  
  151.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(email)">    
  152.                 AND TW.EMAIL = #{email}  
  153.             </if>  
  154.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(name)">    
  155.                 AND TW.NEWNAME = #{name}  
  156.             </if>  
  157.             <if test="subDemo != null">  
  158.                 <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(subDemo.id)">    
  159.                     AND TW.SUBDEMO = #{subDemo.id}  
  160.                 </if>  
  161.             </if>  
  162.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(testInteger)">    
  163.                 AND TW.TESTINTEGER = #{testInteger}  
  164.             </if>  
  165.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(createDate)">    
  166.                 AND TW.CREATEDATE = #{createDate}  
  167.             </if>  
  168.         </trim>  
  169.     </select>  
  170.       
  171.     <!-- auto generate default insert -->  
  172.     <insert id="insertDemo"   
  173.         parameterType="com.tx.core.mybatis.data.Demo">  
  174.         INSERT INTO WD_DEMO  
  175.         (  
  176.             ID,  
  177.             INTTEST,  
  178.             BOOLEANTEST,  
  179.             PASSOWRD,  
  180.             ENDDATE,  
  181.             ISBOOLEANOBJTEST,  
  182.             LASTUPDATEDATE,  
  183.             TESTBIGDECEIMAL,  
  184.             INTEGERTEST,  
  185.             EMAIL,  
  186.             NEWNAME,  
  187.             SUBDEMO,  
  188.             TESTINTEGER,  
  189.             CREATEDATE  
  190.         )  
  191.         VALUES  
  192.         (  
  193.             #{id},  
  194.             #{intTest},  
  195.             #{booleanTest},  
  196.             #{passowrd},  
  197.             #{endDate},  
  198.             #{isBooleanObjTest},  
  199.             #{lastUpdateDate},  
  200.             #{testBigDeceimal},  
  201.             #{integerTest},  
  202.             #{email},  
  203.             #{name},  
  204.             <if test="subDemo != null">  
  205.                 #{subDemo.id},  
  206.             </if>  
  207.             <if test="subDemo == null">  
  208.                 #{subDemo,javaType=java.lang.String},  
  209.             </if>  
  210.             #{testInteger},  
  211.             #{createDate}  
  212.         )  
  213.     </insert>  
  214.       
  215.     <!-- auto generate default delete -->  
  216.     <delete id="deleteDemo"   
  217.         parameterType="com.tx.core.mybatis.data.Demo">  
  218.         DELETE FROM WD_DEMO TW WHERE  
  219.         <trim prefixOverrides="AND | OR">  
  220.             <if test="@com.tx.core.util.OgnlUtils@isNotEmpty(id)">    
  221.                 AND TW.ID = #{id}  
  222.             </if>  
  223.         </trim>  
  224.     </delete>  
  225.   
  226.     <!-- auto generate default update -->  
  227.     <update id="updateDemo"  
  228.         parameterType="java.util.Map">    
  229.         UPDATE wd_demo TW  
  230.         <trim prefix="SET" suffixOverrides=",">  
  231.             <if test="_parameter.containsKey('intTest')">  
  232.                 INTTEST = #{intTest,javaType=int},  
  233.             </if>   
  234.             <if test="_parameter.containsKey('booleanTest')">  
  235.                 BOOLEANTEST = #{booleanTest,javaType=boolean},  
  236.             </if>   
  237.             <if test="_parameter.containsKey('passowrd')">  
  238.                 PASSOWRD = #{passowrd,javaType=java.lang.String},  
  239.             </if>   
  240.             <if test="_parameter.containsKey('endDate')">  
  241.                 ENDDATE = #{endDate,javaType=java.sql.Date},  
  242.             </if>   
  243.             <if test="_parameter.containsKey('isBooleanObjTest')">  
  244.                 ISBOOLEANOBJTEST = #{isBooleanObjTest,javaType=java.lang.Boolean},  
  245.             </if>   
  246.             <if test="_parameter.containsKey('lastUpdateDate')">  
  247.                 LASTUPDATEDATE = #{lastUpdateDate,javaType=java.sql.Timestamp},  
  248.             </if>   
  249.             <if test="_parameter.containsKey('testBigDeceimal')">  
  250.                 TESTBIGDECEIMAL = #{testBigDeceimal,javaType=java.math.BigDecimal},  
  251.             </if>   
  252.             <if test="_parameter.containsKey('integerTest')">  
  253.                 INTEGERTEST = #{integerTest,javaType=java.lang.Integer},  
  254.             </if>   
  255.             <if test="_parameter.containsKey('email')">  
  256.                 EMAIL = #{email,javaType=java.lang.String},  
  257.             </if>   
  258.             <if test="_parameter.containsKey('name')">  
  259.                 NEWNAME = #{name,javaType=java.lang.String},  
  260.             </if>   
  261.             <if test="_parameter.containsKey('subDemo')">  
  262.                 <if test="subDemo != null">  
  263.                     SUBDEMO = #{subDemo.id,javaType=java.lang.String},  
  264.                 </if>  
  265.                 <if test="subDemo == null">  
  266.                     SUBDEMO = #{subDemo,javaType=java.lang.String},  
  267.                 </if>  
  268.             </if>  
  269.             <if test="_parameter.containsKey('testInteger')">  
  270.                 TESTINTEGER = #{testInteger,javaType=java.lang.Integer},  
  271.             </if>   
  272.             <if test="_parameter.containsKey('createDate')">  
  273.                 CREATEDATE = #{createDate,javaType=java.util.Date},  
  274.             </if>   
  275.         </trim>  
  276.         WHERE TW.ID = #{id}   
  277.     </update>    
  278.   
  279. </mapper>  
  280. <!--  
  281. sqlMap生成描述:  
  282.   
  283. -->  


Java代码  收藏代码
  1. /* 
  2.  * 描          述:  <描述> 
  3.  * 修  改   人:   
  4.  * 修改时间:   
  5.  * <修改描述:> 
  6.  */  
  7. package com.tx.core.mybatis.service;  
  8.   
  9. import java.util.HashMap;  
  10. import java.util.List;  
  11. import java.util.Map;  
  12.   
  13. import javax.annotation.Resource;  
  14.   
  15. import org.apache.commons.lang.StringUtils;  
  16. import org.slf4j.Logger;  
  17. import org.slf4j.LoggerFactory;  
  18. import org.springframework.stereotype.Component;  
  19. import org.springframework.transaction.annotation.Transactional;  
  20.   
  21. import com.tx.core.mybatis.dao.DemoDao;  
  22. import com.tx.core.mybatis.model.Demo;  
  23. import com.tx.core.exceptions.parameter.ParameterIsEmptyException;  
  24. import com.tx.core.paged.model.PagedList;  
  25.   
  26. /** 
  27.  * Demo的业务层 
  28.  * <功能详细描述> 
  29.  *  
  30.  * @author   
  31.  * @version  [版本号, ] 
  32.  * @see  [相关类/方法] 
  33.  * @since  [产品/模块版本] 
  34.  */  
  35. @Component("demoService")  
  36. public class DemoService {  
  37.       
  38.     @SuppressWarnings("unused")  
  39.     private Logger logger = LoggerFactory.getLogger(DemoService.class);  
  40.       
  41.     @SuppressWarnings("unused")  
  42.     //@Resource(name = "serviceLogger")  
  43.     private Logger serviceLogger;  
  44.       
  45.     @Resource(name = "demoDao")  
  46.     private DemoDao demoDao;  
  47.       
  48.     /** 
  49.       * 根据Id查询Demo实体 
  50.       * 1、当id为empty时返回null 
  51.       * <功能详细描述> 
  52.       * @param id 
  53.       * @return [参数说明] 
  54.       *  
  55.       * @return Demo [返回类型说明] 
  56.       * @exception throws 可能存在数据库访问异常DataAccessException 
  57.       * @see [类、类#方法、类#成员] 
  58.      */  
  59.     public Demo findDemoById(String id) {  
  60.         if (StringUtils.isEmpty(id)) {  
  61.             return null;  
  62.         }  
  63.           
  64.         Demo condition = new Demo();  
  65.         condition.setId(id);  
  66.         return this.demoDao.findDemo(condition);  
  67.     }  
  68.       
  69.     /** 
  70.       * 根据Demo实体列表 
  71.       * TODO:补充说明 
  72.       *  
  73.       * <功能详细描述> 
  74.       * @return [参数说明] 
  75.       *  
  76.       * @return List<Demo> [返回类型说明] 
  77.       * @exception throws [异常类型] [异常说明] 
  78.       * @see [类、类#方法、类#成员] 
  79.      */  
  80.     public List<Demo> queryDemoList(/*TODO:自己定义条件*/) {  
  81.         //TODO:判断条件合法性  
  82.           
  83.         //TODO:生成查询条件  
  84.         Map<String, Object> params = new HashMap();  
  85.           
  86.         //TODO:根据实际情况，填入排序字段等条件，根据是否需要排序，选择调用dao内方法  
  87.         List<Demo> resList = this.demoDao.queryDemoList(params);  
  88.           
  89.         return resList;  
  90.     }  
  91.       
  92.     /** 
  93.      * 分页查询Demo实体列表 
  94.      * TODO:补充说明 
  95.      *  
  96.      * <功能详细描述> 
  97.      * @return [参数说明] 
  98.      *  
  99.      * @return List<Demo> [返回类型说明] 
  100.      * @exception throws [异常类型] [异常说明] 
  101.      * @see [类、类#方法、类#成员] 
  102.     */  
  103.     public PagedList<Demo> queryDemoPagedList(/*TODO:自己定义条件*/int pageIndex,  
  104.             int pageSize) {  
  105.         //TODO:判断条件合法性  
  106.           
  107.         //TODO:生成查询条件  
  108.         Map<String, Object> params = new HashMap<String, Object>();  
  109.           
  110.         //TODO:根据实际情况，填入排序字段等条件，根据是否需要排序，选择调用dao内方法  
  111.         PagedList<Demo> resPagedList = this.demoDao.queryDemoPagedList(params, pageIndex, pageSize);  
  112.           
  113.         return resPagedList;  
  114.     }  
  115.       
  116.     /** 
  117.       * 查询demo列表总条数 
  118.       * TODO:补充说明 
  119.       * <功能详细描述> 
  120.       * @return [参数说明] 
  121.       *  
  122.       * @return int [返回类型说明] 
  123.       * @exception throws [异常类型] [异常说明] 
  124.       * @see [类、类#方法、类#成员] 
  125.      */  
  126.     public int countDemo(/*TODO:自己定义条件*/){  
  127.         //TODO:判断条件合法性  
  128.           
  129.         //TODO:生成查询条件  
  130.         Map<String, Object> params = new HashMap<String, Object>();  
  131.           
  132.         //TODO:根据实际情况，填入排序字段等条件，根据是否需要排序，选择调用dao内方法  
  133.         int res = this.demoDao.countDemo(params);  
  134.           
  135.         return res;  
  136.     }  
  137.       
  138.     /** 
  139.       * 将demo实例插入数据库中保存 
  140.       * 1、如果demo为空时抛出参数为空异常 
  141.       * 2、如果demo中部分必要参数为非法值时抛出参数不合法异常 
  142.       * <功能详细描述> 
  143.       * @param demo [参数说明] 
  144.       *  
  145.       * @return void [返回类型说明] 
  146.       * @exception throws 可能存在数据库访问异常DataAccessException 
  147.       * @see [类、类#方法、类#成员] 
  148.      */  
  149.     @Transactional  
  150.     public void insertDemo(Demo demo) {  
  151.         //TODO:验证参数是否合法，必填字段是否填写，  
  152.         //如果没有填写抛出parameterIsEmptyException,  
  153.         //如果有参数不合法ParameterIsInvalidException  
  154.         if (demo == null /*TODO:|| 其他参数验证*/) {  
  155.             throw new ParameterIsEmptyException(  
  156.                     "DemoService.insertDemo demo isNull.");  
  157.         }  
  158.           
  159.         this.demoDao.insertDemo(demo);  
  160.     }  
  161.       
  162.     /** 
  163.       * 根据id删除demo实例 
  164.       * 1、如果入参数为空，则抛出异常 
  165.       * 2、执行删除后，将返回数据库中被影响的条数 
  166.       * @param id 
  167.       * @return 返回删除的数据条数，<br/> 
  168.       * 有些业务场景，如果已经被别人删除同样也可以认为是成功的 
  169.       * 这里讲通用生成的业务层代码定义为返回影响的条数 
  170.       * @return int [返回类型说明] 
  171.       * @exception throws 可能存在数据库访问异常DataAccessException 
  172.       * @see [类、类#方法、类#成员] 
  173.      */  
  174.     @Transactional  
  175.     public int deleteById(String id) {  
  176.         if (StringUtils.isEmpty(id)) {  
  177.             throw new ParameterIsEmptyException(  
  178.                     "DemoService.deleteById id isEmpty.");  
  179.         }  
  180.           
  181.         Demo condition = new Demo();  
  182.         condition.setId(id);  
  183.         return this.demoDao.deleteDemo(condition);  
  184.     }  
  185.       
  186.     /** 
  187.       * 根据id更新对象 
  188.       * <功能详细描述> 
  189.       * @param demo 
  190.       * @return [参数说明] 
  191.       *  
  192.       * @return boolean [返回类型说明] 
  193.       * @exception throws [异常类型] [异常说明] 
  194.       * @see [类、类#方法、类#成员] 
  195.      */  
  196.     @Transactional  
  197.     public boolean updateById(Demo demo) {  
  198.         //TODO:验证参数是否合法，必填字段是否填写，  
  199.         //如果没有填写抛出parameterIsEmptyException,  
  200.         //如果有参数不合法ParameterIsInvalidException  
  201.         if (demo == null || StringUtils.isEmpty(demo.getId())) {  
  202.             throw new ParameterIsEmptyException(  
  203.                     "DemoService.updateById demo or demo.id is empty.");  
  204.         }  
  205.           
  206.         //TODO:生成需要更新字段的hashMap  
  207.         Map<String, Object> updateRowMap = new HashMap<String, Object>();  
  208.         updateRowMap.put("id", demo.getId());  
  209.           
  210.         //TODO:需要更新的字段  
  211.         updateRowMap.put("intTest", demo.getIntTest());   
  212.         updateRowMap.put("booleanTest", demo.isBooleanTest());    
  213.         updateRowMap.put("passowrd", demo.getPassowrd());     
  214.         updateRowMap.put("endDate", demo.getEndDate());   
  215.         updateRowMap.put("isBooleanObjTest", demo.getIsBooleanObjTest());     
  216.         updateRowMap.put("lastUpdateDate", demo.getLastUpdateDate());     
  217.         updateRowMap.put("testBigDeceimal", demo.getTestBigDeceimal());   
  218.         updateRowMap.put("integerTest", demo.getIntegerTest());   
  219.         updateRowMap.put("email", demo.getEmail());   
  220.         updateRowMap.put("name", demo.getName());     
  221.         //type:java.lang.String  
  222.         updateRowMap.put("subDemo", demo.getSubDemo());  
  223.         updateRowMap.put("testInteger", demo.getTestInteger());   
  224.         updateRowMap.put("createDate", demo.getCreateDate());     
  225.           
  226.         int updateRowCount = this.demoDao.updateDemo(updateRowMap);  
  227.           
  228.         //TODO:如果需要大于1时，抛出异常并回滚，需要在这里修改  
  229.         return updateRowCount >= 1;  
  230.     }  
  231. }  


Java代码  收藏代码
  1. /* 
  2.  * 描          述:  <描述> 
  3.  * 修  改   人:   
  4.  * 修改时间:   
  5.  * <修改描述:> 
  6.  */  
  7. package com.tx.core.mybatis.dao.impl;  
  8.   
  9. import java.util.List;  
  10. import java.util.Map;  
  11.   
  12. import javax.annotation.Resource;  
  13.   
  14. import org.springframework.stereotype.Component;  
  15.   
  16. import com.tx.core.mybatis.dao.DemoDao;  
  17. import com.tx.core.mybatis.data.Demo;  
  18. import com.tx.core.mybatis.model.Order;  
  19. import com.tx.core.mybatis.support.MyBatisDaoSupport;  
  20. import com.tx.core.paged.model.PagedList;  
  21.   
  22. /** 
  23.  * Demo持久层 
  24.  * <功能详细描述> 
  25.  *  
  26.  * @author   
  27.  * @version  [版本号, 2012-12-11] 
  28.  * @see  [相关类/方法] 
  29.  * @since  [产品/模块版本] 
  30.  */  
  31. @Component("demoDao")  
  32. public class DemoDaoImpl implements DemoDao {  
  33.       
  34.     @Resource(name = "myBatisDaoSupport")  
  35.     private MyBatisDaoSupport myBatisDaoSupport;  
  36.       
  37.     /** 
  38.      * @param condition 
  39.      */  
  40.     @Override  
  41.     public void insertDemo(Demo condition) {  
  42.         this.myBatisDaoSupport.insertUseUUID("demo.insertDemo", condition, "id");  
  43.     }  
  44.       
  45.     /** 
  46.      * @param condition 
  47.      * @return 
  48.      */  
  49.     @Override  
  50.     public int deleteDemo(Demo condition) {  
  51.         return this.myBatisDaoSupport.delete("demo.deleteDemo", condition);  
  52.     }  
  53.       
  54.     /** 
  55.      * @param condition 
  56.      * @return 
  57.      */  
  58.     @Override  
  59.     public Demo findDemo(Demo condition) {  
  60.         return this.myBatisDaoSupport.<Demo> find("demo.findDemo", condition);  
  61.     }  
  62.       
  63.     /** 
  64.      * @param params 
  65.      * @return 
  66.      */  
  67.     @Override  
  68.     public List<Demo> queryDemoList(Map<String, Object> params) {  
  69.         return this.myBatisDaoSupport.<Demo> queryList("demo.queryDemo",  
  70.                 params);  
  71.     }  
  72.       
  73.     /** 
  74.      * @param params 
  75.      * @param orderList 
  76.      * @return 
  77.      */  
  78.     @Override  
  79.     public List<Demo> queryDemoList(Map<String, Object> params,  
  80.             List<Order> orderList) {  
  81.         return this.myBatisDaoSupport.<Demo> queryList("demo.queryDemo",  
  82.                 params,  
  83.                 orderList);  
  84.     }  
  85.       
  86.     /** 
  87.      * @param params 
  88.      * @return 
  89.      */  
  90.     @Override  
  91.     public int countDemo(Map<String, Object> params) {  
  92.         return this.myBatisDaoSupport.<Integer> find("demo.queryDemoCount",  
  93.                 params);  
  94.     }  
  95.       
  96.     /** 
  97.      * @param params 
  98.      * @param pageIndex 
  99.      * @param pageSize 
  100.      * @return 
  101.      */  
  102.     @Override  
  103.     public PagedList<Demo> queryDemoPagedList(Map<String, Object> params,  
  104.             int pageIndex, int pageSize) {  
  105.         return this.myBatisDaoSupport.<Demo> queryPagedList("demo.queryDemo",  
  106.                 params,  
  107.                 pageIndex,  
  108.                 pageSize);  
  109.     }  
  110.       
  111.     /** 
  112.      * @param params 
  113.      * @param pageIndex 
  114.      * @param pageSize 
  115.      * @param orderList 
  116.      * @return 
  117.      */  
  118.     @Override  
  119.     public PagedList<Demo> queryDemoPagedList(Map<String, Object> params,  
  120.             int pageIndex, int pageSize, List<Order> orderList) {  
  121.         return this.myBatisDaoSupport.<Demo> queryPagedList("demo.queryDemo",  
  122.                 params,  
  123.                 pageIndex,  
  124.                 pageSize,  
  125.                 orderList);  
  126.     }  
  127.       
  128.     /** 
  129.      * @param updateRowMap 
  130.      * @return 
  131.      */  
  132.     @Override  
  133.     public int updateDemo(Map<String, Object> updateRowMap) {  
  134.         return this.myBatisDaoSupport.update("demo.updateDemo", updateRowMap);  
  135.     }  
  136. } 
分享到：
| Spring事务管理及与mybatis3整合的事务管理
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    MyBatis基本使用总结

    在使用MyBatis时，我们需要理解其核心组件和工作原理，以便更好地进行数据库操作。 一、MyBatis核心配置文件 MyBatis的核心配置文件通常命名为`mybatis-config.xml`，它是整个MyBatis系统的总配置文件，包含了数据...

    Java开发系列MyBatis使用以及实现

    Java开发系列MyBatis使用以及实现Java开发系列MyBatis使用以及实现Java开发系列MyBatis使用以及实现Java开发系列MyBatis使用以及实现Java开发系列MyBatis使用以及实现Java开发系列MyBatis使用以及实现Java开发系列...

    mybatis简单使用demo

    mybatis简单使用mybatis简单使用demomybatis简单使用demomybatis简单使用demomybatis简单使用demomybatis简单使用demomybatis简单使用demomybatis简单使用demomybatis简单使用demomybatis简单使用demomybatis简单...

    mybatis使用案例，源码

    mybatis使用案例，包含源码，配置等 mybatis使用案例，包含源码，配置等 mybatis使用案例，包含源码，配置等 mybatis使用案例，包含源码，配置等 mybatis使用案例，包含源码，配置等

    mybatis使用的jar包.zip

    在使用MyBatis时，你需要在项目中引入此jar包，并在Spring或者其他的初始化代码中配置MyBatis的SqlSessionFactory，它是MyBatis的主要入口点，用于创建SqlSession对象，进而执行SQL操作。 再来看`mysql-connector-...

    mybatis demo mybatis 实例

    MyBatis可以使用简单的XML或注解进行配置和原始映射，将接口和Java的POJOs(Plain Old Java Objects，普通的Java对象)映射成数据库中的记录。 标题“mybatis demo mybatis 实例”指的是一个MyBatis的学习示例项目，...

    hibernate与mybatis一起使用取长补短

    标题“hibernate与mybatis一起使用取长补短”暗示了在一个项目中同时采用这两种框架，旨在充分利用它们各自的优点，以提升项目的性能和灵活性。 Hibernate是一款强大的ORM框架，它提供了完整的对象模型支持，包括...

    MyBatis使用的jar包

    MyBatis使用的jar包和源码包，开发中会经常用到，从官网上下的，可以保证资源的正确性

    Mybatis使用思维图

    推荐新手小白使用的mybatis思维图，适合快速上手。使用Xmind绘制，打开请使用Xmind（免费版）。不足之处，请指出！

    mybatis使用实例

    MyBatis可以使用简单的XML或注解进行配置和原始映射，将接口和Java的POJOs(Plain Old Java Objects，普通的Java对象)映射成数据库中的记录。 在"mybatis使用实例"中，我们主要会探讨以下几个关键知识点： 1. **...

    基于注解的MyBatis使用实例

    MyBatis 是一款优秀的持久层框架，可以很方便的在java中实现对数据库的操作。 MyBatis 可以将sql语句映射为java接口函数，直接对实体进行操作。 MyBatis 的映射类（Mapper）在映射sql语句时有两种方式，一种是xml...

    mybatis学习-入门（1）-单独使用mybatis

    本部分主要关注如何单独使用MyBatis，不涉及与其他框架的集成。 1. **MyBatis简介** MyBatis消除了几乎所有的JDBC代码和手动设置参数以及获取结果集。它将SQL语句与Java代码分离，提供了一个更简洁、更易于维护的...

    关于springboot 和mybatis使用添加mybatis依赖

    关于springboot 和mybatis使用添加mybatis依赖 首先是springboot项目，依赖mybatis 。环境不多说，主要看配置。

    mybatis_generator使用手册

    MyBatis Generator 使用手册 MyBatis Generator 是 MyBatis 的代码生成工具，旨在通过反射数据库表结构生成对应的Java代码，简化开发过程，提高开发效率。本手册将指导用户如何使用 MyBatis Generator 生成代码，...

    深入理解SpringBoot中关于Mybatis使用方法

    深入理解SpringBoot中关于Mybatis使用方法 Spring Boot是一款流行的Java框架，MyBatis是一款流行的ORM框架，两者结合使用可以简化数据库操作。下面将深入理解SpringBoot中关于Mybatis使用方法。 Orm框架的本质是...

    MyBatis 枚举全面使用指南 - GitChat

    MyBatis 枚举全面使用指南 抓下来打包成了HTML文件, 方便离线观看

    MyBatis使用手册PDF

    MyBatis 可以使用简单的 XML 或注解用于配置和原始映射，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。 ### 关键知识点 1. **MyBatis 使用环境搭建** - MyBatis 可以与 ...

    mybatis 项目真实使用

    在实际项目中，MyBatis 的使用能够有效地简化数据库操作，提高开发效率。以下是 MyBatis 在项目中的核心知识点： 1. **XML 配置与注解方式**：MyBatis 提供了 XML 配置文件和注解两种方式来定义 SQL 映射。XML 配置...

    Spring+mybatis+jdbc结合使用教程

    本文档主要讲解Spring与mybatis与jdbc结合使用的方法和例子。

    mybatis的中文api文档

    MyBatis可以对配置和原生Map使用简单的XML或注解，将接口和Java的POJOs（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。MyBatis的其他语言版本包括英语、西班牙语、日语和韩语，以及简体中文。 ...

Magicbox
Global site tag (gtag.js) - Google Analytics