mybit 分页拦截器代码示例

最新推荐文章于 2022-02-26 10:34:21 发布
最新推荐文章于 2022-02-26 10:34:21 发布
阅读量285 收藏 1
点赞数
分类专栏： java mybits 分页
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/su717854075/article/details/81668715
版权
java 同时被 3 个专栏收录
14 篇文章 0 订阅
订阅专栏
mybits
2 篇文章 0 订阅
订阅专栏
分页
1 篇文章 0 订阅
订阅专栏 
--工具类

package com.bainuo.vin.plugin;
public class Page {

   private int showCount; // 每页显示记录数
   private int totalPage; // 总页数
   private int totalResult; // 总记录数
   private int currentPage; // 当前页
   private int currentResult; // 当前记录起始索引
   private boolean entityOrField; // true:需要分页的地方，传入的参数就是Page实体；false:需要分页的地方，传入的参数所代表的实体拥有Page属性
   private ParameterMap pm = new ParameterMap();

   public ParameterMap getPm() {
      return pm;
   }

   public Page() {
      this.showCount = 10;
   }

   public int getTotalPage() {
      if (totalResult % showCount == 0)
         totalPage = totalResult / showCount;
      else
         totalPage = totalResult / showCount + 1;
      return totalPage;
   }

   public void setTotalPage(int totalPage) {
      this.totalPage = totalPage;
   }

   public int getTotalResult() {
      return totalResult;
   }

   public void setTotalResult(int totalResult) {
      this.totalResult = totalResult;
   }

   public int getCurrentPage() {
      if (currentPage <= 0)
         currentPage = 1;
      return currentPage;
   }

   public void setCurrentPage(int currentPage) {
      this.currentPage = currentPage;
   }



   public int getShowCount() {
      return showCount;
   }

   public void setShowCount(int showCount) {

      this.showCount = showCount;
   }

   public int getCurrentResult() {
      currentResult = (getCurrentPage() - 1) * getShowCount();
      if (currentResult < 0)
         currentResult = 0;
      return currentResult;
   }

   public void setCurrentResult(int currentResult) {
      this.currentResult = currentResult;
   }

   public boolean isEntityOrField() {
      return entityOrField;
   }

   public void setEntityOrField(boolean entityOrField) {
      this.entityOrField = entityOrField;
   }



   @Override
   public String toString() {
      return "Page [showCount=" + showCount + ", totalPage=" + totalPage + ", totalResult=" + totalResult
            + ", currentPage=" + currentPage + ", currentResult=" + currentResult + ", entityOrField="
            + entityOrField + ", pm=" + pm + "]";
   }

}

package com.bainuo.vin.plugin;

/**
 * Created by sq on 2017/11/17.
 * 分页使用参数
 */
public interface PageConstants {
//    public static final String SHOW_COUNT_KEY = "showCount" ; // 每页显示记录数的key
//    public static final  String CURRENT_PAGE_KEY = "currentPage";//当前页
    public static final String SHOW_COUNT_KEY = "limit" ; // 每页显示记录数的key
    public static final  String CURRENT_PAGE_KEY = "page";//当前页
    public static final  String TOTAL_PAGE_KEY = "totalPage";//总页数
    public static final String TOTAL_RESULT_KEY = "count";//总记录数
    public static final  String  CURRENT_RESULT_KEY = "currentResult"; // 当前记录起始索引

    //初始化当前页
    public static final Integer INIT_CURRENT_PAGE = 1;
    //初始化每页显示的个数
    public static final Integer INIT_SHOW_COUNT=20;

    /**
     * 通过总数量和显示个数计算总页数
     * @param totalResult
     * @param showCount
     * @return
     */
    public static int getTotalPage(Integer totalResult, Integer showCount) {
        int totalPage = 0;
        if (totalResult % showCount == 0)
            totalPage = totalResult / showCount;
        else
            totalPage = totalResult / showCount + 1;
        return totalPage;
    }

    /**
     * 获取当前结果
     * @param currentPage
     * @param showCount
     * @return
     */
    public static int getCurrentResult(Integer currentPage, Integer showCount) {

        int currentResult = (currentPage - 1) * showCount;
        if (currentResult < 0)
            currentResult = 0;
        return currentResult;
    }

}

 

package com.bainuo.vin.plugin;


import com.bainuo.vin.util.Tools;
import org.apache.commons.lang.StringUtils;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.executor.ExecutorException;
import org.apache.ibatis.executor.statement.BaseStatementHandler;
import org.apache.ibatis.executor.statement.RoutingStatementHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.mapping.ParameterMode;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.property.PropertyTokenizer;
import org.apache.ibatis.scripting.xmltags.ForEachSqlNode;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.type.TypeHandler;
import org.apache.ibatis.type.TypeHandlerRegistry;

import javax.xml.bind.PropertyException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Properties;


/**
 * 
 * 类名称：PagePlugin.java 类描述：
 * 
 * @version 1.0
 * @Intercepts 是mybaits的拦截器注解
 * @Signature 表明要拦截的接口、方法以及对应的参数类型。
 */
@Intercepts({ @Signature(type = StatementHandler.class, method = "prepare", args = { Connection.class ,Integer.class}) })
public class PagePlugin implements Interceptor {

   private static String dialect = ""; // 数据库方言
   private static String pageSqlId = ""; // mapper.xml中需要拦截的ID(正则匹配)

   public Object intercept(Invocation ivk) throws Throwable {
      if (ivk.getTarget() instanceof RoutingStatementHandler) {
         RoutingStatementHandler statementHandler = (RoutingStatementHandler) ivk.getTarget();
         BaseStatementHandler delegate = (BaseStatementHandler) ReflectHelper.getValueByFieldName(statementHandler,
               "delegate");
         MappedStatement mappedStatement = (MappedStatement) ReflectHelper.getValueByFieldName(delegate,
               "mappedStatement");

         if (mappedStatement.getId().matches(pageSqlId)) { // 拦截需要分页的SQL
            BoundSql boundSql = delegate.getBoundSql();
            // 分页SQL<select>中parameterType属性对应的实体参数，即Mapper接口中执行分页方法的参数,该参数不得为空
            Object parameterObject = boundSql.getParameterObject();
            if (parameterObject == null) {
               throw new NullPointerException("parameterObject尚未实例化！");
            } else {
               Connection connection = (Connection) ivk.getArgs()[0];
               String sql = boundSql.getSql();
               // String countSql = "select count(0) from (" + sql+ ") as
               // tmp_count"; //记录统计
               String countSql = "select count(0) from (" + sql + ")  tmp_count"; // 记录统计
                                                                  // ==
                                                                  // oracle
                                                                  // 加
                                                                  // as
                                                                  // 报错(SQL
                                                                  // command
                                                                  // not
                                                                  // properly
                                                                  // ended)
               PreparedStatement countStmt = connection.prepareStatement(countSql);
               BoundSql countBS = new BoundSql(mappedStatement.getConfiguration(), countSql,
                     boundSql.getParameterMappings(), parameterObject);
               setParameters(countStmt, mappedStatement, countBS, parameterObject);
               ResultSet rs = countStmt.executeQuery();
               int count = 0;
               if (rs.next()) {
                  count = rs.getInt(1);
               }
               rs.close();
               countStmt.close();
               // System.out.println(count);
               ParameterMap parameMap = null;
               if(parameterObject instanceof ParameterMap){
                  parameMap = (ParameterMap) parameterObject;
                  doPageParm(parameMap,count);
               }
               String pageSql = generatePageSql(sql, parameMap);
               ReflectHelper.setValueByFieldName(boundSql, "sql", pageSql); // 将分页sql语句反射回BoundSql.
            }
         }
      }
      return ivk.proceed();
   }

   /**
    * 将总记录数封装到参数里面
    * @param parameterMap
    * @param count 总数
     */
   public void doPageParm(ParameterMap parameterMap ,int count){
         //如果总页数
         Object shwoCount = parameterMap.get(PageConstants.SHOW_COUNT_KEY);
         Integer show = PageConstants.INIT_SHOW_COUNT;
         if(shwoCount!=null&&StringUtils.isNumeric(String.valueOf(show))){
            show = Integer.parseInt(String.valueOf(shwoCount));
         }
         parameterMap.put(PageConstants.SHOW_COUNT_KEY,show);
         Integer currentPage = PageConstants.INIT_CURRENT_PAGE;
         Object curreantString = parameterMap.get(PageConstants.CURRENT_PAGE_KEY);
         if(curreantString!=null&&StringUtils.isNumeric(String.valueOf(curreantString))){
            currentPage = Integer.parseInt(String.valueOf(curreantString));
         }
         parameterMap.put(PageConstants.CURRENT_PAGE_KEY,currentPage);

         //总页数
         Integer totalPage = PageConstants.getTotalPage(count, show);
         parameterMap.put(PageConstants.TOTAL_PAGE_KEY,totalPage);
         //当前索引号
         Integer currentResult = PageConstants.getCurrentResult(currentPage, show);
         parameterMap.put(PageConstants.CURRENT_RESULT_KEY,currentResult);
         //总记录数
         parameterMap.put(PageConstants.TOTAL_RESULT_KEY,count);

   }


   /**
    * 对SQL参数(?)设值,参考org.apache.ibatis.executor.parameter.DefaultParameterHandler
    * 
    * @param ps
    * @param mappedStatement
    * @param boundSql
    * @param parameterObject
    * @throws SQLException
    */
   @SuppressWarnings({ "rawtypes", "unchecked" })
   private void setParameters(PreparedStatement ps, MappedStatement mappedStatement, BoundSql boundSql,
         Object parameterObject) throws SQLException {
      ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
      List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
      if (parameterMappings != null) {
         Configuration configuration = mappedStatement.getConfiguration();
         TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
         MetaObject metaObject = parameterObject == null ? null : configuration.newMetaObject(parameterObject);
         for (int i = 0; i < parameterMappings.size(); i++) {
            ParameterMapping parameterMapping = parameterMappings.get(i);
            if (parameterMapping.getMode() != ParameterMode.OUT) {
               Object value;
               String propertyName = parameterMapping.getProperty();
               PropertyTokenizer prop = new PropertyTokenizer(propertyName);
               if (parameterObject == null) {
                  value = null;
               } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
                  value = parameterObject;
               } else if (boundSql.hasAdditionalParameter(propertyName)) {
                  value = boundSql.getAdditionalParameter(propertyName);
               } else if (propertyName.startsWith(ForEachSqlNode.ITEM_PREFIX)
                     && boundSql.hasAdditionalParameter(prop.getName())) {
                  value = boundSql.getAdditionalParameter(prop.getName());
                  if (value != null) {
                     value = configuration.newMetaObject(value)
                           .getValue(propertyName.substring(prop.getName().length()));
                  }
               } else {
                  value = metaObject == null ? null : metaObject.getValue(propertyName);
               }
               TypeHandler typeHandler = parameterMapping.getTypeHandler();
               if (typeHandler == null) {
                  throw new ExecutorException("There was no TypeHandler found for parameter " + propertyName
                        + " of statement " + mappedStatement.getId());
               }
               typeHandler.setParameter(ps, i + 1, value, parameterMapping.getJdbcType());
            }
         }
      }
   }

   /**
    * 根据数据库方言，生成特定的分页sql
    * 
    * @param sql
    * @param parameMap
    * @return
    */
   private String generatePageSql(String sql, ParameterMap parameMap) {
      if (parameMap != null && Tools.notEmpty(dialect)) {
         StringBuffer pageSql = new StringBuffer();
         if ("mysql".equals(dialect)) {
            pageSql.append(sql);
            pageSql.append(" limit " +parameMap.get(PageConstants.CURRENT_RESULT_KEY) + "," + parameMap.get(PageConstants.SHOW_COUNT_KEY));
         } else if ("oracle".equals(dialect)) {
            pageSql.append("select * from (select tmp_tb.*,ROWNUM row_id from (");
            pageSql.append(sql);
            // pageSql.append(") as tmp_tb where ROWNUM<=");
            pageSql.append(") tmp_tb where ROWNUM<=");
            pageSql.append(parameMap.get(PageConstants.CURRENT_RESULT_KEY)).append("+").append( parameMap.get(PageConstants.SHOW_COUNT_KEY));
            pageSql.append(") where row_id>");
            pageSql.append(parameMap.get(PageConstants.CURRENT_RESULT_KEY));
         }
         return pageSql.toString();
      } else {
         return sql;
      }
   }

   public Object plugin(Object arg0) {
      return Plugin.wrap(arg0, this);
   }

   public void setProperties(Properties p) {
      dialect = p.getProperty("dialect");
      if (Tools.isEmpty(dialect)) {
         try {
            throw new PropertyException("dialect property is not found!");
         } catch (PropertyException e) {
            e.printStackTrace();
         }
      }
      pageSqlId = p.getProperty("pageSqlId");
      if (Tools.isEmpty(pageSqlId)) {
         try {
            throw new PropertyException("pageSqlId property is not found!");
         } catch (PropertyException e) {
            e.printStackTrace();
         }
      }
   }

}

 

 

package com.bainuo.vin.plugin;

import javax.servlet.http.HttpServletRequest;
import java.io.UnsupportedEncodingException;
import java.util.*;


/**
 * 拦截所有参数
 * 
 * @author Administrator
 *
 */
@SuppressWarnings("rawtypes")
public class ParameterMap extends HashMap implements Map {

   /**
    * 
    */
   private static final long serialVersionUID = 1L;

   Map map = null;
   HttpServletRequest request;

   public ParameterMap() {
      map = new HashMap();
   }

   public ParameterMap(Page page) {
      Map<String, Object> pageMap = new HashMap<String, Object>();
      pageMap.put("currentPage", page.getCurrentPage());
      pageMap.put("totalPage", page.getTotalPage());
      pageMap.put("totalResult", page.getTotalResult());
      pageMap.put("showCount", page.getShowCount());
      map = pageMap;
   }

   public Map getMap() {
      return map;
   }

   public void setMap(Map map) {
      this.map = map;
   }

   @SuppressWarnings("unchecked")
   public ParameterMap(HttpServletRequest request) {
      this.request = request;
      try {
         request.setCharacterEncoding("utf-8");
      } catch (UnsupportedEncodingException e) {
         e.printStackTrace();
      }
      Map Proerties = request.getParameterMap();
      Map returnMap = new HashMap();
      Iterator entries = Proerties.entrySet().iterator();
      Entry entry;
      while (entries.hasNext()) {
         String name = "";
         String value = "";

         entry = (Entry) entries.next();
         name = (String) entry.getKey();
         Object valueObject = entry.getValue();
         if (valueObject == null) {
            value = "";
         } else if (valueObject instanceof String[]) {
            String[] values = (String[]) valueObject;
            for (int i = 0; i < values.length; i++) {
               value = values[i] + "," + value;
            }
            value = value.substring(0, value.length() - 1);
         } else {
            value = valueObject.toString();
         }
         returnMap.put(name, value);
      }
//    returnMap.put("SessionID", request.getSession().getId());
      map = returnMap;
   }

   @Override
   public Object get(Object key) {
      Object obj = null;
      if (map.get(key) instanceof Object[]) {
         Object[] arr = (Object[]) map.get(key);
         obj = request == null ? arr : (request.getParameter((String) key) == null ? arr : arr[0]);
      } else {
         obj = map.get(key);
      }
      return obj;
   }

   public String getString(Object key) {
      String str = "";
      if (get(key) != null) {
         str = String.valueOf(get(key));
      }
      return str;
   }

   @SuppressWarnings("unchecked")
   @Override
   public Object put(Object key, Object value) {
      if (value == null) {
         return map.put(key, "");
      }
      return map.put(key, value);
   }

   @SuppressWarnings("unchecked")
   public Object putObject(Object key, Object value) {
      return map.put(key, value);
   }

   @Override
   public Object remove(Object key) {
      return map.remove(key);
   }

   @Override
   public void clear() {
      map.clear();
   }

   @Override
   public boolean containsKey(Object key) {
      return map.containsKey(key);
   }

   @Override
   public boolean containsValue(Object value) {
      return map.containsValue(value);
   }

   @Override
   public Set entrySet() {
      return map.entrySet();
   }

   @Override
   public boolean isEmpty() {
      return map.isEmpty();
   }

   @Override
   public Set keySet() {
      return map.keySet();
   }

   @SuppressWarnings("unchecked")
   @Override
   public void putAll(Map m) {
      map.putAll(m);
   }

   @Override
   public int size() {
      return map.size();
   }

   @Override
   public Collection values() {
      return map.values();
   }
}

 

 

package com.bainuo.vin.plugin;

import java.lang.reflect.Field;

/**
 * @author Administrator 反射工具 分页获取到
 */
public class ReflectHelper {
   /**
    * 获取obj对象fieldName的Field
    * 
    * @param obj
    * @param fieldName
    * @return
    */
   public static Field getFieldByFieldName(Object obj, String fieldName) {
      for (Class<?> superClass = obj.getClass(); superClass != Object.class; superClass = superClass
            .getSuperclass()) {
         try {
            return superClass.getDeclaredField(fieldName);
         } catch (NoSuchFieldException e) {
         }
      }
      return null;
   }

   /**
    * 获取obj对象fieldName的属性值
    * 
    * @param obj
    * @param fieldName
    * @return
    * @throws SecurityException
    * @throws NoSuchFieldException
    * @throws IllegalArgumentException
    * @throws IllegalAccessException
    */
   public static Object getValueByFieldName(Object obj, String fieldName)
         throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
      Field field = getFieldByFieldName(obj, fieldName);
      Object value = null;
      if (field != null) {
         if (field.isAccessible()) {
            value = field.get(obj);
         } else {
            field.setAccessible(true);
            value = field.get(obj);
            field.setAccessible(false);
         }
      }
      return value;
   }

   /**
    * 设置obj对象fieldName的属性值
    * 
    * @param obj
    * @param fieldName
    * @param value
    * @throws SecurityException
    * @throws NoSuchFieldException
    * @throws IllegalArgumentException
    * @throws IllegalAccessException
    */
   public static void setValueByFieldName(Object obj, String fieldName, Object value)
         throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
      Field field = obj.getClass().getDeclaredField(fieldName);
      if (field.isAccessible()) {
         field.set(obj, value);
      } else {
         field.setAccessible(true);
         field.set(obj, value);
         field.setAccessible(false);
      }
   }
}

 

 

--配置文件  mybatis.config-locations = classpath:mybatis/mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
   
   <settings> 
        <setting name="cacheEnabled" value="true" /><!-- 全局映射器启用缓存 -->   
        <setting name="useGeneratedKeys" value="true" /> 
        <setting name="defaultExecutorType" value="REUSE" />
      <setting name="callSettersOnNulls" value="true"/>
      <!--  
      打印查询语句 -->
      <setting name="logImpl" value="STDOUT_LOGGING" /> 
    </settings>

   <plugins>
      <plugin interceptor="com.bainuo.vin.plugin.PagePlugin">
         <property name="dialect" value="mysql"/>
         <property name="pageSqlId" value=".*Page.*"/>
      </plugin>
   </plugins>
</configuration>

 

 

 

 

 

苏sususu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mysql 分页拦截器_MyBatis 拦截器 （实现分页功能）
weixin_28787725的博客
02-27 224
既然是基于MyBatis 所以就先搭建一个Mybatis的小项目1.01导入 mybatis和mysql的包1.02.配置文件 Configuration.xml 中添加2.01.然后创建一个模块user 创建user表DROP TABLE IF EXISTS `user`;CREATE TABLE `user` (`id` int(11) NOT NULL AUTO_INCREMENT,`na...
Mybatis拦截器实现分页
weixin_30571465的博客
01-24 174
本文介绍使用Mybatis拦截器，实现分页；并且在dao层，直接返回自定义的分页对象。 2017-09-29修改：添加Mybatis拦截器分页对oracle、sqlServer的支持 最终dao层结果： public interface ModelMapper { Page<Model> pageByConditions(RowBounds rowBounds, Mode...
拦截器实现分页
aa1bb1cc2的专栏
04-26 368
PageHelper.javaimportjava.util.List;importjava.util.Map.Entry;importjava.util.Properties;importjava.util.Set;importorg.apache.ibatis.binding.MapperMethod.ParamMap;importorg.apache.ibatis.execut...
【笔记】分页拦截器
weixin_52226593的博客
02-26 747
@Configuration public class MybatisPlusConfig { @Bean public MybatisPlusInterceptor mybatisPlusInterceptor(){ MybatisPlusInterceptor mp = new MybatisPlusInterceptor();//创建MybatisPlus拦截器 mp.addInnerInterceptor(new PaginationInnerIn.
Mybatis（3）拦截器实现分页功能
鱼多多
11-23 540
一、Mybatis拦截器概述 MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括： Executor (update, query, flushStatements, commit, rollback,  getTransaction, close, isClosed) ParameterHandler (getP...
mybit自动生成代码
10-12
【标题】"mybit自动生成代码"涉及到的核心技术是代码生成工具，具体在这里是指MyBatis Generator（MBG）。MBG是一个能够自动生成Java源代码和XML配置文件的工具，主要用于减少开发人员在数据访问层（DAO）和映射器...
MyBatis分页
04-19
在Java代码中，可以通过传递两个参数（start和limit）来指定分页信息。 2. **基于Mapper接口方法的分页**：MyBatis提供了一种更优雅的方式来处理分页，即在Mapper接口中定义分页方法，然后在XML中编写动态SQL。...
MyBit-Token::chart_increasing_with_yen:新的MyBit令牌重新分配合同
05-13
此代码用于令牌迁移，从我们的旧ERC20可铸造令牌迁移到新的ERC20通缩供应令牌。 新令牌具有内置的刻录功能，当用户刻录令牌以访问网络时，这将减少总供应量。 无法购买新令牌，而必须通过与持有旧MyBit令牌的钱包...
springMVC+mybit+mysql的一个小例子
03-16
这是一个maven工程，整合springMVC和mybits加mysql实现的一个简单的web访问的demo。简单实现的功能是：mysql中有user表，从页面访问，然后springMVC的控制类负责控制跳转，最终执行dao类对应的mybits配置文件中...
初级java笔试题-mybit:我的工作和测试目的
06-03
初级java笔试题谷歌面试大学 翻译： 它是什么？ 这是我从 Web 开发人员（自学，没有 CS 学位）到 Google 软件工程师的为期数月的学习计划。...这份长长的清单是从Google 的指导说明中提取和扩展的，因此这些是您需要...
Mybatis-分页的两种实现方法
weixin_44822896的博客
07-30 485
分页的实现 mysql的分页语句 select * from user limit #{startIndex}，#{pageSize}； # startIndex ： 起始位置 ，默认是0开始 # pageSize ：页面大小 # 如何计算出当前页面 currentPage = (currentPage-1）* pageSize 使用limit实现分页 编写dao接口 //查询全部用户实现...
MyBits使用基础
qq_40707269的博客
04-15 5476
Mybits是优秀的持久层框架 持久层框架： 所谓"持久"就是将数据保存到可掉电式存储设备中以便今后使用，简单的说，就是将内存中的数据保存到关系型数据库、文件系统、消息队列等提供持久化支持的设备中。持久层就是系统中专注于实现数据持久化的相对独立的层面。 去MAVEN中心仓库去下载 需要的依赖 MyBatis的核心配置文件，xml配置 <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE configuration PUBLIC "-//myb
mybits框架项目搭建
luckcircle的博客
11-24 4475
之前使用SpringMVC框架做了一个项目，后来项目中需要将数据持久化，就选择了使用mybits 3.4.1+mysql 5.7这样的架构，mybits比较灵活，入门比较简单，虽然写的SQL语句比较多，但做一些小项目还是可以的，本人使用的是maven配置mybits。 先上传一张项目文件结构 第一步，在原有的项目中添加mybits和mysql驱动的依赖。 o
mybities相关知识（配置文件）
xqh_silence的博客
03-29 544
查询7天以内的数据 select * from orderform where phone=‘13739049723’ and date_sub(curdate(), INTERVAL 7 DAY) <= date(create_time); XML转义字符 <      <    小于号    > &n...
Mybatis分页实现的方法（拦截器+pageHelper）
oraly的博客
09-29 8042
一、拦截器实现 1.原理 在mybatis 运行过程中拦截执行对象，获得sql信息，将分页信息添加到sql语句中，然后放行mybatis的执行过程 2.了解一点mybatis源码 首先我们需要明白要拦截的对象是处理对象（Statement），拦截的时机应该是sql执行之前， 所以我们应该拦截的是： @Intercepts({@Signature(type=StatementHandler...
Mybatis极其(最)简(好)单(用)的一个分页插件
热门推荐
偶尔记一下 - mybatis.io
04-16 20万+
以前为Mybatis分页查询发愁过，而且在网上搜过很多相关的文章，最后一个都没采用。在分页的地方完全都是手写分页SQL和count的sql，总之很麻烦。 后来有一段时间想从Mybatis内部写一个分页的实现，我对LanguageDriver写过一个实现，自动分页是没问题了，但是查询总数（count）仍然没法一次性解决，最后不了了之。
几种常见mybatis分页实现
feinifi的博客
03-23 12万+
mybatis框架分页实现，有几种方式，最简单的就是利用原生的sql关键字limit来实现，还有一种就是利用interceptor来拼接sql，实现和limit一样的功能，再一个就是利用PageHelper来实现。这里讲解这三种常见的实现方式： 无论哪种实现方式，我们返回的结果，不能再使用List了，需要一个自定义对象Pager。 package com.xxx.mybatis.bean; ...
深入浅出Mybatis-分页
追求极致的人
07-07 17万+
Mybatis的分页功能很弱，它是基于内存的分页（查出所有记录再按偏移量和limit取结果），在大数据量的情况下这样的分页基本上是没有用的。本文基于插件，通过拦截StatementHandler重写sql语句，实现数据库的物理分页。本文适配的mybatis版本是3.2.2。
Mybatis分页助手与通用mapper
RobertChao的博客
01-11 921
文章目录Mybatis分页助手开始整合mybatis分页助手使用分页助手mybatis 的通用mappermybatis 中添加插件 Mybatis分页助手 1、前端分页（不建议使用） 一次性请求数据表格中的所有记录(ajax)，然后在前端缓存并且计算count和分页逻辑，一般前端组件(例如dataTable)会提供分页动作。 特点是：简单，很适合小规模的web平台；当数据量大的时候会产生性能问题...
用mybit框架实现从一个表中查询一个字段的功能
最新发布
06-10
最后，在Java代码中调用该方法即可查询出指定ID对应的字段值，例如： ```java SqlSession sqlSession = sqlSessionFactory.openSession(); MyMapper myMapper = sqlSession.getMapper(MyMapper.class); String ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值