2018-06-15 第四十天
一、TCP
使用 Socket 对象 进行 通信 ，使用底层的TCP 协议。
面向连接的协议。
1：先建立连接。 通信的两端 都会有进行通信的Socket 对象。
2：使用Socket 对象 使用字节流进行消息的通信。
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 使用 Socket 连接服务器，给服务器发送一条信息。服务器收到之后，反馈一个boolean 值。
*
*/
public class MyServer {
public static final int SERVER_PORT = 1777;
public static void main(String[] args) throws Exception{
//创建建立连接服务的 服务对象。
ServerSocket ss = new ServerSocket(SERVER_PORT);
System.out.println("等待连接的请求！");
//阻塞式方法，只有连接请求发过来之后，该方法才会返回，并生成一个与连接过来的对象进行通信的Socket。
Socket socket = ss.accept();
System.out.println("连接成功！---"+socket);
//获取客户端发送的数据
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String str = br.readLine();
System.out.println("服务器收到的信息为："+str);
//给客户端回复一个boolean 值
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
dos.writeBoolean(true);
dos.flush();
//需要写到finally 中 代码
socket.close();
ss.close();
}
}
class MyClient{
public static void main(String[] args) throws Exception{
//创建连接服务器的Socket 对象
Socket socket = new Socket("127.0.0.1", MyServer.SERVER_PORT);
//给服务器发送一条信息
String str = "我可以连接你么？";
OutputStream os = socket.getOutputStream();
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
bw.write(str);
bw.newLine();
bw.flush();
//接收服务的反馈
DataInputStream dis = new DataInputStream(socket.getInputStream());
System.out.println("服务器的反馈："+dis.readBoolean());
dis.close();
bw.close();
socket.close();
}
}
二、tcp-模拟用户登录
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Properties;
/**
* 模拟用户登录
*
* 客户端：发送一个用户名+密码给服务器。接收服务器的一个反馈。
* 服务器：接收客户端的登录请求，解析客户端的用户名和密码知否有效（需要和数据库中的用户信息比对）。
* 如果用户存在，返回 true，否则返回 false。
*
*/
public class LoginServer {
public static final int SERVER_PORT = 1777;
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket(SERVER_PORT);
Socket socket = ss.accept();
System.out.println(socket);
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] buf = new byte[100];
int count = bis.read(buf);
String str = new String(buf,0,count);
String name = str.split("&")[0].split("=")[1];
String pwd = str.split("&")[1].split("=")[1];
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
dos.writeBoolean(hasUser(name,pwd));
dos.flush();
socket.close();
ss.close();
}
/**
* 判断 配置文件中，是否包含指定的用户
* @param name
* @param pwd
* @return
*/
public static boolean hasUser(String name, String pwd)throws Exception{
Properties users = new Properties();
users.load(new FileInputStream("./res/users.txt"));
boolean bool = users.containsKey(name);
if(bool){//人存在，比对密码
if(users.getProperty(name).equals(pwd)){
return true;
}
return false;
}
return false;
}
}
class LoginClient{
public static void main(String[] args) throws Exception{
Socket socket = new Socket("192.168.51.242", LoginServer.SERVER_PORT);
String str = "name=xiaogang&pwd=123456";
byte[] buf = str.getBytes();
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
bos.write(buf);
bos.flush();
DataInputStream dis = new DataInputStream(socket.getInputStream());
System.out.println("服务器的反馈："+dis.readBoolean());
//只关闭socket 即可。
socket.close();
}
}
三、tcp-转换大写
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 需求：客户端给服务器发送一个字符串，可以多次发送，服务器接收到之后，将字符串的大写形式返回。
* 客户端发送一个bye，结束转换
*
*/
public class UpperCaseServer {
//收到字符串，转换为大写返回
public static final int SERVER_PORT = 1777;
public static final String BYE_STR = "bye";
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket(SERVER_PORT);
//监听连接请求
Socket socket = ss.accept();
System.out.println(socket);
//得到读取输入流的字符输入流，，得到往输出流写数据的字符输出流
// br 用于读取小写信息
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//bw 用户回复大写
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
while(true){
//读取客户端发送的内容，转换大写，回复，切记要刷新
String string = br.readLine();
if(BYE_STR.equals(string)){
break;
}
bw.write(string.toUpperCase());
bw.newLine();
bw.flush();
}
socket.close();
ss.close();
}
}
class UpperCaseClient{
public static void main(String[] args) throws Exception{
Socket socket = new Socket("192.168.51.242", UpperCaseServer.SERVER_PORT);
//bw 用于发送给服务器信息的 字符输出流
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
//br 用于读取服务器反馈的
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//用于本地输入的
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
while(true){
System.out.println("请您输入要转换的内容：");
//接收键盘的输入
String string = input.readLine();
//将string 发送给服务器
bw.write(string);
bw.newLine();
bw.flush();
//如果输入了bye ，结束 循环
if(UpperCaseServer.BYE_STR.equals(string))
break;
//读取服务器的反馈
String response = br.readLine();
System.out.println(response);
}
socket.close();
}
}
四、tcp-上传文件
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 服务器上传文件：
*
* 客户端：
* 1：先把文件的名字传给服务器
* 2：读取本地文件的数据，发送给服务器。
*
* 服务器：
* 1：接收文件的名字
* 2：接收文件数据，写入到本地。
*
*/
public class UploadFileServer {
public static final int PORT = 1777;
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket(PORT);
Socket socket = ss.accept();
System.out.println(socket);
DataInputStream dis = new DataInputStream(socket.getInputStream());
//获得文件的名字
String fileName = dis.readUTF();
//写到本地字节输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("c:/server/"+fileName));
//读取客户端发送的数据
BufferedInputStream bis =new BufferedInputStream(socket.getInputStream());
byte[] buf = new byte[100];
int count = bis.read(buf);
while(count != -1){
bos.write(buf, 0, count);
count = bis.read(buf);
}
bos.flush();
bos.close();
//给客户端的反馈
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
dos.writeUTF(fileName + "\t上传成功！");
dos.flush();
socket.close();
ss.close();
}
}
class UploadFileClient{
public static void main(String[] args) throws Exception{
Socket socket = new Socket("192.168.51.242", UploadFileServer.PORT);
File file = new File("c:/dear.jpg");
//将文件的名字发过去
String name = file.getName();
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
dos.writeUTF(name);
dos.flush();
//可以得到文件的字节大小，给服务器发过去。
//发送字节数据
//读取本地字节数据
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
//将读取到的字节数据发送出去
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
byte[] buf = new byte[100];
//读取本地字节数据
int count = bis.read(buf);
while(count != -1){
bos.write(buf, 0, count);
//读取本地字节数据
count = bis.read(buf);
}
bos.flush();
bis.close();
//给输出流添加一个流的末尾的标识,不会影响其他的流
socket.shutdownOutput();
//接收服务器的反馈 ，文件上传成功
DataInputStream dis = new DataInputStream(socket.getInputStream());
System.out.println("服务器反馈："+dis.readUTF());
socket.close();
}
}
五、tcp-并发上传
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
/**
* 服务器上传文件：
*
* 服务器：
* 1：可以同时 响应多个客户端上传文件的请求
* 2：需要满足一个客户端 多次上传同一个文件的需求。
* 客户端的IP地址 + 当前时间的时间戳（System.currentTimeMillis()） + 文件名.txt
*/
public class UploadFileServer {
public static final int PORT = 1777;
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket(PORT);
ArrayList<Socket> sockets = new ArrayList<>();
try {
while(true){
Socket socket = ss.accept();
//得到一个socket 连接之后，立马启动一个线程，该线程负责 当前得到的socket 对象和 与之对应的客户端的通信。
sockets.add(socket);
System.out.println(socket);
//来了一个请求，就需要启动一个线程，该线程负责和该请求进行通信。
new SocketThread(socket).start();
}
} finally {
ss.close();
}
}
/**
* 用来和客户端的一个请求的socket 进行通信的。
*
*/
static class SocketThread extends Thread{
private Socket socket;
public SocketThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
DataInputStream dis = new DataInputStream(socket.getInputStream());
//获得文件的名字
String fileName = dis.readUTF();
//写到本地字节输出流
//TODO
String ip = socket.getInetAddress().getHostAddress();
String timeStr = Long.toString(System.currentTimeMillis());
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("c:/server/"+ip+"_"+timeStr + "_"+ fileName));
//读取客户端发送的数据
BufferedInputStream bis =new BufferedInputStream(socket.getInputStream());
byte[] buf = new byte[10000];
int count = bis.read(buf);
while(count != -1){
bos.write(buf, 0, count);
count = bis.read(buf);
//Thread.sleep(10);
}
bos.flush();
bos.close();
//给客户端的反馈
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
dos.writeUTF(fileName + "\t上传成功！");
dos.flush();
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
六、断点续传
1：从服务器下载文件。
第一步：给服务器发送一个 下载文件的名字（String）；
第二步：服务器从本地读取指定的文件，再通过输出流发送给客户端。
中断了。
2：需要发送2调数据：
1：想要下载的文件的名字。
2：已经下载的文件的大小。
服务器收到已经下载的字节数据的大小，从指定的位置开始读取文件下发给客户端。
---- skip(1024*1024)。
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 从服务器下载文件。断点续传
*
*/
public class DownLoadFileServer {
public static final int SERVER_PORT = 1777;
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket(SERVER_PORT);
Socket socket = ss.accept();
//读取文件的名字
DataInputStream dis = new DataInputStream(socket.getInputStream());
String fileName = dis.readUTF();
//读取文件的大小(已经下载的文件大小)
long size = dis.readLong();
//发送文件是否存在
File file = new File("c://server/"+fileName);
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
boolean exist = file.exists();
dos.writeBoolean(exist);
if(!exist){//文件不存在，结束
socket.close();
ss.close();
return;
}
//读取本地数据，发送给客户端
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
byte[] buf = new byte[1000];
//从文件指定的位置读取
bis.skip(size);
int count = bis.read(buf);
while(count!= -1){
bos.write(buf,0,count);
bos.flush();
count = bis.read(buf);
}
bis.close();
socket.close();
ss.close();
}
}
/**
* 服务器下载文件，客户端
*
*/
class DownLoadFileClient{
public static void main(String[] args) throws Exception{
Socket socket = new Socket("192.168.51.242" , DownLoadFileServer.SERVER_PORT);
//发送请求文件名字
File file = new File("c://dear.jpg");
String fileName = file.getName();
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
dos.writeUTF(fileName);
dos.flush();
//如果文件存在，发送文件大小给服务器，不存在发送0 给服务器
long size = 0;
if(file.exists()){
size = file.length();
}
dos.writeLong(size);
dos.flush();
//接收服务器的反馈，如果服务器文件不存在，则直接终止程序
DataInputStream dis = new DataInputStream(socket.getInputStream());
boolean fileExist = dis.readBoolean();
if(!fileExist){
System.out.println("请求文件不存在，下载 失败！");
socket.close();
return;
}
//接收服务器发送的数据写到本地。切记要写入指定的文件，尾部追加
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file, true));
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] buf = new byte[1000];
int count = bis.read(buf);
while(count != -1){
bos.write(buf, 0, count);
bos.flush();
count = bis.read(buf);
Thread.sleep(10);
}
bos.close();
socket.close();
}
}
1：如果涉及到缓冲流，Buffered 相关的， 要及时对流进行刷新 调用flush 方法。
2：关闭流的时候，只需要关闭socket ，关闭socket 就会把socket 的inputStream 和OutputStream 同时关闭。
3：如果需要关闭socket 的inputStream 和OutputStream 先关输入输出流，再关socket。
4：如果涉及到readLine 方法。需要保证对方会发送一行数据已经行的结束标识。 newLine() 或者使用PrintWriter 要打开自动刷新功能。 的println()。
5：通过关闭socket的输入输出流 通过close 关闭 ，都会导致socket不可用。
6：通过shutDownInputStream 和 shutDownOutputStream 只会单方面的关闭某一个流，不会导致另外的一个流不可用。
八、泛型
1：概念：泛型：generic type---参数化类型。
2：泛型的有效期：编译期。
泛型是从java 源文件 编程成 class 的过程中，对泛型约束的类型进行检查。
在class 文件中。所有的泛型相关的信息都将被擦除掉。
运行期将不再进行泛型类型的检查。
3：泛型类
class MyStack<T>{
T t;
void test(T t){
}
}
4：泛型接口---泛型接口实现子类。
interface MyInterface<T>{
void test(T t);
}
//子类实现父接口，如果父接口是一个泛型接口，那么子类的也许要指定泛型，和父接口类型一致。
class MyInterfaceImpl<Integer> implements MyInterface<Integer>{
@Override
public void test(Integer t) {
}
}
5：泛型通配符（方法参数泛型不固定）
//? 泛型通配符，可以认为是所有泛型类型的父类型
//? 某种特定的类型。可以是任意类型。
static void test(ArrayList<?> list){
}
这个时候，调用该方法，list 中的元素的类型可以是任意类类型。
6：复杂的泛型方法：
声明
使用
泛型类中使用泛型方法
7：静态方法与泛型
泛型类中的静态的方法，不能直接使用类的泛型类型。因为类的泛型的类型是依赖于对象的。而静态方法是依赖于类加载。
如果想在静态方法中使用泛型类的类型，那么必须将该方法声明成泛型方法。
（静态泛型方法的泛型的类型可以和所在的类的泛型的类型相同，也可以不同）
8：泛型的上下边界
方法参数的边界控制 ？
//希望元素的类型是 Number 和 Number 的子类类型
static void test1(List<? extends Number> list){
}
//希望元素的类型是 Number 和 Number 的父类的类型
static void test2(List<? super Number> list){
}
//泛型类的边界的控制 T
class MyStack<T extends Number>
//泛型方法边界 <T extends Number>
//泛型方法的边界的控制
//只能是Number 的子类和 Number 的类型
static <T extends Number> void test1(T t){
}
例：
import java.util.ArrayList;
import java.util.List;
public class Test1 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("123");
//list.add(1);
MyStack<String> stack = new MyStack<>();
test(new ArrayList<String>());
//test1("123");
test1(new ArrayList<Object>());
}
//? 泛型通配符，可以认为是所有泛型类型的父类型
static void test(ArrayList<?> list){
}
//希望元素的类型是 Number 和 Number 的子类类型
static void test1(List<? extends Number> list){
}
//希望元素的类型是 Number 和 Number 的父类的类型
static void test2(List<? super Number> list){
}
//泛型方法
//static <T> void test1(T t){
////t 只能当Object 用。
//}
}
class Student implements Comparable<Student>{
private int age;
@Override
public int compareTo(Student o) {
//Student student = (Student)o;
return age-o.age;
}
}
//容器中元素的类型只能是 Number 和 Number 的子类类型。
class MyStack<T extends Number>{
T t;
<E> void test(E t){
}
//泛型方法的边界的控制
//只能是Number 的子类和 Number 的类型
static <T extends Number> void test1(T t){
}
}
interface MyInterface<T>{
void test(T t);
}
//子类实现父接口，如果父接口是一个泛型接口，那么子类的也许要指定泛型，和父接口类型一致。
class MyInterfaceImpl<Integer> implements MyInterface<Integer>{
@Override
public void test(Integer t) {
}
}
