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

 

運行時效果如下：

 

如你所見，拖拽的時候，對應的DB中父類的改變，還沒有實現，可以自己加一下。

 

參考例子：

1.http://www.javaprogrammingforums.com/java-code-snippets-tutorials/3141-drag-drop-jtrees.html

2.http://www.coderanch.com/t/346509/GUI/java/JTree-drag-drop-inside-one

 

MyBatis3下載地址：

http://code.google.com/p/mybatis/downloads/list?can=3&q=%22mybatis-3%22+-migrations

 

想要完整源代碼的可以留言。