Java与Mysql的爱恨情仇

最新推荐文章于 2024-12-11 09:43:17 发布
最新推荐文章于 2024-12-11 09:43:17 发布
阅读量1.3k 收藏 5
点赞数 1
分类专栏： java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/doubleguy/article/details/104963622
版权

前言

       学了这么久的java，我发现一个很严重的问题，我大部分java重要知识点尤其是不会的知识都有记一些笔记，但唯独到了java连接数据库的时候，发现一点痕迹都木得。可能以前学的时候学会了，就没记吧。但是时间长了，代码也忘得差不多了，是时候重新梳理一下java和Mysql的连接知识了，这会是一个大内容，我挑一部分极其重要和常用的来记录，姑且把它称作  java与Mysql  的爱恨情仇！

一. 重要基本对象介绍

1. DriverManager：驱动管理对象

     * 功能：

                     1. 注册驱动：告诉程序该使用哪一个数据库驱动jar

                     2. 获取数据库连接
      

1. 注册驱动：告诉程序该使用哪一个数据库驱动jar
                    static void registerDriver(Driver driver) :注册与给定的驱动程序 DriverManager 。 
                    写代码使用：  Class.forName("com.mysql.jdbc.Driver");
                    通过查看源码发现：在com.mysql.jdbc.Driver类中存在静态代码块

static {
    try {
        java.sql.DriverManager.registerDriver(new Driver());
    } catch (SQLException E) {
        throw new RuntimeException("Can't register driver!");
    }
}

                    注意：mysql5之后的驱动jar包可以省略注册驱动的步骤。
2. 获取数据库连接：
                    * 方法：static Connection getConnection(String url, String user, String password) 
                    * 参数：
                        * url：指定连接的路径
                            * 语法：jdbc:mysql://ip地址(域名):端口号/数据库名称
                            * 例子：jdbc:mysql://localhost:3306/db3
                            * 细节：如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数                                           据库名称
                        * user：用户名
                        * password：密码 

2. Connection：数据库连接对象

      * 功能：

                1. 获取执行sql 的对象
                2. 管理事务

1. 获取执行sql 的对象
                    * Statement createStatement()
                    * PreparedStatement prepareStatement(String sql)  
2. 管理事务：
                    * 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
                    * 提交事务：commit() 
                    * 回滚事务：rollback() 

3. Statement：执行sql的对象 

        *  执行sql
                1. boolean execute(String sql) ：可以执行任意的sql 了解 
                2. int executeUpdate(String sql) ：执行DML（insert、update、delete）语句、DDL(create，alter、drop)语句
                    * 返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功 返回值>0的则执行成功，反之，则失                                       败。
                3. ResultSet executeQuery(String sql)  ：执行DQL（select)语句
            

        *  练习：
                1. account表 添加一条记录
                2. account表 修改记录
                3. account表 删除一条记录

         代码：

        Statement stmt = null;
        Connection conn = null;
        try {
            //1. 注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2. 定义sql
            String sql = "insert into account values(null,'王五',3000)";
            //3.获取Connection对象
            conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
            //4.获取执行sql的对象 Statement
            stmt = conn.createStatement();
            //5.执行sql
            int count = stmt.executeUpdate(sql);//影响的行数
            //6.处理结果
            System.out.println(count);
            if(count > 0){
                System.out.println("添加成功！");
            }else{
                System.out.println("添加失败！");
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            //stmt.close();
            //7. 释放资源
            //避免空指针异常
            if(stmt != null){
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if(conn != null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

4. ResultSet：结果集对象,封装查询结果

            * boolean next(): 游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，如果是，则返回false，如果不是则                                           返回true
            * getXxx(参数):获取数据
                * Xxx：代表数据类型   如： int getInt() ,    String getString()
                * 参数：
                    1. int：代表列的编号,从1开始   如： getString(1)
                    2. String：代表列名称。 如： getDouble("balance")
            
            * 注意：
                * 使用步骤：
                    1. 游标向下移动一行
                    2. 判断是否有数据
                    3. 获取数据

                   //循环判断游标是否是最后一行末尾。
                    

while(rs.next()){
            //获取数据
            //6.2 获取数据
            int id = rs.getInt(1);
            String name = rs.getString("name");
            double balance = rs.getDouble(3);
        
            System.out.println(id + "---" + name + "---" + balance);
          }

5. PreparedStatement：执行sql的对象

            1. SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题
                1. 输入用户随便，输入密码：a' or 'a' = 'a
                2. sql：select * from user where username = 'fhdsjkf' and password = 'a' or 'a' = 'a' 

            2. 解决sql注入问题：使用PreparedStatement对象来解决
            3. 预编译的SQL：参数使用?作为占位符
            4. 步骤：
                1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
                2. 注册驱动
                3. 获取数据库连接对象 Connection
                4. 定义sql
                    * 注意：sql的参数使用？作为占位符。 如：select * from user where username = ? and password = ?;
                5. 获取执行sql语句的对象 PreparedStatement  Connection.prepareStatement(String sql) 
                6. 给？赋值：
                    * 方法： setXxx(参数1,参数2)
                        * 参数1：？的位置编号 从1 开始
                        * 参数2：？的值
                7. 执行sql，接受返回结果，不需要传递sql语句
                8. 处理结果
                9. 释放资源

            5. 注意：后期都会使用PreparedStatement来完成增删改查的所有操作
                1. 可以防止SQL注入
                2. 效率更高

二. 最基础的java连接数据库方式

* 步骤：
            1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
                     1.复制mysql-connector-java-5.1.37-bin.jar到项目的libs目录下
                     2.右键-->Add As Library
            2. 注册驱动
            3. 获取数据库连接对象 Connection
            4. 定义sql
            5. 获取执行sql语句的对象 Statement
            6. 执行sql，接受返回结果
            7. 处理结果
            8. 释放资源

For example：

package test1;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

/**
 * JDBC快速入门
 */
public class JdbcDemo1 {
    public static void main(String[] args) throws Exception {

        //1. 导入驱动jar包
        //2.注册驱动
        // Class.forName("com.mysql.jdbc.Driver");
        //3.获取数据库连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
        //4.定义sql语句
        String sql = "update account set balance = 2000";
        //5.获取执行sql的对象 Statement
        Statement stmt = conn.createStatement();
        //6.执行sql
        int count = stmt.executeUpdate(sql);
        //7.处理结果
        System.out.println(count);
        //8.释放资源
        stmt.close();
        conn.close();

    }
}

三. 用JDBCUtils简化连接

抽取JDBC工具类 ： JDBCUtils
    * 目的：简化书写
    * 分析：
        1. 注册驱动也抽取
        2. 抽取一个方法获取连接对象
            * 需求：不想传递参数（麻烦），还得保证工具类的通用性。
            * 解决：配置文件
                jdbc.properties
                    url=......
                    user=......
                    password=......
        3. 抽取一个方法释放资源

     * 代码实现：

package test1;

import java.io.FileReader;
import java.net.URL;
import java.sql.*;
import java.util.Properties;

public class JDBCUtils {
        private static String url;
        private static String user;
        private static String password;
        private static String driver;
        /**
         * 文件的读取，只需要读取一次即可拿到这些值。使用静态代码块
         */
        static{
            //读取资源文件，获取值。
    
            try {
                //1. 创建Properties集合类。
                Properties pro = new Properties();
    
                //获取src路径下的文件的方式--->ClassLoader 类加载器
                ClassLoader classLoader = JDBCUtils.class.getClassLoader();
                URL res  = classLoader.getResource("jdbc.properties");
                String path = res.getPath();
                System.out.println(path);///D:/IdeaProjects/itcast/out/production/day04_jdbc/jdbc.properties
                //2. 加载文件
                // pro.load(new FileReader("D:\\IdeaProjects\\itcast\\day04_jdbc\\src\\jdbc.properties"));
                pro.load(new FileReader(path));
    
                //3. 获取数据，赋值
                url = pro.getProperty("url");
                user = pro.getProperty("user");
                password = pro.getProperty("password");
                driver = pro.getProperty("driver");
                //4. 注册驱动
                Class.forName(driver);
            } catch (Exception e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    
    
        /**
         * 获取连接
         * @return 连接对象
         */
        public static Connection getConnection() throws Exception {
    
            return DriverManager.getConnection(url, user, password);
        }
    
        /**
         * 释放资源
         * @param stmt
         * @param conn
         */
        public static void close(Statement stmt, Connection conn){
            if( stmt != null){
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    
            if( conn != null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 释放资源
         * @param stmt
         * @param conn
         */
        public static void close(ResultSet rs, Statement stmt, Connection conn){
            if( rs != null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    
            if( stmt != null){
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    
            if( conn != null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

}

 

四. 使用Druid 连接 

 Druid：数据库连接池实现技术，由阿里巴巴提供的
            1. 使用步骤：
                    1. 导入jar包 druid-1.0.9.jar
                    2. 定义配置文件：
                        * 是properties形式的
                        * 可以叫任意名称，可以放在任意目录下
                    3. 加载配置文件。Properties
                    4. 获取数据库连接池对象：通过工厂来来获取  DruidDataSourceFactory
                    5. 获取连接：getConnection
                    * 代码：    

//1.加载配置文件
Properties pro = new Properties();
InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
pro.load(is);
//2.获取连接池对象
DataSource ds = DruidDataSourceFactory.createDataSource(pro);
//3.获取连接
Connection conn = ds.getConnection();


            2. 定义工具类
                    1. 定义一个类 JDBCUtils
                    2. 提供静态代码块加载配置文件，初始化连接池对象
                    3. 提供方法
                        1. 获取连接方法：通过数据库连接池获取连接
                        2. 释放资源
                        3. 获取连接池的方法

如我们要对 Druid 使用JDBCUtils,那么代码应为：

package cn.itcast.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * Druid连接池的工具类
 */
public class JDBCUtils {

    //1.定义成员变量 DataSource
    private static DataSource ds ;

    static{
        try {
            //1.加载配置文件
            Properties pro = new Properties();
            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            //2.获取DataSource
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取连接
     */
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    /**
     * 释放资源
     */
    public static void close(Statement stmt,Connection conn){
       /* if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(conn != null){
            try {
                conn.close();//归还连接
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }*/

       close(null,stmt,conn);
    }


    public static void close(ResultSet rs , Statement stmt, Connection conn){


        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }


        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(conn != null){
            try {
                conn.close();//归还连接
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 获取连接池方法
     */

    public static DataSource getDataSource(){
        return  ds;
    }

}

五. 使用Template简化连接

Spring JDBC
        * Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
        * 步骤：
                1. 导入jar包
                2. 创建JdbcTemplate对象。依赖于数据源DataSource
                        * JdbcTemplate template = new JdbcTemplate(ds);

                3. 调用JdbcTemplate的方法来完成CRUD的操作
                        * update():执行DML语句。增、删、改语句
                        * queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个                                                           map集合
                                                   * 注意：这个方法查询的结果集长度只能是1
                        * queryForList():查询结果将结果集封装为list集合
                                                  * 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
                        * query():查询结果，将结果封装为JavaBean对象
                                     *  query的参数：RowMapper
                                     *  一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
                                     *  new BeanPropertyRowMapper<类型>(类型.class)
                        * queryForObject：查询结果，将结果封装为对象
                                                       * 一般用于聚合函数的查询

下面这个例子依次介绍了这几个方法的使用方法，不用管这个数据库是啥，只用看这几个方法咋用的就行了

import cn.itcast.domain.Emp;
import cn.itcast.utils.JDBCUtils;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

public class JdbcTemplateDemo2 {

    //Junit单元测试，可以让方法独立执行,使用方法:加注解@Test


    //1. 获取JDBCTemplate对象
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());

    /**
     * 1.. 添加一条记录
     */
    @Test
    public void test1(){
        String sql = "insert into emp(id,ename,dept_id) values(?,?,?)";
        int count = template.update(sql, 1015, "郭靖", 10);
        System.out.println(count);

    }

    /**
     * 2.查询id为1001的记录，将其封装为Map集合
     * 注意：这个方法查询的结果集长度只能是1
     */
    @Test
    public void test2(){
        String sql = "select * from emp where id = ? or id = ?";
        Map<String, Object> map = template.queryForMap(sql, 1001,1002);
        System.out.println(map);
        //{id=1001, ename=孙悟空, job_id=4, mgr=1004, joindate=2000-12-17, salary=10000.00, bonus=null, dept_id=20}
    }

    /**
     * 3. 查询所有记录，将其封装为List
     */
    @Test
    public void test3(){
        String sql = "select * from emp";
        List<Map<String, Object>> list = template.queryForList(sql);

        for (Map<String, Object> stringObjectMap : list) {
            System.out.println(stringObjectMap);
        }
    }

    /**
     * 4. 查询所有记录，将其封装为Emp对象的List集合
     */
    @Test
    public void test4(){
        String sql = "select * from emp";
        List<Emp> list = template.query(sql, new RowMapper<Emp>() {

            @Override
            public Emp mapRow(ResultSet rs, int i) throws SQLException {
                Emp emp = new Emp();
                int id = rs.getInt("id");
                emp.setId(id);

                return emp;
            }
        });


        for (Emp emp : list) {
            System.out.println(emp);
        }
    }

    /**
     * 5. 查询所有记录，将其封装为Emp对象的List集合
     */
    @Test
    public void test5_2(){
        String sql = "select * from emp";
        List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }

    /**
     * 6. 查询总记录数
     */
    @Test
    public void test6(){
        String sql = "select count(id) from emp";
        Long total = template.queryForObject(sql, Long.class);
        System.out.println(total);
    }
}

 

JAVA与Mysql.
qq_56248592的博客
11-22 1271
第一部分数据的增删改查。 @1查看表的结构。 DESC student studentt为数据库 @2增一条记录。 @3改记录 @4删除记录 #查表的结构 DESC student SELECT *FROM student; INSERT INTO `students`.`student`(`stuId`, `stuName`, `stuSex`, `stuAge`) VALUES (1001, '毛毛', '男', 12); INSERT ......
MySQL实战进阶：29+优化技巧 & NoSQL融合，如何重塑数据架构？
java专栏
06-10 2417
本文深度探索了MySQL数据库的高级运维、性能优化、高可用设计、以及与现代技术栈的集成策略，通过29个实战问题及解决方案的详尽解析，全方位覆盖了从常见性能瓶颈、高并发处理、到特定场景下的定制优化，再到MySQL与NoSQL数据库的混合使用等多个维度。我们不仅学习了如何利用InnoDB特性进行深度性能调优，构建高可用架构保障数据安全，还探讨了如何在微服务和容器化趋势下高效集成MySQL，以及如何在不同应用场景下发挥MySQL的独特优势。
java与mysql
Jack_Li
10-05 581
import java.io.IOException; import java.io.InputStream; import java.sql.SQLException; import java.util.Properties; import org.junit.Test; import com.mysql.jdbc.Connection; import com.mysql.jdbc.
JAVA MySql
supperpop的博客
04-05 554
MySql0.DROP DATABASE 数据库名1.主键不能重复并不能为空 primary key2.外键引用 references 表名（字段名）3.检查约束 check（字段名&gt;）4.默认约束 default''5.自增列 AUTO_INCREMENT6.查看表结构 DESC 表名7.查看表详细结构 SHOW CREATE TABLE 表名 \G8.修改表名 alter table 旧...
java与MySQL连接
芙筱粉贞的专栏
08-31 1292
java与MySQL连接
Java与MySQL之间的连接
hwt的博客
09-13 403
想要使Java与mysql之间连接，首先要导入相应的jar文件，然后配置其对应的配置文件，然后用下面的Java代码即可连上mysql。 package com.juwuye.util.jdbc; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; impo
【Java进阶营】【精】MySql性能（8）—orderby与limit的爱恨情仇
05-01 1552
本文前提，比较复杂的查询语句，不是单单理论上的覆盖索引实现延迟关联可以解决的场景。 本文主要讨论： order by 对分页的影响： 1.1 order by 索引字段； 1.2 order by 非索引字段（Using filesort）； order by 非索引字段下：浅分页和深分页的区别 字段 关系 id 自增主键 user_id 二级索引 type 普通字段 create_time 普通字段 1. 排序对浅分页的影响 1.1 存在排序条件（借助索引有序性） .
究竟选哪个？我与Java的事务隔离级别的爱恨情仇
青轩桃李能几何，流光欺人忽蹉跎
07-04 127
这是最严格的隔离级别，它确保事务串行执行，避免了脏读、不可重复读和幻读的所有问题。它避免了脏读的问题，但仍然可能存在不可重复读和幻读的情况。请注意，虽然我会提供一个例子来说明 READ_UNCOMMITTED 隔离级别，但在实际开发中不推荐使用 READ_UNCOMMITTED 级别，因为它存在严重的并发问题。事务的隔离级别可以通过数据库的配置进行设置，例如在Java中使用JDBC连接数据库时，可以通过设置Connection对象的setTransactionIsolation()方法来指定隔离级别。
我与ShardingSphere的爱恨情仇
最新发布
m0_60681411的博客
12-11 961
本文通过SpringBoot+ShardingSphere ,实现了Mysql数据库和DM数据库的分表操作。
数据获取之网络爬虫专栏简介
smilejiasmile的博客
09-01 276
一、技术选型 众所周知，针对不同的业务场景和需求选取不同的技术选型和架构方案方案。可以让我们事半功倍，提升工作效率的同时完成本职工作。而针对互联网上的数据获取需求也是一样。下面我们将介绍三种场景的爬虫数据获取需求和场景，并推荐其相应的解决方案。 1、简单需求（单文件脚本 / 基于 request 网络库及相关第三方库） 针对一次需求和没有持续集成的要求的场景，对于这类简单的任务，不使用爬虫框架也能实现很好的效果，而且代码更少。当采用 Python 语言实现时，常用的相关依赖库有request...
java与mysql连接 使用mysql-connector-java连接msql
m0_73952463的博客
07-17 6400
在java中，使用mysql的语法筛选数据库信息，轻松学习如何建立与mysql以及使用mysql语法。
MySQL 篇 - Java 连接 MySQL 数据库并实现数据交互
热门推荐
小蜗牛的珍贵百宝箱
09-30 1万+
通过本文的介绍，你已经学会了如何在 Java 中连接 MySQL 数据库并实现数据交互。数据库连接：使用 JDBC 连接 MySQL 数据库。数据操作：实现插入、查询、更新和删除（CRUD）操作。最佳实践：使用避免 SQL 注入。在实际应用中，建议使用连接池（如 HikariCP 或 DBCP）来提高性能和资源利用率。同时，可以考虑使用 ORM 框架（如 Hibernate 或 MyBatis）来简化数据库操作，提高开发效率。希望本文能帮助你快速上手 Java 与 MySQL 的数据交互！
java———MySQL 学习
小邹的博客
11-13 2264
1.初识MySQL 1.1数据库分类 ​ 关系数据库：（SQL） MySQL，Oracle，Sql Server，DB2，SQLlite 通过表和表之间，行和列之间的关系进行数据存储 非关系型数据库：（NoSQL） Not Only Redis，MongDB 非关系型数据库，对象存储，一个对象的自身的属性来决定 DBMS（数据库管理系统） 数据库的管理软件，科学有效的管理我们的数据。维护和获取数据 MySQL，数据库管理系统 1.2MySQL简介 MySQL是一个关系型数据库管理系统 由
MySql类型与Java类型
心有猛虎,细嗅蔷薇
03-04 795
MySQL与Java
m0_56017821的博客
07-17 448
数据库连接池技术,面向接口编程实现shop数据库的部份功能
Java和Mysql回顾
米 柴的博客
07-26 341
java基础和mysql的回顾
让Java和MySQL连接起来
weixin_30824277的博客
01-03 824
Java 连接 MySQL 需要驱动包，可以下载菜鸟教程提供的jar 包：http://static.runoob.com/download/mysql-connector-java-5.1.39-bin.jar 操作方法可分为三步： 一、配置程序——让我们程序能找到数据库的驱动jar包 1.把.jar文件复制到项目中去。 2.在eclipse项目右击“构建路径”--“配置构建路径”--...
java与Mysql --JDBC技术
zhouth94的博客
04-21 241
# JDBC Java DataBase Connectivity Java数据库连接. ## 第一步:准备数据库驱动 在Maven中下载MySQL的驱动. ![1555553733394](assets/1555553733394.png) ![1555553766175](assets/1555553766175.png) ## 第二步:构建SE项目 ![155555398852...
Spring boot配置MySQL和dm两个数据源
06-02
<artifactId>mysql-connector-java <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter <version>1.1.10 ``` 2. 配置application.yml文件，指定MySQL和dm的数据源信息： ``` spring: ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小小的香辛料

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值