526互联

2023.3.20课后作业

发布时间 2023-03-22 21:10:42作者: Arkiya

地铁系统JavaWeb开发内容

设计思想：本次项目具体思路为

1.首先是实现常规功能，即输入线路显示出对应站点和输入站点显示出经过该站点的线路

这两个功能相对来说比较简单，只是在数据库中进行查询，使用对应的sql语句进行查询即可

2.对于核心功能：查询两站中的最短线路，使用了一个比较暴力的方法，即查询出所有输入的站点的中转站，把他们放入另一个表单中，对于同一条线路上的直接顺序输出站点即可，对于可以直接中转的，获取他们两个的线路，再经过中转站即可，对于不能直接中转的，从第一个站点遍历通往另一条线路的站点，再次遍历

源程序代码：

Line.java

package Bean;
import java.util.ArrayList;

/*
 *
 */
public class Line
{
    private String startstopname;//起始站站名
    private String endstopname;//结束站站名
    private int startstopID;//    起始站站编号
    private int endstopID;//结束站站编号
    private String startline1=null;//起始点的第一条线
    private String startline2=null;//起始点第二条线
    private String endline1=null;//结束点的第一条线
    private String endline2=null;//结束点的第二条线
    private ArrayList<String> array = new ArrayList<String>();//存放过程站点
    private int originline;//起始站所在线路
    private int finishline;//结束点所在线路
    private String middlestop;//中转站站名
    private String temporarystartstopname;//临时起始站点名称
    private String temporaryendstopname;//临时终点站点名称
    private int temporaryline=0;//临时线路
    public Line() {

    }
    public int getTemporaryline() {
        return temporaryline;
    }
    public void setTemporaryline(int temporaryline) {
        this.temporaryline = temporaryline;
    }
    public String getTemporarystartstopname() {
        return temporarystartstopname;
    }
    public void setTemporarystartstopname(String temporarystartstopname) {
        this.temporarystartstopname = temporarystartstopname;
    }
    public String getTemporaryendstopname() {
        return temporaryendstopname;
    }
    public void setTemporaryendstopname(String temporaryendstopname) {
        this.temporaryendstopname = temporaryendstopname;
    }
    public String getMiddlestop() {
        return middlestop;
    }
    public void setMiddlestop(String middlestop) {
        this.middlestop = middlestop;
    }
    public int getOriginline() {
        return originline;
    }
    public void setOriginline(int originline) {
        this.originline = originline;
    }
    public int getFinishline() {
        return finishline;
    }
    public void setFinishline(int finishline) {
        this.finishline = finishline;
    }
    public ArrayList<String> getArray() {
        return array;
    }
    public void setArray(ArrayList<String> array) {
        this.array = array;
    }
    public String getStartline1() {
        return startline1;
    }
    public void setStartline1(String startline1) {
        this.startline1 = startline1;
    }
    public String getStartline2() {
        return startline2;
    }
    public void setStartline2(String startline2) {
        this.startline2 = startline2;
    }
    public String getEndline1() {
        return endline1;
    }
    public void setEndline1(String endline1) {
        this.endline1 = endline1;
    }
    public String getEndline2() {
        return endline2;
    }
    public void setEndline2(String endline2) {
        this.endline2 = endline2;
    }
    public String getStartstopname() {
        return startstopname;
    }
    public void setStartstopname(String startstopname) {
        this.startstopname = startstopname;
    }
    public String getEndstopname() {
        return endstopname;
    }
    public void setEndstopname(String endstopname) {
        this.endstopname = endstopname;
    }
    public int getStartstopID() {
        return startstopID;
    }
    public void setStartstopID(int startstopID) {
        this.startstopID = startstopID;
    }
    public int getEndstopID() {
        return endstopID;
    }
    public void setEndstopID(int endstopID) {
        this.endstopID = endstopID;
    }


}

 

package Dao;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;

/*
 * 加载连接数据库
 */
import java.sql.*;

public class JdbcUtils {
    private static Connection connection = null;
    private static String url = "jdbc:mysql://localhost:3306/subway2";
    private static String usrname = "root";
    private static String password = "arzia20021209";

    static {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() {
        try {
            connection = DriverManager.getConnection(url, usrname, password);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return connection;
    }

    public static void release(Connection connection, Statement statement, ResultSet resultSet)  {
        try {
            if (connection != null) {
                connection.close();
            }
            if (statement != null) {
                statement.close();
            }
            if (resultSet != null) {
                resultSet.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
}
package Dao;


import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.RunnableScheduledFuture;

import Bean.Line;

public class UserDao {
    int demostartid=0,demoendid=0;
    ArrayList<String> array=new ArrayList<String>();
    /*
     *     起始点与终点在一条线上且非换乘站
     */
    public List<String> find1(String line){
        List<String>list=new ArrayList<>();
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            connection = JdbcUtils.getConnection();
            String sql = "select * from firstline where Line=?";
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setString(1, line);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                String s=resultSet.getString(2);
                list.add(s);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(connection, preparedStatement, resultSet);
        }
        return list;
    }
    
    public List<String> find3(String linepoint){
        List<String>list=new ArrayList<>();
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            connection = JdbcUtils.getConnection();
            String sql = "select * from firstline where StopName=?";
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setString(1, linepoint);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                String s=resultSet.getString(3);
                list.add(s+"号线 ");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(connection, preparedStatement, resultSet);
        }
        return list;
    }
    
    
    
    
    public ArrayList<String> Connectonlyoneline(Line line) throws ClassNotFoundException
    {
        ArrayList<String> array1=new ArrayList<String>();
        int c=0;
        try {
            //连接数据库
            Connection con = JdbcUtils.getConnection();
            Statement statement = con.createStatement();
            //是否成功连接
            if(!con.isClosed())
                System.out.println("Succeeded connecting to the Database!");
            String sql="SELECT * FROM firstline f1 JOIN firstline f2 on f1.Line=f2.Line WHERE f1.StopName='"+line.getStartstopname()+"' AND f2.StopName='"+line.getEndstopname()+"'";
            //保证起始站（同时有可能是中转站）与终点站（同时有可能是中转站）在同一条线路上
            ResultSet rs=statement.executeQuery(sql);
            while(rs.next()) {
                line.setTemporaryline(rs.getInt("Line"));
            }
            //准备数据库查询：将起始站和终点站的中间站
            System.out.println(line.getTemporaryline());
            array.add("乘坐"+line.getTemporaryline()+"号线");
            c=select(line);    //得到起始站与终点站的顺序
            System.out.println(c);
            if(c==1)
            {//起始站编号小于终点站，即起始站在前，终点站在后
                String sql1="select * from firstline where StopID>=(select StopID from firstline where StopName='"+line.getStartstopname()+"' and Line='"+line.getTemporaryline()+"') and StopID<=(select StopID from firstline where StopName='"+line.getEndstopname()+"' and Line='"+line.getTemporaryline()+"')";
                /*
                 * 找到这样的一些站：它们的ID号大于起始站的ID号，
                 * 它们的ID号小于结束站的ID号，并且它们都是同一条线上的站点
                 */
                ResultSet rs1 = statement.executeQuery(sql1);
                while(rs1.next())
                {//遍历结果集
                    array.add(rs1.getString(2));
                }
                rs1.close();
            }
            else if(c==2)
            {//起始站编号大于终点站，即起始站在后，终点站在前
                String sql2="select * from firstline where StopID>=(select StopID from firstline where StopName='"+line.getEndstopname()+"' and Line='"+line.getTemporaryline()+"') and StopID<=(select StopID from firstline where StopName='"+line.getStartstopname()+"' and Line='"+line.getTemporaryline()+"')";
                /*
                 * 同上
                 */
                ResultSet rs2 = statement.executeQuery(sql2);
                while(rs2.next())
                {
                    array1.add(rs2.getString("StopName"));
                }
                for(int i=0;i<array1.size();i++)
                {//测试是否有值
                    System.out.print(array1.get(i)+" ");
                }
                for(int j=array1.size()-1;j>=0;j--)
                {//将站名倒序传入
                    array.add(array1.get(j));
                }

                rs2.close();
            }
            con.close();
            statement.close();
        }catch(SQLException e) {
            e.printStackTrace();
        }finally {
            line.setArray(array);//似乎无意义，在下面已经传回array
            for(int i=0;i<array.size();i++) {
                System.out.println(array.get(i)+" ");
            }
        }
        return array;
    }

    /*
     *     先不着急，起始站/终点站是换乘站的情况最后考虑
     *     首先判断起始站或结束站是否为中转站
     */
    public void JudgeChangeStop(Line line) throws ClassNotFoundException {
        try {
            Connection con=JdbcUtils.getConnection();
            Statement statement=con.createStatement();
            String sql="select * from changeline";
            ResultSet rs = statement.executeQuery(sql);
            while(rs.next()) {
                if(line.getStartstopname().equals(rs.getString("ChangeStopName")))
                {
                    line.setStartline1(rs.getString("ID1"));
                    line.setStartline2(rs.getString("ID2"));
                }
                if(line.getEndstopname().equals(rs.getString("ChangeStopName")))
                {
                    line.setEndline1(rs.getString("ID1"));
                    line.setEndline2(rs.getString("ID2"));
                }
            }
            con.close();
            statement.close();
            rs.close();
        }catch(SQLException e) {
            throw new RuntimeException(e);
        }finally {
            if(line.getStartline1()==null)
            {

            }
        }
    }
    /*
     *     看站点顺序
     */
    public int select(Line line) throws ClassNotFoundException {
        int i=0;//返回值，1为顺序（数据库中），2为逆序（数据库中）
        try {
            Connection con = JdbcUtils.getConnection();
            Statement statement=con.createStatement();
            String sql="select * from firstline where StopName='"+line.getStartstopname()+"'and Line='"+line.getTemporaryline()+"' or StopName='"+line.getEndstopname()+"' and Line='"+line.getTemporaryline()+"'";
            /*
             * 找到与起始站名称相同，结束站名称相同，且同时属于同一条线的两个站
             */
            ResultSet rs = statement.executeQuery(sql);
            while(rs.next()) {
                if(line.getStartstopname().equals(rs.getString("StopName")))
                {
                    line.setStartstopID(rs.getInt("StopID"));
                }
                if(line.getEndstopname().equals(rs.getString("StopName"))) {
                    line.setEndstopID(rs.getInt("StopID"));
                }
            }
            con.close();
            statement.close();
            rs.close();
        }catch(SQLException e) {
            throw new RuntimeException(e);
        }
        System.out.println(line.getStartstopID()+" "+line.getEndstopID());
        if(line.getStartstopID()<line.getEndstopID()) {
            i=1;
            return i;
        }
        else {
            i=2;
            return i;
        }
    }
    /*
     *     判断是否为同一条线
     */
    public int same(Line line) throws ClassNotFoundException {
        int checksameline=0;//同一条线
        try {
            Connection con = JdbcUtils.getConnection();
            Statement statement = con.createStatement();
            String sql="select * from firstline where StopName='"+line.getStartstopname()+"' or StopName='"+line.getEndstopname()+"'";
            /*
             * 同上，但用不着判断是否属于同一线路（本判断只存在于起始点与结束点是普通点）
             */
            ResultSet rs = statement.executeQuery(sql);
            while(rs.next()) {
                if(line.getStartstopname().equals(rs.getString("StopName")))
                {
                    line.setOriginline(rs.getInt("Line"));
                }
                if(line.getEndstopname().equals(rs.getString("StopName"))) {
                    line.setFinishline(rs.getInt("Line"));
                }
            }
        }catch(SQLException e) {
            throw new RuntimeException(e);
        }
        if(line.getFinishline()==line.getOriginline()) {//是同一条线
            checksameline=1;
            return checksameline;
        }
        else {//不是同一条线
            checksameline=2;
            return checksameline;
        }
    }
    /*
     *     两条不同的、有交点的线路
     */
    public ArrayList<String> Connecttwoline(Line line) throws SQLException, ClassNotFoundException{
        int c=0;

        Connection con = JdbcUtils.getConnection();
        Statement statement = con.createStatement();
        same(line);
        String sql="select * from changeline where ID1='"+line.getOriginline()+"' and ID2='"+line.getFinishline()+"'";
        //根据交点线路查询中转站
        ResultSet rs = statement.executeQuery(sql);
        while(rs.next()) {
            line.setMiddlestop(rs.getString("ChangeStopName"));
        }
        rs.close();
        line.setTemporarystartstopname(line.getStartstopname());
        //记录当前起始点与结束点
        line.setTemporaryendstopname(line.getEndstopname());
        //同上
        String sql1="select * from firstline where Line='"+line.getOriginline()+"' and StopName='"+line.getMiddlestop()+"'";
        //根据起始线路和中转站名称标出中转站位置
        ResultSet rs1 = statement.executeQuery(sql1);
        while(rs1.next()) {
            line.setEndstopname(rs1.getString("StopName"));
            //起始点不变，结束点设置为中转点
        }
        rs1.close();
        line.setStartstopname(line.getTemporarystartstopname());
        line.setTemporaryline(line.getOriginline());
        //将起始点和中转点所在线路一致的放入临时站线路
        /*
         *
         *
         *
         *
         */
        array.add("乘坐"+line.getOriginline()+"号线");
        c=select(line);    //得到起始站与终点站的顺序
        if(c==1)
        {//起始站编号小于终点站，即起始站在前，终点站在后
            String sql2="select * from firstline where StopID>=(select StopID from firstline where StopName='"+line.getStartstopname()+"' and Line='"+line.getTemporaryline()+"') and StopID<=(select StopID from firstline where StopName='"+line.getEndstopname()+"' and Line='"+line.getTemporaryline()+"')";
            /*
             * 找到这样的一些站：它们的ID号大于起始站的ID号，
             * 它们的ID号小于结束站的ID号，并且它们都是同一条线上的站点
             */
            ResultSet rs2 = statement.executeQuery(sql2);
            while(rs2.next())
            {//遍历结果集
                array.add(rs2.getString("StopName"));
            }
            rs2.close();
        }
        else if(c==2)
        {//起始站编号大于终点站，即起始站在后，终点站在前
            ArrayList<String> array1=new ArrayList<String>();
            String sql2="select * from firstline where StopID>=(select StopID from firstline where StopName='"+line.getEndstopname()+"' and Line='"+line.getTemporaryline()+"') and StopID<=(select StopID from firstline where StopName='"+line.getStartstopname()+"' and Line='"+line.getTemporaryline()+"')";
            /*
             * 同上
             */
            ResultSet rs2 = statement.executeQuery(sql2);
            while(rs2.next())
            {
                array1.add(rs2.getString("StopName"));
            }
            for(int i=0;i<array1.size();i++)
            {//测试是否有值
                System.out.print(array1.get(i)+" ");
            }
            for(int j=array1.size()-1;j>=0;j--)
            {//将站名倒序传入
                array.add(array1.get(j));
            }

            rs2.close();
        }
        array.add("转乘"+line.getFinishline()+"号线");
        /*
         *
         *
         *
         *
         */
        line.setStartstopname(line.getMiddlestop());
        //将起始点设为中转点
        line.setEndstopname(line.getTemporaryendstopname());
        //将结束点回归
        line.setTemporaryline(line.getFinishline());
        //将中转点和结束点所在线路一致的放入临时站线路
        /*
         *
         *
         *
         */
        c=select(line);    //得到起始站与终点站的顺序
        if(c==1)
        {//起始站编号小于终点站，即起始站在前，终点站在后
            String sql2="select * from firstline where StopID>=(select StopID from firstline where StopName='"+line.getStartstopname()+"' and Line='"+line.getTemporaryline()+"') and StopID<=(select StopID from firstline where StopName='"+line.getEndstopname()+"' and Line='"+line.getTemporaryline()+"')";
            /*
             * 找到这样的一些站：它们的ID号大于起始站的ID号，
             * 它们的ID号小于结束站的ID号，并且它们都是同一条线上的站点
             */
            ResultSet rs2 = statement.executeQuery(sql2);
            while(rs2.next())
            {//遍历结果集
                array.add(rs2.getString("StopName"));
            }
            rs2.close();
        }
        else if(c==2)
        {//起始站编号大于终点站，即起始站在后，终点站在前
            ArrayList<String> array1=new ArrayList<String>();
            String sql2="select * from firstline where StopID>=(select StopID from firstline where StopName='"+line.getEndstopname()+"' and Line='"+line.getTemporaryline()+"') and StopID<=(select StopID from firstline where StopName='"+line.getStartstopname()+"' and Line='"+line.getTemporaryline()+"')";
            /*
             * 同上
             */
            ResultSet rs2 = statement.executeQuery(sql2);
            while(rs2.next())
            {
                array1.add(rs2.getString("StopName"));
            }
            for(int i=0;i<array1.size();i++)
            {//测试是否有值
                System.out.print(array1.get(i)+" ");
            }
            for(int j=array1.size()-1;j>=0;j--)
            {//将站名倒序传入
                array.add(array1.get(j));
            }

            rs2.close();
        }
        /*
         *
         *
         *
         *
         */
        //由于array是全局变量，所以继续直接接受数据即可
        return array;

    }
    /*
     * 判断有无交点
     */
    public int checklink(Line line) throws ClassNotFoundException {
        int c=0;
        Connection con;
        try {
            same(line);
            con = JdbcUtils.getConnection();
            Statement statement = con.createStatement();
            String sql="select * from changeline where ID1='"+line.getOriginline()+"' and ID2='"+line.getFinishline()+"'";
            ResultSet rs=statement.executeQuery(sql);
            while(rs.next()) {
                if(rs.getString("ChangeStopName").equals("")) {

                }
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


        return c;
    }
    /*
     * 解决两条线之间没有换乘站，只能通过第三条线换乘
     * 即A（普通站）->B（中转站）->C（中转站）->D（普通站）
     *
     */
    public ArrayList<String> Connectthreeline(Line line) throws ClassNotFoundException {
        ArrayList<Integer> array1=new ArrayList<Integer>();
        int c=0;
        int min=0;
        try
        {
            same(line);
            Connection con = JdbcUtils.getConnection();
            Statement statement = con.createStatement();

            String sql="SELECT    * FROM    changeline c1 JOIN changeline c2 ON c1.ID2 = c2.ID1 WHERE trim(c1.ChangeStopName) != '' AND trim(c2.ChangeStopName) != '' AND c1.ID1 = '"+line.getOriginline()+"' AND c2.ID2 = '"+line.getFinishline()+"'";
            ResultSet rs = statement.executeQuery(sql);
            while(rs.next())
            {
                if(line.getOriginline()==rs.getInt("ID1"))
                {
                    array1.add(rs.getInt("ID2"));
                }
            }
            rs.close();
            line.setTemporarystartstopname(line.getStartstopname());
            line.setTemporaryendstopname(line.getEndstopname());
            /*
             *
             * 第一次转乘
             * A（普通站）->B（中转站）
             *
             */
            for(int j=0;j<array1.size();j++)
            {
                ArrayList<String> array3=new ArrayList<String>();

                System.out.println("也许这是我想要的起始站"+line.getTemporarystartstopname());
                String sql1="select * from changeline where ID1='"+line.getOriginline()+"' and ID2='"+array1.get(j)+"'";
                ResultSet rs1 = statement.executeQuery(sql1);
                while(rs1.next())
                {
                    line.setEndstopname(rs1.getString("ChangeStopName"));
                }
                rs1.close();
                array3.add("乘坐"+line.getOriginline()+"号线");
                array3.add(line.getTemporarystartstopname());
                String sql4="SELECT * FROM firstline f1 JOIN firstline f2 on f1.Line=f2.Line WHERE f1.StopName='"+line.getStartstopname()+"' AND f2.StopName='"+line.getEndstopname()+"'";
                //保证两个中转站在同一条线路上
                ResultSet rs4=statement.executeQuery(sql4);
                while(rs4.next()) {
                    line.setTemporaryline(rs4.getInt("Line"));
                }
                rs.close();
                c=select(line);
                if(c==1)
                {//起始站编号小于终点站，即起始站在前，终点站在后
                    String sql2="select * from firstline where StopID>=(select StopID from firstline where StopName='"+line.getStartstopname()+"' and Line='"+line.getTemporaryline()+"') and StopID<=(select StopID from firstline where StopName='"+line.getEndstopname()+"' and Line='"+line.getTemporaryline()+"')";
                    /*
                     * 找到这样的一些站：它们的ID号大于起始站的ID号，
                     * 它们的ID号小于结束站的ID号，并且它们都是同一条线上的站点
                     */
                    ResultSet rs2 = statement.executeQuery(sql2);
                    while(rs2.next())
                    {//遍历结果集
                        array3.add(rs2.getString("StopName"));
                    }
                    rs2.close();
                }
                else if(c==2)
                {//起始站编号大于终点站，即起始站在后，终点站在前
                    ArrayList<String> array2=new ArrayList<String>();
                    String sql2="select * from firstline where StopID>=(select StopID from firstline where StopName='"+line.getEndstopname()+"' and Line='"+line.getTemporaryline()+"') and StopID<=(select StopID from firstline where StopName='"+line.getStartstopname()+"' and Line='"+line.getTemporaryline()+"')";
                    /*
                     * 同上
                     */
                    ResultSet rs2 = statement.executeQuery(sql2);
                    while(rs2.next())
                    {
                        array2.add(rs2.getString("StopName"));
                    }
                    for(int i=0;i<array2.size();i++)
                    {//测试是否有值
                        System.out.print(array2.get(i)+" ");
                    }
                    for(int i=array2.size()-1;i>=0;i--)
                    {//将站名倒序传入
                        array3.add(array2.get(i));
                    }
                    rs2.close();
                }
                /*
                 * 第二次换乘
                 * B（中转站）->C（中转站）
                 *
                 */
                line.setStartstopname(line.getEndstopname());
                String sql3="select * from changeline where ID1='"+array1.get(j)+"' and ID2='"+line.getFinishline()+"'";
                ResultSet rs3 = statement.executeQuery(sql3);
                while(rs3.next())
                {
                    line.setEndstopname(rs3.getString("ChangeStopName"));
                }
                String sql5="SELECT * FROM firstline f1 JOIN firstline f2 on f1.Line=f2.Line WHERE f1.StopName='"+line.getStartstopname()+"' AND f2.StopName='"+line.getEndstopname()+"'";
                //保证两个中转站在同一条线路上
                ResultSet rs5=statement.executeQuery(sql5);
                while(rs5.next()) {
                    line.setTemporaryline(rs5.getInt("Line"));
                }
                rs5.close();
                array3.add("转乘"+line.getTemporaryline()+"号线");
                c=select(line);
                if(c==1)
                {//起始站编号小于终点站，即起始站在前，终点站在后
                    String sql2="select * from firstline where StopID>=(select StopID from firstline where StopName='"+line.getStartstopname()+"' and Line='"+line.getTemporaryline()+"') and StopID<=(select StopID from firstline where StopName='"+line.getEndstopname()+"' and Line='"+line.getTemporaryline()+"')";
                    /*
                     * 找到这样的一些站：它们的ID号大于起始站的ID号，
                     * 它们的ID号小于结束站的ID号，并且它们都是同一条线上的站点
                     */
                    ResultSet rs2 = statement.executeQuery(sql2);
                    while(rs2.next())
                    {//遍历结果集
                        array3.add(rs2.getString("StopName"));
                    }
                    rs2.close();
                }
                else if(c==2)
                {//起始站编号大于终点站，即起始站在后，终点站在前
                    ArrayList<String> array2=new ArrayList<String>();
                    String sql2="select * from firstline where StopID>=(select StopID from firstline where StopName='"+line.getEndstopname()+"' and Line='"+line.getTemporaryline()+"') and StopID<=(select StopID from firstline where StopName='"+line.getStartstopname()+"' and Line='"+line.getTemporaryline()+"')";
                    /*
                     * 同上
                     */
                    ResultSet rs2 = statement.executeQuery(sql2);
                    while(rs2.next())
                    {
                        array2.add(rs2.getString("StopName"));
                    }
                    for(int i=0;i<array2.size();i++)
                    {//测试是否有值
                        System.out.print(array2.get(i)+" ");
                    }
                    for(int i=array2.size()-1;i>=0;i--)
                    {//将站名倒序传入
                        array3.add(array2.get(i));
                    }
                    rs2.close();
                }
                /*
                 *
                 * 最后一次换乘
                 * 即C（中转站）->D（普通站）
                 */
                line.setStartstopname(line.getEndstopname());
                line.setEndstopname(line.getTemporaryendstopname());
                String sql6="SELECT * FROM firstline f1 JOIN firstline f2 on f1.Line=f2.Line WHERE f1.StopName='"+line.getStartstopname()+"' AND f2.StopName='"+line.getEndstopname()+"'";
                //保证两个中转站在同一条线路上
                ResultSet rs6=statement.executeQuery(sql6);
                while(rs6.next()) {
                    line.setTemporaryline(rs6.getInt("Line"));
                }
                rs.close();
                array3.add("转乘"+line.getTemporaryline()+"号线");
                c=select(line);
                if(c==1)
                {//起始站编号小于终点站，即起始站在前，终点站在后
                    String sql2="select * from firstline where StopID>=(select StopID from firstline where StopName='"+line.getStartstopname()+"' and Line='"+line.getTemporaryline()+"') and StopID<=(select StopID from firstline where StopName='"+line.getEndstopname()+"' and Line='"+line.getTemporaryline()+"')";
                    /*
                     * 找到这样的一些站：它们的ID号大于起始站的ID号，
                     * 它们的ID号小于结束站的ID号，并且它们都是同一条线上的站点
                     */
                    ResultSet rs2 = statement.executeQuery(sql2);
                    while(rs2.next())
                    {//遍历结果集
                        array3.add(rs2.getString("StopName"));
                    }
                    rs2.close();
                }
                else if(c==2)
                {//起始站编号大于终点站，即起始站在后，终点站在前
                    ArrayList<String> array2=new ArrayList<String>();
                    String sql2="select * from firstline where StopID>=(select StopID from firstline where StopName='"+line.getEndstopname()+"' and Line='"+line.getTemporaryline()+"') and StopID<=(select StopID from firstline where StopName='"+line.getStartstopname()+"' and Line='"+line.getTemporaryline()+"')";
                    /*
                     * 同上
                     */
                    ResultSet rs2 = statement.executeQuery(sql2);
                    while(rs2.next())
                    {
                        array2.add(rs2.getString("StopName"));
                    }
                    for(int i=0;i<array2.size();i++)
                    {//测试是否有值
                        System.out.print(array2.get(i)+" ");
                    }
                    for(int i=array2.size()-1;i>=0;i--)
                    {//将站名倒序传入
                        array3.add(array2.get(i));
                    }
                    rs2.close();
                }
                if(j==0) {
                    min=array3.size();
                }
                /*
                 * 第一次：5 min=5 array.size=5
                 * 第二次：3 array.size=3 min=5
                 * 第三次：7 array.size=7 min=3
                 */
                //输出array3测试
                System.out.println();
                System.out.println();
                for(int x=0;x<array3.size();x++) {
                    System.out.print(array3.get(x)+" ");

                }
                System.out.println();
                System.out.println(min);
                if(min>=array3.size()) {
                    min=array3.size();
                    for(int x=0;x<array3.size();x++) {
                        System.out.print(array3.get(x)+" ");

                    }
                    array=array3;
                }
            }
            statement.close();
            con.close();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return array;

    }
    public int CheckAll(Line line) throws SQLException {
        int checkall=0;
        Connection con=JdbcUtils.getConnection();
        Statement statement = con.createStatement();
        String sql="SELECT * FROM firstline f1 JOIN firstline f2 on f1.Line=f2.Line WHERE f1.StopName='"+line.getStartstopname()+"' AND f2.StopName='"+line.getEndstopname()+"'";
        ResultSet rs = statement.executeQuery(sql);
        while(rs.next()){
            line.setTemporaryline(rs.getInt("Line"));
        }
        rs.close();
        if(line.getTemporaryline()!=0) {
            checkall=1;
            return checkall;
        }
        else if(line.getTemporaryline()==0){
            String sql1="select * from firstline where StopName='"+line.getStartstopname()+"' or StopName='"+line.getEndstopname()+"'";
            /*
             * 同上，但用不着判断是否属于同一线路（本判断只存在于起始点与结束点是普通点）
             */
            ResultSet rs1 = statement.executeQuery(sql1);
            while(rs1.next()) {
                if(line.getStartstopname().equals(rs1.getString("StopName")))
                {
                    line.setOriginline(rs1.getInt("Line"));
                }
                if(line.getEndstopname().equals(rs1.getString("StopName"))) {
                    line.setFinishline(rs1.getInt("Line"));
                }
            }
            rs1.close();
            if(line.getOriginline()==0||line.getFinishline()==0) {
                checkall=4;
                return checkall;
            }
            System.out.println("这不合理！所以线一为"+line.getOriginline()+",线二为"+line.getFinishline());
            String sql2="select * from changeline where ID1='"+line.getOriginline()+"' and ID2='"+line.getFinishline()+"'";
            ResultSet rs2 = statement.executeQuery(sql2);
            while(rs2.next()) {
                line.setMiddlestop(rs2.getString("ChangeStopName"));
            }
            System.out.println(line.getMiddlestop()+"也许不是我想要的");
            if(line.getMiddlestop().equals("")) {
                checkall=3;
                return checkall;
            }
            else {
                checkall=2;
                return checkall;
            }
        }
        return checkall;

    }
}
package service;
import Dao.UserDao;

public class UserService {

    private UserDao userdao=new UserDao();
}
package Servlet;

import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import Bean.Line;
import Dao.UserDao;
import service.UserService;

/**
 * Servlet implementation class servlet
 */
@WebServlet("/servlet")
public class servlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    /**
     * @see HttpServlet#HttpServlet()
     */
    public servlet() {
        super();
        // TODO Auto-generated constructor stub
    }

    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub

    }

    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        request.setCharacterEncoding("utf-8"); //1
        response.setContentType("text/html;charset=utf-8"); //2
        response.setCharacterEncoding("utf-8"); //3
        UserDao dao = new UserDao();
        String method = request.getParameter("method");
        if (method.equals("find1")) {
            List<String> list=new ArrayList<>();
            String line=request.getParameter("line");
            System.out.println("您查询的为"+line+"号线");
            list=dao.find1(line);
            request.setAttribute("stop",list);
            request.getRequestDispatcher("result.jsp").forward(request,response);

        } else if(method.equals("find2")){
            Line line = new Line();
            ArrayList<String> array = new ArrayList<String>();
            String startstopname = request.getParameter("startstopname");
            String endstopname = request.getParameter("endstopname");
            line.setStartstopname(startstopname);
            line.setEndstopname(endstopname);
            try {
                int x = dao.CheckAll(line);
                System.out.println("实际上传过来的值是" + x);
                if (x == 1) {
                    array = dao.Connectonlyoneline(line);
                } else if (x == 2) {
                    array = dao.Connecttwoline(line);
                } else if (x == 3) {
                    array = dao.Connectthreeline(line);
                } else {
                    request.setAttribute("message", "请输入正确的站名！");
                    request.getRequestDispatcher("find2.jsp").forward(request, response);
                    return;
                }
                //array=dao.Connectthreeline(line);
                request.setAttribute("stop", array);
        /*    if(array.equals(null)) {

            }*/
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {

                request.getRequestDispatcher("result.jsp").forward(request, response);
            }

        }
        else
        {
              List<String> list=new ArrayList<>();
              String linepoint=request.getParameter("linepoint");
           
              list=dao.find3(linepoint);
              request.setAttribute("stop",list);
              request.getRequestDispatcher("result.jsp").forward(request,response);

            
            
        }
    }

}

运行结果截图

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

编程总结分析，总体来说本次开发对我来说难度还是蛮大的，尤其是对于换乘内容，和搭档一再讨论，具体可以见之前的博客，加上界面的绘制，主要自己的html不是特别精通，绘制界面就很痛苦，希望能进一步提升自己的能力吧

需求描述：完成一个能自动输出换乘路线的地铁系统

　　估计开发时间：7天。

　　项目计划数据：填写完成。

　　时间记录日志：填写完成。

　　缺陷记录日志：填写完成。

　　姓名：胡硕阳

　　日期：2023.3.13-2023.3.20

        七天中，前五天进行后端开发，最后两天进行前端优化

5、时间记录日志：

　　学生：胡硕阳

　　日期：2023.3.13-2023.3.20

　    教师：王建民

 

 

 

6、缺陷记录日志：

　　学生：胡硕阳

　　日期：2023.3.21

　　教师：王建民