ssh ,jdbc,事务代理类

@FunctionalInterface
public interface Executable {
    void execute() throws Exception;

}

@FunctionalInterface
public interface ExecutableWithParam<R, T> {
    R execute(T t) throws Exception;
}

import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class JdbcProxyHandler {

    private String url;
    private String username;
    private String password;

    public JdbcProxyHandler(String url, String username, String password) {
        this.url = url;
        this.username = username;
        this.password = password;
    }

    public static class JdbcBuilder {
        private String url;
        private String username;
        private String password;

        public static JdbcBuilder builder() {
            return new JdbcBuilder();
        }

        public JdbcBuilder url(String url) {
            this.url = url;
            return this;
        }

        public JdbcBuilder username(String username) {
            this.username = username;
            return this;
        }

        public JdbcBuilder password(String password) {
            this.password = password;
            return this;
        }

        public JdbcProxyHandler instance() {
            return new JdbcProxyHandler(url, username, password);
        }
    }

    public List<Map<String, Object>> query(String nativeSql) {
        Connection connect = null;
        PreparedStatement pstmt = null;
        ResultSet resultSet = null;
        List<Map<String, Object>> list = new ArrayList<>();

        List<List<String>> data = new ArrayList<>();
        try {
            Class.forName("oracle.jdbc.OracleDriver");
            connect = DriverManager.getConnection(url, username, password);
            pstmt = connect.prepareStatement(nativeSql);
            resultSet = pstmt.executeQuery();
            final ResultSetMetaData metaData = resultSet.getMetaData();
            final int columnCount = metaData.getColumnCount();

            //遍历加入
            while (resultSet.next()) {
                Map<String, Object> map = new HashMap<>();
                for (int i = 1; i <= columnCount; i++) {
                    map.put(metaData.getColumnLabel(i), resultSet.getObject(i));
                }
                list.add(map);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //第六步：关闭资源
            try {
                if (resultSet != null) resultSet.close();
                if (pstmt != null) pstmt.close();
                if (connect != null) connect.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return list;
    }
}

import ch.ethz.ssh2.Connection;
import ch.ethz.ssh2.Session;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;


@Slf4j
@Data
public class SSHProxyHandler<R> {

    ExecutableWithParam<R, Connection> executableWithParam;

    RemoteSSH remoteSSH;

    public static class RemoteSSH {
        private String hostname;
        private int port = 22;
        private String username;
        private String password;
        private String charset = Charset.defaultCharset().toString();
        private Connection conn;

        private Session session;
        private boolean isConnected = false;

        private RemoteSSH(String hostname, String username, String password) {
            this.hostname = hostname;
            this.username = username;
            this.password = password;
        }

        public boolean login() throws IOException {
            conn = new Connection(hostname);
            conn.connect();
            isConnected = conn.authenticateWithPassword(username, password);
            return isConnected;
        }

        public String exec(Connection conn, String cmds) {
            InputStream in = null;
            String result = "";
            Session session = null;
            try {
                if (conn != null) {
                    session = conn.openSession();
                    session.execCommand(cmds);
                    in = session.getStdout();
                    result = this.processStdout(in, this.charset);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (session != null) session.close();
                session = null;
            }
            return result;
        }

        public String processStdout(InputStream in, String charset) {
            byte[] buf = new byte[1024];
            StringBuffer sb = new StringBuffer();
            try {
                while (in.read(buf) != -1) {
                    sb.append(new String(buf, charset));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return sb.toString();
        }


        public static class SSHBuilder {
            private String hostname;
            //ftp登录账号
            private String username;
            //ftp登录密码
            private String password;

            public static SSHBuilder builder() {
                return new SSHBuilder();
            }

            public SSHBuilder hostname(String hostname) {
                this.hostname = hostname;
                return this;
            }

            public SSHBuilder username(String username) {
                this.username = username;
                return this;
            }

            public SSHBuilder password(String password) {
                this.password = password;
                return this;
            }

            public RemoteSSH instance() {
                return new RemoteSSH(hostname, username, password);
            }
        }

    }


    private SSHProxyHandler() {
    }

    public static SSHProxyHandler getInstance(RemoteSSH remoteSSH, ExecutableWithParam executableWithParam) {
        SSHProxyHandler handler = new SSHProxyHandler();
        handler.setRemoteSSH(remoteSSH);
        handler.setExecutableWithParam(executableWithParam);
        return handler;
    }

    public R execute() {
        Connection connection = null;
        try {
            if (remoteSSH.login()) {
                connection = remoteSSH.conn;
                return executableWithParam.execute(remoteSSH.conn);
            }
            return null;
        } catch (Exception e) {
            log.error("FTPProxyHandler execute occur exception", e);
            return null;
        } finally {
            if (connection != null) connection.close();
            connection = null;
        }
    }


}

import lombok.extern.slf4j.Slf4j;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;


@Slf4j
public class TransactionProxyHandler {
    Executable executable;

    PlatformTransactionManager transactionManager;

    TransactionDefinition transactionDefinition;

    private TransactionProxyHandler(PlatformTransactionManager transactionManager,
                                    TransactionDefinition transactionDefinition,
                                    Executable executable) {
        this.transactionManager = transactionManager;
        this.transactionDefinition = transactionDefinition;
        this.executable = executable;
    }

    public static class Builder {
        Executable executable;
        PlatformTransactionManager transactionManager;

        TransactionDefinition transactionDefinition;

        public Builder transactionManager(PlatformTransactionManager transactionManager) {
            this.transactionManager = transactionManager;
            return this;
        }

        public Builder transactionDefinition(TransactionDefinition transactionDefinition) {
            this.transactionDefinition = transactionDefinition;
            return this;
        }

        public Builder executable(Executable executable) {
            this.executable = executable;
            return this;
        }

        public TransactionProxyHandler build() {
            return new TransactionProxyHandler(this.transactionManager, this.transactionDefinition, executable);
        }
    }


    public void execute() {
        TransactionStatus status = null;
        try {
            status = transactionManager.getTransaction(transactionDefinition);
            executable.execute();
            transactionManager.commit(status);
            log.info("TransactionProxyHandler handle commit transaction");
        } catch (Exception e) {
            log.error("TransactionProxyHandler handle method occur exception", e);
            if (status != null)
                transactionManager.rollback(status);
            log.warn("TransactionProxyHandler handle rollback transaction");
        }
    }
}