精华内容
下载资源
问答
  • java连接mysql

    千次阅读 2017-04-16 14:17:40
    基本连接 加载驱动: Class.forName(com.mysql.jdbc.Driver) 建立连接:Connection conn=DriverManager.getConnection(url... 其中url="jdbc:mysql://localhost:3306/java_demo",这里的java_demo是自己创建的数据库的

    基本连接

    • 加载驱动: Class.forName(com.mysql.jdbc.Driver)

    • 建立连接:Connection conn=DriverManager.getConnection(url,user,password)

      其中url="jdbc:mysql://localhost:3306/java_demo",这里的java_demo是自己创建的数据库的名字,usermysql数据库的管理员,password是密码
      下面直接连接数据库,返回的是接口Connection对象

    import java.sql.*;
    public static Connection getConnection()
    {
        Connection conn;
        String driver="com.mysql.jdbc.Driver";   //驱动名称
        String url="jdbc:mysql://localhost:3306/java_demo";   //url
        String user="root";
        String password="root";    //管理员和密码都是root
        try{
            Class.forName(driver);    //加载驱动,但是会有ClassNotFoundException异常,因此要避免异常
            try{
                conn = Dri verManager.getConnection(url, user, password);   //获得数据库连接
                return conn;    //返回conn
    
            }catch(SQLException e)
            {
                e.printStackTrace();
            }
    
    
        }catch (ClassNotFoundException e) {
                e.printStackTrace();
        }
        return null;  //如果出现异常就会返回null
    
    }

    查询数据

    • **首先根据所得的Connection对象创建Statement对象:Statement statement = connection.createStatement();

    • 写查询语句:String sql="select * from student;"这里是查询所有student中的数据,详细内容请看我的SQL干货篇二

    • 创建ResultSet对象存储查询结果:ResultSet res=statement.executeQuery(sql),详细的内容请看官方文档ResultSet详细用法

    代码

        String sql="select * from student";
        if(!conn.isClosed())
        {
            Statement statement=conn.createStatement();   //这里的conn是上面连接数据库的返回的Connection对象
            ResultSet res=statement.executeQuery(sql);   //执行查询,注意这里只能是executeQuery,Statement还有一些执行mysql函数,但是都不适合查询,后面会详细说
            while(res.next())    //如果res结果中还有元素,那么返回true,否则返回的是false,用来判断是否res中还有结果
            {
                int id=res.getInt("id");    //得到id,这里的id是student表中的属性名 对应的时int BigInt smallint.....
                String name=res.getString("name");  //得到姓名,对应的是mysql中的Char varChar类型
            }
        }

    当然上面只是对于基本的查询数据,在一些项目中根本用不到,因为不太灵活,上面的方法只适合全局查询,并不适合在项目中根据条件查询,下面介绍预编译sql语句的接口PrepareStatement

    • 首先编写sql语句:sql="select * from student where id=?;";,这里的?表示一个占位,将条件在后面给出,但是这里一定要用?

    • 创建对象:PrepareStatement pre=conn.preparestatement(sql);这里传入参数sql

    • 设置sql中的条件语句,填补占位?的值:pre.setInt(1,1);这里的SetInt设置id值的为1,因为这的idint类型的,第一个参数是表示prepareindex,就是表示第一个占位?,当然第二个就是2,其中还有SetString(prepareindex String var),用来给定表中的char后者varchar类型的值

    代码:

    if(!connection.isClosed())
                    {
                        String sql="select * from course where id=?,name=?";      
                        PreparedStatement preparedStatement=connection.prepareStatement(sql);
                        preparedStatement.setInt(1,1);    //给定条件中的值
                        prepareStatement.setString(2,"jack");  //为第二个?赋值
                        ResultSet res=preparedStatement.executeQuery();    //执行查询,返回的仍然是ResultSet对象
                        while(res.next())
                        {
                            int id=res.getInt("id");
                            String name=res.getString("name");
                            System.out.println(id+"--"+name);
                        }
                    }

    插入数据

    插入数据和上面的两种方法基本是一样的,不同的是mysql语句不同,还有的就是执行语句改成了executeUpdate(sql),下面的代码值给出了预编译对象的方法,另外一种的方法使用范围并不是很大,只要把上面的查询改为executeUpdate即可

    代码:

     public static int save(MemoBean memo) {
            String sql = "insert into student (username, title, content, momotype, memotime) values (?, ?, ?, ?, ?);";
            Connection conn = getConnection();
            PreparedStatement ps = null;
            try {
                ps = conn.prepareStatement(sql);
                ps.setString(1, memo.getUsername());     //设值value中的值 
                ps.setString(2, memo.getTitle());
                ps.setString(3, memo.getContent());
                ps.setString(4, memo.getMemotype());
                ps.setString(5, memo.getMemotime());
                return ps.executeUpdate();     //这里使用的是excuteUpdate
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                if (ps != null) {
                    try {
                        ps.close();   //关闭预编译对象
                    } catch (SQLException e) { 
                        e.printStackTrace();   
                    }
                }
                if (conn != null) {
                    try {
                        conn.close();       //关闭Connection对象
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            } 
            return -1;          //没有插入成功返回-1
        }
    

    更新数据

    这里是同样的思路,和插入的基本是一样,只需要改变sql语句即可

    代码:

    public static int update(MemoBean memo) {
            String sql = "update student set username=?,title=?,content=?,momotype=?,memotime=? where id=?;";//查询语句
            Connection connection = getConnection();
            PreparedStatement ps = null;
            try {
                ps = connection.prepareStatement(sql);
                ps.setString(1, memo.getUsername());    //设置条件语句中的值
                ps.setString(2, memo.getTitle()); 
                ps.setString(3, memo.getContent());
                ps.setString(4, memo.getMemotype());
                ps.setString(5, memo.getMemotime());
                ps.setInt(6,memo.getId());
                return ps.executeUpdate();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            finally {
                if(ps!=null)
                {
                    try {
                        ps.close();
                    }catch (SQLException e)
                    {
                        e.printStackTrace();
                    }
                }
                if(connection!=null)
                {
                    try {
                        connection.close();
                    }catch (SQLException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
            return -1;
        }
    

    最后说

    • 上面的代码是从自己项目中截取的一部分代码,这个是比较适用于面向对象的,也是最常用的对于目前来看

    • 上面只是给出了查询,插入,更新,因为这是最常用到的方法,其中还有创建表,删除表,当然还有一些他的,这里的创建表直接用execute(sql)即可执行,删除表也是用execute(sql)即可执行,当然如果要按照指定的条件删除,那么可以使用预编译对象执行

    • 其中executeUpdate(sql)适用于create,insert,update,delete,但是executeQuery(sql)适用于select,具体见官方文档

    欢迎浏览本人博客

    展开全文
  • Java进阶(二十五)Java连接mysql数据库(底层实现) 前言 很长时间没有系统的使用java做项目了。现在需要使用java完成一个实验,其中涉及到java连接数据库。让自己来写,记忆中已无从搜索。特将之前使用的方法做一简单...

    Java进阶(二十五)Java连接mysql数据库(底层实现)

    前言

          很长时间没有系统的使用java做项目了。现在需要使用java完成一个实验,其中涉及到java连接数据库。让自己来写,记忆中已无从搜索。特将之前使用的方法做一简单的总结。也能够在底层理解一下连接数据库的具体步骤。

    实现

          首先需要导入相关的jar包,我使用的为:mysql-connector-java-5.1.7-bin.jar。

          下面来看一下我所使用的数据库连接方法类:

    MysqlUtil.java

     

    package cn.edu.ujn.util;
     
    import java.lang.reflect.Field;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.ResultSetMetaData;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
     
    import cn.edu.ujn.base.Const;
    import cn.edu.ujn.dao.UserDao;
    import cn.edu.ujn.model.User;
     
    public class MysqlUtil {
    // 定义数据库的用户名
    private final static String USERNAME = Const.USERNAME;
    // 定义数据库的密码
    private final static String PASSWORD = Const.PASSWORD;
    // 定义数据库的驱动信息
    private final String DRIVER = Const.DRIVER;
    // 定义访问数据库的地址
    private final static String URL = Const.URL;
    // 定义数据库的链接
    private static Connection connection;
    // 定义sql语句的执行对象
    private static PreparedStatement pstmt;// 只有在获得了Statement之后才可执行SQL语句
    // 定义查询返回的结果集合
    private static ResultSet resultset;
     
    public MysqlUtil() {
     
    try {
    Class.forName(DRIVER);// 显式地加载 JDBC 驱动程序
    System.out.println("注册驱动成功!");
    } catch (Exception e) {
    System.out.println("注册驱动失败!");
    }
    }
     
    /**
     * 定义获得数据库的链接,试图建立到给定数据库 URL 的连接
     * 
     * @return connection
     */
    public static Connection GetConnection() {
     
    try {
    connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
    System.out.println("数据库连接成功!");
    } catch (Exception e) {
    System.out.println("数据库连接失败!");
    }
    return connection;
    }
     
    /**
     * 完成对数据库表的增加、删除、更新操作
     * 
     * @param sql
     * @param params
     * @return flag
     * @throws SQLException
     */
    public static boolean updateByPreparedStatement(String sql, List<Object> params)// 第二个参数为传输的占位符
    throws SQLException {
     
    //加载数据库驱动
    new MysqlUtil();
    //连接数据库
    MysqlUtil.GetConnection();
    boolean flag = false;
     
    // 表示当用户执行添加、删除、修改时所影响数据库的行数
    int result = -1;
    try {
    pstmt = connection.prepareStatement(sql);
    } catch (Exception e) {
    System.out.println("Error in updateByPreparedStatement!");
    }
     
    // 表示占位符的第一个位置
    int index = 1;
     
    // 判断所填充的占位符是否有值;判断集合的标准方式
    if (params != null && !params.isEmpty()) {
    for (int i = 0; i < params.size(); i++) {
    // System.out.println(i+"    "+params.get(i));
    // 使用给定对象设置指定参数的值。第二个参数必须是Object类型
    pstmt.setObject(index++, params.get(i));
    }
    }
    result = pstmt.executeUpdate();// 用于执行DML语句-返回一个整数,代表被SQL语句影响的记录条数
    flag = result > 0 ? true : false;
    System.out.println("执行SQL语句影响的记录条数为:" + result);
    //关闭数据库
    MysqlUtil.releaseConn();
    return flag;
    }
    /**
     * 查询返回单条记录
     * 
     * @param sql
     * @param params
     * @return map
     * @throws SQLException
     */
    public static Map<String, Object> findSimpleResult(String sql, List<Object> params)
    throws SQLException {
     
    //加载数据库驱动
    new MysqlUtil();
    //连接数据库
    MysqlUtil.GetConnection();
    // 菱形语法在Java7及以后可用
    Map<String, Object> map = new HashMap<String, Object>();
     
    // 表示占位符的第一个位置
    int index = 1;
     
    // 此句很重要,需要进行预编译
    pstmt = connection.prepareStatement(sql);
     
    // 判断所填充的占位符是否有值;判断集合的标准方式
    if (params != null && !params.isEmpty()) {
    for (int i = 0; i < params.size(); i++) {
     
    // 第一个是指你SQL语句中的第几个参数,第二个是要设置的值
    pstmt.setObject(index++, params.get(i));
    }
    }
     
    // 返回查询结果
    resultset = pstmt.executeQuery();
     
    // 获取此 ResultSet 对象的列的编号、类型和属性。
    java.sql.ResultSetMetaData metdata = resultset.getMetaData();
     
    // 获取列数
    int col_lenth = metdata.getColumnCount();
    boolean flag = resultset.next();
    if (!flag) {
    System.out.println("Found nothing!");
    }
    while (resultset.next()) {
    for (int i = 0; i < col_lenth; i++) {
     
    // 获取指定列的名称
    String cols_name = metdata.getColumnName(i + 1);
     
    // 通过列名获得指定列的属性值
    Object cols_value = resultset.getObject(cols_name);
    if (cols_value == null) {
     
    // 由此可见,数据表中字段值不能为空
    cols_value = "";
    }
     
    // 将指定的值与此映射中的指定键关联(可选操作)。
    map.put(cols_name, cols_value);
    }
    }
    //关闭数据库
    MysqlUtil.releaseConn();
    return map;
    }
     
    /**
     * 通过反射机制访问数据库,查询前几页的内容
     * 
     * @param sql
     * @param params
     * @param cls
     * @return
     * @throws Exception
     */
    public static <T> List<T> queryEvamall(String sql, List<Object> params,
    Class<T> cls) throws Exception {
     
    //加载数据库驱动
    new MysqlUtil();
    //连接数据库
    MysqlUtil.GetConnection();
    // 构造一个初始容量为 10 的空列表。
    List<T> list = new ArrayList<T>();
     
    // 表示占位符的第一个位置
    int index = 1;
     
    pstmt = connection.prepareStatement(sql);
     
    // 判断所填充的占位符是否有值;判断集合的标准方式
    if (params != null && !params.isEmpty()) {
    for (int i = 0; i < params.size(); i++) {
     
    // 使用给定对象设置指定参数的值。第二个参数必须是Object类型
    pstmt.setObject(index++, params.get(i));
     
    }
    }
     
    // 返回查询结果
    resultset = pstmt.executeQuery();
     
    // 获取列的相关信息
    java.sql.ResultSetMetaData metdata = resultset.getMetaData();
     
    // 获取列数
    int col_lenth = metdata.getColumnCount();
    while (resultset.next()) {
     
    // 通过反射机制创建一个实例
    T resultObject = cls.newInstance();
    for (int i = 0; i < col_lenth; i++) {
    String cols_name = metdata.getColumnName(i + 1);
    Object cols_value = resultset.getObject(cols_name);
    if (cols_value == null) {
    cols_value = "";
    }
     
    // 通过列名获得反射
    Field field = cls.getDeclaredField(cols_name);
     
    // 打开javabean的私有访问权限
    field.setAccessible(true);
    field.set(resultObject, cols_value);
    }
    list.add(resultObject);
    }
    //关闭数据库
    MysqlUtil.releaseConn();
    return list;
    }
    /**
     * 查询返回多条查询记录
     * 
     * @param sql
     * @param params
     * @return
     * @throws SQLException
     */
    public static List<Map<String, Object>> findMoreResult(String sql,
    List<Object> params) throws SQLException {
    //加载数据库驱动
    new MysqlUtil();
    //连接数据库
    MysqlUtil.GetConnection();
    System.out.println("JJ");
    List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
    // 表示占位符的第一个位置
    int index = 1;
    pstmt = connection.prepareStatement(sql);
    // 判断所填充的占位符是否有值;判断集合的标准方式
    if (params != null && !params.isEmpty()) {
    for (int i = 0; i < params.size(); i++) {
    pstmt.setObject(index++, params.get(i));// 使用给定对象设置指定参数的值。第二个参数必须是
    // Object类型
    }
    }
    try {
    resultset = pstmt.executeQuery();// 返回查询结果
    } catch (Exception e) {
    System.out.println("Error1!");// 调试用
    }
    ResultSetMetaData metdata = resultset.getMetaData();// 获取列的相关信息
    int col_lenth = metdata.getColumnCount();// 获取列数
    System.out.println("数据表列数为:" + col_lenth);// 调试用
    while (resultset.next()) {
    Map<String, Object> map = new HashMap<String, Object>();
    for (int i = 0; i < col_lenth; i++) {
    String cols_name = metdata.getColumnName(i + 1);// 获取列的名称,列从1开始
    Object cols_value = resultset.getObject(cols_name);
    if (cols_value == null) {
    cols_value = "";
    }
    map.put(cols_name, cols_value);
    }
    list.add(map);
    }
    //关闭数据库
    MysqlUtil.releaseConn();
    return list;
    }
     
    /**
     * jdbc的封装可以使用反射机制来封装 使用泛型方法
     * 
     * @param sql
     * @param params
     * @param cls
     * @return
     * @throws Exception
     */
    public static <T> T findSimpleRefResult(String sql, List<Object> params,
    Class<T> cls) throws Exception {
    //加载数据库驱动
    new MysqlUtil();
    //连接数据库
    MysqlUtil.GetConnection();
    T resultObject = null;
     
    // 表示占位符的第一个位置
    int index = 1;
    pstmt = connection.prepareStatement(sql);
     
    // 判断所填充的占位符是否有值;判断集合的标准方式
    if (params != null && !params.isEmpty()) {
    for (int i = 0; i < params.size(); i++) {
     
    // 第一个是指你SQL语句中的第几个参数,第二个是要设置的值
    pstmt.setObject(index++, params.get(i));
    }
    }
     
    // 返回查询结果
    resultset = pstmt.executeQuery();
     
    // 获取列的相关信息
    java.sql.ResultSetMetaData metdata = resultset.getMetaData();
     
    // 获取列数
    int col_lenth = metdata.getColumnCount();
    while (resultset.next()) {
     
    // 通过反射机制创建一个实例
    resultObject = cls.newInstance();
     
    for (int i = 0; i < col_lenth; i++) {
    String cols_name = metdata.getColumnName(i + 1);
    Object cols_value = resultset.getObject(cols_name);
    if (cols_value == null) {
    cols_value = "";
    }
    Field field = cls.getDeclaredField(cols_name);
     
    // 打开javabean的私有访问权限
    field.setAccessible(true);
    field.set(resultObject, cols_value);
    }
     
    }
    //关闭数据库
    MysqlUtil.releaseConn();
    return resultObject;
    }
     
    /**
     * 通过反射机制访问数据库
     * 
     * @param sql
     * @param params
     * @param cls
     * @return
     * @throws Exception
     */
    public static <T> List<T> findMoreRefResult(String sql, List<Object> params, Class<T> cls) throws Exception {
     
    //加载数据库驱动
    new MysqlUtil();
    //连接数据库
    MysqlUtil.GetConnection();
    // 构造一个初始容量为 10 的空列表。
    List<T> list = new ArrayList<T>();
     
    // 表示占位符的第一个位置
    int index = 1;
     
    pstmt = connection.prepareStatement(sql);
     
    System.out.println("MysqlUtil:" + params);
    // 判断所填充的占位符是否有值;判断集合的标准方式
    if (params != null && !params.isEmpty()) {
    for (int i = 0; i < params.size(); i++) {
     
    // 使用给定对象设置指定参数的值。第二个参数必须是Object类型
    pstmt.setObject(index++, params.get(i));
     
    }
    }
     
    // 返回查询结果
    System.out.println("SHQ");
    resultset = pstmt.executeQuery();
    // 获取列的相关信息
    java.sql.ResultSetMetaData metdata = resultset.getMetaData();
     
    // 获取列数
    int col_lenth = metdata.getColumnCount();
    while (resultset.next()) {
     
    // 通过反射机制创建一个实例
    T resultObject = cls.newInstance();
    for (int i = 0; i < col_lenth; i++) {
    String cols_name = metdata.getColumnName(i + 1);
    Object cols_value = resultset.getObject(cols_name);
    if (cols_value == null) {
    cols_value = "";
    }
     
    // 通过列名获得反射
    Field field = cls.getDeclaredField(cols_name);
     
    // 打开javabean的私有访问权限
    field.setAccessible(true);
    field.set(resultObject, cols_value);
    }
    list.add(resultObject);
    }
    //关闭数据库
    MysqlUtil.releaseConn();
    return list;
    }
     
    /**
     * 关闭数据库的链接
     * 
     */
    public static void releaseConn() {
     
    if (resultset != null) {
    try {
    resultset.close();
    } catch (SQLException e) {
    e.printStackTrace();
    }
    }
    if (pstmt != null) {
    try {
    pstmt.close();
    } catch (SQLException e) {
    e.printStackTrace();
    }
    }
    if (connection != null) {
    try {
    connection.close();
    } catch (SQLException e) {
    e.printStackTrace();
    }
    }
    }
     
    /**
     * 查询返回总页数
     * 
     * @param sql
     * @param params
     * @return int
     * @throws SQLException
     */
    public static int cluPage(String sql, List<Object> params)
    throws SQLException {
     
    //存储总页数 
    int countPage = 0;
    //设置每页显示的记录数
    int size = 10;
    //加载数据库驱动
    new MysqlUtil();
    //连接数据库
    MysqlUtil.GetConnection();
    // 表示占位符的第一个位置
    int index = 1;
    // 此句很重要,需要进行预编译
    pstmt = connection.prepareStatement(sql);
    // 判断所填充的占位符是否有值;判断集合的标准方式
    if (params != null && !params.isEmpty()) {
    for (int i = 0; i < params.size(); i++) {
     
    // 第一个是指你SQL语句中的第几个参数,第二个是要设置的值
    pstmt.setObject(index++, params.get(i));
    }
    }
     
    // 返回查询结果
    resultset = pstmt.executeQuery();
    if (resultset.next()) {
    int total = resultset.getInt("total");
    countPage = (total%size  == 0 ? total/size : total/size + 1);
    }
    //关闭数据库
    MysqlUtil.releaseConn();
    System.out.println("总页数为:" + countPage);
    return countPage;
    }
    /**
     * 测试模块
     * 
     * @param args
     */
    public static void main(String[] args) {
    User user = new User();
    user.setUid("18353102068");
    user.setLogin_time("1");
    user.setOut_time("1");
    user.setLast_time(10);
    System.out.println(new UserDao().add(user));
    }
    }

     

          以上介绍了数据库的连接方法及常用的查询操作。

          其中的常量如下定义:

    Const.java

     

    package cn.edu.ujn.base;
     
    public class Const {
    // 定义数据库的IP
    public final static String IP = "localhost";
    // 定义数据库的端口
    public final static String DBPORT = "3308";
    // 定义数据库的名称
    public final static String DBNAME = "lab";
    // 定义数据库的用户名
    public final static String USERNAME = "lmapp";
    // 定义数据库的密码
    public final static String PASSWORD = "lmapp";
    // 定义数据库的驱动信息
    public final static String DRIVER = "com.mysql.jdbc.Driver";
    // 定义访问数据库的地址
    public final static String URL = "jdbc:mysql://" + IP + ":" + DBPORT + "/" + DBNAME;
    }

     

          以上只是实现了java连接到数据库,要实现数据的插入等操作,还需要以下方法:

    UserDao.java

     

    package cn.edu.ujn.dao;
     
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
     
    import cn.edu.ujn.model.User;
    import cn.edu.ujn.util.MysqlUtil;
     
    public class UserDao {
     
    MysqlUtil mysqlUtil = new MysqlUtil();
     
    /**
     * 添加用户信息
     * 
     * @param user
     * @return
     */
    public int add(User user) {
    try {
    String sql = "insert into lab_static_attribute(uid,login_time,out_time,last_time) values(?,?,?,?)";
    List<Object> params = new ArrayList<Object>();
    params.add(user.getUid());
    params.add(user.getLogin_time());
    params.add(user.getOut_time());
    params.add(user.getLast_time());
    return MysqlUtil.updateByPreparedStatement(sql, params) ? 1 : 0;
    }catch (SQLException e) {
    return 0;
    } 
    }
    }

     

          这里只是介绍了数据的增加方法,数据库的CRUD其它三种操作方法,请读者自行练习。

    总结

          相比于框架实现数据库的操作,这里介绍的方法确实需要完成更多的代码。但是对于初学者来说,还是建议通过这种方法来完成数据库的操作。这样可以更多的了解数据库操作的底层操作行为。学知识讲究“知其然,更要知其所以然”。

    美文美图

     

    展开全文
  • Java连接MySQL数据库步骤

    万次阅读 多人点赞 2019-08-31 17:10:47
    Java连接MySQL数据库步骤 声明,只推荐你看代码学会我的步骤,逻辑,还有用的所有方法 第一, ​ 安装mysql数据库配置(https://www.jianshu.com/p/ea4accd7afb4),安装还有配置教程,按照步骤来肯定没错,里面是...

    Java连接MySQL数据库步骤

    声明,只推荐你看代码学会我的步骤,逻辑,还有用的所有方法

    第一,

    ​ 安装mysql数据库配置(https://www.jianshu.com/p/ea4accd7afb4),安装还有配置教程,按照步骤来肯定没错,里面是win10的mysql解压版安装教程,设置账号密码是一定要注意 :账号一般为root,密码一般为 123456 ,如果你要更改的话一定要记住,因为后面连接需要用到(切记),如果忘了会很麻烦。

    第二,

    ​ 如果是新手的话推荐学一下mysql的语法,认真的话一个星期学会绝对没问题(菜鸟教程网站),学会基本的查询当前电脑有的数据库,使用数据库,创建数据库,创建表,查看数据库中的表,还有对表的增删改查语法,新手不推荐使用视图软件,要记住操作mysql的代码,可以先在 cmd 黑框框中写操作数据库的代码。

    如果要用视图软件的话推荐下一个navicat破解版,自己用可以,不能商用。

    第三,

    ​ 下来就要用java编译器连接数据库了(java连接数据库又叫JDBC)。

    mysql提供的第三方java包,里面配置了连接java连接mysql的默认配置和驱动

    链接:https://pan.baidu.com/s/1Z_ztiTEGloX7r3ilZoZsCg
    提取码:0f1s

    创建项目->

    在这里插入图片描述

    创建文件夹起名为lib(把上面下载的包复制到lib文件夹下,直接复制粘贴就好了)->

    在这里插入图片描述

    鼠标右击复制过来的包导入项目导为jar包(在后面写连接代码时可以直接用)->

    在这里插入图片描述
    在这里插入图片描述

    导入成功是这样子
    在这里插入图片描述

    创建两个包,一个存放连接数据库的代码,一个存放数据库中的表信息(pojo)

    com.pojo在这个包里创建的类用来存放你的表中字段,存放实体类,必须满足javaBean(一个表就是一个类,类中属性就是表中字段)
    在这里插入图片描述

    连接步骤(这个很重要)(代码中都有注释):

    1.导jar包,前面已经导过了

    2.在连接类里写代码,加载mysql驱动(要写在代码块里,因为要连接必须最先加载驱动),代码块在加载类时就执行,在构造方法之前(注意是代码块{},不是方法)

    //连接信息	
    private String userName = "root";//这里是你最开始刚下载mysql是输入的账号
    	private String password = "123456";//这里是你最开始mysql设置的密码,
    	private String url = "jdbc:mysql://localhost:3306/testdatabase";
    //数据库连接信息,
    //第一个是java连接数据库协议,中间的是要连接的ip地址和端口号,localhost是本地ip,后面的是你要连接的数据库的名字,我要连接数据库的名字叫testdatabase
    	
    
    
    {
    		try {
        	//这里不用更改,如果你要连的不是mysql的话再换这个括号内的代码
    			Class.forName("com.mysql.jdbc.Driver");
    			System.out.println("驱动加载成功!");
    		} catch (ClassNotFoundException e) {
    			// TODO Auto-generated catch block
    			System.out.println("加载失败!");
    			e.printStackTrace();
    		}
    
    }

    3.创建连接数据库(这里在构造方法里连接)

    public DataBaseConnection() {
    		// TODO Auto-generated constructor stub
    		try {
    			this.connection =  DriverManager.getConnection(url, userName, password);//把上面的三个属性传过来,应该就连接成功了,不成功的话应该就是你的账号密码不正确
    			System.out.println("数据库连接成功!");
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			System.out.println("连接失败!");
    		}
    	}

    4.第四步就是操作数据库了

    这里写一个往数据库里增加数据的代码

    创建方法名叫insert

    先想步骤

    ​ 1.写sql语句(就是你们在菜鸟教程里学的sql语句),菜鸟教程是个非常好的网站

    ​ 2.从连接中获得操作数据库句柄

    ​ 3.设置参数

    ​ 4.就是执行sql语句了

    //这里传一个类对象参数Emp emp,就相当于String str 差不多
    //都是引用数据类型,类,数组,接口
    public void insert(Emp emp){
    		//1.写sql语句
    		String str = "INSERT emp VALUES (?,?,?,?,?,?,?,?)";
    		PreparedStatement ps = null;
    		//2.获取操作数据库句柄
    		try {
    			//把操作数据库返回的结果保存到ps中
    			ps = connection.prepareStatement(str);

    		//3.设置参数
    		ps.setInt(1, emp.getEmpno());
    		ps.setString(2, emp.getEname());
    		ps.setString(3, emp.getJob());
    		ps.setInt(4, emp.getMgr());
    		ps.setDate(5, emp.getDate());
    		ps.setInt(6, emp.getSal());
    		ps.setInt(7, emp.getComm());
    		ps.setInt(8, emp.getDeptno());
    		
    		//4.执行sql语句
    		int len = ps.executeUpdate();
    		System.out.println("修改成功,共影响了"+ len +"行!");
    	} catch (SQLException e) {
    		// TODO Auto-generated catch block
    		e.printStackTrace();
    	}finally{
    		if(ps != null){
    			try {
    				ps.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    
    	//关闭数据库的方法
    	public void closeConnection(){
    		if(connection != null){
    			try {
    				connection.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    }
    

    我的Emp类,就是我存放数据库中emp表中字段的类(你要按照你的数据库中字段来创建类)

    ​ private Integer empno;//因为Integer类型可以判断是否为空
    ​ private String ename;
    ​ private String job;
    ​ private Integer mgr;
    ​ private Date hiredate;
    ​ private Integer sal;
    ​ private Integer comm;
    ​ private Integer deptno;

    public Emp() {
    	// TODO Auto-generated constructor stub
    }
    
    //创建有参构造方法,方便赋值
    public Emp(Integer empno, String ename, String job, Integer mgr, Date hiredate, Integer sal, Integer comm,
    		Integer deptno) {
    	super();
    	this.empno = empno;
    	this.ename = ename;
    	this.job = job;
    	this.mgr = mgr;
    	this.hiredate = hiredate;
    	this.sal = sal;
    	this.comm = comm;
    	this.deptno = deptno;
    }
    
    
    public Integer getEmpno() {
    	return empno;
    }
    
    public void setEmpno(Integer empno) {
    	this.empno = empno;
    }
    
    public String getEname() {
    	return ename;
    }
    
    public void setEname(String ename) {
    	this.ename = ename;
    }
    
    public String getJob() {
    	return job;
    }
    
    public void setJob(String job) {
    	this.job = job;
    }
    
    public Integer getMgr() {
    	return mgr;
    }
    
    public void setMgr(Integer mgr) {
    	this.mgr = mgr;
    }
    
    public Date getHiredate() {
    	return hiredate;
    }
    
    public void setHiredate(Date hiredate) {
    	this.hiredate = hiredate;
    }
    
    public Integer getSal() {
    	return sal;
    }
    
    public void setSal(Integer sal) {
    	this.sal = sal;
    }
    
    public Integer getComm() {
    	return comm;
    }
    
    public void setComm(Integer comm) {
    	this.comm = comm;
    }
    
    public Integer getDeptno() {
    	return deptno;
    }
    
    public void setDeptno(Integer deptno) {
    	this.deptno = deptno;
    }
    //重写toString方法,方便测试,因为输出的是一个对象的话,java默认调用toString方法
    @Override
    public String toString() {
    	return "Emp [empno=" + empno + ", ename=" + ename + ", job=" + job + ", mgr=" + mgr + ", date=" + hiredate
    			+ ", sal=" + sal + ", comm=" + comm + ", deptno=" + deptno + "]";
    }

    最后创建一个测试类(Test),包含main方法,在main方法里写

    在这里插入图片描述

    
    
    	DataBaseConnection dbs = null;
    
    try{
    
    	//创建连接数据库类对象
    
    	dbs = new DataBaseConnection();
    
    	//创建你的表类对象,表类对象就是你存放在pojo中的类,存放表中字段的类,例如我的类为Emp
    
    	//把类中的属性赋值
    
    	Emp emp = new Emp8889, "刘备", "股东", 0, new    							Date(System.currentTimeMillis()), 110, 1000000, 100);                   
    
    	//调用你写的insert类,里面把类对象传进去
    
    	 dbs.insert(emp);
    
    }finally{
    
    //奥,对了,为了防止资源浪费,不管你程序执没执行成功,你都必须关闭数据库
    
    	//需要在你的连接类中写一个关闭数据库的方法
    
    	//上面的代码中我又添加上了,就不用你写了
    
    	dbs.closeConnection();
    
    }

    最后你再查看你数据库中表中数据应该就插入了一条记录。

    ​ 再次强调,只推荐你看代码学会我的步骤,逻辑,还有用的所有方法,千万不要拷贝拿去用,因为就算你跟我的一模一样,你还是不懂。

    ​ 如果学习过程中有什么麻烦就请加我qq交流。

    作者qq:1271224158

    展开全文
  • 1、java连接mysql 2、java查询mysql数据。 3、java插入mysql数据。 4、java更新mysql数据。 5、java删除mysql数据。 6、java执行mysql存储过程。 ide: IntelliJ IDEA2017 这里必不可少的需要导入mysql-connector

    做java开发不可避免要处理数据库,所以这里写篇用jdbc来连接mysql的文章,java是一种高性能,通用的语言 。这使得它适合于编写高效的ETL生产代码和计算密集型的机器学习算法。
    主要内容包括:

    • 1、java连接mysql
    • 2、java查询mysql数据。
    • 3、java插入mysql数据。
    • 4、java更新mysql数据。
    • 5、java删除mysql数据。
    • 6、java执行mysql存储过程。

    ide: IntelliJ IDEA2017

    这里必不可少的需要导入mysql-connector-java-5.1.45-bin.jar包。
    maven加载驱动

     <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.45</version>
        </dependency>

    添加maven依赖好之后,编译build,就自动加载 驱动好了。

    下面是java操作mysql代码:

    package DataStructureAndAlgorithm;
    
    /**
     * Created by Administrator on 2017/12/24.
     */
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    
    public class test6JavaJdbc {
        public static void main(String[] args) {
            Connection con;
            String driver="com.mysql.jdbc.Driver";
            //这里我的数据库是cgjr
            String url="jdbc:mysql://localhost:3306/cgjr?useUnicode=true&characterEncoding=utf-8&useSSL=false";
            String user="root";
            String password="12345";
            try {
                Class.forName(driver);
                con = DriverManager.getConnection(url, user, password);
                if (!con.isClosed()) {
                    System.out.println("数据库连接成功");
                }
                Statement statement = con.createStatement();
    
    //            执行查询语句
                String sql = "select * from persons;";//我的表格叫persons
                ResultSet resultSet = statement.executeQuery(sql);
    
    
    //            打印查询出来的东西
                String name;
                String num;
                while (resultSet.next()) {
                    name = resultSet.getString("name");
                    num = resultSet.getString("num");
                    System.out.println(name+'\t'+num);
                }
    
    
                //            执行插入语句
                String sql2="INSERT INTO `persons` (`name`, `num`) VALUES ('徐志摩', '45');";
                statement.executeUpdate(sql2);
    
    //                       执行更新语句
                String sql3="UPDATE persons set num=66 WHERE `name`=\"徐志摩\"";
                statement.executeUpdate(sql3);
    
    
    
    //               执行删除语句
                String sql4="delete from persons WHERE `name`=\"徐志摩\"";
                statement.executeUpdate(sql4);
    
    //            执行调用存储过程
    
                String sql5="call add_student(3)";
                statement.executeUpdate(sql5);
    
    
    //            关闭连接
                resultSet.close();
                con.close();
                System.out.println("数据库已关闭连接");
            } catch (ClassNotFoundException e) {
                System.out.println("数据库驱动没有安装");
    
            } catch (SQLException e) {
                System.out.println("数据库连接失败");
            }
        }
    }
    

    运行结果:

    数据库连接成功
    zhangsan    20
    laidefa 243  57
    徐志摩 66
    数据库已关闭连接
    
    Process finished with exit code 0
    
    展开全文
  • java连接mysql数据库

    2017-08-06 11:09:28
    java连接mysqljava连接mysql的一个小demo,如有疑问请留言。
  • java连接mysql数据库 以及java连接sql server数据库 在java的应用中,我们经常会对数据库进行必要的操作,下来我们就了解一下java连接mysql数据库 以及java连接sql server数据库的具体步骤吧 一、mysqlimport java...
  • Java连接 MySQL8.0数据库连接字符串

    千次阅读 2020-12-16 18:24:27
    Java连接 MySQL8.0数据库连接字符串
  • java连接Mysql8.0.11

    万次阅读 2018-06-03 13:09:25
    java连接Mysql8.0.11与之前版本有些不同。其中加载驱动为com.mysql.cj.jdbc.Driverurl为jdbc:mysql://localhost/student?useSSL=FALSE&amp;serverTimezone=UTC(student为数据库的名字)代码如下:package study...
  • Java连接Mysql数据库

    万次阅读 多人点赞 2017-12-17 18:32:23
     Mysql作为一个良好的数据库系统,可以在java中连接使用,接下来我们讲介绍Java连接Mysql的过程,当然这里重点不是讲解Mysql的安装与配置(一般想要使用Mysql连接Java的小伙伴,应该都是对Mysql有所了解后才会想到...
  • Linux Java连接MySQL数据库

    千次阅读 2019-02-04 16:41:49
    Linux Java连接MySQL数据库
  • Go ahead. Take a chance. 去吧,去抓住机会! 你是否像我一样,学了java,学过数据库,但却从来没有使用java连接过数据库?如果是,那么continue,如果否,那么你可以return;...java连接mysql数据库相关...
  • 这里写自定义目录标题Java连接MySql详细教程eclipse连接5.0+的MySql数据库eclipse连接8.0+的MySql数据库idea连接MySql Java连接MySql详细教程 这个是关于使用idea,eclipse连接mysql数据库的教程 eclipse连接5.0+的...
  • java连接MySQL8.0

    2019-05-25 22:58:18
    标题:java连接MySQL8.0的配置 **1.驱动 com.mysql.cj.jdbc.Driver 2.url jdbc:mysql://localhost:3306/firstsql?characterEncoding=utf-8&&serverTimezone=UTC&&useSSL=false 3.jar mysql-...
  • java连接MySQL数据库方法

    千次阅读 2018-01-01 22:10:09
    java连接MySQL数据库,用eclipse连接MySQL数据库。
  • Java 连接 MySQL 数据库方法

    千次阅读 2018-09-17 18:02:33
    Java 连接 MySQL 数据库方法 Java 连接 MySQL 数据库方法 1、传统的连接方式 2、读取配置文件方式 3、c3p0连接连接数据库 4、数据库连接池 1、传统的连接方式 导入mysql-connector...
  • java连接mysql8

    千次阅读 2018-06-26 11:59:04
    java连接mysql8与之前的mysql5.7有部分不同1,url连接语句:jdbc:mysql://127.0.0.1:3306/data?useSSL=false&amp;serverTimezone=UTC //data为数据库2,mysql驱动包路径:com.mysql.cj.jdbc.Driver //之前为...
  • Java连接MySQL8

    2018-09-21 09:38:17
    java连接Mysql8.0.11与之前版本有些不同 其中driver:com.mysql.cj.jdbc.Driver url:jdbc:mysql://localhost/student?useSSL=FALSE&amp;serverTimezone=UTC(student为数据库的名字)
  • java连接mysql5.5的jar包

    2015-08-20 15:39:31
    java连接mysql5.5的jar包 mysql-connector-java-5.1.35-bin.jar
  • 【Java】Java连接Mysql数据库的demo示例

    千次阅读 2019-11-10 11:38:56
    【Java】Java连接Mysql数据库的demo示例 1.安装mysql数据库 2.下载java-mysql-connector.jar包 3.完成java配置 4.写java代码运行测试 1.安装mysql数据库 这里不多重复,我主要讲解java连接mysql数据库并写代码运行...
  • 《Java》《MySQL》Java连接MySQL数据库

    千次阅读 2018-08-23 19:44:39
    Java连接MySQL数据库 与MySQL的连接同样要通过JBDC来实现。附上下载地址:MySQL-JDBC 下载完成后将“.zip”文件解压,可以得到mysql-connector-java-5.1.46-bin.jar文件。 mysql-jdbc添加方法:     ...
  • Java连接Mysql报错

    千次阅读 2018-07-02 19:36:40
    Java连接Mysql报错集锦 一.错误: 1.Error:java.lang.ClassNotFoundException: com.mysql.jdbc.Driver 2.Cause:数据库连接的jar包没有正确的导入: 3.Solution: 1、没有导入包 2、导入的包的路径是...
  • java连接mysql数据库的详细步骤

    万次阅读 多人点赞 2016-11-28 15:48:07
    java连接mysql数据库的详细步骤 连接说明: a、mysql连接的驱动 b、mysql数据库的安装 c、eclipse e、数据库服务是否打开(控制面板——管理工具——服务——找到mysql对应服务) f、创建一个数据库 1、...
  • java连接mysql8.0

    千次阅读 2018-06-23 23:21:17
    java连接MySQL 8.0+ 导入jar包(版本一定要对!!!) 目前官网提供了许多版本的连接器,旧版连接方法很多都不同,搜索很可能搜到旧版的下载链接,一定注意要8.0+版本。 IDEA: file-&gt;Project Structure-&...
  • Java连接MySQL数据库——含步骤和代码

    万次阅读 多人点赞 2019-06-01 23:59:22
     MySQL连接驱动:mysql-connector-java-5.1.27.jar 加载驱动:  1. 在工程目录中创建lib文件夹,将下载好的JDBC放到该文件夹下,如下图所示:    2. 右键工程名,在java build path中的Libraries分页中选择...
  • java连接mysql数据库详细教程

    千次阅读 多人点赞 2018-09-11 19:52:08
    java连接mysql数据库详细教程 工具: 1.eclipse 2.Mysql 3.Mysql 连接驱动 mysql-connector-java-5.1.27.jar 步骤一: 把驱动jar文件复制到项目文件下人, ![图片]...
  • Java 连接 MySQL 8.0 数据库

    千次阅读 2019-09-08 20:07:42
    Java 连接 MySQL 8.0 数据库 1. 准备 1.1 安装 Maven 的驱动包 首先在 pom.xml 的文件中添加如下内容。 <dependencies> <!-- 导入 MySQL 的Maven依赖 --> <dependency> <groupId>mysql...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,874
精华内容 13,149
关键字:

java连接mysql

java 订阅
mysql 订阅