网络编程
常见的软件架构
BS架构
CS架构
网络编程小结
网络编程三要素
三要素小结
IP
IPV4
IPV6
IP小结
IPV4的地址分类形式
常用的CMD命令
小结
InetAddress的使用
public class Demo1 {
public static void main(String[] args) throws UnknownHostException {
//获取IP对象
/**
* 通过InetAddress.getByName方法获取到InetAddress对象
* 方法的形参可以是主机名，也可以是IP地址
*/
InetAddress byName = InetAddress.getByName("DESKTOP-0MCCNFM");
System.out.println(byName);
//获取到该对象的主机名，如果该主句无法链接，将返回该对象的IP地址
String hostName = byName.getHostName();
System.out.println(hostName);
//获取该对象的IP地址
String hostAddress = byName.getHostAddress();
System.out.println(hostAddress);
}
}端口号
协议
UDP协议
UDP发送
public class udpSendDemo {
public static void main(String[] args) throws IOException {
//创建一个链接对象
/**
* DatagramSocket的参数是指定端口号，如果为无参构造则表示随机一个端口号
*/
DatagramSocket ds = new DatagramSocket();
//创建一个对象用来打包数据
//创建一个字符数组用来保存要传输的数据
/**
* 参数一：保存数据的字符数组
* 参数二：字符数组传输的开始位置(可不输入，表述从头开始）
* 参数三：字符数组传输的长度
* 参数四：目标设备的地址（IP）
* 参数五：目标设备的接受端口
*/
String str = "你好，万维";
byte[] bytes = str.getBytes();
//目标设备的地址（本地环回地址）
InetAddress byName = InetAddress.getByName("127.0.0.1");
//目标设备的接收端口
int port = 10086;
DatagramPacket dp = new DatagramPacket(bytes,bytes.length,byName,port);
//使用DatagramSocket对象发送DatagramPacket对象（数据包）
ds.send(dp);
//释放资源
ds.close();
}
}UDP接收
public class udpresurt {
public static void main(String[] args) throws IOException {
/**
* 接收数据
*/
//接收数据要创建DatagramSocket对象
//DatagramSocket对象必须要指定端口号，且端口号应该和发送端发送的端口号相同
DatagramSocket ds = new DatagramSocket(10086);
//创建字符数组用于存储接受到的数据
byte[] arr = new byte[1024];
//接收数据只需要将字符数组存入即可
DatagramPacket dp = new DatagramPacket(arr,arr.length);
/**
* 该方法用于接受数据
* 该方法是阻塞的
* 即只用该方法获取到传输的数据时才会向下执行
*/
ds.receive(dp);
//解析数据
//写入的数据
byte[] data = dp.getData();
//发送数据的设备的地址
InetAddress address = dp.getAddress();
//发送端要发送的真实数据的数据的长度
int length = dp.getLength();
//发送端的端口号
int port = dp.getPort();
//new String(data,0,length)表示将data字符数组中的数据从0开始到length转为字符串，即将发送端要传输的字符串转换出来
//data中的其他字符串转换会出现乱码
System.out.println(new String(data,0,length));
System.out.println(length);
System.out.println(address);
System.out.println(port);
/**
* 你好，万维
* 15
* /127.0.0.1
* 55623
*/
//关闭资源
ds.close();
}
}
练习：聊天室
public class udpSendTest {
public static void main(String[] args) throws IOException {
//创建一个链接对象
/**
* DatagramSocket的参数是指定端口号，如果为无参构造则表示随机一个端口号
*/
DatagramSocket ds = new DatagramSocket();
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请输入要说的话");
String str = sc.nextLine();
if (str.equals("886")){
break;
}
byte[] bytes = str.getBytes();
//目标设备的地址（本地环回地址）
InetAddress byName = InetAddress.getByName("127.0.0.1");
//目标设备的接收端口
int port = 10086;
DatagramPacket dp = new DatagramPacket(bytes,bytes.length,byName,port);
//使用DatagramSocket对象发送DatagramPacket对象（数据包）
ds.send(dp);
}
//释放资源
ds.close();
}
}public class udpresurtTest {
public static void main(String[] args) throws IOException {
/**
* 接收数据
*/
//接收数据要创建DatagramSocket对象
//DatagramSocket对象必须要指定端口号，且端口号应该和发送端发送的端口号相同
DatagramSocket ds = new DatagramSocket(10086);
//创建字符数组用于存储接受到的数据
byte[] arr = new byte[1024];
//接收数据只需要将字符数组存入即可
DatagramPacket dp = new DatagramPacket(arr,arr.length);
/**
* 该方法用于接受数据
* 该方法是阻塞的
* 即只用该方法获取到传输的数据时才会向下执行
*/
while (true) {
ds.receive(dp);
//解析数据
//写入的数据
byte[] data = dp.getData();
//发送数据的设备的地址
InetAddress address = dp.getAddress();
String hostAddress = address.getHostAddress();
String hostName = address.getHostName();
//发送端要发送的真实数据的数据的长度
int length = dp.getLength();
//发送端的端口号
int port = dp.getPort();
String s = new String(data,0,length);
//new String(data,0,length)表示将data字符数组中的数据从0开始到length转为字符串，即将发送端要传输的字符串转换出来
//data中的其他字符串转换会出现乱码
System.out.println("ip为："+hostAddress+" 主机名为："+hostName+" 的人发来了话："+s);
}
//关闭资源
// ds.close();
}
}
UDP的三种通讯方式
组播
public class udpresurt {
public static void main(String[] args) throws IOException {
/**
* 接收数据
*/
//接收数据要创建MulticastSocket对象,用于组播
//MulticastSocket对象必须要指定端口号，且端口号应该和发送端发送的端口号相同
MulticastSocket ds = new MulticastSocket(10086);
//将主机添加到224.0.0.1的这一组中
InetAddress byName = InetAddress.getByName("224.0.0.1");
ds.joinGroup(byName);
//创建字符数组用于存储接受到的数据
byte[] arr = new byte[1024];
//接收数据只需要将字符数组存入即可
DatagramPacket dp = new DatagramPacket(arr,arr.length);
/**
* 该方法用于接受数据
* 该方法是阻塞的
* 即只用该方法获取到传输的数据时才会向下执行
*/
ds.receive(dp);
//解析数据
//写入的数据
byte[] data = dp.getData();
//发送数据的设备的地址
InetAddress address = dp.getAddress();
//发送端要发送的真实数据的数据的长度
int length = dp.getLength();
//发送端的端口号
int port = dp.getPort();
//new String(data,0,length)表示将data字符数组中的数据从0开始到length转为字符串，即将发送端要传输的字符串转换出来
//data中的其他字符串转换会出现乱码
System.out.println(new String(data,0,length));
System.out.println(length);
System.out.println(address);
System.out.println(port);
//关闭资源
ds.close();
}
}
public class udpSendDemo {
public static void main(String[] args) throws IOException {
//创建一个链接对象
/**
* DatagramSocket的参数是指定端口号，如果为无参构造则表示随机一个端口号
*/
MulticastSocket ds = new MulticastSocket();
//创建一个对象用来打包数据
//创建一个字符数组用来保存要传输的数据
/**
* 参数一：保存数据的字符数组
* 参数二：字符数组传输的开始位置(可不输入，表述从头开始）
* 参数三：字符数组传输的长度
* 参数四：目标设备的地址（IP）
* 参数五：目标设备的接受端口
*/
String str = "你好，万维";
byte[] bytes = str.getBytes();
//目标设备的地址（本地环回地址）
InetAddress byName = InetAddress.getByName("224.0.0.1");
//目标设备的接收端口
int port = 10086;
DatagramPacket dp = new DatagramPacket(bytes,bytes.length,byName,port);
//使用DatagramSocket对象发送DatagramPacket对象（数据包）
ds.send(dp);
//释放资源
ds.close();
}
}广播（只需要单播，将IP改为255.255.255.255）
public class udpSendDemo2 {
public static void main(String[] args) throws IOException {
//创建一个链接对象
/**
* DatagramSocket的参数是指定端口号，如果为无参构造则表示随机一个端口号
*/
DatagramSocket ds = new DatagramSocket();
//创建一个对象用来打包数据
//创建一个字符数组用来保存要传输的数据
/**
* 参数一：保存数据的字符数组
* 参数二：字符数组传输的开始位置(可不输入，表述从头开始）
* 参数三：字符数组传输的长度
* 参数四：目标设备的地址（IP）
* 参数五：目标设备的接受端口
*/
String str = "你好，万维";
byte[] bytes = str.getBytes();
//目标设备的地址（本地环回地址）
InetAddress byName = InetAddress.getByName("255.255.255.255");
//目标设备的接收端口
int port = 10086;
DatagramPacket dp = new DatagramPacket(bytes,bytes.length,byName,port);
//使用DatagramSocket对象发送DatagramPacket对象（数据包）
ds.send(dp);
//释放资源
ds.close();
}
}TCP
public class ClientDemo {
public static void main(String[] args) throws IOException {
//客户端，发送数据
//"127.0.0.1",指定服务器地址和端口号
Socket s = new Socket("127.0.0.1",10001);
//通过s.getOutputStream();方法获取到输出流，写出数据
OutputStream os = s.getOutputStream();
//目前传输中文会报错
// os.write("你好你好".getBytes());
os.write("halloword".getBytes());
//关闭资源
os.close();
s.close();
}
}public class SocketDemo {
public static void main(String[] args) throws IOException {
//服务端的接收对象，要指定客户端的访问端口
ServerSocket ss = new ServerSocket(10001);
//用于监听客户端连接，一旦有链接则继续执行
Socket socket = ss.accept();
InputStream inputStream = socket.getInputStream();
int ch;
while ((ch = inputStream.read())!= -1){
System.out.println((char) ch);
}
//关闭资源
inputStream.close();
socket.close();
ss.close();
}
}中文乱码的解决
将接收流使用转换流包装，客户端不需要更改
public class SocketDemo {
public static void main(String[] args) throws IOException {
//服务端的接收对象，要指定客户端的访问端口
ServerSocket ss = new ServerSocket(10001);
//用于监听客户端连接，一旦有链接则继续执行
Socket socket = ss.accept();
InputStream is = socket.getInputStream();
//InputStreamReader包装InputStream可以避免乱码
InputStreamReader isr = new InputStreamReader(is);
//提高效率
BufferedReader br = new BufferedReader(isr);
int ch;
while ((ch = br.read())!= -1){
System.out.println((char) ch);
}
//关闭资源
br.close();
socket.close();
ss.close();
}
}三次握手，四次挥手
综合练习
练习一：多发多收
public class udpsend {
public static void main(String[] args) throws IOException {
//udp发送
DatagramSocket ds = new DatagramSocket();
Scanner sc = new Scanner(System.in);
while (true){
System.out.println("请输入数据");
String s = sc.nextLine();
if (s.equals("886")){
break;
}
byte[] bytes = s.getBytes();
InetAddress address = InetAddress.getByName("127.0.0.1");
DatagramPacket dp = new DatagramPacket(bytes,0,bytes.length,address,10000);
ds.send(dp);
}
ds.close();
}
}
public class udpresure {
public static void main(String[] args) throws IOException {
//UDP接受
DatagramSocket ds = new DatagramSocket(10000);
byte[] bytes = new byte[1024];
DatagramPacket dp = new DatagramPacket(bytes,0,bytes.length);
while (true) {
ds.receive(dp);
//解析数据
InetAddress address = dp.getAddress();
int port = dp.getPort();
int len = dp.getLength();
byte[] data = dp.getData();
String s = new String(data, 0, len);
System.out.println("ip为："+address.getHostAddress()+"主机名为"+address.getHostName()+"发来了消息："+s);
}
}
}练习二：接收和反馈
public class udpresure {
public static void main(String[] args) throws IOException {
//UDP服务端
DatagramSocket ds = new DatagramSocket(10000);
byte[] bytes = new byte[1024];
DatagramPacket dp = new DatagramPacket(bytes, 0, bytes.length);
//接收数据
ds.receive(dp);
//解析数据
InetAddress address = dp.getAddress();
int port = dp.getPort();
int len = dp.getLength();
byte[] data = dp.getData();
String s = new String(data, 0, len);
System.out.println("ip为：" + address.getHostAddress() + "主机名为" + address.getHostName() + "发来了消息：" + s);
//发送数据发送
String string = "服务端接收到了请求";
bytes = string.getBytes();
DatagramPacket dp2 = new DatagramPacket(bytes, 0, bytes.length, address, port);
ds.send(dp2);
ds.close();
}
}public class udpsend {
public static void main(String[] args) throws IOException {
//udp客户端
//接收端口是10002
DatagramSocket ds = new DatagramSocket();
Scanner sc = new Scanner(System.in);
//开始发送信息
System.out.println("请输入数据");
String s = sc.nextLine();
byte[] bytes = s.getBytes();
InetAddress address = InetAddress.getByName("127.0.0.1");
DatagramPacket dp = new DatagramPacket(bytes, 0, bytes.length, address, 10000);
ds.send(dp);
//开始接收数据
ds.receive(dp);
//解析数据
InetAddress address2 = dp.getAddress();
int port = dp.getPort();
int len = dp.getLength();
byte[] data = dp.getData();
String s2 = new String(data, 0, len);
System.out.println("ip为：" + address2.getHostAddress() + "主机名为" + address2.getHostName() + "发来了消息：" + s2);
ds.close();
}
}练习三：上传文件
public class TcpFileget {
public static void main(String[] args) throws IOException {
//使用TCP链接来接受文件
ServerSocket ss = new ServerSocket(10003);
Socket s = ss.accept();
InputStream is = s.getInputStream();
FileOutputStream fos = new FileOutputStream("D:\\Test\\b.rar");
byte[] bytes = new byte[1024];
int ch;
while ((ch = is.read(bytes))!= -1){
fos.write(bytes,0,ch);
}
//接收完毕给客户端一个反馈
//获取一个发送流
OutputStream os = s.getOutputStream();
String string = "文件接受完毕，上传成功";
System.out.println(string);
byte[] bytes1 = string.getBytes();
os.write(bytes1);
os.close();
fos.close();
is.close();
s.close();
ss.close();
}
}
public class TcpFilesend {
public static void main(String[] args) throws IOException {
//使用TCP链接来发送文件
Socket s = new Socket("127.0.0.1",10003);
OutputStream os = s.getOutputStream();
FileInputStream fis = new FileInputStream("C:\\Users\\20724\\Desktop\\代码.rar");
//接收文件，并通过OS法除去
byte[] bytes = new byte[1204];
int ch;
while ((ch = fis.read(bytes))!= -1){
os.write(bytes,0,ch);
}
//表示文件传输已经结束
s.shutdownOutput();
//获取接受流
InputStream is = s.getInputStream();
byte[] bytes1 = new byte[1024];
int c;
while ((c = is.read(bytes1)) != -1) {
// StringBuilder sb = new StringBuilder();
String string = new String(bytes1,0,c);
System.out.println("服务区传输的数据："+string);
}
is.close();
fis.close();
os.close();
s.close();
}
}练习四：文件重名
//只需将接受代码中保存文件的名称的代码进行修改即可
//解决重名问题可以添加一个UUID
UUID uuid = UUID.randomUUID();//36a05678-f015-4d47-b641-4598918f2269
//将UUID中的-去掉
String s1 = uuid.toString().replaceAll("-", "");
FileOutputStream fos = new FileOutputStream("D:\\Test\\"+s1+".rar");
练习五：上传文件（多线程）
public class TcpFileget {
public static void main(String[] args) throws IOException {
//使用TCP链接来接受文件
ServerSocket ss = new ServerSocket(10004);
Socket s = null;
while (true) {
s = ss.accept();
MyThread myThread = new MyThread(s);
Thread thread = new Thread(myThread);
thread.start();
}
}
}
public class MyThread implements Runnable{
Socket s;
MyThread(Socket s){
this.s = s;
}
@Override
public void run() {
try {
InputStream is = s.getInputStream();
//解决重名问题可以添加一个UUID
UUID uuid = UUID.randomUUID();//36a05678-f015-4d47-b641-4598918f2269
//将UUID中的-去掉
String s1 = uuid.toString().replaceAll("-", "");
FileOutputStream fos = new FileOutputStream("D:\\Test\\"+s1+".rar");
byte[] bytes = new byte[1024];
int ch;
while ((ch = is.read(bytes))!= -1){
fos.write(bytes,0,ch);
}
//接收完毕给客户端一个反馈
//获取一个发送流
OutputStream os = s.getOutputStream();
String string = "文件接受完毕，上传成功";
System.out.println(string);
byte[] bytes1 = string.getBytes();
os.write(bytes1);
s.shutdownOutput();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}public class TcpFilesend {
public static void main(String[] args) throws IOException {
//使用TCP链接来发送文件
Socket s = new Socket("127.0.0.1",10004);
OutputStream os = s.getOutputStream();
FileInputStream fis = new FileInputStream("C:\\Users\\20724\\Desktop\\代码.rar");
//接收文件，并通过OS法除去
byte[] bytes = new byte[1204];
int ch;
while ((ch = fis.read(bytes))!= -1){
os.write(bytes,0,ch);
}
//表示文件传输已经结束
s.shutdownOutput();
//获取接受流
InputStream is = s.getInputStream();
byte[] bytes1 = new byte[1024];
int c;
while ((c = is.read(bytes1)) != -1) {
// StringBuilder sb = new StringBuilder();
String string = new String(bytes1,0,c);
System.out.println("服务区传输的数据："+string);
}
s.close();
}
}
练习六：上传文件（线程池优化）
其他代码同上
public class TcpFilesend {
public static void main(String[] args) throws IOException {
//使用TCP链接来发送文件
Socket s = new Socket("127.0.0.1",10004);
OutputStream os = s.getOutputStream();
FileInputStream fis = new FileInputStream("C:\\Users\\20724\\Desktop\\代码.rar");
//接收文件，并通过OS法除去
byte[] bytes = new byte[1204];
int ch;
while ((ch = fis.read(bytes))!= -1){
os.write(bytes,0,ch);
}
//表示文件传输已经结束
s.shutdownOutput();
//获取接受流
InputStream is = s.getInputStream();
byte[] bytes1 = new byte[1024];
int c;
while ((c = is.read(bytes1)) != -1) {
// StringBuilder sb = new StringBuilder();
String string = new String(bytes1,0,c);
System.out.println("服务区传输的数据："+string);
}
s.close();
}
}
练习七：(接收浏览器的数据并打印）
public class GetTCP {
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(10008);
Socket socket = ss.accept();
InputStream inputStream = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(inputStream);
int a;
while ((a = isr.read())!= -1){
System.out.print((char) a);
}
isr.close();
ss.close();
}
}练习八：网络编程（大作业）
zhangsan=123
lisi=123
wangwu=123
qwqwq=123
sdsds=1231username
public class Service {
//用静态记录一登录成功的信息
static ArrayList<Socket> list = new ArrayList<>();
//服务器端
public static void main(String[] args) throws IOException {
//使用集合存储登录的用户的链接
HashMap<String,String> userMap = new HashMap<>();
//获取数据
FileReader fr = new FileReader("javaday34dzy\\src\\main\\java\\userdata.txt");
BufferedReader br = new BufferedReader(fr);
String str;
while ((str = br.readLine())!= null){
String[] split = str.split("=");
userMap.put(split[0],split[1]);
}
//获取所有已注册的数据
ServerSocket ss = new ServerSocket(10086);//启动服务
Socket s = null;
while (true) {
//创建接受流
s = ss.accept();
System.out.println("有客户端来链接");
//创建线程
Thread t = new Thread(new serviceThread(s,userMap));
t.start();
}
}
}public class serviceThread implements Runnable{
Socket s;
HashMap<String,String> hashMap;
public serviceThread(Socket socket, HashMap<String, String> hashMap) {
this.s = socket;
this.hashMap = hashMap;
}
@Override
public void run() {
try {
//开始接收数据，并对接收的数据进行处理
InputStream is = s.getInputStream();
OutputStream os = s.getOutputStream();
//使用字符缓冲流包装
BufferedReader br = new BufferedReader(new InputStreamReader(is));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
//接受第一次传来的等录或注册
int s1 = br.read();
System.out.println(s1);
if (s1=='1'){
//登录
userjoin(br, bw);
}else {
userresuie(br, bw);
}
// //开始接收数据
// String str;
// while ((str = br.readLine()) != null){
// System.out.println(str);
// //判断数据
// //将数据拆分
//
// }
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private void userresuie(BufferedReader br, BufferedWriter bw) throws IOException {
//注册
// String s1 = br.readLine();
String s2 = br.readLine();
System.out.println("正在注册");
System.out.println("================");
System.out.println(s2);
//解析数据
String[] split = s2.split("&");
String[] split1 = split[0].split("=");
String[] split2 = split[1].split("=");
boolean flag = true;
//遍历
Set<String> strings = hashMap.keySet();
for (String string : strings) {
if (split1[1].equals(string)){
flag = false;
//已经有账号，不可在注册
bw.write(0);
//刷新将数据发出
bw.flush();
break;
}
}
if (flag){
//没有账号开始注册
//整理数据
String userdata = split1[1]+"="+split2[1];
FileWriter fw = new FileWriter("javaday34dzy\\src\\main\\java\\userdata.txt",true);
BufferedWriter bw1 = new BufferedWriter(fw);
bw1.write(userdata);
//换行
bw1.newLine();
//关闭资源
bw1.close();
System.out.println("账号注册成功");
}
}
private void userjoin(BufferedReader br, BufferedWriter bw) throws IOException {
String s2 = br.readLine();
//解析数据
String[] split = s2.split("&");
String[] split1 = split[0].split("=");
String[] split2 = split[1].split("=");
boolean flag = true;
//判断
//遍历
Set<String> strings = hashMap.keySet();
for (String string : strings) {
if (split1[1].equals(string)){
//判断密码是否一样
String password = hashMap.get(string);
if (password.equals(split2[1])){
flag = false;
//密码正确，登录
bw.write(1);
//刷新将数据发出
bw.flush();
//将信息写入集合中
Service.list.add(s);
//写一个while(){}表示正在聊天
//接收客户端发送过来的消息，并打印在控制台
talk2All(br, string);
}else {
密码不正确
bw.write(0);
//刷新将数据发出
bw.flush();
}
}
}
if (flag){
//没有账号，先注册账号
bw.write(-1);
//刷新将数据发出
bw.flush();
}
}
private void talk2All(BufferedReader br, String username) throws IOException {
while (true) {
String message = br.readLine();
System.out.println(username + "发送过来消息：" + message);
//群发
for (Socket s : Service.list) {
//s依次表示每一个客户端的连接对象
writeMessage2Client(s, username + "发送过来消息：" + message);
}
}
}
private void writeMessage2Client(Socket s, String message) throws IOException {
//获取输出流
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
bw.write(message);
bw.newLine();
bw.flush();
}
}public class Join {
//用户端
//选择登录还是注册
//服务器已经连接成功
//==============欢迎来到黑马聊天室================
//1登录
//2注册
//请输入您的选择：
public static void main(String[] args) throws IOException {
//和服务端进行连接
Socket s = new Socket("127.0.0.1",10086);
//获取发送流
OutputStream os = s.getOutputStream();
//获取接受流
InputStream is = s.getInputStream();
//向服务端发送请求，如果回复则显示 服务器已经连接成功
//使用缓冲字符包装
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
BufferedReader br = new BufferedReader(new InputStreamReader(is));
Scanner sc = new Scanner(System.in);
//
while (true) {
System.out.println("服务器已经连接成功");
System.out.println("==============欢迎来到黑马聊天室================");
System.out.println("1登录");
System.out.println("2注册");
System.out.println("请输入您的选择：");
String str = sc.next();
//判断输入的试什么
switch (str){
case "1":
joinin(sc, bw, br, s);
break;
case "2":
resurt(sc, bw);
break;
default:
System.out.println("您输入的数据有误，请重新选择");
}
}
}
private static void resurt(Scanner sc, BufferedWriter bw) throws IOException {
//调用注册函数
System.out.println("请输入用户名");
String usernamere = sc.next();
System.out.println("请输入密码");
String passwordre = sc.next();
//将两个数据进行加工并发送给服务端,1username=zhangsan&password=123,最前边的1表述告诉服务器这是登录操作
String joinstrre = "username="+usernamere+"&password="+passwordre;
System.out.println(joinstrre);
bw.write(2);
bw.flush();
//第二次发送
bw.write(joinstrre);
bw.newLine();
bw.flush();
//开始监听服务器的返回数据
}
private static void joinin(Scanner sc, BufferedWriter bw, BufferedReader br, Socket s) throws IOException {
//调用登录函数
/**
* 请输入用户名
* zhangsan
* 请输入密码
* 123
*/
System.out.println("请输入用户名");
String username = sc.next();
System.out.println("请输入密码");
String password = sc.next();
//将两个数据进行加工并发送给服务端,1username=zhangsan&password=123,最前边的1表述告诉服务器这是登录操作
String joinstr = "username="+username+"&password="+password;
bw.write("1");
bw.flush();
//第二次发送
bw.write(joinstr);
bw.newLine();
bw.flush();
//开始监听服务器的返回数据
int joinresult = br.read();
//判断返回的数据
if (joinresult==1){
System.out.println("登录成功");
//登陆成功的操作
//开一条单独的线程，专门用来接收服务端发送过来的聊天记录
//创建一个对应的线程用于接受发来的数据
new Thread(new joinThread(s)).start();
//开始聊天
talk2All(bw);
} else if (joinresult==0) {
System.out.println("密码有误");
//重新进行操作
}else {
System.out.println("用户名不存在");
//重新进行操作
}
}
private static void talk2All(BufferedWriter bw) throws IOException {
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请输入您要说的话");
String str = sc.nextLine();
//把聊天内容写给服务器
bw.write(str);
bw.newLine();
bw.flush();
}
}
}public class joinThread implements Runnable{
Socket s;
public joinThread(Socket s) {
this.s = s;
}
@Override
public void run() {
//循环，重复的接受
while (true) {
try {
//接收服务器发送过来的聊天记录
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
String msg = br.readLine();
System.out.println(msg);
} catch (IOException e) {
e.printStackTrace();
}
}
}
}