AAA

最新推荐文章于 2022-07-12 19:49:09 发布
最新推荐文章于 2022-07-12 19:49:09 发布
阅读量167 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qian_qian_123/article/details/82466434
版权

模拟用户登录的功能，实现：客户发送登录用户信息，服务器端显示登录信息并响应给客户端（登录成功，登录失败）信息。

服务器端实现步骤：

1、建立连接，监听端口。

2、使用accept（）方法等待客户端触发通信。

3、打开Socket关联的输入/输出流。

4、向输出流中写入信息。

5、从输入流中读取响应信息。

6、关闭所有的数据流和Socket。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map.Entry;

public class Service {

	public static void main(String[] args) {

		InputStream is = null;
		OutputStream os = null;

		ServerSocket serverSocket = null;
		Socket socket = null;
		try {

			serverSocket = new ServerSocket(6000);

			System.out.println("服务器已经启动!");
			socket = serverSocket.accept();

			// 从客户端读取数据，需要先转换为字符流
			is = socket.getInputStream();
			BufferedReader br = new BufferedReader(new InputStreamReader(is));
			String str = str = br.readLine();
			System.out.println("我是服务器，客户端输入的消息为：" + str);
			socket.shutdownInput();

			// 对客户端输入的账号密码信息进行处理
			String[] str2 = str.split("&");
			HashMap<String, String> hm = new HashMap<>();
			for (String str1 : str2) {
				String[] str3 = str1.split(":");
				hm.put(str3[0], str3[1]);
			}

			String reply = "登录失败";
			if ("zhangwendi".equals(hm.get("name"))
					&& "123456".equals(hm.get("password"))) {
				reply = "登录成功！";
			}

			// 向客户端发送消息
			os = socket.getOutputStream();
			os.write(reply.getBytes());
			socket.shutdownOutput();

		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null)
					is.close();
				if (os != null)
					os.close();
				socket.close();
				serverSocket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

}

客户端实现步骤：

1、建立连接，连接指向服务器及端口。

2、打开Socket关联的输入/输出流。

3、向输出流中写入信息。

4、从输入流中读取响应信息。

5、关闭所有的数据流和Socket。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class client {
	public static void main(String[] args) {
		InputStream is = null;
		OutputStream os = null;
		Socket socket = null;
		try {
			socket = new Socket("127.0.0.1", 6000);

			os = socket.getOutputStream();
			is = socket.getInputStream();

			// 向服务器发送消息，需要先转换为字节流
			Scanner can = new Scanner(System.in);
			System.out.println("输入账号：");
			String name = can.next();
			System.out.println("输入密码：");
			String password = can.next();
			String str = "name:" + name + "&password:" + password;
			byte[] b = str.getBytes();
			os.write(b);
			socket.shutdownOutput();

			// 从服务器读取信息，需要先把字节流转换为容易读取的字符流
			BufferedReader bis = new BufferedReader(new InputStreamReader(is));
			String str2 = bis.readLine();
			System.out.println("客户端输出：服务器回应为==>" + str2);
			socket.shutdownInput();

		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null)
					is.close();
				if (os != null)
					os.close();
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}

<<<<=======升级=======>>>>实现传递对象信息

import java.io.Serializable;

public class User implements Serializable {
	/**
	 * 随机序列号
	 */
	private static final long serialVersionUID = -7185447814341077688L;
	private String name;
	private String password;

	public User(String name, String password) {
		super();
		this.name = name;
		this.password = password;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	@Override
	public String toString() {
		return "User [name=" + name + ", password=" + password + "]";
	}

}

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Service {

	public static void main(String[] args) {

		InputStream is = null;
		OutputStream os = null;

		ServerSocket serverSocket = null;
		Socket socket = null;
		try {

			serverSocket = new ServerSocket(6000);

			System.out.println("服务器已经启动!");
			socket = serverSocket.accept();

			// 从客户端读取数据，需要先转换为字符流
			is = socket.getInputStream();

			ObjectInputStream ois = new ObjectInputStream(is);
			User user = (User) ois.readObject();

			// BufferedReader br = new BufferedReader(new
			// InputStreamReader(is));
			// String str = str = br.readLine();
			System.out.println("我是服务器，客户端输入的消息为：" + user);
			socket.shutdownInput();

			// 对客户端输入的账号密码信息进行处理
			// String[] str2 = str.split("&");
			// HashMap<String, String> hm = new HashMap<>();
			// for (String str1 : str2) {
			// String[] str3 = str1.split(":");
			// hm.put(str3[0], str3[1]);
			// }

			String reply = "登录失败";
			if ("zhangwendi".equals(user.getName())
					&& "123456".equals(user.getPassword())) {
				reply = "登录成功！";
			}

			// 向客户端发送消息
			os = socket.getOutputStream();
			os.write(reply.getBytes());
			socket.shutdownOutput();

		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null)
					is.close();
				if (os != null)
					os.close();
				socket.close();
				serverSocket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class client {
	public static void main(String[] args) {
		InputStream is = null;
		OutputStream os = null;
		Socket socket = null;
		try {
			socket = new Socket("127.0.0.1", 6000);

			os = socket.getOutputStream();
			is = socket.getInputStream();

			// 向服务器发送消息，需要先转换为字节流
			Scanner can = new Scanner(System.in);
			System.out.println("输入账号：");
			String name = can.next();
			System.out.println("输入密码：");
			String password = can.next();

			User user = new User(name, password);//
			ObjectOutputStream oos = new ObjectOutputStream(os);
			oos.writeObject(user);
			// String str = "name:" + name + "&password:" + password;
			// byte[] b = str.getBytes();
			// os.write(b);
			socket.shutdownOutput();

			// 从服务器读取信息，需要先把字节流转换为容易读取的字符流
			BufferedReader bis = new BufferedReader(new InputStreamReader(is));
			String str2 = bis.readLine();
			System.out.println("客户端输出：服务器回应为==>" + str2);
			socket.shutdownInput();

		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null)
					is.close();
				if (os != null)
					os.close();
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}

<<<<=======再升级=======>>>>实现处理客户端的多次请求，利用while循环设计服务器（单个任务执行完才执行下个任务）

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Service {

	public static void main(String[] args) {

		InputStream is = null;
		OutputStream os = null;

		ServerSocket serverSocket = null;
		Socket socket = null;
		try {

			serverSocket = new ServerSocket(6000);

			System.out.println("服务器已经启动!");
			while (true) {
				socket = serverSocket.accept();

				// 从客户端读取数据，需要先转换为字符流
				is = socket.getInputStream();

				ObjectInputStream ois = new ObjectInputStream(is);
				User user = (User) ois.readObject();

				// BufferedReader br = new BufferedReader(new
				// InputStreamReader(is));
				// String str = str = br.readLine();
				System.out.println("我是服务器，客户端输入的消息为：" + user);
				socket.shutdownInput();

				// 对客户端输入的账号密码信息进行处理
				// String[] str2 = str.split("&");
				// HashMap<String, String> hm = new HashMap<>();
				// for (String str1 : str2) {
				// String[] str3 = str1.split(":");
				// hm.put(str3[0], str3[1]);
				// }

				String reply = "登录失败";
				if ("zhangwendi".equals(user.getName())
						&& "123456".equals(user.getPassword())) {
					reply = "登录成功！";
				}

				// 向客户端发送消息
				os = socket.getOutputStream();
				os.write(reply.getBytes());
				socket.shutdownOutput();
			}

		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null)
					is.close();
				if (os != null)
					os.close();
				socket.close();
				serverSocket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class client {
	public static void main(String[] args) {
		InputStream is = null;
		OutputStream os = null;
		Socket socket = null;
		try {
			socket = new Socket("127.0.0.1", 6000);

			os = socket.getOutputStream();
			is = socket.getInputStream();

			// 向服务器发送消息，需要先转换为字节流
			// Scanner can = new Scanner(System.in);
			// System.out.println("输入账号：");
			// String name = can.next();
			// System.out.println("输入密码：");
			// String password = can.next();

			User user = new User("zhangwendi", "123456");//为了方便测试，直接赋值
			// User user = new User(name, password);//
			ObjectOutputStream oos = new ObjectOutputStream(os);
			oos.writeObject(user);
			// String str = "name:" + name + "&password:" + password;
			// byte[] b = str.getBytes();
			// os.write(b);
			socket.shutdownOutput();

			// 从服务器读取信息，需要先把字节流转换为容易读取的字符流
			BufferedReader bis = new BufferedReader(new InputStreamReader(is));
			String str2 = bis.readLine();
			System.out.println("客户端输出：服务器回应为==>" + str2);
			socket.shutdownInput();

		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null)
					is.close();
				if (os != null)
					os.close();
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}

服务器已经启动!
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi2, password=123456]

<<<<=======再升级=======>>>>实现多客户端的响应处理，利用多线程设计服务器（可同时处理多个客户端的请求）

设计步骤：

1、创建服务器端线程类，run（）方法中实现对一个请求的响应处理。

2、修改服务器端代码，实现一直监听。

3.服务器端每监听到一次请求，创建一个线程对象，启动。

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ServiceThread extends Thread {

	Socket socket = null;

	public ServiceThread(Socket socket) {
		super();
		this.socket = socket;
	}

	@Override
	public void run() {
		InputStream is = null;
		OutputStream os = null;
		try {
			// 从客户端读取数据
			is = socket.getInputStream();

			ObjectInputStream ois = new ObjectInputStream(is);
			User user = (User) ois.readObject();

			try {
				Thread.sleep(3000);// 为了测试方便，休眠三秒
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}

			System.out.println("我是服务器，客户端输入的消息为：" + user);
			socket.shutdownInput();

			try {
				Thread.sleep(3000);// 为了测试方便，再休眠三秒
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			String reply = "登录失败";
			if ("zhangwendi".equals(user.getName())
					&& "123456".equals(user.getPassword())) {
				reply = "登录成功！";
			}

			// 向客户端发送消息
			os = socket.getOutputStream();
			os.write(reply.getBytes());
			socket.shutdownOutput();

		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null)
					is.close();
				if (os != null)
					os.close();
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

}

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Service {

	public static void main(String[] args) {

		ServerSocket serverSocket = null;
		Socket socket = null;

		try {
			serverSocket = new ServerSocket(6000);

			System.out.println("服务器已经启动!");
			while (true) {
				socket = serverSocket.accept();
				new ServiceThread(socket).start();
			}

		} catch (IOException e) {
			e.printStackTrace();
		}

	}
}

服务器已经启动!
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]
我是服务器，客户端输入的消息为：User [name=zhangwendi, password=123456]

 

 

笑笑师弟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java socket服务器与客户端的通信实现用户登录
11-22
这个socket通信比较直观，比较容易看懂，实现了Java中的socket的通信问题。是Java网络编程的一个比较不错的例子！
模拟用户登录的功能TCP协议
Shi_Yuan_Csdn的博客
08-21 1729
模拟用户登录的功能 实现客户发送登录用户信息，服务器端显示登录信并响应给客户端登录成功 服务器端 public class Server { public static void main(String[] args) throws Exception {     ServerSocket ss = new ServerSocket(8090);     Socket s = ss.acce...
网络编程(补)
df5465695的博客
07-11 86
采用多线程的方式，实现多客户请求一个专门负责监听的应用主服务程序一个专门负责处理请求的线程程序小练习：多客户端用户登录需求说明 模拟用户登录的功能 实现客户发送登录用户信息，服务器端显示登录信并响应给客户端登录成功 实现多客户端用户登录分析 创建服务器端线程类，run()方法中实现对一个请求的响应处理 修改服务器端代码，实现循环监听状态 、 服务器端每监听到一个请求，创建一个处理线程 基于UDP协议的Socket编程
Java高级特性-第5章：Java网络编程
qq_42263859的博客
07-12 285
Java高级特性-第5章：Java网络编程
基于TCP协议的Socket编程——使用Socket编程实现用户登录
诗人密语
09-05 5167
关键步骤如下： 1、两个端点进行连接 2、打开传递信息的输入/输出流 3、传递数据，接受数据 4、关闭连接。   模拟用户登录的功能，实现：客户发送登录用户信息，服务器端显示登录信息并响应给客户端（登录成功，登录失败）信息。 服务器端实现步骤： 1、建立连接，监听端口。 2、使用accept（）方法等待客户端触发通信。 3、打开Socket关联的输入/输出流。 4、向输出流中...
aaa
最新发布
04-16
aaa
aaa.rar_播放器aaa
09-14
JMF播放器源代码 运行JMFSample就可以拉 呵呵
socket实现用户登陆
dowhathowtodo
11-28 1000
需求： 通过客户端键盘录入用户名，实现登录。 服务端对客户端的发送过来的用户名进行校验。 如果该用户存在，服务端显示用户登录，并回馈给客户端欢迎光临。 如果该用户不存在，服务端显示用户尝试登录，并回馈给客户端，该用户不存在。 另外，客户端最多只能尝试登录三次。 服务端也一样作此限定。 效果图（左图为客户端，右图为服务器端）： 思路： 客户端： 1，建立socket服务。 ...
通过Socket实现TCP编程，用户登录之服务器相应客户端，客户端和服务端之间的通信...
weixin_34341229的博客
10-09 886
服务器端： 　　1.创建ServerSocket对象，绑定监听端口； 　　2.通过accept()方法监听客户端请求； 　　3.建立连接后通过输入流读取客户端发送的请求信息; 　　4.通过输出流向客户端发送响应信息; package com.wxd.socket; import java.io.*; import java.net.ServerSocket; import ...
socket实现用户端 登录 服务器端 用户名验证
zhanggf的博客
09-04 7758
客户端： 客户端通过键盘录入用户名。 服务端对这个用户名进行校验。 服务器端： 如果该用户存在，在服务端显示xxx，已登陆，并在客户端显示 xxx，欢迎光临； 如果该用户不存在，在服务端显示xxx，尝试登陆，并在客户端显示 xxx，该用户不存在； 最多就登录三次。
typedef struct aaa aaa
06-01
这是一个 C 语言中的语法结构，它使用 typedef 关键字给结构体类型 aaa 起了一个新的类型名 aaa。这个语法结构等价于如下代码： ``` struct aaa { // 结构体成员 }; typedef struct aaa aaa; ``` 用这个新的类型名 aaa，我们就可以方便地定义结构体变量了，例如： ``` aaa myStruct; ``` 需要注意的是，这里的 aaa 实际上是一个不完整类型，因为在 typedef 声明中只声明了类型名，没有声明结构体的具体成员。如果想要使用这个结构体变量，需要在另外的地方定义结构体的具体成员，例如： ``` typedef struct aaa { int a; char b; } aaa; aaa myStruct; ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值