主要是前段时间学习的网络知识的基于TCP与UDP编程，Java实现简单的大小写字母的转化，该文主要参考：
https://blog.csdn.net/yjp19871013/article/details/53537398
UDP服务端代码：
public class ToUpperUDPServer { //服务器的IP
public static final String SERVER_IP = "127.0.0.1"; //服务器端的端口号 最好是大于2000 不要选取那些特殊的端口号 Oracle：1521 MySQL：3306 Tomcat：8080
public static final int SERVER_PORT = 10005; //最大的传输字节数
public static final int MAX_BYTES = 1024; //UDP使用DatagramSocket发送数据包
private DatagramSocket serverSocket; /**
* 启动服务器
* @param serverIp 服务器的IP地址
* @param serverPort 服务器的端口号
*/
public void startServer(String serverIp, int serverPort){ try {
//创建DatagramSocket
InetAddress serverAddr = InetAddress.getByName(serverIp);
serverSocket = new DatagramSocket(serverPort, serverAddr); //创建接受服务的对象
byte[] recvBuf = new byte[MAX_BYTES];
DatagramPacket recvPacket = new DatagramPacket(recvBuf, recvBuf.length); //死循环，一直运行服务器
while(true){ System.out.println("服务端正在接收数据，接收的数据包为："+recvPacket);
//接受数据，会在这里堵塞，直达数据到来
serverSocket.receive(recvPacket);
String receStr = new String(recvPacket.getData(), 0 , recvPacket.getLength()); //获取连接端的IP和端口号port
InetAddress clientAddr = recvPacket.getAddress();
int clientPort = recvPacket.getPort(); //回传数据
String upperStr = receStr.toUpperCase();
byte[] sendBuf = upperStr.getBytes();
DatagramPacket sendPacket = new DatagramPacket(sendBuf, sendBuf.length, clientAddr, clientPort); System.out.println("服务端正在发送数据，发送的数据包为："+sendPacket);
//服务器Socket 发送数据
serverSocket.send(sendPacket);
} } catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SocketException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} public static void main(String[] args) {
ToUpperUDPServer server = new ToUpperUDPServer();
server.startServer(SERVER_IP, SERVER_PORT);
}
}
UDP客户端代码：
public class ToUpperUDPClient { //创建连接的DatagramSocket
private DatagramSocket clientSocket; public String toUpperRemote(String serverIp, int serverPort, String str){ String recvStr = ""; try {
//创建 UDP socket
clientSocket = new DatagramSocket(); byte[] sendBuf = str.getBytes();
InetAddress serverAddr = InetAddress.getByName(serverIp);
DatagramPacket sendPacket = new DatagramPacket(sendBuf, sendBuf.length, serverAddr, serverPort);
clientSocket.send(sendPacket);
System.out.println("客户端正在发送数据，发送的数据包为：" + sendPacket); //接收服务器的响应
byte[] recvBuf = new byte[ToUpperUDPServer.MAX_BYTES];
DatagramPacket recvPacket = new DatagramPacket(recvBuf, recvBuf.length);
clientSocket.receive(recvPacket);
System.out.println("客户端正在接收服务器的响应，接收的数据包为：" + recvPacket); //显示响应
recvStr = new String(recvPacket.getData(), 0 , recvPacket.getLength()); } catch (SocketException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(null != clientSocket){
clientSocket.close();
clientSocket = null;
}
}
return recvStr;
} public static void main(String[] args) { ToUpperUDPClient client = new ToUpperUDPClient();
String recvStr = client.toUpperRemote(ToUpperUDPServer.SERVER_IP, ToUpperUDPServer.SERVER_PORT, "aaaAAAbbbBBBcccCCC");
System.out.println("客户端收到的数据:" + recvStr);
}
}
TCP服务端有三种模式：
1、基于TCP协议阻塞式服务
public class ToUpperTCPBlockServer { //服务端的IP地址
public static final String SERVER_IP = "127.0.0.1"; //服务端的端口号
public static final int SERVER_PORT = 10005; //请求终结字符串
public static final char REQUEST_END_CHAR = '#'; /***
* 开启服务
* @param serverIp 服务端ip地址
* @param serverPort 服务端端口号
*/
public void startServer(String serverIp, int serverPort){ try {
//创建服务器地址对象
InetAddress serverAddr = InetAddress.getByName(serverIp); //Java提供了ServerSocket作为服务器
//楼主使用了Java的自动关闭的语法， 这个自动关闭语法是JDK1.7中的，我这里是正常写法
ServerSocket serverSocket = new ServerSocket(SERVER_PORT, 5, serverAddr); while(true){ StringBuilder recvStrBuilder = new StringBuilder(); //有客户端向服务器发起tcp连接时，accept会返回一个Socket
//该Socket的対端就是客户端的Socket
//具体过程可以查看TCP三次握手过程
Socket connection = serverSocket.accept();
InputStream in = connection.getInputStream(); //读取客户端的请求字符串，请求字符以#结尾
for(int c=in.read(); c!=REQUEST_END_CHAR; c=in.read()){
recvStrBuilder.append((char) c);
}
recvStrBuilder.append("#");
String recvStr = recvStrBuilder.toString(); //向客户端写出处理过的字符串
OutputStream os = connection.getOutputStream();
os.write(recvStr.toUpperCase().getBytes());
} } catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} public static void main(String[] args) {
ToUpperTCPBlockServer server = new ToUpperTCPBlockServer();
System.out.println("服务器端开始接收请求...");
server.startServer(SERVER_IP, SERVER_PORT);
}
}
2、基于TCP的并发服务器
public class ToUpperTCPThreadServer { //服务器对外的ip
public static final String SERVER_IP = "127.0.0.1"; //服务器端口号
public static final int SERVER_PORT = 10005; //请求中介字符串
public static final char REQUEST_END_CHAR = '#'; /***
* 开启服务
* @param serverIp 服务端ip
* @param serverPort 服务端端口号
*/
public void startServer(String serverIp, int serverPort){ try {
InetAddress serverAddr = InetAddress.getByName(serverIp);
ServerSocket serverScoket = new ServerSocket(SERVER_PORT, 5 ,serverAddr); //创建线程池
Executor executor = Executors.newFixedThreadPool(100); //保持服务一直处于开启的状态
while(true){
final StringBuilder recvStrBuilder = new StringBuilder(); //有客户向服务器发起TCP连接时，accept会返回一个socket
//该socket的对端就是客户端的socket
//具体情况可以查看socket的三次握手情况
final Socket connection = serverScoket.accept(); //利用线程池，启动线程
executor.execute(new Runnable() { @Override
public void run() {
// TODO Auto-generated method stub
Socket conn = connection;
try {
InputStream in = conn.getInputStream();
for(int c=in.read(); c!=REQUEST_END_CHAR; c=in.read()){
recvStrBuilder.append((char) c);
}
recvStrBuilder.append('#');
String resvStr = recvStrBuilder.toString(); ////向客户端写出处理后的字符串
OutputStream os = connection.getOutputStream();
os.write(resvStr.toUpperCase().getBytes()); } catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
if(conn != null){
try {
conn.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
});
} } catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} public static void main(String[] args) {
ToUpperTCPThreadServer server = new ToUpperTCPThreadServer();
server.startServer(SERVER_IP, SERVER_PORT);
}
}
3、第三种
public class ToUpperTCPNonBlockServer { //服务器对外的ip
public static final String SERVER_IP = "127.0.0.1"; //服务器端口号
public static final int SERVER_PORT = 10005; //请求中介字符串
public static final char REQUEST_END_CHAR = '#'; /**
* 开启服务
* @param serverIp 服务器对外的ip
* @param serverPort 服务器端端口号
*/
public void startServer(String serverIp, int serverPort){ try {
//使用NIO 需要用到ServerSocketChannel 其中包含一个serverSocket对象
ServerSocketChannel serverChannel = ServerSocketChannel.open();
//创建地址对象
InetSocketAddress localAddr = new InetSocketAddress(SERVER_IP,SERVER_PORT);
//服务器绑定地址
serverChannel.bind(localAddr);
//设置为非堵塞
serverChannel.configureBlocking(false); //注册到Selector 会ServerSocket的accept
//我们用Selector监听accept是否返回
//当调用accept卡伊返回时，会得到通知
//注意是可以返回，还需要调用accept
Selector selector = Selector.open();
serverChannel.register(selector, SelectionKey.OP_ACCEPT); //服务一直处于启动状态，所以这个是死循环
while(true){
//调用select，阻塞在这里，直到有注册的channel满足条件
selector.select(); //如果走到这里，有符合条件的channel
//可以通过selector.selectedKeys().iterator()得到符合条件的迭代器
Iterator<SelectionKey> keys = selector.selectedKeys().iterator(); //处理得到的keys
while(keys.hasNext()){ //取出一个key 并移除
SelectionKey key = keys.next();
keys.remove();
try{
if(key.isAcceptable()){
//有accept返回，取出可以使用的channel
ServerSocketChannel server = (ServerSocketChannel) key.channel(); //调用accept三次握手 返回与客户端可以通信的channel
SocketChannel channel = server.accept(); //将该channel 置为非堵塞
channel.configureBlocking(false); //注册此selector 当可读或可写时将得到通知，select返回
channel.register(selector, SelectionKey.OP_READ);
}else if(key.isReadable()){
//有channel可读 取出可读的channel
SocketChannel channel = (SocketChannel) key.channel(); //创建读取缓冲区，一次读取1024字节
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer); //锁住缓冲区，缓冲区的大小将固定
buffer.flip(); //附件上buffer 供写出使用
key.attach(buffer);
key.interestOps(SelectionKey.OP_WRITE);
}else if(key.isWritable()){
//有channel可写，取出可写的channel
SocketChannel channel = (SocketChannel) key.channel(); //取出可读时设置的缓冲区
ByteBuffer buffer = (ByteBuffer) key.attachment(); //将缓冲区的指针移动到缓冲区开始的位置
buffer.rewind(); //读取为String
String recv = new String(buffer.array()); //清空缓冲区
buffer.clear();
buffer.flip(); //写回数据
byte[] sendByte = recv.toUpperCase().getBytes();
channel.write(ByteBuffer.wrap(sendByte)); //变为等待者
key.interestOps(SelectionKey.OP_READ);
}
}catch(Exception e){
key.cancel();
key.channel().close();
e.printStackTrace();
}
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} public static void main (String[] args){
ToUpperTCPBlockServer server = new ToUpperTCPBlockServer();
server.startServer(SERVER_IP, SERVER_PORT);
}
}
TCP客户端：
public class ToUpperTCPClient { //客户端的请求的 TCP socket
private Socket clientSocket; public String toUpperRemote(String serverIp, int ServerPort, String str){ StringBuilder recvStrBuilder = new StringBuilder(); try {
//创建连接服务器的socket
clientSocket = new Socket(serverIp, ServerPort); //写出请求的字符串
OutputStream os = clientSocket.getOutputStream();
os.write(str.getBytes()); //读取服务器响应
InputStream in = clientSocket.getInputStream();
for(int c=in.read(); c!='#'; c=in.read()){
recvStrBuilder.append((char) c);
} } catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(clientSocket != null){
try {
clientSocket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
return recvStrBuilder.toString();
} public static void main(String[] args) {
ToUpperTCPClient client = new ToUpperTCPClient();
String recvStr = client.toUpperRemote(ToUpperTCPBlockServer.SERVER_IP, ToUpperTCPBlockServer.SERVER_PORT,"aaaAAAbbbBBBcccCCC" + ToUpperTCPBlockServer.REQUEST_END_CHAR);
System.out.println("收到:" + recvStr);
}
}
