1.递归查询根节点的所有子节点id
CREATE DEFINER=`root`@`localhost` PROCEDURE `aaa`(
IN `areaId` INT
,
IN `tableName` VARCHAR(50),
OUT `result` VARCHAR(4000),
IN `idName` VARCHAR(50),
IN `parentIdName` VARCHAR(50)
)
LANGUAGE SQL
NOT DETERMINISTIC
CONTAINS SQL
SQL SECURITY DEFINER
COMMENT ''
BEGIN
DECLARE sTemp VARCHAR(4000);
DECLARE sTempChd VARCHAR(4000);
DECLARE sqlStr VARCHAR(4000);
SET sTemp='';
SET sTempChd = CAST(areaId AS CHAR);
set sqlStr = '';
WHILE sTempChd IS NOT NULL DO
SET sTemp= CONCAT(sTemp,',',sTempChd);
Set @temp = sTempChd;
SET @SQLStr0=concat('SELECT GROUP_CONCAT(',idName,') INTO @temp FROM ',tableName,' WHERE FIND_IN_SET(',parentIdName,',@temp)>0;');
PREPARE sqlStr FROM @SQLStr0;
EXECUTE sqlStr;
Set sTempChd = @temp ;
END WHILE;
Set result = sTemp;
END
areaId:根节点id
idName:id字段名称
parentIdName:父节点id的字段名称
2.递归获取某个节点的根节点
//递归获取某个节点的根节点
private CategoryTreeNode getRootCategoryNode(List<CategoryTreeNode> trees, Category category,List<Integer> checkLine) {
CategoryTreeNode categoryTreeNode = null;
if(trees != null){
for(CategoryTreeNode node : trees){
if(null != node){
//防止死循环
if(checkLine.contains(node.hashCode())){
continue;
}
checkLine.add(node.hashCode());
}
if(null != node && node.getId()!= null&&
node.getId().equals(category.getId())){
categoryTreeNode = node;
break;
}
if(node.getChildren() != null && !node.getChildren().isEmpty()){
CategoryTreeNode tempNode = getRootCategoryNode(node.getChildren(),category,checkLine);
if(tempNode != null){
//categoryTreeNode = tempNode;
categoryTreeNode = node;
break;
}
}
}
}
return categoryTreeNode;
}
3.将list转换成树形结构
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.Page;
import com.sstech.module.content.model.Content;
public class ExchangeUtil {
static Logger logger = LoggerFactory.getLogger(ExchangeUtil.class);
public static <T> List<T> iteratorToList(Iterator<T> i){
List<T> list = new ArrayList<T>();
if(null == i){
return list;
}
else{
while(i.hasNext()){
list.add(i.next());
}
}
return list;
}
// public static <T> Page<T> listToPage(List<T> list){
// Page<T> result = new Page<T>() {
//
// };
// }
/**
* 将list转换成树形结构
*
* map里放入
* parentIdFieldName : 父节点id字段名
* idFieldName : id字段名
* childNodeFieldName : 子节点list字段名
*
* nodeClass : 节点类路径
* idAndParentIdClass : id字段的类路径 (默认Integer)
*
* @param nodes
* @return
*/
public static <T> List<T> buildTree(List<T> nodes,Map<String,Object> classParam) throws Exception
{
if(!classParam.containsKey("parentIdFieldName")){
classParam.put("parentIdFieldName", "parentId");
}
if(!classParam.containsKey("idFieldName")){
classParam.put("idFieldName", "id");
}
if(!classParam.containsKey("childNodeFieldName")){
throw new Exception("leak of childNodeFieldName");
}
if(!classParam.containsKey("nodeClass")){
throw new Exception("leak of nodeClass");
}
if(!classParam.containsKey("idAndParentIdClass")){
throw new Exception("leak of idAndParentIdClass");
}
List<T> rootNodes = new ArrayList<T>();
List<T> nodesBesidesLeafs = new ArrayList<T>();;
try {
nodesBesidesLeafs = buildTreeByList(nodes,classParam);
} catch (NoSuchMethodException e) {
logger.error(e.getMessage(),e);
return new ArrayList<T>();
} catch (SecurityException e) {
logger.error(e.getMessage(),e);
return new ArrayList<T>();
} catch (NoSuchFieldException e) {
logger.error(e.getMessage(),e);
return new ArrayList<T>();
} catch (IllegalArgumentException e) {
logger.error(e.getMessage(),e);
return new ArrayList<T>();
} catch (IllegalAccessException e) {
logger.error(e.getMessage(),e);
return new ArrayList<T>();
} catch (InvocationTargetException e) {
logger.error(e.getMessage(),e);
return new ArrayList<T>();
}
if(!nodes.equals(nodesBesidesLeafs)){
rootNodes = buildTree(nodesBesidesLeafs,classParam);
}
else{
rootNodes = nodesBesidesLeafs;
}
return rootNodes;
}
/**
* 获取除了叶子节点以外的所有节点
*
* map里放入
* parentIdFieldName : 父节点id字段名
* idFieldName : id字段名
* childNodeFieldName : 子节点list字段名
*
* nodeClass : 节点类路径
* idAndParentIdClass : id字段的类路径 (默认Integer)
*
* @param nodes
* @return
*/
static <T> List<T> buildTreeByList(List<T> nodes,Map<String,Object> classParam)
throws NoSuchMethodException, SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, ClassNotFoundException{
List<T> nodesLeafs = new ArrayList<T>();
List<T> nodesBesidesLeafs = new ArrayList<T>();
String parentIdFieldName = String.valueOf(classParam.get("parentIdFieldName"));
String idFieldName = String.valueOf(classParam.get("idFieldName"));
String childNodeFieldName = String.valueOf(classParam.get("childNodeFieldName"));
Class<?> nodeClass = Class.forName(String.valueOf(classParam.get("nodeClass")));
Class<?> idAndParentIdClass = Class.forName(String.valueOf(classParam.get("idAndParentIdClass")));
if(null == idAndParentIdClass){
idAndParentIdClass = Integer.class;
}
Method equalsMethod = idAndParentIdClass.getMethod("equals",Object.class);
Field parentIdField = null;
Field idField = null;
Field childNodeField = null;
do{
Field[] fildList = nodeClass.getDeclaredFields();
for(int i=0;i<fildList.length;i++){
if(fildList[i].getName().equals(parentIdFieldName)){
parentIdField = fildList[i];
}
else if(fildList[i].getName().equals(idFieldName)){
idField = fildList[i];
}
else if(fildList[i].getName().equals(childNodeFieldName)){
childNodeField = fildList[i];
}
}
nodeClass = nodeClass.getSuperclass();
}while(!((null != parentIdField && null != idField && null != childNodeField) ||
nodeClass.getDeclaredFields().length <= 0));
parentIdField.setAccessible(true);
idField.setAccessible(true);
childNodeField.setAccessible(true);
if(null == nodes || nodes.isEmpty()){
return new ArrayList<T>();
}
int nodesSize = nodes.size();
for(int i=0;i<nodesSize;i++){
boolean hasLeafNodes = false;
boolean hasFatherNodes = false;
for(int j=0;j<nodesSize;j++){
if( false == hasLeafNodes && null != parentIdField.get(nodes.get(i)) && null != parentIdField.get(nodes.get(j)) &&
(Boolean) equalsMethod.invoke(idField.get(nodes.get(i)), parentIdField.get(nodes.get(j)))
){
hasLeafNodes = true;
}
if( false == hasFatherNodes && null != parentIdField.get(nodes.get(i)) && null != parentIdField.get(nodes.get(j)) &&
(Boolean) equalsMethod.invoke(parentIdField.get(nodes.get(i)), idField.get(nodes.get(j)))
){
hasFatherNodes = true;
Object childNode = childNodeField.get(nodes.get(j));
if(null == childNode){
childNode = new ArrayList<T>();
childNodeField.set(nodes.get(j), childNode);
}
@SuppressWarnings("unchecked")
List<T> childNodeList = (List<T>) childNode;
if(!childNodeList.contains(nodes.get(i))){
childNodeList.add(nodes.get(i));
}
}
}
if(hasFatherNodes && !hasLeafNodes
&& !nodesLeafs.contains(nodes.get(i))){
nodesLeafs.add(nodes.get(i));
}
}
nodesBesidesLeafs.addAll(nodes);
nodesBesidesLeafs.removeAll(nodesLeafs);
return nodesBesidesLeafs;
}
}
4.获取树的某个节点额其子节点id
@Override
public IBaseResult deleteById(List<Integer> ids) {
IBaseResult result = DefaultResult.buildSuccessResult();
List<Menu> menuTree =
menuMapper.findAll(ConnectionUtil.findServiceMarkBySession(session));
Map<String,Object> classParam = new HashMap<String,Object>();
classParam.put("childNodeFieldName", "children");
classParam.put("nodeClass", Menu.class.getName());
classParam.put("idAndParentIdClass", Integer.class.getName());
List<Menu> trees = new ArrayList<Menu>();
try {
trees = ExchangeUtil.buildTree(menuTree, classParam);
} catch (Exception e) {
logger.error(e.getMessage(),e);
}
if(null!=ids){
for(Integer id : ids){
List<Integer> treeIds = new ArrayList<Integer>();
treeIds.add(id);
getTreeNodeIds(trees,treeIds,new ArrayList<Menu>());
menuMapper.delete(treeIds,ConnectionUtil.findServiceMarkBySession(session));
logger.info(treeIds.toArray().toString());
}
}
return result;
}
private void getTreeNodeIds(List<Menu> topRootNodes ,List<Integer> result,List<Menu> checkedGroup){
if(null != topRootNodes){
for(Menu node : topRootNodes){
if(result.contains(node.getParentId())){
result.add(node.getId());
}
if(null != node.getChildren() && !checkedGroup.containsAll(node.getChildren())){
checkedGroup.add(node);
getTreeNodeIds(node.getChildren(),result,checkedGroup);
}
}
}else{
}
}