java连接mysql数据库,Java连接MySQL数据库实现用户登录功能

发布时间：2022-11-19

本文目录一览：

  1. java怎么连接mysql
  2. java中连接MySQL数据库的几种方式
  3. 如何使用Java访问MySQL数据库
  4. java是怎么连接mysql数据库的
  5. java连接数据库的代码
  6. java怎么连接mysql数据库

java怎么连接mysql

下面代码是使用jdbc直接链接mysql的操作，链接方式与SQL SERVER类似，区别在于加载的驱动不同，url的设置也有点区别，用户名、密码、端口号这些设置都类似 执行脚本返回的结果，可以看出java成功链接上mysql并获取到返回值 mysql-connector-java-5.1.26-bin.jar是java链接mysql使用的jar包，与SQL SERVER链接也有专门的jar包，jar包中包含了java链接mysql所用到的函数驱动等等，所有的jar包都是放到web工程lib目录下 4 如果工程是整合在ssh下，一般情况下都会有一个properties文件，该文件配置了数据库链接常用的命令，下图是mysql中的配置 使用spring框架下进行的测试，结果可以成功执行，其实无论是sql server还是mysql还是其他的数据库，基本功能都一样，只是语法结构有所区别，java在调用的过程中大部分功能只要切换了数据库链接命令就可以公用，如果系统架构设计的足够好，当我们切换数据库的时候，应用程序是不用调整就能兼容的

java中连接MySQL数据库的几种方式

Java要连接数据库，那么首先你必须安装mysql数据库。 安装好mysql之后，安装JDK了。 安装好JDK之后，就是安装Eclipse了，要支持JDK版本，Eclipse安装的时候会自动去找JDK安装位置的，解压版的Eclipse，就要配置eclipse.ini文件了，将对应的JDK配置好，这些已经准备就绪的时候，就到mysql中创建数据库和表。 先创建数据库：

CREATE DATABASE SCUTCS;

接着，创建表：

CREATE TABLE STUDENT
(
SNO CHAR(7) NOT NULL,
SNAME VARCHAR(8) NOT NULL,
SEX CHAR(2) NOT NULL,
BDATE DATE NOT NULL,
HEIGHT DEC(5,2) DEFAULT 000.00,
PRIMARY KEY(SNO)
);

然后插入数据，可以用SQL语句insert into 表名 values (value1, value2, ...); 编写.java文件来演示一下如何访问MySQL数据库。

import java.sql.*;
public class JDBCTest {
    public static void main(String[] args){
        // 驱动程序名
        String driver = "com.mysql.jdbc.Driver";
        // URL指向要访问的数据库名scutcs
        String url = "jdbc:mysql://127.0.0.1:3306/scutcs";
        // MySQL配置时的用户名
        String user = "root";
        // MySQL配置时的密码
        String password = "root";
        try {
            // 加载驱动程序
            Class.forName(driver);
            // 连续数据库
            Connection conn = DriverManager.getConnection(url, user, password);
            if(!conn.isClosed())
                System.out.println("Succeeded connecting to the Database!");
            // statement用来执行SQL语句
            Statement statement = conn.createStatement();
            // 要执行的SQL语句
            String sql = "select * from student";
            // 结果集
            ResultSet rs = statement.executeQuery(sql);
            while(rs.next())
                // 选择sname这列数据
                name = rs.getString("sname");
            // 输出结果
            System.out.println(rs.getString("sno") + "\t" + name);
            rs.close();
            conn.close();
        } catch(ClassNotFoundException e) {
            System.out.println("Sorry,can`t find the Driver!");
            e.printStackTrace();
        } catch(SQLException e) {
            e.printStackTrace();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}

如何使用Java访问MySQL数据库

第1步 获取Java与MySQL的连接器 第2步 将下载的包存放在自己机器上jdk安装目录下面的jre目录下面的lib目录下面的ext目录中，在程序中导入与数据库操作相关的对象

import java.sql.Connection; //导入数据库连接对象
import java.sql.DriverManager; //导入数据库驱动管理对象
import java.sql.ResultSet; //导入数据记录集对象
import java.sql.SQLException; //导入数据SQL操作异常对象
import java.sql.Statement; //导入SQL操作接口对象

第3步：在程序中写入如下内容

String url; //连接数据库的字符串
String sql; //执行数据sql查询操作的字符串
Connection conn; //数据库连接变量
Statement st; //数据库操作对象
ResultSet rs; //数据记录集对象
url = "jdbc:mysql://localhost:3306/test?user=rootpassword="; //在程序中只要修改这句，就可以实现数据库连接
try {
    conn = DriverManager.getConnection(url);
    st = conn.createStatement();
    sql = "select * from test"; //只要修改这句，就可以实现各种查询操作
    rs=st.executeQuery(sql); //执行数据查询
    while(rs.next())
    {
        System.out.println(rs.getString(1)); //获得数据表test中第1个字段的数据，该字段为字符串类型
        System.out.println(rs.getString(2)); //获得数据表test中第2个字段的数据，该字段为字符串类型
    }
    rs.close(); //关闭数据记录集
    conn.close(); //关闭数据库连接
} catch (SQLException e) {
    System.out.println("Error:"+e.toString()+e.getMessage());
}

java是怎么连接mysql数据库的

java连接mysql数据库的步骤如下： 首先要下载mysql-connection-java-5.0.16-bin.jar这个jar包（版本不一致没关系），然后在工程中导入该库文件。 然后写一个类（DBHelper）用来打开或关闭数据库：

package com.hu.demo;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class DBHelper {
    public static final String url = "jdbc:mysql://127.0.0.1/student";
    public static final String name = "com.mysql.jdbc.Driver";
    public static final String user = "root";
    public static final String password = "root";
    public Connection conn = null;
    public PreparedStatement pst = null;
    public DBHelper(String sql) {
        try {
            Class.forName(name);//指定连接类型
            conn = DriverManager.getConnection(url, user, password);//获取连接
            pst = conn.prepareStatement(sql);//准备执行语句
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public void close() {
        try {
            this.conn.close();
            this.pst.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

最后再写一个Demo类来执行相关查询操作：

package com.hu.demo;
import java.sql.ResultSet;
import java.sql.SQLException;
public class Demo {
    static String sql = null;
    static DBHelper db1 = null;
    static ResultSet ret = null;
    public static void main(String[] args) {
        sql = "select *from stuinfo";//SQL语句
        db1 = new DBHelper(sql);//创建DBHelper对象
        try {
            ret = db1.pst.executeQuery();//执行语句，得到结果集
            while (ret.next()) {
                String uid = ret.getString(1);
                String ufname = ret.getString(2);
                String ulname = ret.getString(3);
                String udate = ret.getString(4);
                System.out.println(uid + "\t" + ufname + "\t" + ulname + "\t" + udate );
            }//显示数据
            ret.close();
            db1.close();//关闭连接
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

这样就完成了mysql数据库的连接了。

java连接数据库的代码

package mysql;
import java.sql.*;
/**
 * @author xys
 */
public class ConnectMysql {
    public static Connection getConnection() throws ClassNotFoundException, SQLException {
        String url = "jdbc:mysql://localhost:3306/databaseName";
        String user = "mysqluser";
        String password = "password";
        String driverClass = "com.mysql.cj.jdbc.Driver";
        Connection connection = null;
        Class.forName(driverClass);
        try {
            connection = DriverManager.getConnection(url, user, password);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        if (connection != null) {
            System.out.println("数据库连接成功");
        } else {
            System.out.println("数据库连接失败");
            connection.close();
        }
        return connection;
    }
    public void getResult() throws ClassNotFoundException, SQLException {
        // 实例化 Statement 对象
        Statement statement = getConnection().createStatement();
        // 要执行的 Mysql 数据库操作语句（增、删、改、查）
        String sql = "";
        // 展开结果集数据库
        ResultSet resultSet = statement.executeQuery(sql);
        while (resultSet.next()) {
            // 通过字段检索
            int id = resultSet.getInt("id");
            String name = resultSet.getString("name");
            // 输出数据
            System.out.println("ID : " +id);
            System.out.println("name :" + name);
        }
        // 完成后需要依次关闭
        resultSet.close();
        statement.close();
        getConnection().close();
    }
}

java怎么连接mysql数据库

这里介绍两种方式：

一，jdbc链接MySQL数据库：

  1. 如果你用jdbc方式，则按照下列方式进行连接：
    • A，注册驱动
    • B，链接数据库
    • C，执行sql
    • D，返回结果集 如下为一个基本完整流程：
package com.hu.demo;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class DBHelper {
    public static final String url = "jdbc:mysql://127.0.0.1/student";
    public static final String name = "com.mysql.jdbc.Driver";
    public static final String user = "root";
    public static final String password = "root";
    public Connection conn = null;
    public PreparedStatement pst = null;
    public DBHelper(String sql) {
        try {
            Class.forName(name);//指定连接类型
            conn = DriverManager.getConnection(url, user, password);//获取连接
            pst = conn.prepareStatement(sql);//准备执行语句
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public void close() {
        try {
            this.conn.close();
            this.pst.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
  1. 将注册，链接封装好，执行sql语句，返回结果集，代码如下：
package com.hu.demo;
import java.sql.ResultSet;
import java.sql.SQLException;
public class Demo {
    static String sql = null;
    static DBHelper db1 = null;
    static ResultSet ret = null;
    public static void main(String[] args) {
        sql = "select *from stuinfo";//SQL语句
        db1 = new DBHelper(sql);//创建DBHelper对象
        try {
            ret = db1.pst.executeQuery();//执行语句，得到结果集
            while (ret.next()) {
                String uid = ret.getString(1);
                String ufname = ret.getString(2);
                String ulname = ret.getString(3);
                String udate = ret.getString(4);
                System.out.println(uid + "\t" + ufname + "\t" + ulname + "\t" + udate );
            }//显示数据
            ret.close();
            db1.close();//关闭连接
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
  1. 查询结果如下：

二，利用框架链接MySQL，这里是springMVC+Mybatis方式链接，主要是配置文件：

config.properties文件

validationQuery=SELECT 1
jdbc_url=jdbc:mysql://localhost:3306/test?useUnicode=truecharacterEncoding=UTF-8zeroDateTimeBehaviorsss=convertToNull
jdbc_username=root
jdbc_password=123456

spring-mabatis.xml文件，进行相关配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 配置数据源 -->
    <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <property name="url" value="${jdbc_url}" />
        <property name="username" value="${jdbc_username}" />
        <property name="password" value="${jdbc_password}" />
        <!-- 初始化连接大小 -->
        <property name="initialSize" value="0" />
        <!-- 连接池最大使用连接数量 -->
        <property name="maxActive" value="20" />
        <!-- 连接池最小空闲 -->
        <property name="minIdle" value="0" />
        <!-- 获取连接最大等待时间 -->
        <property name="maxWait" value="60000" />
        <!--
        <property name="poolPreparedStatements" value="true" />
        <property name="maxPoolPreparedStatementPerConnectionSize" value="33" />
        -->
        <property name="validationQuery" value="${validationQuery}" />
        <property name="testOnBorrow" value="false" />
        <property name="testOnReturn" value="false" />
        <property name="testWhileIdle" value="true" />
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000" />
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="25200000" />
        <!-- 打开removeAbandoned功能 -->
        <property name="removeAbandoned" value="true" />
        <!-- 1800秒，也就是30分钟 -->
        <property name="removeAbandonedTimeout" value="1800" />
        <!-- 关闭abanded连接时输出错误日志 -->
        <property name="logAbandoned" value="true" />
        <!-- 监控数据库 -->
        <!-- <property name="filters" value="stat" /> -->
        <property name="filters" value="mergeStat" />
    </bean>
    <!-- myBatis文件 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!-- 自动扫描entity目录, 省掉Configuration.xml里的手工配置 -->
        <property name="mapperLocations" value="classpath:com/fourfaith/*/mapping/*.xml" />
    </bean>
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.fourfaith.**.dao" />
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
    </bean>
    <!-- 配置事务管理器 -->
    <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- 拦截器方式配置事物 -->
    <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="add*" propagation="REQUIRED" />
            <tx:method name="append*" propagation="REQUIRED" />
            <tx:method name="insert*" propagation="REQUIRED" />
            <tx:method name="save*" propagation="REQUIRED" />
            <tx:method name="update*" propagation="REQUIRED" />
            <tx:method name="modify*" propagation="REQUIRED" />
            <tx:method name="edit*" propagation="REQUIRED" />
            <tx:method name="delete*" propagation="REQUIRED" />
            <tx:method name="remove*" propagation="REQUIRED" />
            <tx:method name="repair" propagation="REQUIRED" />
            <tx:method name="delAndRepair" propagation="REQUIRED" />
            <tx:method name="import*" propagation="REQUIRED" read-only="false"
                        rollback-for="java.lang.Exception" />
            <tx:method name="get*" propagation="SUPPORTS" />
            <tx:method name="find*" propagation="SUPPORTS" />
            <tx:method name="load*" propagation="SUPPORTS" />
            <tx:method name="search*" propagation="SUPPORTS" />
            <tx:method name="datagrid*" propagation="SUPPORTS" />
            <tx:method name="*" propagation="SUPPORTS" />
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut id="transactionPointcut"
                      expression="execution(* com...*.service..*Impl.*(..))" />
        <aop:advisor pointcut-ref="transactionPointcut"
                      advice-ref="transactionAdvice" />
    </aop:config>
    <!-- 配置druid监控spring jdbc -->
    <bean id="druid-stat-interceptor"
          class="com.alibaba.druid.support.spring.stat.DruidStatInterceptor" />
    <bean id="druid-stat-pointcut"
          class="org.springframework.aop.support.JdkRegexpMethodPointcut"
          scope="prototype">
        <property name="patterns">
            <list>
                <value>com...*.service.*</value>
            </list>
        </property>
    </bean>
    <aop:config>
        <aop:advisor advice-ref="druid-stat-interceptor"
                      pointcut-ref="druid-stat-pointcut" />
    </aop:config>
</beans>

还有很多方式可以实现，这里就简略的描述一番。

推荐文章