软件工程二人组队开发第一周

小组成员：高达，程超然

项目名称：地铁站搭乘系统

项目目的：能使用户搭乘到最优路线

环境：Mysql（8.0）和Eclipse（jdk1.8）

我的工作是写除了servlet的java代码，使用控制台实现我们想要的功能：输出最优路线。

项目经历了四次重构，形成了最终版。蓝色的那个是最终版，重构主要是想法的改变和方法的改变。

第一个是数据库俩个表：站点表存贮所有站点和他们所在的线路，但是转站点的所在路线设为-1（特别区分）

有六种情况：1.无转站点，俩点在一条线路路  2.无转站点，俩点不在条线路路  3.一个转站点，俩点在一条路上  4.一个转站点，俩点不在一条路上 5.俩个转站点，俩点在一条路上  6.俩个转站点，俩点不在一条路上。 

然后如果最优的话，肯定是转站最少啊。写java代码，后来发现如果有一个环路线，有时候多转战要更近。

放弃！

第二个是学习dijkstra算法，数据库里面的数据也是俩个表，一个站点表，一个站点关系表。使用邻接链表和多次调用sql语句。电脑难屏死机，气的我牙根疼。

放弃，但是这个方案是可行的，但是中途放弃了。

重点：因为多次调用sql语句电脑才死机的，而不是邻接链表存贮，应该一次把数据全取出来用java代码处理。

放弃！

第三个是回到第一个的方法，想要多建表来实现那种功能，但是情况却多了起来，好多个表之间的对比求取，太麻烦了。写累了，决定放弃。

放弃！

第四个是我还是想用dijkstra算法，但是怎样不死机呢？数据库同第二个。用矩阵(二维整数数组)来代替就简单了白，-1是到不了，自己到自己是0，因为不知道距离

所以剩下的全是1，以后知道距离了，就可以把距离代替1，这样求出来的就是真正的时间最优路线，而不是理想化的了。（理想化：站点与站点之间距离一样）

成功！

做web的良好的习惯，使用的是mysql数据库，DButil层（连接数据库和关闭连接）+bean层+dao层（取数据库数据）+service层（服务层）

站点表：表内140个站点

站点关系表：151个关系

运行截图：

遇到的问题：

重点1：因为多次调用sql语句电脑才死机的，而不是邻接链表存贮，应该一次把数据全取出来用java代码处理。

for（sql）不知道为什么就是会卡死，网上说这样会占用大量的cpu和内存，我觉得是mysql的斯必得跟不上JVM虚拟机。

重点2：学习dijkstra算法，我挺笨的，学习了挺久的。

重点3：mysql的数据里面是存贮空格的，因为做完以后得排查数据库错误，有一个站点一直查不到，因为它是站点名+一个空格。。。

DButil包内：

package DButil;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * 数据库的工具类
 * 
 * @author 达达超可爱
 *
 */
public final class DButil {

    
    /**
     *  数据库的连接函数
     *  可修改的
     * 
     * @return 数据库的连接
     */
    public  Connection getConn()
    {
        Connection connection =null; 
        // student 为数据库名称  ？ 后面加的是条件
        String db_url="jdbc:mysql://localhost:3306/newsubway?serverTimezone=UTC&useCursorFetch=true&defaultFetchSize=300";
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            connection = DriverManager.getConnection(db_url, "root", "123456");
            // System.out.println("Success connect MySql server!");  
            
        } catch (Exception e) {
            
        }
        
        return connection;
    }
    
    public void close(Connection con)
    {
        if(con!=null)
        {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    
    public  void close(Statement state, Connection conn) {
        if (state != null) {
            try {
                state.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    public  void close( PreparedStatement state, Connection conn) {
        if (state != null) {
            try {
                state.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    public  void close(ResultSet rs, PreparedStatement state, Connection conn) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (state != null) {
            try {
                state.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    public  void close(ResultSet rs, Statement state, Connection conn) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (state != null) {
            try {
                state.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

bean包内：

package bean;

public class Daobean {

 
    String name;
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    
}

package bean;

public class PointBean {

    int line;
    String name;
    int number;
    public int getLine() {
        return line;
    }
    public void setLine(int line) {
        this.line = line;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
    
}

package bean;
//站点与站点之间的联系关系
public class Changebean {

    String name1;
    String name2;
    public String getName1() {
        return name1;
    }
    public void setName1(String name1) {
        this.name1 = name1;
    }
    public String getName2() {
        return name2;
    }
    public void setName2(String name2) {
        this.name2 = name2;
    }
    
}

dao包内：

package dao;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

import DButil.DButil;
import bean.Changebean;
import bean.Daobean;
import bean.PointBean;



public class Dao {
   //返回所有点的名称为一个数组
    public List<Daobean> selectDaoList()
    {
        List<Daobean> l=new ArrayList<Daobean>();
        Daobean b=null;
        
        try
        {
        DButil DB=new DButil();
        Connection con = DB.getConn();
        Statement stm = con.createStatement();
        ResultSet rs = stm.executeQuery("select * from point");
        while(rs.next())
        {
            b=new Daobean();
            b.setName(rs.getString("name"));
            l.add(b);
        }
        DB.close(rs, stm, con);
        } catch (Exception e) 
        {
        e.printStackTrace();
        
        }
        return l;
    }
      //返回所有点的关系为一个数组
    //每个点与点 之间的长度此时未知无法使用
    public List<Changebean> selectChangeList()
    {
        List<Changebean> l=new ArrayList<Changebean>();
        Changebean b=null;
        
        try
        {
        DButil DB=new DButil();
        Connection con = DB.getConn();
        Statement stm = con.createStatement();
        ResultSet rs = stm.executeQuery("select point1,point2,length from pointlian");
        while(rs.next())
        {
            b=new Changebean();
            b.setName1(rs.getString("point1"));
            b.setName2(rs.getString("point2"));
            l.add(b);
        }
        DB.close(rs, stm, con);
        } catch (Exception e) 
        {
        e.printStackTrace();
        
        }
        return l;
    }
    
    public List<PointBean> selectPointList()
    {
        List<PointBean> l=new ArrayList<PointBean>();
        PointBean b=null;
        
        try
        {
        DButil DB=new DButil();
        Connection con = DB.getConn();
        Statement stm = con.createStatement();
        ResultSet rs = stm.executeQuery("select name,number from point");
        while(rs.next())
        {
            b=new PointBean();
            b.setName(rs.getString("name"));
        //    b.setLine(rs.getInt("line"));
            b.setNumber(rs.getInt("number"));
            l.add(b);
        }
        DB.close(rs, stm, con);
        } catch (Exception e) 
        {
        e.printStackTrace();
        
        }
        return l;
    }
    
}

Servise包内：

package service;

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

import bean.Changebean;
import bean.Daobean;
import bean.PointBean;
import dao.Dao;

public class TrainService {
   //主要调用函数 调用这个就行
    public String trainText(String start,String end) 
    {

        Dao dao = new Dao();// 使用Dao层
        List<Daobean> l = new ArrayList<Daobean>();
        List<Changebean> n = new ArrayList<Changebean>();
        l = dao.selectDaoList();
        n = dao.selectChangeList();
        Integer startnumber=null;
        Integer endnumber=null;
        for(int i=0;i<l.size();i++)
        {
            if(start.equals(l.get(i).getName()))
            {
                startnumber=i;
            }
            if(end.equals(l.get(i).getName()))
            {
                endnumber=i;
            }
        }
        // l为所有点的名称 n为所有点之间的关系
        // 构建邻接矩阵
        // -1为不相邻,1是相邻,0是自己和自己

        // 建立战点与战点之间的图形
        // 初始化矩阵,全为-1
        int[][] m = new int[l.size()][l.size()];

        for (int i = 0; i < l.size(); i++) 
        {

            for (int j = 0; j < l.size(); j++) 
            {
                m[i][j] = -1;
            }
        }
        // 根据关系把矩阵中为1的找出来
        for (int i = 0; i < l.size(); i++) 
        {
            Daobean b1 = new Daobean();
            b1 = l.get(i);
            for (int j = 0; j < l.size(); j++) 
            {
                Daobean b2 = new Daobean();
                b2 = l.get(j);
                m[i][j] = returnint(b1.getName(), b2.getName(), n, m[i][j]);
            }

        }
        // 自己与自己为0
        for (int i = 0; i < l.size(); i++) 
        {
            m[i][i] = 0;
        }
        // 因为地铁双向所以为无向图,因此需要它的转置矩阵后与原矩阵相加的规律把它对角线的全为1
        for (int i = 0; i < l.size(); i++) 
        {
            for (int j = 0; j < l.size(); j++) 
            {
                if (m[i][j] == 1) {
                    m[j][i] = 1;
                }
            }
        }
        // 需要修改的地方
        ///
        ////
        /////
        l.clear();
        n.clear();

        String mm=null;
        if(startnumber==null||endnumber==null)
        {
            mm="请输入正确的地点";
        }
        else 
        {
        String b = dijkstra(m, startnumber, endnumber);
        // 去除空格
        String[] re = b.split("   ");// 用split()函数直接分割
        int rep[] = new int[re.length];
        for (int i = 0; i < re.length; i++) 
         {
            rep[i] = Integer.parseInt(re[i]);
         }
        //for (int i = 0; i < re.length; i++) 
         {
            //System.out.print(" " + rep[i]);
         }
        //System.out.println();
        List<PointBean> lll = new ArrayList<PointBean>();
        lll = dao.selectPointList();
        {/*
             * for(int i=0;i<lll.size();i++) {
             * System.out.println(i+" "+lll.get(i).getNumber()); }
             */
        }
        mm = returnWay(rep, lll);
        }
        mm = mm.substring(0,mm.length() - 2);
        return mm;
    }

    public String returnWay(int[] n, List<PointBean> list) 
    {
        String a = "";
        int line = 0;
        for (int j = 0; j < list.size(); j++)
        {
            if ((n[0] + 1) == list.get(j).getNumber()) 
            {
                // a=a+""+list.get(j).getLine()+"号线："+list.get(j).getName()+"->";
                a = a + "" + list.get(j).getName() + "->";
                line = list.get(j).getLine();
            }
        }
        for (int i = 1; i < n.length; i++) 
        {
            for (int j = 0; j < list.size(); j++)

            {
                if ((n[i] + 1) == list.get(j).getNumber()) 
                {
                    if (line != list.get(j).getLine()) 
                    {
                        line = list.get(j).getLine();
                        a = a + "" + list.get(j).getLine() + "号线：";
                    }
                    a = a + "" + list.get(j).getName() + "->";
                }
            }

        }

        return a;
    }

    // 获取最短路径 返回的是一个String,需要处理
    public static String getRoute(int[][] WW, int[] indexs, int end, String a, int b) 
    {
        String[] routeArray = new String[indexs.length];
        String dada = b + "";
        if (dada.length() == 1) 
        {
            dada = "  " + b;
        }
        if (dada.length() == 2) 
        {
            dada = " " + b;
        }

        for (int i = 0; i < routeArray.length; i++) 
        {
            routeArray[i] = "";
        }

        routeArray[indexs[0]] = indexs[0] + "";
        for (int i = 1; i < indexs.length; i++) 
        {
            // 看该点与前面所有点的连接线中的最短路径，然后得到该最短路径到底是连接了哪个点，进而此点的route就是找出那点的route+此点
            int[] thePointDis = WW[indexs[i]];
            int prePoint = 0;

            int tmp = 9999;
            for (int j = 0; j < thePointDis.length; j++) 
            {
                boolean chooseFlag = false;
                for (int m = 0; m < i; m++) 
                {
                    if (j == indexs[m]) 
                    {
                        chooseFlag = true;
                    }
                }
                if (chooseFlag == false) 
                {
                    continue;
                }
                if (thePointDis[j] < tmp && thePointDis[j] > 0) 
                {
                    prePoint = j;
                    tmp = thePointDis[j];
                }
            }
            routeArray[indexs[i]] = routeArray[prePoint] + "   " + indexs[i];
        }
        for (int i = 0; i < routeArray.length; i++) 
        {

            if (routeArray[i].length() > 3
                    && routeArray[i].substring(routeArray[i].length() - 3, routeArray[i].length()).equals(dada)) 
            {
                a = routeArray[i];
            }
        }
        return a;
    }

    public static String dijkstra(int[][] W1, int start, int end) 
    {
        String b = "";
        boolean[] isLabel = new boolean[W1[0].length];// 是否标号
        int[] indexs = new int[W1[0].length];// 所有标号的点的下标集合，以标号的先后顺序进行存储，实际上是一个以数组表示的栈
        int i_count = -1;// 栈的顶点
        int[] distance = W1[start].clone();// v0到各点的最短距离的初始值
        int index = start;// 从初始点开始
        int presentShortest = 0;// 当前临时最短距离

        indexs[++i_count] = index;// 把已经标号的下标存入下标集中
        isLabel[index] = true;

        while (i_count < W1[0].length) 
        {
            // 第一步：得到与原点最近的某个点
            int min = Integer.MAX_VALUE;
            for (int i = 0; i < distance.length; i++) 
            {
                if (!isLabel[i] && distance[i] != -1 && i != index) 
                {
                    // 如果到这个点有边,并且没有被标号
                    if (distance[i] < min) 
                    {
                        min = distance[i];
                        index = i;// 把下标改为当前下标
                    }
                }
            }
            i_count = i_count + 1;
            if (i_count == W1[0].length) 
            {
                break;
            }
            isLabel[index] = true;// 对点进行标号
            indexs[i_count] = index;// 把已经标号的下标存入下标集中

            if (W1[indexs[i_count - 1]][index] == -1
                    || presentShortest + W1[indexs[i_count - 1]][index] > distance[index]) 
            {
                // 如果两个点没有直接相连，或者两个点的路径大于最短路径
                presentShortest = distance[index];
            } else {
                presentShortest += W1[indexs[i_count - 1]][index];
            }

            // 第二步：加入vi后，重新计算distance中的距离
            for (int i = 0; i < distance.length; i++) 
            {

                // 如果vi到那个点有边，则v0到后面点的距离加
                if (distance[i] == -1 && W1[index][i] != -1) 
                {// 如果以前不可达，则现在可达了
                    distance[i] = presentShortest + W1[index][i];
                } else if (W1[index][i] != -1 && presentShortest + W1[index][i] < distance[i]) 
                {
                    // 如果以前可达，但现在的路径比以前更短，则更换成更短的路径
                    distance[i] = presentShortest + W1[index][i];
                }

            }

        }
        b = getRoute(W1, indexs, end, b, end);
        return b;

    }

    // 将矩阵对应位置判断是否为1
    public static int returnint(String b1, String b2, List<Changebean> n, int i) 
    {
        for (int j = 0; j < n.size(); j++) 
        {
            if (b1.equals(n.get(j).getName1()) && b2.equals(n.get(j).getName2())) 
            {
                i = 1;
            }
        }
        return i;
    }
}