mybatis常用经典分页方法

来自棱镜学院-在线IT教育www.prismcollege.com

分页方法一：

可以查看如下代码，新建一个数据库分页基础类

 package com.ssm.utils.pagination.pagebounds;

 import java.util.List;
 import org.apache.ibatis.session.SqlSession;
 import org.apache.ibatis.session.SqlSessionFactory;
 import org.mybatis.spring.SqlSessionFactoryBean;
 import org.mybatis.spring.SqlSessionUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import com.github.miemiedev.mybatis.paginator.domain.PageBounds;
 /**
  * 用于数据库分页
  * 使用方法如：public class XXXServiceImpl extends BasePageService implements IXXXService {
  * 然后代码中使用如：this.getPageList(XXXMapper.class,
                             "selectObjectListMethod", sqlmapperParams, currentPage,pageSize);
     其中currentPage由网页客户端保存，每次分页+1
  * @author Administrator
  *
  */
 public class BasePageService {
     @Autowired
     private SqlSessionFactoryBean sqlSessionFactoryBean;

     public List getPageList(Class mapperClass, String sqlId,
             Object sqlParameter, int pageIndex, int pageSize) {
         SqlSession session = null;
         try {
             SqlSessionFactory sessionFactory = sqlSessionFactoryBean
                     .getObject();
             session = sessionFactory.openSession();
             if (pageIndex <= 0) {
                 pageIndex = 1;
             }
             if (pageSize <= 0) {
                 pageSize = 10;
             }
             PageBounds pageBounds = new PageBounds(pageIndex, pageSize);
             List pageList = session.selectList(mapperClass.getName()   
                         + "." + sqlId, sqlParameter, pageBounds);   
                 return pageList;   
             } catch (Exception e) {   
                 e.printStackTrace();   
             } finally {   
                 session.close();   
             }   
             return null;   
         }   
     }   
    
   
   
    
   分页方法2： 
   定义一个page基本类，用于网页与后端之间的页面传输封装 
    
   import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.InputStreamReader;
 import com.ssm.util.PageData;

 public class Page {
     private int isM1 = 0; // 每页显示记录数
     private int isM2; // 每页显示记录数
     private int showCount = 10; // 每页显示记录数
     private int totalPage; // 总页数
     private int totalResult; // 总记录数
     private int currentPage = 1; // 当前页
     private int currentResult; // 当前记录起始索引
     private boolean entityOrField; // true:需要分页的地方，传入的参数就是Page实体；false:需要分页的地方，传入的参数所代表的实体拥有Page属性
     private String pageStr; // 最终页面显示的底部翻页导航，详细见：getPageStr();
     private PageData pd = new PageData();
     private int begin;
     private int end;
     // 总行数，需要外接传入
     private int rows;

     public int getIsM1() {
         return isM1;
     }

     public void setIsM1(int isM1) {
         this.isM1 = isM1;
     }

     public int getIsM2() {
         return isM2;
     }

     public void setIsM2(int isM2) {
         this.isM2 = isM2;
     }

     public int getRows() {
         return rows;
     }

     public void setRows(int rows) {
         this.rows = rows;
     }

     public int getBegin() {
         begin = (currentPage - 1) * showCount;
         return begin;
     }

     public void setBegin(int begin) {
         this.begin = begin;
     }

     public int getEnd() {
         end = currentPage * showCount;
         return end;
     }

     public void setEnd(int end) {
         this.end = end;
     }

     public Page() {
         // 通过page。txt设置每页显示的条数
         // String xmpath =
         // String.valueOf(Thread.currentThread().getContextClassLoader().getResource(""));
         // // System.out.println(xmpath);
         // xmpath = xmpath.substring(6)+"page.txt";
         // // System.out.println(xmpath);
         // this.showCount = Integer.parseInt(readTxtFile(xmpath));
     }

     public int getTotalPage() {
         if (rows % showCount == 0)
             totalPage = rows / showCount;
         else
             totalPage = rows / 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;
         if (currentPage > getTotalPage())
             currentPage = getTotalPage();
         return currentPage;
     }

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

     // 用于显示页码
     public String getPageStr() {
         StringBuffer sb = new StringBuffer();
         if (totalResult > 0) {
             sb.append(" \n");   
                 if (currentPage == 1) {   
                     sb.append(" 共" + totalResult   
                             + "条\n");   
                     sb.append(" \n");   
                     sb.append(" 跳转\n");   
                     sb.append(" 首页\n");   
                     sb.append(" 上页\n");   
                 } else {   
                     sb.append(" 共" + totalResult   
                             + "条\n");   
                     sb.append(" \n");   
                     sb.append(" 跳转\n");   
                     sb.append(" 首页\n");   
                     sb.append("    
                             + (currentPage - 1) + ")\">上页\n");   
                 }   
                 int showTag = 3; // 分页标签显示数量   
                 int startTag = 1;   
                 if (currentPage > showTag) {   
                     startTag = currentPage - 1;   
                 }   
                 int endTag = startTag + showTag - 1;   
                 for (int i = startTag; i <= totalPage && i <= endTag; i++) {   
                     if (currentPage == i)   
                         sb.append("" + i + "\n");   
                     else   
                         sb.append("    
                                 + i + ")\">" + i + "\n");   
                 }   
                 if (currentPage == totalPage) {   
                     sb.append(" 下页\n");   
                     sb.append(" 尾页\n");   
                 } else {   
                     sb.append("    
                             + (currentPage + 1) + ")\">下页\n");   
                     sb.append("    
                             + totalPage + ")\">尾页\n");   
                 }   
                 sb.append(" 第" + currentPage + "页\n");   
                 sb.append(" 共" + totalPage + "页\n");   
                 // sb.append("  跳转\n");   
                 sb.append("\n");
             sb.append("\n");
             sb.append("function nextPage(page){");
             sb.append(" if(true && document.forms[0]){\n");
             sb.append("     var url = document.forms[0].getAttribute(\"action\");\n");
             sb.append("     if(url.indexOf('?')>-1){url += \"&"
                     + (entityOrField ? "currentPage" : "page.currentPage")
                     + "=\";}\n");
             sb.append("     else{url += \"?"
                     + (entityOrField ? "currentPage" : "page.currentPage")
                     + "=\";}\n");
             sb.append("     document.forms[0].action = url+page;\n");
             sb.append("     document.forms[0].submit();\n");
             sb.append(" }else{\n");
             sb.append("     var url = document.location+'';\n");
             sb.append("     if(url.indexOf('?')>-1){\n");
             sb.append("         if(url.indexOf('currentPage')>-1){\n");
             sb.append("             var reg = /currentPage=\\d*/g;\n");
             sb.append("             url = url.replace(reg,'currentPage=');\n");
             sb.append("         }else{\n");
             sb.append("             url += \"&"
                     + (entityOrField ? "currentPage" : "page.currentPage")
                     + "=\";\n");
             sb.append("         }\n");
             sb.append("     }else{url += \"?"
                     + (entityOrField ? "currentPage" : "page.currentPage")
                     + "=\";}\n");
             sb.append("     document.location = url + page;\n");
             sb.append(" }\n");
             sb.append("}\n");
             sb.append("function toTZ(){");
             sb.append("var toPaggeVlue = document.getElementById(\"toGoPage\").value;");
             sb.append("if(toPaggeVlue == ''){document.getElementById(\"toGoPage\").value=1;return;}");
             sb.append("if(isNaN(Number(toPaggeVlue))){document.getElementById(\"toGoPage\").value=1;return;}");
             sb.append("nextPage(toPaggeVlue);");
             sb.append("}\n");
             sb.append("\n");
         }
         pageStr = sb.toString();
         return pageStr;
     }

     public void setPageStr(String pageStr) {
         this.pageStr = pageStr;
     }

     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;
     }

     public PageData getPd() {
         return pd;
     }

     public void setPd(PageData pd) {
         this.pd = pd;
     }

     // 读取文件
     public String readTxtFile(String filePath) {
         try {
             String encoding = "utf-8";
             File file = new File(filePath);
             if (file.isFile() && file.exists()) { // 判断文件是否存在
                 InputStreamReader read = new InputStreamReader(
                         new FileInputStream(file), encoding);// 考虑到编码格式
                 BufferedReader bufferedReader = new BufferedReader(read);
                 String lineTxt = null;
                 while ((lineTxt = bufferedReader.readLine()) != null) {
                     return lineTxt;
                 }
                 read.close();
             } else {
                 System.out.println("找不到指定的文件");
             }
         } catch (Exception e) {
             System.out.println("读取文件内容出错");
             e.printStackTrace();
         }
         return "";
     }
 } 
    
     
  下面这个类PageData为扩展使用，目前暂未使用 
    
   package com.ssm.util;

 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;

 import javax.servlet.http.HttpServletRequest;

 public class PageData extends HashMap implements Map{
     private static final long serialVersionUID = 1L;
     Map map = null;
     HttpServletRequest request;

     //获取请求参数和请求参数值的map
     public PageData(HttpServletRequest request){
         this.request = request;
         Map properties = request.getParameterMap();
         Map returnMap = new HashMap();
         Iterator entries = properties.entrySet().iterator();
         Map.Entry entry;
         String name = "";
         String value = "";
         while (entries.hasNext()) {
             entry = (Map.Entry) entries.next();
             name = (String) entry.getKey();
             Object valueObj = entry.getValue();
             if(null == valueObj){
                 value = "";
             }else if(valueObj instanceof String[]){
                 String[] values = (String[])valueObj;
                 for(int i=0;i
                      value = values[i] + ",";
                 }
                 value = value.substring(0, value.length()-1);
             }else{
                 value = valueObj.toString();
             }
             returnMap.put(name, value);
         }
         map = returnMap;
     }

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

     @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) {
         return (String)get(key);
     }

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

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

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

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

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

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

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

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

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

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

     public Collection values() {
         return map.values();
     }
 } 
   
  接下来可根据page定义一个更加具体的页面和后端传输的页面封装类，如 
    
    
   import java.io.Serializable;
 import java.util.List;

 public class XXXPage extends Page implements Serializable{
     private String identity_type;
     private String username;
     private String name;
     private String city;
     private List freeTimeList;
     private String[] jobType;
     private List createdTimeList;
     ********************************
     public String getIdentity_type() {
         return identity_type;
     }
     public void setIdentity_type(String identity_type) {
         this.identity_type = identity_type;
     }
 } 
   
  下一步可在controller的action中使用 如 
    
   public String listPageData(Model model, XXXPage page,HttpServletRequest request) { 
   xxxxxxxxx; 
   } 并在传回客户端时可 model.addAttribute("page", page); 
     
   其中 mybatis中操作 
   List list = userMapper.findXXXByPage(page);//得到满足条件的招聘用户列表 int rows = xxxMapper.findRows(page);//得到满足条件的行数  
   page.setRows(rows);  
   只需要在mapper中sql中 进行sql分页  limit  #{begin,jdbcType=INTEGER},#{showCount,jdbcType=INTEGER} 即可。 
   分页方法3： 
   修改mybatis自带的rowbound内存分页为物理分页 
   新建类Page_duan  
    
   import java.util.List;
 import java.util.Map;
 import org.codehaus.jackson.map.ObjectMapper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import com.google.common.base.Joiner;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;

 public class Page_duan {
     private static final long serialVersionUID = -399284318168302833L;
     private static final Logger logger = LoggerFactory
             .getLogger(Page_duan.class);
     private static ObjectMapper mapper = new ObjectMapper();
     public static String DEFAULT_PAGESIZE = "10";
     private int pageNo; // 当前页码
     private int pageSize; // 每页行数
     private int totalRecord; // 总记录数
     private int totalPage; // 总页数
     private Map params; // 查询条件
     private Map> paramLists; // 数组查询条件
     private String searchUrl; // Url地址
     private String pageNoDisp; // 可以显示的页号(分隔符"|"，总页数变更时更新)

     private Page_duan() {
         pageNo = 1;
         pageSize = Integer.valueOf(DEFAULT_PAGESIZE);
         totalRecord = 0;
         totalPage = 0;
         params = Maps.newHashMap();
         paramLists = Maps.newHashMap();
         searchUrl = "";
         pageNoDisp = "";
     }

     public int getPageNo() {
         return pageNo;
     }

     public void setPageNo(int pageNo) {
         this.pageNo = pageNo;
     }

     public int getPageSize() {
         return pageSize;
     }

     public void setPageSize(int pageSize) {
         this.pageSize = pageSize;
     }

     public int getTotalRecord() {
         return totalRecord;
     }

     public void setTotalRecord(int totalRecord) {
         this.totalRecord = totalRecord;
         refreshPage();
     }

     public int getTotalPage() {
         return totalPage;
     }

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

     public Map getParams() {
         return params;
     }

     public void setParams(Map params) {
         this.params = params;
     }

     public Map> getParamLists() {
         return paramLists;
     }

     public void setParamLists(Map> paramLists) {
         this.paramLists = paramLists;
     }

     public String getSearchUrl() {
         return searchUrl;
     }

     public void setSearchUrl(String searchUrl) {
         this.searchUrl = searchUrl;
     }

     public String getPageNoDisp() {
         return pageNoDisp;
     }

     public void setPageNoDisp(String pageNoDisp) {
         this.pageNoDisp = pageNoDisp;
     }

     public static Page_duan newBuilder(int pageNo, int pageSize, String url) {
         Page_duan page = new Page_duan();
         page.setPageNo(pageNo);
         page.setPageSize(pageSize);
         page.setSearchUrl(url);
         return page;
     }

     /**
      * 查询条件转JSON
      */
     public String getParaJson() {
         Map map = Maps.newHashMap();
         for (String key : params.keySet()) {
             if (params.get(key) != null) {
                 map.put(key, params.get(key));
             }
         }
         String json = "";
         try {
             json = mapper.writeValueAsString(map);
         } catch (Exception e) {
             logger.error("转换JSON失败", params, e);
         }
         return json;
     }

     /**
      * 数组查询条件转JSON
      */
     public String getParaListJson() {
         Map map = Maps.newHashMap();
         for (String key : paramLists.keySet()) {
             List lists = paramLists.get(key);
             if (lists != null && lists.size() > 0) {
                 map.put(key, lists);
             }
         }
         String json = "";
         try {
             json = mapper.writeValueAsString(map);
         } catch (Exception e) {
             logger.error("转换JSON失败", params, e);
         }
         return json;
     }

     /**
      * 总件数变化时，更新总页数并计算显示样式
      */
     private void refreshPage() {
         // 总页数计算
         totalPage = totalRecord % pageSize == 0 ? totalRecord / pageSize
                 : (totalRecord / pageSize + 1);
         // 防止超出最末页（浏览途中数据被删除的情况）
         if (pageNo > totalPage && totalPage != 0) {
             pageNo = totalPage;
         }
         pageNoDisp = computeDisplayStyleAndPage();
     }

     /**
      * 计算页号显示样式 这里实现以下的分页样式("[]"代表当前页号)，可根据项目需求调整 [1],2,3,4,5,6,7,8..12,13
      * 1,2..5,6,[7],8,9..12,13 1,2..6,7,8,9,10,11,12,[13]
      */
     private String computeDisplayStyleAndPage() {
         List pageDisplays = Lists.newArrayList();
         if (totalPage <= 11) {
             for (int i = 1; i <= totalPage; i++) {
                 pageDisplays.add(i);
             }
         } else if (pageNo < 7) {
             for (int i = 1; i <= 8; i++) {
                 pageDisplays.add(i);
             }
             pageDisplays.add(0);// 0 表示 省略部分(下同)
             pageDisplays.add(totalPage - 1);
             pageDisplays.add(totalPage);
         } else if (pageNo > totalPage - 6) {
             pageDisplays.add(1);
             pageDisplays.add(2);
             pageDisplays.add(0);
             for (int i = totalPage - 7; i <= totalPage; i++) {
                 pageDisplays.add(i);
             }
         } else {
             pageDisplays.add(1);
             pageDisplays.add(2);
             pageDisplays.add(0);
             for (int i = pageNo - 2; i <= pageNo + 2; i++) {
                 pageDisplays.add(i);
             }
             pageDisplays.add(0);
             pageDisplays.add(totalPage - 1);
             pageDisplays.add(totalPage);
         }
         return Joiner.on("|").join(pageDisplays.toArray());
     }

 } 
    
   新建如下类 
    
   import java.util.Properties;
 import org.apache.ibatis.plugin.Interceptor;
 import org.apache.ibatis.plugin.Invocation;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.util.Properties;
 import org.apache.commons.jxpath.JXPathContext;
 import org.apache.commons.jxpath.JXPathNotFoundException;
 import org.apache.ibatis.executor.Executor;
 import org.apache.ibatis.executor.parameter.DefaultParameterHandler;
 import org.apache.ibatis.mapping.BoundSql;
 import org.apache.ibatis.mapping.MappedStatement;
 import org.apache.ibatis.mapping.MappedStatement.Builder;
 import org.apache.ibatis.mapping.ParameterMapping;
 import org.apache.ibatis.mapping.SqlSource;
 import org.apache.ibatis.plugin.Interceptor;
 import org.apache.ibatis.plugin.Intercepts;
 import org.apache.ibatis.plugin.Invocation;
 import org.apache.ibatis.plugin.Plugin;
 import org.apache.ibatis.plugin.Signature;
 import org.apache.ibatis.session.ResultHandler;
 import org.apache.ibatis.session.RowBounds;

 @Intercepts({@Signature(type=Executor.class,method="query",
 args={ MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class })})
 public class PageHelper_duan implements Interceptor {

     @Override
     public Object intercept(Invocation invocation) throws Throwable {

         //当前环境 MappedStatement，BoundSql，及sql取得
         MappedStatement mappedStatement=(MappedStatement)invocation.getArgs()[0];
         Object parameter = invocation.getArgs()[1];
         BoundSql boundSql = mappedStatement.getBoundSql(parameter);
         String originalSql = boundSql.getSql().trim();
         Object parameterObject = boundSql.getParameterObject();

         //Page对象获取，“信使”到达拦截器！
         Page_duan page = searchPageWithXpath(boundSql.getParameterObject(),".","page","*/page");

         if(page!=null ){
           //Page对象存在的场合，开始分页处理
           String countSql = getCountSql(originalSql);
           Connection connection=mappedStatement.getConfiguration()
                             .getEnvironment().getDataSource().getConnection()  ;
           PreparedStatement countStmt = connection.prepareStatement(countSql);
           BoundSql countBS = copyFromBoundSql(mappedStatement, boundSql, countSql);
           DefaultParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, parameterObject, countBS);
           parameterHandler.setParameters(countStmt);
           ResultSet rs = countStmt.executeQuery();
           int totpage=0;
           if (rs.next()) {
             totpage = rs.getInt(1);
           }
           rs.close();
           countStmt.close();
           connection.close();

           //分页计算
           page.setTotalRecord(totpage);
           //对原始Sql追加limit
           int offset = (page.getPageNo() - 1) * page.getPageSize();
           StringBuffer sb = new StringBuffer();
           sb.append(originalSql).append(" limit ").append(offset).append(",").append(page.getPageSize());
           BoundSql newBoundSql = copyFromBoundSql(mappedStatement, boundSql, sb.toString());
           MappedStatement newMs = copyFromMappedStatement(mappedStatement,new BoundSqlSqlSource(newBoundSql));
           invocation.getArgs()[0]= newMs;
         }
         return invocation.proceed();

       }



     /**
        * 根据给定的xpath查询Page对象
        */
       private Page_duan searchPageWithXpath(Object o,String... xpaths) {
         JXPathContext context = JXPathContext.newContext(o);
         Object result;
         for(String xpath : xpaths){
           try {
             result = context.selectSingleNode(xpath);
           } catch (JXPathNotFoundException e) {
             continue;
           }
           if ( result instanceof Page_duan ){
             return (Page_duan)result;
           }
         }
         return null;
       }

       /**
        * 复制MappedStatement对象
        */
       private MappedStatement copyFromMappedStatement(MappedStatement ms,SqlSource newSqlSource) {
         Builder builder = new Builder(ms.getConfiguration(),ms.getId(),newSqlSource,ms.getSqlCommandType());

         builder.resource(ms.getResource());
         builder.fetchSize(ms.getFetchSize());
         builder.statementType(ms.getStatementType());
         builder.keyGenerator(ms.getKeyGenerator());
         for(String pro : ms.getKeyProperties())
             builder.keyProperty(pro);
         builder.timeout(ms.getTimeout());
         builder.parameterMap(ms.getParameterMap());
         builder.resultMaps(ms.getResultMaps());
         builder.resultSetType(ms.getResultSetType());
         builder.cache(ms.getCache());
         builder.flushCacheRequired(ms.isFlushCacheRequired());
         builder.useCache(ms.isUseCache());
         return builder.build();
       }

       /**
        * 复制BoundSql对象
        */
       private BoundSql copyFromBoundSql(MappedStatement ms, BoundSql boundSql, String sql) {
         BoundSql newBoundSql = new BoundSql(ms.getConfiguration(),sql, boundSql.getParameterMappings(), boundSql.getParameterObject());
         for (ParameterMapping mapping : boundSql.getParameterMappings()) {
             String prop = mapping.getProperty();
             if (boundSql.hasAdditionalParameter(prop)) {
                 newBoundSql.setAdditionalParameter(prop, boundSql.getAdditionalParameter(prop));
             }
         }
         return newBoundSql;
       }

       /**
        * 根据原Sql语句获取对应的查询总记录数的Sql语句
        */
       private String getCountSql(String sql) {
         return "SELECT COUNT(*) FROM (" + sql + ") aliasForPage";
       }

       public class BoundSqlSqlSource implements SqlSource {
           BoundSql boundSql;
           public BoundSqlSqlSource(BoundSql boundSql) {
             this.boundSql = boundSql;
           }
           public BoundSql getBoundSql(Object parameterObject) {
             return boundSql;
           }
         }
       @Override
       public Object plugin(Object arg0) {
          return Plugin.wrap(arg0, this);
       }



     @Override
     public void setProperties(Properties arg0) {
         // TODO Auto-generated method stub

     }

 } 
  java，架构技术学习 欢迎加QQ群交流： 
  368614849 
  14 
  

                            
                        
                    
                    
                    
                    
                    
                    
                
                
                    
                        
                        
                             
                        
                        
                        
                            
                        
                        
                        
                            
                        
                    
                
            
        
    
    
        你可能感兴趣的:(技术分析总结)
        
            
                
                    【国护攻防场景下的沙箱技术对比】
                        网安第一深禽
基础学习网络安全安全web安全
                        目录前言沙箱技术分析总结前言真高兴呀，又是受到红队大佬青睐的一天，今天下午很荣幸的收到了来自红队大佬的恶意投喂，把我们各位在座100年工作经验的蓝队师傅们吓得赶忙拔掉自己的电脑电源，断掉自己的网线，一顿操作真的猛地一批，把自己笔记本成功kill掉了。这活儿干的有理有据，实在是100年工作经验所不及的，这样吧，再加上150年，凑个250吧。还有红队师傅真的挺幽默的，红队师傅在今天星期四忍饥挨饿使劲公
                    
                    2020-06-09 《交易心理分析》读书感想之一—矛盾/诱惑/风险
                        树毛竹

                        01为什么会有心理分析？先是有基本分析，但是，对于大多数交易者而言，基本分析偏向于长期性，也显得过于宽泛，而且操作性不好把握。因为基本分析的“应该如何”和“现状如何”之间，产生了“现实落差”，人们就转向了技术分析。通过对集体行为模式的观察和量化，技术分析总结出可以辨识的形态，进而预测下一步的可能变化，预测未来的价格波动。运用技术分析解读市场，发现了市场中的无数赚钱机会。但是，我们真正把握住了多少呢
                    
                    内核新视界文章汇总
                        内核新视界
文章汇总linuxgitc语言rust
                        linux系统调试Ftracedebugfs接口使用说明（内核文档ftrace.rst）linuxarm64架构ARM64启动过程分析Linux下ARM64内核空间分布及页表查询linux内核技术分析总结RCU使用及机制源码的一些分析性能优化及测试几个影响cpucache性能因素及cache测试工具介绍内核深度解析文章总结目录：Linux内核深度解析文章总结uboot启动ARMv8架构u-boot
                    
                    如何在前端通过JavaScript创建修改CAD图形
                        vjmap

                        背景在之前的博文CAD图DWG解析WebGIS可视化技术分析总结、CAD_DWG图Web可视化一站式解决方案-唯杰地图-vjmap中讲解了如何把CAD的DWG格式的图纸Web可视化的方案，那在Web前端能不能通过JavaScript创建或基于现在的CAD图形进行修改呢？现状创建修改CAD图形，一般是基于AutoCAD进行二次开发，ObjectARX是AutoDesk公司针对AutoCAD平台上的二
                    
                    复盘总结
                        祖国天之骄子

                        1.分析什么样的人会看这篇文章呢？在什么样的时间段看？根据社交账号，抓取在社交网络中公开信息作为初始的兴趣特征数据。根据对每篇文章的阅读行为，比如：停留时间，阅读环境，以及文章特征组织出完善的特征资料库。通过大数据挖掘技术分析总结近似人群的兴趣特征。不同的时间段去头条中看顶端推送的文章。比如：早上中午晚上。2.今日头条：连接用户与资讯（用户特征环境特征文章特征）通过精准化的内容资讯激发用户粘性。3
                    
                    诸葛亮舌战群儒的技术分析总结
                        当白
常识普及
                        原文出自同人于野，是得到上我比较喜欢的一位作家万维钢这是他早期的一篇文章，这里作下总结：过程：-张昭一上来用的就是第一个技术，而且是先把诸葛亮抬上去（自比管乐、如鱼得水）再揭短：怎么刘备得了你反而地盘还变小了呢？-这个是事实俱在，诸葛亮只能拔高境界：道德上不忍夺同宗之基业，战略上别有良图。-但张昭不买账，继续揭短，仍然先捧后摔，列举诸葛亮种种败绩。-于是诸葛亮用非常长的篇幅列举种种有利于自己的事实
                    
                    j2me 联网技术分析总结
                        lukew
SocketCC++C#SUN
                        阅读更多基本点:GenericConnectionsIntheCLDCGenericConnectionframework,allconnectionsarecreatedusingtheopenstaticmethodfromtheConnectorclass.Ifsuccessful,thismethodreturnsanobjectthatimplementsoneofthegenericc
                    
                    j2me 联网技术分析总结
                        Look into it ~

                        j2me联网技术分析总结基本点:GenericConnectionsIntheCLDCGenericConnectionframework,allconnectionsarecreatedusingtheopenstaticmethodfromtheConnectorclass.Ifsuccessful,thismethodreturnsanobjectthatimplementsoneofthe
                    
                                面向对象面向过程
                                    3213213333332132
java
                                    面向对象：把要完成的一件事，通过对象间的协作实现。 
面向过程：把要完成的一件事，通过循序依次调用各个模块实现。 
我把大象装进冰箱这件事为例，用面向对象和面向过程实现，都是用java代码完成。 
 
1、面向对象 
 

package bigDemo.ObjectOriented;

/**
 * 大象类
 * 
 * @Description
 * @author FuJian
                                
                                Java Hotspot: Remove the Permanent Generation
                                    bookjovi
HotSpot
                                      
openjdk上关于hotspot将移除永久带的描述非常详细，http://openjdk.java.net/jeps/122 
  
JEP 122: Remove the Permanent Generation

Author	Jon Masamitsu
Organization	Oracle
Created	2010/8/15
Updated	2011/
                                
                                正则表达式向前查找向后查找,环绕或零宽断言
                                    dcj3sjt126com
正则表达式
                                    向前查找和向后查找 
1. 向前查找：根据要匹配的字符序列后面存在一个特定的字符序列(肯定式向前查找)或不存在一个特定的序列(否定式向前查找)来决定是否匹配。.NET将向前查找称之为零宽度向前查找断言。 
    对于向前查找，出现在指定项之后的字符序列不会被正则表达式引擎返回。 
2. 向后查找：一个要匹配的字符序列前面有或者没有指定的
                                
                                BaseDao
                                    171815164
seda
                                    

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class BaseDao {

	public Conn
                                
                                Ant标签详解--Java命令
                                    g21121
Java命令
                                            这一篇主要介绍与java相关标签的使用          终于开始重头戏了，Java部分是我们关注的重点也是项目中用处最多的部分。               
1
                                
                                [简单]代码片段_电梯数字排列
                                    53873039oycg
代码
                                           今天看电梯数字排列是9 18 26这样呈倒N排列的,写了个类似的打印例子，如下:       
import java.util.Arrays;

public class 电梯数字排列_S3_Test {
	public static void main(S
                                
                                Hessian原理
                                    云端月影
hessian原理
                                    Hessian 原理分析 
 
 
 
 
 
一．      远程通讯协议的基本原理 
 
网络通信需要做的就是将流从一台计算机传输到另外一台计算机，基于传输协议和网络 IO 来实现，其中传输协议比较出名的有 http 、 tcp 、 udp 等等， http 、 tcp 、 udp 都是在基于 Socket 概念上为某类应用场景而扩展出的传输协
                                
                                区分Activity的四种加载模式----以及Intent的setFlags
                                    aijuans
android
                                      
在多Activity开发中，有可能是自己应用之间的Activity跳转，或者夹带其他应用的可复用Activity。可能会希望跳转到原来某个Activity实例，而不是产生大量重复的Activity。 
这需要为Activity配置特定的加载模式，而不是使用默认的加载模式。 加载模式分类及在哪里配置 
Activity有四种加载模式： 
 
 standard 
 singleTop
                                
                                hibernate几个核心API及其查询分析
                                    antonyup_2006
html.netHibernatexml配置管理
                                    (一)  org.hibernate.cfg.Configuration类 
        读取配置文件并创建唯一的SessionFactory对象.(一般,程序初始化hibernate时创建.) 
        Configuration co
                                
                                PL/SQL的流程控制
                                    百合不是茶
oraclePL/SQL编程循环控制
                                    PL/SQL也是一门高级语言,所以流程控制是必须要有的,oracle数据库的pl/sql比sqlserver数据库要难,很多pl/sql中有的sqlserver里面没有 
  
流程控制; 
   分支语句 if 条件 then 结果 else 结果  end if ;

  条件语句 case    when   条件  then  结果;

   循环语句  loop    
                                
                                强大的Mockito测试框架
                                    bijian1013
mockito单元测试
                                    一.自动生成Mock类        在需要Mock的属性上标记@Mock注解，然后@RunWith中配置Mockito的TestRunner或者在setUp()方法中显示调用MockitoAnnotations.initMocks(this);生成Mock类即可。二.自动注入Mock类到被测试类  &nbs
                                
                                精通Oracle10编程SQL(11)开发子程序
                                    bijian1013
oracle数据库plsql
                                    /*
 *开发子程序
 */
--子程序目是指被命名的PL/SQL块，这种块可以带有参数，可以在不同应用程序中多次调用
--PL/SQL有两种类型的子程序：过程和函数
--开发过程
--建立过程：不带任何参数
CREATE OR REPLACE PROCEDURE out_time
IS
BEGIN
 DBMS_OUTPUT.put_line(systimestamp);
E
                                
                                【EhCache一】EhCache版Hello World
                                    bit1129
Hello world
                                    本篇是EhCache系列的第一篇，总体介绍使用EhCache缓存进行CRUD的API的基本使用，更细节的内容包括EhCache源代码和设计、实现原理在接下来的文章中进行介绍 
  环境准备 
1.新建Maven项目 
  
2.添加EhCache的Maven依赖 
        <dependency>
            <groupId>ne
                                
                                学习EJB3基础知识笔记
                                    白糖_
beanHibernatejbosswebserviceejb
                                    最近项目进入系统测试阶段，全赖袁大虾领导有力，保持一周零bug记录，这也让自己腾出不少时间补充知识。花了两天时间把“传智播客EJB3.0”看完了，EJB基本的知识也有些了解，在这记录下EJB的部分知识，以供自己以后复习使用。 
  
EJB是sun的服务器端组件模型，最大的用处是部署分布式应用程序。EJB (Enterprise JavaBean)是J2EE的一部分，定义了一个用于开发基
                                
                                angular.bootstrap
                                    boyitech
AngularJSAngularJS APIangular中文api
                                    angular.bootstrap 
描述：  
    手动初始化angular。 
    这个函数会自动检测创建的module有没有被加载多次，如果有则会在浏览器的控制台打出警告日志，并且不会再次加载。这样可以避免在程序运行过程中许多奇怪的问题发生。 
    使用方法：       angular .
                                
                                java-谷歌面试题-给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数
                                    bylijinnan
java
                                    

public class SearchInShiftedArray {

	/**
	 * 题目：给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数。
	 * 请在这个特殊数组中找出给定的整数。
	 * 解答：
	 * 其实就是“旋转数组”。旋转数组的最小元素见http://bylijinnan.iteye.com/bl
                                
                                天使还是魔鬼？都是我们制造
                                    ducklsl
生活教育情感
                                    ----------------------------剧透请原谅，有兴趣的朋友可以自己看看电影，互相讨论哦！！！ 
    从厦门回来的动车上，无意中瞟到了书中推荐的几部关于儿童的电影。当然，这几部电影可能会另大家失望，并不是类似小鬼当家的电影，而是关于“坏小孩”的电影！ 
    自己挑了两部先看了看，但是发现看完之后，心里久久不能平
                                
                                [机器智能与生物]研究生物智能的问题
                                    comsci
生物
                                     
 
      我想,人的神经网络和苍蝇的神经网络,并没有本质的区别...就是大规模拓扑系统和中小规模拓扑分析的区别.... 
 
 
      但是,如果去研究活体人类的神经网络和脑系统,可能会受到一些法律和道德方面的限制,而且研究结果也不一定可靠,那么希望从事生物神经网络研究的朋友,不如把
                                
                                获取Android Device的信息
                                    dai_lm
android
                                    
String phoneInfo = "PRODUCT: " + android.os.Build.PRODUCT;
phoneInfo += ", CPU_ABI: " + android.os.Build.CPU_ABI;
phoneInfo += ", TAGS: " + android.os.Build.TAGS;
ph
                                
                                最佳字符串匹配算法（Damerau-Levenshtein距离算法）的Java实现
                                    datamachine
java算法字符串匹配
                                    原文：http://www.javacodegeeks.com/2013/11/java-implementation-of-optimal-string-alignment.html------------------------------------------------------------------------------------------------------------
                                
                                小学5年级英语单词背诵第一课
                                    dcj3sjt126com
englishword
                                    long 长的 
show 给...看，出示 
mouth 口，嘴 
write 写 
  
use 用，使用 
take 拿，带来 
hand 手 
clever 聪明的 
  
often 经常 
wash 洗 
slow 慢的 
house 房子 
  
water 水 
clean 清洁的 
supper 晚餐 
out 在外 
  
face 脸，
                                
                                macvim的使用实战
                                    dcj3sjt126com
macvim
                                    macvim用的是mac里面的vim, 只不过是一个GUI的APP, 相当于一个壳 
  
1. 下载macvim 
https://code.google.com/p/macvim/ 
  
2. 了解macvim 
:h               vim的使用帮助信息 
:h macvim  
                                
                                java二分法查找
                                    蕃薯耀
java二分法查找二分法java二分法
                                    java二分法查找 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年6月23日 11:40:03 星期二 
http:/
                                
                                Spring Cache注解+Memcached
                                    hanqunfeng
springmemcached
                                    Spring3.1 Cache注解  
依赖jar包： 
<!-- simple-spring-memcached -->
		<dependency>
			<groupId>com.google.code.simple-spring-memcached</groupId>
			<artifactId>simple-s
                                
                                apache commons io包快速入门
                                    jackyrong
apache commons
                                    原文参考 
http://www.javacodegeeks.com/2014/10/apache-commons-io-tutorial.html 
 
  Apache Commons IO 包绝对是好东西，地址在http://commons.apache.org/proper/commons-io/，下面用例子分别介绍： 
  1）  工具类 
  2
                                
                                如何学习编程
                                    lampcy
java编程C++c
                                    首先,我想说一下学习思想.学编程其实跟网络游戏有着类似的效果.开始的时候,你会对那些代码,函数等产生很大的兴趣,尤其是刚接触编程的人,刚学习第一种语言的人.可是,当你一步步深入的时候,你会发现你没有了以前那种斗志.就好象你在玩韩国泡菜网游似的,玩到一定程度,每天就是练级练级,完全是一个想冲到高级别的意志力在支持着你.而学编程就更难了,学了两个月后,总是觉得你好象全都学会了,却又什么都做不了,又没有
                                
                                架构师之spring-----spring3.0新特性的bean加载控制@DependsOn和@Lazy
                                    nannan408
Spring3
                                    1.前言。 
   如题。 
2.描述。 
   


@DependsOn用于强制初始化其他Bean。可以修饰Bean类或方法，使用该Annotation时可以指定一个字符串数组作为参数，每个数组元素对应于一个强制初始化的Bean。

@DependsOn({"steelAxe","abc"})
@Comp
                                
                                Spring4+quartz2的配置和代码方式调度
                                    Everyday都不同
代码配置spring4quartz2.x定时任务
                                    前言：这些天简直被quartz虐哭。。因为quartz 2.x版本相比quartz1.x版本的API改动太多，所以，只好自己去查阅底层API…… 
  
quartz定时任务必须搞清楚几个概念： 
JobDetail——处理类 
Trigger——触发器，指定触发时间，必须要有JobDetail属性，即触发对象 
Scheduler——调度器，组织处理类和触发器，配置方式一般只需指定触发
                                
                                Hibernate入门
                                    tntxia
Hibernate
                                      
前言 
  
使用面向对象的语言和关系型的数据库，开发起来很繁琐，费时。由于现在流行的数据库都不面向对象。Hibernate 是一个Java的ORM（Object/Relational Mapping）解决方案。 
  
Hibernte不仅关心把Java对象对应到数据库的表中，而且提供了请求和检索的方法。简化了手工进行JDBC操作的流程。 
  
如
                                
                                Math类
                                    xiaoxing598
Math
                                    一、Java中的数字（Math）类是final类，不可继承。 
1、常数    PI：double圆周率 E：double自然对数    
2、截取（注意方法的返回类型）    double ceil(double d) 返回不小于d的最小整数 double floor(double d) 返回不大于d的整最大数   int round(float f) 返回四舍五入后的整数 long round
                                
                
            
        
    


    
        
            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    
        
            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.