package cn.itcast.tcp;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
/*
UDP通讯协议的特点：
1. 将数据极封装为数据包，面向无连接。
2. 每个数据包大小限制在64K中
3.因为无连接，所以不可靠
4. 因为不需要建立连接，所以速度快
5.udp 通讯是不分服务端与客户端的，只分发送端与接收端。
TCP通讯协议特点：
1. tcp是基于IO流进行数据 的传输 的，面向连接。
2. tcp进行数据传输的时候是没有大小限制的。
3. tcp是面向连接，通过三次握手的机制保证数据的完整性。 可靠协议。
4. tcp是面向连接的，所以速度慢。
5. tcp是区分客户端与服务端 的。
比如： 打电话、 QQ\feiQ的文件传输、 迅雷下载....
tcp协议下的Socket：
Socket(客户端) , tcp的客户端一旦启动马上要与服务端进行连接。
ServerSocket(服务端类)
tcp的客户端使用步骤：
1. 建立tcp的客户端服务。
2. 获取到对应的流对象。
3.写出或读取数据
4. 关闭资源。
*/
//tcp客户端
public class Demo1Client {
public static void main(String[] args) throws IOException{
//建立tcp的服务
Socket socket = new Socket(InetAddress.getLocalHost(),9090);
//获取到Socket的输出流对象
OutputStream outputStream = socket.getOutputStream();
//利用输出流对象把数据写出即可。
outputStream.write("服务端你好".getBytes());
//获取到输入流对象，读取服务端回送的数据。
InputStream inputStream = socket.getInputStream();
byte[] buf = new byte[1024];
int length = inputStream.read(buf);
System.out.println("客户端接收到的数据："+ new String(buf,0,length));
//关闭资源
socket.close();
}
}
package cn.itcast.tcp;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
//tcp的服务端
/*
java.net.BindException: 端口被占用。
ServerSocket的使用 步骤
1. 建立tcp服务端 的服务。
2. 接受客户端的连接产生一个Socket.
3. 获取对应的流对象读取或者写出数据。
4. 关闭资源。
为什么ServerSocket不设计一个getInputStream与getOutputStream 呢？
*/
//服务端
public class Demo1Server {
public static void main(String[] args) throws Exception {
//建立Tcp的服务端,并且监听一个端口。
ServerSocket serverSocket = new ServerSocket(9090);
//接受客户端的连接
Socket socket = serverSocket.accept(); //accept() 接受客户端的连接 该方法也是一个阻塞型的方法，没有客户端与其连接时，会一直等待下去。
//获取输入流对象，读取客户端发送的内容。
InputStream inputStream = socket.getInputStream();
byte[] buf = new byte[1024];
int length = 0;
length = inputStream.read(buf);
System.out.println("服务端接收："+ new String(buf,0,length));
//获取socket输出流对象，向客户端发送数据
OutputStream outputStream = socket.getOutputStream();
outputStream.write("客户端你好啊！".getBytes());
//关闭资源
serverSocket.close();
}
}
package cn.itcast.tcp;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.Socket;
/*
需求： 客户端与服务端一问一答聊天。
1.如果使用BuffrerdReader的readline方法一定要加上\r\n才把数据写出。
2.使用字符流一定要调用flush方法数据才会写出。
*/
//聊天的客户端
public class ChatClient {
public static void main(String[] args) throws IOException {
//建立tcp的客户端服务
Socket socket = new Socket(InetAddress.getLocalHost(),9090);
//获取socket的输出流对象。
OutputStreamWriter socketOut =new OutputStreamWriter(socket.getOutputStream());
//获取socket的输入流对象
BufferedReader socketReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//获取键盘的输入流对象，读取数据
BufferedReader keyReader = new BufferedReader(new InputStreamReader(System.in));
String line = null;
//不断的读取键盘录入的数据，然后把数据写出
while((line = keyReader.readLine())!=null){
socketOut.write(line+"\r\n");
//刷新
socketOut.flush();
//读取服务端回送的数据
line = socketReader.readLine();
System.out.println("服务端回送的数据是："+line);
}
//关闭资源
socket.close();
}
}
package cn.itcast.tcp;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
//tcp的服务端
/*
java.net.BindException: 端口被占用。
ServerSocket的使用 步骤
1. 建立tcp服务端 的服务。
2. 接受客户端的连接产生一个Socket.
3. 获取对应的流对象读取或者写出数据。
4. 关闭资源。
为什么ServerSocket不设计一个getInputStream与getOutputStream 呢？
*/
//服务端
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
/*
聊天的服务端
浏览器与服务器之间的数据传输就是使用了Tcp协议通讯的的
*/
public class ChatServer {
public static void main(String[] args) throws IOException {
//建立tcp的服务端
ServerSocket serverSocket = new ServerSocket(9090);
//接受客户端的连接，产生一个Socket
Socket socket = serverSocket.accept();
//获取到Socket的输入流对象
BufferedReader socketReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//获取到Socket输出流对象
OutputStreamWriter socketOut = new OutputStreamWriter(socket.getOutputStream());
//获取键盘的输入流对象
BufferedReader keyReader = new BufferedReader(new InputStreamReader(System.in));
//读取客户端的数据
String line = null;
while((line = socketReader.readLine())!=null){
System.out.println("服务端接收到的数据："+ line);
System.out.println("请输入回送给客户端的数据：");
line = keyReader.readLine();
socketOut.write(line+"\r\n");
socketOut.flush();
}
//关闭资源
serverSocket.close();
}
}
package cn.itcast.tcp;
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
//模拟Tomcat服务器
public class TomcatDemo extends Thread {
Socket socket;
public TomcatDemo(Socket socket){
this.socket = socket;
}
public void run() {
try {
//获取socket的输出流对象
OutputStream outputStream = socket.getOutputStream();
//把数据写到浏览器上
outputStream.write("<html><head><title>aaa</title></head><body>你好啊浏览器</body></html>".getBytes());
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
//建立tcp的服务端
ServerSocket serverSocket = new ServerSocket(9090);
//不断的接受客户端的连接
while(true){
Socket socket = serverSocket.accept();
new TomcatDemo(socket).start();
}
}
}
多线程下载图片
package cn.itcast.tcp;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashSet;
/*
1. 编写一个服务端可以给多个客户端发送图片。 （多线程）
*/
public class ImageServer extends Thread {
Socket socket ;
//使用该集合是用于存储ip地址的。
static HashSet<String> ips = new HashSet<String>();
public ImageServer(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
//获取到socket输出流对象
OutputStream outputStream = socket.getOutputStream();
//获取图片的输入流对象
FileInputStream fileInputStream = new FileInputStream("F:\\美女\\3.jpg");
//读取图片数据，把数据写出
byte[] buf = new byte[1024];
int length = 0 ;
while((length = fileInputStream.read(buf))!=-1){
outputStream.write(buf,0,length);
}
String ip = socket.getInetAddress().getHostAddress(); // socket.getInetAddress() 获取对方的IP地址
if(ips.add(ip)){
System.out.println("恭喜"+ip+"同学成功下载，当前下载的人数是："+ ips.size());
}
//关闭资源
fileInputStream.close();
socket.close();
}catch (IOException e) {
}
}
public static void main(String[] args) throws IOException {
//建立tcp的服务 ,并且要监听一个端口
ServerSocket serverSocket = new ServerSocket(9090);
while(true){
//接受用户的链接。
Socket socket = serverSocket.accept();
new ImageServer(socket).start();
}
}
}
package cn.itcast.tcp;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
//下载图片的客户端
public class ImageClient {
public static void main(String[] args) throws Exception{
//建立tcp的服务
Socket socket = new Socket(InetAddress.getLocalHost(),9090);
//获取socket的输入流对象
InputStream inputStream = socket.getInputStream();
//获取文件的输出流对象
FileOutputStream fileOutputStream = new FileOutputStream("F:\\3.jpg");
//边读边写
byte[] buf = new byte[1024];
int length = 0 ;
while((length = inputStream.read(buf))!=-1){
fileOutputStream.write(buf,0,length);
}
//关闭资源
fileOutputStream.close();
socket.close();
}
}
多用户登录
package cn.itcast.tcp;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.Socket;
/*
2. 实现登陆与注册 功能。
客户端与服务端连接的时候，就要提示客户端请选择功能。
客户端注册的时候，用户名与密码都是发送给服务端 的，服务端需要把数据保存到服务端的文件上。
登陆： 登陆的时候客户端输入用户名与密码发送给服务端，服务端需要校验，返回结果给客户端。
*/
public class LoginClient {
public static void main(String[] args) throws IOException {
Socket socket = new Socket(InetAddress.getLocalHost(),9090);
//获取socket的输出流对象
OutputStreamWriter socketOut = new OutputStreamWriter(socket.getOutputStream());
//获取到socket的输入流对象
BufferedReader socketReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//获取到键盘的输入流对象
BufferedReader keyReader = new BufferedReader(new InputStreamReader(System.in));
while(true){
System.out.println("请选择功能： A(登陆) B(注册)");
String option = keyReader.readLine();
if("a".equalsIgnoreCase(option)){
getInfo(socketOut, keyReader, option);
//读取服务器反馈的信息
String line = socketReader.readLine();
System.out.println(line);
}else if("b".equalsIgnoreCase(option)){
getInfo(socketOut, keyReader, option);
//读取服务器反馈的信息
String line = socketReader.readLine();
System.out.println(line);
}
}
}
public static void getInfo(OutputStreamWriter socketOut,BufferedReader keyReader, String option)
throws IOException {
System.out.println("请输入用户名:");
String userName = keyReader.readLine();
System.out.println("请输入密码：");
String password = keyReader.readLine();
String info = option +" "+userName+" "+password+"\r\n";
socketOut.write(info);
socketOut.flush();
}
}
package cn.itcast.tcp;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Properties;
public class LoginServer extends Thread {
Socket socket;
static File file = new File("F:\\users.properties");
public LoginServer(Socket socket) {
this.socket = socket;
}
static {
try {
if (!file.exists()) {
file.createNewFile();
}
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void run() {
while(true){
try {
// 获取socket的输入流对象
BufferedReader bufferedReader = new BufferedReader(
new InputStreamReader(socket.getInputStream()));
// 获取socket的输出流对象
OutputStreamWriter socketOut = new OutputStreamWriter(
socket.getOutputStream());
// 读取客户端输入的信息
String info = bufferedReader.readLine();
String[] datas = info.split(" ");
// 获取到用户 的选择功能
String option = datas[0];
// 注册
String userName = datas[1];
String password = datas[2];
if ("a".equalsIgnoreCase(option)) {
// 登陆
Properties properties = new Properties();
// 加载配置文件
properties.load(new FileReader(file));
if (properties.containsKey(userName)) {
String tempPass = properties.getProperty(userName);
if (password.equals(tempPass)) {
socketOut.write("欢迎" + userName + "登陆成功\r\n");
} else {
socketOut.write("密码错误\r\n");
}
} else {
socketOut.write("用户名不存在，请重新输入...\r\n");
}
socketOut.flush();
} else if ("b".equalsIgnoreCase(option)) {
// 创建一个配置文件类
Properties properties = new Properties();
//加载原来的配置文件
properties.load(new FileReader(file));
if (!properties.containsKey(userName)) {
// 不存在该用户名
properties.setProperty(userName, password);
// 生成一个配置文件
properties.store(new FileWriter(file), "users");
socketOut.write("注册成功..\r\n");
} else {
// 存在用户名
socketOut.write("用户名已经被注册，请重新输入\r\n");
}
socketOut.flush();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(9090);
while (true) {
Socket socket = serverSocket.accept();
new LoginServer(socket).start();
}
}
}