public class MyServerSocket {
public static void main(String[] args){
System.out.println("Hello, World!");
//port 1-65535
try{
ServerSocket serverSocket=new ServerSocket(12345);
//accept是个阻塞的方法 会阻塞当前线程 返回socket类型
Socket socket=serverSocket.accept();
//建立连接
JOptionPane.showMessageDialog(null,"有客户机连接到了本机的12345端口");
}catch (IOException e){
e.printStackTrace();
}
}
}
Kotlin写法
object MyServerSocket {
fun main(args: Array<String>) {
println("Hello, World!")
//port 1-65535
try {
val serverSocket = ServerSocket(12345)
//accept是个阻塞的方法 会阻塞当前线程 返回socket类型
val socket = serverSocket.accept()//接收客户端请求
//建立连接
JOptionPane.showMessageDialog(null, "有客户机连接到了本机的12345端口")
} catch (e: IOException) {
e.printStackTrace()
}
}
}
public class ServerListener extends Thread {
@Override
public void run() {
System.out.println("Hello, World!");
//port 1-65535
try{
ServerSocket serverSocket=new ServerSocket(12345);
//accept是个阻塞的方法 会阻塞当前线程 返回socket类型
//每当有客户端连接 accept都会返回一个socket对象 循环接听客户端的连接
while(true){
Socket socket=serverSocket.accept();
//建立连接
JOptionPane.showMessageDialog(null,"有客户机连接到了本机的12345端口");
//每个socket又要与每个独立的客户端进行通信 所以要将socket传递给新的线程
new ChatSocket(socket).start();//循环监听客户端请求
}
}catch (
IOException e){
e.printStackTrace();
}
}
}
public class ChatSocket extends Thread {
Socket socket;
public ChatSocket(Socket s){
this.socket=s;
}
//写回方法
public void out(String out) throws IOException {
socket.getOutputStream().write(out.getBytes("UTF-8"));
}
@Override
public void run() {
int count=0;
while (true){
count++;
try {
out("loop"+count);
sleep(1000);
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}
}
1）运行多个窗体访问
2）telnet localhost 12345
3）多个线程不同，每个分配独立的chatsocket线程，所以比如要管理线程
public class ChatManager {
//私有化构造方法 单例化
private ChatManager() { }
private static final ChatManager cm = new ChatManager();
public static ChatManager getChatManaget() {
return cm;
}
Vector<ChatSocket> vector = new Vector<ChatSocket>();
public void add(ChatSocket cs) {
vector.add(cs);
}
//某个线程向所有客户端发送信息
public void publish(ChatSocket cs, String out) throws IOException {
System.out.print(out);
for (int i = 0; i < vector.size(); i++) {
System.out.println("当前cs"+cs);
ChatSocket csChatSoccket = vector.get(i);
if (!cs.equals(csChatSoccket)){
String msg = "";
msg += out + "\n";//加个换行 不然安卓收不到 太坑了
csChatSoccket.out(msg);
}
}
}
}
代码二:建立了解后单独保存并且封入管理类
public class ServerListener extends Thread {
@Override
public void run() {
System.out.println("Hello, World!");
//port 1-65535
try{
ServerSocket serverSocket=new ServerSocket(12345);
//accept是个阻塞的方法 会阻塞当前线程 返回socket类型
//每当有客户端连接 accept都会返回一个socket对象 循环接听客户端的连接
while(true){
Socket socket=serverSocket.accept();
//建立连接
JOptionPane.showMessageDialog(null,"有客户机连接到了本机的12345端口");
//每个socket又要与每个独立的客户端进行通信 所以要将socket传递给新的线程
/*更新1.
匿名方式直接创建 改为命名方式(赋个值 然后可以被调用)
new ChatSocket(socket).start();//循环监听客户端请求*/
ChatSocket cs=new ChatSocket(socket);
cs.start();
ChatManager.getChatManaget().add(cs);
}
}catch (
IOException e){
e.printStackTrace();
}
}
}
代码三：读入缓冲区的内容并发送消息给终端
public class ChatSocket extends Thread {
Socket socket;
public ChatSocket(Socket s){
this.socket=s;
}
public void out(String out) throws IOException {
socket.getOutputStream().write(out.getBytes("UTF-8"));
}
@Override
public void run() {
// int count=0;
/*
* 修改2. 服务器循环读取消息再发送给终端
* */
try {
BufferedReader br=new BufferedReader(
new InputStreamReader(
socket.getInputStream(),"UTF-8"));
String line=null;
while ((line=br.readLine())!=null) {
ChatManager.getChatManaget().publish(this,line);
}
br.close();
} catch (IOException e) {
e.printStackTrace();
}
//count++;
/*try {
out("loop"+count);
sleep(1000);
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}*/
}
}
关闭一个窗口后后，若未remove数组中的东西 ，则会报错(1. socked
关闭报错 2.读写流关闭报错(安卓))。每次连接的这个弹窗提示要点掉，不然会阻塞线程。
<uses-permission android:name="android.permission.INTERNET" />
compileSdkVersion 29
buildToolsVersion "29.0.2"
class MainActivity : AppCompatActivity(), View.OnClickListener {
companion object {
const val KEY = "key"
const val TAG = "My Phone"
}
//创建一个socket
private var socket: Socket? = null
//创建输入输出流
private var writer: BufferedWriter? = null
private var reader: BufferedReader? = null
private var socketAddress: SocketAddress? = null
private var isConnected = false
private var sp: SharedPreferences? = null
private var currentName: String? = null
private var connectFailed = false
private var progressDialog: ProgressDialog? = null
private var task: AsyncTask<Void?, String?, Void?>? = null
val currentPosition by lazy { StringBuilder() }
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
init()
}
private fun init() {
btnConnect.setOnClickListener(this)
btnSend.setOnClickListener(this)
btnSetName.setOnClickListener(this)
tvConnectState!!.text = "连接状态：未连接"
//初始化sharepreference
sp = getPreferences(MODE_PRIVATE)
sp?.let {
currentName = it.getString(MainActivity.Companion.KEY, null)
}
if (currentName != null) {
tvCurrentName!!.text = "当前昵称：$currentName"
}
}
override fun onClick(v: View) {
when (v.id) {
R.id.btnConnect ->
if (currentName != null) {
connect()
} else {
Toast.makeText(this, "请先设置昵称后重新连接", Toast.LENGTH_SHORT).show()
}
R.id.btnSend -> send()
R.id.btnSetName -> {
val tmp = etSetName!!.text.toString().trim { it <= ' ' }
setName(tmp)
}
}
}
// ==================================== 逻辑相关
private fun setName(s: String) {
if (s != "") {
val editor = sp!!.edit()
editor.putString(MainActivity.Companion.KEY, s)
if (editor.commit()) {
tvCurrentName!!.text = "当前昵称：$s"
currentName = s
etSetName!!.setText("")
Toast.makeText(this, "昵称设置成功", Toast.LENGTH_SHORT).show()
} else {
Toast.makeText(this, "昵称设置失败，请重试", Toast.LENGTH_SHORT).show()
}
} else {
Toast.makeText(this, "昵称不能为空", Toast.LENGTH_SHORT).show()
}
}
private fun connect() {
progressDialog = ProgressDialog.show(this," 连接状况", "正在连接...")
var read: AsyncTask<Void, String, Void> = @SuppressLint("StaticFieldLeak")
object : AsyncTask<Void, String, Void>() {
@SuppressLint("WrongThread")
override fun doInBackground(vararg params: Void?): Void? {
//把这些放Asynctask中更好 不允许在主线程连接
val ip = etIP!!.text.toString()
val port = Integer.valueOf(etPort!!.text.toString())
//socket = java.net.Socket(ip, port)//Socket(etIP!!.text,)
//设置最长连接时间
socket= Socket()
socketAddress = InetSocketAddress(ip, port)
socket?.let {
it.connect(socketAddress,3000)
//包装Buffererd
writer = BufferedWriter(OutputStreamWriter(it.getOutputStream()))
reader = BufferedReader(InputStreamReader(it.getInputStream()))
//连接成功就发送这个
publishProgress("@success")
}
var line: String? = null
Log.e(TAG, "doInBackground: Start$line")
//就是line不为null
while (reader!!.readLine().also({ line = it }) != null) {
Log.e(TAG, "doInBackground: 进入循环$line" )
publishProgress(line)
}
Log.e(TAG, "doInBackground: 退出循环$line" )
return null
}
override fun onProgressUpdate(vararg values: String?) {
//这里没做连接失败的反馈 相加自己加个glag
if (values[0].equals("@success")){
tvConnectState!!.text = "连接状态：已连接"
Toast.makeText(this@MainActivity, "连接成功", Toast.LENGTH_SHORT).show()
progressDialog!!.dismiss()
}
//发布values的第一个对象
Log.e(TAG, "onProgressUpdate: Start$values[0]" )
currentPosition.append("别人说:==${values[0]}"+"\n")
tvChatRecord?.text=currentPosition
super.onProgressUpdate(*values)
}
}
read.execute()
}
//不涉及联网操作 放主线程应该没问题 有问题 flush
private fun send() {
Thread(Runnable {
//一定要追加换行符
currentPosition.append("我说:${etMassage.text}").append("\n")
writer?.write(etMassage.text.toString() + "\n")
writer?.flush()
runOnUiThread {
etMassage!!.setText("")
tvChatRecord?.text = currentPosition
}
//数据强制输出 安卓反复开启 服务器会有混淆 报closed错误
}).start()
}
override fun onDestroy() {
writer?.close()
reader?.close()
super.onDestroy()
}
}
第一个阶段，完成连接发送更新UI消息，之后便进入了While循环，从断点我们知道一进入就不会退出循环了(哪怕刚开始取到空，只是单纯的 不执行代码 这种类似以起c++ ！=EOF输入CTRL+Z才退出循环，一直在循环中 发现输入流有东西(其他端实现)就直接通知UI更新)
实现我发的就是我说，其他人发的就其他人说：这个比较简直自己发的直接获取为我说，AsyncTask中接到的所有消息都是他说
发送消息非常重要加换行符，估计是侦测借位换行符的，亲测结尾加上两个换行符也达不到换行效果。
打断点暂时测不出来关闭连接后的 情况
