Java和MySQL简建立连接

最新推荐文章于 2024-03-22 17:34:24 发布
最新推荐文章于 2024-03-22 17:34:24 发布
阅读量176 收藏
点赞数
分类专栏： 编程学习笔记 文章标签： mysql java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40640737/article/details/107355793
版权
这篇博客详细介绍了如何使用JDBC进行数据操作，包括插入、查询、动态参数、回滚等，并探讨了MyBatis的高级特性如动态SQL、懒加载和多表查询。此外，还涵盖了存储过程的使用以及各种子查询的实例，最后讨论了不等值内连接和数据排序的方法。
摘要由CSDN通过智能技术生成

JDBC

JDBC插入多条数据

package com.easy.view;

import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class Test6 {

	public static void main(String[] args) throws Exception {
		//如何插入多条数据，减少数据库的压力
		
		
		//4个数据源
		//1.驱动：连接数据库的一个不可或缺的类，可以在com.mysql.jdbc包下找到Driver这个类
		String driver = "com.mysql.jdbc.Driver";
		//2.jdbc连接数据库的路径
		String url = "jdbc:mysql://127.0.0.1:3306/myemployees";
		
		//3.用户名
		String userName = "root";
		//4.密码
		String psw = "123456";
		
		//五个执行步骤
		//1.加载驱动
		Class.forName(driver);
		
		//2.连接数据库
		//获取数据库连接
		//连接对象
		java.sql.Connection conn = DriverManager.getConnection(url, userName, psw);
		
		
		
		String selectSql = "insert into employees (last_name) values (?)";
		
		//3.预编译sql，获取预编译对象：预先编译，在执行之前编译成二进制
		PreparedStatement pre = conn.prepareStatement(selectSql);
		
		//Batch就是把所有的代码放在一块儿执行
		for (int i = 0; i < 10; i++) {
			//方法括号里面的1表示第一个？
			pre.setString(1, String.valueOf(i));
			pre.addBatch();
		}
		
		int[] i = pre.executeBatch();
		
		for (int j : i) {
			System.out.println(j);
		}
		
		conn.close();
	}
}

JDBC查询

package com.easy.view;

import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class Test6 {

	public static void main(String[] args) throws Exception {
		// 如何执行查询操作

		//4个数据源
		//1.驱动：连接数据库的一个不可或缺的类，可以在com.mysql.jdbc包下找到Driver这个类
		String driver = "com.mysql.jdbc.Driver";
		//2.jdbc连接数据库的路径
		String url = "jdbc:mysql://127.0.0.1:3306/myemployees";
		
		//3.用户名
		String userName = "root";
		//4.密码
		String psw = "123456";
		
		//五个执行步骤
		//1.加载驱动
		Class.forName(driver);
		
		//2.连接数据库
		//获取数据库连接
		//连接对象
		java.sql.Connection conn = DriverManager.getConnection(url, userName, psw);
		
		String selectSql = "select last_name, department_id from employees where employee_id = 104";
		
		//3.预编译sql，获取预编译对象：预先编译，在执行之前编译成二进制
		PreparedStatement pre =  conn.prepareStatement(selectSql);
		
		//4.执行查询操作
		ResultSet res = pre.executeQuery();
		//next相当于游标
		while(res.next()) {
			//String也可以写Object
			System.out.println(res.getString("last_name"));
			System.out.println(res.getObject("department_id"));
		}
		
		//5.关闭连接对象
		conn.close();
	}
}

JDBC动态传参

package com.easy.view;

import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class Test6 {

	public static void main(String[] args) throws Exception {
		//动态传参where
		
		
		//4个数据源
		//1.驱动：连接数据库的一个不可或缺的类，可以在com.mysql.jdbc包下找到Driver这个类
		String driver = "com.mysql.jdbc.Driver";
		//2.jdbc连接数据库的路径
		String url = "jdbc:mysql://127.0.0.1:3306/myemployees";
		
		//3.用户名
		String userName = "root";
		//4.密码
		String psw = "123456";
		
		//五个执行步骤
		//1.加载驱动
		Class.forName(driver);
		
		//2.连接数据库
		//获取数据库连接
		//连接对象
		java.sql.Connection conn = DriverManager.getConnection(url, userName, psw);
		
		String selectSql = "select last_name, department_id, salary from employees where last_name = ? or year = ?";
		
		//3.预编译sql，获取预编译对象：预先编译，在执行之前编译成二进制
		PreparedStatement pre =  conn.prepareStatement(selectSql);
		pre.setString(1, "Ernst");
		pre.setInt(2, 50);

		//4.执行查询操作
		ResultSet res = pre.executeQuery();
		//next相当于游标
		while(res.next()) {
			//String也可以写Object
			System.out.println(res.getString("last_name"));
			System.out.println(res.getObject("department_id"));
			System.out.println(res.getObject("salary"));
		}
		
		//5.关闭连接对象
		conn.close();
	}
}

JDBC回滚

package com.easy.view;

import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class Test6 {

	public static void main(String[] args) throws Exception {
		//关闭自动提交，使用rollback
		//4个数据源
		//1.驱动：连接数据库的一个不可或缺的类，可以在com.mysql.jdbc包下找到Driver这个类
		String driver = "com.mysql.jdbc.Driver";
		//2.jdbc连接数据库的路径
		String url = "jdbc:mysql://127.0.0.1:3306/myemployees";
		
		//3.用户名
		String userName = "root";
		//4.密码
		String psw = "123456";
		
		//五个执行步骤
		//1.加载驱动
		Class.forName(driver);
		
		//2.连接数据库
		//获取数据库连接
		//连接对象
		java.sql.Connection conn = DriverManager.getConnection(url, userName, psw);
		
		//默认自动提交，修改为手动提交
		conn.setAutoCommit(false);
		
		String sql = "delete from employees where employee_id = ?";
		
		//3.预编译sql，获取预编译对象：预先编译，在执行之前编译成二进制
		PreparedStatement pre =  conn.prepareStatement(sql);
		pre.setInt(1, 104);
		//4.拿到数据库里执行
		//i：在数据库内执行了多少条数据
		int i = pre.executeUpdate();
		
		System.out.println(i);
		
		conn.rollback();
		//5.关闭连接对象
		conn.close();
	}
}

JDBC将数据库中的信息装入List

package com.easy.view;

import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class Test6 {

	public static void main(String[] args) throws Exception {
		//如何将数据库中的数据装入List
		
		//4个数据源
		//1.驱动：连接数据库的一个不可或缺的类，可以在com.mysql.jdbc包下找到Driver这个类
		String driver = "com.mysql.jdbc.Driver";
		//2.jdbc连接数据库的路径
		String url = "jdbc:mysql://127.0.0.1:3306/myemployees";
		
		//3.用户名
		String userName = "root";
		//4.密码
		String psw = "123456";
		
		//五个执行步骤
		//1.加载驱动
		Class.forName(driver);
		
		//2.连接数据库
		//获取数据库连接
		//连接对象
		java.sql.Connection conn = DriverManager.getConnection(url, userName, psw);
		
		String selectSql = "select last_name, department_id, salary from employees";
		
		//3.预编译sql，获取预编译对象：预先编译，在执行之前编译成二进制
		PreparedStatement pre = conn.prepareStatement(selectSql);
		
		//4.执行查询操作
		ResultSet res = pre.executeQuery();
		
		List<Employees> list = new ArrayList<Employees>();
		//next相当于游标
		while(res.next()) {
			Employees employees = new Employees();
			employees.setLast_name(res.getString("last_name"));
			list.add(employees);
		}
		for (Employees employees : list) {
			System.out.println(employees.getLast_name());
		}
		System.out.println(list);
		
		//5.关闭连接对象
		conn.close();
	}
}

JDBC模糊查询

package com.easy.view;

import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class Test6 {

	public static void main(String[] args) throws Exception {
		// 如何进行模糊查询
		
		
		//4个数据源
		//1.驱动：连接数据库的一个不可或缺的类，可以在com.mysql.jdbc包下找到Driver这个类
		String driver = "com.mysql.jdbc.Driver";
		//2.jdbc连接数据库的路径
		String url = "jdbc:mysql://127.0.0.1:3306/sale";
		
		//3.用户名
		String userName = "root";
		//4.密码
		String psw = "123456";
		
		//五个执行步骤
		//1.加载驱动
		Class.forName(driver);
		
		//2.连接数据库
		//获取数据库连接
		//连接对象
		java.sql.Connection conn = DriverManager.getConnection(url, userName, psw);
		
		String name = "金";
		//这种写法不常用
//		String selectSql = "select username from user where username like '%" + name + "%'";
		
		
		String selectSql = "select username from user where username like ?";
		
		//3.预编译sql，获取预编译对象：预先编译，在执行之前编译成二进制
		PreparedStatement pre = conn.prepareStatement(selectSql);
		
		pre.setString(1, "%" + name + "%");

		//4.执行查询操作
		ResultSet res = pre.executeQuery();
		//next相当于游标
		while(res.next()) {
			//String也可以写Object
			System.out.println(res.getString("username"));
		}
		
		//5.关闭连接对象
		conn.close();
	}
}

JDBC如何写多条SQL语句

package com.easy.view;

import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class Test6 {

	public static void main(String[] args) throws Exception {
		//如何在1个JDBC中写入多个SQL语句
		//4个数据源
		//1.驱动：连接数据库的一个不可或缺的类，可以在com.mysql.jdbc包下找到Driver这个类
		String driver = "com.mysql.jdbc.Driver";
		//2.jdbc连接数据库的路径
		String url = "jdbc:mysql://127.0.0.1:3306/school";
		
		//3.用户名
		String userName = "root";
		//4.密码
		String psw = "123456";
		
		//五个执行步骤
		//1.加载驱动
		Class.forName(driver);
		
		//2.连接数据库
		//获取数据库连接
		//连接对象
		java.sql.Connection conn = DriverManager.getConnection(url, userName, psw);
		
		String sql = "select * from student where classid = ?";
		String sql2 = "select * from teacher where class_id = ?";
		
		//3.预编译sql，获取预编译对象：预先编译，在执行之前编译成二进制
		PreparedStatement pre = conn.prepareStatement(sql);
		PreparedStatement pre2 = conn.prepareStatement(sql2);
		pre.setInt(1, 1);
		pre2.setInt(1, 1);
		
		 //4.执行查询操作
		 ResultSet res = pre.executeQuery();
		 ResultSet res2 = pre2.executeQuery();
				
		//next相当于游标
				while(res.next()) {
					System.out.println(res.getObject("name"));
				}
				while(res2.next()) {
					System.out.println(res2.getObject("name"));
				}
		//5.关闭连接对象
		conn.close();
	}
}

JDBC如何用res.nex()判断是否在数据库中有重复的值

package com.easy.view;

import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class Test6 {

	public static void main(String[] args) throws Exception {
		// 如何用res.next()判断是否重复
		
		//4个数据源
		//1.驱动：连接数据库的一个不可或缺的类，可以在com.mysql.jdbc包下找到Driver这个类
		String driver = "com.mysql.jdbc.Driver";
		//2.jdbc连接数据库的路径
		String url = "jdbc:mysql://127.0.0.1:3306/sale";
		
		//3.用户名
		String userName = "root";
		//4.密码
		String psw = "123456";
		
		//五个执行步骤
		//1.加载驱动
		Class.forName(driver);
		
		//2.连接数据库
		//获取数据库连接
		//连接对象
		java.sql.Connection conn = DriverManager.getConnection(url, userName, psw);
		
		String selectSql = "select username from user where username = '刘吉'";
		
		//3.预编译sql，获取预编译对象：预先编译，在执行之前编译成二进制
		PreparedStatement pre =  conn.prepareStatement(selectSql);
		
		//4.执行查询操作
		ResultSet res = pre.executeQuery();
		//next相当于游标
		//res.next()就是查看sql语句的查询结果，如果有值，则返回true；如果没有，则返回false
		if (res.next()) {
			System.out.println("用户名重复");
		}
		else {
			System.out.println("用户名不重复");
		}
		
		
		//5.关闭连接对象
		conn.close();
	}
}

JDBC手动提交

package com.easy.view;

import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class Test6 {

	public static void main(String[] args) throws Exception {
		//关闭自动提交
		//4个数据源
		//1.驱动：连接数据库的一个不可或缺的类，可以在com.mysql.jdbc包下找到Driver这个类
		String driver = "com.mysql.jdbc.Driver";
		//2.jdbc连接数据库的路径
		String url = "jdbc:mysql://127.0.0.1:3306/myemployees";
		
		//3.用户名
		String userName = "root";
		//4.密码
		String psw = "123456";
		
		//五个执行步骤
		//1.加载驱动
		Class.forName(driver);
		
		//2.连接数据库
		//获取数据库连接
		//连接对象
		java.sql.Connection conn = DriverManager.getConnection(url, userName, psw);
		//默认自动提交
		conn.setAutoCommit(false);
		
		String sql = "delete from employees where employee_id = ?";
		
		//3.预编译sql，获取预编译对象：预先编译，在执行之前编译成二进制
		PreparedStatement pre =  conn.prepareStatement(sql);
		pre.setInt(1, 121);
		//4.拿到数据库里执行
		//i：在数据库内执行了多少条数据
		int i = pre.executeUpdate();
		
		System.out.println(i);
		
		conn.commit();
		//5.关闭连接对象
		conn.close();
	}
}

JDBC增删改

package com.easy.view;

import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class Test6 {

	public static void main(String[] args) throws Exception {
		//如何执行增删改的操作
		//4个数据源
		//1.驱动：连接数据库的一个不可或缺的类，可以在com.mysql.jdbc包下找到Driver这个类
		String driver = "com.mysql.jdbc.Driver";
		//2.jdbc连接数据库的路径
		String url = "jdbc:mysql://127.0.0.1:3306/myemployees";
		
		//3.用户名
		String userName = "root";
		//4.密码
		String psw = "123456";
		
		//五个执行步骤
		//1.加载驱动
		Class.forName(driver);
		
		//2.连接数据库
		//获取数据库连接
		//连接对象
		java.sql.Connection conn = DriverManager.getConnection(url, userName, psw);
		
		String sql = "delete from employees where employee_id = 120";
		
		//3.预编译sql，获取预编译对象：预先编译，在执行之前编译成二进制
		PreparedStatement pre =  conn.prepareStatement(sql);
		
		//4.拿到数据库里执行
		//i：在数据库内执行了多少条数据
		int i = pre.executeUpdate();
		
		System.out.println(i);
		//5.关闭连接对象
		conn.close();
	}
}

MyBatis

main方法里面写

//获取一个sql的会话，连接数据库
SqlSession sqlSession = MyBatisTools.getSqlSession();

//获取接口对象，以class结尾
//Mapper叫作映射
EmployeesMapper emp = sqlSession.getMapper(EmployeesMapper.class);

//中间用emp就可以调用EmployeesMapper接口里面的方法

//提交：Mybatis不是自动提交
sqlSession.commit();
//关闭会话
sqlSession.close();

查询最高工资

//⑤查询部门最高工资，取出的max(salary)不可能用一个属性来接，因此定义int类型就好了
	int selectMaxsalary();

<!-- //⑤查询部门最高工资，取出的max(salary)不可能用一个属性来接，因此定义int类型就好了 -->
	<select id = "selectMaxsalary" resultType = "java.lang.Integer">
		select max(salary) from employees;
	</select>

//		int i = emp.selectMaxsalary();
//		System.out.println(i);

传多个参数用对象

//④传多个参数，用对象。保证实体类里面的属性和数据库中表的字段名一致
	Employees selectBysalaryAndyear(Employees employees);

	<!-- //④传多个参数，用对象 -->
	<select id = "selectBysalaryAndyear"  parameterType = "com.easyup.model.Employees" resultType = "com.easyup.model.Employees">
		<!-- {}里面写实体类里面属性的名字 -->
		select last_name from employees where salary = #{salary} and year = #{year};
	</select>

Employees employees = new Employees();
//		employees.setYear(22);
//		employees.setSalary(42000);
//		Employees i = emp.selectBysalaryAndyear(employees);
//		System.out.println(i.getLast_name());

动态SQL

	//⑥动态SQL
	//（1）where if，可以省略前面的and
	List<Employees> selectByNameAndJobId(Employees emp);
	//（2）set if：可以省略掉后面的逗号
	int updateLastName(Employees emp);
	//（3）foreach————SQL:list(1,2,3,4)：遍历集合
	List<Employees> selectEmpByids(List<Integer> ids);
	//（4）<sql><include>标签可以将select后面要查询的语句重复使用，不必每次都写
	Employees selectEmpById(Employees emp);


<!-- //⑥动态SQL
	//（1）where if，可以省略前面的and -->
	<select id = "selectByNameAndJobId" resultType = "com.easyup.model.Employees">
		select last_name, job_id
		from employees
		<where>
		<!-- where if 是去掉字if里面前面的and的，但是不能删除if里面后面的and -->
		<!-- where if 至少传入一个参数 -->
		
			<if test = "last_name != null and last_name != ''">
				last_name = #{last_name}
			</if>
			
			<if test= "job_id != null and job_id != ''">
				and job_id = #{job_id}
			</if>
		</where>
	</select>


	<!-- //（2）set if：可以省略掉后面的逗号 -->
	<update id = "updateLastName" >
		update employees
		<!--  删除语句后面的逗号 -->
		<set>
			<if test = "last_name != null and last_name != ''">
				last_name = #{last_name},
			</if >
			
			<if test= "job_id != null and job_id != ''">
				job_id = #{job_id}
			</if>
		</set>
		where employee_id = #{employee_id}
	</update>
	
	<!-- //（3）foreach————SQL:list(1,2,3,4)：遍历集合 -->
	<!-- 此处参数是int类型的集合，可以写参数也可以不写 -->
	<select id = "selectEmpByids" parameterType = "java.lang.Integer" resultType = "com.easyup.model.Employees">
		select last_name
		from employees
		where employee_id
		in
		<！-- item表示in（）里面的内容 -->
		<foreach collection = "list" open = "(" close = ")" separator = "," item = "item">
			#{item}
		</foreach>
	</select>
	
	
	<!-- //（4）<sql><include>标签可以将select后面要查询的语句重复使用，不必每次都写 -->
	<sql id = "empSql">
	last_name, job_id, salary, employee_id, year
	</sql>

	<select id = "selectEmpById" parameterType = "com.easyup.model.Employees"  resultType = "com.easyup.model.Employees">
		select 
		<include refid = "empSql"></include>
		from employees
		where employee_id = #{employee_id}
	</select>


//		Employees empl = new Employees(); 
		
		//where if方法的调用
//		empl.setLast_name("Ernst");
//		empl.setJob_id("IT_PROG");
		
//		List<Employees> list = emp.selectByNameAndJobId(empl);
//		for (Employees employees : list) {
//			System.out.println(employees.getLast_name());
//			System.out.println(employees.getJob_id());
//		}
		
		//set if方法的调用
//		empl.setLast_name("Pataballa11111");
//		empl.setEmployee_id(106);
//		int i = emp.updateLastName(empl);
//		System.out.println(i);
		
		//foreach方法的调用
//		List<Integer> list = new ArrayList<Integer>();
//		list.add(105);
//		list.add(106);
//		list.add(107);
//		list.add(108);
//		List<Employees> selectEmpByids = emp.selectEmpByids(list);
//		for (Employees employees : selectEmpByids) {
//			System.out.println(employees.getLast_name());
//		}
		
		//<include>方法的调用
//		empl.setEmployee_id(105);
//		Employees selectEmpById = emp.selectEmpById(empl);
//		System.out.println(selectEmpById);

动态传参需要写入参数

//③动态传参需要写入参数
	Employees selectById(int employee_id);


<!-- //③动态传参需要写入参数 -->
	<!-- 动态传参 -->
	<select id = "selectById"  parameterType = "java.lang.Integer" resultType = "com.easyup.model.Employees">
		<!-- {}里面写实体类里面属性的名字，或者参数的名字 -->
		select last_name from employees where employee_id = #{employee_id};
	</select>


//查看一个字段的单个信息
//		Employees employees= emp.selectById(108);
//		System.out.println(employees.getLast_name());

多表查询：一对多

	//多表查询：查询一个表和另一个表中相同字段有相同值，因此主表也有多个值，需要用List来接
	//（2）一对多
	List<Departments> selectDepEmp();


	<!-- //（2）一对多 -->
	<resultMap type = "com.easyup.model.Departments" id = "DepMap">
		<result column = "department_name" property = "departmentName"/>
		<collection property = "empList" ofType = "com.easyup.model.Employees">
			<result column = "last_name" property = "lastName"/>
		</collection>
	</resultMap>

	<select id = "selectDepEmp" resultMap = "DepMap">
		select departments.department_name, employees.last_name
		from departments, employees
		where departments.department_id = employees.department_id;
	</select>


		//一对多
//		List<Departments> list = dep.selectDepEmp();
//		for (Departments d : list) {
//			System.out.println(d.getDepartmentName());
//			for (Employees e : d.getEmpList()) {
//				System.out.println(e.getLastName());
//			}
//		}

多表查询：一对一

	//⑨多表查询
	//（1）一对一：两张表分别由同一字段。要明白是从谁出发去找谁。
	//注意事项：①分清楚多表查询中的一对一和懒加载的一对一的区别：多表查询的一对一只需在该类中有另外一个类的变量，②如果
	//从employees找card
	List<Employees> selectCard();
	//从card找employees
	List<Card> selectCardEmp();


	<!-- //⑨多表查询 -->
	<!-- //（1）一对一：两张表分别由同一字段。要明白是从谁出发去找谁。 -->
	<!-- 从Employees去取Card -->
	<resultMap type = "com.easyup.model.Employees" id = "EmpCard">
		<result column = "last_name" property = "lastName"/>
		<!-- 一对一的关系 -->
		<!-- 从员工表出发，和card是一对一的关系 -->
		<association property = "card" javaType = "com.easyup.model.Card">
			<result column = "card_num" property = "num"/>
		</association>
	</resultMap>
	
	<select id = "selectCard" resultMap = "EmpCard">
		select employees.last_name, card.card_num, employees.salary
		from employees,card
		where employees.card_id = card.id;
	</select>
	
	
	<!-- 从Card去取Employees -->
	<resultMap type = "com.easyup.model.Card" id = "CardEmp">
		<result column = "card_num" property = "num"/>
		<result column = "id" property = "Id"/>
		<!-- 一对一的关系 -->
		<!-- 从员工表出发，和card是一对一的关系 -->
		<!-- association里面的property写的是Employees里面的一个成员变量 -->
		<association property = "employees" javaType = "com.easyup.model.Employees">
			<result column = "last_name" property = "lastName"/>
			<result column = "salary" property = "salary"/>
			<result column = "year" property = "year"/>
			<result column = "employee_id" property = "employee_id"/>
		</association>
	</resultMap>
	
	<select id = "selectCardEmp" resultMap = "CardEmp">
		select employees.last_name, card.card_num, employees.salary, employees.year, employees.employee_id
		from employees,card
		where employees.card_id = card.id;
	</select>


		//从员工表找Card
//		List<Employees> selectCard = emp.selectCard();
//		for (Employees employees : selectCard) {
//			System.out.println(employees);
//		}
		
		//从Card找员工表
//		List<Card> selectCardEmp = emp.selectCardEmp();
//		
//		for (Card card : selectCardEmp) {
//			System.out.println(card);
//		}

刚插入一条数据，取出id

	//⑩刚插进去一条信息，然后取出主键：只能用于使用对象作为参数的情况
	int insertEmp(Employees emp);


	<!-- //⑩刚插进去一条信息，然后取出主键 -->
	<insert id = "insertEmp" parameterType = "com.easyup.model.Employees">
		<selectKey order = "AFTER" resultType = "java.lang.Integer" keyProperty = "employee_id">
			//固定方法名
			select last_insert_id()
		</selectKey>
			insert into employees
			(last_name) values (#{lastName})
	</insert>


		//向数据库中添加数据，然后马上取到对应的主键
//		Employees employees = new Employees();
//		employees.setLastName("小明33333333333");
//		int insertEmp = emp.insertEmp(employees);
//		System.out.println("执行了：" + insertEmp);
//		System.out.println("id：" + employees.getEmployee_id());

高级映射

	//⑦高级映射
	//增删改不需要结果集映射，只有查询的时候需要用到结果集映射
	Employees selectById11();


	<!-- //⑦高级映射 -->
	<!--//增删改不需要结果集映射，只有查询的时候需要用到结果集映射 -->
	<resultMap type = "com.easyup.model.Employees" id = "empMap">
		<result column = "last_name" property = "lastName"/>
	</resultMap>
	<select id = "selectById11" resultMap = "empMap">
		select <include refid = "empSql"></include>
		from employees 
		where employee_id = 108;
	</select>


//		Employees selectById11 = emp.selectById11();
//		System.out.println(selectById11);

懒加载，一对一

//懒加载，又叫延迟加载、按需加载
//把多表查询，拆成单表查询，比如从员工表找card表，只有调用getcard的时候才会去查card表
//注意事项：①Employees里面要有Card类型的card；②主查询要查询那个与子查询相关联的字段；③子查询的参数要写与主查询相关联的字段；④log文件要放在src的目录下

	//主查询的方法定义
	Employees selectCardlazy(@Param("empId")int employeeId);


	//主查询的XML
	<resultMap type = "com.easyup.model.Employees" id = "cc">
		<result column = "last_name" property = "lastName"/>
		<association property = "card" javaType = "com.easyup.model.Card"
		select = "com.easyup.mapper.CardMapper.selectCard" column = "card_id"
		fetchType = "lazy">
		</association>
	</resultMap>
	
	
	<select id = "selectCardlazy" resultMap = "cc">
		select last_name,card_id
		from employees
		where employee_id = #{empId}
	</select>


	//子查询的方法定义
	Card selectCard(@Param("id")int id);



	//子查询的XML
	<resultMap type = "com.easyup.model.Card" id = "aa">
		<result column = "id" property = "Id"/>
		<result column = "card_num" property = "num"/>
	</resultMap>

	<select id = "selectCard" resultMap = "aa">
		select id,card_num
		from card
		where id = #{id}
	</select>


		//调用方法
		Employees selectCardlazy = emp.selectCardlazy(104);
//		System.out.println(selectCardlazy.getLastName());
		System.out.println(selectCardlazy.getCard().getNum());

懒加载：一对多

//懒加载：一对多
//注意事项：①department类里面要有employees泛型的List；②collection里面的property要写empList；③子查询的筛选条件要写与主查询相关联的字段；④log文件要放在src的目录下

//从department查员工表，用懒加载
Departments selectFromDepToEmp(@Param("depId")int depId);


<resultMap type = "com.easyup.model.Departments" id = "Deplazy">
<result column = "department_name" property = "departmentName"/>
<result column = "department_id" property = "departmentId"/>
<collection property="empList" ofType = "com.easyup.model.Employees"
select = "com.easyup.mapper.EmployeesMapper.selectFromDepToEmp" column = "department_id"
fetchType = "lazy"
></collection>
</resultMap>

<select id = "selectFromDepToEmp" resultMap = "Deplazy">
	select department_name, department_id
	from departments
	where department_id = #{depId}
</select>


//从部门表找员工表的懒加载
List<Employees> selectFromDepToEmp(@Param("depId")int depId);


<resultMap type = "com.easyup.model.Employees" id = "hh">
	<result column = "last_name" property = "lastName"/>
</resultMap>

<select id = "selectFromDepToEmp" resultMap = "hh">
	select last_name
	from employees
	where department_id = #{depId}
</select>


	Departments selectFromDepToEmp = dep.selectFromDepToEmp(60);
	System.out.println(selectFromDepToEmp.getDepartmentName());
	
	for(Employees employees : selectFromDepToEmp.getEmpList()) {
		System.out.println(employees.getLastName());
	}

懒加载：一对多对一

//根据job_id可以找到多个员工
//接口中的方法定义
List<Jobs> selectJobsEmpLazy(@Param("jobId")String jobId);

//XML的写法
<resultMap type = "com.easyup.model.Jobs" id = "ff">
	<result column = "job_id" property = "jobId"/>
	<result column = "job_title" property = "jobTitle"/>
	<collection property = "empList" ofType = "com.easyup.model.Employees"
		select = "com.easyup.mapper.EmployeesMapper.selectFromJobsToEmployees" column = "job_id"
		fetchType = "lazy">
	</collection>
</resultMap>

<select id = "selectJobsEmpLazy" resultMap = "ff">
	select job_id, job_title
	from jobs
	where job_id = #{jobId}
</select>



//从Jobs表找员工表的懒加载
//方法的定义
List<Employees> selectFromJobsToEmployees(@Param("JobId")String jobId);
//XML的写法
<resultMap type = "com.easyup.model.Employees" id = "gg">
	<result column = "last_name" property = "lastName"/>
	<result column = "salary" property = "salary"/>
	<result column = "employee_id" property = "employee_id"/>
	<association property = "jobGrades" javaType = "com.easyup.model.JobGrades"
	select = "com.easyup.mapper.JobGradesMapper.selectSalaryLevel" column = "salary"
	fetchType = "lazy">
	</association>
</resultMap>

<select id = "selectFromJobsToEmployees" resultMap = "gg">
	select last_name, salary
	from employees
	where job_id = #{jobId}
</select>


//根据查到的员工的工资，去工资登记表里面查对应的工资等级
//方法的定义
JobGrades selectSalaryLevel(@Param("salary")int salary);

//XML的写法
<resultMap type = "com.easyup.model.JobGrades" id = "kk">
	<result column = "grade_level" property = "gradeLevel"/>
</resultMap>

<select id = "selectSalaryLevel" resultMap = "kk">
	select grade_level
	from job_grades
	where #{salary} between lowest_sal and highest_sal
</select>


	//main方法的写法
	//用jobs查员工表一对多
	List<Jobs> selectJobsEmpLazy = job.selectJobsEmpLazy("IT_PROG");
	for (Jobs jobs : selectJobsEmpLazy) {
		System.out.println(jobs.getJobId() + "  " + jobs.getJobTitle());
		for (Employees ee : jobs.getEmpList()) {
			System.out.println(ee.getLastName() + "  " + ee.getSalary());
			System.out.println(ee.getJobGrades().getGradeLevel());
		}
	}

模糊查询

	//⑧模糊查询
	//（1）老师教的第一种
	List<Employees> selectLike(String name);
	//（2）我们的第二种
	List<Employees> selectLikeName(String name);


	<!-- //⑧模糊查询-->
	<!-- //（1）老师教的第一种 -->
	<select id = "selectLike" parameterType = "java.lang.String" resultMap = "empMap">
		select last_name
		from employees
		where last_name like concat('%', #{name}, '%');
	</select>
	
	<!-- //（2）我们的第二种 -->
	<select id = "selectLikeName" parameterType = "java.lang.String" resultMap = "empMap">
		select <include refid = "empSql"></include>
		from employees
		where last_name like #{lastName};
	</select>


//		List<Employees> selectLike = emp.selectLike("Er");
//		for (Employees employees : selectLike) {
//			System.out.println(employees);
//		}
		
//		String name = "sti";
//		List<Employees> selectLikeName = emp.selectLikeName("%" + name + "%");
//		for (Employees employees : selectLikeName) {
//			System.out.println(employees);

取出一个表中一个字段所有的数据要用List来接

//②取出一个表中一个字段所有的数据要用List来接
	List<Employees> selectAll();


<!-- //②取出一个表中一个字段所有的数据要用List来接 -->
	<!-- 查询所有信息的时候不能写* -->
	<select id = "selectAll" resultType = "com.easyup.model.Employees">
		select last_name from employees;
	</select>


//查看一个字段的所有信息
//		List<Employees> list = emp.selectAll();
//		
//		for (Employees employees : list) {
//			System.out.println(employees.getLast_name());
//		}

增删改

    //①增删改的返回值l类型都是int
	int add();
	int delete();
	int update();


	<!-- id表示和哪一个方法进行联系 -->
	<!-- //①增删改的返回值都是int -->
	<insert id = "add">
		insert into employees (last_name)
		values ('小明22222222')
	</insert>
	
	<delete id = "delete">
		delete from employees where employee_id = 152;
	</delete>
	
	<update id = "update">
		update employees set last_name = '大吉哥' where employee_id = 152;
	</update>


//调用接口里面的方法，并接取返回值
//		int i = emp.add();
//		int j = emp.update();
//		int k = emp.delete();

注解查询：查询（一个参数，多个参数均可）

//注解查询：查询一个字段
@Select("select id, card_num from card where id = #{id}")
@Results({
	@Result(column = "card_num", property = "num")
})
Card selectCardId(@Param("id")int id);


	//查询
//		Card selectCardId = car.selectCardId(1);
//		System.out.println(selectCardId.getNum());


//注解查询：查询多个字段
@Select("select employee_id, last_name, salary, year, job_id from employees where employee_id = #{employee_id}")
@Results({
	@Result(column = "employee_id", property = "employee_id"),
	@Result(column = "last_name", property = "lastName"),
	@Result(column = "salary", property = "salary"),
	@Result(column = "year", property = "year"),
	@Result(column = "job_id", property = "job_id")
})
Employees selectemployees(@Param("employee_id") int employee_id);


//		Employees selectemployees = emp.selectemployees(104);
//		System.out.println(selectemployees);

注解查询：多个参数，一半注解，一半XML

//注解查询：多个参数，一半注解，一半XML
int insertEmp1(@Param("salary") int salary, @Param("lastName")String last_name);


<insert id = "insertEmp1">
		insert into employees
		(last_name, salary) values (#{lastName}, #{salary})
</insert>


//		int insertEmp1 = emp.insertEmp1(80000, "小花1111111111");
//		System.out.println(insertEmp1);

注解查询：增删改（无参）

	//注解查询
	@Insert("insert into card (card_num) values (211302)")
	int insertCard();
	
	@Delete("delete from card where card_num = 211302")
	int deleteCard();
	
	@Update("update card set card_num = 777 where id = 3")
	int updateCard();


		//注解查询：添加数据
//		int insertCard = car.insertCard();
//		System.out.println(insertCard);
		
		//注解查询：删除数据
//		int deleteCard = car.deleteCard();
//		System.out.println(deleteCard);
		
		//注解查询：更新数据
//		int updateCard = car.updateCard();
//		System.out.println(updateCard);

注解查询：增删改：多个参数

	//多个参数的写法：
	//更新
	@Update("update card set card_num = #{num} where id = #{id}")
	int updateCard2(@Param("id") int id, @Param("num") int num);
	//删除
	@Delete("delete from card where id = #{id} and card_num = num")
	int deleteCard2(@Param("id") int id, @Param("num") int num);
	//添加
	@Insert("insert into card (id, card_num) values (#{id}, #{num})")
	int insertCard3(@Param("id") int id, @Param("num") int num);


		//多个参数
		//更新
//		int updateCard2 = car.updateCard2(1, 1111111111);
//		System.out.println(updateCard2);

注解查询：增删改：使用对象动态传参

	//动态传参：使用对象
	//更新
	@Update("update card set card_num = #{num} where id = #{id}")
	int updateCard1(Card card);
	//删除
	@Delete("delete from card where id = #{id}")
	int deleteCard1(Card card);
	//添加
	@Insert("insert into card (card_num) values (#{num})")
	int insertCard1(Card card);


		//注解查询——动态传参：更新数据
//		Card card = new Card();
//		card.setId(1);
//		card.setNum(9);
//		int updateCard1 = car.updateCard1(card);
//		System.out.println(updateCard1);
		
		//注解查询——动态传参：删除数据
//		Card card = new Card();
//		card.setId(3);
//		int deleteCard1 = car.deleteCard1(card);
//		System.out.println(deleteCard1);
		
		//注解查询——动态查询：添加数据
//		Card card = new Card();
//		card.setNum(1203);
//		int insertCard1 = car.insertCard1(card);
//		System.out.println(insertCard1);

存储过程

INOUT参数的使用以及PLSQL

-- 传入一个参数，如果大于3则返回100，否则返回500
-- 用户变量作用于当前会话，局部变量作用于begin和end之间
-- INOUT的使用
delimiter $$
create procedure my_pro8(INOUT in_param varchar(20))
begin
    declare param varchar(20);
    if in_param > 3
    then set param := 100;
    else set param := 500;
    end if;
    
    set in_param := param;

end $$
delimiter ;

set @param = 3;
call my_pro8(@param);

select @param;



-- PLSQL while
-- PLSQL：过程语言，在存储过程中使用的语言，也就是和Java一样有循环、分支这些语句，但是很少用到

delimiter $$
create procedure my_pro11_while()
begin
    declare i int;
    set i := 0;
    
    while i < 10 do
    
	insert into boss (name) values (i);
        set i = i + 1;
        end while;


end $$
delimiter ;

call my_pro11_while();

select *
from boss;

既有输入又有输出参数的存储过程

-- 输出模式

delimiter $$
create procedure my_por2( IN in_param  varchar(30),
		         OUT out_param varchar(30))
-- 存储过程体
begin
-- 查询员工表中id为103号员工的信息
select last_name into out_param
from employees
where employee_id = in_param;
end $$
delimiter ;


set @param := null;
call my_por2(103, @param);

select @param;

有多个输出参数的存储过程

-- 如果要返回一行多列的数据 
delimiter $$
create procedure my_por5( IN in_param  varchar(30),
	          OUT out_param varchar(30),
                          OUT out_param1 varchar(30),
                          OUT out_param2 varchar(30))

begin
select d.department_name, d.department_id, d.location_id   into out_param, out_param1, out_param2
from employees as e inner join departments as d
on e.department_id = d.department_id
and e.last_name = in_param;
end $$
delimiter ;

set @my_out1 := null;
set @my_out2 := null;
set @my_out3 := null;
call my_por5('Hunold', @my_out1, @my_out2, @my_out3);

select @my_out1, @my_out2,@my_out3;

只有输入参数的存储过程

delimiter $$
create procedure my_por1( IN in_param  varchar(30))
-- 存储过程体
begin
-- 查询员工表中id为103号员工的信息
select *
from employees
where employee_id = in_param;
end $$
delimiter ;

-- 调用存储过程
call my_por1(103);

子查询

from后子查询

-- from后子查询：子句当成一个表来使用，要有字段名字和表名
-- 一般将分组查询的表格作为from后子查询的子表
-- select后子查询，两表之间的关联写在子句里面，from后子查询两表之间的关联写在外面

-- 每个部门的平均工资的工资等级
select *
from (select avg(salary) as ag
from employees
group by department_id) as ag_emp inner join job_grades as j
on ag_emp.ag between j.lowest_sal and j.highest_sal;


-- 查询员工工资比本部门平均工资高（不包含临界值）的员工的员工号，姓名和工资
SELECT employee_id,last_name,salary,e.department_id
FROM employees e
INNER JOIN (
    SELECT AVG(salary) ag,department_id
    FROM employees
    GROUP BY department_id
) ag_dep
ON e.department_id = ag_dep.department_id
WHERE salary > ag_dep.ag;

select后子查询

-- select后子查询：子句当成一个字段来使用

-- 利用部门表查询每个部门的员工个数、部门编号、部门名称
select d.department_id, d.department_name, 
(select count(employee_id)
from employees
where d.department_id = employees.department_id)
from departments as d;

标量子查询

-- 标量子查询：子查询的结果是一个标量
-- 查询工资比105号员工高的所有人信息

select *
from employees
where salary > (select salary
from employees
where employee_id = 105);

行子查询

-- 行子查询：子句返回结果集是一行多列
-- 行子查询可以使用等号，但是不可以使用大于、大于等于、小于、小于等于这类符号
-- 查询与103号年龄和工资都相同的人的信息alter

select *
from employees
where (year, salary) =
(select year, salary
from employees
where employee_id = 1);

列子查询

-- 列子查询：子查询的结果是一列多行
-- 查询比103号或104号员工高的员工的信息

select *
from employees
where salary > any(select salary
from employees
where employee_id in(103,104));

相关子查询

-- 相关子查询：子句有值的话返回true，主句才会进行比对和显示。如果为空的话就不会显示。
-- 相关子查询的子表写在where后面
-- 相关子查询的效率特别高，输出只有两个布尔值，ture和false

-- 查询部门表是否存在年龄大于21岁的员工，如果存在则输出该部门的信息。
select *
from departments
where exists (
select *
from employees
where employees.department_id = departments.department_id
and year > 21
);

其它

不等值内连接

-- 不等值内连接
-- 查询员工所对应的工资等级alter
select j.grade_level,e.last_name
from employees as e inner join job_grades as j
on e.salary between j.lowest_sal and j.highest_sal
and e.last_name = 'Hunold';

将数据按照第一个排序，如果第一个相同的情况下按照第二个排序

select * 
from rank 
order by times asc, time asc;

游标的使用

-- 游标

DELIMITER $$
create PROCEDURE my_pro12()
begin
-- 声明一个标志done， 用来判断游标是否遍历完
DECLARE done INT DEFAULT 0;
-- 声明一个变量，用来存放从游标中提取的数据
-- 特别注意这里的名字不能与由游标中使用的列明相同，
-- 否则得到的数据都是NULL
DECLARE lastName varchar(30) DEFAULT NULL;
DECLARE salaryParam int DEFAULT NULL;
-- 声明游标对应的 SQL 语句
DECLARE cur CURSOR FOR
select last_name, salary from employees;
-- 在游标循环到最后会将 done 设置为 1
DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = 1;
-- 执行查询
open cur;
-- 遍历游标每一行
REPEAT
-- 把一行的信息存放在对应的变量中
FETCH cur INTO lastName, salaryParam;
if not done then
-- 这里就可以使用 lastName， salaryParam 对应的信息了
select lastName, salaryParam;
end if;
UNTIL done END REPEAT;
CLOSE cur;
end $$
DELIMITER ;

call my_pro12();
qq_40640737
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA中MySQL建立连接
weixin_30824277的博客
01-29 391
下面是在JAVA中与MySQL建立连接的一个模块： package com.han; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; /** * SQL connection module * @author HAN * */ public cla...
java 建立连接mysql_如何在JAVA中建立MySQL连接
weixin_29823011的博客
02-03 144
我的Java程序似乎无法连接到Java,我已经启动了MySQL服务器,在phpMyAdmin中创建了一个数据库。但我对如何使用从MySQL下载的JDBC驱动程序感到困惑。这是我的代码:private void startConnection(){Connection conn = null;String url = "jdbc:mysql://localhost/";String dbName =...
Java连接mysql数据库的详细教程（增查）
LeeChance的专栏
06-24 1万+
Java连接mysql数据库的详细教程（增查）
java怎么连接mysql数据库
weixin_35752122的博客
01-04 523
要在 Java 中连接 MySQL 数据库，您需要以下步骤： 安装 MySQL 驱动。可以使用 MySQL 官方的 Connector/J 驱动，也可以使用其他的驱动。 导入 JDBC 包。要使用 JDBC，您需要导入 java.sql 包。 加载并注册驱动。需要使用 Class.forName() 方法加载并注册驱动。 创建连接。使用 DriverManager.getConnectio...
java连接mysql数据库及测试是否连接成功的方法
08-29
Java 连接 MySQL 数据库及测试是否连接成功的方法 Java 连接 MySQL 数据库...本文详细介绍了 Java 连接 MySQL 数据库的方法，包括获取连接对象、执行 SQL 语句和关闭资源。希望本文能够对大家 Java 程序设计有所帮助。
Java连接MySQL的依赖包
05-04
在Java编程中，连接MySQL数据库是一项基础且重要的任务。为了实现这一目标，开发人员需要引入特定的驱动程序，即MySQL的Java连接器（JDBC驱动）。在这个场景中，提到的"mysql-connector-java-5.1.7-bin.jar"正是这样...
Java使用jdbc连接MySQL数据库实例分析
08-27
Java语言可以通过jdbc（Java Database Connectivity）连接MySQL数据库，实现数据的存储和读取。在本文中，我们将详细介绍Java使用jdbc连接MySQL数据库的实例分析。 配置文件db.properties 在使用jdbc连接MySQL...
学生信息管理系统--java连接mysql
12-04
《学生信息管理系统——Java连接MySQL实战指南》 在信息技术领域，数据库管理是不可或缺的一部分，而Java作为广泛应用的编程语言，其与数据库的交互能力尤为重要。本项目“学生信息管理系统”正是一个利用Java语言...
mysql-connector-java java连接mysql库
11-16
3. 创建连接：使用`DriverManager.getConnection()`方法创建数据库连接，传入数据库URL、用户名和密码，如`Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase", "username", ...
Java连接MySQL数据库方法
m0_73685411的博客
05-10 7326
Java链接数据库的方法
mysql和java建立连接_JAVA中MySQL建立连接
weixin_29972227的博客
01-21 202
下面是在JAVA中与MySQL建立连接的一个模块：package com.han;import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;/*** SQL connection module* @author HAN**/public class Conn {Connection c...
Java连接Mysql数据库步骤详细讲解
玄衣手记
09-21 2万+
java连接mysql数据库操作步骤详细讲解，解决输出中文乱码问题，使用maven工程，jdbc，实现mysql数据库数据查询。逐步讲解，适合初学者和零基础者。
Java连接 MySQL详细教程，分享复习经验和后台开发面经
m0_63174475的博客
11-07 396
（由于安装了汉化包，英文版的用户可以对应图标来操作） 选中菜单栏文件，之后选择项目结构 选择Libraries 点击+ ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210321181721553.png?x-oss- 【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】 浏览器打开：qq.cn.hn/FTf 免费领取 process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow
JAVA连接Mysql——JDBC详细教程
Smile的博客
11-01 5679
组件名称简介常用方法名称简介参数返回值类型这个类管理一系列数据库驱动程序。匹配连接使用通信子协议从 JAVA 应用程序中请求合适的数据库驱动程序。识别 JDBC 下某个子协议的第一驱动程序将被用于建立数据库连接。尝试建立与给定数据库URL的连接。url- 表单的数据库网址。user- 代表其建立连接的数据库用户。password- 用户密码。ConnectionConnection与特定数据库的连接会话。执行SQL语句，并在连接的上下文中返回结果。
Java连接MySQL数据库的超级详细步骤（Windows）
热门推荐
firstlt0217的博客
05-19 11万+
1. 数据准备 1. 下载JDK 下载Java开发工具包JDK，下载地址：https://www.oracle.com/java/technologies/javase-jdk14-downloads.html，下载待用。 2. 下载Mysql Java 连接 MySQL 需要驱动包，下载地址为：http://dev.mysql.com/downloads/connector/j/。 解压后得到 jar 库文件，待用，最终会将红框文件导入相应项目文件中。 3. 下载MySQL 下载地址：https:/
【JDBC编程】Java连接MySQL的五个步骤
最新发布
2203_75565612的博客
03-22 1213
这里可以看到Java使用数据库的代码非常多，而且每次连接都需要重复这个过程，于是就有大佬写了数据库框架Mybatis，把上面的代码都封装了起来，用的时候只需要一条注解就可以了。里的数据一行一行排列，每行有多个字段，并且有一个记录指针，指针所指的数据行叫做当前数据行，我们只能来操作当前的数据行。连接池在初始化时将创建一定数量的数据库连接，这些连接是可以复用的，每次使用完数据库连接，释放资源调用connection.close()连接，是无法重复利用的，每次使用完以后释放资源。方法提供了对这些行中数据的访问。
Java和MySQL的连接和操作（JDBC）
weixin_52068218的博客
12-12 6468
Java和数据库的连接和操作
全面了解Java连接MySQL的基础知识，快速实现数据交互
沉淀、分享、成长，让自己和他人都能有所收获！
05-23 2万+
简单介绍MySQL数据库的基本概念、安装步骤以及如何创建新的数据库和表。1.下载和安装 MySQL Connector/J 驱动程序；2.创建 Connection 对象以连接数据库；3.使用 Statement 和 PreparedStatement 对象执行 SQL 查询和更新操作；4.处理 SQL 查询语句返回的结果集；5.捕获和处理可能出现的异常；6.释放资源。通过学习本文，您可以了解到如何使用 Java 程序连接 MySQL 数据库，并执行查询和更新操作。
Java连接MySQL数据库完整指南
"这份文档详细介绍了如何使用Java连接MySQL数据库，包括所需软件的下载和安装步骤。" 在Java编程中，连接MySQL数据库是一项基础且重要的任务。本攻略将引导你完成这一过程，主要包括两个主要阶段：软件下载和安装。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值