JDBC学习笔记

阅读数：次 2020-07-25

原创字数统计: 4.6k字 | 预计阅读时长≈ 21分钟

本笔记为本人在B站学习时整理而成，为了更好的学习，将其整理成笔记，以防忘记相关知识点。

概述

JDBC是什么

Java DataBase Connectivity（Java语言连接数据库）

JDBC的本质是什么

JDBC是SUN公司制定的一套接口（interface）

java.sql.*; (这个软件包下有很多接口)

接口都有调用者和实现者。

面向接口调用、面向接口写实现类，这都属于面向接口编程。

为什么要面向接口编程？

//解耦合：降低程序的耦合度，提高程序的扩展力。
	//多态机制就是非常典型的：面向抽象编程。（不要面向具体编程）
	//建议：
	Animal a = new Cat();
	Animal a = new Dog();
	// 喂养的方法
	public void feed(Animal a){ // 面向父类型编程。
				
	}
	//不建议：
	Dog d = new Dog();
	Cat c = new Cat();

为什么SUN制定一套JDBC接口呢

#因为每一个数据库的底层实现原理都不一样。
Oracle数据库有自己的原理。
MySQL数据库也有自己的原理。
MS SqlServer数据库也有自己的原理。
....
#每一个数据库产品都有自己独特的实现原理。
	
#DBC的本质到底是什么？
一套接口。

JDBC编程

准备工作

先从官网下载对应的驱动jar包，然后将其配置到环境变量classpath当中.

1	classpath=.;D:\MySql Connector Java 5.1.23\mysql-connector-java-5.1.23-bin.jar

以上的配置是针对于文本编辑器的方式开发，使用IDEA工具的时候，不需要配置以上的环境变量。

IDEA有自己的配置方式。

JDBC编程六步（需要背会）

第一步：注册驱动 #（作用：告诉Java程序，即将要连接的是哪个品牌的数据库）

第二步：获取连接 #（表示JVM的进程和数据库进程之间的通道打开了，这属于进程之间的通信，重量级的，使用完之后一定要关闭通道。）

第三步：获取数据库操作对象 #（专门执行sql语句的对象）

第四步：执行SQL语句 #（DQL DML....）

第五步：处理查询结果集 #（只有当第四步执行的是select语句的时候，才有这第五步处理查询结果集。）

第六步：释放资源 #（使用完资源之后一定要关闭资源。Java和数据库属于进程间的通信，开启之后一定要关闭。）

#url包括：协议、IP地址、端口号、数据库实例名

数据库创建student表，包含id，name

create table student(
	id int primary key auto_increment,
	name varchar(255)
);

java代码（笔记在代码里）

第一个jdbc程序

package com.itkw.jdbc;

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

/**
 * @author lijing
 * @Description 实现JDBC连接mysql数据库
 * @create 2020-07-09 21:22
 */
public class JDBCTest01 {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;


        try {

//            1.注册驱动
//            这是注册驱动的其中一种方式，其实这种方式在com.mysql.jdbc.Driver中已经写好了，在静态代码块中
//            DriverManager.registerDriver(new Driver());

//            通过反射机制类加载的方式可以直接执行静态代码块
            Class.forName("com.mysql.jdbc.Driver");//常用的，参数是一个字符串，可以写到配置文件中。

//            2.获取连接
            String url = "jdbc:mysql://localhost:3306/study";
            String username = "root";
            String password = "root";
            conn = DriverManager.getConnection(url, username, password);

//            3.获取数据库操作对象
            stmt = conn.createStatement();

//            4.执行SQL语句
            int count = stmt.executeUpdate("insert into student(name) values ('lihui')");
            System.out.println(count == 1 ? "增加成功" : "增加失败");

//            5.处理查询结果集（DQL语句才需要使用）


        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {

//            6.释放资源
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

通过配置文件读取数据库连接信息

创建jdbc.properties文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/study
user=root
password=root

编写代码

注意：使用ResourceBundle是从src目录下开始读取的，我的jdbc.properties直接放在了src目录下，所以获取文件要这样获取：

1 2	ResourceBundle resource = ResourceBundle.getBundle("jdbc");//不需要加后缀 //如果放在了src的其他目录下，自行改getBundle中的值

package com.itkw.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ResourceBundle;

/**
 * @author lijing
 * @Description  通过资源绑定器绑定属性配置文件，这样写目的是不建议把连接数据库信息写死到java程序中
 * @create 2020-07-09 21:52
 */
public class JDBCTest02 {
    public static void main(String[] args) {

        ResourceBundle resource = ResourceBundle.getBundle("jdbc");//不需要加后缀，并且只能是properties文件
        String driver = resource.getString("driver");
        String url = resource.getString("url");
        String user = resource.getString("user");
        String password = resource.getString("password");

        Connection conn = null;
        Statement stmt = null;
        try {
//            注册驱动
            Class.forName(driver);

//            2.获取连接
            conn = DriverManager.getConnection(url, user, password);

            System.out.println(conn);

//            3.获取数据库操作对象
//            stmt = conn.createStatement();

//            4.执行SQL语句
//            int count = stmt.executeUpdate("insert into student(name) values ('jinggege')");
//            System.out.println(count == 1 ? "增加成功" : "增加失败");

//            5.处理查询结果集（DQL语句才需要使用）


        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {

//            6.释放资源
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

查询操作

package com.itkw.jdbc;

import java.sql.*;
import java.util.ResourceBundle;

/**
 * @author lijing
 * @Description 查询操作，遍历结果集
 * @create 2020-07-09 22:09
 */
public class JDBCTest03 {
    public static void main(String[] args) {

        ResourceBundle source = ResourceBundle.getBundle("jdbc");
        String driver = source.getString("driver");
        String url = source.getString("url");
        String user = source.getString("user");
        String password = source.getString("password");

        Connection conn = null;
        Statement stmt = null;
        ResultSet resultSet = null;

        try {
//        1.注册驱动
            Class.forName(driver);

//        2.获取连接
            conn = DriverManager.getConnection(url, user, password);

//        3.获取数据库操作对象
            stmt = conn.createStatement();
//        4.执行sql语句
            String sql = "select id,name from student";
            resultSet = stmt.executeQuery(sql);

//        5.处理查询结果集
            while (resultSet.next()) {
//                可以通过String类型取出，也可以通过特定类型取出，但要对应
//                String id = resultSet.getString("id");
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                System.out.println(id + "," + name);
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {

//        6.释放资源
            if (resultSet != null) {
                try {
                    resultSet.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();
                }
            }
        }
    }
}

SQL注入

创建t_user表

/*==============================================================*/
/* DBMS name:      MySQL 5.0                                    */
/* Created on:     2020/07/10 11:02:22                          */
/*==============================================================*/


drop table if exists t_user;

/*==============================================================*/
/* Table: t_user                                                */
/*==============================================================*/
create table t_user
(
   id                   bigint auto_increment,
   loginName            varchar(255),
   loginPwd             varchar(255),
   realName             varchar(255),
   primary key (id)
);

insert into t_user(loginName,loginPwd,realName) values('zhangsan','123','张三');
insert into t_user(loginName,loginPwd,realName) values('jack','123','杰克');
commit;
select * from t_user;

java代码

package com.itkw.jdbc;

import java.sql.*;
import java.util.HashMap;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Scanner;

/**
 * @author lijing
 * @Description 实现用户登录功能
 * @create 2020-07-10 9:27
 */
public class JDBCTest04 {
    public static void main(String[] args) {
        Map<String, String> userLoginInfo = initUI();
        boolean loginSuccess = login(userLoginInfo);
        System.out.println(loginSuccess ? "登录成功" : "登录失败");
    }

    private static boolean login(Map<String, String> userLoginInfo) {
        boolean loginSuccess = false;//登录成功与否的标记
        String loginName = userLoginInfo.get("loginName");
        String loginPwd = userLoginInfo.get("loginPwd");

        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
        String driver = bundle.getString("driver");
        String url = bundle.getString("url");
        String user = bundle.getString("user");
        String password = bundle.getString("password");

        try {
//            1.注册驱动
            Class.forName(driver);
//            2.获取连接
            conn = DriverManager.getConnection(url, user, password);
//            3.获取数据库操作对象
            stmt = conn.createStatement();
//            4.执行sql语句
//            下面的语句会引起sql注入    例如密码为：   qwe' or '1'='1
//            数据库会自动将密码拼接为： 'qwe' or '1'='1'
            String sql = "select * from t_user where loginName = '" + loginName + "' and loginPwd = '" + loginPwd + "'";
//            以上正好完成了sql语句的拼接，以下代码的含义是，发送sql语句给DBMS，DBMS进行sql编译
//            正好将用户提供的"非法信息"编译进去，导致了原sql语句的含义被扭曲了。
//            导致sql注入的根本原因是：用户输入的信息中含有SQL语句的关键字，并且这些关键字参与了sql语句的编译过程
//            导致sql语句的原意被扭曲，进而达到sql注入。
            rs = stmt.executeQuery(sql);
//            5.处理结果集
            if (rs.next()) {
                loginSuccess = true;
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
//            6.释放资源
            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();
                }
            }
        }

        return loginSuccess;
    }

    private static Map<String, String> initUI() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String loginName = sc.nextLine();
        System.out.println("请输入用户密码：");
        String loginPwd = sc.nextLine();
        Map<String, String> userLoginInfo = new HashMap<>();
        userLoginInfo.put("loginName", loginName);
        userLoginInfo.put("loginPwd", loginPwd);
        return userLoginInfo;
    }
}

使用PreparedStatement预编译，防止SQL注入

package com.itkw.jdbc;

import java.sql.*;
import java.util.HashMap;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Scanner;

/**
 * @author lijing
 * @Description 解决sql注入问题
 * 只要用户提供的信息不参与SQL语句的编译过程，问题就解决了。
 * 即使用户提供的信息中含有sql语句的关键字，但是没有参与编译，不起作用。
 * 要想使用户信息不参与SQL语句的编译，那么必须使用java.sql.PreparedStatement
 * PreparedStatement接口继承了java.sql.Statement
 * PreparedStatement是属于预编译的数据库操作对象。
 * PreparedStatement的原理是：预先对SQL语句的框架进行编译，再给SQL语句传"值"。
 *
 * 解决SQL注入的关键是：用户提供的信息中即使有SQL语句的关键字，但是并不参与编译，不起作用。
 *
 * 对比Statement和PreparedStatement：
 *        - Statement存在SQL注入问题，PreparedStatement解决了SQL注入问题。
 *        - Statement是编译一次执行一次，PreparedStatement是编译一次，可执行N次。PreparedStatement效率较高一些。
 *        - PreparedStatement会在编译阶段做类型的安全检查。
 *
 * 综上所述，PreparedStatement使用较多，只有极少数情况下使用Statement。
 * 当业务要求必须支持SQL注入的时候，就得使用Statement，因为它支持SQL注入，PreparedStatement不支持。
 * 比如说京东商城的价格升序和降序，相当于输入了desc和asc，用PreparedStatement的话没法实现。
 * @create 2020-07-10 12:07
 */
public class JDBCTest05 {
    public static void main(String[] args) {
        Map<String, String> userLoginInfo = initUI();
        boolean loginSuccess = login(userLoginInfo);
        System.out.println(loginSuccess ? "登录成功" : "登录失败");
    }

    private static boolean login(Map<String, String> userLoginInfo) {
        boolean loginSuccess = false;//登录成功与否的标记
        String loginName = userLoginInfo.get("loginName");
        String loginPwd = userLoginInfo.get("loginPwd");

        Connection conn = null;
        PreparedStatement ps = null;  //这里换成预编译
        ResultSet rs = null;

        ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
        String driver = bundle.getString("driver");
        String url = bundle.getString("url");
        String user = bundle.getString("user");
        String password = bundle.getString("password");

        try {
//            1.注册驱动
            Class.forName(driver);
//            2.获取连接
            conn = DriverManager.getConnection(url, user, password);
//            3.获取预编译的数据库操作对象
            String sql = "select * from t_user where loginName = ? and loginPwd = ?";//? 表示占位符，不能用单引号括起来
            ps = conn.prepareStatement(sql);
//            给占位符传值(第一个问号下标是1，第二个问号下标是2，JDBC中所有下标从1开始)
            ps.setString(1, loginName);
            ps.setString(2, loginPwd);
//            4.执行sql语句(采用预编译，executeQuery()中不要写sql)
            rs = ps.executeQuery();
//            5.处理结果集
            if (rs.next()) {
                loginSuccess = true;
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
//            6.释放资源
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

        return loginSuccess;
    }

    private static Map<String, String> initUI() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String loginName = sc.nextLine();
        System.out.println("请输入用户密码：");
        String loginPwd = sc.nextLine();
        Map<String, String> userLoginInfo = new HashMap<>();
        userLoginInfo.put("loginName", loginName);
        userLoginInfo.put("loginPwd", loginPwd);
        return userLoginInfo;
    }
}

使用PreparedStatement增删改

package com.itkw.jdbc;

import java.sql.*;
import java.util.ResourceBundle;

/**
 * @author lijing
 * @Description 使用PreparedStatement 增删改
 * @create 2020-07-10 14:52
 */
public class JDBCTest06 {
    public static void main(String[] args) {
        ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
        String driver = bundle.getString("driver");
        String url = bundle.getString("url");
        String user = bundle.getString("user");
        String password = bundle.getString("password");

        Connection conn = null;
        PreparedStatement ps = null;

        try {
//            1.注册驱动
            Class.forName(driver);
//            2.获取连接
            conn = DriverManager.getConnection(url, user, password);
//            3.获取预编译的数据库操作对象

//            增加操作
            /*String sql = "insert into t_user(loginName,loginPwd,realName) values(?,?,?)";
            ps = conn.prepareStatement(sql);
            ps.setString(1, "lihui");
            ps.setString(2, "1234");
            ps.setString(3, "李慧");*/

//            修改操作
            /*String sql = "update t_user set loginPwd = ? where loginName = ?";
            ps = conn.prepareStatement(sql);
            ps.setString(1, "12345");
            ps.setString(2, "lihui");*/

//            删除操作
            String sql = "delete from t_user where loginName = ?";
            ps = conn.prepareStatement(sql);
            ps.setString(1, "lihui");

//            4.执行sql语句
            int count = ps.executeUpdate();
//            System.out.println(count == 1 ? "增加成功" : "增加失败");
//            System.out.println(count == 1 ? "修改成功" : "修改失败");
            System.out.println(count == 1 ? "删除成功" : "删除失败");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
//            6.释放资源
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

JDBC事务机制

package com.itkw.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ResourceBundle;

/**
 * @author lijing
 * @Description
 *
 * JDBC事务机制：
 *         1. JDBC中的事务是自动提交的
 *              只要执行任意一条DML语句，则自动提交一次。这是JDBC默认的事务行为。
 *              比如执行一个转账操作，如果在转账的中间出现了异常，那么后面的就不会执行，出现问题了
 *
 *              那我们就必须设置为手动提交事务。
 *              conn.setAutoCommit(false); 禁用自动提交事务
 *              conn.commit(); 手动提交事务
 *              conn.rollback(); 回滚事务
 *          2. 结论： 禁用禁用自动提交事务，在java程序中手动提交事务。
 * @create 2020-07-10 15:16
 */
public class JDBCTest07 {
    public static void main(String[] args) {

        ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
        String driver = bundle.getString("driver");
        String url = bundle.getString("url");
        String user = bundle.getString("user");
        String password = bundle.getString("password");

        Connection conn = null;
        PreparedStatement ps = null;

        try {
//            1.注册驱动
            Class.forName(driver);
//            2.获取连接
            conn = DriverManager.getConnection(url, user, password);

//            禁用自动提交事务
            conn.setAutoCommit(false);

//            3.获取预编译的数据库操作对象

            String sql = "update t_act set balance = ? where actno = ?";
            ps = conn.prepareStatement(sql);
            ps.setDouble(1, 10000);
            ps.setInt(2, 111);

//            4.执行sql语句
            int count = ps.executeUpdate();

            /*String s = null;
            s.toString(); *///模拟异常操作，后面的将不会执行

            ps.setDouble(1, 10000);
            ps.setInt(2, 222);
            count += ps.executeUpdate();

            System.out.println(count == 2 ? "转账成功" : "转账失败");

            conn.commit();//手动提交事务

        } catch (ClassNotFoundException e) {
            if (conn != null) {
                try {
                    conn.rollback();
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }
            e.printStackTrace();
        } catch (SQLException e) {
            if (conn != null) {
                try {
                    conn.rollback();
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }
            e.printStackTrace();
        } finally {
//            6.释放资源
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

封装工具类

package com.itkw.jdbc.utils;

import java.sql.*;

/**
 * @author lijing
 * @Description 封装JDBC工具类，简化JDBC编程
 * @create 2020-07-10 15:52
 */
public class DBUtil {

    /**
     * 工具类中的构造方法都是私有的
     * 因为工具类中的方法都是静态的，不需要new对象，直接通过类名调用。
     */
    private DBUtil() {

    }

    /**
     * 静态代码块在类加载时执行，并且只执行一次
     */
    static {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取数据库连接对象
     *
     * @return 连接对象
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {

        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/study", "root", "root");

        return conn;
    }

    /**
     * 关闭资源
     * @param conn 数据库连接对象
     * @param stmt 数据库操作对象
     * @param rs   结果集
     */
    public static void close(Connection conn, Statement stmt, ResultSet rs) {
        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();
            }
        }
    }
}

介绍行级锁/悲情锁

工具类使用，并且测试悲情锁

代码

package com.itkw.jdbc.utils;

import java.sql.*;

/**
 * @author lijing
 * @Description 测试工具类、实现模糊查询  行级锁
 * @create 2020-07-10 16:07
 */
public class DBUtilTest {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
//            获取连接
            conn = DBUtil.getConnection();
            conn.setAutoCommit(false);//禁用自动提交事务
//            获取预编译的数据库操作对象
//            后面加上for update 加上行级锁，事务结束后，别的事务才能修改这些被锁住的数据，否则程序一直卡在那儿。
            String sql = "select realName from t_user where loginName like ? for update ";
            ps = conn.prepareStatement(sql);
            ps.setString(1, "_i%");//第二个字母为i
//            处理结果集
            rs = ps.executeQuery();
            while (rs.next()) {
                System.out.println(rs.getString("realName"));
            }

            conn.commit();//手动提交事务 针对于DML操作

        } catch (SQLException e) {
            if (conn != null) {
                try {
                    conn.rollback();
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }
            e.printStackTrace();
        } finally {
            DBUtil.close(conn, ps, rs);
        }
    }
}

package com.itkw.jdbc.utils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * @author lijing
 * @Description 测试行级锁/悲情锁  被锁住后 无法修改 等另外的那个事务结束后才能修改
 * @create 2020-07-10 16:38
 */
public class HangJiSuoTest {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;

        try {
            conn = DBUtil.getConnection();
            conn.setAutoCommit(false);

            String sql = "update t_user set realName = '李慧慧' where loginName = ?";
            ps = conn.prepareStatement(sql);
            ps.setString(1, "lihui");

            int count = ps.executeUpdate();
            System.out.println(count);


            conn.commit();
        } catch (SQLException e) {
            try {
                conn.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        }finally {
            DBUtil.close(conn, ps, null);
        }
    }
}

介绍PowerDesigner的使用

PowerDesigner是设计表使用的。

//这是我学习时遇到的问题，可能只有我遇到吧，其他人不一定出现这个问题，所以在这做个笔记。

1. 使用PowerDesigner生成的sql语句在Navicat里面drop table if exists xxx 会报错，原因是drop前面有个特殊字符看不出来，可以在drop前把它删除，
  如果drop关键字变成蓝色的了，就没事了。

2. 可以在cmd窗口中在对应的数据库中使用source语句  然后把sql脚本拖进去，会自动变为路径，但是sql语句不能放在中文路径下，会报错。


解决方法：（不要在设计的时候直接在preview中点击保存文件）
点击PowerDesigner中上面的数据库----->生成数据库，修改sql脚本名，然后保存。
这样的sql脚本导入Navicat中就不会有问题。
脚本文件中有这样的标识，这样drop前面不会有特殊字符：
/*==============================================================*/
/* DBMS name:      MySQL 5.0                                    */
/* Created on:     2020/07/10 10:53:38                          */
/*==============================================================*/

本文作者： LiJing
发布时间： 2020-07-25
最后更新： 2023-01-27
本文标题： JDBC学习笔记
本文链接： https://blog-yilia.xiaojingge.com/posts/c4fa58df.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 许可协议进行许可。转载请注明出处！