JTree拖拽及无限级分类实现

本文主要是介绍JTree拖拽及无限级分类实现，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

我一直用自己写的一个软件来记笔记，最开始用的是PB做的，功能有限，且到了一家公司不让用盗版，于是用Java又做了一个，随着笔记的分类越来越多，JList已经不能满足显示分类的要求了，查找起来不方便，于是想改用JTree来实现，但随之而来的一个问题是，如何来管理分类的父类别改变，唯一的办法是拖拽来管理。于是研究了一天，参考了几个例子，终于实现了。

该文涉及两个问题：

1.分类是从DB中取来的，实现无限级分类

2.实现树的拖拽

DB的框架用的是IBatis，现在更名叫MyBatis了，这个东西用过之后就再也离不开了，非常方便，省却了很多无聊机械的setter代码，而且对于动态sql的支持非常好，文档一天就可以看完，上手很快。

表结构：

temp_type(type_no int primary key , type_name varchar(200) , parent_type_no int null)

测试数据：

MyBatis配置文件：

1）dao.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> <typeAliases> <typeAlias alias="booktype" type="bean.Type"/> </typeAliases> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="${driver}"/> <property name="url" value="${url}"/> <property name="username" value="${username}"/> <property name="password" value="${password}"/> </dataSource> </environment> </environments> <mappers> <mapper resource="dao/booktype.xml"/> </mappers> </configuration>

2）映射文件：booktype.xml

<?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="book.TempTypeDAO"> <resultMap id="booktypeMap" type="booktype"> <id column="type_no" property="id"/> <result column="type_name" property="name"/> <result column="parent_type_no" property="parentTypeNo" typeHandler="dao.ParentTypeConveter"/> </resultMap> <select id="selectAll" resultMap="booktypeMap"> select type_no , type_name , parent_type_no from temp_type order by lower(type_name) </select> <insert id="insertBookType" parameterType="booktype"> <selectKey keyProperty="id" resultType="int" order="BEFORE"> select max(type_no)+1 from temp_type; </selectKey> insert into temp_type(type_no,type_name,parent_type_no) values( #{id},#{name},#{parentTypeNo}) </insert> <update id="updateBookType" parameterType="booktype"> update temp_type <set> <if test="name!=null">type_name=#{name},</if> <if test="parentTypeNo!=null">parent_type_no=#{parentTypeNo}</if> </set> where type_no=#{id} </update> <delete id="deleteBookType" parameterType="booktype"> delete from temp_type where type_no=#{id} </delete> <select id="selectTypesWithCond" parameterType="booktype" resultType="booktype"> select * from temp_type <where> <if test="id!=null">type_no=#{id} and</if> <if test="name!=null">type_name=#{name} and</if> <if test="parentTypeNo!=null">parent_type_no=#{parentTypeNo}</if> </where> </select> <select id="selectSameTypeNameWhenInsert" parameterType="booktype" resultType="booktype"> select * from temp_type where parent_type_no=#{parentTypeNo} and type_name=#{name} </select> <select id="selectSameTypeNameWhenEdit" parameterType="booktype" resultType="booktype"> select * from temp_type where parent_type_no=#{parentTypeNo} and type_name=#{name} and type_no!=#{id} </select> <select id="selectMaxTypeNo" resultType="int"> select max(type_no) from temp_type </select> </mapper>

3）dao基类：作用是把MyBatis的session的各个方法包括一下，在具体 dao里使用

package dao; import org.apache.ibatis.session.*; import java.sql.Connection; import java.util.List; public abstract class AbsBaseIbatisDAO { private SqlSessionFactory factory; private SqlSession session; protected String namespace; protected AbsBaseIbatisDAO(String namespace, SqlSessionFactory factory) { this.namespace = namespace; this.factory = factory; session=factory.openSession(true); } public SqlSessionFactory getFactory() { return factory; } public void setFactory(SqlSessionFactory factory) { this.factory = factory; session=factory.openSession(); } protected void clearCache() { session.clearCache(); } protected void close() { session.close(); } protected void commit() { session.commit(); } protected void commit(boolean b) { session.commit(b); } protected int delete(String s) { return session.delete(namespace+"." +s); } protected int delete(String s, Object o) { return session.delete(namespace+"." +s,o); } protected Configuration getConfiguration() { return null; } protected Connection getConnection() { return null; //To change body of implemented methods use File | Settings | File Templates. } protected <T> T getMapper(Class<T> tClass) { return null; //To change body of implemented methods use File | Settings | File Templates. } protected int insert(String s) { return session.insert(namespace+"." +s); } protected int insert(String s, Object o) { int rst=session.insert(namespace+"." +s,o); return rst; } protected void rollback() { //To change body of implemented methods use File | Settings | File Templates. } protected void rollback(boolean b) { //To change body of implemented methods use File | Settings | File Templates. } protected void select(String s, Object o, ResultHandler resultHandler) { session.select(namespace+"." +s,o,resultHandler); } protected void select(String s, Object o, RowBounds rowBounds, ResultHandler resultHandler) { session.select(namespace+"." +s,o,rowBounds,resultHandler); } protected List selectList(String s) { return session.selectList(namespace+"." +s); } protected List selectList(String s, Object o) { return session.selectList(namespace+"." +s,o); } protected List selectList(String s, Object o, RowBounds rowBounds) { return session.selectList(namespace+"." +s,o,rowBounds); } protected Object selectOne(String s) { return session.selectOne(namespace+"." +s); } protected Object selectOne(String s, Object o) { return session.selectOne(namespace+"." +s,o); } protected int update(String s) { return session.update(namespace+"." +s); } protected int update(String s, Object o) { return session.update(namespace+"." +s,o); } public SqlSession getSession() { return session; } protected String getNamespace() { return namespace; } protected void setNamespace(String namespace) { this.namespace = namespace; } }

4）具体dao:

package dao; import bean.Type; import org.apache.ibatis.session.SqlSessionFactory; import java.util.List; public class TempTypeDAO extends AbsBaseIbatisDAO { public TempTypeDAO(String namespace, SqlSessionFactory factory) { super(namespace, factory); } public void insert(Type bookType) { insert("insertBookType", bookType); } public void update(Type bookType) { update("updateBookType", bookType); } public void delete(int typeNo) { delete("deleteBookType", typeNo); } public List<Type> selectAll() { return (List<Type>) selectList("selectAll"); } public List<Type> selectSameTypeWhenInsert(Type type) { return (List<Type>) selectList("selectSameTypeNameWhenInsert", type); } public List<Type> selectSameTypeWhenEdit(Type type) { return (List<Type>) selectList("selectSameTypeNameWhenEdit", type); } public Integer selectMaxTypeNo(){ return (Integer)selectOne("selectMaxTypeNo"); } }

5）业务对象：

package bo; import bean.Type; import dao.TempTypeDAO; import java.util.List; public class BookBO { private TempTypeDAO typeDAO; public void createType(String name, Type parentType) { Type t = new Type(); t.setName(name); if (parentType != null) { t.setParentTypeNo(parentType.getId()); } typeDAO.insert(t); } public void createType(Type t) { typeDAO.insert(t); } public void editType(Type type) { typeDAO.update(type); } public void deleteType(Type type) { typeDAO.delete(type.getId()); } public List<Type> getAllTypes() { return (List<Type>) typeDAO.selectAll(); } public boolean isTypeExist(Type type) { if (type.getId() == null) { return !typeDAO.selectSameTypeWhenInsert(type).isEmpty(); } else { return !typeDAO.selectSameTypeWhenEdit(type).isEmpty(); } } public Integer getNextTypeNo() { Integer maxNow = typeDAO.selectMaxTypeNo(); return (maxNow != null ? maxNow + 1 : 1); } public Integer getMaxTypeNo(){ Integer maxNow = typeDAO.selectMaxTypeNo(); return (maxNow != null ? maxNow : 0); } public TempTypeDAO getTypeDAO() { return typeDAO; } public void setTypeDAO(TempTypeDAO typeDAO) { this.typeDAO = typeDAO; } }

呵呵，以上这些是用于取数据，看不懂也没关系，不影响主题。

下面是创建一个包含JTree的类，不仅负责生成JTree，还要加上各种事件，包括右键菜单的生成，添加、删除的操作，与DB的交互。

package test; import bean.Type; import bo.BookBO; import other.Msg; import xdg.XdgUtil; import javax.swing.*; import javax.swing.event.TreeModelEvent; import javax.swing.event.TreeModelListener; import javax.swing.tree.DefaultMutableTreeNode; import javax.swing.tree.DefaultTreeModel; import javax.swing.tree.TreePath; import java.awt.*; import java.awt.event.*; import java.sql.SQLException; import java.util.ArrayList; import java.util.Enumeration; import java.util.List; public class TypeTree { private JTree tree; private BookBO bo; private Component parentComp; private DefaultTreeModel model; public TypeTree(Component parentComp,BookBO bo) { this.bo = bo; this.parentComp=parentComp; Type t = new Type(); t.setId(0); t.setName("All"); List<Type> types = bo.getAllTypes(); DefaultMutableTreeNode root = new DefaultMutableTreeNode(t); generateTree(root, types); model=new DefaultTreeModel(root); tree = new JTree(model); tree.setCellEditor(new TypeNodeEditor(new JTextField(6))); tree.setDragEnabled(true); try { tree.setTransferHandler(new MyJTreeTransferHandler()); } catch (ClassNotFoundException e) { e.printStackTrace(); } setPopupMenu(); expandAll(); } public void expandAll(){ for (int i = 0; i < tree.getRowCount(); i++) { tree.expandRow(i); } } public static void generateTree(DefaultMutableTreeNode node, List<Type> types) { Type parent = (Type) node.getUserObject(); List<DefaultMutableTreeNode> sonNodeList = new ArrayList<DefaultMutableTreeNode>(); for (Type t : types) { if (parent.getId().equals(t.getParentTypeNo())) { DefaultMutableTreeNode sonNode = new DefaultMutableTreeNode(t); node.add(sonNode); sonNodeList.add(sonNode); // types.remove(t); } } for (DefaultMutableTreeNode n : sonNodeList) { generateTree(n, types); } } public void setPopupMenu(){ final JPopupMenu pop=new JPopupMenu(); // JMenuItem itemAdd=new JMenuItem("Add"); // JMenuItem itemDelete=new JMenuItem("Delete"); // pop.add(new AbstractAction("Add"){ public void actionPerformed(ActionEvent e) { add(); } }); pop.add(new AbstractAction("Delete") { public void actionPerformed(ActionEvent e) { delete(); } }); tree.addKeyListener(new KeyAdapter(){ @Override public void keyPressed(KeyEvent e) { if (isNotSelecting()) return ; if (e.getKeyCode()==KeyEvent.VK_DELETE){ delete(); } } }); tree.addMouseListener(new MouseAdapter(){ @Override public void mouseReleased(MouseEvent e) { if (!e.isPopupTrigger()) return; if (isNotSelecting()) return; pop.show(tree,e.getX(),e.getY()); } }); } private void add() { Type parentType=getSelectedType(); DefaultMutableTreeNode parentNode=getSelectedNode(); Type t=new Type(); t.setParentTypeNo(parentType.getId()==0?null:parentType.getId()); t.setName(""); DefaultMutableTreeNode newNode=new DefaultMutableTreeNode(t); model.insertNodeInto(newNode,parentNode,parentNode.getChildCount());//note it getSelectedNode().add(newNode); TreePath path = new TreePath(newNode.getPath()); tree.makeVisible(path);//note it tree.setSelectionPath(path); tree.scrollPathToVisible(path); tree.startEditingAtPath(path); } private void delete() { Type type = getSelectedType(); if (Msg.showConfirm(parentComp, "Really delete /"" + type + "/" and its descendant ?") == 1) { try { DefaultMutableTreeNode node=getSelectedNode(); model.removeNodeFromParent(node); Enumeration e= node.breadthFirstEnumeration(); while (e.hasMoreElements()){ DefaultMutableTreeNode n=(DefaultMutableTreeNode)e.nextElement(); Type t=(Type)n.getUserObject(); bo.deleteType(t); } } catch (Exception ex) { ex.printStackTrace(); Msg.showError(parentComp, ex); } } } public Type getSelectedType(){ DefaultMutableTreeNode node=(DefaultMutableTreeNode)tree.getLastSelectedPathComponent(); System.out.println(node.getUserObject()); Type t=(Type)node.getUserObject(); return t; } public DefaultMutableTreeNode getSelectedNode(){ return (DefaultMutableTreeNode)tree.getLastSelectedPathComponent(); } public boolean isSelecting(){ return getSelectedNode()!=null; } public boolean isNotSelecting(){ return !isSelecting(); } public JTree getTree() { return tree; } class TypeTreeModelListener implements TreeModelListener { public void treeNodesChanged(TreeModelEvent e) { } public void treeNodesInserted(TreeModelEvent e) { //To change body of implemented methods use File | Settings | File Templates. } public void treeNodesRemoved(TreeModelEvent e) { } public void treeStructureChanged(TreeModelEvent e) { //To change body of implemented methods use File | Settings | File Templates. } } class TypeNodeEditor extends DefaultCellEditor{ private JTextField tf; private Type actualObj; TypeNodeEditor(JTextField tf){ super(tf); this.tf=tf; } @Override public boolean stopCellEditing() { if (XdgUtil.isEmpty(tf.getText())) return false; Type t=getSelectedType(); String oldName=t.getName(); t.setName(tf.getText().trim()); if (bo.isTypeExist(t)){ XdgUtil.showMsg(parentComp, String.format("%s has existed, maybe it's not visiable!",tf.getText())); t.setName(oldName); super.cancelCellEditing(); return false; } t.setName(tf.getText()); if (t.getId()==null){ bo.createType(t); t.setId(bo.getMaxTypeNo()); }else{ bo.editType(t); } actualObj=t; return super.stopCellEditing(); } @Override public Object getCellEditorValue() { return actualObj; } } }

这里面有一个方法generateTree，是个递归，用来生成符合类别层次定义的类别结点的。很简单，一目了然，不加注释了。

下面讲解实现拖拽的办法。说起拖拽，看起来很难，实现起来并不难。关键有两个地方，一个是实现TransferHandler接口，它用来跟踪拖拽的过程，比如释放鼠标的时候，源做什么操作，目标又做什么操作，这是写你的逻辑的主要接口，另外一个接口是Transferable，它负责包括一下你拖拽的对象的，注意，对象只能从这个接口包装后获得，别无它法。下面是实现，看之前最好学习一下《Java核心技术中》拖拽的章节，否则很难理解：

package test; import java.awt.datatransfer.DataFlavor; import java.awt.datatransfer.Transferable; import java.awt.datatransfer.UnsupportedFlavorException; import java.io.IOException; import java.util.ArrayList; import java.util.List; import javax.swing.*; import javax.swing.tree.DefaultMutableTreeNode; import javax.swing.tree.DefaultTreeModel; import javax.swing.tree.TreePath; public class MyJTreeTransferHandler extends TransferHandler { public MyJTreeTransferHandler() throws ClassNotFoundException { } public int getSourceActions(JComponent c) { return MOVE; } @Override protected Transferable createTransferable(JComponent c) { JTree tree=(JTree)c; TreePath[] paths=tree.getSelectionPaths(); ArrayList nodes=new ArrayList(); for (TreePath path:paths){ nodes.add(path.getLastPathComponent()); } return new JTreeTransferable(nodes); } @Override protected void exportDone(JComponent source, Transferable data, int action) { // if (action!=MOVE) return; // try { // TreePath[] paths=(TreePath[])data.getTransferData(JTreeTransferable.FLAVOR); // JTree tree=(JTree)source; // DefaultTreeModel model=(DefaultTreeModel)tree.getModel(); // // for (TreePath path:paths){ // // DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent(); model.nodesWereRemoved(node.getParent(),new int[]{ 2},new DefaultMutableTreeNode[]{node}); // model.nodeStructureChanged(node); // model.removeNodeFromParent(node); // // } // } catch (Exception e) { // e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates. // } } @Override public boolean canImport(TransferSupport support) { if (support.isDataFlavorSupported(JTreeTransferable.FLAVOR)){ if (support.getDropAction()==MOVE) return true; } return false; } @Override public boolean importData(TransferSupport support) { JTree tree=(JTree)support.getComponent(); DefaultTreeModel model=(DefaultTreeModel)tree.getModel(); Transferable transfer=support.getTransferable(); try { List<DefaultMutableTreeNode> nodes=(List<DefaultMutableTreeNode>) transfer.getTransferData(JTreeTransferable.FLAVOR); JTree.DropLocation location= (JTree.DropLocation)support.getDropLocation(); DefaultMutableTreeNode newParent =(DefaultMutableTreeNode)location.getPath().getLastPathComponent(); for (DefaultMutableTreeNode node:nodes){ model.removeNodeFromParent(node); model.insertNodeInto(node, newParent, newParent.getChildCount()); } } catch (UnsupportedFlavorException e) { e.printStackTrace(); return false; } catch (Exception e) { e.printStackTrace(); return false; } return true; } } class JTreeTransferable implements Transferable { public static DataFlavor FLAVOR =null; private List<DefaultMutableTreeNode> nodes; JTreeTransferable( ArrayList<DefaultMutableTreeNode> nodes ) { try{ FLAVOR= new DataFlavor(DataFlavor.javaJVMLocalObjectMimeType + ";class=/"" + ArrayList.class.getName() + "/""); this.nodes=nodes; }catch(Exception ex){ ex.printStackTrace(); } } public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException { return nodes; } public DataFlavor[] getTransferDataFlavors() { return new DataFlavor[]{FLAVOR}; } public boolean isDataFlavorSupported(DataFlavor flv) { return FLAVOR.equals(flv); } }

1）exportDone是指完成拖拽后，对拖拽源的操作，在JTree里显然是要删除原位置的结点，

2）importData方法是指放开鼠标时，要如何放置这些拖拽过来的结点，且此方法先于exportDone执行。

3）createTransferable则是用前面讲的Transferable的实现类，包装一下你拖拽的数据，即结点，返回给系统；

4）canImport用来确定什么情况下，允许拖拽；

5）getSourceActions指允许的操作，如MOVE（移动操作）

JTtree删除结点是要靠DefaultTreeModel.removeNodeFromParent，而插入则是insertNodeInto，这里有一个最关键的问题是，在importData将结点插入到新位置，而在exportDone写了删除结点的代码后，一运行，发现无法拖拽，实际上是拖拽成功了，但马上又被删除了，原因是，传过来的拖拽结点对象实际保存的是对象的引用，而非深copy，结点insertNodeInto到新位置之后，父结点对象被更新成了新位置的，这时再删除的时候，也是从新父结点来删除拖过来的子结点，当然就马上把结点删除了。这是今天花时间最多处理的问题，参考的两个例子，其中一个是copy一份拖拽结点，重新new一个结点用来插入，而删除时则用原始的，分开进行可以避免这个问题，另一个例子巨长，不知怎么，没有new却确实生成了新对象了，避免了此问题，但时间有限，没深研究，我深思过后，觉得最简单的办法就是不实现exportDone，因为它总是先插入新结点才被执行，如果让顺序反过来，我手工先删除旧结点，再插入新结点，问题就解决了，所以，就只实现importData了，把逻辑全写在这一个方法里即可。当然exportDone方法还是有它的价值的，用在源和目标不是一个对象的时候，它是必须的，JTree比较特殊。

调用者程序：

/* * To change this template, choose Tools | Templates * and open the template in the editor. */ package test; import java.awt.BorderLayout; import java.io.Reader; import java.util.Properties; import javax.swing.JFrame; import javax.swing.JScrollPane; import javax.swing.JTree; import bo.BookBO; import dao.TempTypeDAO; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; public class IbatisTest { public static void main(String[] args) throws Exception { Properties prop = new Properties(); prop.load(IbatisTest.class.getResourceAsStream("/config.properties")); Reader reader = Resources.getResourceAsReader("dao/dao.xml"); SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, prop); BookBO bookBO=new BookBO(); TempTypeDAO typeDAO = new TempTypeDAO("book.TempTypeDAO", factory); bookBO.setTypeDAO(typeDAO); JFrame frame = new JFrame("book types"); JScrollPane jsp = new JScrollPane(); TypeTree typeTree=new TypeTree(frame, bookBO); JTree tree = typeTree.getTree(); tree.setEditable(true); jsp.setViewportView(tree); frame.add(jsp, BorderLayout.CENTER); frame.setSize(600,500); frame.setVisible(true); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // typeDAO.getSession().close(); } }

运行时效果如下：