Java Socket 连接池问题

0 0

Java Socket 连接池问题3

应用场合:
表现层用JSF框架,开发一个网盘,我必须要与集群服务器进行通信之后在将服务器的返回结果呈现给客户端.
考虑到客户端并发及为了减小服务器端开销,我使用了Socket连接池的思想.
对应每一个客户端请求就从池中取出一个socket,发送HTTP请求到集群服务器端,接收服务器端HTTP响应.
其他的请求操作都是完全正确的,但是在上传文件时,服务器端总是报400 bad request错误.
集群服务器开发的大哥告诉我这是我这边发送的请求不正确导致的,但是我查找了好久实在不明白错在什么地方.
贴一段代码,还望各位指点哈,多谢!
//

import java.net.Socket;
import java.net.SocketException;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import org.apache.log4j.Logger;

import cn.com.loongstore.util.IOUtils;

/**
* socket连接池
* @author Administrator
*
*/
public class SocketPool {
private Logger logger = Logger.getLogger(SocketPool.class);

public static int MIN_CONNECTIONS = 0; // 最大socket连接数
public static int MAX_CONNECTIONS = 0; // 最小socket连接数
private static SocketPool instance = null;
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();

private List<Socket> socketList = null;

private SocketPool() {
//
}

public static SocketPool getInstance() {
if(instance == null) {
instance = new SocketPool();
}
return instance;
}

public void init() {
socketList = new LinkedList<Socket>();
int minConnections = LdsConfig.getMinConnections();
int maxConnections = LdsConfig.getMaxConnections();
for(int i=minConnections;i<=maxConnections;i++) {
socketList.add(socketList.size(), produceSocket());
}
logger.info("Socket pool initialized size: "+socketList.size());
}

/**
* 从Socket池中获取一个可用的Socket
* @return
*/
public Socket getSocket() {
Socket socket = null;

lock.lock();
try {
while(socketList.isEmpty()) {
System.out.println(Thread.currentThread().getName()+" wait getting socket...");
condition.await();
}
socket = socketList.remove(0);
}catch(InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
//socket = produceSocket();
return socket;
}

/**
* 使用完Socket之后将Socket归还到Socket池中
* @param socket
*/
public void restoreSocket(Socket socket) {
if(socket == null) {
return;
}

lock.lock();
try {
socketList.add(socketList.size(), socket);
condition.signal();
}finally {
lock.unlock();
}
}

/**
* 关闭Socket池
*/
public void shutDownSocketPool() {
for(Socket socket:socketList) {
IOUtils.closeSocket(socket);
socket = null;
}
}

/**
* 获取Socket池大小
* @return
*/
public int getPoolSize() {
int size = 0;

lock.lock();
try {
size = socketList.size();
}finally {
lock.unlock();
}
return size;
}

/**
* 生成一个新的Socket对象
* @return
*/
public Socket produceSocket() {
Socket socket = new Socket();
try {
socket.setReuseAddress(true);
socket.setKeepAlive(true);
socket.setSoTimeout(10*1000);
} catch (SocketException e) {
e.printStackTrace();
}
return socket;
}

}

// 发送HTTP请求并接收HTTP响应的函数
// 先读HTTP消息头,再读HTTP消息体
protected HttpPacket sendAndReceived(HttpPacket packet) throws IOException {
HttpPacket response = null;
DataOutputStream dos = null;
DataInputStream dis = null;

if(packet == null || packet.getHeader() == null) {
return response;
}

System.out.println("Send http request ...");
dos = new DataOutputStream(socket.getOutputStream());
dos.write(packet.getHeader().getBytes("UTF-8"));
if(!packet.isEmptyBody()) {
dos.write(packet.getBody());
}
dos.flush();
System.out.println("Send http request complete.");

System.out.println("Receive http reponse header ...");
dis = new DataInputStream(socket.getInputStream());
int readLength = 0;
String header = null;
byte[] buffer = new byte[512]; // 预读缓冲区
byte[] sepBytes = new byte[4]; // 存放消息头与消息体的分隔符\r\n\r\n
byte[] headerBytes = null; // 消息头数据
byte[] headerBodyBytes = null; // 在读取消息头时读到的部分消息体数据
int contentLength = 0; // 消息体数据长度
int k = 1;
int index = 0; // 分隔符\r\n\r\n在缓冲区中距离起始位置的偏移量

readLength = dis.read(buffer);// 读取HTTP响应头时一次性读取512个字节,跟响应实体"多退少补"
if(readLength < 0) { // 连接关闭,请求重发
throw new IOException("Socket have closed");
}

for(int i=0;i<readLength;i++) {
sepBytes[(k-1)%4] = buffer[i];
k++;
if(sepBytes[0] == 13 && sepBytes[1] == 10 && sepBytes[2] == 13 && sepBytes[3] == 10) {
index = i;
break;
}else if(sepBytes[3] == 13 && sepBytes[0] == 10 && sepBytes[1] == 13 && sepBytes[2] == 10) {
index = i;
break;
}
}

if(index > 0) {
headerBytes = new byte[index+1];
headerBodyBytes = new byte[readLength-index-1];
System.arraycopy(buffer, 0, headerBytes, 0, (index+1));
System.arraycopy(buffer, (index+1), headerBodyBytes, 0, (readLength-index-1));
}else {
headerBytes = buffer;
}
header = new String(headerBytes);
System.out.println("Receive http response header complete.");

System.out.println("Receive http response boy ...");
readLength = 0;
byte[] body = null;
contentLength = proParser.parseContentLength(header);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
if(headerBodyBytes != null) {
bos.write(headerBodyBytes); // 保存之前读取到的部分响应实体
readLength = headerBodyBytes.length;
}
if(contentLength > readLength) {
if(contentLength > 1024) {
body = new byte[1024];
}else {
body = new byte[contentLength];
}

while(readLength < contentLength) {
int length = dis.read(body);
if(length > 0) {
bos.write(body,0,length);
readLength += length;
}else {
break;
}
}
}
body = bos.toByteArray();
bos = null;
System.out.println("Receive http response body complete.");

System.out.println(header);
System.out.println(body==null?"http response body is empty.":new String(body));

response = new HttpPacket(request.getName(), header,body);
return response;
}

问题补充：

greenmartian 写道

不明白为什么要池化socket，连接如果断了，不抛弃留着有什么意义呢

之所以池化socket，是为了重用连接，因为与服务器端建立的实际上是长连接，不是通信完毕就立刻关闭的。倘若面对浏览器的每一操作请求都new一个新的socket是不是开销就大了啊！

Java Web Socket 连接池