当前位置：文档之家 › fastdfs-javaapi连接池

fastdfs-javaapi连接池

  • 格式：docx
  • 大小：31.21 KB
  • 文档页数：10

Fastdfs-javaapi-连接池1 简绍大家都知道fastdfs分为tracker server和storage server, tracker server是跟踪服务器，主要做调度工作，在访问上起负载均衡的作用。

storage server是存储服务器，主要负责文件的存储。

我们使用java api在分布式文件系统的文件去上传、修改、删除等操作时，有以下几步：1）申请与tracker server的连接TrackerClient trackerClient = new TrackerClient();TrackerServer trackerServer= trackerClient.getConnection();2）通过trackerServer得到与storage server的连接的客户端StorageServer ss = tc.getStoreStorage(ts);StorageClient1 client1 = new StorageClient1(trackerServer, ss);3）上传文件client1.upload_file1(fileBuff, fileExtName, null);4）关闭连接ss.close();trackerServer.close();最终可以完成我们想要的操作，但是这两次创建的连接都是tcp/ip连接，如果每次创建完连接我们都再关闭连接。

这个过程是很耗时的。

通过api申请的连接并不支持高发发（即一个storage连接只能上传一个文件），我们必须保证同一时刻一个连接上传一个文件。

由于我们用fastdfs做文件服务器，通过web的管理平台将文件上传至分布式文件系统中，每次申请完连接再关闭连接，对我们来说会延长上传文件的时间，而且上传文件高并发下，申请的连接可能突然增至几百个，这样我们的服务器的性能损耗太大了。

2 java api 源代码分析通过查看fastdfs java api的源代码了解到。

通过trackerServer和storageServer得到的new StorageClient1(trackerServer, storageServer);client对象，在操作文件时，会自动检查trackerServer和storageServer是否为空，如果为空，程序会自动为任一server创建连接，待操作完成后，将创建的连接关闭。

如果storageServer为null,则程序自动创建trackerServer，根据trackerServer得到storageServer，并返回storageServer，在返回storageServer 之前会关闭trackerServer。

通过storageServer上传完文件之后，关闭storageServer. 如果都不空null，则api中不会关闭连接。

3 结合实际。

由于我们搭建的文件系统架构是，一个tracker和三个storage.从这个图形可以看出，我们的tracker 连接是没有必要改变的，申请一次就可以，（直接点）故我们可以为tracker 创建连接池。

连接池代码如下ConnectionPool ：import java.io.IOException;import .InetSocketAddress;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.TimeUnit;import org.csource.fastdfs.ClientGlobal;import org.csource.fastdfs.StorageClient1;import org.csource.fastdfs.StorageServer;import org.csource.fastdfs.TrackerClient;import org.csource.fastdfs.TrackerGroup;import org.csource.fastdfs.TrackerServer;public class ConnectionPool {// the limit of connection instanceprivate int size = 5;// busy connection instancesprivate ConcurrentHashMap<StorageClient1, Object> busyConnectionPool = null ;// idle connection instancesprivate ArrayBlockingQueue<StorageClient1> idleConnectionPool = null ;private final static String tgStr = "192.168.4.117";private final static int port = 22122;private Object obj = new Object();// class method // singleton tracker St1 St1 St1private ConnectionPool() {busyConnectionPool = new ConcurrentHashMap<StorageClient1, Object>();idleConnectionPool = newArrayBlockingQueue<StorageClient1>(size);init(size);};private static ConnectionPool instance = new ConnectionPool();// get the connection pool instancepublic static ConnectionPool getPoolInstance() {return instance;}// class method// init the connection poolprivate void init(int size) {initClientGlobal();TrackerServer trackerServer = null;try {TrackerClient trackerClient = new TrackerClient();//Only trackertrackerServer = trackerClient.getConnection();for (int i = 0; i < size; i++) {StorageServer storageServer = null;StorageClient1 client1 = newStorageClient1(trackerServer,storageServer);idleConnectionPool.add(client1);}} catch (IOException e) {e.printStackTrace();}finally{if(trackerServer!=null){try {trackerServer.close();} catch (IOException e) {e.printStackTrace();}}}}// 1. pop one connection from the idleConnectionPool,// 2. push the connection into busyConnectionPool;// 3. return the connection// 4. if no idle connection, do wait for wait_time seconds, and check againpublic StorageClient1 checkout(int waitTimes) throws InterruptedException {StorageClient1 client1 = idleConnectionPool.poll(waitTimes, TimeUnit.SECONDS);busyConnectionPool.put(client1, obj);return client1;}// 1. pop the connection from busyConnectionPool;// 2. push the connection into idleConnectionPool;// 3. do nessary cleanup works.public void checkin(StorageClient1 client1) {if (busyConnectionPool.remove(client1)!=null) {idleConnectionPool.add(client1);}}// so if the connection was broken due to some erros (like// : socket init failure, network broken etc), drop this connection // from the busyConnectionPool, and init one new connection.public void drop(StorageClient1 client1) {if (busyConnectionPool.remove(client1)!=null) {TrackerServer trackerServer = null;try {TrackerClient trackerClient = new TrackerClient();//TODO此处有内存泄露，因为trackerServer没有关闭连接trackerServer = trackerClient.getConnection();StorageServer storageServer = null;StorageClient1 newClient1 = newStorageClient1(trackerServer, storageServer);idleConnectionPool.add(newClient1);} catch (IOException e) {e.printStackTrace();}finally{if(trackerServer!=null){try {trackerServer.close();} catch (IOException e) {e.printStackTrace();}}}}}private void initClientGlobal() {InetSocketAddress[] trackerServers = new InetSocketAddress[1];trackerServers[0] = new InetSocketAddress(tgStr, port);ClientGlobal.setG_tracker_group(newTrackerGroup(trackerServers));// 连接超时的时限，单位为毫秒ClientGlobal.setG_connect_timeout(2000);// 网络超时的时限，单位为毫秒ClientGlobal.setG_network_timeout(30000);ClientGlobal.setG_anti_steal_token(false);// 字符集ClientGlobal.setG_charset("UTF-8");ClientGlobal.setG_secret_key(null);}}上传文件类接口：ImageServerimport java.io.File;import java.io.IOException;/*** 图片文件上传* @author zhanghua**/public interface ImageServer {/*** 上传文件* @param file 文件* @return文件存储路径* @throws IOException* @throws Exception*/public String uploadFile(File file) throws IOException, Exception ;/*** 上传文件* @param file 文件* @param name 文件名称* @return文件存储路径* @throws IOException* @throws Exception*/public String uploadFile(File file, String name) throws IOException, Exception ;/*** 上传文件* @param fileBuff 二进制数组* @param name* @return*/public String uploadFile(byte[] fileBuff,String name) throws IOException, Exception;}上传文件实现：ImageServerImplimport java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;import .InetSocketAddress;import org.csource.fastdfs.ClientGlobal;import org.csource.fastdfs.StorageClient1;import org.csource.fastdfs.TrackerGroup;import com.imageserver.pool.ConnectionPool;public class ImageServerImpl implements ImageServer {private final static String tgStr = "192.168.4.117";private final static int port = 22122;public ImageServerImpl() {init();}public String uploadFile(File file) throws IOException, Exception { return uploadFile(file, file.getName());}public String uploadFile(File file, String name) throws IOException, Exception {byte[] fileBuff = getFileBuffer(file);String fileExtName = getFileExtName(name);return send(fileBuff, fileExtName);}public String uploadFile(byte[] fileBuff, String name) throws IOException,Exception {String fileExtName = getFileExtName(name);return send(fileBuff, fileExtName);}private String send(byte[] fileBuff, String fileExtName)throws IOException, Exception {String upPath = null;StorageClient1 client1 = null;try {client1 = ConnectionPool.getPoolInstance().checkout(10);upPath = client1.upload_file1(fileBuff, fileExtName, null);ConnectionPool.getPoolInstance().checkin(client1);} catch (InterruptedException e) {//确实没有空闲连接,并不需要删除与fastdfs连接throw e;} catch (Exception e) {//发生io异常等其它异常，默认删除这次连接重新申请ConnectionPool.getPoolInstance().drop(client1);e.printStackTrace();throw e;}return upPath;}private String getFileExtName(String name) {String extName = null;if (name != null && name.contains(".")) {extName = name.substring(stIndexOf(".") + 1);}return extName;}private byte[] getFileBuffer(File file) {byte[] fileByte = null;try {FileInputStream fis = new FileInputStream(file);fileByte = new byte[fis.available()];fis.read(fileByte);} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}return fileByte;}private void init() {InetSocketAddress[] trackerServers = new InetSocketAddress[1];trackerServers[0] = new InetSocketAddress(tgStr, port);ClientGlobal.setG_tracker_group(newTrackerGroup(trackerServers));// 连接超时的时限，单位为毫秒ClientGlobal.setG_connect_timeout(2000);// 网络超时的时限，单位为毫秒ClientGlobal.setG_network_timeout(30000);ClientGlobal.setG_anti_steal_token(false);// 字符集ClientGlobal.setG_charset("UTF-8");ClientGlobal.setG_secret_key(null);}}上传文件测试类：ImageServerTestimport java.io.File;import java.io.IOException;import java.util.concurrent.atomic.AtomicInteger;public class ImageServerTest {ImageServer s = new ImageServerImpl();AtomicInteger count = new AtomicInteger();static long stime = 0;public static void main(String[] args) {stime = System.currentTimeMillis();new ImageServerTest().mutiUP();}public void statTime() {if (count.getAndIncrement() == 9) {System.out.println("用时：" + (System.currentTimeMillis() - stime));}}public void mutiUP() {for (int i = 0; i < 1; i++) {new Thread() {@Overridepublic void run() {try {for (int j = 0; j < 10; j++) {String p = s.uploadFile(newFile("F:\\pic\\1.jpg"));System.out.println(p);}statTime();} catch (IOException e) {e.printStackTrace();} catch (Exception e) {e.printStackTrace();}}}.start();}}}。

合集下载

java hikaripool 保持永久连接的方法

java hikaripool 保持永久连接的方法

java hikaripool 保持永久连接的方法JavaHikari连接池是一个高效的连接池实现，可以帮助Java应用程序管理数据库连接。

但是，由于连接池中的连接是有限的，我们需要确保它们被充分利用。

在本文中，我们将介绍一些方法，帮助您保持Hikari连接池中的连接始终处于活动状态。

1. 设置连接超时时间连接池中的连接如果长时间处于空闲状态，就会被连接池回收。

为了避免连接回收，可以设置连接超时时间。

在Hikari连接池中，我们可以使用以下属性来设置连接超时时间：```dataSource.setMaximumPoolSize(10);dataSource.setMinimumIdle(1);dataSource.setIdleTimeout(60_000);```这将确保连接在空闲一段时间后被回收之前，始终保持活动状态。

2. 使用心跳检测有时候，连接池中的连接可能会因为网络问题或其他原因被意外断开。

在这种情况下，我们可以使用心跳检测来检测连接是否仍然有效。

在Hikari连接池中，我们可以使用以下属性来启用心跳检测：```dataSource.setConnectionTestQuery('SELECT 1');dataSource.setConnectionTimeout(30_000);dataSource.setValidationTimeout(5_000);```这将确保在连接池中的连接断开时，能够及时检测到并重新建立连接。

3. 使用连接池监控连接池监控可以帮助我们了解连接池中的连接使用情况，并根据需要进行优化。

在Hikari连接池中，我们可以使用以下属性来启用连接池监控：```dataSource.setMetricRegistry(metricRegistry);dataSource.setHealthCheckRegistry(healthCheckRegistry); ```这将为我们提供有关连接池中连接的详细信息，例如活动连接数、空闲连接数和连接等待时间。

MySQL中的连接池使用与配置方法

MySQL中的连接池使用与配置方法

MySQL中的连接池使用与配置方法在开发和运维过程中，数据库是一个非常重要的组成部分。

针对高并发的场景，数据库连接的创建和关闭是一个非常耗时的操作，通常会导致性能瓶颈。

为了解决这个问题，我们可以使用连接池来缓解数据库连接的创建和关闭带来的性能问题。

连接池是一种数据库连接的管理机制，它可以预先创建一定数量的数据库连接，并将这些连接保存在一个池中。

当应用程序需要访问数据库时，可以直接从连接池中获取一个空闲的连接，使用完毕后再将连接返回给连接池。

这样可以减少每次访问数据库时创建和关闭连接的时间，提高了应用程序的响应速度和并发处理能力。

在MySQL中，连接池是通过使用连接池软件实现的。

常见的连接池软件有C3P0、Druid等。

接下来，我们将重点介绍如何使用Druid连接池，并对其进行配置。

Druid是阿里巴巴开源的一个高性能、可扩展的数据库连接池。

它具有监控、可扩展、可配置等特点，并且在高并发环境下表现出色。

下面我们将分步骤介绍如何在MySQL中使用Druid连接池。

第一步：添加Druid依赖在项目的pom.xml文件中添加Druid的依赖。

可以通过以下方式引入其最新版本：```xml<dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId><version>1.2.5</version></dependency>```第二步：配置数据源在项目的配置文件中，添加Druid的数据源配置。

可以根据实际情况进行配置，以下是一个示例配置：```yamlspring:datasource:url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTCusername: rootpassword: 123456# 配置数据源类型和驱动type: com.alibaba.druid.pool.DruidDataSourcedriver-class-name: com.mysql.cj.jdbc.Driver# 配置Druid连接池的相关参数druid:# 初始化连接数initial-size: 5# 最小空闲连接数min-idle: 5# 最大活跃连接数max-active: 20# 获取连接时的最大等待时间，单位毫秒max-wait: 60000# 配置测试连接的SQL语句validation-query: SELECT 1# 配置获取连接时是否验证连接的有效性test-on-borrow: true```在上述配置中，需要注意以下几点：- `url`、`username`和`password`配置的是数据库的连接信息。

关于DBCP数据库连接池配置整理

关于DBCP数据库连接池配置整理

1.简介DBCP(DataBase Connection Pool),数据库连接池。

是 apache 上的一个 java 连接池项目，也是tomcat 使用的连接池组件。

单独使用dbcp需要3个包：common-dbcp.jar,common-pool.jar,common-collections.jar由于建立数据库连接是一个非常耗时耗资源的行为，所以通过连接池预先同数据库建立一些连接，放在内存中，应用程序需要建立数据库连接时直接到连接池中申请一个就行，用完后再放回去。

dbcp提供了数据库连接池可以在spring，iBatis，hibernate中调用dbcp完成数据库连接，框架一般都提供了dbcp连接的方法；tomcat中也提供了dbcp的jndi设置方法，也可以不在框架中使用dbcp，单独使用dbcp 需要3个包：common-dbcp.jar,common-pool.jar,common-collections.jar2.参数说明翻译自这里可以开启PreparedStatements池. 当开启时, 将为每个连接创建一个statement 池,并且被下面方法创建的PreparedStatements将被缓存起来:●public PreparedStatement prepareStatement(String sql)●public PreparedStatement prepareStatement(String sql, int resultSetType, intresultSetConcurrency)如果容许则可以使用下面的方式来获取底层连接:Connection conn = ds.getConnection();Connection dconn = ((DelegatingConnection) conn).getInnermostDelegate();...conn.close()默认false不开启, 这是一个有潜在危险的功能, 不适当的编码会造成伤害.(关闭底层连接或者在守护连接已经关闭的情况下继续使用它).请谨慎使用,并且仅当需要直接访问驱动的特定功能时使用.注意: 不要关闭底层连接, 只能关闭前面的那个如果开启"removeAbandoned",那么连接在被认为泄露时可能被池回收. 这个机制在(getNumIdle() < 2) and (getNumActive() > getMaxActive() - 3)时被触发。

java调用api接口实例

java调用api接口实例

java调用api接口实例# 2. 使用JAVA调用API的实例## 2.1 简介API（Application Programming Interface），即应用程序接口，是一种特定的接口，它允许第三方软件（如Java）与另一个软件系统进行交互，以便更好地提供服务。

Java将API作为类库，可帮助开发人员更容易的进行开发。

## 2.2 实现### 2.2.1 准备工作首先，我们需要准备基本的环境：- Java开发环境（如Eclipse）- 用于调用API的第三方jar包### 2.2.2 使用API使用API的步骤一般如下：- 加载API：将jar包添加到Java项目中，使用Java类可以访问API。

- 初始化：初始化API的配置文件，设置必要的参数，以便API 可以正常工作。

- 调用API：通过调用API中的方法，获取要求的功能，完成任务。

### 2.2.3 编写实例下面是一个使用API的实例，以调用Amazon S3（Simple StorageService）的API进行数据处理。

```javapackage com.example.s3;import com.amazonaws.auth.AWSStaticCredentialsProvider; import com.amazonaws.auth.BasicAWSCredentials;import com.amazonaws.regions.Regions;import com.amazonaws.services.s3.AmazonS3;import com.amazonaws.services.s3.AmazonS3ClientBuilder; public class S3Example {// 访问keyprivate static final String ACCESS_KEY = 'XXXXXXXX';// 密钥private static final String SECRET_KEY = 'XXXXXXXX';public static void main(String[] args) {// 获取S3客户端AmazonS3 s3Xclient = getS3Client();// 使用客户端进行操作doSomething(s3Xclient);}// 获取S3客户端private static AmazonS3 getS3Client() {// 创建认证信息BasicAWSCredentials awsCreds = new BasicAWSCredentials(ACCESS_KEY, SECRET_KEY);// 设置区域AWSCredentialsProvider awsCredsProvider = new AWSStaticCredentialsProvider(awsCreds);// 创建S3客户端AmazonS3 s3Client = AmazonS3ClientBuilder.standard().withCredentials(awsCredsProvider).withRegion(_EAST_1).build();return s3Client;}// 使用S3客户端private static void doSomething(AmazonS3 s3Client) {// TODO// 使用API调用S3相关的操作，如上传文件，下载文件，列出bucket等}}```该实例使用了Amazon S3的API，读取了访问key和密钥的信息，调用了接口获取S3客户端，并通过调用`doSomething()`方法实现了对S3的操作，如上传文件，下载文件，列出bucket等。