├── MySqlJDBC.java
├── Neo4jRestAPI.java
├── addClassUserInfo.jsp
├── admin
    └── AdminInfo.java
├── controller
    ├── AddClassUserInfoServlet.java
    ├── AddNodeController1.java
    ├── AddNodeController2.java
    ├── DisplayController.java
    ├── LoginServlet.java
    └── UserInfoServlet.java
├── framework.jsp
├── index.jsp
├── inputInfo.jsp
├── login.jsp
├── model
    ├── BookBeanDBA.java
    ├── ClassBeanDBA.java
    ├── FacultyBeanDBA.java
    ├── GradeBeanDBA.java
    ├── MajorBeanDBA.java
    ├── UserBeanDBA.java
    ├── UserClassBeanDBA.java
    └── UserInfoConfigBeanDBA.java
├── model2
    ├── NodeBeanDBA.java
    └── RelationshipBeanDBA.java
├── preparations
    ├── GetNodes.java
    ├── GetPaths.java
    ├── JsonFormat.java
    ├── displayInWeb.html
    ├── increaseAndDecrease.html
    └── myStyle.css
├── showUserInfoConfig.jsp
└── systemInfo
    └── SystemInfo.java


/MySqlJDBC.java:
--------------------------------------------------------------------------------
  1 | package com.zehua;
  2 | 
  3 | import java.sql.*;
  4 | import java.util.ArrayList;
  5 | 
  6 | public class MysqlJDBC {
  7 |     static Connection conn = null;
  8 |     static PreparedStatement preparedStatement = null;
  9 |     static ResultSet resultSet = null;
 10 | 
 11 |     //得到connection
 12 |     public static Connection getConn(){
 13 |         String driver = "com.mysql.jdbc.Driver";
 14 |         String url = "jdbc:mysql://127.0.0.1:3306/dbcd?useUnicode=true&characterEncoding=utf-8&useSSL=false";
 15 |         String user = "scott";
 16 |         String password = "tiger";
 17 |         try {
 18 |             Class.forName(driver);
 19 |             conn = DriverManager.getConnection(url,user,password);
 20 |         } catch (ClassNotFoundException e) {
 21 |             e.printStackTrace();
 22 |         } catch (SQLException e) {
 23 |             e.printStackTrace();
 24 |         }
 25 |         return conn;
 26 |     }
 27 |     //关闭连接
 28 |     public static void close(Connection conn,PreparedStatement preparedStatement,ResultSet resultSet){
 29 |         if (conn!=null){
 30 |             try {
 31 |                 conn.close();
 32 |             } catch (SQLException e) {
 33 |                 e.printStackTrace();
 34 |             }
 35 |         }
 36 |         if (preparedStatement!=null){
 37 |             try {
 38 |                 preparedStatement.close();
 39 |             } catch (SQLException e) {
 40 |                 e.printStackTrace();
 41 |             }
 42 |         }
 43 |         if (resultSet!=null){
 44 |             try {
 45 |                 resultSet.close();
 46 |             } catch (SQLException e) {
 47 |                 e.printStackTrace();
 48 |             }
 49 |         }
 50 |     }
 51 |     //查询，返回查询集
 52 |     public static ArrayList[] query(String sql, String[] parameters){
 53 |         ArrayList<Object>[] resultArray = null;
 54 |         getConn();
 55 |         try {
 56 |             preparedStatement = conn.prepareStatement(sql);
 57 |             if(parameters!=null){
 58 |                 for(int i = 0;i<parameters.length;i++){
 59 |                     preparedStatement.setString(i+1,parameters[i]);
 60 |                 }
 61 |             }
 62 |             resultSet = preparedStatement.executeQuery();
 63 |             ResultSetMetaData meta = resultSet.getMetaData();
 64 |             //得到结果集中的列数目
 65 |             int colsCount = meta.getColumnCount();
 66 | 
 67 |             //这个arraylist用来临时保存结果，因为我在这里还没法得到记录的数目
 68 |             ArrayList<ArrayList> arrays = new ArrayList<>();
 69 | 
 70 |             int arrayLength = 0;
 71 |             int rowCount = 0;//为了得到记录的行数
 72 |             while(resultSet.next()){//每次移动一条数据
 73 |                 rowCount++;
 74 |                 ArrayList<Object> array = new ArrayList<Object>();
 75 |                 for(int index = 1;index<=colsCount;index++){
 76 |                     //对于每一条记录，分别得到每列的数据
 77 |                     String str = resultSet.getString(index);
 78 |                     array.add(str);
 79 |                 }
 80 |                 arrays.add(array);
 81 |             }
 82 |             //当过了循环体后，就可以的到记录的数目了；
 83 |             resultArray = new ArrayList[rowCount];
 84 |             for(int i = 0;i<arrays.size();i++){
 85 |                 resultArray[i] = arrays.get(i);
 86 |             }
 87 |         } catch (SQLException e) {
 88 |             e.printStackTrace();
 89 |         }
 90 |         close(conn,preparedStatement,resultSet);
 91 |         return resultArray;
 92 |     }
 93 |     //更新数据，包括更新，插入，删除
 94 |     public static boolean executeUpdate(String sql,String[] parameters){
 95 |         boolean isSuccess = false;
 96 |         getConn();
 97 |         try {
 98 |             preparedStatement  = conn.prepareStatement(sql);
 99 |             for(int i = 0;i<parameters.length;i++){
100 |                 preparedStatement.setString(i+1,parameters[i]);
101 |             }
102 |             preparedStatement.executeUpdate();
103 |             isSuccess = true;
104 |         } catch (SQLException e) {
105 |             e.printStackTrace();
106 |         }
107 |         return isSuccess;
108 |     }
109 | }
110 | 


--------------------------------------------------------------------------------
/Neo4jRestAPI.java:
--------------------------------------------------------------------------------
  1 | package com.zehua;
  2 | 
  3 | import org.neo4j.driver.v1.*;
  4 | import org.neo4j.driver.v1.types.Node;
  5 | import org.neo4j.driver.v1.types.Path;
  6 | import org.neo4j.driver.v1.types.Relationship;
  7 | import systemInfo.SystemInfo;
  8 | 
  9 | import java.util.*;
 10 | 
 11 | public class Neo4jRestAPI {
 12 | 
 13 |     static Driver driver = null;
 14 | 
 15 |     public static void getDriver(){
 16 |         String uri = "Bolt://localhost:7687";
 17 |         String user = "";//这里写自己neo4j的用户名
 18 |         String password = "";//这里写自己neo4j的密码
 19 |         driver = GraphDatabase.driver(uri, AuthTokens.basic(user,password));
 20 |     }
 21 |     public static void close(){
 22 |         if(driver!=null){
 23 |             driver.close();
 24 |         }
 25 |     }
 26 |     //add,delete,modify attribute,
 27 |     public static void executeCypher(String cypher){
 28 |         getDriver();
 29 |         try(Session session = driver.session()){
 30 | 
 31 |             try(Transaction transaction = session.beginTransaction()){
 32 |                 transaction.run(cypher);
 33 |                 transaction.success();
 34 |             }
 35 | 
 36 |         }
 37 |         close();
 38 |     }
 39 |     //node
 40 |     public static Map<String,String> executeFindNodeCypher(String cypher){
 41 |         getDriver();
 42 | 
 43 |         Map<String,String> node_AttrKey_AttrValue_Map = new HashMap<>();
 44 | 
 45 |         try(Session session = driver.session()){
 46 |             StatementResult result = session.run(cypher);
 47 | 
 48 |             while(result.hasNext()){
 49 |                 Record record = result.next();
 50 |                 List<Value> value = record.values();
 51 | 
 52 |                 for(Value i:value){
 53 |                     Node node = i.asNode();
 54 |                     Iterator keys = node.keys().iterator();
 55 | 
 56 |                     while(keys.hasNext()){
 57 |                         String attrKey = (String)keys.next();
 58 |                         String attrValue = node.get(attrKey).asString();
 59 |                         node_AttrKey_AttrValue_Map.put(attrKey,attrValue);
 60 |                     }
 61 |                 }
 62 |             }
 63 |         }
 64 |         close();
 65 |         return node_AttrKey_AttrValue_Map;
 66 |     }
 67 |     //relation
 68 |     public static Map<String,String> executeFindRelAttrCypher(String cypher){
 69 |         getDriver();
 70 | 
 71 |         Map<String,String> Rel_AttrKey_AttrValue_Map = new HashMap<>();
 72 | 
 73 |         try(Session session = driver.session()){
 74 |             StatementResult result = session.run(cypher);
 75 | 
 76 |             while(result.hasNext()){
 77 |                 Record record = result.next();
 78 |                 List<Value> value = record.values();
 79 | 
 80 |                 for(Value i:value){
 81 |                     Map map = i.asMap();
 82 |                     Rel_AttrKey_AttrValue_Map = map;
 83 |                 }
 84 |             }
 85 |         }
 86 |         close();
 87 |         return Rel_AttrKey_AttrValue_Map;
 88 |     }
 89 |     //返回关系的StringBuffer，为可视化做准备！json文件
 90 |     public static StringBuffer executeFindRelationCypher(String cypher){
 91 |         //关系的StringBuffer,json格式
 92 |         StringBuffer relationBuffer = new StringBuffer("");
 93 |         relationBuffer.append("\"links\":[");//return "links":[
 94 |         getDriver();
 95 | 
 96 |         try(Session session = driver.session()){
 97 |             //result包含了所有的path
 98 |             StatementResult result = session.run(cypher);
 99 | 
100 |             while(result.hasNext()){
101 |                 Record record = result.next();
102 |                 List<Value> value = record.values();
103 | 
104 |                 for(Value i:value){
105 |                     Path path = i.asPath();
106 |                     Iterator<Relationship> relationships = path.relationships().iterator();
107 | 
108 |                     while(relationships.hasNext()){
109 |                         Relationship relationship = relationships.next();
110 | 
111 |                         long startNodeId = relationship.startNodeId();
112 |                         long endNodeId = relationship.endNodeId();
113 |                         String relType = relationship.type();
114 | 
115 |                         //得到关系属性的健
116 |                         Iterator<String> relKeys = relationship.keys().iterator();
117 | 
118 |                         relationBuffer.append("{");
119 |                         relationBuffer.append("\"source\":");
120 |                         relationBuffer.append(startNodeId);
121 |                         relationBuffer.append(",");
122 |                         relationBuffer.append("\"target\":");
123 |                         relationBuffer.append(endNodeId);
124 |                         relationBuffer.append(",");
125 |                         relationBuffer.append("\"type\":");
126 |                         relationBuffer.append("\""+relType+"\"");
127 | 
128 |                         //这里处理关系属性
129 |                         while(relKeys.hasNext()){
130 |                             String relKey = relKeys.next();
131 |                             String relValue = relationship.get(relKey).asObject().toString();
132 | 
133 |                             //去除制表符
134 |                             relValue = relValue.replaceAll("\t","");
135 |                             //去除换行符
136 |                             relValue= relValue.replaceAll("\r","");
137 |                             //去除回车符
138 |                             relValue = relValue.replaceAll("\n","");
139 | 
140 |                             //将双引号换成单引号
141 |                             relValue = relValue.replaceAll("\"","'");
142 | 
143 |                             relationBuffer.append(",");
144 |                             relationBuffer.append("\""+relKey+"\"");
145 |                             relationBuffer.append(":");
146 |                             relationBuffer.append("\""+relValue+"\"");
147 |                         }
148 |                         if(!relationships.hasNext()&&!result.hasNext()){
149 |                             relationBuffer.append("}");
150 |                         }
151 |                         else {
152 |                             //如果是最后一个，只需要添加}即可
153 |                             relationBuffer.append("},");
154 |                         }
155 | 
156 |                     }
157 |                 }
158 |             }
159 |         }
160 |         relationBuffer.append("]");
161 |         close();
162 |         return relationBuffer;
163 |     }
164 |     //返回关系中节点的StringBuffer，为可视化做准备！json文件,需要增加节点的类型
165 |     public static StringBuffer executeFindRelationNodesCypher(String cypher) {
166 |         //用一个set集合去除重复项
167 |         Set nodeSet = new HashSet();
168 |         StringBuffer relationNodesBuffer = new StringBuffer("");
169 |         relationNodesBuffer.append("\"nodes\":[");
170 |         getDriver();
171 | 
172 |         try(Session session = driver.session()){
173 |             StatementResult result = session.run(cypher);
174 | 
175 |             while(result.hasNext()){
176 |                 Record record = result.next();
177 |                 List<Value> value = record.values();
178 | 
179 |                 for(Value i:value){
180 | 
181 |                     Path path = i.asPath();
182 |                     Iterator<Node> nodes = path.nodes().iterator();
183 | 
184 |                     while(nodes.hasNext()){
185 |                         Node node = nodes.next();
186 |                         //在增加节点以前，先判断是否在集合中
187 |                         boolean isExist = nodeSet.contains(node.id());
188 |                         if (isExist) continue;
189 |                         Iterator<String> nodeKeys = node.keys().iterator();
190 |                         relationNodesBuffer.append("{");
191 | 
192 |                         //节点属性
193 |                         while(nodeKeys.hasNext()){
194 |                             String nodeKey = nodeKeys.next();
195 |                             relationNodesBuffer.append("\""+nodeKey+"\":");
196 |                             //node.get(nodeKey).toString();
197 |                             //System.out.println(node.get(nodeKey).asObject().toString());
198 |                             String content = node.get(nodeKey).asObject().toString();
199 | 
200 |                             //去除制表符
201 |                             content = content.replaceAll("\t","");
202 |                             //去除换行符
203 |                             content = content.replaceAll("\r","");
204 |                             //去除回车符
205 |                             content = content.replaceAll("\n","");
206 | 
207 |                             //将双引号换成单引号
208 |                             content = content.replaceAll("\"","'");
209 | 
210 |                             relationNodesBuffer.append("\""+content+"\",");
211 |                         }
212 |                         relationNodesBuffer.append("\"id\":");
213 |                         relationNodesBuffer.append(node.id());
214 |                         //添加节点类型！不知道为什么取得节点类型用的是labels，可能一个节点可以属于多个类别
215 |                         //但是我们这里只属于一个类别！
216 |                         Iterator<String> nodeTypes = node.labels().iterator();
217 |                         //得到节点类型了！
218 |                         String nodeType = nodeTypes.next();
219 | 
220 |                         relationNodesBuffer.append(",");
221 |                         relationNodesBuffer.append("\"type\":");
222 |                         relationNodesBuffer.append("\""+nodeType+"\"");
223 | 
224 | 
225 |                         //从SystemInfo中得到NodeTypeKeys，好为新的节点类型分配颜色
226 |                         Set<String> nodeTypeKeys = SystemInfo.getNodeTypeKeys();
227 | 
228 |                         //如果是新的节点类型，则分配颜色，并保持到SystemInfo中
229 |                         if(!nodeTypeKeys.contains(nodeType)){
230 |                             int colorIndex = nodeTypeKeys.size();
231 |                             //以防万一，所需颜色超过5，则随机一种颜色
232 |                             if(colorIndex>=5){
233 |                                 colorIndex = (int)Math.random()*5;
234 |                             }
235 |                             //得到颜色集合
236 |                             String[] colors = SystemInfo.getColor();
237 |                             String color = colors[colorIndex];
238 |                             //添加
239 |                             SystemInfo.addNodeType_Color(nodeType,color);
240 |                             //添加颜色属性
241 |                             relationNodesBuffer.append(",");
242 |                             relationNodesBuffer.append("\"color\":");
243 |                             relationNodesBuffer.append("\""+color+"\"");
244 |                         }
245 |                         else{
246 |                             //说明不是新的节点
247 |                             //通过nodeType得到该节点的颜色
248 |                             Map nodeType_Color = SystemInfo.getNodeType_Color();
249 |                             String color = nodeType_Color.get(nodeType).toString();
250 |                             //添加颜色属性
251 |                             relationNodesBuffer.append(",");
252 |                             relationNodesBuffer.append("\"color\":");
253 |                             relationNodesBuffer.append("\""+color+"\"");
254 |                         }
255 | 
256 |                         //将节点添加到set集合中
257 |                         nodeSet.add(node.id());
258 | 
259 |                         if(!nodes.hasNext()&&!result.hasNext()){
260 |                             relationNodesBuffer.append("}");
261 |                         }
262 |                         else{
263 |                             relationNodesBuffer.append("},");
264 |                         }
265 |                     }
266 |                 }
267 |             }
268 |         }
269 |         int bufferLength = relationNodesBuffer.length();
270 |         char lastChar = relationNodesBuffer.charAt(bufferLength-1);
271 |         if(lastChar==','){
272 |             String str = relationNodesBuffer.substring(0,relationNodesBuffer.length()-1);
273 |             relationNodesBuffer = relationNodesBuffer.replace(0,bufferLength,str);
274 |         }
275 |         relationNodesBuffer.append("]");
276 |         close();
277 |         return  relationNodesBuffer;
278 |     }
279 |     //执行多条cypher语句
280 |     //处理关系
281 |     public static StringBuffer executeFindRelationCyphers(ArrayList<String> cypherArrayList){
282 |         StringBuffer relationBuffer = new StringBuffer("");
283 |         relationBuffer.append("\"links\":[");//return "links":[
284 |         getDriver();
285 | 
286 |         int index = 0;
287 | 
288 |         //新建一个Map,以startNodeId作为key，以endNodeId作为value，用来去重
289 |         Map<Long,Long> start_end = new HashMap<>();
290 | 
291 |         //不知道可不可以批处理
292 |         //这里我就没用批处理了
293 |         try(Session session = driver.session()){
294 | 
295 |             for(int i = 0;i<cypherArrayList.size();i++){
296 |                 String cypher = cypherArrayList.get(i);
297 |                 StatementResult statementResult = session.run(cypher);
298 | 
299 |                 while(statementResult.hasNext()){
300 |                     Record record = statementResult.next();
301 |                     List<Value> list = record.values();
302 | 
303 |                     for(Value item:list){
304 |                         Path path = item.asPath();
305 |                         Iterator<Relationship> rels = path.relationships().iterator();
306 |                         while(rels.hasNext()){
307 |                             index++;
308 | 
309 |                             Relationship relationship = rels.next();
310 |                             long startNodeId = relationship.startNodeId();
311 |                             long endNodeId = relationship.endNodeId();
312 | 
313 |                             //先判断是否重复,
314 |                             boolean isExist = start_end.get(startNodeId)!=null&&start_end.get(startNodeId)==endNodeId;
315 |                             //如果重复，跳过该关系
316 |                             if(isExist){
317 |                                 continue;
318 |                             }
319 |                             //没用重复,将将该关系添加到map中
320 |                             start_end.put(startNodeId,endNodeId);
321 | 
322 |                             String relType = relationship.type();
323 | 
324 |                             //一个新的关系到来
325 |                             if(index==1){
326 |                                 relationBuffer.append("{");
327 |                             }else{
328 |                                 relationBuffer.append(",{");
329 |                             }
330 |                             relationBuffer.append("\"source\":");
331 |                             relationBuffer.append(startNodeId);
332 |                             relationBuffer.append(",");
333 |                             relationBuffer.append("\"target\":");
334 |                             relationBuffer.append(endNodeId);
335 |                             relationBuffer.append(",");
336 |                             relationBuffer.append("\"type\":");
337 |                             relationBuffer.append("\""+relType+"\"");
338 | 
339 |                             Iterator<String> relKeys = relationship.keys().iterator();
340 | 
341 |                             while(relKeys.hasNext()){
342 |                                 String relKey = relKeys.next();
343 |                                 String relKeyValue = relationship.get(relKey).asObject().toString();
344 | 
345 |                                 //去除空格
346 |                                 //relKeyValue = relKeyValue.replaceAll("\\s","");
347 |                                 //去除制表符
348 |                                 relKeyValue = relKeyValue.replaceAll("\t","");
349 |                                 //去除换行符
350 |                                 relKeyValue = relKeyValue.replaceAll("\r","");
351 |                                 //去除回车符
352 |                                 relKeyValue = relKeyValue.replaceAll("\n","");
353 | 
354 |                                 //将双引号换成单引号
355 |                                 relKeyValue = relKeyValue.replaceAll("\"","'");
356 | 
357 |                                 relationBuffer.append(",");
358 |                                 relationBuffer.append("\""+relKey+"\":");
359 |                                 relationBuffer.append("\""+relKeyValue+"\"");
360 |                             }
361 |                             relationBuffer.append("}");
362 |                             /*if(i==cypherArrayList.size()-1&&!rels.hasNext()){
363 |                                 relationBuffer.append("}");
364 |                             }
365 |                             else{
366 |                                 relationBuffer.append("},");
367 |                             }*/
368 |                         }
369 |                     }
370 |                 }
371 |             }
372 |         }
373 |         relationBuffer.append("]");
374 |         close();
375 |         return relationBuffer;
376 |     }
377 |     //接下来是处理节点！！，这个有点复杂了！因为需要添加颜色属性！
378 |     //执行多条cypher语句
379 |     public static StringBuffer executeFindRelationNodesCyphers(ArrayList<String> cypherArrayList){
380 |         //用一个set集合去除重复项
381 |         Set nodeSet = new HashSet();
382 |         StringBuffer relationNodesBuffer = new StringBuffer("");
383 |         relationNodesBuffer.append("\"nodes\":[");
384 |         getDriver();
385 | 
386 |         int index = 0;
387 | 
388 |         try(Session session = driver.session()){
389 | 
390 |             for(int i = 0;i<cypherArrayList.size();i++){
391 |                 String cypher = cypherArrayList.get(i);
392 |                 StatementResult statementResult = session.run(cypher);
393 | 
394 |                 while(statementResult.hasNext()){
395 |                     Record record = statementResult.next();
396 |                     List<Value> list = record.values();
397 | 
398 |                     for(Value item:list){
399 |                         Path path = item.asPath();
400 |                         Iterator<Node> nodes = path.nodes().iterator();
401 | 
402 |                         while(nodes.hasNext()){
403 | 
404 |                             index++;
405 | 
406 |                             Node node = nodes.next();
407 |                             long nodeId = node.id();
408 |                             boolean isExist = nodeSet.contains(nodeId);
409 |                             if(isExist) continue;
410 | 
411 |                             if(index==1){
412 |                                 relationNodesBuffer.append("{");
413 |                             }
414 |                             else{
415 |                                 relationNodesBuffer.append(",{");
416 |                             }
417 | 
418 |                             //没有重复，将nodeId添加到集合中
419 |                             nodeSet.add(nodeId);
420 | 
421 |                             //得到node的类型
422 |                             Iterator<String> nodeTypes = node.labels().iterator();
423 |                             String nodeType = nodeTypes.next();
424 |                             //从SystemInfo中得到NodeTypeKeys，好为新的节点类型分配颜色
425 |                             Set<String> nodeTypeKeys = SystemInfo.getNodeTypeKeys();
426 | 
427 |                             //如果是新的节点类型，则分配颜色，并保持到SystemInfo中
428 |                             if(!nodeTypeKeys.contains(nodeType)){
429 |                                 int colorIndex = nodeTypeKeys.size();
430 |                                 //以防万一，所需颜色超过5，则随机一种颜色
431 |                                 if(colorIndex>=5){
432 |                                     colorIndex = (int)Math.random()*5;
433 |                                 }
434 |                                 //得到颜色集合
435 |                                 String[] colors = SystemInfo.getColor();
436 |                                 String color = colors[colorIndex];
437 |                                 //添加
438 |                                 SystemInfo.addNodeType_Color(nodeType,color);
439 |                                 //添加颜色属性
440 |                                 relationNodesBuffer.append("\"color\":");
441 |                                 relationNodesBuffer.append("\""+color+"\"");
442 |                             }
443 |                             else{
444 |                                 //说明不是新的节点
445 |                                 //通过nodeType得到该节点的颜色
446 |                                 Map nodeType_Color = SystemInfo.getNodeType_Color();
447 |                                 String color = nodeType_Color.get(nodeType).toString();
448 |                                 //添加颜色属性
449 |                                 relationNodesBuffer.append("\"color\":");
450 |                                 relationNodesBuffer.append("\""+color+"\"");
451 |                             }
452 | 
453 |                             //添加id
454 |                             relationNodesBuffer.append(",");
455 |                             relationNodesBuffer.append("\"id\":");
456 |                             relationNodesBuffer.append(nodeId);
457 | 
458 |                             //添加type
459 |                             relationNodesBuffer.append(",");
460 |                             relationNodesBuffer.append("\"type\":");
461 |                             relationNodesBuffer.append("\""+nodeType+"\"");
462 | 
463 |                             //添加其他属性
464 |                             Iterator<String> nodeKeys = node.keys().iterator();
465 | 
466 |                             while (nodeKeys.hasNext()){
467 |                                 String nodeKey = nodeKeys.next();
468 |                                 String nodeKeyValue = node.get(nodeKey).asObject().toString();
469 | 
470 |                                 //去除空格
471 |                                 //nodeKeyValue = nodeKeyValue.replaceAll("\\s","");
472 |                                 //去除制表符
473 |                                 nodeKeyValue = nodeKeyValue.replaceAll("\t","");
474 |                                 //去除换行符
475 |                                 nodeKeyValue = nodeKeyValue.replaceAll("\r","");
476 |                                 //去除回车符
477 |                                 nodeKeyValue = nodeKeyValue.replaceAll("\n","");
478 | 
479 |                                 //将双引号换成单引号
480 |                                 nodeKeyValue = nodeKeyValue.replaceAll("\"","'");
481 | 
482 |                                 relationNodesBuffer.append(",");
483 |                                 relationNodesBuffer.append("\""+nodeKey+"\"");
484 |                                 relationNodesBuffer.append(":");
485 |                                 relationNodesBuffer.append("\""+nodeKeyValue+"\"");
486 |                             }
487 |                             //添加完一个节点后
488 |                             relationNodesBuffer.append("}");
489 |                         }
490 | 
491 |                     }
492 |                 }
493 |             }
494 |         }
495 |         relationNodesBuffer.append("]");
496 |         close();
497 |         return relationNodesBuffer;
498 |     }
499 | 
500 | }
501 | 


--------------------------------------------------------------------------------
/addClassUserInfo.jsp:
--------------------------------------------------------------------------------
  1 | <%@ page import="com.zehua.admin.AdminInfo" %>
  2 | <%@ page import="com.zehua.model.ClassBeanDBA" %>
  3 | <%@ page import="com.zehua.model.ClassBean" %>
  4 | <%@ page import="java.util.ArrayList" %><%--
  5 |   Created by IntelliJ IDEA.
  6 |   User: 29306
  7 |   Date: 2018/6/6
  8 |   Time: 20:54
  9 |   To change this template use File | Settings | File Templates.
 10 | --%>
 11 | <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 12 | <html>
 13 | <head>
 14 |     <meta charset="utf-8">
 15 |     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
 16 |     <title>我的</title>
 17 |     <link rel="stylesheet" href="layui/css/layui.css">
 18 |     <link rel="stylesheet" href="css/myStyle.css">
 19 | 
 20 |     <!--import d3 version 5-->
 21 |     <script type="text/javascript" src="js/d3.min.js"></script>
 22 |     <!--import jquery3.3.1-->
 23 |     <script type="text/javascript" src="js/jquery-3.3.1.min.js"></script>
 24 | </head>
 25 | <body>
 26 | 
 27 | <%
 28 |     String[] allClasses;
 29 |     String[] allClassesId;
 30 |     String[] userClasses = AdminInfo.getClassTypeArray();
 31 |     //先得到该年级，专业下的所有课程
 32 |     //通过gradeId，和majorId
 33 |     String gradeId = AdminInfo.getGradeId();
 34 |     String majorId = AdminInfo.getMajorId();
 35 | 
 36 |     ClassBeanDBA classBeanDBA  = new ClassBeanDBA();
 37 |     ArrayList<ClassBean> classBeans= classBeanDBA.findItem(gradeId,majorId);
 38 |     allClasses = new String[classBeans.size()];
 39 |     allClassesId = new String[classBeans.size()];
 40 |     for(int i = 0;i<classBeans.size();i++){
 41 |         ClassBean classBean = classBeans.get(i);
 42 |         String className = classBean.getClassName();
 43 |         String classId = classBean.getClassId();
 44 |         allClasses[i] = className;
 45 |         allClassesId[i]= classId;
 46 |     }
 47 | %>
 48 | 
 49 | <table width="100%" height="100%">
 50 |     <tr align="center">
 51 |         <td width="25%"></td>
 52 |         <td width="50%" style="background-color: burlywood;vertical-align: middle">
 53 |             <form class="layui-form" action="AddClassUserInfoServlet">
 54 |                         <h1>请选择你需要添加的课程</h1>
 55 |                         <hr>
 56 |                         <br>
 57 |                         <br>
 58 |                         <br>
 59 |                         <%
 60 |                             for(int i = 0;i<allClasses.length;i++){
 61 |                                 String thisClassName = allClasses[i];
 62 |                                 String thisClassId = allClassesId[i];
 63 |                                 //标记是否已经在用户课程表中了！！
 64 |                                 boolean isInclude = false;
 65 |                                 for(int x = 0;x<userClasses.length;x++){
 66 |                                     if(thisClassName.equals(userClasses[x])){
 67 |                                         isInclude = true;
 68 |                                         break;
 69 |                                     }
 70 |                                 }
 71 |                                 if(isInclude){
 72 |                         %>
 73 |                         <input type="checkbox" name="className" title="<%=thisClassName %>" value="<%=thisClassId %>" checked="true"><br><br>
 74 |                         <%
 75 |                         }else{
 76 |                         %>
 77 |                         <input type="checkbox" name="className" title="<%=thisClassName %>" value="<%=thisClassId %>"><br><br>
 78 |                         <%
 79 |                                 }
 80 |                             }
 81 |                         %>
 82 | 
 83 |                 <br>
 84 |                 <br>
 85 |                 <br>
 86 |                 <hr>
 87 |                 <input type="submit" class="layui-btn layui-btn-lg" value="确定">
 88 |             </form>
 89 |         </td>
 90 |         <td width="25%"></td>
 91 |     </tr>
 92 | </table>
 93 | 
 94 | 
 95 | <script src="layui/layui.js"></script>
 96 | <script>
 97 |     layui.use(['form', 'layedit', 'laydate'], function(){
 98 |         var form = layui.form
 99 |             ,layer = layui.layer
100 |     });
101 | </script>
102 | </body>
103 | </html>
104 | 


--------------------------------------------------------------------------------
/admin/AdminInfo.java:
--------------------------------------------------------------------------------
  1 | package com.zehua.admin;
  2 | 
  3 | import org.bouncycastle.math.ec.custom.sec.SecT113R1Point;
  4 | 
  5 | import java.util.HashMap;
  6 | import java.util.HashSet;
  7 | import java.util.Map;
  8 | import java.util.Set;
  9 | 
 10 | //目前只支持查询课程级别一下的关系
 11 | //怎样使的在用户登录后，建立一个全局唯一的AdminInfo!!!!!!!!!!!!!
 12 | public class AdminInfo {
 13 | 
 14 |     private static String username = "";//用户名
 15 |     private static String id = "";//用户id
 16 |     private static String gradeId = "";//年级id
 17 |     private static String gradeName = "";//年级
 18 |     private static String facultyId = "";//学院id
 19 |     private static String facultyName = "";//学院
 20 |     private static String majorId = "";//专业id
 21 |     private static String majorName = "";//专业
 22 |     private static Set<String> classIdSet = new HashSet();//所选课的id
 23 |     private static Set<String> classTypeSet = new HashSet();//所选课的名称
 24 |     private static Map<String,Set<String>> classType_subMap = new HashMap();
 25 | 
 26 |     public static String getUsername() {
 27 |         return username;
 28 |     }
 29 | 
 30 |     public static void setUsername(String username) {
 31 |         AdminInfo.username = username;
 32 |     }
 33 | 
 34 |     public static String getId() {
 35 |         return id;
 36 |     }
 37 | 
 38 |     public static void setId(String id) {
 39 |         AdminInfo.id = id;
 40 |     }
 41 | 
 42 |     public static String getGradeId() {
 43 |         return gradeId;
 44 |     }
 45 | 
 46 |     public static void setGradeId(String gradeId) {
 47 |         AdminInfo.gradeId = gradeId;
 48 |     }
 49 | 
 50 |     public static String getGradeName() {
 51 |         return gradeName;
 52 |     }
 53 | 
 54 |     public static void setGradeName(String gradeName) {
 55 |         AdminInfo.gradeName = gradeName;
 56 |     }
 57 | 
 58 |     public static String getFacultyId() {
 59 |         return facultyId;
 60 |     }
 61 | 
 62 |     public static void setFacultyId(String facultyId) {
 63 |         AdminInfo.facultyId = facultyId;
 64 |     }
 65 | 
 66 |     public static String getFacultyName() {
 67 |         return facultyName;
 68 |     }
 69 | 
 70 |     public static void setFacultyName(String facultyName) {
 71 |         AdminInfo.facultyName = facultyName;
 72 |     }
 73 | 
 74 |     public static String getMajorId() {
 75 |         return majorId;
 76 |     }
 77 | 
 78 |     public static void setMajorId(String majorId) {
 79 |         AdminInfo.majorId = majorId;
 80 |     }
 81 | 
 82 |     public static String getMajorName() {
 83 |         return majorName;
 84 |     }
 85 | 
 86 |     public static void setMajorName(String majorName) {
 87 |         AdminInfo.majorName = majorName;
 88 |     }
 89 | 
 90 |     //添加课程Id
 91 |     public static void addClassIdSetItem(String... items){
 92 |         int length = items.length;
 93 | 
 94 |         for(int i = 0;i<length;i++){
 95 |             classIdSet.add(items[i]);
 96 |         }
 97 |     }
 98 |     //移除课程id
 99 |     public static void deleteClassIdSetItem(String... items){
100 |         int length = items.length;
101 | 
102 |         for(int i = 0;i<length;i++){
103 |             classIdSet.remove(items[i]);
104 |         }
105 |     }
106 |     //返回课程id
107 |     public static String[] getClassIdArray(){
108 |         int length = classIdSet.size();
109 |         Object[] classIdArrayObj = classIdSet.toArray();
110 |         String[] classIdArray = new String[length];
111 | 
112 |         for(int i = 0;i<length;i++){
113 |             classIdArray[i] = classIdArrayObj[i].toString();
114 |         }
115 | 
116 |         return classIdArray;
117 |     }
118 |     //添加课程级别的节点
119 |     public static void addClassTypeSetItem(String... items){
120 |         int length = items.length;
121 | 
122 |         for(int i = 0;i<length;i++){
123 |             classTypeSet.add(items[i]);
124 |         }
125 |     }
126 |     //移除课程
127 |     public static void deleteClassTypeSetItem(String... items){
128 |         int length = items.length;
129 | 
130 |         for(int i = 0;i<length;i++){
131 |             classTypeSet.remove(items[i]);
132 |         }
133 |     }
134 |     //得到课程级别的节点类型的集合
135 |     public static String[] getClassTypeArray(){
136 |         int length = classTypeSet.size();
137 |         Object[] classTypeArrayObj = classTypeSet.toArray();
138 |         String[] classTypeArray = new String[length];
139 | 
140 |         for(int i = 0;i<length;i++){
141 |             classTypeArray[i] = classTypeArrayObj[i].toString();
142 |         }
143 | 
144 |         return classTypeArray;
145 |     }
146 |     //添加某课程下面的节点类型，这里默认为“章节”和“知识点”,不太明白没关系
147 |     //后面会有所了解
148 |     public static void addClassType_subMap(String classTypeSetItem,String... items){
149 |         Set<String> classType_subSet = classType_subMap.get(classTypeSetItem);
150 | 
151 |         if(classType_subSet==null){
152 |             classType_subSet = new HashSet();
153 |         }
154 |         int length = items.length;
155 | 
156 |         for(int i = 0;i<length;i++){
157 |             classType_subSet.add(items[i]);
158 |         }
159 |         classType_subMap.put(classTypeSetItem,classType_subSet);
160 |     }
161 |     //得到某课程下面的节点类型集合，这里默认为“章节”和“知识点”,不太明白没关系
162 |     public static String[] getClassType_subArray(String classTypeSetItem){
163 |         Set classType_subSet = classType_subMap.get(classTypeSetItem);
164 |         int length = classType_subSet.size();
165 |         Object[] classType_subArrayObj = classType_subSet.toArray();
166 |         String[] classType_subArray = new String[length];
167 | 
168 |         for(int i = 0;i<length;i++){
169 |             classType_subArray[i] = classType_subArrayObj[i].toString();
170 |         }
171 |         return classType_subArray;
172 |     }
173 |     //得到全部课程下面的节点类型集合
174 |     public static Map getClassType_subMap(){
175 | 
176 |         return classType_subMap;
177 |     }
178 | }
179 | 


--------------------------------------------------------------------------------
/controller/AddClassUserInfoServlet.java:
--------------------------------------------------------------------------------
  1 | package com.zehua.controller;
  2 | 
  3 | import com.zehua.admin.AdminInfo;
  4 | import com.zehua.model.*;
  5 | 
  6 | import javax.servlet.ServletException;
  7 | import javax.servlet.annotation.WebServlet;
  8 | import javax.servlet.http.HttpServlet;
  9 | import javax.servlet.http.HttpServletRequest;
 10 | import javax.servlet.http.HttpServletResponse;
 11 | import java.io.IOException;
 12 | import java.util.ArrayList;
 13 | 
 14 | @WebServlet(name = "AddClassUserInfoServlet")
 15 | public class AddClassUserInfoServlet extends HttpServlet {
 16 |     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 17 |         this.doGet(request,response);
 18 |     }
 19 | 
 20 |     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 21 |         request.setCharacterEncoding("utf-8");
 22 | 
 23 |         response.setContentType("text/html; charset=utf-8");
 24 |         String[] userClasses = AdminInfo.getClassTypeArray();
 25 |         String[] userClassesId = AdminInfo.getClassIdArray();
 26 |         //将userClassesId转化成arrayList
 27 |         ArrayList<String> al = new ArrayList<>();
 28 | 
 29 |         for(int i = 0;i<userClassesId.length;i++){
 30 |             al.add(userClassesId[i]);
 31 |         }
 32 | 
 33 |         String id  = AdminInfo.getId();
 34 |         //获得了选中的class的id
 35 |         //通过classId查库
 36 |         //得到className
 37 |         String[] checkedClassIds = request.getParameterValues("className");
 38 |         ClassBeanDBA classBeanDBA = new ClassBeanDBA();
 39 |         UserClassBeanDBA userClassBeanDBA = new UserClassBeanDBA();
 40 | 
 41 |         for(int i = 0;i<checkedClassIds.length;i++){
 42 |             String classId = checkedClassIds[i];
 43 | 
 44 |             //得到className
 45 |             ArrayList<ClassBean> classBeans = classBeanDBA.findItem(classId);
 46 |             //只有一个
 47 |             String className = classBeans.get(0).getClassName();
 48 |             //先检查是否已经存在！通过id
 49 |             int j = 0;
 50 |             int size = al.size();
 51 |             for(;j<size;j++){
 52 |                 if (classId.equals(al.get(j))){
 53 |                     //说明已经存在，并把这个id中al中移除
 54 |                     al.remove(classId);
 55 |                     break;
 56 |                 }
 57 |             }
 58 |             //说明存在
 59 |             if(j<size) continue;
 60 | 
 61 |             //往userClass中添加记录
 62 |             UserClassBean userClassBean = new UserClassBean(id,classId);
 63 |             userClassBeanDBA.addItem(userClassBean);
 64 | 
 65 |             AdminInfo.addClassTypeSetItem(className);
 66 |             AdminInfo.addClassIdSetItem(classId);
 67 | 
 68 |             //然后去书表中利用课程号，查找到书集
 69 |             BookBeanDBA bookBeanDBA = new BookBeanDBA();
 70 |             ArrayList<BookBean> bookBeans = bookBeanDBA.findItem(classId);
 71 | 
 72 |             for(int y = 0;y<bookBeans.size();y++){
 73 |                 BookBean bookBean = bookBeans.get(y);
 74 |                 //得到书名
 75 |                 String bookName = bookBean.getBookName();
 76 |                 //然后可以添加AdminInfo的subSetItem域
 77 |                 //这些是默认的，课程下面默认有：
 78 |                 //章节，知识点
 79 |                 //不过可以自己添加！
 80 |                 String chapter = bookName+"章节";
 81 |                 String knowledge = bookName+"知识点";
 82 |                 String[] classType_subSetItem = {chapter,knowledge};
 83 | 
 84 |                 AdminInfo.addClassType_subMap(className,classType_subSetItem);
 85 |             }
 86 |         }
 87 |         //循环完了之后。看看是否al为空，如果不为空，则说明用户删了一些课程
 88 |         //将用户删的课程从用户信息中移除
 89 |         for(int i = 0;i<al.size();i++){
 90 |             String thisClassId = al.get(i);
 91 |             //AdminInfo移除
 92 |             AdminInfo.deleteClassIdSetItem(thisClassId);
 93 |             String thisClassName = classBeanDBA.findItem(thisClassId).get(0).getClassName();
 94 |             AdminInfo.deleteClassTypeSetItem(thisClassName);
 95 |             //数据库中移除
 96 |             UserClassBean userClassBean = new UserClassBean(id,thisClassId);
 97 |             userClassBeanDBA.deleteItem(userClassBean);
 98 |         }
 99 |         //为AdminInfo添加选中的课程
100 | 
101 |         request.getRequestDispatcher("successful.jsp").forward(request,response);
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/controller/AddNodeController1.java:
--------------------------------------------------------------------------------
 1 | package com.zehua.controller;
 2 | 
 3 | import com.zehua.model2.NodeBeanDBA;
 4 | import com.zehua.model2.RelationshipBeanDBA;
 5 | 
 6 | import javax.servlet.ServletException;
 7 | import javax.servlet.annotation.WebServlet;
 8 | import javax.servlet.http.HttpServlet;
 9 | import javax.servlet.http.HttpServletRequest;
10 | import javax.servlet.http.HttpServletResponse;
11 | import javax.servlet.http.HttpSession;
12 | import java.io.IOException;
13 | import java.util.Map;
14 | 
15 | @WebServlet(name = "AddNodeController1")
16 | 
17 | //为了使节点或者关系的属性不用用户输入，我们规定在新建一个节点 类别，或者关系类别的时候
18 | //都必须加入一个属性名为（名称），值为（sdu.zehuape@qq.com），且其他属性名的值都为空（不为空也可以，反正随便）;
19 | //不管是节点类型还是关系类型，都这样处理
20 | //以后！每次添加新的东西（关系或者节点），都事先查出对应的属性集合
21 | //而 有新增属性的时候，值为（du.zehuape@qq.com）的必须同步更新
22 | //而如果由新的节点类型被加入，这要求强制性注册（即，更新AdminInfo）！！
23 | public class AddNodeController1 extends HttpServlet {
24 |     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
25 |         this.doGet(request,response);
26 |     }
27 | 
28 |     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
29 |         request.setCharacterEncoding("utf-8");
30 | 
31 |         String flag = request.getParameter("flag");
32 |         HttpSession session = request.getSession();
33 |         session.setAttribute("flag",flag);
34 | 
35 | 
36 |         if(flag.equals("addNode")){
37 |             NodeBeanDBA nodeBeanDBA = new NodeBeanDBA();
38 | 
39 |             String nodeType = request.getParameter("nodeType");
40 |             //得到了节点类型，去查询该节点类型中，名称为（sdu.zehuape@qq.com）的节点
41 |             //得到属性集合
42 |             Map<String,String> node_AttrKey_AttrValue_Map =
43 |                     nodeBeanDBA.getNodeAttrs(nodeType);
44 |             //利用session传递对象
45 |             session.setAttribute("node_AttrKey_AttrValue_Map",node_AttrKey_AttrValue_Map);
46 | 
47 |             session.setAttribute("nodeType",nodeType);
48 |             String welcome = "欢迎来到添加 ("+nodeType+") 节点的界面";
49 |             request.getRequestDispatcher("inputInfo.jsp?welcome="+welcome).forward(request,response);
50 |         }
51 |         else if(flag.equals("addRel")){
52 |             RelationshipBeanDBA relationshipBeanDBA = new RelationshipBeanDBA();
53 | 
54 |             String fromNodeType = request.getParameter("fromNodeType");
55 |             String relType = request.getParameter("relType");
56 |             String toNodeType = request.getParameter("toNodeType");
57 | 
58 |             //得到了关系类型的名称，去查询name为（在sdu.zehuape@qq.com）的关系的所有属性
59 |             Map<String,String> relation_AttrKey_AttrValue_Map =
60 |                     relationshipBeanDBA.getRelAttrs(relType);
61 |             //利用session传递对象
62 |             session.setAttribute("relation_AttrKey_AttrValue_Map",relation_AttrKey_AttrValue_Map);
63 | 
64 |             session.setAttribute("fromNodeType",fromNodeType);
65 |             session.setAttribute("relType",relType);
66 |             session.setAttribute("toNodeType",toNodeType);
67 | 
68 |             String welcome = "欢迎来到添加 ("+fromNodeType+")"+"-["+relType+"]-"+"("+toNodeType+") 节点的界面";
69 |             request.getRequestDispatcher("inputInfo.jsp?welcome="+welcome).forward(request,response);
70 |         }
71 | 
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/controller/AddNodeController2.java:
--------------------------------------------------------------------------------
 1 | package com.zehua.controller;
 2 | 
 3 | import com.zehua.model2.NodeBeanDBA;
 4 | import com.zehua.model2.RelationshipBeanDBA;
 5 | 
 6 | import javax.servlet.ServletException;
 7 | import javax.servlet.annotation.WebServlet;
 8 | import javax.servlet.http.HttpServlet;
 9 | import javax.servlet.http.HttpServletRequest;
10 | import javax.servlet.http.HttpServletResponse;
11 | import java.io.IOException;
12 | 
13 | @WebServlet(name = "AddNodeController2")
14 | public class AddNodeController2 extends HttpServlet {
15 |     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
16 |         doGet(request,response);
17 |     }
18 | 
19 |     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
20 |         request.setCharacterEncoding("utf-8");
21 | 
22 |         String result = request.getParameter("result");
23 |         String rowsLengthStr = request.getParameter("rowsLength");
24 |         String colsLengthStr = request.getParameter("colsLength");
25 |         int rowsLength = 0;
26 |         int colsLength = 0;
27 | 
28 |         if(rowsLengthStr!=null){
29 |             rowsLength = Integer.parseInt(rowsLengthStr);
30 |         }
31 |         if(colsLengthStr!=null){
32 |             colsLength = Integer.parseInt(colsLengthStr);
33 |         }
34 | 
35 |         //本来在输入的时候是可以输入空格的（或者什么都不输入！这个可以在那个jsp页面加一个判断，填入%作为标记，表示特殊情况）
36 |         // 目前只考虑全输入的情况！
37 | 
38 |         //按空格分割
39 |         String[] resultStrs = result.split(" ");
40 |         for(int i = 0;i<resultStrs.length;i++){
41 |             System.out.println(resultStrs[i]);
42 |         }
43 |         //健
44 |         String[] attributesName = new String[colsLength];
45 |         //值
46 |         String[][] attributesValue = new String[rowsLength-1][colsLength];
47 |         //第一列为属性名
48 |         int i = 0;
49 | 
50 |         for(;i<colsLength;i++){
51 |             attributesName[i] = resultStrs[i];
52 |         }
53 |         //其他的列为属性值，是一个二维数组
54 |         for(int x = 0;x<rowsLength-1;x++){
55 | 
56 |             for(int y = 0;y<colsLength;y++){
57 |                 System.out.println(x*colsLength+y+i);
58 |                 attributesValue[x][y] = resultStrs[x*colsLength+y+i];
59 |             }
60 |         }
61 |         String flag = request.getSession().getAttribute("flag").toString();
62 |         if(flag.equals("addNode")){
63 |             String nodeType = request.getSession().getAttribute("nodeType").toString();
64 | 
65 |             String[] nodeAttributesName = attributesName;
66 |             String[][] nodeAttributesValue = attributesValue;
67 |             NodeBeanDBA nodeBeanDBA = new NodeBeanDBA();
68 |             nodeBeanDBA.addNode(nodeType,nodeAttributesName,nodeAttributesValue);
69 |             request.getRequestDispatcher("successful.jsp").forward(request,response);
70 |         }
71 |         else if(flag.equals("addRel")){
72 |             String fromNodeType = request.getSession().getAttribute("fromNodeType").toString();
73 |             String relType = request.getSession().getAttribute("relType").toString();
74 |             String toNodeType = request.getSession().getAttribute("toNodeType").toString();
75 | 
76 |             String[] someParametersName = attributesName;
77 |             String[][] someParametersValue = attributesValue;
78 |             RelationshipBeanDBA relationshipBeanDBA = new RelationshipBeanDBA();
79 |             relationshipBeanDBA.addRelationship(fromNodeType,relType,toNodeType,someParametersName,someParametersValue);
80 | 
81 |             request.getRequestDispatcher("successful.jsp").forward(request,response);
82 |         }
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/controller/DisplayController.java:
--------------------------------------------------------------------------------
 1 | package com.zehua.controller;
 2 | 
 3 | import com.zehua.model2.RelationshipBeanDBA;
 4 | import systemInfo.SystemInfo;
 5 | 
 6 | import javax.servlet.ServletException;
 7 | import javax.servlet.annotation.WebServlet;
 8 | import javax.servlet.http.HttpServlet;
 9 | import javax.servlet.http.HttpServletRequest;
10 | import javax.servlet.http.HttpServletResponse;
11 | import java.io.IOException;
12 | import java.io.PrintWriter;
13 | import java.util.ArrayList;
14 | 
15 | @WebServlet(name = "DisplayController")
16 | public class DisplayController extends HttpServlet {
17 | 
18 |     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
19 |         doGet(request,response);
20 |     }
21 | 
22 |     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
23 |         //这句话可以解决从jsp页面接受到中文乱码问题
24 |         request.setCharacterEncoding("utf-8");
25 | 
26 |         response.setContentType("text/html; charset=utf-8");
27 | 
28 |         PrintWriter out  = response.getWriter();
29 | 
30 |         String selectItem1 = request.getParameter("selectItem1");
31 |         String selectItem2 = request.getParameter("selectItem2");
32 |         String keyword = request.getParameter("keyword");
33 |         String times = request.getParameter("times");//判断这次操作是用户点击查询按钮还是双击节点
34 |         String isHide = request.getParameter("isHide");
35 | 
36 |         String nodeType = "";
37 |         String nodeName = "";
38 | 
39 |         if(selectItem1!=null&&selectItem1!=""){
40 |             if(selectItem2!=null&&selectItem2!=""){
41 |                 nodeType = selectItem2;
42 |             }
43 |             else nodeType= selectItem1;
44 |         }
45 |         nodeName  = keyword;
46 | 
47 |         String json = "";
48 |         RelationshipBeanDBA relationshipBeanDBA = new RelationshipBeanDBA();
49 |         //用户点击的是查询按钮！
50 |         if(times.equals("first")||isHide.equals("yes")){
51 |             //这里需要特别注意！！，因为更换了服务器tomcat->neo4j，所以会报500错误，
52 |             //解决办法：将neo4j的驱动包，拷到jre中lib的ext目录下
53 |             json = relationshipBeanDBA.lookInto(nodeType,nodeName);
54 |         }
55 |         //用户双击了节点！
56 |         else{
57 |             //执行新的查询方法（允许多条查询语句语句同时进行）
58 |             //先将语句加入到SystemInfo中，然后在得到全部的查询语句
59 |             String cypher = "";
60 | 
61 |             StringBuffer stringBuffer = new StringBuffer("");
62 |             stringBuffer.append("match p=(:");
63 |             stringBuffer.append(nodeType);
64 |             stringBuffer.append("{");
65 |             stringBuffer.append("名称:");
66 |             stringBuffer.append("\"");
67 |             stringBuffer.append(nodeName);
68 |             stringBuffer.append("\"");
69 |             stringBuffer.append("}");
70 |             stringBuffer.append(")");
71 |             stringBuffer.append("-[*..1]-() return p");
72 | 
73 |             cypher = stringBuffer.toString();
74 | 
75 |             SystemInfo.addCypher(cypher);
76 | 
77 |             //得到所有的查询语句
78 |             ArrayList<String> cypherArrayList = SystemInfo.getCypherArrayList();
79 | 
80 |             /*for(int i = 0;i<cypherArrayList.size();i++){
81 |                 System.out.println(cypherArrayList.get(i));
82 |             }*/
83 | 
84 |             json = relationshipBeanDBA.lookIntos(cypherArrayList);
85 |         }
86 |         out.write(json);
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/controller/LoginServlet.java:
--------------------------------------------------------------------------------
 1 | package com.zehua.controller;
 2 | 
 3 | import com.zehua.model.UserBean;
 4 | import com.zehua.model.UserBeanDBA;
 5 | 
 6 | import javax.servlet.ServletException;
 7 | import javax.servlet.annotation.WebServlet;
 8 | import javax.servlet.http.HttpServlet;
 9 | import javax.servlet.http.HttpServletRequest;
10 | import javax.servlet.http.HttpServletResponse;
11 | import java.io.IOException;
12 | import java.io.PrintWriter;
13 | import java.util.ArrayList;
14 | 
15 | @WebServlet(name = "LoginServlet")
16 | public class LoginServlet extends HttpServlet {
17 |     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
18 |         doGet(request,response);
19 |     }
20 | 
21 |     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
22 |         //这句话可以避免jsp页面传值到servlet页面时出现乱码
23 |         request.setCharacterEncoding("utf-8");
24 | 
25 |         //这句话可以避免从servlet到jsp页面出现乱码
26 |         response.setContentType("text/html; charset=utf-8");
27 | 
28 |         PrintWriter out = response.getWriter();
29 | 
30 |         String userNameError = "";
31 |         String userPasswordError = "";
32 |         String isOk = "false";
33 | 
34 |         String username = request.getParameter("username");
35 |         String password = request.getParameter("password");
36 | 
37 |         UserBeanDBA userBeanDBA = new UserBeanDBA();
38 |         //数据库验证
39 |         ArrayList<UserBean> users = userBeanDBA.findItemWithName(username);
40 |         if(users.size()!=0){
41 |             ArrayList<UserBean> userBean = userBeanDBA.findItemWithNameAndPas(username,password);
42 |             //这里只会有一个用户
43 |             if(userBean.size()!=0){
44 |                 isOk = "true";
45 |             }
46 |             else{
47 |                 userPasswordError = "密码错误！";
48 |             }
49 |         }
50 |         else{
51 |             userNameError = "用户名不存在！";
52 |         }
53 |         StringBuffer stringBuffer = new StringBuffer("");
54 |         stringBuffer.append("{");
55 |         stringBuffer.append("\"");
56 |         stringBuffer.append("userNameError");
57 |         stringBuffer.append("\"");
58 |         stringBuffer.append(":");
59 |         stringBuffer.append("\"");
60 |         stringBuffer.append(userNameError);
61 |         stringBuffer.append("\"");
62 |         stringBuffer.append(",");
63 |         stringBuffer.append("\"");
64 |         stringBuffer.append("userPasswordError");
65 |         stringBuffer.append("\"");
66 |         stringBuffer.append(":");
67 |         stringBuffer.append("\"");
68 |         stringBuffer.append(userPasswordError);
69 |         stringBuffer.append("\"");
70 |         stringBuffer.append(",");
71 |         stringBuffer.append("\"");
72 |         stringBuffer.append("isOk");
73 |         stringBuffer.append("\"");
74 |         stringBuffer.append(":");
75 |         stringBuffer.append("\"");
76 |         stringBuffer.append(isOk);
77 |         stringBuffer.append("\"");
78 |         stringBuffer.append("}");
79 | 
80 |         String json = stringBuffer.toString();
81 |         out.write(json);
82 |         //查询数据库，新建一个AdminInfo
83 | 
84 | 
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/controller/UserInfoServlet.java:
--------------------------------------------------------------------------------
  1 | package com.zehua.controller;
  2 | 
  3 | import com.zehua.admin.AdminInfo;
  4 | import com.zehua.model.*;
  5 | 
  6 | import javax.servlet.ServletException;
  7 | import javax.servlet.annotation.WebServlet;
  8 | import javax.servlet.http.HttpServlet;
  9 | import javax.servlet.http.HttpServletRequest;
 10 | import javax.servlet.http.HttpServletResponse;
 11 | import java.io.IOException;
 12 | import java.util.ArrayList;
 13 | 
 14 | @WebServlet(name = "UserInfoServlet")
 15 | public class UserInfoServlet extends HttpServlet {
 16 |     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 17 |         this.doGet(request,response);
 18 |     }
 19 | 
 20 |     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 21 |         //这句话可以避免jsp页面传值到servlet页面时出现乱码
 22 |         request.setCharacterEncoding("utf-8");
 23 | 
 24 |         //这句话可以避免从servlet到jsp页面出现乱码
 25 |         response.setContentType("text/html; charset=utf-8");
 26 | 
 27 |         String username = request.getParameter("username");
 28 |         String password = request.getParameter("password");
 29 | 
 30 |         UserBeanDBA userBeanDBA = new UserBeanDBA();
 31 |         //数据库验证
 32 |         ArrayList<UserBean> user = userBeanDBA.findItemWithNameAndPas(username,password);
 33 | 
 34 |         //在这里只会返回一个
 35 |         UserBean userBean = user.get(0);
 36 |         String id = userBean.getId();
 37 |         //这里AdminInfo保存数据
 38 |         AdminInfo.setUsername(username);
 39 |         AdminInfo.setId(id);
 40 | 
 41 |         UserInfoConfigBeanDBA userInfoConfigBeanDBA = new UserInfoConfigBeanDBA();
 42 |         ArrayList<UserInfoConfigBean> userInfoConfigBeans = userInfoConfigBeanDBA.findItem(id);
 43 | 
 44 |         //只会有一个
 45 |         //保存该用户的一些基本信息，也就是保存在AdminInfo中
 46 |         for(int i = 0;i<userInfoConfigBeans.size();i++){
 47 |             UserInfoConfigBean userInfoConfigBean = userInfoConfigBeans.get(i);
 48 | 
 49 |             String gradeId = userInfoConfigBean.getGradeId();
 50 |             String facultyId = userInfoConfigBean.getFacultyId();
 51 |             String majorId = userInfoConfigBean.getMajorId();
 52 | 
 53 |             AdminInfo.setGradeId(gradeId);
 54 |             AdminInfo.setFacultyId(facultyId);
 55 |             AdminInfo.setMajorId(majorId);
 56 | 
 57 |             //1、查找课程
 58 |             UserClassBeanDBA userClassBeanDBA = new UserClassBeanDBA();
 59 |             ArrayList<UserClassBean> userClassBeans = userClassBeanDBA.findItem(id);
 60 | 
 61 |             //这里会有多个，因为一个用户会与多门课发生联系
 62 |             for(int x = 0;x<userClassBeans.size();x++){
 63 |                 UserClassBean userClassBean = userClassBeans.get(x);
 64 |                 //得到课程编号，然后再去课程中查找！
 65 |                 String classId = userClassBean.getClassId();
 66 | 
 67 |                 ClassBeanDBA classBeanDBA = new ClassBeanDBA();
 68 |                 //得到课程名称！
 69 |                 ArrayList<ClassBean> classBeans = classBeanDBA.findItem(classId);
 70 |                 //只会有一个
 71 |                 ClassBean classBean = classBeans.get(0);
 72 |                 String className = classBean.getClassName();
 73 |                 //得到课程名称后，将它加入到AdminInfo中的ClassType域中
 74 |                 AdminInfo.addClassTypeSetItem(className);
 75 |                 //将课程编号加入到AdminInfo中
 76 |                 AdminInfo.addClassIdSetItem(classId);
 77 | 
 78 |                 //然后去书表中利用课程号，查找到书集
 79 |                 BookBeanDBA bookBeanDBA = new BookBeanDBA();
 80 |                 ArrayList<BookBean> bookBeans = bookBeanDBA.findItem(classId);
 81 | 
 82 |                 for(int y = 0;y<bookBeans.size();y++){
 83 |                     BookBean bookBean = bookBeans.get(y);
 84 |                     //得到书名
 85 |                     String bookName = bookBean.getBookName();
 86 |                     //然后可以添加AdminInfo的subSetItem域
 87 |                     //这些是默认的，课程下面默认有：
 88 |                     //章节，知识点
 89 |                     //不过可以自己添加！
 90 |                     String chapter = bookName+"章节";
 91 |                     String knowledge = bookName+"知识点";
 92 |                     String[] classType_subSetItem = {chapter,knowledge};
 93 | 
 94 |                     AdminInfo.addClassType_subMap(className,classType_subSetItem);
 95 |                 }
 96 | 
 97 |             }
 98 |             //2、查找年级
 99 |             GradeBeanDBA gradeBeanDBA = new GradeBeanDBA();
100 |             ArrayList<GradeBean> gradeBeans = gradeBeanDBA.findItem(gradeId);
101 |             //只会有一个
102 |             String gradeName = gradeBeans.get(0).getGradeName();
103 |             //AdminInfo中的gradeName域
104 |             AdminInfo.setGradeName(gradeName);
105 |             //3、查找学院
106 |             FacultyBeanDBA facultyBeanDBA = new FacultyBeanDBA();
107 |             ArrayList<FacultyBean> facultyBeans = facultyBeanDBA.findItem(facultyId);
108 |             //只会有一个
109 |             String facultyName = facultyBeans.get(0).getFacultyName();
110 |             //AdminInfo中的facultyName域
111 |             AdminInfo.setFacultyName(facultyName);
112 |             //4、查找专业
113 |             MajorBeanDBA majorBeanDBA = new MajorBeanDBA();
114 |             ArrayList<MajorBean> majorBeans = majorBeanDBA.findItem(majorId);
115 |             //只有一个
116 |             String majorName = majorBeans.get(0).getMajorName();
117 |             //AdminInfo中的majorName域
118 |             AdminInfo.setMajorName(majorName);
119 |         }
120 |         //至此，配置信息全部完成
121 |         //可以跳转了！！
122 |         request.getRequestDispatcher("index.jsp").forward(request,response);
123 | 
124 |     }
125 | }
126 | 


--------------------------------------------------------------------------------
/framework.jsp:
--------------------------------------------------------------------------------
  1 | <%--
  2 |   Created by IntelliJ IDEA.
  3 |   User: 29306
  4 |   Date: 2018/5/26
  5 |   Time: 9:02
  6 |   To change this template use File | Settings | File Templates.
  7 | --%>
  8 | <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  9 | 
 10 | <html>
 11 | <head>
 12 |   <meta charset="utf-8">
 13 |   <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
 14 |   <title>我的</title>
 15 |   <link rel="stylesheet" href="layui/css/layui.css">
 16 |   <link rel="stylesheet" href="css/myStyle.css">
 17 | 
 18 |   <!--import d3 version 5-->
 19 |   <script type="text/javascript" src="js/d3.min.js"></script>
 20 |   <!--import jquery3.3.1-->
 21 |   <script type="text/javascript" src="js/jquery-3.3.1.min.js"></script>
 22 | 
 23 |   <link rel="stylesheet" href="css/jquery-ui.min.css">
 24 |   <script src="js/jquery-ui.min.js"></script>
 25 | </head>
 26 | <body class="layui-layout-body">
 27 | 
 28 | 
 29 | <div class="layui-layout layui-layout-admin">
 30 |   <div class="layui-header">
 31 |     <div class="layui-logo">xxxxxxx</div>
 32 |     <!-- 头部区域（可配合layui已有的水平导航） -->
 33 |     <ul class="layui-nav layui-layout-left">
 34 |       <li class="layui-nav-item">
 35 |         <!-- 输入查询内容-->
 36 |         <!--这里不可以为空-->
 37 |         <form class="myform" action="DisplayController" method="post" >
 38 |           <input type="text" name="keyword"  placeholder="数据库" autocomplete="off" class="layui-input input">
 39 |         </form>
 40 |       </li>
 41 |       <span>&nbsp;&nbsp;&nbsp;</span>
 42 |       <li class="layui-nav-item">
 43 |         <!--这里不可以为空-->
 44 |         <form class="selectForm1" action="DisplayController">
 45 |           课程：
 46 | 
 47 |           <select  lay-search="" id="level1">
 48 |             <option value="">直接选择或搜索选择</option>
 49 |           </select>
 50 | 
 51 |         </form>
 52 | 
 53 |       </li>
 54 |       <li class="layui-nav-item">
 55 |         <!--这里可以为空-->
 56 |         <!--先不级联-->
 57 |         <form class="selectForm2" action="DisplayController">
 58 |           -->
 59 |           <select name="selectItem2"  lay-search="" id="level2">
 60 |             <option value="">--请选择--</option>
 61 |           </select>
 62 |         </form>
 63 |       </li>
 64 |       <span>&nbsp;&nbsp;&nbsp;</span>
 65 |       <li class="layui-nav-item">
 66 |         <!--查询-->
 67 |         <button class="layui-btn layui-btn-radius checkButton" onclick="checkButton()">查询</button>
 68 |       </li>
 69 |       <span>&nbsp;&nbsp;</span>
 70 |       <li class="layui-nav-item">
 71 |         <!--清空-->
 72 |         <button class="layui-btn layui-btn-radius clearButton" onclick="clearButton()">清空</button>
 73 |       </li>
 74 | 
 75 |     </ul>
 76 |     <ul class="layui-nav layui-layout-right">
 77 | 
 78 |       <li class="layui-nav-item">
 79 |         是否隐藏后继节点：
 80 |         <input type="radio" name="radio" value="yes">是&nbsp;&nbsp;
 81 |         <input type="radio" name="radio" value="no">否
 82 |       </li>
 83 | 
 84 |       <li class="layui-nav-item">
 85 |         <a href="javascript:;">
 86 |           <img src="http://t.cn/RCzsdCq" class="layui-nav-img">
 87 |           贤心
 88 |         </a>
 89 |         <dl class="layui-nav-child">
 90 |           <dd><a href="showUserInfoConfig.jsp">基本资料</a></dd>
 91 |           <dd><a href="">安全设置</a></dd>
 92 |         </dl>
 93 |       </li>
 94 |       <li class="layui-nav-item"><a href="">退了</a></li>
 95 |     </ul>
 96 |   </div>
 97 | 
 98 |   <div class="layui-side layui-bg-black">
 99 |     <div class="layui-side-scroll">
100 |       <!-- 左侧导航区域（可配合layui已有的垂直导航） -->
101 |       <ul class="layui-nav layui-nav-tree"  lay-filter="test">
102 |         <li class="layui-nav-item layui-nav-itemed">
103 |           <a class="" href="javascript:;">添加</a>
104 |           <dl class="layui-nav-child">
105 |             <dd><a href="javascript:;" data-method="addNode" class="addNode"><span>&nbsp;&nbsp;</span>添加节点</a></dd>
106 |             <dd><a href="javascript:;" data-method="addRel" class="addRel"><span>&nbsp;&nbsp;</span>添加关系</a></dd>
107 |             <dd>
108 |               <a href="javascript:;"><span>&nbsp;&nbsp;</span>上传csv文件</a>
109 |               <dl class="layui-nav-child">
110 |                 <dd><a href="javascript:;"><span>&nbsp;&nbsp;&nbsp;&nbsp;</span>上传添加节点.csv</a></dd>
111 |                 <dd><a href="javascript:;"><span>&nbsp;&nbsp;&nbsp;&nbsp;</span>上传添加关系.csv</a></dd>
112 |               </dl>
113 |             </dd>
114 |           </dl>
115 |         </li>
116 |       </ul>
117 |     </div>
118 |   </div>
119 |   <div class="layui-body">
120 | 
121 |     <svg class=".svg" width="100%" height="100%"></svg>
122 | 
123 |   </div>
124 | 
125 |   <div class="layui-footer">
126 | 
127 |   </div>
128 | </div>
129 | <script src="layui/layui.js"></script>
130 | 
131 | <script>
132 |     //JavaScript代码区域
133 |     layui.use(['element','layer'], function(){
134 |         var element = layui.element;
135 |         var layer = layui.layer;
136 | 
137 |         var $ = layui.jquery;
138 | 
139 |         var active = {
140 | 
141 |             addNode: function(){
142 |                 //示范一个公告层
143 |                 layer.open({
144 |                     type: 1
145 |                     ,title: false //不显示标题栏
146 |                     ,closeBtn: false
147 |                     ,area: '300px;'
148 |                     ,shade: 0.8
149 |                     ,id: 'LAY_layuipro' //设定一个id，防止重复弹出
150 |                     ,btn: ['取消']
151 |                     ,btnAlign: 'c'
152 |                     ,moveType: 1 //拖拽模式，0或者1
153 |                     ,content: '<div style="padding: 50px; line-height: 22px; background-color: #393D49; color: #fff; font-weight: 300;">' +
154 |                     '<form action="AddNodeController1?flag=addNode" method="post">'+
155 |                     '节点类型：<input type="text" name="nodeType">'+
156 |                     '<input type="submit" value="提交" >'+
157 |                     '</form>'+
158 |                     '</div>'
159 |                 });
160 |             },
161 | 
162 |             addRel: function(){
163 |                 //示范一个公告层
164 |                 layer.open({
165 |                     type: 1
166 |                     ,title: false //不显示标题栏
167 |                     ,closeBtn: false
168 |                     ,area: '300px;'
169 |                     ,shade: 0.8
170 |                     ,id: 'LAY_layuipro' //设定一个id，防止重复弹出
171 |                     ,btn: ['取消']
172 |                     ,btnAlign: 'c'
173 |                     ,moveType: 1 //拖拽模式，0或者1
174 |                     ,content: '<div style="padding: 50px; line-height: 22px; background-color: #393D49; color: #fff; font-weight: 300;">' +
175 |                     '<form action="AddNodeController1?flag=addRel" method="post">'+
176 |                     '前驱节点类型：<input type="text" name="fromNodeType"> <br>'+
177 |                     ' 关 系 类 型：<input type="text" name="relType"> <br>'+
178 |                     '后继节点类型：<input type="text" name="toNodeType">'+
179 |                     '<input type="submit" value="提交" >'+
180 |                     '</form>'+
181 |                     '</div>'
182 |                 });
183 |             }
184 |         };
185 | 
186 |         $('.addNode').on('click', function(){
187 |             var othis = $(this), method = othis.data('method');
188 |             active[method] ? active[method].call(this, othis) : '';
189 |         });
190 |         $('.addRel').on('click', function(){
191 |             var othis = $(this), method = othis.data('method');
192 |             active[method] ? active[method].call(this, othis) : '';
193 |         });
194 |     });
195 | 
196 | </script>
197 | 
198 | <script>
199 |     layui.use(['form', 'layedit', 'laydate'], function(){
200 |         var form = layui.form
201 |             ,layer = layui.layer
202 |     });
203 | </script>
204 | 
205 | </body>
206 | </html>
207 | 
208 | 


--------------------------------------------------------------------------------
/index.jsp:
--------------------------------------------------------------------------------
  1 | <%@ page import="com.zehua.admin.AdminInfo" %>
  2 | <%@ page import="java.util.Map" %><%--
  3 |   Created by IntelliJ IDEA.
  4 |   User: 29306
  5 |   Date: 2018/5/26
  6 |   Time: 9:02
  7 |   To change this template use File | Settings | File Templates.
  8 | --%>
  9 | <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 10 | <!--可以为某个教师量身定做，因为某教师接触的科目是很有限的-->
 11 | <!--应该要可以添加书籍的-->
 12 | <html>
 13 | <head>
 14 |   <meta charset="utf-8">
 15 |   <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
 16 |   <title>我的</title>
 17 |   <link rel="stylesheet" href="layui/css/layui.css">
 18 |   <link rel="stylesheet" href="css/myStyle.css">
 19 | 
 20 |   <!--import d3 version 5-->
 21 |   <script type="text/javascript" src="js/d3.min.js"></script>
 22 |   <!--import jquery3.3.1-->
 23 |   <script type="text/javascript" src="js/jquery-3.3.1.min.js"></script>
 24 | 
 25 |   <link rel="stylesheet" href="css/jquery-ui.min.css">
 26 |   <script src="js/jquery-ui.min.js"></script>
 27 | </head>
 28 | <body class="layui-layout-body">
 29 | 
 30 | 
 31 | <%
 32 |   //得到用户所选课程的集合
 33 |   String[] classTypeArray = AdminInfo.getClassTypeArray();
 34 |   //得到一个映射关系，具体请看AdminInfo源码
 35 |   Map classType_subMap = AdminInfo.getClassType_subMap();
 36 |   //将该映射关系转换成一个二维数组
 37 |   String[][] xx = new String[classTypeArray.length][];
 38 | 
 39 |   for(int i = 0;i<classTypeArray.length;i++){
 40 |       String className = classTypeArray[i];
 41 |       String[] classType_subArray = AdminInfo.getClassType_subArray(className);
 42 |       xx[i] = classType_subArray;
 43 |   }
 44 | %>
 45 | 
 46 | <div class="layui-layout layui-layout-admin">
 47 |   <div class="layui-header">
 48 |     <div class="layui-logo">山东财经大学</div>
 49 |     <!-- 头部区域（可配合layui已有的水平导航） -->
 50 |     <ul class="layui-nav layui-layout-left">
 51 |       <li class="layui-nav-item">
 52 |         <!-- 输入查询内容-->
 53 |         <!--这里不可以为空-->
 54 |         <form class="myform" action="DisplayController" method="post" >
 55 |           <input type="text" name="keyword"  placeholder="数据库" autocomplete="off" class="layui-input input">
 56 |         </form>
 57 |       </li>
 58 |       <span>&nbsp;&nbsp;&nbsp;</span>
 59 |       <li class="layui-nav-item">
 60 |         <!--这里不可以为空-->
 61 |         <form class="selectForm1" action="DisplayController">
 62 |           课程：
 63 | 
 64 |               <select  lay-search="" id="level1">
 65 |                 <option value="">直接选择或搜索选择</option>
 66 |                 <%
 67 |                   for(int i = 0;i<classTypeArray.length;i++){
 68 |                       String optionClassName = "option_"+i;
 69 |                 %>
 70 |                 <option value="<%=classTypeArray[i] %>" class="<%=optionClassName %>"><%=classTypeArray[i] %></option>
 71 |                 <%
 72 |                   }
 73 |                 %>
 74 |               </select>
 75 |         </form>
 76 | 
 77 |       </li>
 78 |       <li class="layui-nav-item">
 79 |         <!--这里可以为空-->
 80 |         <!--先不级联-->
 81 |         <form class="selectForm2" action="DisplayController">
 82 |           -->
 83 |           <select name="selectItem2"  lay-search="" id="level2">
 84 |             <option value="">--请选择--</option>
 85 |           </select>
 86 |         </form>
 87 |       </li>
 88 |       <span>&nbsp;&nbsp;&nbsp;</span>
 89 |       <li class="layui-nav-item">
 90 |         <!--查询-->
 91 |         <button class="layui-btn layui-btn-radius checkButton" onclick="checkButton()">查询</button>
 92 |       </li>
 93 |       <span>&nbsp;&nbsp;</span>
 94 |       <li class="layui-nav-item">
 95 |         <!--清空-->
 96 |         <button class="layui-btn layui-btn-radius clearButton" onclick="clearButton()">清空</button>
 97 |       </li>
 98 | 
 99 |     </ul>
100 |     <ul class="layui-nav layui-layout-right">
101 | 
102 |       <li class="layui-nav-item">
103 |         是否隐藏后继节点：
104 |         <input type="radio" name="radio" value="yes">是&nbsp;&nbsp;
105 |         <input type="radio" name="radio" value="no">否
106 |       </li>
107 | 
108 |       <li class="layui-nav-item">
109 |         <a href="javascript:;">
110 |           <img src="http://t.cn/RCzsdCq" class="layui-nav-img">
111 |           贤心
112 |         </a>
113 |         <dl class="layui-nav-child">
114 |           <dd><a href="showUserInfoConfig.jsp">基本资料</a></dd>
115 |           <dd><a href="">安全设置</a></dd>
116 |         </dl>
117 |       </li>
118 |       <li class="layui-nav-item"><a href="">退了</a></li>
119 |     </ul>
120 |   </div>
121 | 
122 |   <div class="layui-side layui-bg-black">
123 |     <div class="layui-side-scroll">
124 |       <!-- 左侧导航区域（可配合layui已有的垂直导航） -->
125 |       <ul class="layui-nav layui-nav-tree"  lay-filter="test">
126 |         <li class="layui-nav-item layui-nav-itemed">
127 |           <a class="" href="javascript:;">添加</a>
128 |           <dl class="layui-nav-child">
129 |             <dd><a href="javascript:;" data-method="addNode" class="addNode"><span>&nbsp;&nbsp;</span>添加节点</a></dd>
130 |             <dd><a href="javascript:;" data-method="addRel" class="addRel"><span>&nbsp;&nbsp;</span>添加关系</a></dd>
131 |             <dd>
132 |               <a href="javascript:;"><span>&nbsp;&nbsp;</span>上传csv文件</a>
133 |               <dl class="layui-nav-child">
134 |                 <dd><a href="javascript:;"><span>&nbsp;&nbsp;&nbsp;&nbsp;</span>上传添加节点.csv</a></dd>
135 |                 <dd><a href="javascript:;"><span>&nbsp;&nbsp;&nbsp;&nbsp;</span>上传添加关系.csv</a></dd>
136 |               </dl>
137 |             </dd>
138 |           </dl>
139 |         </li>
140 |       </ul>
141 |     </div>
142 |   </div>
143 |   <div class="layui-body">
144 | 
145 |     <svg class=".svg" width="100%" height="100%"></svg>
146 | 
147 |   </div>
148 | 
149 |   <div class="layui-footer">
150 | 
151 |   </div>
152 | </div>
153 | <script src="layui/layui.js"></script>
154 | 
155 | 
156 | <script type="text/javascript">
157 | 
158 |   //xx是映射关系转换成的一个二维数组
159 |   var data = new Array(<%=xx.length %>)
160 |   <%
161 |   int i = 0;
162 |   for(;i<xx.length;i++){
163 |   %>
164 |   //这样使得js中的data变量变成了一个和java变量一样的二维数组
165 |   data[<%=i %>] = new Array(<%=xx[i].length%>)
166 |   <%
167 |   }
168 |   %>
169 | 
170 |   <%
171 |   int x = 0;
172 |   for(;x<xx.length;x++){
173 |       int y = 0;
174 |       for(;y<xx[x].length;y++){
175 |   %>
176 |   //注意，一定要加双引号
177 |   //赋值
178 |   data[<%=x %>][<%=y %>] = "<%=xx[x][y] %>";
179 |   <%
180 |     }
181 |   }
182 |   %>
183 | //二级联动的实现
184 |       $(function(){
185 |           $("#level1").change(function(){
186 |               $("#level2").html("<option value=''>--请选择--</option>");
187 |               var value = $(this).val();
188 |               if(value == 0){
189 |                   return;
190 |               }
191 |               //得到选中option的class属性的值
192 |               var optionClassName = $("#level1").find("option:selected").attr("class");
193 |               var strs = optionClassName.split("_");
194 |               var index = strs[1];
195 |               var subData = data[index];
196 |               for(var i in subData){
197 |                   $("#level2").append("<option value='"+subData[i]+"'>"+subData[i]+"</option>");
198 |               }
199 |           });
200 |       });
201 | 
202 | </script>
203 | 
204 | 
205 | 
206 | 
207 | <script>
208 |     //JavaScript代码区域
209 |     layui.use(['element','layer'], function(){
210 |         var element = layui.element;
211 |         var layer = layui.layer;
212 | 
213 |         var $ = layui.jquery;
214 | 
215 |         var active = {
216 | 
217 |             addNode: function(){
218 |                 //示范一个公告层
219 |                 layer.open({
220 |                     type: 1
221 |                     ,title: false //不显示标题栏
222 |                     ,closeBtn: false
223 |                     ,area: '300px;'
224 |                     ,shade: 0.8
225 |                     ,id: 'LAY_layuipro' //设定一个id，防止重复弹出
226 |                     ,btn: ['取消']
227 |                     ,btnAlign: 'c'
228 |                     ,moveType: 1 //拖拽模式，0或者1
229 |                     ,content: '<div style="padding: 50px; line-height: 22px; background-color: #393D49; color: #fff; font-weight: 300;">' +
230 |                     '<form action="AddNodeController1?flag=addNode" method="post">'+
231 |                     '节点类型：<input type="text" name="nodeType">'+
232 |                     '<input type="submit" value="提交" >'+
233 |                     '</form>'+
234 |                     '</div>'
235 |                 });
236 |             },
237 | 
238 |             addRel: function(){
239 |                 //示范一个公告层
240 |                 layer.open({
241 |                     type: 1
242 |                     ,title: false //不显示标题栏
243 |                     ,closeBtn: false
244 |                     ,area: '300px;'
245 |                     ,shade: 0.8
246 |                     ,id: 'LAY_layuipro' //设定一个id，防止重复弹出
247 |                     ,btn: ['取消']
248 |                     ,btnAlign: 'c'
249 |                     ,moveType: 1 //拖拽模式，0或者1
250 |                     ,content: '<div style="padding: 50px; line-height: 22px; background-color: #393D49; color: #fff; font-weight: 300;">' +
251 |                     '<form action="AddNodeController1?flag=addRel" method="post">'+
252 |                     '前驱节点类型：<input type="text" name="fromNodeType"> <br>'+
253 |                     ' 关 系 类 型：<input type="text" name="relType"> <br>'+
254 |                     '后继节点类型：<input type="text" name="toNodeType">'+
255 |                     '<input type="submit" value="提交" >'+
256 |                     '</form>'+
257 |                     '</div>'
258 |                 });
259 |             }
260 |         };
261 | 
262 |         $('.addNode').on('click', function(){
263 |             var othis = $(this), method = othis.data('method');
264 |             active[method] ? active[method].call(this, othis) : '';
265 |         });
266 |         $('.addRel').on('click', function(){
267 |             var othis = $(this), method = othis.data('method');
268 |             active[method] ? active[method].call(this, othis) : '';
269 |         });
270 |     });
271 | 
272 | </script>
273 | 
274 | <script type="text/javascript">
275 |   function checkButton(){
276 |       //注意！！不能同时提交两个表单，否则第一个表单中的input的值在servlet界面获取不到
277 |       //我原本想这样写，但是不行
278 |       //$(".myform").submit();
279 |       //$(".selectForm").submit();
280 |       var selectItem1 = $('.selectForm1 option:selected').val();
281 |       var selectItem2 = $('.selectForm2 option:selected').val();
282 |       var keyword = $(".input").val();
283 | 
284 |       var isHide = $('input:radio:checked').val();
285 | 
286 |       new display(selectItem1,selectItem2,keyword,"first",isHide);
287 |   }
288 | 
289 |   function display(parameter1,parameter2,parameter3,parameter4,parameter5){
290 |       //这一行代码很重要，否则！查询的时候，前面查询的结果还在
291 |       $("svg").html("");
292 |       d3.json("DisplayController?selectItem1="+parameter1+"&selectItem2="+parameter2+"&keyword="+parameter3+"&times="+parameter4+"&isHide="+parameter5).then(function(dataJson){
293 |           //GroupExplorer constructing function
294 |           //this is one way to create a javascript object
295 |           function GroupExplorer(data){
296 |               //create an object-include some data
297 |               //this is an another way to create a javascript object
298 | 
299 |               var defaultConfig = {
300 |                   data:{"nodes":[],"links":[]},//critical data set
301 |                   windowWidth:window.innerWidth,
302 |                   windowHeight:window.innerHeight,
303 |                   defaultLinkDistance:200
304 |               }
305 | 
306 |               //because the initial "data" is null,
307 |               //so you need use jquery syntax "extend" to merge the json data
308 |               //below,merge "data" into "defaultWindow"
309 |               //"true" mean do not cover
310 |               //details see jquery API document
311 |               $.extend(true,defaultConfig,data);
312 | 
313 |               //so now we get the json file that we need
314 |               //now let`s begin,transform json file to force graph data
315 |               //but first ,we need to get "svg"
316 | 
317 |               var svg = d3.select("svg");
318 |               var svgWidth = svg.attr("width");
319 |               var svgHeight = svg.attr("height");
320 |               /*svg.attr("width",defaultConfig.windowWidth);
321 |               svg.attr("height",defaultConfig.windowHeight);*/
322 | 
323 |               defaultConfig.data.links.forEach(function(e){
324 |                   if(typeof e.source=="number"&&typeof e.target=="number"){
325 |                       var sourceNode = defaultConfig.data.nodes.filter(function(n){
326 |                           return n.id === e.source;
327 |                       })[0];
328 |                       var targetNode = defaultConfig.data.nodes.filter(function(n){
329 |                           return n.id === e.target;
330 |                       })[0];
331 |                       e.source = sourceNode;
332 |                       e.target = targetNode;
333 |                   }
334 |               });
335 | 
336 |               //create a force graph
337 |               var forceSimulation = d3.forceSimulation()
338 |                   .force("link",d3.forceLink())
339 |                   .force("charge",d3.forceManyBody())
340 |                   .force("center",d3.forceCenter(defaultConfig.windowWidth/2,defaultConfig.windowHeight/2));
341 | 
342 |               //transform nodes data
343 |               forceSimulation.nodes(defaultConfig.data.nodes)
344 |                   .on("tick",ticked);
345 |               //tranform links data
346 |               forceSimulation.force("link")
347 |                   .links(defaultConfig.data.links)
348 |                   .distance(defaultConfig.defaultLinkDistance);
349 | 
350 |               console.log(defaultConfig.data.links);
351 | 
352 | 
353 |               //define arrow
354 |               svg.append("svg:defs")
355 |                   .append("svg:marker")
356 |                   .attr("id", "marker")
357 |                   .attr('viewBox', '0 -5 10 10')
358 |                   //改变箭头位置
359 |                   .attr("refX", 23)
360 |                   .attr("refY",0)
361 |                   .attr('markerWidth', 10)
362 |                   .attr('markerHeight', 10)
363 |                   .attr('orient', 'auto')
364 |                   .append('svg:path')
365 |                   .attr('d', 'M0,-5L10,0L0,5')
366 |                   .attr("fill","brown");
367 |               //draw links
368 |               var links = svg.append("g")
369 |                   .selectAll("line")
370 |                   .data(defaultConfig.data.links)
371 |                   .enter()
372 |                   .append("line")
373 |                   .attr("title","")
374 |                   .attr("x1",function(n){return n.source.x})
375 |                   .attr("y1",function(n){return n.source.y})
376 |                   .attr("x2",function(n){return n.target.x})
377 |                   .attr("y2",function(n){return n.target.y})
378 |                   .attr("stroke","brown")
379 |                   .attr("stroke-width",2)
380 |                   .attr("marker-end","url(#marker)")
381 |                   .on("mouseover",mouseOverRel);
382 |               //draw links-text
383 |               var links_text = svg.append("g")
384 |                   .selectAll("text")
385 |                   .data(defaultConfig.data.links)
386 |                   .enter()
387 |                   .append("text")
388 |                   .attr("x",function(e){
389 |                       return (e.source.x+e.target.x)/2;
390 |                   })
391 |                   .attr("y",function(e){
392 |                       return (e.source.y+e.target.y)/2;
393 |                   })
394 |                   .attr("font-size",10)
395 |                   .text(function(e){return e.type});
396 |               //draw nodes group = node+node-text
397 |               var nodes_g = svg.append("g")
398 |                   .selectAll("g")
399 |                   .data(defaultConfig.data.nodes)
400 |                   .enter()
401 |                   .append("g")
402 |                   .attr("transform",function(e){
403 |                       return "translate("+e.x+","+e.y+")";
404 |                   })
405 |                   .call(d3.drag()
406 |                       .on("start",started)
407 |                       .on("drag",dragged)
408 |                       .on("end",ended));
409 |               //draw nodes
410 |               nodes_g.append("circle")
411 |                   .attr("title","")
412 |                   .attr("r",30)
413 |                   .attr("fill",function (e) {
414 |                       console.log(e.color);
415 |                       return e.color;
416 |                   })
417 |                   .on("mouseover",mouseOverNode)
418 |                   .on("dblclick",doubleClick);
419 |               //draw node-text
420 |               nodes_g.append("text")
421 |                   .attr("x",-40)
422 |                   .attr("y",40)
423 |                   .attr("font-size",10)
424 |                   .text(function(e){return e.名称});
425 | 
426 |               function started(d){
427 |                   if(!d3.event.active){
428 |                       forceSimulation.alphaTarget(0.8).restart();
429 |                   }
430 |                   d.fx = d.x;
431 |                   d.fy = d.y;
432 |               }
433 |               function dragged(d){
434 |                   d.fx = d3.event.x;
435 |                   d.fy = d3.event.y;
436 |               }
437 |               function ended(d) {
438 |                   if(!d3.event.active){
439 |                       forceSimulation.alphaTarget(0);
440 |                   }
441 |                   d.fx = null;
442 |                   d.fy = null;
443 |               }
444 | 
445 |               function ticked(){
446 |                   links
447 |                       .attr("x1",function(n){return n.source.x})
448 |                       .attr("y1",function(n){return n.source.y})
449 |                       .attr("x2",function(n){return n.target.x})
450 |                       .attr("y2",function(n){return n.target.y})
451 |                   links_text
452 |                       .attr("x",function(e){
453 |                           return (e.source.x+e.target.x)/2;
454 |                       })
455 |                       .attr("y",function(e){
456 |                           return (e.source.y+e.target.y)/2;
457 |                       })
458 |                   nodes_g
459 |                       .attr("transform",function(e){
460 |                           return "translate("+e.x+","+e.y+")";
461 |                       })
462 |               }
463 | 
464 |               //节点的监听
465 |               function mouseOverNode(data) {
466 | 
467 |                   var keys = Object.keys(data);
468 |                   var content = "";
469 | 
470 |                   for(var i = 0;i<keys.length;i++){
471 |                       var key = keys[i];
472 | 
473 |                       //筛选key
474 |                       //其中有几个是默认的key，我们不需要，可以根据console后台打印的node数据格式可以看到
475 |                       //id
476 |                       //index
477 |                       //x
478 |                       //y
479 |                       //vx
480 |                       //vy
481 |                       //还有在拖拽的时候会产生新的两个key——fx和fy
482 |                       if(key=="id"||key=="index"||key=="x"||key=="y"||key=="vx"||key=="vy"||key=="fx"||key=="fy")
483 |                           continue;
484 |                       //通过这样获取value
485 |                       var value = data[key];
486 |                       content += key+"："+value+"   ";
487 |                   }
488 | 
489 |                   $(this).attr("title",content);
490 |               }
491 | 
492 |               //关系的监听
493 |               function mouseOverRel(data) {
494 | 
495 |                   var keys = Object.keys(data);
496 |                   var content = "";
497 | 
498 |                   for(var i = 0;i<keys.length;i++){
499 |                       var key = keys[i];
500 | 
501 |                       //筛选key
502 |                       //其中有几个是默认的key，我们不需要，可以根据console后台打印的relationship数据格式可以看到
503 |                       //index
504 |                       //source
505 |                       //target
506 | 
507 |                       //还有在拖拽的时候会产生新的两个key——fx和fy
508 |                       if(key=="index"||key=="source"||key=="target")
509 |                           continue;
510 |                       //通过这样获取value
511 |                       if(key=="type"){
512 |                           content += "关系类型"+"："+data.type+"   ";
513 |                           continue;
514 |                       }
515 |                       var value = data[key];
516 |                       content += key+"："+value+"   ";
517 |                   }
518 | 
519 |                   $(this).attr("title",content);
520 |               }
521 | 
522 |               //处理双击事件
523 |               //相当于递归调用
524 |               function doubleClick(data){
525 |                   var nodeName = data.名称;
526 |                   var nodeType = data.type;
527 | 
528 |                   //得到所需要的nodeName,和nodeType
529 |                   //可以调用查询按钮点击事件，即将这次的双击事件看成查询事件，只是在后台调用不同的查询方法
530 |                   var parameter1 = nodeType;
531 |                   var parameter2 = "";
532 |                   var parameter3 = nodeName;
533 |                   var parameter4 = "other";
534 |                   var isHide = $('input:radio:checked').val();
535 |                   console.log(isHide);
536 | 
537 |                   new display(parameter1,parameter2,parameter3,parameter4,isHide);
538 | 
539 |                   console.log(nodeType+"----"+nodeName);
540 |               }
541 | 
542 |           }
543 |           //because in the way of creating a javascript object,
544 |           //you need to use "new" to use it
545 |           new GroupExplorer({data:dataJson});
546 |       })
547 |   }
548 | 
549 |   function clearButton() {
550 |       $(".input").val("");
551 |   }
552 | </script>
553 | 
554 | <script>
555 |     layui.use(['form', 'layedit', 'laydate'], function(){
556 |         var form = layui.form
557 |             ,layer = layui.layer
558 |     });
559 | </script>
560 | 
561 | <script type="text/javascript">
562 |     $(document).tooltip();
563 | </script>
564 | 
565 | </body>
566 | </html>
567 | 


--------------------------------------------------------------------------------
/inputInfo.jsp:
--------------------------------------------------------------------------------
  1 | <%@ page import="java.util.Map" %>
  2 | <%@ page import="java.util.Set" %><%--
  3 |   Created by IntelliJ IDEA.
  4 |   User: 29306
  5 |   Date: 2018/5/26
  6 |   Time: 15:27
  7 |   To change this template use File | Settings | File Templates.
  8 | --%>
  9 | <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 10 | <html>
 11 | <head>
 12 |     <title>Title</title>
 13 |     <link rel="stylesheet" href="css/myStyle.css">
 14 |     <link rel="stylesheet" href="layui/css/layui.css">
 15 | 
 16 |     <script type="text/javascript" src="js/jquery-3.3.1.min.js"></script>
 17 | 
 18 | </head>
 19 | <body>
 20 | 
 21 |     <%
 22 | 
 23 |         //注意，java变量在js中不可以通过《%= %》这种方式来获取
 24 |         //可以通过：把java变量的值赋值给页面中<input type="hidden"/>的value，通过js去取；
 25 | 
 26 |         String welcome = request.getParameter("welcome");
 27 | 
 28 |         String flag = session.getAttribute("flag").toString();
 29 | 
 30 |         int length = 0;
 31 |         String[] attrKeys = null;
 32 |         if(flag.equals("addNode")){
 33 |             Map<String,String> node_AttrKey_AttrValue_Map =
 34 |                     (Map<String, String>) session.getAttribute("node_AttrKey_AttrValue_Map");
 35 |             //得到所有的属性
 36 |             System.out.println(node_AttrKey_AttrValue_Map);
 37 |             Object[] attrKeysObj = node_AttrKey_AttrValue_Map.keySet().toArray();
 38 |             length = attrKeysObj.length;
 39 |             attrKeys = new String[length];
 40 | 
 41 |             for(int i = 0;i<length;i++){
 42 |                 attrKeys[i] = attrKeysObj[i].toString();
 43 |             }
 44 | 
 45 |         }
 46 |         if(flag.equals("addRel")){
 47 |             Map<String,String> relation_AttrKey_AttrValue_Map =
 48 |                     (Map<String, String>) session.getAttribute("relation_AttrKey_AttrValue_Map");
 49 |             //得到所有的属性
 50 |             Object[] attrKeysObj = relation_AttrKey_AttrValue_Map.keySet().toArray();
 51 |             length = attrKeysObj.length-1;
 52 |             attrKeys = new String[length];
 53 | 
 54 |             int index = 0;
 55 |             for(int i = 0;i<attrKeysObj.length;i++){
 56 |                 if(attrKeysObj[i].toString().equals("name")) continue;
 57 |                 attrKeys[index++] = attrKeysObj[i].toString();
 58 |             }
 59 |         }
 60 |     %>
 61 | 
 62 |     <!--通过一个hidden的input来保存nodeType的值-->
 63 |     <!--其实也可以直接用session传-->
 64 |     <input type="hidden" value="" class="nodeTypeInput">
 65 | 
 66 |     <script>
 67 |         function onSubmit(){
 68 |             var table = document.getElementById("table");
 69 |             //得到行数
 70 |             var rowsLength  = table.rows.length;
 71 |             //得到列数
 72 |             var colsLength = table.rows[0].cells.length;
 73 | 
 74 |             var result = "";
 75 | 
 76 |             //格式化输入的数据，即用空格分开
 77 |             var textarea = document.getElementsByTagName("textarea");
 78 |             var length = textarea.length;
 79 |             for(var i = 0;i<length;i++){
 80 |                 var str = textarea[i].value;
 81 |                 str += " ";
 82 |                 result += str;
 83 |             }
 84 |             window.location.href = "AddNodeController2?result="+result+"&rowsLength="+rowsLength+"&colsLength="+colsLength;
 85 |         }
 86 |     </script>
 87 | 
 88 | <script type="text/javascript">
 89 |     $(document).ready(function(){
 90 |         <!--增加列-->
 91 |         $(".colAdd").click(function(){
 92 |             var str = "<td class='col'><textarea ></textarea></td>"
 93 |             $(".tr").append(str);
 94 |         });
 95 |         <!--减少列-->
 96 |         $(".colMinus").click(function(){
 97 |             var table = document.getElementById("table");
 98 |             var rowsLength  = table.rows.length;
 99 |             var colsLength = table.rows[0].cells.length;
100 |             for(var i = 0;i<rowsLength;i++){
101 |                 var index = -1-(rowsLength-1-i)*colsLength;
102 |                 //移除最后一列元素，，
103 |                 // 因为这里是选种全部的col，而不是每一个tr下的col
104 |                 $(".col").eq(index).remove();
105 |             }
106 |         });
107 |         <!--增加行-->
108 |         $(".rowAdd").click(function(){
109 |             var table = document.getElementById("table");
110 |             var colsLength = table.rows[0].cells.length;
111 | 
112 |             var subStr1 = "<tr class=\"tr\">"
113 |             var subStr2 = "";
114 |             for(var i = 1;i<=colsLength;i++){
115 |                 var subStr2_str = "<td class='col'><textarea></textarea></td>";
116 |                 subStr2 += subStr2_str;
117 |             }
118 |             var subStr3 = "</tr>"
119 |             var str = subStr1+subStr2+subStr3;
120 |             $(".table").append(str);
121 |         });
122 |         <!--减少行-->
123 |         $(".rowMinus").click(function(){
124 |             <!--jquery语法，移除匹配元素中的最后一个元素-->
125 |             $(".tr").eq(-1).remove();
126 |         });
127 |     });
128 | </script>
129 | 
130 | <table width="100%" height="100%">
131 |     <tr align="center">
132 |         <td width="25%"></td>
133 |         <td width="50%" style="background-color: burlywood;vertical-align: middle">
134 |             <h1 align="center"><%=welcome %></h1>
135 |             <hr>
136 |             <br>
137 |             <br>
138 |             <br>
139 |             <br>
140 |             <table border="0" width="100%" align="center">
141 |                 <tr align="center">
142 |                     <td width="25%"><button class="layui-btn layui-btn-sm colAdd" type="button">列+1</button></td>
143 |                     <td width="25%"><button class="layui-btn layui-btn-sm colMinus" type="button">列-1</button></td>
144 |                     <td width="25%"><button class="layui-btn layui-btn-sm rowAdd" type="button">行+1</button></td>
145 |                     <td width="25%"><button class="layui-btn layui-btn-sm rowMinus" type="button">行-1</button></td>
146 |                 </tr>
147 |             </table>
148 |             <br>
149 |             <table width="80%" border="1"  align="center" class="table" id="table">
150 |                 <tbody>
151 |                 <tr class="tr" bgcolor="#ffc0cb" align="center">
152 |                     <%
153 |                         if(flag.equals("addNode")){
154 |                             for(int i = 0;i<length;i++){
155 |                     %>
156 |                     <td class="col" ><textarea readonly style="text-align: center;background-color: pink" ><%=attrKeys[i] %></textarea></td>
157 |                     <%
158 |                         }
159 |                     }
160 |                     else if(flag.equals("addRel")){
161 |                     %>
162 |                     <td class="col" ><textarea readonly style="text-align: center;background-color: pink" >名称</textarea></td>
163 |                     <td class="col" ><textarea readonly style="text-align: center;background-color: pink" >name</textarea></td>
164 |                     <td class="col" ><textarea readonly style="text-align: center;background-color: pink" >名称</textarea></td>
165 |                     <%
166 |                         for(int i = 0;i<length;i++){
167 |                     %>
168 |                     <td class="col" ><textarea readonly style="text-align: center;background-color: pink" ><%=attrKeys[i] %></textarea></td>
169 |                     <%
170 |                             }
171 |                         }
172 |                     %>
173 |                 </tr>
174 |                 <tr class="tr" align="center">
175 |                     <%
176 |                         if(flag.equals("addNode")){
177 |                             for(int i = 0;i<length;i++){
178 |                     %>
179 |                     <td class="col" ><textarea ></textarea></td>
180 |                     <%
181 |                             }
182 |                         }
183 |                     %>
184 |                     <%
185 |                         if(flag.equals("addRel")){
186 |                             for(int i = 0;i<length+3;i++){
187 |                     %>
188 |                     <td class="col" ><textarea ></textarea></td>
189 |                     <%
190 |                             }
191 |                         }
192 |                     %>
193 |                 </tr>
194 |                 </tbody>
195 |             </table>
196 |             <br>
197 |             <table width="50%" border="0"  align="center" class="">
198 |                 <tbody>
199 |                 <tr align="center">
200 |                     <td width="50%"><button class="layui-btn layui-btn-sm " type="button" >重置</button></td>
201 |                     <td width="50%"><button class="layui-btn layui-btn-sm " type="button" onclick="onSubmit()">提交</button></td>
202 |                 </tr>
203 |                 </tbody>
204 |             </table>
205 |             <br>
206 |             <br>
207 |             <br>
208 |             <br>
209 |             <hr>
210 |             <a href="index.jsp">返回主界面</a>
211 |         </td>
212 |         <td width="25%"></td>
213 |     </tr>
214 | </table>
215 | 
216 | </body>
217 | </html>
218 | 


--------------------------------------------------------------------------------
/login.jsp:
--------------------------------------------------------------------------------
  1 | <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2 | <!DOCTYPE HTML>
  3 | <html>
  4 | <head>
  5 |     <meta charset="utf-8">
  6 |     <title>Home</title>
  7 |     <!-- Animate.css -->
  8 |     <link rel="stylesheet" href="css/animate.css">
  9 |     <!-- Bootstrap  -->
 10 |     <link rel="stylesheet" href="css/bootstrap.css">
 11 |     <!-- Theme style  -->
 12 |     <link rel="stylesheet" href="css/style.css">
 13 | 
 14 |     <!--js-->
 15 |     <!-- Modernizr JS -->
 16 |     <script src="js/modernizr-2.6.2.min.js"></script>
 17 |     <!-- FOR IE9 below -->
 18 |     <!--[if lt IE 9]>
 19 |     <script src="js/respond.min.js"></script>
 20 |     <![endif]-->
 21 |     <!-- jQuery -->
 22 |     <script src="js/jquery-3.3.1.min.js"></script>
 23 |     <!-- Waypoints -->
 24 |     <script src="js/jquery.waypoints.min.js"></script>
 25 |     <!-- Carousel -->
 26 |     <script src="js/owl.carousel.min.js"></script>
 27 |     <!-- Main -->
 28 |     <script src="js/main.js"></script>
 29 | 
 30 | </head>
 31 | <body>
 32 | 
 33 | <div class="gtco-loader"></div>
 34 | 
 35 | <div id="page">
 36 | 
 37 | 
 38 |     <div class="page-inner">
 39 | 
 40 | 
 41 |         <header id="gtco-header" class="gtco-cover" role="banner" style="background-image: url(images/img_4.jpg)">
 42 |             <div class="overlay"></div>
 43 |             <div class="gtco-container">
 44 |                 <div class="row">
 45 |                     <div class="col-md-12 col-md-offset-0 text-left">
 46 |                         <div class="row row-mt-15em">
 47 |                             <div class="col-md-7 mt-text animate-box" data-animate-effect="fadeInUp">
 48 |                                 <span class="intro-text-small">Welcome to Splash</span>
 49 |                                 <h1>Build website using this template.</h1>
 50 |                             </div>
 51 |                             <div class="col-md-4 col-md-push-1 animate-box" data-animate-effect="fadeInRight">
 52 |                                 <div class="form-wrap">
 53 |                                     <div class="tab">
 54 |                                         <ul class="tab-menu">
 55 |                                             <li class="gtco-second"><a href="#" data-tab="signup">注册</a></li>
 56 |                                             <li class="active gtco-first"><a href="#" data-tab="login">登录</a></li>
 57 |                                         </ul>
 58 |                                         <div class="tab-content">
 59 |                                             <div class="tab-content-inner" data-content="signup">
 60 |                                                 <form action="#">
 61 |                                                     <div class="row form-group">
 62 |                                                         <div class="col-md-12">
 63 |                                                             <label for="username">用户名</label>
 64 |                                                             <input type="text" class="form-control" >
 65 |                                                         </div>
 66 |                                                     </div>
 67 |                                                     <div class="row form-group">
 68 |                                                         <div class="col-md-12">
 69 |                                                             <label for="password">密&nbsp;&nbsp;码</label>
 70 |                                                             <input type="password" class="form-control" >
 71 |                                                         </div>
 72 |                                                     </div>
 73 |                                                     <div class="row form-group">
 74 |                                                         <div class="col-md-12">
 75 |                                                             <label for="password2">重复密码</label>
 76 |                                                             <input type="password" class="form-control" id="password2">
 77 |                                                         </div>
 78 |                                                     </div>
 79 | 
 80 |                                                     <div class="row form-group">
 81 |                                                         <div class="col-md-12">
 82 |                                                             <input type="submit" class="btn btn-primary" value="注册">
 83 |                                                         </div>
 84 |                                                     </div>
 85 |                                                 </form>
 86 |                                             </div>
 87 | 
 88 |                                             <div class="tab-content-inner active" data-content="login">
 89 |                                                 <form action="UserInfoServlet" method="post">
 90 |                                                     <div class="row form-group">
 91 |                                                         <div class="col-md-12">
 92 |                                                             <label for="username">用户名</label>
 93 |                                                             <input type="text" class="form-control username" id="username" name="username"><br>
 94 |                                                             <text class="error1" style="color: red"></text>
 95 |                                                         </div>
 96 |                                                     </div>
 97 |                                                     <div class="row form-group">
 98 |                                                         <div class="col-md-12">
 99 |                                                             <label for="password">密&nbsp;&nbsp;码</label>
100 |                                                             <input type="password" class="form-control password" id="password" name="password"><br>
101 |                                                             <text class="error2" style="color: red"></text>
102 |                                                         </div>
103 |                                                     </div>
104 | 
105 |                                                     <div class="row form-group">
106 |                                                         <div class="col-md-12">
107 |                                                             <input type="button" class="btn btn-primary submit" value="登录">
108 |                                                         </div>
109 |                                                     </div>
110 |                                                 </form>
111 |                                             </div>
112 |                                         </div>
113 |                                     </div>
114 |                                 </div>
115 |                             </div>
116 |                         </div>
117 |                     </div>
118 |                 </div>
119 |             </div>
120 |         </header>
121 |     </div>
122 | 
123 | </div>
124 | 
125 | <div class="gototop js-top">
126 |     <a href="#" class="js-gotop"><i class="icon-arrow-up"></i></a>
127 | </div>
128 | 
129 | <script type="text/javascript">
130 | 
131 |     //jquery的class选择器，当用户点击“登录”按钮时触发
132 |     $(".submit").click(function(){
133 |         //得到用户输入的用户名和密码
134 |         var username = $(".username").val();
135 |         var password = $(".password").val();
136 |         //异步通信，利用ajax传数据到后台（LoginServlet）
137 |         $.ajax({
138 |             url:"LoginServlet?username="+username+"&password="+password
139 |         }).done(function(data){//当处理完成后，返回一个json数据，可以看LoginServlet文件源码，以便知道返回的json数据格式
140 |             var json = data;
141 |             //解析json数据
142 |             var obj = JSON.parse(json,function(name,value){//键值对的方式
143 |                 if(name=="userNameError"){
144 |                     //用户名错误
145 |                     $(".error1").text(value)
146 |                 }
147 |                 else if(name=="userPasswordError"){
148 |                     //密码错误
149 |                     $(".error2").text(value);
150 |                 }
151 |                 else {
152 |                     //没有错误，就可以正常登陆
153 |                     if(value=="true"){
154 |                         $("form").submit();
155 |                     }
156 |                 }
157 |                 return value;
158 |             });
159 |         })
160 |     })
161 | </script>
162 | 
163 | </body>
164 | </html>
165 | 


--------------------------------------------------------------------------------
/model/BookBeanDBA.java:
--------------------------------------------------------------------------------
 1 | package com.zehua.model;
 2 | 
 3 | import com.zehua.MysqlJDBC;
 4 | 
 5 | import java.util.ArrayList;
 6 | 
 7 | public class BookBeanDBA {
 8 | 
 9 |     String bookId = null;
10 |     String bookName = null;
11 |     String classId = null;
12 |     public void initializeInfo(BookBean bookBean){
13 |         bookId = bookBean.getBookId();
14 |         bookName = bookBean.getBookName();
15 |         classId = bookBean.getClassId();
16 |     }
17 |     //增
18 |     public boolean addItem(BookBean bookBean){
19 |         initializeInfo(bookBean);
20 | 
21 |         String sql = "insert into book values(?,?,?)";
22 |         String[] parameters = {bookId,bookName,classId};
23 | 
24 |         boolean isSuccess = MysqlJDBC.executeUpdate(sql,parameters);
25 | 
26 |         return isSuccess;
27 |     }
28 |     //删
29 |     public boolean deleteItem(BookBean bookBean){
30 |         initializeInfo(bookBean);
31 | 
32 |         String sql = "delete from book where bookId = ? and bookName = ? and classId = ?";
33 |         String[] parameters = {bookId,bookName,classId};
34 | 
35 |         boolean isSuccess = MysqlJDBC.executeUpdate(sql,parameters);
36 | 
37 |         return isSuccess;
38 |     }
39 |     //改
40 |     public boolean modifyItem(BookBean bookBean){
41 |         initializeInfo(bookBean);
42 | 
43 |         String sql = "update book set bookId = ? , bookName = ? where classId = ?";
44 |         String[] parameters = {bookId,bookName,classId};
45 | 
46 |         boolean isSuccess = MysqlJDBC.executeUpdate(sql,parameters);
47 | 
48 |         return isSuccess;
49 |     }
50 |     //查，目前先只写按classId查询
51 |     public ArrayList<BookBean> findItem(String classId){
52 | 
53 |         ArrayList<BookBean> resultBookBeans = new ArrayList<BookBean>();
54 | 
55 |         String sql = "select*from book where classId = ?";
56 |         String[] parameters = {classId};
57 | 
58 |         ArrayList<Object>[] resultArray = MysqlJDBC.query(sql,parameters);
59 |         int length = resultArray.length;
60 |         for(int i = 0;i<length;i++){
61 |             ArrayList<Object> arrayList = resultArray[i];
62 | 
63 |             String thisBookId = arrayList.get(0).toString();
64 |             String thisBookName = arrayList.get(1).toString();
65 |             String thisClassId = arrayList.get(2).toString();
66 | 
67 |             BookBean thisBookBean = new BookBean(thisBookId,thisBookName,thisClassId);
68 |             resultBookBeans.add(thisBookBean);
69 | 
70 |         }
71 |         return resultBookBeans;
72 | 
73 |     }
74 | 
75 | }
76 | 


--------------------------------------------------------------------------------
/model/ClassBeanDBA.java:
--------------------------------------------------------------------------------
  1 | package com.zehua.model;
  2 | 
  3 | import com.zehua.MysqlJDBC;
  4 | 
  5 | import java.util.ArrayList;
  6 | 
  7 | public class ClassBeanDBA {
  8 | 
  9 |     String classId = null;
 10 |     String className = null;
 11 |     String gradeId = null;
 12 |     String majorId = null;
 13 | 
 14 |     public void initializeInfo(ClassBean classBean){
 15 |         classId = classBean.getClassId();
 16 |         className = classBean.getClassName();
 17 |         gradeId = classBean.getGradeId();
 18 |         majorId = classBean.getMajorId();
 19 |     }
 20 | 
 21 |     //增
 22 |     public boolean addItem(ClassBean classBean){
 23 |         initializeInfo(classBean);
 24 | 
 25 |         String sql = "insert into class values(?,?,?,?)";
 26 |         String[] parameters = {classId,className,gradeId,majorId};
 27 | 
 28 |         boolean isSuccess = MysqlJDBC.executeUpdate(sql,parameters);
 29 | 
 30 |         return isSuccess;
 31 |     }
 32 |     //删
 33 |     public boolean deleteItem(ClassBean classBean){
 34 |         initializeInfo(classBean);
 35 | 
 36 |         String sql = "delete from class where classId = ? , className = ? , gradeId = ? , majorId = ?";
 37 |         String[] parameters = {classId,className,gradeId,majorId};
 38 | 
 39 |         boolean isSuccess = MysqlJDBC.executeUpdate(sql,parameters);
 40 | 
 41 |         return isSuccess;
 42 | 
 43 |     }
 44 |     //改
 45 |     public boolean modifyItem(ClassBean classBean){
 46 |         initializeInfo(classBean);
 47 | 
 48 |         String sql = "update class set classId = ? , className = ? where gradeId = ? and majorId = ?";
 49 |         String[] parameters = {classId,className,gradeId,majorId};
 50 | 
 51 |         boolean isSuccess = MysqlJDBC.executeUpdate(sql,parameters);
 52 | 
 53 |         return isSuccess;
 54 | 
 55 |     }
 56 |     //查，目前先只写按gradeId和majorId查询
 57 |     public ArrayList<ClassBean> findItem(String gradeId,String majorId){
 58 |         ArrayList<ClassBean> resultClassBeans = new ArrayList<ClassBean>();
 59 | 
 60 |         String sql = "select * from class where gradeId = ? and majorId = ?";
 61 |         String[] parameters = {gradeId,majorId};
 62 | 
 63 |         ArrayList<Object>[] resultArray = MysqlJDBC.query(sql,parameters);
 64 |         int length = resultArray.length;
 65 |         for(int i = 0;i<length;i++){
 66 |             ArrayList<Object> arrayList = resultArray[i];
 67 | 
 68 |             String thisClassId = arrayList.get(0).toString();
 69 |             String thisClassName = arrayList.get(1).toString();
 70 |             String thisGradeId = arrayList.get(2).toString();
 71 |             String thisMajorId = arrayList.get(3).toString();
 72 | 
 73 |             ClassBean thisClassBean = new ClassBean(thisClassId,thisClassName,thisGradeId,thisMajorId);
 74 |             resultClassBeans.add(thisClassBean);
 75 | 
 76 |         }
 77 |         return resultClassBeans;
 78 |     }
 79 | 
 80 |     //查！按classId查
 81 |     public ArrayList<ClassBean> findItem(String classId){
 82 |         ArrayList<ClassBean> resultClassBeans = new ArrayList<ClassBean>();
 83 | 
 84 |         String sql = "select * from class where classId = ?";
 85 |         String[] parameters = {classId};
 86 | 
 87 |         ArrayList<Object>[] resultArray = MysqlJDBC.query(sql,parameters);
 88 |         int length = resultArray.length;
 89 |         for(int i = 0;i<length;i++){
 90 |             ArrayList<Object> arrayList = resultArray[i];
 91 | 
 92 |             String thisClassId = arrayList.get(0).toString();
 93 |             String thisClassName = arrayList.get(1).toString();
 94 |             String thisGradeId = arrayList.get(2).toString();
 95 |             String thisMajorId = arrayList.get(3).toString();
 96 | 
 97 |             ClassBean thisClassBean = new ClassBean(thisClassId,thisClassName,thisGradeId,thisMajorId);
 98 |             resultClassBeans.add(thisClassBean);
 99 | 
100 |         }
101 |         return resultClassBeans;
102 |     }
103 | 
104 | }
105 | 


--------------------------------------------------------------------------------
/model/FacultyBeanDBA.java:
--------------------------------------------------------------------------------
 1 | package com.zehua.model;
 2 | 
 3 | import com.zehua.MysqlJDBC;
 4 | 
 5 | import java.util.ArrayList;
 6 | 
 7 | public class FacultyBeanDBA {
 8 | 
 9 |     String facultyId = null;
10 |     String facultyName = null;
11 | 
12 |     public void initializeInfo(FacultyBean facultyBean){
13 |         facultyId = facultyBean.getFacultyId();
14 |         facultyName = facultyBean.getFacultyName();
15 |     }
16 | 
17 |     public boolean addItem(FacultyBean facultyBean){
18 |         initializeInfo(facultyBean);
19 | 
20 |         String sql = "insert into faculty values(?,?)";
21 |         String[] parameters = {facultyId,facultyName};
22 | 
23 |         boolean isSuccess = MysqlJDBC.executeUpdate(sql,parameters);
24 | 
25 |         return isSuccess;
26 | 
27 |     }
28 | 
29 |     public boolean deleteItem(FacultyBean facultyBean){
30 |         initializeInfo(facultyBean);
31 | 
32 |         String sql = "delete from faculty where facultyId = ? and facultyName = ?";
33 |         String[] parameters = {facultyId,facultyName};
34 | 
35 |         boolean isSuccess = MysqlJDBC.executeUpdate(sql,parameters);
36 | 
37 |         return isSuccess;
38 | 
39 |     }
40 | 
41 |     public boolean modifyItem(FacultyBean facultyBean){
42 |         initializeInfo(facultyBean);
43 | 
44 |         String sql = "update faculty set facultyName = ? where facultyId = ?";
45 |         String[] parameters = {facultyName,facultyId};
46 | 
47 |         boolean isSuccess = MysqlJDBC.executeUpdate(sql,parameters);
48 | 
49 |         return isSuccess;
50 | 
51 |     }
52 | 
53 |     public ArrayList<FacultyBean> findItem(String facultyId){
54 | 
55 |         ArrayList<FacultyBean> resultFacultyBeans = new ArrayList<FacultyBean>();
56 | 
57 |         String sql = "select*from faculty where facultyId = ?";
58 |         String[] parameters = {facultyId};
59 | 
60 |         ArrayList<Object>[] resultArray = MysqlJDBC.query(sql,parameters);
61 |         int length = resultArray.length;
62 |         for(int i = 0;i<length;i++){
63 |             ArrayList<Object> arrayList = resultArray[i];
64 | 
65 |             String thisFacultyId = arrayList.get(0).toString();
66 |             String thisFacultyName = arrayList.get(1).toString();
67 | 
68 |             FacultyBean thisFacultyBean = new FacultyBean(thisFacultyId,thisFacultyName);
69 |             resultFacultyBeans.add(thisFacultyBean);
70 | 
71 |         }
72 |         return resultFacultyBeans;
73 | 
74 |     }
75 | 
76 | }
77 | 


--------------------------------------------------------------------------------
/model/GradeBeanDBA.java:
--------------------------------------------------------------------------------
 1 | package com.zehua.model;
 2 | 
 3 | import com.zehua.MysqlJDBC;
 4 | 
 5 | import java.util.ArrayList;
 6 | 
 7 | public class GradeBeanDBA {
 8 | 
 9 |     String gradeId = null;
10 |     String gradeName = null;
11 | 
12 |     public void initializeInfo(GradeBean gradeBean){
13 |         gradeId = gradeBean.getGradeId();
14 |         gradeName = gradeBean.getGradeName();
15 |     }
16 | 
17 |     public boolean addItem(GradeBean gradeBean){
18 |         initializeInfo(gradeBean);
19 | 
20 |         String sql = "insert into grade values(?,?)";
21 |         String[] parameters = {gradeId,gradeName};
22 | 
23 |         boolean isSuccess = MysqlJDBC.executeUpdate(sql,parameters);
24 | 
25 |         return isSuccess;
26 | 
27 |     }
28 | 
29 |     public boolean deleteItem(GradeBean gradeBean){
30 |         initializeInfo(gradeBean);
31 | 
32 |         String sql = "delete from grade where gradeId = ? and gradeName = ?";
33 |         String[] parameters = {gradeId,gradeName};
34 | 
35 |         boolean isSuccess = MysqlJDBC.executeUpdate(sql,parameters);
36 | 
37 |         return isSuccess;
38 | 
39 |     }
40 | 
41 |     public boolean modifyItem(GradeBean gradeBean){
42 |         initializeInfo(gradeBean);
43 | 
44 |         String sql = "update grade set gradeName = ? where gradeId = ?";
45 |         String[] parameters = {gradeName,gradeId};
46 | 
47 |         boolean isSuccess = MysqlJDBC.executeUpdate(sql,parameters);
48 | 
49 |         return isSuccess;
50 | 
51 |     }
52 | 
53 |     public ArrayList<GradeBean> findItem(String gradeId){
54 | 
55 |         ArrayList<GradeBean> resultGradeBeans = new ArrayList<GradeBean>();
56 | 
57 |         String sql = "select*from grade where gradeId = ?";
58 |         String[] parameters = {gradeId};
59 | 
60 |         ArrayList<Object>[] resultArray = MysqlJDBC.query(sql,parameters);
61 |         int length = resultArray.length;
62 |         for(int i = 0;i<length;i++){
63 |             ArrayList<Object> arrayList = resultArray[i];
64 | 
65 |             String thisGradeId = arrayList.get(0).toString();
66 |             String thisGradeName = arrayList.get(1).toString();
67 | 
68 |             GradeBean thisGradeBean = new GradeBean(thisGradeId,thisGradeName);
69 |             resultGradeBeans.add(thisGradeBean);
70 | 
71 |         }
72 |         return resultGradeBeans;
73 | 
74 |     }
75 | 
76 | }
77 | 


--------------------------------------------------------------------------------
/model/MajorBeanDBA.java:
--------------------------------------------------------------------------------
 1 | package com.zehua.model;
 2 | 
 3 | import com.zehua.MysqlJDBC;
 4 | 
 5 | import java.util.ArrayList;
 6 | 
 7 | public class MajorBeanDBA {
 8 | 
 9 |     String majorId = null;
10 |     String majorName = null;
11 |     String facultyId = null;
12 | 
13 |     public void initializeInfo(MajorBean majorBean){
14 |         majorId = majorBean.getMajorId();
15 |         majorName = majorBean.getMajorName();
16 |         facultyId = majorBean.getFacultyId();
17 |     }
18 | 
19 |     public ArrayList<MajorBean> findItem(String majorId){
20 | 
21 |         ArrayList<MajorBean> resultMajorBeans = new ArrayList<MajorBean>();
22 | 
23 |         String sql = "select*from major where majorId = ?";
24 |         String[] parameters = {majorId};
25 | 
26 |         ArrayList<Object>[] resultArray = MysqlJDBC.query(sql,parameters);
27 |         int length = resultArray.length;
28 |         for(int i = 0;i<length;i++){
29 |             ArrayList<Object> arrayList = resultArray[i];
30 | 
31 |             String thisMajorId = arrayList.get(0).toString();
32 |             String thisMajorName = arrayList.get(1).toString();
33 |             String thisFacultyId = arrayList.get(2).toString();
34 | 
35 | 
36 |             MajorBean thisMajorBean = new MajorBean(thisMajorId,thisMajorName,thisFacultyId);
37 |             resultMajorBeans.add(thisMajorBean);
38 | 
39 |         }
40 |         return resultMajorBeans;
41 | 
42 |     }
43 | 
44 | }
45 | 


--------------------------------------------------------------------------------
/model/UserBeanDBA.java:
--------------------------------------------------------------------------------
 1 | package com.zehua.model;
 2 | 
 3 | import com.zehua.MysqlJDBC;
 4 | 
 5 | import java.util.ArrayList;
 6 | 
 7 | public class UserBeanDBA {
 8 | 
 9 |     private String username;
10 |     private String password;
11 |     private String id;
12 | 
13 |     public void initializeInfo(UserBean userBean){
14 |         username = userBean.getUsername();
15 |         password = userBean.getPassword();
16 |         id = userBean.getId();
17 |     }
18 | 
19 |     //按用户名，密码查找
20 |     public ArrayList<UserBean> findItemWithNameAndPas(String username, String password){
21 | 
22 |         ArrayList<UserBean> resultUserBeans = new ArrayList<UserBean>();
23 | 
24 |         String sql = "select*from user where username = ? and password = ?";
25 |         String[] parameters = {username,password};
26 | 
27 |         ArrayList<Object>[] resultArray = MysqlJDBC.query(sql,parameters);
28 |         int length = resultArray.length;
29 |         for(int i = 0;i<length;i++){
30 |             ArrayList<Object> arrayList = resultArray[i];
31 | 
32 |             String thisUsername = arrayList.get(0).toString();
33 |             String thisPassword = arrayList.get(1).toString();
34 |             String thisId = arrayList.get(2).toString();
35 | 
36 |             UserBean thisUserBean = new UserBean(thisUsername,thisPassword,thisId);
37 |             resultUserBeans.add(thisUserBean);
38 | 
39 |         }
40 |         return resultUserBeans;
41 | 
42 |     }
43 | 
44 |     //按用户名查找
45 |     public ArrayList<UserBean> findItemWithName(String username){
46 | 
47 |         ArrayList<UserBean> resultUserBeans = new ArrayList<UserBean>();
48 | 
49 |         String sql = "select*from user where username = ?";
50 |         String[] parameters = {username};
51 | 
52 |         ArrayList<Object>[] resultArray = MysqlJDBC.query(sql,parameters);
53 |         int length = resultArray.length;
54 |         for(int i = 0;i<length;i++){
55 |             ArrayList<Object> arrayList = resultArray[i];
56 | 
57 |             String thisUsername = arrayList.get(0).toString();
58 |             String thisPassword = arrayList.get(1).toString();
59 |             String thisId = arrayList.get(2).toString();
60 | 
61 |             UserBean thisUserBean = new UserBean(thisUsername,thisPassword,thisId);
62 |             resultUserBeans.add(thisUserBean);
63 | 
64 |         }
65 |         return resultUserBeans;
66 | 
67 |     }
68 | 
69 | }
70 | 


--------------------------------------------------------------------------------
/model/UserClassBeanDBA.java:
--------------------------------------------------------------------------------
 1 | package com.zehua.model;
 2 | 
 3 | import com.zehua.MysqlJDBC;
 4 | 
 5 | import java.util.ArrayList;
 6 | 
 7 | public class UserClassBeanDBA {
 8 | 
 9 |     private String id;
10 |     private String classId;
11 | 
12 |     public void initializeInfo(UserClassBean userClassBean){
13 |         id = userClassBean.getId();
14 |         classId = userClassBean.getClassId();
15 |     }
16 | 
17 |     public boolean addItem(UserClassBean userClassBean){
18 |         initializeInfo(userClassBean);
19 | 
20 |         String sql = "insert into userClass values (?,?)";
21 |         String[] parameters = {id,classId};
22 | 
23 |         boolean isSuccess = MysqlJDBC.executeUpdate(sql,parameters);
24 | 
25 |         return isSuccess;
26 | 
27 |     }
28 | 
29 |     //删
30 |     public boolean deleteItem(UserClassBean userClassBean){
31 |         initializeInfo(userClassBean);
32 | 
33 |         String sql = "delete from userClass where id = ? and classId = ?";
34 |         String[] parameters = {id,classId};
35 | 
36 |         boolean isSuccess = MysqlJDBC.executeUpdate(sql,parameters);
37 | 
38 |         return isSuccess;
39 |     }
40 | 
41 |     public ArrayList<UserClassBean> findItem(String id){
42 | 
43 |         ArrayList<UserClassBean> resulUserClassBeans = new ArrayList<UserClassBean>();
44 | 
45 |         String sql = "select*from userClass where id = ?";
46 |         String[] parameters = {id};
47 | 
48 |         ArrayList<Object>[] resultArray = MysqlJDBC.query(sql,parameters);
49 |         int length = resultArray.length;
50 |         for(int i = 0;i<length;i++){
51 |             ArrayList<Object> arrayList = resultArray[i];
52 | 
53 |             String thisId = arrayList.get(0).toString();
54 |             String thisClassId = arrayList.get(1).toString();
55 | 
56 |             UserClassBean thisUserClassBean = new UserClassBean(thisId,thisClassId);
57 |             resulUserClassBeans.add(thisUserClassBean);
58 | 
59 |         }
60 |         return resulUserClassBeans;
61 | 
62 |     }
63 | 
64 | }
65 | 


--------------------------------------------------------------------------------
/model/UserInfoConfigBeanDBA.java:
--------------------------------------------------------------------------------
 1 | package com.zehua.model;
 2 | 
 3 | import com.zehua.MysqlJDBC;
 4 | 
 5 | import java.util.ArrayList;
 6 | 
 7 | public class UserInfoConfigBeanDBA {
 8 | 
 9 |     private String id;
10 |     private String gradeId;
11 |     private String facultyId;
12 |     private String majorId;
13 | 
14 |     public void initializeInfo(UserInfoConfigBean userInfoConfigBean){
15 |         id = userInfoConfigBean.getId();
16 |         gradeId = userInfoConfigBean.getGradeId();
17 |         facultyId = userInfoConfigBean.getFacultyId();
18 |         majorId = userInfoConfigBean.getMajorId();
19 |     }
20 | 
21 |     public ArrayList<UserInfoConfigBean> findItem(String id){
22 | 
23 |         ArrayList<UserInfoConfigBean> resultUserInfoConfigBeans = new ArrayList<UserInfoConfigBean>();
24 | 
25 |         String sql = "select*from userInfoConfig where id = ?";
26 |         String[] parameters = {id};
27 | 
28 |         ArrayList<Object>[] resultArray = MysqlJDBC.query(sql,parameters);
29 |         int length = resultArray.length;
30 |         for(int i = 0;i<length;i++){
31 |             ArrayList<Object> arrayList = resultArray[i];
32 | 
33 |             String thisId = arrayList.get(0).toString();
34 |             String thisGradeId = arrayList.get(1).toString();
35 |             String thisFacultyId = arrayList.get(2).toString();
36 |             String thisMajorId = arrayList.get(3).toString();
37 | 
38 |             UserInfoConfigBean thisUserInfoConfigBean =
39 |                     new UserInfoConfigBean(thisId,thisGradeId,thisFacultyId,thisMajorId);
40 |             resultUserInfoConfigBeans.add(thisUserInfoConfigBean);
41 | 
42 |         }
43 |         return resultUserInfoConfigBeans;
44 | 
45 |     }
46 | 
47 | }
48 | 


--------------------------------------------------------------------------------
/model2/NodeBeanDBA.java:
--------------------------------------------------------------------------------
 1 | package com.zehua.model2;
 2 | 
 3 | import com.zehua.Neo4jRestAPI;
 4 | 
 5 | import java.util.Map;
 6 | 
 7 | public class NodeBeanDBA {
 8 | 
 9 |     public void addNode(String nodeType,String[] nodeAttributesName,String[][] nodeAttributesValue){
10 |         for(int index = 0;index<nodeAttributesValue.length;index++){
11 |             String cypher = "";
12 |             StringBuffer stringBuffer = new StringBuffer("");
13 |             stringBuffer.append("merge (:");
14 |             stringBuffer.append(nodeType);//节点类型
15 |             stringBuffer.append("{");//开始添加节点属性
16 |             int i = 0;
17 |             for(i = 0;i<nodeAttributesName.length-1;i++){
18 |                 stringBuffer.append(nodeAttributesName[i]);
19 |                 stringBuffer.append(":");
20 |                 stringBuffer.append("\"");
21 |                 stringBuffer.append(nodeAttributesValue[index][i]);
22 |                 stringBuffer.append("\",");
23 |             }
24 |             //当添加最后一个属性时需要做特殊处理
25 |             stringBuffer.append(nodeAttributesName[i]);
26 |             stringBuffer.append(":");
27 |             stringBuffer.append("\"");
28 |             stringBuffer.append(nodeAttributesValue[index][i]);
29 |             stringBuffer.append("\"");
30 |             stringBuffer.append("})");
31 |             //一条cypher语句拼接完成
32 |             cypher = stringBuffer.toString();
33 |             //执行
34 |             Neo4jRestAPI.executeCypher(cypher);
35 |         }
36 |     }
37 | 
38 |     //这里是针对（sdu.zehuape@qq.com）所写的一个方法,这样的话，形参一个就可以了
39 |     //标准格式match (n:XXX{xxx:"yyy"}) return n;
40 |     public Map<String,String> getNodeAttrs(String nodeType){
41 |         Map<String,String> node_AttrKey_AttrValue_Map = null;
42 | 
43 |         String cypher = "";
44 |         StringBuffer stringBuffer= new StringBuffer();
45 |         stringBuffer.append("match (n:");
46 |         stringBuffer.append(nodeType);
47 |         stringBuffer.append("{");
48 |         stringBuffer.append("名称");
49 |         stringBuffer.append(":");
50 |         stringBuffer.append("\"");
51 |         stringBuffer.append("sdu.zehuape@qq.com");
52 |         stringBuffer.append("\"");
53 |         stringBuffer.append("}) ");
54 |         stringBuffer.append("return n");
55 | 
56 |         cypher = stringBuffer.toString();
57 |         //执行
58 |         node_AttrKey_AttrValue_Map = Neo4jRestAPI.executeFindNodeCypher(cypher);
59 |         return node_AttrKey_AttrValue_Map;
60 |     }
61 | 
62 |     /*
63 |     public void deleteNode(String nodeType,String[] nodeAttributesName,String[] nodeAttributesValue){
64 |         String cypher = "";
65 |         StringBuffer stringBuffer = new StringBuffer("");
66 |         stringBuffer.append("match (n:");
67 |         stringBuffer.append(nodeType);//节点类型
68 |         stringBuffer.append("{");//开始添加节点属性
69 |         int i = 0;
70 |         for(i = 0;i<nodeAttributesName.length-1;i++){
71 |             stringBuffer.append(nodeAttributesName[i]);
72 |             stringBuffer.append(":");
73 |             stringBuffer.append("\"");
74 |             stringBuffer.append(nodeAttributesValue[i]);
75 |             stringBuffer.append("\",");
76 |         }
77 |         //当添加最后一个属性时需要做特殊处理
78 |         stringBuffer.append(nodeAttributesName[i]);
79 |         stringBuffer.append(":");
80 |         stringBuffer.append("\"");
81 |         stringBuffer.append(nodeAttributesValue[i]);
82 |         stringBuffer.append("\"");
83 |         stringBuffer.append("})");
84 |         stringBuffer.append("delete n");
85 |         //一条cypher语句拼接完成
86 |         cypher = stringBuffer.toString();
87 |         //执行
88 |         Neo4jRestAPI.executeCypher(cypher);
89 |     }*/
90 | 
91 | }
92 | 


--------------------------------------------------------------------------------
/model2/RelationshipBeanDBA.java:
--------------------------------------------------------------------------------
  1 | package com.zehua.model2;
  2 | 
  3 | import com.zehua.Neo4jRestAPI;
  4 | import com.zehua.neo4jJava.ToJson;
  5 | import systemInfo.SystemInfo;
  6 | 
  7 | import java.util.ArrayList;
  8 | import java.util.Map;
  9 | 
 10 | public class RelationshipBeanDBA {
 11 | 
 12 |     //标准格式
 13 |     //match (n1:XXX1{yyy1:"xxx1"}),(n2:XXX2{yyy2:"xxx2"})
 14 |     //merge (n1)-[:RRR{sss:"rrr"}]-(n2);
 15 |     public void addRelationship(String fromNodeType,String relType,String toNodeType,String[] someParametersName,String[][] someParapetersValue){
 16 |         for(int index = 0;index<someParapetersValue.length;index++){
 17 |             String cypher = "";
 18 |             StringBuffer stringBuffer = new StringBuffer("");
 19 |             stringBuffer.append("match (n1:");
 20 |             stringBuffer.append(fromNodeType);
 21 |             stringBuffer.append("{");
 22 |             stringBuffer.append(someParametersName[0]);
 23 |             stringBuffer.append(":");
 24 |             stringBuffer.append("\"");
 25 |             stringBuffer.append(someParapetersValue[index][0]);
 26 |             stringBuffer.append("\"");
 27 |             stringBuffer.append("})");
 28 |             stringBuffer.append(",");
 29 |             stringBuffer.append("(n2:");
 30 |             stringBuffer.append(toNodeType);
 31 |             stringBuffer.append("{");
 32 |             stringBuffer.append(someParametersName[2]);
 33 |             stringBuffer.append(":");
 34 |             stringBuffer.append("\"");
 35 |             stringBuffer.append(someParapetersValue[index][2]);
 36 |             stringBuffer.append("\"");
 37 |             stringBuffer.append("}) ");
 38 |             stringBuffer.append("merge (n1)-[:");//开始添加关系
 39 |             stringBuffer.append(relType);
 40 |             stringBuffer.append("{");//开始关系属性的添加
 41 |             stringBuffer.append(someParametersName[1]);
 42 |             stringBuffer.append(":");
 43 |             stringBuffer.append("\"");
 44 |             stringBuffer.append(someParapetersValue[index][1]);
 45 |             stringBuffer.append("\"");
 46 |             //因为添加关系时，关系必须有一个属性，
 47 |             //所以，下面的循环是添加关系其他的属性（如果有的话）
 48 |             for(int i = 3;i<someParametersName.length;i++){
 49 |                 stringBuffer.append(",");
 50 |                 stringBuffer.append(someParametersName[i]);
 51 |                 stringBuffer.append(":");
 52 |                 stringBuffer.append("\"");
 53 |                 stringBuffer.append(someParapetersValue[index][i]);
 54 |                 stringBuffer.append("\"");
 55 |             }
 56 |             stringBuffer.append("}]-(n2)");
 57 |             //得到cypher语句
 58 |             cypher = stringBuffer.toString();
 59 |             System.out.println(cypher);
 60 |             //执行
 61 |             Neo4jRestAPI.executeCypher(cypher);
 62 |         }
 63 |     }
 64 |     //这里是针对（sdu.zehuape@qq.com）所写的一个方法,这样的话，形参一个就可以了
 65 |     public Map<String,String> getRelAttrs(String relType){
 66 |         Map<String,String> relation_AttrKey_AttrValue_Map = null;
 67 | 
 68 |         String cypher = "";
 69 |         StringBuffer stringBuffer= new StringBuffer();
 70 |         stringBuffer.append("match ()-");
 71 |         stringBuffer.append("[r:");
 72 |         stringBuffer.append(relType);
 73 |         stringBuffer.append("{");
 74 |         stringBuffer.append("name:");
 75 |         stringBuffer.append("\"");
 76 |         stringBuffer.append("sdu.zehuape@qq.com");
 77 |         stringBuffer.append("\"");
 78 |         stringBuffer.append("}");
 79 |         stringBuffer.append("]");
 80 |         stringBuffer.append("-() ");
 81 |         stringBuffer.append("return r");
 82 | 
 83 |         cypher = stringBuffer.toString();
 84 | 
 85 |         System.out.println(cypher);
 86 |         //执行
 87 |         relation_AttrKey_AttrValue_Map = Neo4jRestAPI.executeFindRelAttrCypher(cypher);
 88 |         return relation_AttrKey_AttrValue_Map;
 89 |     }
 90 |     //写入json文件,查找
 91 |     public String lookInto(String nodeType, String nodeName){
 92 |         String cypher = "";
 93 | 
 94 |         if(nodeName==null||nodeName==""){
 95 |             StringBuffer stringBuffer1 = new StringBuffer("");
 96 |             stringBuffer1.append("match p=(:");
 97 |             stringBuffer1.append(nodeType);
 98 |             stringBuffer1.append(")");
 99 |             stringBuffer1.append("-[*..1]-() return p");
100 | 
101 |             cypher = stringBuffer1.toString();
102 |         }else{
103 |             StringBuffer stringBuffer2 = new StringBuffer("");
104 |             stringBuffer2.append("match p=(:");
105 |             stringBuffer2.append(nodeType);
106 |             stringBuffer2.append("{");
107 |             stringBuffer2.append("名称:");
108 |             stringBuffer2.append("\"");
109 |             stringBuffer2.append(nodeName);
110 |             stringBuffer2.append("\"");
111 |             stringBuffer2.append("}");
112 |             stringBuffer2.append(")");
113 |             stringBuffer2.append("-[*..1]-() return p");
114 | 
115 |             cypher = stringBuffer2.toString();
116 | 
117 |             //先清空，再将cypher语句加入到SystemInfo中
118 | 
119 |         }
120 |         SystemInfo.clearAll();
121 |         SystemInfo.addCypher(cypher);
122 | //System.out.println(cypher);
123 | 
124 | 
125 |         StringBuffer relationBuffer = Neo4jRestAPI.executeFindRelationCypher(cypher);
126 |         StringBuffer relationNodesBuffer = Neo4jRestAPI.executeFindRelationNodesCypher(cypher);
127 |         ToJson toJson = new ToJson(relationNodesBuffer,relationBuffer);
128 |         //toJson.writeJson();
129 | //System.out.println(toJson.getJson());
130 | 
131 |         return toJson.getJson();
132 |     }
133 |     //针对的是多条查询语句
134 |     public String lookIntos(ArrayList<String> cypherArrayList){
135 |         String cypher = "";
136 | 
137 |         StringBuffer relationBuffer = Neo4jRestAPI.executeFindRelationCyphers(cypherArrayList);
138 |         StringBuffer relationNodesBuffer = Neo4jRestAPI.executeFindRelationNodesCyphers(cypherArrayList);
139 |         ToJson toJson = new ToJson(relationNodesBuffer,relationBuffer);
140 | 
141 |         //toJson.writeJson();
142 | 
143 |         return toJson.getJson();
144 |     }
145 | 
146 | }
147 | 


--------------------------------------------------------------------------------
/preparations/GetNodes.java:
--------------------------------------------------------------------------------
 1 | package com.zehua.neo4jJava;
 2 | 
 3 | import org.neo4j.driver.v1.*;
 4 | import org.neo4j.driver.v1.types.Node;
 5 | 
 6 | import java.util.HashMap;
 7 | import java.util.Iterator;
 8 | import java.util.List;
 9 | import java.util.Map;
10 | 
11 | public class GetNodes {
12 | 
13 |     static Driver driver = null;
14 | 
15 |     public static void getDriver(){
16 |         String uri = "Bolt://localhost:7687";
17 |         String user = "";//写你自己的neo4j的用户名
18 |         String password = "";//写你自己的neo4j的密码
19 |         driver = GraphDatabase.driver(uri, AuthTokens.basic(user,password));
20 |     }
21 | 
22 |     public static void close(){
23 |         if(driver!=null){
24 |             driver.close();
25 |         }
26 |     }
27 | 
28 |     //node
29 |     public static void getNodesInfo(String cypher){
30 |         getDriver();
31 | 
32 |         Map<String,String> node_AttrKey_AttrValue_Map = new HashMap<>();
33 | 
34 |         try(Session session = driver.session()){
35 |             StatementResult result = session.run(cypher);
36 | 
37 |             while(result.hasNext()){
38 |                 Record record = result.next();
39 |                 List<Value> value = record.values();
40 | 
41 |                 for(Value i:value){
42 |                     Node node = i.asNode();
43 |                     Iterator keys = node.keys().iterator();
44 | 
45 |                     Iterator nodeTypes = node.labels().iterator();
46 |                     String nodeType = nodeTypes.next().toString();
47 |                     System.out.println("节点类型："+nodeType);
48 |                     System.out.println("节点属性如下：");
49 |                     while(keys.hasNext()){
50 |                         String attrKey = (String)keys.next();
51 |                         String attrValue = node.get(attrKey).asString();
52 |                         System.out.println(attrKey+"-------"+attrValue);
53 |                     }
54 |                     System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
55 |                 }
56 |             }
57 |         }
58 |         close();
59 |     }
60 | 
61 |     public static void main(String... args){
62 | 
63 |         String cypher = "match (n:数据库章节{名称:'关系数据库'}) return n";
64 |         getNodesInfo(cypher);
65 | 
66 |     }
67 | 
68 | }
69 | 


--------------------------------------------------------------------------------
/preparations/GetPaths.java:
--------------------------------------------------------------------------------
 1 | package com.zehua.neo4jJava;
 2 | 
 3 | import org.neo4j.driver.v1.*;
 4 | import org.neo4j.driver.v1.types.Path;
 5 | import org.neo4j.driver.v1.types.Relationship;
 6 | 
 7 | import java.util.Iterator;
 8 | import java.util.List;
 9 | 
10 | public class GetPaths {
11 | 
12 |     static Driver driver = null;
13 | 
14 |     public static void getDriver(){
15 |         String uri = "Bolt://localhost:7687";
16 |         String user = "";//写你自己的neo4j的用户名
17 |         String password = "";//写你自己的neo4j的密码
18 |         driver = GraphDatabase.driver(uri, AuthTokens.basic(user,password));
19 |     }
20 | 
21 |     public static void close(){
22 |         if(driver!=null){
23 |             driver.close();
24 |         }
25 |     }
26 | 
27 |     public static void getPathsInfo(String cypher){
28 |         getDriver();
29 | 
30 |         int count = 0;
31 |         try(Session session = driver.session()){
32 |             //result包含了所有的path
33 |             StatementResult result = session.run(cypher);
34 | 
35 |             while(result.hasNext()){
36 |                 Record record = result.next();
37 |                 List<Value> value = record.values();
38 | 
39 |                 for(Value i:value){
40 |                     Path path = i.asPath();
41 |                     //处理路径中的关系
42 |                     Iterator<Relationship> relationships = path.relationships().iterator();
43 | 
44 |                     //Iterator<Node> nodes = path.nodes().iterator();//得到path中的节点
45 | 
46 |                     while(relationships.hasNext()){
47 |                         count++;
48 |                         Relationship relationship = relationships.next();
49 | 
50 |                         long startNodeId = relationship.startNodeId();
51 |                         long endNodeId = relationship.endNodeId();
52 |                         String relType = relationship.type();
53 | 
54 |                         System.out.println("关系"+count+"： ");
55 |                         System.out.println("关系类型："+relType);
56 |                         System.out.println("from "+startNodeId+"-----"+"to "+endNodeId);
57 | 
58 |                         System.out.println("关系属性如下：");
59 | 
60 |                         //得到关系属性的健
61 |                         Iterator<String> relKeys = relationship.keys().iterator();
62 |                         //这里处理关系属性
63 |                         while(relKeys.hasNext()){
64 |                             String relKey = relKeys.next();
65 |                             String relValue = relationship.get(relKey).asObject().toString();
66 |                             System.out.println(relKey+"-----"+relValue);
67 |                         }
68 |                         System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
69 |                     }
70 |                 }
71 |             }
72 |         }
73 |         close();
74 |     }
75 | 
76 |     public static void main(String... args){
77 | 
78 |         String cypher = "match p=shortestPath((n1:数据库课程{名称:'数据库'})-[*..6]-(n2:数据库知识点{名称:'概念结构设计'})) return p";
79 |         getPathsInfo(cypher);
80 |     }
81 | 
82 | }
83 | 


--------------------------------------------------------------------------------
/preparations/JsonFormat.java:
--------------------------------------------------------------------------------
  1 | package com.zehua.neo4jJava;
  2 | 
  3 | import org.neo4j.driver.v1.*;
  4 | import org.neo4j.driver.v1.types.Node;
  5 | import org.neo4j.driver.v1.types.Path;
  6 | import org.neo4j.driver.v1.types.Relationship;
  7 | 
  8 | import java.util.*;
  9 | 
 10 | public class JsonFormat {
 11 | 
 12 |     static Driver driver = null;
 13 | 
 14 |     public static void getDriver(){
 15 |         String uri = "Bolt://localhost:7687";
 16 |         String user = "";//写你自己的neo4j的用户名
 17 |         String password = "";//写你自己的neo4j的密码
 18 |         driver = GraphDatabase.driver(uri, AuthTokens.basic(user,password));
 19 |     }
 20 | 
 21 |     public static void close(){
 22 |         if(driver!=null){
 23 |             driver.close();
 24 |         }
 25 |     }
 26 | 
 27 |     //返回关系的StringBuffer，为可视化做准备！json文件
 28 |     public static StringBuffer executeFindRelationCypher(String cypher){
 29 |         //关系的StringBuffer,json格式
 30 |         StringBuffer relationBuffer = new StringBuffer("");
 31 |         relationBuffer.append("\"links\":[");//return "links":[
 32 |         getDriver();
 33 | 
 34 |         try(Session session = driver.session()){
 35 |             //result包含了所有的path
 36 |             StatementResult result = session.run(cypher);
 37 | 
 38 |             while(result.hasNext()){
 39 |                 Record record = result.next();
 40 |                 List<Value> value = record.values();
 41 | 
 42 |                 for(Value i:value){
 43 |                     Path path = i.asPath();
 44 |                     Iterator<Relationship> relationships = path.relationships().iterator();
 45 | 
 46 |                     while(relationships.hasNext()){
 47 |                         Relationship relationship = relationships.next();
 48 | 
 49 |                         long startNodeId = relationship.startNodeId();
 50 |                         long endNodeId = relationship.endNodeId();
 51 |                         String relType = relationship.type();
 52 | 
 53 |                         //得到关系属性的健
 54 |                         Iterator<String> relKeys = relationship.keys().iterator();
 55 | 
 56 |                         relationBuffer.append("{");
 57 |                         relationBuffer.append("\"source\":");
 58 |                         relationBuffer.append(startNodeId);
 59 |                         relationBuffer.append(",");
 60 |                         relationBuffer.append("\"target\":");
 61 |                         relationBuffer.append(endNodeId);
 62 |                         relationBuffer.append(",");
 63 |                         relationBuffer.append("\"type\":");
 64 |                         relationBuffer.append("\""+relType+"\"");
 65 | 
 66 |                         //这里处理关系属性
 67 |                         while(relKeys.hasNext()){
 68 |                             String relKey = relKeys.next();
 69 |                             String relValue = relationship.get(relKey).asObject().toString();
 70 | 
 71 |                             //去除制表符
 72 |                             relValue = relValue.replaceAll("\t","");
 73 |                             //去除换行符
 74 |                             relValue= relValue.replaceAll("\r","");
 75 |                             //去除回车符
 76 |                             relValue = relValue.replaceAll("\n","");
 77 | 
 78 |                             //将双引号换成单引号
 79 |                             relValue = relValue.replaceAll("\"","'");
 80 | 
 81 |                             relationBuffer.append(",");
 82 |                             relationBuffer.append("\""+relKey+"\"");
 83 |                             relationBuffer.append(":");
 84 |                             relationBuffer.append("\""+relValue+"\"");
 85 |                         }
 86 |                         if(!relationships.hasNext()&&!result.hasNext()){
 87 |                             relationBuffer.append("}");
 88 |                         }
 89 |                         else {
 90 |                             //如果是最后一个，只需要添加}即可
 91 |                             relationBuffer.append("},");
 92 |                         }
 93 | 
 94 |                     }
 95 |                 }
 96 |             }
 97 |         }
 98 |         relationBuffer.append("]");
 99 |         close();
100 |         return relationBuffer;
101 |     }
102 | 
103 |     //返回关系中节点的StringBuffer，为可视化做准备！json文件,需要增加节点的类型
104 |     public static StringBuffer executeFindRelationNodesCypher(String cypher) {
105 |         //用一个set集合去除重复项
106 |         Set nodeSet = new HashSet();
107 |         StringBuffer relationNodesBuffer = new StringBuffer("");
108 |         relationNodesBuffer.append("\"nodes\":[");
109 |         getDriver();
110 | 
111 |         try(Session session = driver.session()){
112 |             StatementResult result = session.run(cypher);
113 | 
114 |             while(result.hasNext()){
115 |                 Record record = result.next();
116 |                 List<Value> value = record.values();
117 | 
118 |                 for(Value i:value){
119 | 
120 |                     Path path = i.asPath();
121 |                     Iterator<Node> nodes = path.nodes().iterator();
122 | 
123 |                     while(nodes.hasNext()){
124 |                         Node node = nodes.next();
125 |                         //在增加节点以前，先判断是否在集合中
126 |                         boolean isExist = nodeSet.contains(node.id());
127 |                         if (isExist) continue;
128 |                         Iterator<String> nodeKeys = node.keys().iterator();
129 |                         relationNodesBuffer.append("{");
130 | 
131 |                         //节点属性
132 |                         while(nodeKeys.hasNext()){
133 |                             String nodeKey = nodeKeys.next();
134 |                             relationNodesBuffer.append("\""+nodeKey+"\":");
135 |                             //node.get(nodeKey).toString();
136 |                             //System.out.println(node.get(nodeKey).asObject().toString());
137 |                             String content = node.get(nodeKey).asObject().toString();
138 | 
139 |                             //去除制表符
140 |                             content = content.replaceAll("\t","");
141 |                             //去除换行符
142 |                             content = content.replaceAll("\r","");
143 |                             //去除回车符
144 |                             content = content.replaceAll("\n","");
145 | 
146 |                             //将双引号换成单引号
147 |                             content = content.replaceAll("\"","'");
148 | 
149 |                             relationNodesBuffer.append("\""+content+"\",");
150 |                         }
151 |                         relationNodesBuffer.append("\"id\":");
152 |                         relationNodesBuffer.append(node.id());
153 |                         //添加节点类型！不知道为什么取得节点类型用的是labels，可能一个节点可以属于多个类别
154 |                         //但是我们这里只属于一个类别！
155 |                         Iterator<String> nodeTypes = node.labels().iterator();
156 |                         //得到节点类型了！
157 |                         String nodeType = nodeTypes.next();
158 | 
159 |                         relationNodesBuffer.append(",");
160 |                         relationNodesBuffer.append("\"type\":");
161 |                         relationNodesBuffer.append("\""+nodeType+"\"");
162 | 
163 |                         //将节点添加到set集合中
164 |                         nodeSet.add(node.id());
165 | 
166 |                         if(!nodes.hasNext()&&!result.hasNext()){
167 |                             relationNodesBuffer.append("}");
168 |                         }
169 |                         else{
170 |                             relationNodesBuffer.append("},");
171 |                         }
172 |                     }
173 |                 }
174 |             }
175 |         }
176 |         int bufferLength = relationNodesBuffer.length();
177 |         char lastChar = relationNodesBuffer.charAt(bufferLength-1);
178 |         if(lastChar==','){
179 |             String str = relationNodesBuffer.substring(0,relationNodesBuffer.length()-1);
180 |             relationNodesBuffer = relationNodesBuffer.replace(0,bufferLength,str);
181 |         }
182 |         relationNodesBuffer.append("]");
183 |         close();
184 |         return  relationNodesBuffer;
185 |     }
186 | 
187 |     public static void main(String... args){
188 | 
189 |         String cypher = "match p=(:数据库课程)-[*..1]-() return p";
190 | 
191 |         StringBuffer relationBuffer = executeFindRelationCypher(cypher);
192 |         StringBuffer relationNodesBuffer = executeFindRelationNodesCypher(cypher);
193 |         ToJson toJson = new ToJson(relationNodesBuffer,relationBuffer);
194 | 
195 |         toJson.writeJson();
196 | 
197 |     }
198 | 
199 | }
200 | 


--------------------------------------------------------------------------------
/preparations/displayInWeb.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <!--draw the graph completely-->
  3 | <html lang="en">
  4 | <head>
  5 |     <meta charset="UTF-8">
  6 |     <title>Title</title>
  7 |     <!--import d3 version 5-->
  8 |     <script type="text/javascript" src="js/d3.min.js"></script>
  9 |     <!--import jquery3.3.1-->
 10 |     <script type="text/javascript" src="js/jquery-3.3.1.min.js"></script>
 11 | </head>
 12 | <body>
 13 |     <svg></svg>
 14 |     <script>
 15 |         //get json file
 16 |         d3.json("data.json").then(function(dataJson){
 17 |             //GroupExplorer constructing function
 18 |             //this is one way to create a javascript object
 19 |             function GroupExplorer(data){
 20 |                 //create an object-include some data
 21 |                 //this is an another way to create a javascript object
 22 |                 var defaultConfig = {
 23 |                     data:{"nodes":[],"links":[]},//critical data set
 24 |                     windowWidth:window.innerWidth,
 25 |                     windowHeight:window.innerHeight,
 26 |                     defaultLinkDistance:150
 27 |                 }
 28 |                 //because the initial "data" is null,
 29 |                 //so you need use jquery syntax "extend" to merge the json data
 30 |                 //below,merge "data" into "defaultWindow"
 31 |                 //"true" mean do not cover
 32 |                 //details see jquery API document
 33 |                 $.extend(true,defaultConfig,data);
 34 | 
 35 |                 //so now we get the json file that we need
 36 |                 //now let`s begin,transform json file to force graph data
 37 |                 //but first ,we need to get "svg"
 38 |                 var svg = d3.select("svg");
 39 |                 svg.attr("width",defaultConfig.windowWidth);
 40 |                 svg.attr("height",defaultConfig.windowHeight);
 41 | 
 42 |                 defaultConfig.data.links.forEach(function(e){
 43 |                     if(typeof e.source=="number"&&typeof e.target=="number"){
 44 |                         var sourceNode = defaultConfig.data.nodes.filter(function(n){
 45 |                             return n.id === e.source;
 46 |                         })[0];
 47 |                         var targetNode = defaultConfig.data.nodes.filter(function(n){
 48 |                             return n.id === e.target;
 49 |                         })[0];
 50 |                         e.source = sourceNode;
 51 |                         e.target = targetNode;
 52 |                     }
 53 |                 });
 54 | 
 55 |                 //create a force graph
 56 |                 var forceSimulation = d3.forceSimulation()
 57 |                     .force("link",d3.forceLink())
 58 |                     .force("charge",d3.forceManyBody())
 59 |                     .force("center",d3.forceCenter(defaultConfig.windowWidth/2,defaultConfig.windowHeight/2));
 60 | 
 61 |                 //transform nodes data
 62 |                 forceSimulation.nodes(defaultConfig.data.nodes)
 63 |                     .on("tick",ticked);
 64 |                 //tranform links data
 65 |                 forceSimulation.force("link")
 66 |                     .links(defaultConfig.data.links)
 67 |                     .distance(defaultConfig.defaultLinkDistance);
 68 | 
 69 |                 console.log(defaultConfig.data.nodes);
 70 |                 console.log(defaultConfig.data.links);
 71 | 
 72 |                 //define arrow
 73 |                 svg.append("svg:defs")
 74 |                     .append("svg:marker")
 75 |                     .attr("id", "marker")
 76 |                     .attr('viewBox', '0 -5 10 10')
 77 |                     .attr("refX", 20)
 78 |                     .attr("refY",0)
 79 |                     .attr('markerWidth', 10)
 80 |                     .attr('markerHeight', 10)
 81 |                     .attr('orient', 'auto')
 82 |                     .append('svg:path')
 83 |                     .attr('d', 'M0,-5L10,0L0,5')
 84 |                     .attr("fill","brown");
 85 |                 //draw links
 86 |                 var links = svg.append("g")
 87 |                     .selectAll("line")
 88 |                     .data(defaultConfig.data.links)
 89 |                     .enter()
 90 |                     .append("line")
 91 |                     .attr("x1",function(n){return n.source.x})
 92 |                     .attr("y1",function(n){return n.source.y})
 93 |                     .attr("x2",function(n){return n.target.x})
 94 |                     .attr("y2",function(n){return n.target.y})
 95 |                     .attr("stroke","brown")
 96 |                     .attr("stroke-width",1)
 97 |                     .attr("marker-end","url(#marker)");
 98 |                 //draw links-text
 99 |                 var links_text = svg.append("g")
100 |                     .selectAll("text")
101 |                     .data(defaultConfig.data.links)
102 |                     .enter()
103 |                     .append("text")
104 |                     .attr("x",function(e){
105 |                         return (e.source.x+e.target.x)/2;
106 |                     })
107 |                     .attr("y",function(e){
108 |                         console.log(e.source.y+"+"+e.target.y)
109 |                         return (e.source.y+e.target.y)/2;
110 |                     })
111 |                     .attr("font-size",10)
112 |                     .text(function(e){return e.type});
113 |                 //draw nodes group = node+node-text
114 |                 var nodes_g = svg.append("g")
115 |                     .selectAll("g")
116 |                     .data(defaultConfig.data.nodes)
117 |                     .enter()
118 |                     .append("g")
119 |                     .attr("transform",function(e){
120 |                         return "translate("+e.x+","+e.y+")";
121 |                     })
122 |                     .call(d3.drag()
123 |                         .on("start",started)
124 |                         .on("drag",dragged)
125 |                         .on("end",ended));
126 |                 //draw nodes
127 |                 nodes_g.append("circle")
128 |                     .attr("r",10)
129 |                     .attr("fill","blue");
130 |                 //draw node-text
131 |                 nodes_g.append("text")
132 |                     .attr("x",-15)
133 |                     .attr("y",20)
134 |                     .attr("font-size",10)
135 |                     .text(function(e){return e.name});
136 | 
137 |                 function started(d){
138 |                     if(!d3.event.active){
139 |                         forceSimulation.alphaTarget(0.8).restart();
140 |                     }
141 |                     d.fx = d.x;
142 |                     d.fy = d.y;
143 |                 }
144 |                 function dragged(d){
145 |                     d.fx = d3.event.x;
146 |                     d.fy = d3.event.y;
147 |                 }
148 |                 function ended(d) {
149 |                     if(!d3.event.active){
150 |                         forceSimulation.alphaTarget(0);
151 |                     }
152 |                     d.fx = null;
153 |                     d.fy = null;
154 |                 }
155 | 
156 |                 function ticked(){
157 |                     links
158 |                         .attr("x1",function(n){return n.source.x})
159 |                         .attr("y1",function(n){return n.source.y})
160 |                         .attr("x2",function(n){return n.target.x})
161 |                         .attr("y2",function(n){return n.target.y})
162 |                     links_text
163 |                         .attr("x",function(e){
164 |                             return (e.source.x+e.target.x)/2;
165 |                         })
166 |                         .attr("y",function(e){
167 |                             return (e.source.y+e.target.y)/2;
168 |                         })
169 |                     nodes_g
170 |                         .attr("transform",function(e){
171 |                             return "translate("+e.x+","+e.y+")";
172 |                         })
173 |                 }
174 | 
175 |             }
176 |             //because in the way of creating a javascript object,
177 |             //you need to use "new" to use it
178 |             new GroupExplorer({data:dataJson});
179 |         })
180 |     </script>
181 | </body>
182 | </html>
183 | 


--------------------------------------------------------------------------------
/preparations/increaseAndDecrease.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |     <title>Title</title>
 5 |     <meta charset="utf-8">
 6 |     <link rel="stylesheet" href="css/myStyle.css">
 7 | 
 8 |     <script type="text/javascript" src="js/jquery-3.3.1.min.js"></script>
 9 | </head>
10 | <body>
11 |     <script type="text/javascript">
12 |         $(document).ready(function(){
13 |             <!--增加列-->
14 |             $(".colAdd").click(function(){
15 |                 var str = "<td class='col'><textarea ></textarea></td>"
16 |                 $(".tr").append(str);
17 |             });
18 |             <!--减少列-->
19 |             $(".colMinus").click(function(){
20 |                 var table = document.getElementById("table");
21 |                 var rowsLength  = table.rows.length;
22 |                 var colsLength = table.rows[0].cells.length;
23 |                 for(var i = 0;i<rowsLength;i++){
24 |                     var index = -1-(rowsLength-1-i)*colsLength;
25 |                     //移除最后一列元素，，
26 |                     // 因为这里是选种全部的col，而不是每一个tr下的col
27 |                     $(".col").eq(index).remove();
28 |                 }
29 |             });
30 |             <!--增加行-->
31 |             $(".rowAdd").click(function(){
32 |                 var table = document.getElementById("table");
33 |                 var colsLength = table.rows[0].cells.length;
34 | 
35 |                 var subStr1 = "<tr class=\"tr\">"
36 |                 var subStr2 = "";
37 |                 for(var i = 1;i<=colsLength;i++){
38 |                     var subStr2_str = "<td class='col'><textarea></textarea></td>";
39 |                     subStr2 += subStr2_str;
40 |                 }
41 |                 var subStr3 = "</tr>"
42 |                 var str = subStr1+subStr2+subStr3;
43 |                 $(".table").append(str);
44 |             });
45 |             <!--减少行-->
46 |             $(".rowMinus").click(function(){
47 |                 <!--jquery语法，移除匹配元素中的最后一个元素-->
48 |                 $(".tr").eq(-1).remove();
49 |             });
50 |         });
51 |     </script>
52 | 
53 |     <table border="0" width="100%" align="center">
54 |         <tr align="center">
55 |             <td width="25%"><button class="colAdd" type="button">列+1</button></td>
56 |             <td width="25%"><button class="colMinus" type="button">列-1</button></td>
57 |             <td width="25%"><button class="rowAdd" type="button">行+1</button></td>
58 |             <td width="25%"><button class="rowMinus" type="button">行-1</button></td>
59 |         </tr>
60 |     </table>
61 |     <br>
62 |     <table width="80%" border="1"  align="center" class="table" id="table">
63 |         <tbody>
64 |         <tr class="tr" align="center">
65 |             <td class='col'><textarea></textarea></td>
66 |             <td class='col'><textarea></textarea></td>
67 |         </tr>
68 |         <tr class="tr" align="center">
69 |             <td class='col'><textarea></textarea></td>
70 |             <td class='col'><textarea></textarea></td>
71 |         </tr>
72 |         </tbody>
73 |     </table>
74 |     <br>
75 |     <table width="50%" border="0"  align="center" class="">
76 |         <tbody>
77 |         <tr align="center">
78 |             <td width="50%"><button type="reset" >重置</button></td>
79 |             <td width="50%"><button type="button" onclick="onSubmit()">提交</button></td>
80 |         </tr>
81 |         </tbody>
82 |     </table>
83 | </body>
84 | </html>
85 | 


--------------------------------------------------------------------------------
/preparations/myStyle.css:
--------------------------------------------------------------------------------
 1 | textarea{
 2 |     font-size: 20px;
 3 |     border-bottom: hidden;
 4 |     border-top: hidden;
 5 |     border-left: hidden;
 6 |     border-right: hidden;
 7 |     width: 100%;
 8 | }
 9 | 
10 | .layui-form-select dl dd, .layui-form-select dl dt{
11 |     background-color: #01AAED;
12 | }
13 | 


--------------------------------------------------------------------------------
/showUserInfoConfig.jsp:
--------------------------------------------------------------------------------
  1 | <%@ page import="com.zehua.admin.AdminInfo" %><%--
  2 |   Created by IntelliJ IDEA.
  3 |   User: 29306
  4 |   Date: 2018/6/6
  5 |   Time: 19:06
  6 |   To change this template use File | Settings | File Templates.
  7 | --%>
  8 | <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  9 | <html>
 10 | <head>
 11 |     <meta charset="utf-8">
 12 |     <title>Title</title>
 13 | 
 14 |     <link rel="stylesheet" href="layui/css/layui.css">
 15 | 
 16 |     <!--import d3 version 5-->
 17 |     <script type="text/javascript" src="js/d3.min.js"></script>
 18 |     <!--import jquery3.3.1-->
 19 |     <script type="text/javascript" src="js/jquery-3.3.1.min.js"></script>
 20 | 
 21 |     <script type="text/javascript" src="layui/layui.js"></script>
 22 | </head>
 23 | <body>
 24 | 
 25 | <%
 26 |     String username = AdminInfo.getUsername();
 27 |     String id = AdminInfo.getId();
 28 |     String gradName = AdminInfo.getGradeName();
 29 |     String facultyName = AdminInfo.getFacultyName();
 30 |     String majorName = AdminInfo.getMajorName();
 31 | 
 32 |     //得到课程集合
 33 |     String[] classTypeArray = AdminInfo.getClassTypeArray();
 34 | 
 35 | %>
 36 | 
 37 | <table width="100%" height="100%">
 38 |     <tr align="center">
 39 |         <td width="25%"></td>
 40 |         <td width="50%" style="background-color: burlywood;vertical-align: middle">
 41 |             <!--显示-->
 42 |             <h1>你的基本信息页面</h1>
 43 |             <hr>
 44 |             <br>
 45 |             <br>
 46 |             <br>
 47 |             姓名：<%=username %><br>
 48 |             编号：<%=id %><br>
 49 |             年级：<%=gradName %><br>
 50 |             学院：<%=facultyName %><br>
 51 |             专业：<%=majorName %><br>
 52 |             <br>
 53 |             <br>
 54 |             <br>
 55 |             <hr>
 56 |             <br>
 57 |             <br>
 58 |             <table>
 59 |                 <tbody>
 60 |                 <%
 61 |                     for(int i = 0;i<classTypeArray.length;i++){
 62 |                 %>
 63 |                 <tr>
 64 |                     <td width="50%"><%=classTypeArray[i] %></td>
 65 |                     <!--button的type属性很重要-->
 66 |                     <td width="50%">
 67 |                         <form class="layui-form">
 68 |                             <div class="layui-form-item">
 69 |                                 <div class="layui-inline">
 70 |                                     <div class="layui-input-inline">
 71 |                                         <select>
 72 |                                             <%
 73 |                                                 String[] classType_subArray = AdminInfo.getClassType_subArray(classTypeArray[i]);
 74 |                                                 for(int j = 0;j<classType_subArray.length;j++){
 75 |                                             %>
 76 |                                             <option value="<%=classType_subArray[j] %>"><%=classType_subArray[j] %></option>
 77 |                                             <%
 78 |                                                 }
 79 |                                             %>
 80 |                                         </select>
 81 |                                     </div>
 82 |                                 </div>
 83 |                             </div>
 84 |                         </form>
 85 |                     </td>
 86 |                 </tr>
 87 |                 <%
 88 |                     }
 89 |                 %>
 90 |                 <tr align="center">
 91 |                     <td colspan="3">
 92 |                         <button class="layui-btn layui-btn-lg addClass">添加课程</button>
 93 |                     </td>
 94 |                 </tbody>
 95 |             </table>
 96 | 
 97 |         </td>
 98 |         <td width="25%"></td>
 99 |     </tr>
100 | </table>
101 | 
102 | <script type="text/javascript">
103 |     $(".addClass").click(function () {
104 |         window.location.href = "addClassUserInfo.jsp";
105 |     })
106 | 
107 | </script>
108 | 
109 | <script>
110 |     layui.use(['form', 'layedit', 'laydate'], function(){
111 |         var form = layui.form
112 |             ,layer = layui.layer
113 |     });
114 | </script>
115 | 
116 | </body>
117 | </html>
118 | 


--------------------------------------------------------------------------------
/systemInfo/SystemInfo.java:
--------------------------------------------------------------------------------
 1 | package systemInfo;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.HashMap;
 5 | import java.util.Map;
 6 | import java.util.Set;
 7 | 
 8 | //1、这个类包含用户某一系列操作查询的所有语句（即用户双击了节点）
 9 | //而当用户重新输入数据时，该类将重新保存用户的查询产生的查询语句！
10 | //2、这个类还包含一个颜色数组color[5]
11 | // （数组大小为5 已经足够！因为可能展现给用户的节点类别不超过5）
12 | //展现的不同的节点类用不同的颜色
13 | //3、包含一个节点-颜色的对应关系
14 | public class SystemInfo {
15 | 
16 |     //用于保存每次用户点击“查询”后的所有查询语句，用于实现“双击”节点后弹出下一层
17 |     public static ArrayList<String> cypherArrayList = new ArrayList<>();
18 |     //默认为5种颜色
19 |     public static final String[] COLOR = {"blue","yellow","green","pink","purple"};
20 |     //将一种颜色和一种类型的节点对应起来
21 |     public static Map nodeType_Color = new HashMap();
22 | 
23 |     //添加cypher语句
24 |     public static void addCypher(String... cyphers){
25 |         int length = cyphers.length;
26 | 
27 |         for(int i = 0;i<length;i++){
28 |             String cypher = cyphers[i];
29 |             cypherArrayList.add(cypher);
30 |         }
31 |     }
32 |     //返回保存的cypher语句
33 |     public static ArrayList<String> getCypherArrayList(){
34 |         return cypherArrayList;
35 |     }
36 |     //清空所有
37 |     public static void clearAll(){
38 |         cypherArrayList.clear();
39 |         nodeType_Color.clear();
40 |     }
41 |     //返回颜色数组
42 |     public static String[] getColor(){
43 |         return COLOR;
44 |     }
45 |     //添加节点和颜色的映射
46 |     public static void addNodeType_Color(String nodeType,String color){
47 |         nodeType_Color.put(nodeType,color);
48 |     }
49 |     //返回节点和颜色的映射
50 |     public static Map<String,String> getNodeType_Color(){
51 |         return nodeType_Color;
52 |     }
53 |     //返回已经分配颜色的节点集合
54 |     public static Set<String> getNodeTypeKeys(){
55 |         return nodeType_Color.keySet();
56 |     }
57 | 
58 | }
59 | 


--------------------------------------------------------------------------------