8月22号 JDBC，线程，网络编程补充

JDBC编程步骤：
加载驱动程序：Class.forName(driverClass)
加载Mysql驱动：Class.forName("com.mysql.jdbc.Driver")
获得数据库连接：DriverManager.getConnection("jdbc:mysql://localhost:3306/imooc","root","root")
创建Statement对象，conn.createStatement();来对数据库进行操作
DAO(Data Access Object) 数据访问对象是第一个面向对象的接口，它显露了 Microsoft Jet 数据库引擎（由 Microsoft Access 所使用），并允许 Visual Basic 开发者通过 ODBC 像直接连接到其他数据库一样，直接连接到 Access 表。DAO 最适用于单系统应用程序或小范围本地分布使用

详细设置：

MVC
​常用MVC三层架构：
View       视图层 显示数据（数据库记录）。
Control    控制层 处理输入（写入数据库记录）。
Model      模型层(dao,接口,impl) 表示应用程序核心（比如数据库记录列表）。

DB         数据库

​ 线程：
Java语言对线程的支持：

基于java.lang中的class Thread和interface Runnable,里面都有一个共通的方法public void run();

Thread常用方法
volatile保证线程可以正确的读取其他线程写入的值，可见性
volatile boolean flag = true;
错误方法：stop();
stop方法会使程序戛然而止，突然的停止，有些进程还没执行，或者没执行完成，线程就被stop强行终止，所以不建议使用stop方法。
正确的方法：
使用退出标志：在线程中设定volatile boolean flag = true;
public void run(){
while(flag){
线程内容
}
}    如果要结束线程，直接将线程的flag值设定为false，线程就会正常结束
广为流传的错误方法：interrupt();
实现互斥与同步：
构造一个锁的对象：
在类中添加一个  private final Object lock = new Object();
synchronized(lock){
while(){lock.wait();}    //while循环，保证条件不满足时任务都被条件阻挡
线程代码，该段代码互斥操作
lock.notifyAll();     //唤醒所有lock对象上等待的线程
}
 
网络编程​
​java的网络支持：
针对网络通信的不同层次，java提供的
网络功能的四大类：
InetAddress   用于标识网络上的硬件资源
URL  统一资源定位符，通过URL可以直接读取或写入网络上的数据
Scokets   使用TCP协议实现网络通信的Scoket相关的类
Datagram   使用UDP协议，将数据保存在数据报中，通过网络进行通信
InetAddress：
//获取本机的InetAddress实例
InetAddress address = InetAddress.getLocalHost();
System.out.println("计算机名："+address.getHostName());
System.out.println("IP地址："+address.getHostAddress());
byte[] bytes=address.getAddress();   //获取字节数组形式的ip地址
System.out.println("字节数组形式的IP:"+java.util.Arrays.toString(bytes));
System.out.println(address);   //直接输出Inetaddress对象
InetAddress address2 = InetAddress.getByName("J1VB4CXMG7WMRPP");//通过计算机名或IP地址获取Inetaddress对象
URL：
由两部分组成：协议名称和资源名称，中间用冒号隔开，在java.net包中，提供URL类来表示URL
通过URL获取地址的属性：

public class Test {
    public static void main(String[] args) {
        //创建URL实例
        try {
            URL imooc = new URL("http://www.imooc.com");
            //#后面表示锚点
            URL url = new URL(imooc, "/index.html?username=tom#test");
            System.out.println("协议：" + url.getProtocol());
            System.out.println("主机：" + url.getHost());
            //如果未指定端口号，使用默认端口号，获取端口号的方法返回-1
            System.out.println("端口：" + url.getPort());
            System.out.println("文件路径：" + url.getPath());
            System.out.println("文件名：" + url.getFile());
            System.out.println("相对路径：" + url.getRef());
            System.out.println("查询字符串：" + url.getQuery());
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }
}

结果：
协议：http
主机：www.imooc.com
端口：-1
文件路径：/index.html
文件名：/index.html?username=tom
相对路径：test
查询字符串：username=tom
通过URL获取网页源码：

public class Test {
    public static void main(String[] args) {
        try {
            URL url = new URL("http://www.baidu.com");
            InputStream is = url.openStream();
            InputStreamReader isr = new java.io.InputStreamReader(is, "utf-8");
            BufferedReader br = new BufferedReader(isr);
            String data = br.readLine();
            while (data != null) {
                System.out.println(data);
                data = br.readLine();
            }
            br.close();
            isr.close();
            is.close();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
        // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
    }
}

结果是百度首页的源码。

Socket通信：

​TCP协议是面向连接，可靠的，有序的，以字节流的方式发送数据，基于TCP协议实现网络通信的类。
客户端的socket类，服务器端的servletsocket类
前面已经介绍过socket的相关知识：这里来说明一下socket的多线程连接：
首先是客户端：

public static void main(String[] args) {
        try {
            //1.创建客户端Socket，指定服务器地址和端口
            Socket socket = new Socket("localhost", 8888);
            //2.获取输出流，向服务器端发送信息
            OutputStream os = socket.getOutputStream();//字节输出流
            PrintWriter pw = new PrintWriter(os);//将输出流包装为打印流
            pw.write("用户名：alice;密码：789");
            pw.flush();
            socket.shutdownOutput();//关闭输出流
            //3.获取输入流，并读取服务器端的响应信息
            InputStream is = socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String info = null;
            while ((info = br.readLine()) != null) {
                System.out.println("我是客户端，服务器说：" + info);
            }
            //4.关闭资源
            br.close();
            is.close();
            pw.close();
            os.close();
            socket.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

然后是服务器端：

    public static void main(String[] args) {
        try {
            //1.创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口
            ServerSocket serverSocket = new ServerSocket(8888);
            Socket socket = null;
            //记录客户端的数量
            int count = 0;
            System.out.println("***服务器即将启动，等待客户端的连接***");
            //循环监听等待客户端的连接
            while (true) {
                //调用accept()方法开始监听，等待客户端的连接
                socket = serverSocket.accept();
                //创建一个新的线程
                ServerThread serverThread = new ServerThread(socket);
                //启动线程
                serverThread.start();
                count++;//统计客户端的数量
                System.out.println("客户端的数量：" + count);
                InetAddress address = socket.getInetAddress();
                System.out.println("当前客户端的IP：" + address.getHostAddress());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

服务器多线程相应机制：

    public class ServerThread extends Thread {
        // 和本线程相关的Socket
        Socket socket = null;

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

        //线程执行的操作，响应客户端的请求
        public void run() {
            InputStream is = null;
            InputStreamReader isr = null;
            BufferedReader br = null;
            OutputStream os = null;
            PrintWriter pw = null;
            try {
                //获取输入流，并读取客户端信息
                is = socket.getInputStream();
                isr = new InputStreamReader(is);
                br = new BufferedReader(isr);
                String info = null;
                while ((info = br.readLine()) != null) {//循环读取客户端的信息
                    System.out.println("我是服务器，客户端说：" + info);
                }
                socket.shutdownInput();//关闭输入流
                //获取输出流，响应客户端的请求
                os = socket.getOutputStream();
                pw = new PrintWriter(os);
                pw.write("欢迎您！");
                pw.flush();//调用flush()方法将缓冲输出
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //关闭资源
                try {
                    if (pw != null) pw.close();
                    if (os != null) os.close();
                    if (br != null) br.close();
                    if (isr != null) isr.close();
                    if (is != null) is.close();
                    if (socket != null) socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

先行启动服务器端，然后启动客户端，服务器端会相应并输出用户数为1，在启动客户端，服务器会再次相应，数量变为2.
UDP的socket：
服务器端实现步骤：
1，创建datagramsocket，指定端口号
2，创建datagrampacket
3，接受客户端发送的数据信息
4，读取数据
客户端实现步骤：
1，定义发送信息
2，创建datagrampacket，包含要发送的信息
3，创建datagramsocket
4，发送信息