Hana数据库，Java连接池_长睡将军的博客-程序员宅基地_hana数据库

SAP Hana是个内存数据库

驱动

        <dependency>
            <groupId>com.sap.cloud.db.jdbc</groupId>
            <artifactId>ngdbc</artifactId>
            <version>2.4.64</version>
        </dependency>

package com.df.rpc.jdbc;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.LinkedList;
import java.util.logging.Logger;
import javax.annotation.PostConstruct;
import javax.sql.DataSource;

/**
 * 原生的jdbc连接池
 */

@SuppressWarnings("all")
@Slf4j
@Component
public class HanaJDBCPool implements DataSource {

    private static LinkedList<Connection> listConnections = new LinkedList<Connection>();

    @Value("${hana.db.driver}")
    String driver;
    @Value("${hana.db.url}")
    String url;
    @Value("${hana.db.username}")
    String username;
    @Value("${hana.db.password}")
    String password;

    @Value("${hana.db.initsize}")
    Integer jdbcPoolInitSize;

    @Value("${hana.db.poolmax}")
    Integer jdbcPoolMax;//必须大于init 的两倍

    @PostConstruct
    public void initHanaConnection(){
        try {
            Class.forName(driver);
            for(int i = 0;i< jdbcPoolInitSize;i++){
                Connection conn = DriverManager.getConnection(url, username, password);
                listConnections.add(conn);
            }

        } catch (Exception e) {
            throw new ExceptionInInitializerError(e);
        }
    }


    @Async
    private void createConnection(){
        try {
            Class.forName(driver);
            for(int i = 0;i< jdbcPoolInitSize;i++){
                Connection conn = DriverManager.getConnection(url, username, password);
                listConnections.add(conn);
            }

        } catch (Exception e) {
            throw new ExceptionInInitializerError(e);
        }
    }





    @Override
    public Connection getConnection() throws SQLException {
        if (listConnections.size() <= jdbcPoolMax/2){
            createConnection();
        }

        if (listConnections.size() > 0) {
            Connection conn1 = listConnections.removeFirst();
            log.debug("linkedlist1数据库连接池大小是" + listConnections.size());
            return (Connection) Proxy.newProxyInstance(conn1.getClass().getClassLoader(),
                    new Class[]{Connection.class}, new InvocationHandler() {
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                            if (!method.getName().equalsIgnoreCase("close")) {
                                return method.invoke(conn1, args);
                            } else {
                                listConnections.add(conn1);
                                log.debug(conn1 + "对象被释放，重新放回linkedlist集合中！");
                                log.debug("此时Linkedlist集合中有" + listConnections.size() + "个数据库连接对象！");
                                return null;
                            }
                        }
                    });
        } else {
            log.error(url +" 连接数据库失败！");
        }
        return null;
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return null;
    }

    @Override
    public PrintWriter getLogWriter() throws SQLException {
        return null;
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {

    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {

    }

    @Override
    public int getLoginTimeout() throws SQLException {
        return 0;
    }

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }



}

package com.df.rpc.jdbc;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;


@SuppressWarnings("all")
@Slf4j
@Component
public class HanaJDBCRpc {

    @Autowired
    private HanaJDBCPool pool;


    /**
     *  * 获取资源
     */
    public Connection getConnection() throws SQLException {
        return pool.getConnection();
    }
    /**
     *  * 关闭资源
     *  * @param resultSet 查询返回的结果集，没有为空
     *  * @param statement
     *  * @param connection
     */
    public void close(ResultSet resultSet, Statement statement, Connection connection) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
            resultSet = null;
        }
        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }


}

查询结果包装

package com.df.rpc.utils;


import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 数据库查询结果POJO转换
 *
 * @author chenyl
 */
public class HanaDbUtil {
    private static final char SEPARATOR = '_';

    public static <T> T toBean(Class<T> clazz, ResultSet rs) throws Exception {
        if (!rs.next()) {
            return null;
        }
        T t = clazz.newInstance();
        ResultSetMetaData rsmd = rs.getMetaData();
        int len = rsmd.getColumnCount();
        Map<String, Method> mm = getSetMethod(clazz);
        for (int i = 1; i <= len; i++) {
            String label = rsmd.getColumnLabel(i);
            Method m = mm.get(lineToCamel(label, true));
            if (m != null) {
                m.invoke(t, rs.getObject(label));
            }
        }
        return t;
    }

    public static Map<String, Object> toMap(ResultSet rs) throws Exception {
        Map<String, Object> map = new HashMap<String, Object>();
        if (!rs.next()) {
            return null;
        }
        ResultSetMetaData rsmd = rs.getMetaData();
        int len = rsmd.getColumnCount();
        for (int i = 1; i <= len; i++) {
            String label = rsmd.getColumnLabel(i);
            map.put(lineToCamel(label, false), rs.getObject(label));
        }
        return map;
    }

    public static Map<String, Object> toStrMap(ResultSet rs) throws Exception {
        Map<String, Object> map = new HashMap<String, Object>();
        if (!rs.next()) {
            return null;
        }
        ResultSetMetaData rsmd = rs.getMetaData();
        int len = rsmd.getColumnCount();
        for (int i = 1; i <= len; i++) {
            String label = rsmd.getColumnLabel(i);
            Object obj = rs.getObject(label);
            if (obj instanceof java.sql.Timestamp) {
                java.sql.Timestamp ts = (java.sql.Timestamp) obj;
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                map.put(lineToCamel(label, false), format.format(new Date(ts.getTime())));
            } else if (obj instanceof java.util.Date) {
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                map.put(lineToCamel(label, false), format.format((Date) obj));
            } else {
                map.put(lineToCamel(label, false), rs.getString(label));
            }
        }
        return map;
    }

    public static <T> List<T> toList(Class<T> clazz, ResultSet rs) throws Exception {
        List<T> list = new ArrayList<T>();
        while (true) {
            T t = toBean(clazz, rs);
            if (t == null) {
                break;
            }
            list.add(t);
        }
        return list;
    }

    public static List toList(ResultSet rs) throws Exception {
        List list = new ArrayList();
        while (true) {
            Map m = toMap(rs);
            if (m == null) {
                break;
            }
            list.add(m);
        }
        return list;
    }

    public static List toStrList(ResultSet rs) throws Exception {
        List list = new ArrayList();
        while (true) {
            Map m = toStrMap(rs);
            if (m == null) {
                break;
            }
            list.add(m);
        }
        return list;
    }

    private static Map<String, Method> getSetMethod(Class<?> clazz) {
        Map<String, Method> map = new HashMap<String, Method>();
        Method[] array = clazz.getMethods();
        int len = array.length;
        for (int i = 0; i < len; i++) {
            Method m = array[i];
            if (m.getName().startsWith("set") && m.getParameterTypes().length == 1) {
                map.put(m.getName().substring(3), m);
            }
        }
        return map;
    }

    public static String lineToCamel(String str, boolean firstUpperCase) {
        if (str == null || str.length() == 0) {
            return str;
        }
        str = str.toLowerCase();
        int len = str.length();
        StringBuffer sb = new StringBuffer();
        boolean upperCase = firstUpperCase;
        for (int i = 0; i < len; i++) {
            char c = str.charAt(i);
            if (c == SEPARATOR) {
                upperCase = true;
                continue;
            }
            if (upperCase) {
                sb.append(Character.toUpperCase(str.charAt(i)));
                upperCase = false;
            } else {
                sb.append(str.charAt(i));
            }
        }
        return sb.toString();
    }

    public static String camelToLine(String str) throws Exception {
        if (str == null || str.length() == 0) {
            return str;
        }
        StringBuilder sb = new StringBuilder();
        boolean nextIsUpperCase = false;
        int len = str.length();
        for (int i = 0; i < len; i++) {
            char c = str.charAt(i);
            if (i < len - 1) {
                nextIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
            } else {
                nextIsUpperCase = false;
            }
            if (Character.isLowerCase(c) && nextIsUpperCase) {
                if (i < len - 1) {
                    sb.append(c).append(SEPARATOR).append(Character.toLowerCase(str.charAt(i + 1)));
                    i++;
                } else {
                    sb.append(c).append(SEPARATOR);
                }

            } else if (Character.isUpperCase(c) && !nextIsUpperCase && i > 0) {
                sb.append(SEPARATOR).append(Character.toLowerCase(str.charAt(i)));
            } else {
                sb.append(Character.toLowerCase(c));
            }

        }
        return sb.toString();
    }


    public static void close(ResultSet rs) throws SQLException {
        if (rs != null) {
            rs.close();
        }
    }

    public static void close(Connection conn) throws SQLException {
        if (conn != null) {
            conn.close();
        }
    }
}

配置文件

hana.db.name=poc-hana
hana.db.driver = com.sap.db.jdbc.Driver
#jdbc:sap://192.168.0.102:39015??DatabaseName=HXE&reconnect=true
hana.db.url=jdbc:sap://192.168.1.5:39015?reconnect=true
hana.db.username=SYSTEM
[email protected]
hana.db.initsize=5
#必须大于init 的两倍
hana.db.poolmax=12

本文链接：https://blog.csdn.net/qq_33656559/article/details/119918586

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

jQuery中的函数封装_Ay192018的博客-程序员宅基地_jquery 封装函数

1.函数封装的概念：函数是由事件驱动的或者当它被调用时执行的可重复使用的代码块。用函数把重复的代码块包裹起来就是函数封装。2.封装的作用：其实就是为了减少代码的冗余，增加代码的可读性与易维护性，将实现同一功能的代码封装起来，在需要实现这一功能时调用即可。举例1 删除dom对象的空白节点：function removeNode(nodee) {for (var i = 0; i < nodee.length; i ++) {if (nodee[i].nodeType === 3 &

Springmvc+Myabtis+Ajax实现异步分页emp+dept（全部查询及模糊查询）_weixin_30649641的博客-程序员宅基地

1.在项目中创建如下目录2.创建实体类Deptpackage com.entity;import java.io.Serializable;/** * 部门表 * @author Administrator * */public class Dept implements Serializable{ /** * ...

电气自动化与计算机应用哪个好,应用电子和电气这两个专业，选哪那个好？_小白大王的博客-程序员宅基地

应用电子和电气这两个专业，选哪那个好？以下文字资料是由(历史新知网www.lishixinzhi.com)小编为大家搜集整理后发布的内容，让我们赶快一起来看一下吧！应用电子和电气这两个专业，选哪那个好？从我理解，电子是属于弱电，电气为强电应用电子应该是电子产品开发，包括产品里面的编程，电气应该是工厂，民用，供电等方面，电气的就业范围大一点，工资一般，除非在做设计和在供电部门电子就业方向是维修和产品...

docker复现网络yolov3详解_木木阳的博客-程序员宅基地_docker复现

yolov3-docker复现一、docker环境搭建二、yolov3复现这张图片就是本博客的主要内容一、docker环境的复现1.了解docker 如果读者为docker新手，或者跟我一样一知半解的话，建议百度搜索：docker-从入门到实践，这个文档对初学者帮助很大。2.由于每个人机型不一样，所以关于docker安装我这里就不再叙述了，上述给的文档说的非常详细，如果还是不会的话，可以私信我，就是我也不一定能解决的说。3.这里从docker pull开始进行详细介绍：1）docker p

SpringBoot2 线程池的定义和使用_赵小胖-0914的博客-程序员宅基地

SpringBoot2 线程池的定义和使用定义线程池@[email protected]@Configurationpublic class AsyncExecutorConfig implements AsyncConfigurer { @Bean public ThreadPoolTaskExecutor asyncServiceExecutor() { ...

c语言实现数据库系统,一个大程序＂实现一个基于命令行的简单数据库系统＂..._F杂谈的博客-程序员宅基地

一个大程序＂实现一个基于命令行的简单数据库系统＂实现一个基于命令行的简单数据库系统基本功能：1、建立数据库表2、能够对数据库中的单表进行数据导入3、能够对数据库中的单表进行插入4、能够对数据库中的单表进行查询5、能够对数据库中的单表进行更新6、能够对数据库中的单表进行删除高级功能：当数据量比较大的时候，请大家建立索引，并通过索引加快查询速度(选作)要求：1、不能使用Cstring.h，string...