java socket连接池_Java - Socket连接池
1：SocketAdapter类，此类继承了socket，重载了socket类的close方法，目的是当用户关闭socket的时候，我们并不关闭它只是放在连接池内部。
package com.tarena.socketpool;
import java.net.*;
import java.io.IOException;
/**
*
socket连接的简单实现
*
Description:
*
Copyright: Copyright Tarena(c) 2005
*
Company: Tarena
* @author chengxing
* @version 1.0
*/
public class ConnectionAdapter extends Socket{
/**
* 连接状态
*/
private boolean status=true;
/**
* 默认的构造函数
*/
public ConnectionAdapter() {
super();
}
public ConnectionAdapter(String host,int port)throws UnknownHostException,IOException{
super(host,port);
}
/**
* 判断此连接是否空闲
* @return boolean 空闲返回ture,否则false
*/
public boolean isFree(){
return status;
}
/**
* 当使用此连接的时候设置状态为false(忙碌)
*/
public void setBusy(){
this.status=false;
}
/**
* 当客户端关闭连接的时候状态设置为true(空闲)
*/
public void close(){
System.out.println(Close : set the status is free );
status=true;
}
public void destroy(){
//Close socket connection
close();
// System.out.println(Close success );
}
}
第二个类连接管理器。
package com.tarena.socketpool;
import java.lang.reflect.*;
import java.util.Properties;
/**
*
连接管理器
*
Copyright: Copyright Tarena(c) 2005
*
Company: Tarena
* @author chengxing
* @version 1.0
*/
public class ConnectionManager {
//测试程序默认的连接池实现类
public static final String PROVIDER_CLASS=com.tarena.socketpool.MyConnectionProvider;
//测试程序的默认ip
public static final String HOST=127.0.0.1;
//测试程序的默认端口号
public static final String PORT=9880;
/**
* 注册钩子程序的静态匿名块
*/
static {
//增加钩子控制资源的释放周期
Runtime runtime = Runtime.getRuntime();
Class c = runtime.getClass();
try {
Method m = c.getMethod(addShutdownHook, new Class[] { Thread.class } );
m.invoke(runtime, new Object[] { new ShutdownThread() });
}
catch (NoSuchMethodException e) {
e.printStackTrace();
// Ignore -- the user might not be running JDK 1.3 or later.
}
catch (Exception e) {
e.printStackTrace();
}
}
/**
* 默认的构造函数
*/
public ConnectionManager() {
}
/**
* 得到并初始化一个连接池
* 连接池的实现类通过系统参数来传递进来，通过命令行-DConnectionProvider=YourImplClass
* 如果没有指定的实现的话，则采用系统默认的实现类
* 通过命令行传入的参数列表如下
* 对方主机名-DHost=192.168.0.200
* 对方端口号 -DPort=9880
* 最小连接数 -DMax_style='font-size:10px'0
* 最大连结数 -DMin_style='font-size:14px'0
* 以上的值可以改变，但是参数不能改变，
* 最大连结数和最小连接数可以省略，默认值分别为２０和１０
* @return ConnectionProvider
*/
public static ConnectionProvider getConnectionProvider()throws Exception{
String provider_class=System.getProperty(ConnectionProvider);
if(provider_class==null)provider_class=PROVIDER_CLASS;
String host=System.getProperty(Host);
if(host==null)host=HOST;
String port=System.getProperty(port);
if(port==null)port=PORT;
String max_size=System.getProperty(Max_size);
String min_size=System.getProperty(Min_size);
Properties pro=new Properties();
pro.setProperty(ConnectionProvider.SERVER_IP,host);
pro.setProperty(ConnectionProvider.SERVER_PORT,port);
if(max_size!=null)pro.setProperty(ConnectionProvider.MAX_SIZE,max_size);
if(min_size!=null)pro.setProperty(ConnectionProvider.MIN_SIZE,min_size);
//通过反射得到实现类
System.out.println(provider_class);
System.out.flush();
Class provider_impl=Class.forName(provider_class);
//由于是单子模式，采用静态方法回调
Method m=provider_impl.getMethod(newInstance,new Class[]{java.util.Properties.class});
ConnectionProvider provider=null;
try{
provider = (ConnectionProvider) m.invoke(provider_impl, new Object[]{pro});
}catch(Exception e){
e.printStackTrace();
}
return provider;
}
/**
*
*
一个钩子的线程: 在程序结束的时候调用注销连接池
*
Description:
*
Copyright: Copyright Tarena(c) 2005
*
Company: Tarena
* @author chengxing
* @version 1.0
*/
private static class ShutdownThread extends Thread {
public void run() {
try{
ConnectionProvider provider = ConnectionManager.getConnectionProvider();
if (provider != null) {
provider.destroy();
}
}catch(Exception e){
e.printStackTrace();
}
}
}
}
第三个类，连接池的接口定义
package com.tarena.socketpool;
import java.net.*;
import java.util.*;
import java.io.IOException;
/**
*
*
定义的抽象类，所有的子类必须单子模式去实现，
* 统一方法为public ConnectionProvider newInstance();
* 连接提供器的抽象接口，每一个实现它的子类最好都是JAVABEAN，
* 这样它的方法就可以是被外界控制
* @see JiveBeanInfo
*
Copyright: Copyright Tarena(c) 2005
*
Company: Tarena
* @author chengxing
* @version 1.0
*/
public interface
ConnectionProvider {
public static final String SERVER_IP = SERVER_IP_ADDRESS;
public static final String SERVER_PORT = SERVER_IP_PORT;
public static final String MAX_SIZE = MAX_SIZE;
public static final String MIN_SIZE = MIN_SIZE;
/**
*判断连接池内是否有连接
* @return true 有连接返回true,否则返回false
*/
public boolean isPooled();
/**
* 当此方法被调用的时候提供一个 socket
* @see Socket
* @return Socket a Connection object.
*/
public Socket getConnection() throws java.net.SocketException;
/**
* 连接池初始化
*/
public void init() throws UnknownHostException, IOException;
/**
* 连接池重新启动
*/
public void restart() throws UnknownHostException, IOException;
/**
* 注销连接池
*/
public void destroy();
}
第四个类MyConnectionProvider，自己写的一个连接池的简单实现
package com.tarena.socketpool;
import java.util.*;
import java.net.*;
import java.net.SocketException;
import java.io.IOException;
/**
*
*
这是一个连接管理器的简单实现
*
Description: implements the Interface ConnectionProvider
*
Copyright: Copyright Tarena(c) 2005
*
Company: Tarena
* @author chengxing
* @version 1.0
*/
public class MyConnectionProvider
implements ConnectionProvider {
private Properties pro = null;
private static ConnectionProvider provider = null;
private static Object object_lock = new Object();
private String ip;
private String port;
/**
* 默认的最大连接数
*/
private int max_size = 20;
/**
* 默认的最小连接数
*/
private int min_size = 10;
/**
* Socket connection池数组
*/
private ConnectionAdapter[] socketpool = null;
/**
* 构造对象的时候初始化连接池
* @throws UnknownHostException 未知的主机异常
* @throws IOException
*/
private MyConnectionProvider(Properties pro) throws UnknownHostException,
IOException {
ip = pro.getProperty(SERVER_IP);
port = pro.getProperty(SERVER_PORT);
String max_size_s = pro.getProperty(MAX_SIZE);
String min_size_s = pro.getProperty(MIN_SIZE);
if (max_size_s != null) {
max_size = Integer.parseInt(max_size_s);
}
if (min_size_s != null) {
min_size = Integer.parseInt(min_size_s);
}
init(); //构造对象的时候初始化连接池
}
/**
* 判断是否已经池化
* @return boolean 如果池化返回ture,反之返回false
*/
public boolean isPooled() {
if (socketpool != null) {
return true;
}
else return false;
}
/**
*返回一个连接
* @return a Connection object.
*/
public Socket getConnection() {
Socket s = null;
for (int i = 0; i < socketpool.length; i++) {
if (socketpool[i] != null) {
//如果有空闲的连接，返回一个空闲连接，如果没有，继续循环
if (socketpool[i].isFree()) {
s = socketpool[i];
return s;
}
else continue;
}
else { //如果连接为空，证明超过最小连接数，重新生成连接
try {
s = socketpool[i] = new ConnectionAdapter(ip, Integer.parseInt(port));
}
catch (Exception e) {
//never throw
}
}
}
//如果连接仍旧为空的话，则超过了最大连接数
if (s == null) {
try { //生成普通连接，由客户端自行关闭，释放资源，不再由连接池管理
s = new Socket(ip, Integer.parseInt(port));
}
catch (Exception e) { //此异常永远不会抛出
}
}
return s;
}
/**
* 初始化连接池
* @throws UnknownHostException 主机ip找不到
* @throws IOException 此端口号上无server监听
*/
public void init() throws UnknownHostException, IOException {
socketpool = new ConnectionAdapter[max_size];
for (int i = 0; i < min_size; i++) {
socketpool[i] = new ConnectionAdapter(ip, Integer.parseInt(port));
System.out.print( . );
}
System.out.println();
System.out.println(System init success ....);
}
/**
* 重新启动连接池
* @throws UnknownHostException
* @throws IOException
*/
public void restart() throws UnknownHostException, IOException {
destroy();
init();
}
/**
* 注销此连接池
*/
public void destroy() {
for (int i = 0; i < socketpool.length; i++) {
if (socketpool[i] != null) {
ConnectionAdapter adapter = (ConnectionAdapter) socketpool[i];
adapter.destroy();
System.out.print( . );
}
}
System.out.println(\ndestory success ....);
}
/**
* 静态方法，生成此连接池实现的对象
* @param pro Properties 此连接池所需要的所有参数的封装
* @throws UnknownHostException 主机无法找到
* @throws IOException 与服务器无法建立连接
* @return ConnectionProvider 返回父类ConnectionProvider
*/
public static ConnectionProvider newInstance(java.util.Properties pro) throws
UnknownHostException, IOException {
if (provider == null) {
synchronized (object_lock) {
if (provider == null) {
provider = new MyConnectionProvider(pro);
}
}
}
return provider;
}
/**
*设置系统属性 通过封装系统properties对象来封装所需要的不同值
* SERVER_IP，SERVER_PORT，MAX_SIZE,MIN_SIZE等父类定义的不同的参数
* @param pro Properties 传进来的系统属性
*/
public void setProperties(Properties pro) {
this.pro = pro;
}
}
java socket连接池_Java - Socket连接池相关推荐
- java socket 对方关闭_java Socket判断对方是否已关闭连接
如何判断远端socket是否已经断开连接,如果断开那么需要重新连接. 1通过socket类的方法isClosed().isConnected().isInputStreamShutdown().isO ...
- java socket 线程池_java socket编程的一个例子（线程池）
服务器程序EchoServer.java: import java.io.*; import java.net.*; import java.util.concurrent.*; public cla ...
- java dbcp连接池_Java——DBCP连接池
连接池 实际开发中"获得连接"或"释放资源"是非常消耗系统资源的两个过程,为了解决此类性能问题,通常情况我们采用连接池技术,来共享连接Connection.这样 ...
- java redis释放连接池_Java 使用连接池操作redis
构建连接池对象JedisPool JedisPool jedisPool = new JedisPool(jedisPoolConfig, "127.0.0.1", 6379); ...
- mysql odbc连接池_Java Mysql连接池配置和案例分析--超时异常和处理
前言: 最近在开发服务的时候, 发现服务只要一段时间不用, 下次首次访问总是失败. 该问题影响虽不大, 但终究影响用户体验. 观察日志后发现, mysql连接因长时间空闲而被关闭, 使用时没有死链检测 ...
- java socket负载均衡_Java Socket分发服务负载均衡
1 1. 设备请求分发服务器,分发服务器返回有效的socket服务器ip与port,然后断开连接.2 a) 设备与服务器建立连接.3 b) 服务器接收到连接请求后,立即将分配好的socket服务器ip ...
- java 多线程池_Java ThreadPoolExecutor线程池 同时执行50个线程
最近项目上有个需求,需要从FTP服务器中下载大批量的数据文件,然后解析该数据文件进行入库,数据库为oracle,最后在通过web工程,以报表和图表的形式进行展现. 这些批量的数据文件为纯文本文件,每天 ...
- java socket远空_JAVA Socket超时浅析
套接字或插座(socket)是一种软件形式的抽象,用于表达两台机器间一个连接的"终端".针对一个特定的连接,每台机器上都有一个"套接字",可以想象它们之间有一条 ...
- java定时线程池_java 定时器线程池（ScheduledThreadPoolExecutor）的实现
前言 定时器线程池提供了定时执行任务的能力,即可以延迟执行,可以周期性执行.但定时器线程池也还是线程池,最底层实现还是ThreadPoolExecutor,可以参考我的另外一篇文章多线程–精通Thre ...
- java socket 循环读取_java socket tcp(服务器循环检测)
刚才看了下以前写了的代码,tcp通信,发现太简单了,直接又摘抄了一个,运行 博客:http://blog.csdn.net/zhy_cheng/article/details/7819659 优点是服 ...
最新文章
- 史上最简单的SpringCloud教程 | 第八篇: 消息总线(Spring Cloud Bus)(Finchley版本)
- Windows PatchGuard学习
- VTK：图片之ImageConvolve
- 数据存储介质销毁：护航数据安全的最后一公里
- Windows Terminal 完全配置教程（主题以及启动设置）
- android 75 新闻列表页面
- IOT---(6)Android Things 开发环境搭建
- 蓝桥杯 ADV-154 算法提高 质数的后代
- ubuntu系统使用光盘/ISO镜像作为apt-get更新源
- 3. COM编程——COM编程入门实践
- 和10位CIO，聊了聊他们今年的OKR
- 【时间序列】时间序列预测基本方法：移动平均（SMA，EMA，WMA）
- 论文笔记-------Topological sound
- php布尔运算,布尔逻辑运算符有哪些？
- 云计算OpenStack环境搭建
- 惠普暗影精灵4pro安装ubuntu16.04
- 解决C# WPF的xaml突然报错XDG000 标签全不识别
- Ps制作文字组成文字云人物海报
- 微信提示已连接到服务器失败,微信提示无法连接到服务器如何解决
- 【Druid】Druid连接池（二）——配置监控界面