java存储过程-MYSQL-LINUX

最新推荐文章于 2024-09-05 10:59:16 发布
最新推荐文章于 2024-09-05 10:59:16 发布
阅读量150 收藏
点赞数
分类专栏： mysql 文章标签： java存储过程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012866232/article/details/77342292
版权

存储过程
在java中的调用：
DELIMITER //
create procedure date_pro_troubleanalysisone_count(pTROUBLE_DATE_BEGIN datetime, pTROUBLE_DATE_END datetime,pSYSTEM_ID VARCHAR(255),pSOURCE VARCHAR(255))

BEGIN
declare tmp_num int default -1;
declare total_num int default -1;

select ifnull(count_number,-1) into tmp_num from bussi_analysis_rule_troubleanalysisone_count where SYSTEM_ID = pSYSTEM_ID AND SOURCE =pSOURCE AND TROUBLE_DATE = pTROUBLE_DATE_BEGIN AND count_number is not null;
select tmp_num;

IF(tmp_num = -1 ) THEN
insert into bussi_analysis_rule_troubleanalysisone_count(count_number,SOURCE,SYSTEM_ID,TROUBLE_DATE) select count(*),pSOURCE AS SOURCE,pSYSTEM_ID AS SYSTEM_ID,pTROUBLE_DATE_BEGIN AS TROUBLE_DATE
from bussi_analysis_rule_troubleanalysisone where SYSTEM_ID = pSYSTEM_ID AND SOURCE =pSOURCE
AND TROUBLE_DATE between pTROUBLE_DATE_BEGIN AND pTROUBLE_DATE_END;
else
update bussi_analysis_rule_troubleanalysisone_count set count_number = ( select count(*)
from bussi_analysis_rule_troubleanalysisone where SYSTEM_ID = pSYSTEM_ID AND SOURCE =pSOURCE
AND TROUBLE_DATE between pTROUBLE_DATE_BEGIN AND pTROUBLE_DATE_END) where SYSTEM_ID = pSYSTEM_ID AND SOURCE =pSOURCE and TROUBLE_DATE=pTROUBLE_DATE_BEGIN;
end IF;
END

drop PROCEDURE date_pro_troubleanalysisone_count_byday
call date_pro_troubleanalysisone_count(‘2017-07-16’,’2017-07-17’,’4’,’数据质量分析模块’);

drop PROCEDURE date_pro_troubleanalysisone_count_byday

DELIMITER //
create procedure date_pro_troubleanalysisone_count_byday(pTROUBLE_DATE_BEGIN datetime, pTROUBLE_DATE_END datetime)

BEGIN
declare tmp_num int default -1;
declare total_num int default -1;

select ifnull(count_number,-1) into tmp_num from bussi_analysis_rule_troubleanalysisone_count_byday where TROUBLE_DATE = pTROUBLE_DATE_BEGIN and count_number is not null;
select tmp_num;
IF(tmp_num = -1 ) THEN

insert into bussi_analysis_rule_troubleanalysisone_count_byday(TROUBLE_DATE,SYSTEM_ID,SOURCE,count_number) select date_format(TROUBLE_DATE,’%Y-%m-%d’) as TROUBLE_DATE, SYSTEM_ID,SOURCE, count(*) as NUMBER from bussi_analysis_rule_troubleanalysisone
where TROUBLE_DATE between pTROUBLE_DATE_BEGIN AND pTROUBLE_DATE_END group by date_format(TROUBLE_DATE,’%Y-%m-%d’),SYSTEM_ID;
else
update bussi_analysis_rule_troubleanalysisone_count_byday set count_number = ( select count(*)
from bussi_analysis_rule_troubleanalysisone where TROUBLE_DATE between pTROUBLE_DATE_BEGIN AND pTROUBLE_DATE_END) where TROUBLE_DATE=pTROUBLE_DATE_BEGIN;
end IF;
END
call date_pro_troubleanalysisone_count_byday(‘2017-7-19’,’2017-7-20’)
select date_format(TROUBLE_DATE,’%Y-%m-%d’) as TROUBLE_DATE, SYSTEM_ID, count(*) as NUMBER from bussi_analysis_rule_troubleanalysisone_count_byday
where TROUBLE_DATE between ‘2017-7-12’ AND ‘2017-7-13’ group by date_format(TROUBLE_DATE,’%Y-%m-%d’),SYSTEM_ID limit 0,100;

====================================================================================
nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 0 -1 4 数据质量分析模块 > troubleanalysisone_count_4–1.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 1 0 4 数据质量分析模块 > troubleanalysisone_count_4-0.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 2 1 4 数据质量分析模块 > troubleanalysisone_count_4-1.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 3 2 4 数据质量分析模块 > troubleanalysisone_count_4-2.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 4 3 4 数据质量分析模块 > troubleanalysisone_count_4-3.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 5 4 4 数据质量分析模块 > troubleanalysisone_count_4-4.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 6 5 4 数据质量分析模块 > troubleanalysisone_count_4-5.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 7 6 4 数据质量分析模块 > troubleanalysisone_count_4-6.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 0 -1 3 故障诊断模块 > troubleanalysisone_count_3–1.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 1 0 3 故障诊断模块 > troubleanalysisone_count_3-0.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 2 1 3 故障诊断模块 > troubleanalysisone_count_3-1.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 3 2 3 故障诊断模块 > troubleanalysisone_count_3-2.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 4 3 3 故障诊断模块 > troubleanalysisone_count_3-3.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 5 4 3 故障诊断模块 > troubleanalysisone_count_3-4.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 6 5 3 故障诊断模块 > troubleanalysisone_count_3-5.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 7 6 3 故障诊断模块 > troubleanalysisone_count_3-6.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 0 -1 2 故障诊断模块 > troubleanalysisone_count_2–1.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 1 0 2 故障诊断模块 > troubleanalysisone_count_2-0.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 2 1 2 故障诊断模块 > troubleanalysisone_count_2-1.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 3 2 2 故障诊断模块 > troubleanalysisone_count_2-2.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 4 3 2 故障诊断模块 > troubleanalysisone_count_2-3.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 5 4 2 故障诊断模块 > troubleanalysisone_count_2-4.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 6 5 2 故障诊断模块 > troubleanalysisone_count_2-5.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 7 6 2 故障诊断模块 > troubleanalysisone_count_2-6.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 0 -1 1 故障诊断模块 > troubleanalysisone_count_1–1.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 1 0 1 故障诊断模块 > troubleanalysisone_count_1-0.log
`package com.xnrh.flowwork.procedure.executor;

import java.io.ByteArrayInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import com.xnrh.flowwork.procedure.jdbc.AlarmShow;
import com.xnrh.flowwork.procedure.jdbc.DateUtil;

public class ProcedureExecutor {
private static String driverName;
private static String url;
private static String user;
private static String password;

    /*
      * 静态代码块，类初始化时加载数据库驱动
     */
    static {
        try {
            InputStream inCfg = ProcedureExecutor.class.getClassLoader().getResourceAsStream("configure.properties"); 
            Properties propertiesCfg = new Properties();
            propertiesCfg.load(inCfg);
            String filePath = propertiesCfg.getProperty("jdbc.cfg.path");

            // 加载 /home/jdbc.properties配置文件
            InputStream in = new FileInputStream(filePath);
            Properties properties = new Properties();
            properties.load(in);

             // 获取驱动名称、url、用户名以及密码
            driverName = properties.getProperty("jdbc_driver");
             url = properties.getProperty("jdbc_url");
             user = properties.getProperty("jdbc_username");
             password = properties.getProperty("jdbc_password");

             // 加载驱动
             Class.forName(driverName);

         } catch (IOException e) {
             e.printStackTrace();
         } catch (ClassNotFoundException e) {
             e.printStackTrace();
         }
     }

     /*
      * 获取连接
      */
     public static Connection getConnection() throws SQLException {

         return DriverManager.getConnection(url, user, password);

     }

     /*
      * 释放资源
      */
     public static void releaseResources(ResultSet resultSet,
             Statement statement, Connection connection) {

         try {
             if (resultSet != null)
                 resultSet.close();
         } catch (SQLException e) {
             e.printStackTrace();
         } finally {
             resultSet = null;
             try {
                 if (statement != null)
                     statement.close();
             } catch (SQLException e) {
                 e.printStackTrace();
             } finally {
                 statement = null;
                 try {
                     if (connection != null)
                         connection.close();
                 } catch (SQLException e) {
                     e.printStackTrace();
                 } finally {
                     connection = null;
                 }
             }
         }

     }

//preStartDays = 7 向前7天
//preEndDays=-1  向后一天
public List<AlarmShow> execute(String procedure,int preStartDays,int preEndDays,List<Object> params) throws SQLException 
{
    String TROUBLE_DATE_BEGIN = null;
    String TROUBLE_DATE_END = null;
    List <AlarmShow> list = new ArrayList<AlarmShow>(); //实例化List对象
    if(procedure==null||procedure.length()==0)
        return list;
    System.out.println("0|execute|start to work|"+procedure);
    Connection conn = getConnection();  //创建数据库连接
    try
    {
        String procedureDesc = procedure;
        procedureDesc += "(";
        DateUtil du = new DateUtil();
        boolean useDate = procedure.startsWith("date");
        if(useDate){
            TROUBLE_DATE_BEGIN = du.getPastDate(preStartDays);
            TROUBLE_DATE_END = du.getPastDate(preEndDays);
            procedureDesc += "?,?";
        }

        if(params!=null && params.size()>0){
            for(int i=0;i<params.size();i++){
                if(useDate||i!=0)
                    procedureDesc += ",";
                procedureDesc += "?";
            }
        }
        procedureDesc += ")";
        System.out.println("1|execute|start to prepareCall|"+procedureDesc);
        //调用存储过程
        CallableStatement cs = conn.prepareCall("{call "+procedureDesc+"}");
        System.out.println("2|execute|after prepareCall|"+procedureDesc);
        int startOffset = 1;
        if(useDate){
            cs.setString(1, TROUBLE_DATE_BEGIN);
            cs.setString(2, TROUBLE_DATE_END);
            startOffset=3;
        }
        for(int ii=0;ii<params.size();ii++){
            Object o = params.get(ii);
            if(o instanceof String){
                cs.setString(ii+startOffset, (String)o);
            } else if(o instanceof byte[]){
                InputStream ais = new ByteArrayInputStream((byte[])o);
                cs.setBinaryStream(ii+startOffset, ais);
            } else if(o instanceof Integer){
                int id = ((Integer)o).intValue();
                cs.setInt(ii+startOffset, id);
            } else if(o instanceof Long){
                long l = ((Long)o).longValue();
                cs.setLong(ii+startOffset,l);
            } else if(o instanceof Double){
                double d = ((Double)o).doubleValue();
                cs.setDouble(ii+startOffset,d);
            }
        }
        System.out.println("3|execute|start to executeQuery|"+procedureDesc);
        ResultSet rs = cs.executeQuery(); //执行查询操作，并获取结果集
        System.out.println("4|execute|after executeQuery|"+procedureDesc);
        if(rs!=null){
            /*while(rs.next())
            {
                AlarmShow ot = new AlarmShow(); //实例化AlarmShow对象
                ot.setSYSTEM_ID(rs.getString("SYSTEM_ID")); 
                ot.setNUMBER(rs.getInt("NUMBER")); 
                ot.setSOURCE(rs.getString("SOURCE"));
                ot.setTROUBLE_DATE(rs.getString("TROUBLE_DATE"));
                list.add(ot);
            }*/
        }
    }catch(Exception e)
    {
        e.printStackTrace();
    }        
    return list;     //返回list
}

//
public boolean mainExecute(String[] args) throws SQLException
{
    if(args.length>1)
    {
        ProcedureExecutor PM = new ProcedureExecutor();
        String procedure = args[0];
        int preStartDays = 0;
        int preEndDays = 0;
        int offset = 1;
        if(procedure.startsWith("date") && args.length>2){
            preStartDays = Integer.parseInt(args[1]);
            preEndDays = Integer.parseInt(args[2]);
            offset=3;
        }else if(procedure.startsWith("date")){
            System.out.println("date procedure , params is less than 3");
            return false;
        }
        List<Object> params = new ArrayList<Object>();
        for(int i=offset;i<args.length;i++)
        {
            params.add(args[i]);
        }
        //
        System.out.println("0|main|start to work|"+procedure);
        //
        PM.execute(procedure,preStartDays,preEndDays,params);
        System.out.println("1|main|after work|"+procedure);
        return true;
        /*for (AlarmShow ot : PM.findAll(procedure,preStartDays,preEndDays,params))
        {
            System.out.print(ot.getSYSTEM_ID() + "--" + ot.getNUMBER() + "--");
            System.out.print(ot.getSOURCE() + "--" + ot.getTROUBLE_DATE());
            System.out.println();
        }*/
    }else{
        System.out.println("params is less than 1");
        System.out.println("样例: java -jar proceduremain.jar 1 30 date_pro_troubleanalysisone_count 7 -1 4 数据质量分析模块");
        return false;
    }
}

}
`&

package com.xnrh.flowwork.procedure.main;

import java.sql.SQLException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import com.xnrh.flowwork.procedure.executor.ProcedureExecutor;
import com.xnrh.flowwork.procedure.jdbc.Object_testjdbczzr;

public class RunTaskMain implements Runnable{
    private String[] argv;
    private int deleys=1;
    private int sleeps=2;
    public RunTaskMain(String[] args){
        if(args!=null && args.length>1)
        {
            argv = new String[args.length-2];
            for(int i=2;i<args.length;i++)
            {
                argv[i-2] = args[i];
            }
            deleys = Integer.parseInt(args[0]);
            sleeps = Integer.parseInt(args[1]);
        } else {
            System.out.println("样例: java -jar proceduremain.jar 1 30 date_pro_troubleanalysisone_count 2 -1 4 数据质量分析模块");
        }
    }

    public int getDeleys() {
        return deleys;
    }

    public void setDeleys(int deleys) {
        this.deleys = deleys;
    }

    public int getSleeps() {
        return sleeps;
    }

    public void setSleeps(int sleeps) {
        this.sleeps = sleeps;
    }

    public static void main(String[] args) {

        RunTaskMain runnable = new RunTaskMain(args);
        ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
        //第二个参数为首次执行的延迟时间
        //第三个参数为定时执行的时间间隔
        service.scheduleAtFixedRate(runnable, runnable.getDeleys(), runnable.getSleeps() , TimeUnit.MINUTES);
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        ProcedureExecutor PM = new ProcedureExecutor();
        try {
            PM.mainExecute(argv);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 2 1 1 故障诊断模块 > troubleanalysisone_count_1-1.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 3 2 1 故障诊断模块 > troubleanalysisone_count_1-2.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 4 3 1 故障诊断模块 > troubleanalysisone_count_1-3.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 5 4 1 故障诊断模块 > troubleanalysisone_count_1-4.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 6 5 1 故障诊断模块 > troubleanalysisone_count_1-5.log &

nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 7 6 1 故障诊断模块 > troubleanalysisone_count_1-6.log &

导出页面存储过程：

DELIMITER //
create procedure date_pro_quality_load_desc_qk(pTROUBLE_DATE_BEGIN datetime, pTROUBLE_DATE_END datetime,pPROVINCE_NAME varchar(255),pSYSTEM_ID VARCHAR(255),pCARRIER_OPERATOR_NAME VARCHAR(255),pCONNECT_TYPE VARCHAR(255))

BEGIN
declare tmp_num int default -1;
declare total_num int default -1;

select ifnull(SOURCE_FILE_TOTAL_NUMBER,-1) into tmp_num from bussi_analysis_data_quality_load_desc_qk where SYSTEM_ID = pSYSTEM_ID AND PROVINCE_NAME=pPROVINCE_NAME AND CARRIER_OPERATOR_NAME = pCARRIER_OPERATOR_NAME AND
CONNECT_TYPE =pCONNECT_TYPE AND SOURCE_FILE_ACCEPT_DATE = pTROUBLE_DATE_BEGIN AND SOURCE_FILE_TOTAL_NUMBER is not null;
select tmp_num;

IF(tmp_num = -1 ) THEN
insert into bussi_analysis_data_quality_load_desc_qk(SYSTEM_ID,PROVINCE_NAME,CARRIER_OPERATOR_NAME,CONNECT_TYPE,SOURCE_FILE_ACCEPT_DATE,SOURCE_FILE_TOTAL_NUMBER) select pSYSTEM_ID AS SYSTEM_ID,pPROVINCE_NAME AS PROVINCE_NAME,pCARRIER_OPERATOR_NAME AS CARRIER_OPERATOR_NAME,
pCONNECT_TYPE AS CONNECT_TYPE , pTROUBLE_DATE_BEGIN AS SOURCE_FILE_ACCEPT_DATE ,sum(SOURCE_FILE_TOTAL_NUMBER)
from bussi_analysis_data_quality_load_desc where SYSTEM_ID = pSYSTEM_ID AND PROVINCE_NAME=pPROVINCE_NAME AND CARRIER_OPERATOR_NAME =pCARRIER_OPERATOR_NAME
AND SOURCE_FILE_ACCEPT_DATE between pTROUBLE_DATE_BEGIN AND pTROUBLE_DATE_END;
else
update bussi_analysis_data_quality_load_desc_qk set SOURCE_FILE_TOTAL_NUMBER = ( select sum(SOURCE_FILE_TOTAL_NUMBER) AS SOURCE_FILE_TOTAL_NUMBER
from bussi_analysis_data_quality_load_desc where SYSTEM_ID = pSYSTEM_ID AND PROVINCE_NAME=pPROVINCE_NAME AND CARRIER_OPERATOR_NAME = pCARRIER_OPERATOR_NAME AND
CONNECT_TYPE =pCONNECT_TYPE AND SOURCE_FILE_ACCEPT_DATE between pTROUBLE_DATE_BEGIN AND pTROUBLE_DATE_END) where SYSTEM_ID = pSYSTEM_ID AND PROVINCE_NAME=pPROVINCE_NAME AND CARRIER_OPERATOR_NAME = pCARRIER_OPERATOR_NAME AND
CONNECT_TYPE =pCONNECT_TYPE AND SOURCE_FILE_ACCEPT_DATE = pTROUBLE_DATE_BEGIN;
end IF;
END

drop PROCEDURE date_pro_quality_load_desc_qk
call date_pro_quality_load_desc_qk(‘2017-07-01’,’2017-07-02’,’beijing’,’3’,’YiDong’,’wlan’);

================================================================
eclipse的调用测试过程与linux如何执行的过程：
eclipse->run as ->configuration参数填写 如：（0 6 date_pro_troubleanalysisone_count_byday 1 -1）
->run

eclipse打成jar包：export->

[root@master01 procedureMain]# ll
total 7684
-rwxrwxrwx 1 root root 2952 Jul 20 19:01 jdbc.properties
-rwxrwxrwx 1 root root 3924124 Jul 20 19:36 proceduremainByday.jar
-rwxrwxrwx 1 root root 3926099 Jul 21 11:26 proceduremain.jar
[root@master01 procedureMain]# nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count_byday 2 -1 &
[1] 9423
[root@master01 procedureMain]# nohup: appending output to `nohup.out’

[root@master01 procedureMain]# jps
9423 jar
9495 Jps
8849 Bootstrap

[root@master01 procedureMain]# ps -ef|grep proceduremain.jar
root 9423 8590 1 11:30 pts/3 00:00:00 java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count_byday 2 -1
root 9525 8590 0 11:31 pts/3 00:00:00 grep proceduremain.jar

[root@master01 procedureMain]# nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 7 -1 4 数据质量分析模块 > /home/count_100_7_-1.log &
[2] 9927
[root@master01 procedureMain]# jps
10211 Jps
9927 jar
9766 jar
8849 Bootstrap
[root@master01 procedureMain]# nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 7 -1 1 故障诊断模块 > /home/count_systemid_1.log &
[3] 10283
[root@master01 procedureMain]# jps
9927 jar
9766 jar
10283 jar
10313 Jps
8849 Bootstrap
[root@master01 procedureMain]# nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 7 -1 2 故障诊断模块 > /home/count_systemid_2.log &
[4] 10381
[root@master01 procedureMain]# nohup java -jar proceduremain.jar 0 100 date_pro_troubleanalysisone_count 7 -1 3 故障诊断模块 > /home/count_systemid_3.log &
[5] 10411
[root@master01 procedureMain]# jps

ForLebron
关注
专栏目录
mysql驱动包-mysql-connector-java-5.1.41-bin.zip
08-18
MySQL驱动包`mysql-connector-java-5.1.41-bin.zip`是专门为Java开发者设计的，用于在Java应用程序中连接MySQL数据库的JDBC驱动程序。这个压缩包包含了MySQL Connector/J，它是MySQL官方提供的Java Database ...
mysql-connector-java-8.0.29.jar
05-30
MySQL Connector/J 8.0.29 是MySQL数据库与Java应用程序之间通信的重要桥梁，它是一个实现了Java Database Connectivity (JDBC) API的驱动程序，使得Java开发者能够方便地在Java应用中连接并操作MySQL数据库。...
Linux虚拟机部署Java环境-Jdk-Mysql
rows_com的博客
02-09 624
工具，然后使用堡垒机基础控件windows版进行安装扫描，最后点击自动检测，保证能扫描到X-shell工具的安装路径。使用堡垒机登录快照夏选择工具点击Xshell进行连接。需要的话可以联系我我单独发给你！
Linux----centos7 安装部署Java jdk tomcat mysql
weixin_50731688的博客
04-15 257
不太建议关闭防火墙，建议让防火墙放行我们所需要访问的端口。
Java/Linux/Mysql 时区设置
记录 分享 成就
09-12 437
代码中设置JVM时区。中默认使用系统的时区。
Linux下java、mysql以及tomcat安装
k010908的博客
07-10 176
Linux下安装java、mysql以及tomcat。
Ubuntu18.04无网络配置Java-Nginx-MySQL环境（arm64）
帕里亚的杂货铺
02-06 832
在无网络的机器中无法直接使用apt-get进行安装，而如果下载.deb或是.rpm包则需要依次安装其所需的依赖包，相对复杂；本文利用打包好的tar.gz或是源码编译可以实现不需要apt-get的Java、Nginx和MySQL安装，从而满足网页应用的部署。
Linux - Linux安装部署xxl-job
MinggeQingchun的博客
09-05 1181
将下载的xxl-job-2.4.1.tar.gz上传到linux，我这里建了个文件夹用来存放压缩包。因为xxl-job需要存储数据，需要依赖Mysql数据库（如果连接外部MySQL，可以不用部署）此处也可以在本地直接下载2.4.1版本的源码包，然后解压缩，IDEA打开。如果本地打包好了，直接上传jar包，可以不用安装Maven）因为部署的是jar应用，启动时需要依赖Jdk1.8+（文件，连接到mysql数据库，导入到mysql中。因为需要打包，所以要有Maven环境（设置log.path参数为。
linux下mysql-5.7.32的安装
xuzai
01-31 2277
文章目录卸载MySQL一、基本内容二、安装前准备三、安装mysql1、基本操作 卸载MySQL //rpm包安装方式卸载 查包名：rpm -qa|grep -i mysql 删除命令：rpm -e –nodeps 包名 //yum安装方式下载 1.查看已安装的mysql 命令：rpm -qa | grep -i mysql 2.卸载mysql 命令：yum remove mysql-community-server-5.6.36-2.el7.x86_64 查看mysql的其它依赖：rpm -qa |
linux下安装mysql-8.0.30超级详细
Amik69901183的博客
09-15 5573
linux下安装mysql-8.0.30超级详细-完全
Linux安装MySql-8.0.28
Rcc_so的博客
08-30 879
MySql-8.0.28安装手册
linux安装mysql8.0.28教程
qq_42264638的博客
04-19 3751
1.去官网下载最新版本（不想下载也可以私信我我发你） 我这里用的版本是（mysql-8.0.28-linux-glibc2.12-x86_64.tar.xz） 2.可以上传到linux服务器 2.1解压 tar xvJf mysql-8.0.28-linux-glibc2.12-x86_64.tar.xz 2.2移动安装包到usr/local下面（这个时候安装包文件夹修改成了mysql） mv mysql-8.0.11-linux-glibc2.12-x86_64 /usr/local/mysql
mysql-connector-java-8.0.20.jar
08-13
MySQL是世界上最受欢迎的关系型数据库管理系统之一，而`mysql-connector-java-8.0.20.jar`是MySQL针对Java开发的官方驱动程序，用于在Java应用程序中与MySQL数据库进行通信。这个驱动，也称为JDBC（Java Database ...
mysql-connector-java-5.1.7-bin.jar
11-15
MySQL是世界上最受欢迎的关系型数据库管理系统（RDBMS）之一，尤其在Web应用程序开发中被...通过理解和正确使用这个驱动，开发者可以轻松地在Java项目中集成MySQL数据库，实现数据的存储、检索和其他复杂的数据库操作。
mysql-connector-java-5.1.49.jar
03-02
MySQL Connector/J 5.1.49支持多种数据库特性，包括预编译的SQL语句（PreparedStatement）、批处理、存储过程调用、事务管理和连接池集成。此外，它还提供了对JDBC 4.0规范的支持，包括自动类型检测和自动重连功能。...
Java 代码实现了一个简单的文本编辑器-可运行
10-17
Java 代码实现了一个简单的文本编辑器
MATLAB实现基于Attention-LSTM的多特征分类预测（含完整的程序和代码详解）
10-17
内容概要：本文详细介绍了如何使用MATLAB实现基于Attention机制的LSTM模型进行多特征分类预测。主要内容包括程序设计思路、代码实现、模型构建与训练、模型评估及可视化、以及简单的GUI界面设计。模型可以在多个领域应用，如金融数据分析、医疗诊断等。 适合人群：对深度学习和分类预测感兴趣的科研人员和开发人员，具备一定的MATLAB和深度学习基础。 使用场景及目标：适用于需要处理时间序列数据并进行分类预测的项目。目标是通过Attention-LSTM模型提高分类准确率，同时提供直观的可视化结果和友好的用户界面。 其他说明：文中提供了详细的代码实现和注释，读者可以通过实践加深对模型的理解。此外，还讨论了模型优化和未来的研究方向。
基于Flask和SQLAlchemy 的简易仓库管理系统源码(期末课程设计).zip
10-17
基于Flask和SQLAlchemy 的简易仓库管理系统源码(期末课程设计).zip 1.多数小白下载后，在使用过程，可能会遇到些小问题，若自己解决不了，请及时私信描述你的问题，我会第一时间提供帮助，也可以远程指导 2.项目代码完整可靠，谈不上高分、满分(多数为夸大其词），但难度适中，满足一些毕设、课设要求，且属于易上手的优质项目，项目内基本都有说明文档，按照操作即可，遇到困难也可私信交流 3.适用人群：各大计算机相关专业行业的在校学生、高校老师、公司程序员等下载使用 4.特别是那种爱钻研学习的学霸，强烈推荐此项目，可以二次开发提升自己。如果确定自己是学渣，拿来作毕设、课设直接用也无妨，但自己还是尽可能弄懂项目最好！
民航网上订票系统 JAVA毕业设计 源码+数据库+论文 Vue.js+SpringBoot+MySQL.zip
最新发布
10-17
民航网上订票系统 JAVA毕业设计 源码+数据库+论文 Vue.js+SpringBoot+MySQL 系统启动教程：https://www.bilibili.com/video/BV11ktveuE2d
Linux下MySQL数据库安装与Java项目配置教程
本文档详细介绍了在Linux系统上安装MySQL数据库以及配置Java项目的一系列步骤，主要针对的是对Linux环境有一定基础的开发者和管理员。以下是文章的主要知识点： 1. 安装MySQL数据库： - 首先，用户需要从MySQL官方...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值