Mysql praktische Übungen einfaches Bibliotheksverwaltungssystem

Datenbank erstellen, falls nicht vorhanden: java100_bookmanager;
verwenden Sie java100_bookmanager;
Tabelle löschen, wenn Buch vorhanden ist;
//ID als automatisch inkrementierenden Primärschlüssel festlegen. Tabelle erstellen: Buch (ID int Primärschlüssel auto_increment, Name varchar (20), Autor varchar (20), Preis int, Typ varchar (20), isBorrowed int);

Tabelle löschen, wenn Benutzer vorhanden ist;
//Legen Sie außerdem die Benutzer-ID als automatisch inkrementierenden Primärschlüssel fest und stellen Sie sicher, dass die Benutzernamen eindeutig sind. create table user(
    Benutzer-ID int Primärschlüssel auto_increment,
    Benutzername varchar(20) eindeutig,
    Passwort varchar(20),
    isAdmin int
);
-- Fügen Sie einige Bücher ein, fügen Sie sie in Buchwerte ein (null, „Die Reise nach Westen“, „Wu Cheng’en“, 10000, „Klassische Romane“, 0);
in Buchwerte einfügen (null, „Die Geschichte der Drei Reiche“, „Luo Guanzhong“, 10000, „Klassische Romane“, 0);
in Buchwerte einfügen (null, „Water Margin“, „Shi Naian“, 10000, „Classical Novels“, 0);
in Buchwerte einfügen (null, „Jin Ping Mei“, „Lanling Xiao Xiao Sheng“, 10000, „Klassische Romane“, 0);
--Fügen Sie einige Benutzer ein, fügen Sie sie in Benutzerwerte ein (null, „admin“, „123“, „1“).
in Benutzerwerte einfügen (null, „zhangsan“, „123“, 0);

öffentliche Klasse Bücher {
    private int bookId;//Buchnummer private String name;//Buchtitel private String author;//Autor private int price;//Preis private String type;//Typ private boolean isBorrowed;//Ob es ausgeliehen ist//set get method public int getBookId() {
        Buch-ID zurückgeben;
    }

    öffentliche void setBookId(int bookId) {
        this.bookId = Buch-ID;
    }

    öffentliche Zeichenfolge getName() {
        Rückgabename;
    }

    öffentliche void setName(String name) {
        dieser.name = Name;
    }

    öffentliche Zeichenfolge getAuthor() {
        Autor zurückgeben;
    }

    öffentliche void setAuthor(String author) {
        dieser.Autor = Autor;
    }

    öffentliche int getPreis() {
        Rücksendepreis;
    }

    öffentliche void setPrice(int Preis) {
        dieser.Preis = Preis;
    }

    öffentliche Zeichenfolge getType() {
        Rückgabetyp;
    }

    öffentliche void setType(String-Typ) {
        dieser.Typ = Typ;
    }

    öffentliches Boolean istGeliehen() {
        Rückgabe ist geliehen;
    }

    öffentliche Leere setBorrowed (boolean geliehen) {
        isBorrowed = geliehen;
    }

    @Überschreiben
    öffentliche Zeichenfolge toString() {
        return "Buch{" +
                "BuchID=" + BuchID +
                ", name='" + name + '\'' +
                ", Autor='" + Autor + '\'' +
                ", Preis=" + Preis +
                ", Typ='" + Typ + '\'' +
                ", istGeliehen=" + istGeliehen +
                '}';
    }

abstrakte öffentliche Klasse Benutzer {
    private int Benutzer-ID;
    privater String-Benutzername;
    privates String-Passwort;

    IOperation[] operations; //Methodenarray, das die in der Benutzerklasse enthaltenen Methoden angibt abstract int menu(); //Unterklassen müssen die Menümethode überschreiben, da die beiden Unterklassen unterschiedliche Menüs sehen public void doOperation(int choice) { //Diese Methode wird verwendet, um einige Operationen auszuführen, wie z. B. das Ausleihen und Zurückgeben von Büchern usw. operations[choice].work();
    }

    öffentliche int getUserId() {
        Benutzer-ID zurückgeben;
    }

    öffentliche void setUserId(int Benutzer-ID) {
        this.userId = Benutzer-ID;
    }

    öffentliche Zeichenfolge getUserName() {
        Benutzername zurückgeben;
    }

    public void setUserName(String benutzerName) {
        this.userName = Benutzername;
    }

    öffentliche Zeichenfolge getPassWord() {
        passwort zurückgeben;
    }

    öffentliche void setPassWord(String passWord) {
        this.passWord = Passwort;
    }

    @Überschreiben
    öffentliche Zeichenfolge toString() {
        return "Benutzer{" +
                "Benutzer-ID=" + Benutzer-ID +
                ", Benutzername='" + Benutzername + '\'' +
                ", passWord='" + passWord + '\'' +
                '}';
    }
}

öffentliche Klasse NormalUser erweitert Benutzer{
    öffentlicher NormalBenutzer(){
        this.operations = new IOperation[]{//Öffne ein separates Paket um diese Methoden zu speichern und zu implementieren new ExitOperation(), //System beenden new DisplayOperation(), //Bücherliste anzeigen new FindOperation(), //Buch suchen new BorrowOperation(), //Buch ausleihen new ReturnOperation(), //Buch zurückgeben};
    }
    @Überschreiben
    public int menu() {//Menümethode der übergeordneten Klasse überschreiben System.out.println("==========================");
        System.out.println("Willkommen, "+this.getUserName()+"!");
        System.out.println("1. Bücherliste anzeigen");
        System.out.println("2. Finden Sie das angegebene Buch");
        System.out.println("3. Bücher ausleihen");
        System.out.println("4. Bücher zurückgeben");
        System.out.println("0. Beenden Sie das System");
        System.out.println("=========================");
        System.out.println("Bitte geben Sie Optionen ein");
        Scanner sc = neuer Scanner (System.in);
        int choice=sc.nextInt();
        Rückgabeoption;
    }
}

öffentliche Klasse Admin erweitert Benutzer {
    öffentlicher Admin(){
        diese.operationen = neue IOperation[]{
                neue ExitOperation(), //System verlassen neue DisplayOperation(), //Bücherliste anzeigen neue FindOperation(), //Buch suchen neue AddOperation(), //Buch hinzufügen neue DelOperation(), //Buch löschen };
    }
    @Überschreiben
    öffentliches int-Menü () {
        System.out.println("=========================");
        System.out.println("Willkommen,"+this.getUserName()+"Sie sind Administrator!");
        System.out.println("1. Bücherliste anzeigen");
        System.out.println("2. Finden Sie das angegebene Buch");
        System.out.println("3. Neue Bücher");
        System.out.println("4. Bücher löschen");
        System.out.println("0. Beenden Sie das System");
        System.out.println("=========================");
        System.out.println("Bitte geben Sie Optionen ein");
        Scanner sc = neuer Scanner (System.in);
        int choice=sc.nextInt();
        Rückgabeoption;
    }
}

//Kapseln Sie hier die Datenbankverbindungsoperation public class DBUtil {
// URL-Konto und Passwort entsprechend den persönlichen Einstellungen festlegen private static final String URL="jdbc:mysql://127.0.0.1:3306/java100_bookmanager?characterEncoding=utf8&&useSSL=false";
    privater statischer endgültiger String BENUTZERNAME="root";
    privater statischer endgültiger String PASSWORD="q986681563";
    //Hungry Man-Modus//Der statische Codeblock wird während der Ladephase der Klasse zur Instanziierung aufgerufen/*private static DataSource dataSource=new MysqlDataSource();

    statisch{
        ((MysqlDataSource)Datenquelle).setUrl(URL);
        ((MysqlDataSource)dataSource).setUser(BENUTZERNAME);
        ((MysqlDataSource)dataSource).setPassword(PASSWORT);
    }*/
    //Lazy-Modus //Die Methode getDataSource wird nur beim ersten Mal instanziiert private static DataSource dataSource=null;
    öffentliche statische Datenquelle getDataSource() {
        wenn(dataSource==null){
            Datenquelle = neue MysqlDataSource();
            ((MysqlDataSource)Datenquelle).setUrl(URL);
            ((MysqlDataSource)dataSource).setUser(BENUTZERNAME);
            ((MysqlDataSource)dataSource).setPassword(PASSWORT);
        }
        Datenquelle zurückgeben;
    }
    öffentliche statische Verbindung getConnection() wirft SQLException {
        gibt getDataSource().getConnection() zurück;
    }
    public static void close(ResultSet resultSet, PreparedStatement statement,Connection connection){//Ressourcen freigeben//Die auskommentierte Methode ist sicherer/*if(resultSet!=null){
            versuchen {
                resultSet.close();
            } Fang (SQLException e) {
                e.printStackTrace();
            }
        }
        if(Anweisung!=null){
            versuchen {
                Anweisung.schließen();
            } Fang (SQLException e) {
                e.printStackTrace();
            }
        }
        if (Verbindung!=null) {
            versuchen {
                Verbindung.schließen();
            } Fang (SQLException e) {
                e.printStackTrace();
            }
        }*/
        versuchen {
            wenn(Ergebnismenge!=null) Ergebnismenge.schließen();
            if(Anweisung!=null) Anweisung.schließen();
            wenn(Verbindung!=null) Verbindung.schließen();
        } Fang (SQLException e) {
            e.printStackTrace();
        }
    }
}

//DAO-Datenzugriffsobjekt Datenzugriffsobjekt öffentliche Klasse BookDAO {
    //1. Neue Bücher hinzufügen public boolean add(Books book){
        Verbindung Verbindung=null;
        PreparedStatement-Anweisung=null;
        versuchen {
            Verbindung = DBUtil.getConnection();
            Zeichenfolge sql="in Buchwerte einfügen (null,?,?,?,?,?)";
            Anweisung=Verbindung.prepareStatement(sql);
            Anweisung.setString(1,book.getName());
            Anweisung.setString(2,book.getAuthor());
            Anweisung.setInt(3,book.getPrice());
            Anweisung.setString(4,book.getType());
            Anweisung.setInt(5,book.isBorrowed()?1:0);
            int ret = Anweisung.executeUpdate();
            wenn (ret!=1) false zurückgibt;
            gibt true zurück;
        } Fang (SQLException e) {
            e.printStackTrace();
        }Endlich {
            DBUtil.close(null,Anweisung,Verbindung);
        }
        gibt false zurück;
    }
    //2. Alle Bücher anzeigen public List<Books> selectAll(){
        Liste<Bücher> Liste=neue ArrayList<>();
        Verbindung Verbindung=null;
        PreparedStatement-Anweisung=null;
        Ergebnismenge Ergebnismenge=null;
        versuchen {
            Verbindung=DBUtil.getConnection();
            Zeichenfolge sql="select*from book";
            Anweisung=Verbindung.prepareStatement(sql);
            Ergebnismenge = Anweisung.executeQuery();
            während(resultSet.next()){
                Bücher Buch = neue Bücher();
                book.setBookId(resultSet.getInt("id"));
                book.setName(resultSet.getString("name"));
                book.setAuthor(resultSet.getString("Autor"));
                Buch.SetPrice(ErgebnisSet.getInt("Preis"));
                book.setType(resultSet.getString("Typ"));
                Buch.setBorrowed(resultSet.getInt("isBorrowed")==1);
                Liste.Hinzufügen(Buch);
            }
        } Fang (SQLException e) {
            e.printStackTrace();
        }Endlich {
            DBUtil.close(resultSet,Anweisung,Verbindung);
        }
        Liste zurückgeben;
    }
    //3. Bücher nach Namen suchen public List<Books> selectByName(String name) {
        Liste<Bücher> Liste=neue ArrayList<>();
        Verbindung Verbindung=null;
        PreparedStatement-Anweisung=null;
        Ergebnismenge Ergebnismenge=null;
        versuchen {
            Verbindung=DBUtil.getConnection();
            Zeichenfolge sql="Wählen Sie * aus dem Buch aus, wobei Name =?";
            Anweisung=Verbindung.prepareStatement(sql);
            Anweisung.setString(1,name);
            Ergebnismenge = Anweisung.executeQuery();
            während(resultSet.next()){
                Bücher Buch = neue Bücher();
                book.setBookId(resultSet.getInt("Id"));
                book.setName(resultSet.getString("name"));
                book.setAuthor(resultSet.getString("Autor"));
                book.setType(resultSet.getString("Typ"));
                Buch.SetPrice(ErgebnisSet.getInt("Preis"));
                Buch.setBorrowed(resultSet.getInt("isBorrowed")==1);
                Liste.Hinzufügen(Buch);
            }
        } Fang (SQLException e) {
            e.printStackTrace();
        }Endlich {
            DBUtil.close(resultSet,Anweisung,Verbindung);
        }
        Liste zurückgeben;
    }
    //4. Bücher löschen public boolean delete(int bookId){
        Verbindung Verbindung=null;
        PreparedStatement-Anweisung=null;
        versuchen {
            Verbindung=DBUtil.getConnection();
            String sql="Aus Buch löschen, in dem ID=?";
            Anweisung=Verbindung.prepareStatement(sql);
            Anweisung.setInt(1,bookId);
            int ret = Anweisung.executeUpdate();
            wenn (ret!=1) false zurückgibt;
            gibt true zurück;
        } Fang (SQLException e) {
            e.printStackTrace();
        }Endlich {
            DBUtil.close(null,Anweisung,Verbindung);
        }
        gibt false zurück;
    }
    //5. Ein Buch ausleihen public boolean borrowBook(int bookId){
        Verbindung Verbindung=null;
        PreparedStatement-Anweisung=null;
        PreparedStatement-Anweisung2=null;
        Ergebnismenge Ergebnismenge=null;
        versuchen {
            Verbindung=DBUtil.getConnection();
            Zeichenfolge sql="Wählen Sie * aus dem Buch aus, wobei id=?";
            Anweisung=Verbindung.prepareStatement(sql);
            Anweisung.setInt(1,bookId);
            Ergebnismenge = Anweisung.executeQuery();
            wenn(resultSet.next()){
                boolean istGeliehen=(resultSet.getInt("istGeliehen")==1);
                wenn(istGeliehen){
                    System.out.println("Das Buch wurde ausgeliehen und kann nicht erneut ausgeliehen werden! bookId="+bookId);
                    gibt false zurück;
                }
            }anders{
                System.out.println("Buch existiert nicht bookId="+bookId);
                gibt false zurück;
            }
            sql="Buch aktualisieren, Satz isBorrowed=1, wobei id=?";
            Anweisung2 = Verbindung.prepareStatement(sql);
            Anweisung2.setInt(1,bookId);
            int ret = Anweisung2.executeUpdate();
            wenn(ret!=1) {
                System.out.println("Ausleihen fehlgeschlagen");
                gibt false zurück;
            }
            System.out.println("Ausleihen erfolgreich");
            gibt true zurück;
        } Fang (SQLException e) {
            e.printStackTrace();
        }Endlich {
            wenn(Ergebnismenge!=null) {
                versuchen {
                    Verbindung.schließen();
                } Fang (SQLException-Ausnahmen) {
                    throwables.printStackTrace();
                }
            }
            if(Anweisung!=null) {
                versuchen {
                    Anweisung.schließen();
                } Fang (SQLException-Ausnahmen) {
                    throwables.printStackTrace();
                }
            }
            wenn(Anweisung2!=null) {
                versuchen {
                    Anweisung2.schließen();
                } Fang (SQLException-Ausnahmen) {
                    throwables.printStackTrace();
                }
            }
            if (Verbindung!=null) {
                versuchen {
                    Verbindung.schließen();
                } Fang (SQLException-Ausnahmen) {
                    throwables.printStackTrace();
                }
            }
        }
        gibt false zurück;
    }
    //6. Rückgabewert: public boolean returnBook(int bookId){
        Verbindung Verbindung=null;
        PreparedStatement-Anweisung=null;
        PreparedStatement-Anweisung2=null;
        Ergebnismenge Ergebnismenge=null;
        versuchen {
            Verbindung=DBUtil.getConnection();
            Zeichenfolge sql="Wählen Sie * aus dem Buch aus, wobei id =?";
            Anweisung=Verbindung.prepareStatement(sql);
            Anweisung.setInt(1,bookId);
            Ergebnismenge = Anweisung.executeQuery();
            wenn(resultSet.next()){
                boolean istGeliehen=(resultSet.getInt("istGeliehen")==1);
                wenn(!istGeliehen){
                    System.out.println("Das Buch wurde nicht ausgeliehen und muss nicht zurückgegeben werden bookId="+bookId);
                    gibt false zurück;
                }
            }anders{
                System.out.println("Es gibt kein solches Buch! bookId="+bookId);
                gibt false zurück;
            }
            sql="Buch aktualisieren, Satz isBorrowed=0, wobei id=?";
            Anweisung2 = Verbindung.prepareStatement(sql);
            Anweisung2.setInt(1,bookId);
            int ret = Anweisung2.executeUpdate();
            wenn (ret!=1) false zurückgibt;
            gibt true zurück;
        } Fang (SQLException e) {
            e.printStackTrace();
        }Endlich {
            wenn(Ergebnismenge!=null) {
                versuchen {
                    Verbindung.schließen();
                } Fang (SQLException-Ausnahmen) {
                    throwables.printStackTrace();
                }
            }
            if(Anweisung!=null) {
                versuchen {
                    Anweisung.schließen();
                } Fang (SQLException-Ausnahmen) {
                    throwables.printStackTrace();
                }
            }
            wenn(Anweisung2!=null) {
                versuchen {
                    Anweisung2.schließen();
                } Fang (SQLException-Ausnahmen) {
                    throwables.printStackTrace();
                }
            }
            if (Verbindung!=null) {
                versuchen {
                    Verbindung.schließen();
                } Fang (SQLException-Ausnahmen) {
                    throwables.printStackTrace();
                }
            }
        }
        gibt false zurück;
        }
    }
   

öffentliche Klasse UserDao {
    //Logik zum Suchen von Passwörtern basierend auf Benutzernamen //Benutzername ist eine eindeutige Einschränkung public user selectByName(String name){
        Verbindung Verbindung=null;
        PreparedStatement-Anweisung=null;
        Ergebnismenge Ergebnismenge=null;
        versuchen {
            Verbindung=DBUtil.getConnection();
            Zeichenfolge sql="select* from user where username=?";
            Anweisung=Verbindung.prepareStatement(sql);
            Anweisung.setString(1,name);
            Ergebnismenge = Anweisung.executeQuery();
            wenn(resultSet.next()){
                boolean istAdmin=(resultSet.getInt("isAdmin")==1);
                Benutzer Benutzer=null;
                wenn(istAdmin){
                    Benutzer = neuer Admin();
                }sonst Benutzer=neuer NormalBenutzer();
                users.setPassWord(resultSet.getString("Passwort"));
                Benutzer.setUserId(resultSet.getInt("userId"));
                users.setUserName(resultSet.getString("Benutzername"));
                wiederkehrende Benutzer;
            }

        } Fang (SQLException e) {
            e.printStackTrace();
        }Endlich {
            DBUtil.close(resultSet,Anweisung,Verbindung);
        }
        gibt null zurück;
    }
}

öffentliche Klasse Main {
    öffentliche statische void main(String[] args) {
        Benutzer Benutzer=Anmelden();
        während(wahr){
            int choice=Benutzer.menü();
            Benutzer.doOperation(Auswahl);
        }
    }
    private statische Benutzeranmeldung(){
        Scanner sc = neuer Scanner (System.in);
        System.out.println("Bitte geben Sie Ihren Benutzernamen ein");
        Zeichenfolgename=sc.next();
        System.out.println("Bitte geben Sie Ihr Passwort ein");
        Zeichenfolge „Passwort“ = sc.next();
        UserDao userDao=neues UserDao();
        Benutzer Benutzer=userDao.selectByName(Name);
        wenn(Benutzer==null){
            System.out.println("Anmeldung fehlgeschlagen!");
            System.exit(0);
        }
        wenn(!users.getPassWord().equals(password)){
            System.out.println("Falsches Passwort");
            System.exit(0);
        }
        wiederkehrende Benutzer;
    }
}

öffentliche Schnittstelle IOperation {
    ungültige Arbeit();
}

öffentliche Klasse AddOperation implementiert IOperation{
    @Überschreiben
    öffentliche Leere Arbeit () {
        System.out.println("Neue Bücher!");
        Scanner sc = neuer Scanner (System.in);
        System.out.println("Bitte geben Sie den Titel des Buches ein");
        Zeichenfolgename=sc.next();
        System.out.println("Bitte geben Sie den Autor ein");
        Zeichenfolge Autor = sc.next();
        System.out.println("Bitte geben Sie den Preis ein");
        int Preis = sc.nextInt();
        System.out.println("Bitte geben Sie die Kategorie ein");
        Zeichenfolgetyp = sc.next();
        Bücher Buch = neue Bücher();
        Buch.setName(Name);
        buch.setPrice(Preis);
        Buch.setType(Typ);
        book.setAuthor(Autor);
        BookDAO bookDAO=neues BookDAO();
        boolean ret = bookDAO.add(Buch);
        if(ret) System.out.println("Erfolgreich hinzugefügt");
        sonst System.out.println("Addition fehlgeschlagen");
    }
}

öffentliche Klasse BorrowOperation implementiert IOperation {
    @Überschreiben
    öffentliche Leere Arbeit () {
        System.out.println("Ausgeliehene Bücher");
        System.out.println("Bitte geben Sie die Buch-ID ein, die Sie ausleihen möchten");
        Scanner sc = neuer Scanner (System.in);
        int id=sc.nextInt();
        BookDAO bookDAO=neues BookDAO();
        boolean ret = bookDAO.borrowBook(id);
    }
}

öffentliche Klasse DelOperation implementiert IOperation{
    @Überschreiben
    öffentliche Leere Arbeit () {
        System.out.println("Bücher löschen!");
        Scanner sc = neuer Scanner (System.in);
        System.out.println("Bitte geben Sie die ID des zu löschenden Buches ein");
        int id=sc.nextInt();
        BookDAO bookDAO=neues BookDAO();
        boolean ret = bookDAO.delete(id);
        if(ret) System.out.println("Erfolgreich gelöscht");
        sonst System.out.println("Löschen fehlgeschlagen");
    }
}

öffentliche Klasse DisplayOperation implementiert IOperation {
    @Überschreiben
    öffentliche Leere Arbeit () {
        System.out.println("Alle Bücher anzeigen");
        BookDAO bookdao=neues BookDAO();
        Liste<Bücher> Liste=bookdao.selectAll();
        für(Bücher Buch:Liste){
            System.out.println(Buch);
        }
        System.out.println("Buchanzeige abgeschlossen");
    }
}

öffentliche Klasse ExitOperation implementiert IOperation{
    @Überschreiben
    öffentliche Leere Arbeit () {
        System.out.println("Programm beenden");
        System.exit(0);
    }
}

öffentliche Klasse FindOperation implementiert IOperation{
    @Überschreiben
    öffentliche Leere Arbeit () {
        System.out.println("Suche nach Büchern nach Namen");
        System.out.println("Bitte geben Sie den Titel des Buches ein");
        Scanner sc = neuer Scanner (System.in);
        Zeichenfolgename=sc.next();
        BookDAO bookDAO=neues BookDAO();
        Liste<Bücher> Bücher = bookDAO.selectByName(Name);
        für(Bücher Buch:Bücher){
            System.out.println(Buch);
        }
        System.out.println("Suche nach Büchern nach Namen abgeschlossen");
    }
}

öffentliche Klasse ReturnOperation implementiert IOperation{
    @Überschreiben
    öffentliche Leere Arbeit () {
        System.out.println("Gebt die Bücher zurück!");
        System.out.println("Bitte geben Sie die ID des Buches ein, das Sie zurückgeben möchten");
        Scanner sc = neuer Scanner (System.in);
        int id=sc.nextInt();
        BookDAO bookDAO=neues BookDAO();
        boolean ret = bookDAO.returnBook(id);
        wenn(ret){
            System.out.println("Rückgabe erfolgreich");
        }anders{
            System.out.println("Rückgabe fehlgeschlagen");
        }
    }
}