4.16学习总结 - 技术栈

MySQL数据库学习(一)

一.MySQL数据库的基本知识

(一).数据库

概念：数据仓库,软件,安装在操作系统之上

作用：存储数据，管理数据

(二).数据库的分类

关系型数据库：SQL（Structured Query Language）

MySQL、Oracle、Sql Server、DB2、SQLlite

通过表和表之间，行和列之间的关系进行数据的存储

通过外键关联来建立表与表之间的关系

非关系型数据库：NoSQL（Not Only SQL）

Redis、MongoDB

指数据以对象的形式存储在数据库中，而对象之间的关系通过每个对象自身的属性来决定

(三).数据库三层结构

1.所有安装Mysql数据库，就是在主机安装一个数据库管理系统(DBMS)，这个管理程序可以管理多个数据库。DBMS(database manage system)

2.一个数据库中可以创建多个表，以保存数据(信息)。

3.数据库管理系统(DBMS)、数据库、表三者之间的关系。

二.SQL语句

(一).SQL语句概述

Structure Query Language(结构化查询语言)简称SQL，它被美国国家标准局(ANSI)确定为关系型数据库语言的美国标准，后被国际化标准组织(ISO)采纳为关系数据库语言的国际标准。数据库管理系统可以通过SQL管理数据库；定义和操作数据，维护数据的完整性和安全性. 原文链接：https://blog.csdn.net/weixin_45851945/article/details/114287877

(二).SQL语句的分类

1、DDL(Data Definition Language) 数据定义语言，用来操作数据库、表、列等；常用语句：CREATE、 ALTER、DROP

2、DML(Data Manipulation Language) 数据操作语言，用来操作数据库中表里的数据；常用语句：INSERT、 UPDATE、 DELETE

3、DCL(Data Control Language) 数据控制语言，用来操作访问权限和安全级别；常用语句：GRANT、DENY

4、DQL(Data Query Language) 数据查询语言，用来查询数据常用语句：SELECT

(三).SQL语句的优点

1、简单易学，具有很强的操作性

2、绝大多数重要的数据库管理系统均支持SQL

3、高度非过程化；用SQL操作数据库时大部分的工作由DBMS自动完成

三.数据库操作

1.数据库操作

表操作

2.数据库的字段属性

1.UnSigned

无符号的
声明了该列不能为负数

2.ZEROFILL

0填充的
不足位数的用0来填充 , 如int(3),5则为005

3.Auto_InCrement

通常理解为自增，自动在上一条记录的基础上默认+1
通常用来设计唯一的主键，必须是整数类型
可定义起始值和步长

4.NULL 和 NOT NULL

默认为NULL , 即没有插入该列的数值
如果设置为NOT NULL , 则该列必须有值

5.DEFAULT

默认的
用于设置默认值
例如,性别字段,默认为"男" , 否则为 "女" ; 若无指定该列的值 , 则默认值为"男"的值

3.数据库列类型

1.数值类型

2.字符串类型

3.时间类型

二.网络编程练习

一.要求:

要求在两个项目中实现一个简单的服务端及客户端要求服务端能够同时连接多个客户端且客户端与服务端之间能够持续多次通信

二.设计思路:

分别为客户端和服务端创建多个线程,客户端主线程用来连接服务端,副线程用来对服务端的信息进行监听,服务端,主线程用来监听客户端,保持客户端连接,副线程用于接受发消息.同时,创建多个客户端时,我们应将多个客户端的socket对象放入集合中.

三.代码实现

服务端:

public class Server {
    public static void main(String[] args) {
        List<Socket> socketList=new ArrayList<>();
        //开启线程接收客户端连接
        new Thread(new AcceptSocket(socketList)).start();
        //向所有用户发送消息
        while(true) {
            Scanner scanner=new Scanner(System.in);
            String sendinfo=scanner.nextLine();
            //遍历集合向每一个客户端发送消息
            socketList.forEach(socket -> {
                try {
                    PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
                    printWriter.println(sendinfo);
                    printWriter.flush();
                } catch (SocketException e) {
                    System.out.println(1);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

//等待客户端连接,主线程
class AcceptSocket implements Runnable{

    List<Socket> socketlist;

    //构造函数
    public AcceptSocket(List<Socket> socketList){
        this.socketlist=socketList;
    }

    //重写run方法
    @Override
    public void run() {
        ServerSocket serverSocket=null;
        try {
            //创建对象并绑定端口
            serverSocket=new ServerSocket(9000);
            System.out.println("正在监听客户端连接");
            //循环接收客户端的请求
            while(true)
            {
                Socket socket=serverSocket.accept();
                //将接受到后加入到socketList
                socketlist.add(socket);
                //开启处理客户端线程,开启分线程处理客户端消息
                new Thread(new getSocket(socket,socketlist)).start();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //释放资源
            if(null!=serverSocket){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

//出来客户端的信息,分线程
class getSocket implements Runnable {

    Socket socket=null;
    List<Socket> socketList;

    //构造函数
    public getSocket(Socket socket,List<Socket> socketList){
        this.socket=socket;
        this.socketList=socketList;
    }

    @Override
    public void run() {
        BufferedReader bufferedReader=null;
        try {
            //缓冲流,接收信息
            bufferedReader=new BufferedReader(new InputStreamReader(socket.getInputStream()));
            System.out.println("已连接,准备读取客户端:"+socket.getLocalAddress().toString()+":"+socket.getPort());
            while(true)
            {
                String clientinfo=bufferedReader.readLine();
                //打印信息
                System.out.println(socket.getLocalAddress().toString().substring(1) + ":" + socket.getPort() + "发送的消息是：" + clientinfo);
            }

        } catch (SocketException e) {
            System.out.println(socket.getLocalAddress().toString().substring(1) + ":" + socket.getPort() + "断开连接");
            socketList.remove(socket);
        } catch (IOException e){
            e.printStackTrace();
        } finally {
            try {
                if (null!=bufferedReader){
                    bufferedReader.close();
                }
                if(null!=socket){
                    socket.close();
                }
            }  catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

客户端:

//客户端,连接服务器
public class Client {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Socket socket = null;
        PrintWriter printWriter = null;
        try {
            socket = new Socket("localhost", 9000);
            printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));

            //开启线程接收服务端的消息
            new Thread(new AcceptServer(socket)).start();
            System.out.println("可以给服务器端发送数据了");
            while (true) {
                // 给服务端发送消息
                String sendInfo = scanner.nextLine();
                printWriter.println(sendInfo);
                printWriter.flush();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭连接
            try {
                if (null != socket) {
                    socket.close();
                }
                if (null != printWriter) {
                    printWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

//接收服务器的信息,分线程
class AcceptServer implements Runnable {

    Socket socket;

    public AcceptServer(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        BufferedReader bufferedReader = null;
        try {
            bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            while (true) {
                String serverInfo = bufferedReader.readLine();
                System.out.println("服务器的消息为：" + serverInfo);
            }
        } catch (SocketException e) {
            System.out.println("服务器异常关闭");
            // 退出
            System.exit(0);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭连接
            try {
                if (null != bufferedReader) {
                    bufferedReader.close();
                }
                if (null != socket) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}