socket编程二，面向对象编程

由于第一个socket编程实现的是传递一个字符串，无法实现一个对象传递，下面来改造上次编写的代码实现面向对象编程.

第一步：新建一个java project,增加一个User类 如下图：






第二步：编写User类的代码，代码如下所示：

package com.socket.entity;

import java.io.Serializable;

/**
 * 用户实体类
 * 
 * @author lfc 备注：如果这个实体类需要通过socket类来实现传递，必须实现 Serializable接口
 */
public class User implements Serializable {

	private static final long serialVersionUID = -8828187863940569914L;
	private long id;
	private String name;
	private String password;
	private int age;

	public long getId() {
		return id;
	}

	public void setId(long id) {
		this.id = id;
	}

	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;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public User() {

	}

	public User(long id, String name, String password, int age) {

		this.id = id;
		this.name = name;
		this.password = password;
		this.age = age;
	}

}

第三步，修改服务器端后的代码如下：

package com.socket.server;

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

import com.socket.entity.User;

/**
 * 服务器端
 * 
 * @author lfc 对于这个客户端以及服务端，运行的时候，必须先服务端开始运行起来，开始监听客户端的程序请求
 * 缺点：如果是登录程序中只能监听一个用户登录程序就会进入死亡转态了
 */
public class SocketServer {

	public static void main(String[] args) {
		
		System.out.println("服务器端准备好监听客户端的请求了。。。");
		try {
			// 1：创建一个服务端的ServerScoket,绑定端口开始监听
			ServerSocket serverScoket = new ServerSocket(8800);
			// 2:使用accept()方法阻塞等待连接，获得新的连接
			Socket socket = serverScoket.accept();
			// 3:获得输入流
			InputStream is = socket.getInputStream();
			// 包装下变成字符流，实现可以对对象进行反序列话操作
			ObjectInputStream ois=new ObjectInputStream(is);
			//创建输出流，用来给客户端提示的响应信息
			OutputStream os = socket.getOutputStream();
			PrintWriter pw = new PrintWriter(os);
			// 4:读取对象，获得对象
			User user=(User)ois.readObject();
			System.out.println("编号："+user.getId());
			System.out.println("年龄："+user.getAge());
			System.out.println("姓名："+user.getName());
			System.out.println("密码："+user.getPassword());
			//给客户端的回应信息
			String response="客户端已经收到你们的信息了,Success";
			pw.write(response);
			pw.flush();
			// 5:关闭资源,注意，关闭的时候，要从底部开始往上依次关闭，顺序不能错！
			os.close();
			pw.close();
			ois.close();
			is.close();
			socket.close();
			serverScoket.close();

		} catch (IOException e) {

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

		System.out.println("本次服务端监听结束！。。。");
	}

}

第四步，修改客户端的代码后如下：

package com.socket.client;

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.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;

import com.socket.entity.User;

/**
 * 客户端
 * 
 * @author lfc
 * 
 */
public class loginClient {

	public static void main(String[] args) throws UnknownHostException {

		try {
			// 1,创建serverScoket客户端，绑定服务器端的ip以及端口
			Socket scoket = new Socket("localhost", 8800);
			// 2,得到scoket读写流
			OutputStream os = scoket.getOutputStream();
			// 获得对象输出流，可以对对象进行序列化操作
			ObjectOutputStream oos=new ObjectOutputStream(os);
			//输入流
			InputStream is=scoket.getInputStream();
			BufferedReader br=new BufferedReader(new InputStreamReader(is));
			// 3,利用一定的协议对scoket中的对读写操作
			PrintWriter pw = new PrintWriter(os);
			User user=new User();
			user.setId(1);
			user.setAge(19);
			user.setName("tom");
			user.setPassword("AAbb123");
			oos.writeObject(user);
			//需要先关闭，一定要记得先关闭
			scoket.shutdownOutput();
			//接收并显示收到服务器端返回的信息！
			String answer = null;
			while (!((answer = br.readLine()) == null)) {
				System.out.println("我是服务器端接收并且给返回的信息：\n" + answer);

			}
			// 4,关闭流
			
			is.close();
			oos.close();
			br.close();
			os.close();
			scoket.close();

		} catch (IOException e) {

			e.printStackTrace();
		}
		System.out.println("客户端请求完毕！");
	}

}

第五步：运行服务器端的代码，控制台输出的内容如下：






可以看见，运行服务器端后，服务器处于监听转态

第六步：运行客户端的代码，结果如下图：








此时客户端收到来自服务器的回应，并且显示success

第七步，再次查看服务器端的控制台输出的内容如下：






服务器端，收到来自客户端的一个对象，并且实现面向对象编程了。