MyBatis无限级分类实现的两种方法--自关联与map集合

1、这回先创建数据库吧

下表cid是CategoryId的缩写,cname是CategoryName的缩写，pid是parentId的缩写

无限级分类一般都包含这三个属性，至少也要包含cid和pid才能建立无限级关联

ok,这个东东就是无限级分类了。

即便是外行人稍微看一眼也能发现cid为1的图书在小说和周刊两行中作为了pid,也就是说小说和周刊的父级分类就是图书

图书和饮料的pid是0，代表他们是顶级分类

如果没有其他约束条件，这张表几乎可以无限向下级延伸，是一个树形结构，这里就不写什么数学公式了，道理很简单。想必大家都懂了。

2、写个实体类

首先还是生产实体类，植入一个他本身的List集合:

 package cn.sohappy.acourses.bean;

 import java.util.ArrayList;
 import java.util.List;

 public class Category {
     private Long cid;
     private String cname;
     private Long pid;
     private List<Category> children;

    //省略getter and setter
 }

然后初始化children并重写toString方法方便测试，完整代码如下：

 package cn.sohappy.acourses.bean;

 import java.util.ArrayList;
 import java.util.List;

 public class Category {
     private Long cid;
     private String cname;
     private Long pid;
     private List<Category> children=new ArrayList<Category>();//这里为了防止后面空指针，初始化了children实例

     public List<Category> getChildren() {
         return children;
     }

     public void setChildren(List<Category> children) {
         this.children = children;
     }

     public Long getCid() {
         return cid;
     }

     public void setCid(Long cid) {
         this.cid = cid;
     }

     public String getCname() {
         return cname;
     }

     public void setCname(String cname) {
         this.cname = cname;
     }

     public Long getPid() {
         return pid;
     }

     public void setPid(Long pid) {
         this.pid = pid;
     }

     @Override
     public String toString() {
         return "Category{cid:"+cid+
                 ",cname:"+cname+
                 ",pid:"+pid+
                 ",children:"+children+
                 "}";
     }
 }

3、写接口：

List<Category> findCategoriesByParentId(Long pid);自关联查询

List<Category> findAllCategories();一条sql查询所有，后期用Map算法分级

 package cn.sohappy.acourses.course0921;

 import cn.sohappy.acourses.bean.Category;

 import java.util.List;

 public interface ICategoryDAO {
     List<Category> findCategoriesByParentId(Long pid);
     List<Category> findAllCategories();
 }

4、小配置：

 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE mapper
         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="cn.sohappy.acourses.course0921.ICategoryDAO">
     <!--.自关联查询-->
     <resultMap id="selectCategoriesByPid" type="cn.sohappy.acourses.bean.Category">
         <id property="cid" column="cid"/>
         <result property="cname" column="cname"/>
         <result property="pid" column="pid"/>
         <collection property="children" ofType="cn.sohappy.acourses.bean.Category" select="findCategoriesByParentId" column="cid"/>
     </resultMap>
     <select id="findCategoriesByParentId" resultMap="selectCategoriesByPid">
         select * from category where pid=#{}
     </select>
     <!--.单次查询-->
     <resultMap id="MenuOneSQL" type="cn.sohappy.acourses.bean.Category" autoMapping="false">
         <id property="cid" column="cid"/>
         <result property="cname" column="cname"/>
         <result property="pid" column="pid"/>
     </resultMap>
     <select id="findAllCategories" resultMap="MenuOneSQL">
         select * from category
     </select>
 </mapper>

5.测试类：

 package cn.test;

 import cn.sohappy.acourses.bean.BillManyToOne;
 import cn.sohappy.acourses.bean.Category;
 import cn.sohappy.acourses.bean.UserOneToMany;
 import cn.sohappy.acourses.course0921.ICategoryDAO;
 import cn.sohappy.acourses.course0921.IUserDAO;
 import cn.sohappy.acourses.course0921.InfiniteMenuUtil;
 import cn.sohappy.bean.Smbms_user;
 import cn.sohappy.util.MyBatisUtil;
 import org.apache.ibatis.session.SqlSession;
 import org.junit.Test;

 import java.util.List;

 public class test20170921 {
     @Test
     //自关联实现无穷分类
     public void selfCorrelation(){
         SqlSession session = MyBatisUtil.getSession();
         ICategoryDAO mapper = session.getMapper(ICategoryDAO.class);
         List<Category> categories = mapper.findCategoriesByParentId(0L);
         for (Category item :categories) {
             System.out.println(item);
         }
         session.close();
     }
     @Test
     //Map集合实现无穷分类
     public void InfiniteMenu(){
         SqlSession session = MyBatisUtil.getSession();
         ICategoryDAO mapper = session.getMapper(ICategoryDAO.class);
         List<Category> categoriesClassified = new InfiniteMenuUtil().loadMenu(mapper.findAllCategories());
         for (Category item :categoriesClassified) {
             System.out.println(item);
         }
         session.close();
     }
 }

6、InfiniteMenu的Map算法

 package cn.sohappy.acourses.course0921;

 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.*;

 public class InfiniteMenuUtil {
     @SuppressWarnings("unchecked")
     public <T> List<T> loadMenu(List<T> menus) {
         List<T> rootMenus = new ArrayList<T>();
         if (menus != null && menus.size() != ) {
             List<Method> methodsList = Arrays.asList(menus.get().getClass().getDeclaredMethods());
             //这里可以自己定制啦,我定制的是以pid,id,children结尾的get方法为分别getPid，getId，getChildren.所以menu类(Category)的属性名要符合定制规范
             Method getId = null;
             Method getPid = null;
             Method getChildren = null;
             //get getMethod
             for (Method item : methodsList) {
                 if ("get".equals(item.getName().toLowerCase().substring(,))&&item.getName().length()>=&&"pid".equals(item.getName().toLowerCase().substring(item.getName().length() - , item.getName().length()))){
                     getPid = item;
                     continue;
                 }
                 if ("get".equals(item.getName().toLowerCase().substring(,))&&item.getName().length()>=&&"id".equals(item.getName().toLowerCase().substring(item.getName().length() - , item.getName().length()))){
                     getId = item;
                     continue;
                 }
                 if ("get".equals(item.getName().toLowerCase().substring(,))&&item.getName().length()>=&&"children".equals(item.getName().toLowerCase().substring(item.getName().length() - , item.getName().length()))){
                     getChildren = item;
                 }
             }
             if (getId!=null&&getPid!=null&&getChildren!=null){
                 //get menuMap
                 Map<Long, T> menuMap = new HashMap<Long, T>();
                 for (T menu : menus) {
                     Long id = null;
                     try {
                         id = (Long)getId.invoke(menu);
                     } catch (IllegalAccessException e) {
                         e.printStackTrace();
                     } catch (InvocationTargetException e) {
                         e.printStackTrace();
                     }
                     menuMap.put(id,menu);
                 }
                 //add children
                 for (T menu:menus) {
                     Long pid = null;
                     try {
                         pid = (Long)getPid.invoke(menu);
                     } catch (IllegalAccessException e) {
                         e.printStackTrace();
                     } catch (InvocationTargetException e) {
                         e.printStackTrace();
                     }
                     if (pid==null||pid==){
                         rootMenus.add(menu);
                     }else {
                         T t = menuMap.get(pid);
                         List<T> ts;
                         try {
                             ts = (List<T>) getChildren.invoke(t);
                             ts.add(menu);
                         } catch (IllegalAccessException e) {
                             e.printStackTrace();
                         } catch (InvocationTargetException e) {
                             e.printStackTrace();
                         }
                     }
                 }
             }
         }
         return rootMenus;
     }
 }