[JavaWeb_兄弟连_马剑威]_020_JDBC实现简单增删改操作

JavaWeb开发之JDBC的增删改查项⽬搭建的包命名和类命名：⾸先导⼊数据库的驱动架包，并添加依赖1.Dao层是专门负责和数据库交互，数据处理的代码层2.Dao是接⼝，DaoImpl是Dao接⼝的实现类3.Java代码连接数据库的步骤：“贾琏欲执事”⼝诀 （1）贾：加载数据库注册驱动,将数据库驱动注册到DriverManager中去。

Class.forName("com.mysql.jdbc.Driver"); （2）琏：创建连接数据库的对象，通过DriverManager获取 Connection conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "123456"); （3）欲：创建预编译或⾮预编译 SQL语句对象 String sql="update t_student set name = ?,age = ? where id = ?"; PrepardStatment ps =conn.preparedStatment(sql); ps.setString(1，"⼩明"); ps.setInt(2，20)； ps.setInt(3，2)； （4）执：执⾏SQL语句 int row =ps.executeUpdate(); （5）事：释放资源（先创后放） conn.close(); ps.close();具体代码：@Overridepublic int insert(Student stu) {String sql = "insert into t_student(name,age)values(?,?)";Connection conn = null;PreparedStatement ps = null;try {// 1.加载注册驱动Class.forName("com.mysql.jdbc.Driver");// 2.获取数据库连接对象conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root"); // 3.创建预编译语句对象ps = conn.prepareStatement(sql);// 3.1设置预编译语句对象占位符对应的参数值ps.setString(1, stu.getName());ps.setInt(2, stu.getAge());// 4.执⾏SQL语句 (注意：⽅法不能带sql参数)int row = ps.executeUpdate();return row;} catch (Exception e) {e.printStackTrace();} finally {try {if (ps != null) {ps.close();}} catch (SQLException e) {e.printStackTrace();} finally {try {if (conn != null) {conn.close();}} catch (SQLException e) {e.printStackTrace();}}}return 0;}@Overridepublic int delete(Integer id) {String sql = "delete from t_student where id = ?";Connection conn = null;PreparedStatement ps = null;try {// 1.加载注册驱动Class.forName("com.mysql.jdbc.Driver");// 2.获取数据库连接对象conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root"); // 3.创建预编译语句对象ps = conn.prepareStatement(sql);// 3.1设置预编译语句对象占位符对应的参数值ps.setInt(1, id);// 4.执⾏SQL语句 (注意：⽅法不能带sql参数)int row = ps.executeUpdate();return row;} catch (Exception e) {e.printStackTrace();} finally {try {if (ps != null) {ps.close();}} catch (SQLException e) {e.printStackTrace();} finally {try {if (conn != null) {conn.close();}} catch (SQLException e) {e.printStackTrace();}}}return 0;}@Overridepublic int update(Student stu) {String sql = "update t_student set name = ?,age = ? where id = ?";Connection conn = null;PreparedStatement ps = null;try {// 1.加载注册驱动Class.forName("com.mysql.jdbc.Driver");// 2.获取数据库连接对象conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root"); // 3.创建预编译语句对象ps = conn.prepareStatement(sql);// 3.1设置预编译语句对象占位符对应的参数值ps.setString(1, stu.getName());ps.setInt(2, stu.getAge());ps.setInt(3, stu.getId());// 4.执⾏SQL语句 (注意：⽅法不能带sql参数)int row = ps.executeUpdate();return row;} catch (Exception e) {e.printStackTrace();} finally {try {if (ps != null) {ps.close();}} catch (SQLException e) {e.printStackTrace();} finally {try {if (conn != null) {conn.close();}} catch (SQLException e) {e.printStackTrace();}}}return 0;}@Overridepublic Student selectByPrimaryKey(Integer id) {String sql = "select * from t_student where id = ?";Connection conn = null;PreparedStatement ps = null;ResultSet rs = null;try {// 1.加载注册驱动Class.forName("com.mysql.jdbc.Driver");// 2.获取数据库连接对象conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root"); // 3.创建预编译语句对象ps = conn.prepareStatement(sql);ps.setInt(1, id);// 4.执⾏sql语句rs = ps.executeQuery();while (rs.next()) {String name = rs.getString("name");int age = rs.getInt("age");// 封装Student对象Student stu = new Student(id, name, age);//返回Student对象return stu;}} catch (Exception e) {e.printStackTrace();} finally {try {if (rs != null) {rs.close();}} catch (SQLException e) {e.printStackTrace();} finally {try {if (ps != null) {ps.close();}} catch (SQLException e) {e.printStackTrace();} finally {try {if (conn != null) {conn.close();}} catch (SQLException e) {e.printStackTrace();}}}}return null;}@Overridepublic List<Student> selectList() {List<Student> students = new ArrayList<>();String sql = "select * from t_student";Connection conn = null;PreparedStatement ps = null;ResultSet rs = null;try {// 1.加载注册驱动Class.forName("com.mysql.jdbc.Driver");// 2.获取数据库连接对象conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root"); // 3.创建预编译语句对象ps = conn.prepareStatement(sql);// 4.执⾏sql语句rs = ps.executeQuery();while (rs.next()) {int id = rs.getInt("id");String name = rs.getString("name");int age = rs.getInt("age");// 封装Student对象Student stu = new Student(id, name, age);// 学⽣对象添加到集合中students.add(stu);}} catch (Exception e) {e.printStackTrace();} finally {try {if (rs != null) {rs.close();}} catch (SQLException e) {e.printStackTrace();} finally {try {if (ps != null) {ps.close();}} catch (SQLException e) {e.printStackTrace();} finally {try {if (conn != null) {conn.close();}} catch (SQLException e) {e.printStackTrace();}}}}return students;}。

通过Java代码实现对数据库的数据进⾏操作：增删改查（JDBC）在写代码之前，依然是引⽤mysql数据库的jar包⽂件：右键项⽬—构建路径—设置构建路径—库—添加外部JAR在数据库中我们已经建⽴好⼀个表xs ；分别有xuehao xingming xuexiao 三个列然后我们开始码代码调⽤，进⾏增删改查⾸先是增加import java.sql.*;public class XueYuan {public static void main(String[] args) throws Exception {Class.forName("com.mysql.jdbc.Driver");//加载驱动String jdbc="jdbc:mysql://127.0.0.1:3306/mydb?characterEncoding=GBK";Connection conn=DriverManager.getConnection(jdbc, "root", "");//链接到数据库Statement state=conn.createStatement(); //容器String sql="insert into xs values('1108','张伟','汉企')"; //SQL语句state.executeUpdate(sql); //将sql语句上传⾄数据库执⾏conn.close();//关闭通道}执⾏后，数据中多了⼀⾏数据删除数据import java.sql.*;public class XueYuan {public static void main(String[] args) throws Exception {Class.forName("com.mysql.jdbc.Driver");//加载驱动String jdbc="jdbc:mysql://127.0.0.1:3306/mydb?characterEncoding=GBK";Connection conn=DriverManager.getConnection(jdbc, "root", "");//链接到数据库Statement state=conn.createStatement(); //容器String sql="delete from xs where xuehao='1108'"; //SQL语句state.executeUpdate(sql); //将sql语句上传⾄数据库执⾏conn.close();//关闭通道}}执⾏后，数据库中xuehao为“1108”的数据的整⾏被删掉修改数据import java.sql.*;public class XueYuan {public static void main(String[] args) throws Exception {Class.forName("com.mysql.jdbc.Driver");//加载驱动String jdbc="jdbc:mysql://127.0.0.1:3306/mydb?characterEncoding=GBK";Connection conn=DriverManager.getConnection(jdbc, "root", "");//链接到数据库Statement state=conn.createStatement(); //容器String sql="update xs set xuexiao='淄博汉企' where xuehao='1101' "; //SQL语句state.executeUpdate(sql); //将sql语句上传⾄数据库执⾏conn.close();//关闭通道}}数据库中的1101对应的xuexiao发⽣了改变⼩结：数据的增删改⼏乎是⼀样的唯⼀不同的是SQL语句不同⽽已查询数据查询数据和增删改不同的地⽅是，我们需要获取，⽽正常获取时，我们获取到的是⼀个字符集import java.sql.*;import javax.xml.stream.events.StartElement;public class Test3 {public static void main(String[] args) throws Exception {//导⼊驱动包Class.forName("com.mysql.jdbc.Driver");//链接⾄数据库String jdbc="jdbc:mysql://127.0.0.1:3306/mydb";Connection conn=DriverManager.getConnection(jdbc, "root", "");Statement state=conn.createStatement();//容器String sql="select * from xs"; //sql语句ResultSet rs=state.executeQuery(sql); //将sql语句传⾄数据库，返回的值为⼀个字符集⽤⼀个变量接收while(rs.next()){ //next（）获取⾥⾯的内容System.out.println(rs.getString(1)+" "+rs.getString(2)+" "+rs.getString(3));//getString（n）获取第n列的内容//数据库中的列数是从1开始的}conn.close();}获取的结果例⼦：输⼊账号和密码，在数据库中获取，如果有该信息，则显⽰其登陆成功，如果没有，则显⽰输⼊错误有两种⽅法可以实现：import java.sql.*;import java.util.*;public class Login {public static void main(String[] args) throws Exception {// 输⼊⽤户名和密码Scanner sc=new Scanner(System.in);System.out.println("请输⼊账号");String zh=sc.nextLine();System.out.println("请输⼊密码");String mm=sc.nextLine();// zh=zh.replaceAll("\'", "\""); //替换// mm=mm.replaceAll("\'", "\""); //替换//到数据库验证⽤户名和密码是否正确Class.forName("com.mysql.jdbc.Driver");Connection conn=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mydb", "root", "");Statement state=conn.createStatement();String sql="select * from yonghu where zhanghao='"+zh+"' and mima='"+mm+"'";ResultSet re=state.executeQuery(sql);//输出：正确显⽰欢迎，不正确显⽰错误if(re.next()){System.out.println("登陆成功！"+re.getString(3)+" 欢迎你");}else{System.out.println("输⼊账号或密码错误");}conn.close();}}实现了该功能但是如果我们输⼊同样会显⽰登陆成功（sql注⼊攻击），为避免出现这种情况我们加⼊两个替换zh=zh.replaceAll("\'", "\"") 将输⼊的所有单引号全部换成双引号，就可以避免这样的漏洞;但是这种⽅法治标不治本，根本原因是字符串的拼接的原因从根本上解决问题还有⼀种写法在SQL语句中，不确定的条件⽤?代替，PreparedStatement（sql）容器来装 setString（ n ，m）来赋值n是第⼏个问号的位置，m是赋import java.sql.*;import java.util.*;public class Login {public static void main(String[] args) throws Exception{//输⼊⽤户名和密码Scanner sc=new Scanner(System.in);System.out.println("请输⼊账号");String zh=sc.nextLine();System.out.println("请输⼊密码");String mm=sc.nextLine();Class.forName("com.mysql.jdbc.Driver");String jdbc="jdbc:mysql://127.0.0.1:3306/mydb";Connection conn=DriverManager.getConnection(jdbc, "root", "");String sql="select * from yonghu where zhanghao=? and mima=?"; //sql语句PreparedStatement state=conn.prepareStatement(sql); //容器state.setString(1, zh); //将第n个值替换成某个值state.setString(2, mm);ResultSet re=state.executeQuery(); //上传数据库返回结果集if(re.next()){ //如果取到了值，那么输出System.out.println("登陆成功"+re.getString(3)+"，欢迎你");}else{System.out.println("登陆失败，账号或密码输⼊错误");}}。

JAVA数据库基本操作增删改查增：一、使用JDBCAPI操作数据库1、创建jdbc对象：为了访问数据库需要创建一个jdbc对象，使用DriverManager类的static方法getConnection(创建jdbc对象。

2、获取Statement对象：通过jdbc.createStatement(方法创建一个Statement对象，使用executeUpdate(方法执行SQL语句。

3、执行sql语句：使用前面创建的Statement对象执行SQL语句，例如，执行INSERT语句则需要使用executeUpdate(方法将要插入的数据插入数据库。

4、关闭jdbc对象：通过jdbc对象的close(方法关闭jdbc对象，以便释放资源，并将数据插入数据库。

二、使用Hibernate框架操作数据库1、创建SessionFactory对象：Hibernate框架使用SessionFactory类来管理数据库的连接，并从数据库中加载实体，进行数据的操作。

SessionFactory对象维护一个连接池，利用它可以创建多个Session对象。

2、创建Session对象：Hibernate框架使用Session类来管理数据，使用SessionFactory对象的openSession(方法可以创建Session对象，并从连接池中获取需要的连接。

3、获取Transaction对象：Session类的beginTransaction(方法可以创建Transaction对象，用于控制数据库的事务。

4、执行SQL语句：使用Session对象的save(方法执行SQL语句，向数据库中插入数据。

6、关闭session：使用Session对象的close(方法关闭session，释放资源。

删：一、使用JDBCAPI操作数据库。

java项目中实现增删改查基本流程Java项目中实现增删改查基本流程引言本文将详细讨论在Java项目中实现增删改查的基本流程。

通过该流程，我们可以在项目中对数据进行操作，包括创建、读取、更新和删除。

步骤一：创建在创建数据之前，首先需要创建数据库和相应的表。

接下来，我们可以通过以下步骤创建具体的数据：1.创建模型类：创建一个Java类来表示数据模型，包含需要的属性和方法。

2.设计数据库表结构：根据模型类的属性，设计数据库表结构，确定每个属性对应的字段。

3.编写DAO（数据访问对象）类：该类用于实现对数据库的访问操作，包括插入数据到数据库中。

4.实例化模型类：在业务逻辑层中，实例化模型类，并设置相应的属性值。

5.调用DAO类的插入方法：在业务逻辑层中，调用DAO类的插入方法，将数据插入到数据库中。

步骤二：读取读取数据是对数据库进行查询操作，获取需要的数据。

下面是读取数据的基本流程：1.编写DAO类的查询方法：在DAO类中编写查询方法，根据需要的条件和属性查询数据。

2.调用DAO类的查询方法：在业务逻辑层中，调用DAO类的查询方法，获取查询结果。

3.处理查询结果：根据返回的结果集，进行数据的处理和展示。

步骤三：更新更新数据是对数据库中已有数据的修改操作。

下面是更新数据的基本流程：1.编写DAO类的更新方法：在DAO类中编写更新方法，根据需要的条件和属性更新数据。

2.实例化模型类并设置属性值：在业务逻辑层中，实例化模型类，并设置需要更新的属性值。

3.调用DAO类的更新方法：在业务逻辑层中，调用DAO类的更新方法，更新数据。

步骤四：删除删除数据是在数据库中删除指定的数据记录。

下面是删除数据的基本流程：1.编写DAO类的删除方法：在DAO类中编写删除方法，根据需要的条件删除数据。

2.调用DAO类的删除方法：在业务逻辑层中，调用DAO类的删除方法，删除数据。

结论在一个Java项目中，实现增删改查的基本流程是创建、读取、更新和删除。

Java使用JDBC连接MYSQL数据库增删改查示例JDBC连接MYSQL数据库：import java.sql.Connection;import java.sql.DriverManager;public class Mysql {public static void main(String arg[]) {try {Connection con = null; //定义一个MYSQL链接对象Class.forName("com.mysql.jdbc.Driver").newInstance(); //MYSQL 驱动con =DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test", "root", "root"); //链接本地MYSQLSystem.out.print("yes");} catch (Exception e) {System.out.print("MYSQL ERROR:" + e.getMessage());}}}</pre>Class.forName("com.mysql.jdbc.Driver").newInstance(); 我们链接的是MYSQL 数据库，所以需要一个MYSQL的数据库驱动，如果你的环境中没有安装，可以下载：mysql-connector-java-5.1.17-bin.jar JAR包，然后放进jdk1.6.0_37\jre\lib\ext 重启eclispe 就可以在JRE系统库中看到。

con = DriverManager.getConnection;("jdbc:mysql://127.0.0.1:3306/test", "root", "root"); 是链接数据库的语句，返回Connection con;对象。

《java web》实验报告利用JDBC实现DAO对数据库进行增删改查一、实验目的学会利用JDBC实现DAO对数据库进行增删改查。

二、实验环境Windows10操作系统，谷歌浏览器，Myeclipse2014。

三、实验内容与实验过程及分析（写出详细的实验步骤，并分析实验结果）实验：利用JDBC实现DAO对数据库进行增删改查实验步骤：利用JDBC实现DAO对数据库进行增删改查测试类：package test;import java.util.Date;import erDao;import erDaoImpl;import er;public class UserDaoTest {public static void add(User user){UserDao userDao = new UserDaoImpl();userDao.insertUser(user);}public static void delete(int userid){UserDao userDao = new UserDaoImpl();userDao.deleteUser(userid);}public static void uppdate(User user){UserDao userDao = new UserDaoImpl();userDao.updateUser(user);}public static User select(int userid){UserDao userDao = new UserDaoImpl();return userDao.getUser(userid);}public static void main(String[] args) {// TODO Auto-generated method stubUser user = new User();short gender = 1;user.setUsername("quaner");user.setUserpass("1234560");user.setHead("Administrator");user.setGender(gender);user.setRegtime("2019-5-4");// add(user);User us = select(21);System.out.println("userid=" + us.getUserid() + ", username=" + us.getUsername()+ ", regtime=" + us.getRegtime() + ", userpass=" + us.getUserpass() + ", head="+ us.getHead() + ", gender=" + us.getGender());// delete(16);// uppdate(user);}}实验结果图为：四、 实验总结（每项不少于20字）存在问题：代码书写不够熟练，关于实现DAO 连接数据库对数据库进行操作还有许多不足的地方。

myeclipse中JDBC连接mysql和简单的增删改查废话不多说，直接上操作图，操作起来理解会更彻底1、myeclipse中项⽬结构，先在web-inf-lib下导⼊jar包，注意Web App Libraries这个⽬录，下⾯会有⽤到的地⽅2、连接语句package utils;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import com.sun.corba.se.spi.orbutil.fsm.Guard.Result;public class BaseDao {//第⼀步：先设置四个常量（url数据库地址，username数据库⽤户名，password数据库密码，driver数据库驱动）private static final String URL = "jdbc:mysql://127.0.0.1:3306/petshop?characterEncoding=utf-8";private static final String USERNAME = "root";private static final String PASSWORD = "ok";private static final String DRIVER = "com.mysql.jdbc.Driver";//Web App Libraries -- mysql-connector.jar--下的⽂件名//1.加载驱动，⽤静态块//jdbc是java提供给各⼤数据库开发商的⼀些接⼝（规则）,⽽驱动就是这些规则的具体实现⽅法static{try {Class.forName(DRIVER);//要求JVM查找并加载指定的类，也就是注册mysql实现的驱动类} catch (ClassNotFoundException e) {e.printStackTrace();}}//2.获取数据库连接，通过在DriverManager驱动管理类中设置参数public Connection getConnection() throws SQLException{return DriverManager.getConnection(URL,USERNAME,PASSWORD);}//3.创建预编译执⾏对象PreparedStatementpublic PreparedStatement createPreparedStatement(Connection conn,String sql,Object... params) throws SQLException{//从当前的conn对象中，获取执⾏对象，把预编译sql语句放⼊其中PreparedStatement pstmt = conn.prepareStatement(sql);//如果预编译sql中有占位符，则表⽰要赋值if(params!=null && params.length>0){//通过遍历，将params对象集合中的元素⼀⼀对应付给占位符for(int i=1;i<=params.length;i++){pstmt.setObject(i, params[i-1]);}}return pstmt;//带有sql语句的预编译执⾏对象}//4.创建公共DML执⾏⽅法public int executeDML(String sql,Object... params){int result = 0;//⽤于返回受影响的⾏数来判断是否执⾏成功//创建两个数据库对象Connection conn = null;//数据库连接对象PreparedStatement pstmt = null;//预编译执⾏对象,接收try {conn = this.getConnection();pstmt = this.createPreparedStatement(conn, sql, params);result = pstmt.executeUpdate();} catch (SQLException e) {e.printStackTrace();} finally{closeAll(conn,pstmt,null);}return result;}//5.释放公共资源⽅法void closeAll(Connection conn, PreparedStatement pstmt,ResultSet rs) {try {if(rs!=null)rs.close();} catch (SQLException e) {e.printStackTrace();}finally{try {if(pstmt!=null)pstmt.close();} catch (SQLException e) {e.printStackTrace();}finally{try {if(conn!=null)conn.close();} catch (SQLException e) {e.printStackTrace();}}}}}3、测试类中的代码，实现简单的增删改查package utils;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.util.Scanner;public class TestDML {static Scanner input = new Scanner(System.in);public static void main(String[] args) {System.out.println("请选择您要执⾏的操作\n1.执⾏ 2.删除 3.修改4.查所有"); TestDML test = new TestDML();int choose = input.nextInt();switch (choose) {case 1://新增test.insertNewGrade();break;case 2://删除test.delGrade();break;case 3://修改test.updateGrade();break;case 4://查询test.selectAll();break;}}private void selectAll() {BaseDao bd = new BaseDao();Connection conn = null;String sql = "select * from petstore";PreparedStatement pstmt=null;ResultSet rs = null;try {conn = bd.getConnection();//获取数据库链接对象pstmt = bd.createPreparedStatement(conn, sql);rs = pstmt.executeQuery();System.out.println("id\tname\tpassword\tbalance");while(rs.next()){System.out.println(rs.getInt(1)+"\t"+rs.getString(2)+"\t"+rs.getString(3)+"\t"+rs.getInt(4)); }} catch (SQLException e) {e.printStackTrace();}finally{bd.closeAll(conn,pstmt,rs);}}private void updateGrade() {System.out.println("请输⼊要修改的id编号：");int Id = input.nextInt();System.out.println("请输⼊新的id：");int id = input.nextInt();System.out.println("请输⼊新的name：");String name = input.next();System.out.println("请输⼊新的password：");String password = input.next();System.out.println("请输⼊新的balance：");String balance = input.next();//执⾏插⼊语句，需要传⼊sql和paramsBaseDao bd = new BaseDao();String sql = "update petstore set id=?, name=?,password=?,balance = ? where id=?"; Object[] params = {id,name,password,balance,Id};int result = bd.executeDML(sql, params);if(result>0){System.out.println("修改成功");}else{System.out.println("修改失败");}}private void delGrade() {System.out.println("请输⼊要删除的id：");int id = input.nextInt();//执⾏插⼊语句，需要传⼊sql和params BaseDao bd = new BaseDao();String sql = "delete from petstore where id=?"; Object[] params = {id};int result = bd.executeDML(sql, params);if(result>0){System.out.println("删除成功");}else{System.out.println("删除失败");}}private void insertNewGrade() {//执⾏新增（年级编号，年级名称）System.out.println("请输⼊id：");int id = input.nextInt();System.out.println("请输⼊name：");String name = input.next();System.out.println("请输⼊password："); String password = input.next();System.out.println("请输⼊balance：");String balance = input.next();//执⾏插⼊语句，需要传⼊sql和params BaseDao bd = new BaseDao();String sql = "insert into petstore value (?,?,?,?)"; Object[] params = {id,name,password,balance}; int result = bd.executeDML(sql, params);if(result>0){System.out.println("新增成功");}else{System.out.println("新增失败");}}}4、效果，下⾯是表中原有的⼀个数据1、插⼊2、删除3、更新4、查看表数据以上。

jdbc数据库增、删、改、查语句一、增加数据1. 插入单行数据在JDBC中，我们可以使用INSERT INTO语句来向数据库中插入单行数据。

例如，我们要向student表中插入一条新的学生记录，可以使用以下语句：INSERT INTO student (id, name, age) VALUES (1, '张三', 18);2. 批量插入数据如果我们要向数据库中插入多行数据，可以使用批量插入的方式，以提高效率。

例如，我们要向student表中插入多条新的学生记录，可以使用以下语句：INSERT INTO student (id, name, age) VALUES (1, '张三', 18), (2, '李四', 20), (3, '王五', 22);二、删除数据1. 删除指定行数据在JDBC中，我们可以使用DELETE FROM语句来删除数据库中的指定行数据。

例如，我们要删除student表中id为1的学生记录，可以使用以下语句：DELETE FROM student WHERE id = 1;2. 删除所有数据如果我们要删除数据库中的所有数据，可以使用DELETE FROM语句，并不指定任何条件。

例如，我们要删除student表中的所有学生记录，可以使用以下语句：DELETE FROM student;三、修改数据1. 更新指定行数据在JDBC中，我们可以使用UPDATE语句来更新数据库中的指定行数据。

例如，我们要将student表中id为1的学生记录的年龄修改为20岁，可以使用以下语句：UPDATE student SET age = 20 WHERE id = 1;2. 批量更新数据如果我们要更新数据库中的多行数据，可以使用批量更新的方式，以提高效率。

例如，我们要将student表中id为1和2的学生记录的年龄都修改为20岁，可以使用以下语句：UPDATE student SET age = 20 WHERE id IN (1, 2);四、查询数据1. 查询所有数据在JDBC中，我们可以使用SELECT语句来查询数据库中的数据。

java项目中的增删改查方法在Java项目中，增删改查（CRUD）操作是非常常见的需求。

无论是开发Web应用、移动应用还是后台系统，都会涉及到对数据的增加、删除、修改和查询操作。

在Java中，我们通常使用数据库来存储数据，而针对数据库的增删改查操作，我们通常会使用SQL语句来实现。

下面我们来看看在Java项目中，如何实现增删改查方法。

1. 增加（Create），在Java项目中，要实现数据的增加操作，通常需要先连接数据库，然后使用SQL语句向数据库中插入新的数据。

在Java中，我们可以使用JDBC（Java Database Connectivity）来连接数据库，使用PreparedStatement或者Statement来执行插入操作。

另外，如果我们使用了ORM框架（如Hibernate或MyBatis），我们也可以通过框架提供的API来实现数据的插入操作。

2. 删除（Delete），删除数据操作通常是根据某个条件从数据库中删除符合条件的数据。

在Java项目中，我们可以使用SQL的DELETE语句来实现数据的删除操作。

同样地，我们可以使用JDBC或者ORM框架提供的API来执行删除操作。

3. 修改（Update），修改数据操作通常是根据某个条件更新数据库中的数据。

在Java项目中，我们可以使用SQL的UPDATE语句来实现数据的更新操作。

同样地，我们可以使用JDBC或者ORM框架提供的API来执行更新操作。

4. 查询（Retrieve），查询数据操作是从数据库中检索数据。

在Java项目中，我们可以使用SQL的SELECT语句来实现数据的查询操作。

同样地，我们可以使用JDBC或者ORM框架提供的API来执行查询操作，并将查询结果返回给Java应用程序。

总的来说，在Java项目中实现增删改查方法，我们通常会使用JDBC来连接数据库并执行SQL语句，或者使用ORM框架来简化数据库操作。

无论是使用JDBC还是ORM框架，都需要对数据库操作有一定的了解，以便能够编写出高效、安全的增删改查方法。

JDBC增删改查实验报告一、引言数据库是现代软件开发中不可或缺的一部分，而对数据库的操作也是开发中最常见的任务之一。

JDBC（Java Database Connectivity）是Java语言中用于与数据库进行交互的API。

本实验将通过使用JDBC进行增删改查操作，探索JDBC在数据库操作中的应用。

二、实验目的通过本实验，我们将达到以下目的： 1. 理解JDBC的基本概念和原理； 2. 掌握使用JDBC进行数据库连接和操作的方法； 3. 熟悉JDBC在增删改查中的应用； 4. 实践使用JDBC进行数据库操作。

三、实验环境本实验使用以下环境： - 操作系统：Windows 10 - JDK版本：Java 8 - 数据库：MySQL 8.0 - IDE：Eclipse四、实验步骤4.1 数据库准备在MySQL数据库中创建一个名为”test_db”的数据库，并创建一个名为”users”的表，表结构如下：CREATE TABLE users (id INT PRIMARY KEY AUTO_INCREMENT,name VARCHAR(50),age INT,email VARCHAR(50));4.2 配置JDBC连接在Java项目中引入JDBC依赖，例如使用Maven管理依赖的项目，在pom.xml文件中添加以下代码：<dependencies><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.26</version></dependency></dependencies>4.3 连接数据库在Java代码中使用JDBC连接数据库，示例代码如下：import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;public class JdbcDemo {public static void main(String[] args) {// JDBC连接数据库String url = "jdbc:mysql://localhost:3306/test_db";String username = "root";String password = "123456";try {Connection connection = DriverManager.getConnection(url, username, password);// 连接成功，进行后续操作// ...} catch (SQLException e) {e.printStackTrace();}}}4.4 插入数据使用JDBC向数据库中插入数据，示例代码如下：import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.SQLException;public class JdbcDemo {public static void main(String[] args) {// JDBC连接数据库// ...try {// 插入数据String insertSql = "INSERT INTO users (name, age, email) VALUES (?, , )";PreparedStatement statement = connection.prepareStatement(insertSq l);statement.setString(1, "张三");statement.setInt(2, 20);statement.setString(3,"********************");int rows = statement.executeUpdate();if (rows > 0) {System.out.println("插入成功");} else {System.out.println("插入失败");}} catch (SQLException e) {e.printStackTrace();}}}4.5 查询数据使用JDBC从数据库中查询数据，示例代码如下：import java.sql.Connection;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;public class JdbcDemo {public static void main(String[] args) {// JDBC连接数据库// ...try {// 查询数据String selectSql = "SELECT * FROM users";Statement statement = connection.createStatement();ResultSet resultSet = statement.executeQuery(selectSql);while (resultSet.next()) {int id = resultSet.getInt("id");String name = resultSet.getString("name");int age = resultSet.getInt("age");String email = resultSet.getString("email");System.out.println("id: " + id + ", name: " + name + ", age: " + age + ", email: " + email);}} catch (SQLException e) {e.printStackTrace();}}}4.6 更新数据使用JDBC更新数据库中的数据，示例代码如下：import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.SQLException;public class JdbcDemo {public static void main(String[] args) {// JDBC连接数据库// ...try {// 更新数据String updateSql = "UPDATE users SET age = ? WHERE name = ?";PreparedStatement statement = connection.prepareStatement(updateSq l);statement.setInt(1, 25);statement.setString(2, "张三");int rows = statement.executeUpdate();if (rows > 0) {System.out.println("更新成功");} else {System.out.println("更新失败");}} catch (SQLException e) {e.printStackTrace();}}}4.7 删除数据使用JDBC从数据库中删除数据，示例代码如下：import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.SQLException;public class JdbcDemo {public static void main(String[] args) {// JDBC连接数据库// ...try {// 删除数据String deleteSql = "DELETE FROM users WHERE name = ?";PreparedStatement statement = connection.prepareStatement(deleteSq l);statement.setString(1, "张三");int rows = statement.executeUpdate();if (rows > 0) {System.out.println("删除成功");} else {System.out.println("删除失败");}} catch (SQLException e) {e.printStackTrace();}}}五、实验总结通过本次实验，我们成功地使用JDBC进行了增删改查操作。

JDBC增删改的操作（1）JDBC 增删改的操作（1）⼀、项⽬使⽤技术封装数据库连接、关闭⽅法和封装数据库增、删、改、查⽅法，实现Java项⽬连接数据库，实现基础的JDBC操作。

⼆、使⽤⽰例1、项⽬准备1）创建数据库创建jdbc_test数据库，在此数据库中创建student表，设置id属性、name属性、age属性，分别存放学⽣id信息、名称和年龄，id属性设置为int类型，为⾃增长，name属性设置为varhcar(25)，age属性设置为int类型。

2）导⼊jar包将druid-1.1.10.jar和mysql-connector-java-5.1.48-bin.jar导⼊项⽬中2、设置配置⽂件jdbc.propertiesdriverClassName = com.mysql.jdbc.Driverurl = jdbc:mysql://localhost:3306/jdbc_testusername = rootpassword = rootmaxActive = 20maxWait = 100003、写JDBC连接的⼯具类JDBCUtils.class主要应⽤于数据库的连接、关闭，⽅便相关增删改操作的调⽤，提⾼代码的复⽤性。

public class JDBCUtils {//2.创建DateSource实现类对象(推荐懒汉式)private static DataSource ds;//1.私有化构造器，不让外界通过新建构造器进⾏访问private JDBCUtils() {}//3.给DataSource进⾏初始化static {try {Properties pro= new Properties();pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("jdbc.properties"));ds = DruidDataSourceFactory.createDataSource(pro);} catch (Exception e) {throw new RuntimeException("DataSource初始化错误");}}//4.提供获取链接对象公共的访问⽅式public static Connection getConnection () throws SQLException {if (ds != null) {return ds.getConnection();}throw new RuntimeException("DataSource初始化错误");}//5.封装对象关闭⽅法public static void close (Connection con) {if (con != null) {try {con.close();} catch (SQLException e) {throw new RuntimeException("Connection连接对象关闭异常");}}}//6.封装增删改连接对象的⽅法public static void close (Statement st ,Connection con) {if (st != null) {try {st.close();} catch (SQLException e) {throw new RuntimeException("StatementSQL发送对象关闭异常"); }}close(con);}public static void close (ResultSet rs ,Statement st ,Connection con) {if (rs != null) {try {rs.close();} catch (SQLException e) {throw new RuntimeException("ResultSet结果集对象关闭异常"); }}close(st,con);}}4、将数据库中数据⽣成JavaBean⽂件public class Student {private int id;private String name;private int age;public Student() { }//⽣成⼀个除id外的其他两个的构造器，id在数据库中为⾃增public Student(String name, int age) { = name;this.age = age;}public Student(int id, String name, int age) {this.id = id; = name;this.age = age;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}//重写toString()⽅法，⽅便打印输出查看@Overridepublic String toString() {return "Student{" +"id=" + id +", name='" + name + '\'' +", age=" + age +'}';}}5、增删改查等接⼝⽂件public interface StudentBasicDAO {//提供添加学⽣对象的⽅法void addStudent (Student s);//提供删除学⽣对象的⽅法void deleteStudent (int sid);//提供修改学⽣对象的⽅法void updateStudent(Student s);//提供查询所有学⽣的⽅法List<Student> getAllStudent();//提供通过指定ID查询学⽣的⽅法Student getStudent(int sid);}6、StudentBasicDAOImpl实现类public class StudentBasicDAOImpl implements StudentBasicDAO {//重写⽗类接⼝中的增加学⽣的⽅法@Overridepublic void addStudent(Student s) {Connection con = null;PreparedStatement ps = null;try {//获取数据库连接对象con = JDBCUtils.getConnection();//添加新增的SQL语句，数据库中的id为⾃增故⽽不进⾏插⼊String sql = "insert into student values(null, ?, ?)";//获取SQL语句的发送对象ps = con.prepareStatement(sql);//确定？问号处的数据ps.setString(1, s.getName());ps.setInt(2, s.getAge());//发送SQL语句ps.executeUpdate();} catch (SQLException e) {throw new RuntimeException();}finally {JDBCUtils.close(ps , con);}}//重写接⼝中删除学⽣的⽅法@Overridepublic void deleteStudent(int sid) {Connection con = null;PreparedStatement ps = null;try {con = JDBCUtils.getConnection();String sql = "delete from student where id = ?";ps = con.prepareStatement(sql);ps.setInt(1, sid);ps.executeUpdate();} catch (SQLException e) {throw new RuntimeException();}finally {JDBCUtils.close(ps , con);}}//重写接⼝中修改学⽣信息⽅法@Overridepublic void updateStudent(Student s) {Connection con = null;PreparedStatement ps = null;try {con = JDBCUtils.getConnection();String sql = "update student set name = ? ,age = ? where id = ?"; ps = con.prepareStatement(sql);ps.setString(1, s.getName());ps.setInt(2, s.getAge());ps.setInt(3, s.getId());ps.executeUpdate();} catch (SQLException e) {throw new RuntimeException();}finally {JDBCUtils.close(ps , con);}}@Overridepublic List<Student> getAllStudent() {Connection con = null;PreparedStatement ps = null;ArrayList<Student> list = null;ResultSet rs = null;try {con = JDBCUtils.getConnection();String sql = "select * from student";list = new ArrayList<>();ps = con.prepareStatement(sql);rs = ps.executeQuery();while(rs.next()){int id = rs.getInt(1);String name = rs.getString(2);int age = rs.getInt(3);Student stu = new Student(id, name, age);list.add(stu);}} catch (SQLException e) {throw new RuntimeException();}finally {JDBCUtils.close(rs, ps, con);}//如果没有异常将返回student对象的集合return list;}//重写接⼝中获取指定id号学⽣记录信息@Overridepublic Student getStudent(int sid) {Connection con = null;PreparedStatement ps = null;ResultSet rs = null;Student s = null;try {//获取数据库连接con = JDBCUtils.getConnection();//获取sql语句String sql = "select * from student where id = ?";//获取发送对象ps = con.prepareStatement(sql);//处理？处信息ps.setInt(1, sid);//发送sql语句信息rs = ps.executeQuery();//解析结果集//游标需要移动才能获取经过的值rs.next();int id = rs.getInt(1);String name = rs.getString(2);int age = rs.getInt(3);s = new Student(id, name, age);} catch (SQLException e) {throw new RuntimeException();}finall{//调⽤⼯具类⽅法，关闭与数据库的连接JDBCUtils.close(rs, ps, con);}return s;}}7、JDBCDemo测试类public class JDBCDemo {//为了使静态⽅法中可以调⽤dao,添加static关键字static StudentBasicDAOImpl dao = new StudentBasicDAOImpl(); public static void main(String[] args) throws Exception {//Connection con = JDBCUtils.getConnection();//System.out.println(con);//往数据库中添加sudent对象addStudent();//删除id为10的学⽣记录deleteStudent();//修改id号为12的学⽣信息，name修改为海绵宝宝，age为12 updateStudent();//获取所有的学⽣对象getAllStudent();//获取指定学⽣对象getStudent();}//增加学⽣记录private static void addStudent() {dao.addStudent(new Student("派⼤星",4));dao.addStudent(new Student("海绵宝宝",4));dao.addStudent(new Student("章鱼哥",4));}//删除学⽣记录private static void deleteStudent(){//删除id号为4的学⽣记录dao.deleteStudent(4);}//修改指定学⽣记录的信息private static void updateStudent(){Student s = dao.getStudent(1);s.setAge(22);dao.updateStudent(s);}//获取指定学⽣对象的⽅法private static void getStudent() {Student student = dao.getStudent(3);System.out.println("id号为3的学⽣信息如下："); System.out.println(student);}//获取所有学⽣对象的⽅法private static void getAllStudent() {List<Student> allStudent = dao.getAllStudent(); System.out.println("所有学⽣信息如下：");//直接输出System.out.println(allStudent);//遍历输出ListIterator<Student> sli = allStudent.listIterator(); while (sli.hasNext()){System.out.println(sli.next());}}}。

一、概述Java Database Connectivity（JDBC）是Java编程语言用于与数据库进行连接的一种标准接口。

通过JDBC，开发人员可以在Java应用程序中执行对数据库的增删改查操作。

本文将介绍JDBC实现数据库增删改查的流程，包括数据库连接、数据操作、事务管理等内容。

二、数据库连接1. 导入JDBC驱动在使用JDBC之前，首先需要导入数据库对应的JDBC驱动。

一般来说，不同的数据库有不同的JDBC驱动，开发人员需要根据实际使用的数据库选择对应的驱动，并将其导入项目中。

2. 加载驱动类在Java中，可以使用Class.forName()方法来加载JDBC驱动类。

通过这一步，程序可以在运行时将驱动注册到DriverManager中，以便后续进行数据库连接。

3. 建立数据库连接使用DriverManager.getConnection()方法可以建立与数据库的连接。

在这一步中，需要提供数据库的URL、用户名和密码等信息，以确保能够成功连接到数据库。

三、数据操作1. 创建Statement或PrepareStatement在连接成功后，可以通过Connection对象创建Statement或PrepareStatement对象。

前者用于执行静态SQL语句，后者则用于执行预编译的SQL语句。

2. 执行SQL语句通过Statement或PrepareStatement对象，可以执行增删改查等SQL语句操作。

开发人员需要根据具体需求编写对应的SQL语句，并通过executeUpdate()或executeQuery()方法来执行。

3. 处理结果集对于查询操作，执行executeQuery()方法后会返回一个ResultSet对象，其中包含了查询得到的结果集。

开发人员可以通过ResultSet对象来遍历结果集，并进行相应的数据处理操作。

四、事务管理1. 开启事务在JDBC中，可以通过Connection对象的setAutoCommit()方法来开启或关闭自动提交模式。

Java连接MySQL数据库增删改查通⽤⽅法版权声明：本⽂为博主原创⽂章，未经博主允许不得转载。

Java连接MySQL数据库增删改查通⽤⽅法 运⾏环境：eclipse+MySQL 以前我们Java连接MySQL数据库都是⼀个数据库写⼀个类，类下⾯写好多⽅法，要是多个数据库，就要写多个类多个⽅法，导致代码编写太过于繁琐，所以为了改变这样的繁琐，我将连接数据库的⽅法进⾏了⼀系列的封装，使⽤户传⼊⼀个对象值Object就可以得到想要的。

我在之前写过⼀篇普通的Java连接MySQL数据库，⼤家可以看看，以便对⽐参考之后就知道差距了 接下来我给⼤家讲讲如何将这个不可复⽤，⼜多重复的连接代码，封装起来，⾮常好⽤基本思想：我们连接数据库的时候，写的⽅法都是要⼀个个类的去写，其中的⽅法不计其数，连接数据库都是需要：1. Class.forName()：加载驱动 ——》com.mysql.jdbc.Driver2. DriverManager.getConnection()：驱动管理，连接到数据库三个属性1.数据库地址 2.数据库⽤户名3.密码3. createStatement():创建Statement对象4. ResultSet：执⾏sql语句获得结果集，再遍历那么我们为了能通⽤，那么其中的：数据库名，sql语句，遍历结果集要得到的结果，都是要根据不同数据库根据传⼊参数不同⽽变化的⾸先每个项⽬开始前都要将数据库实体化，每个表都是⼀个实体类，表名是类名，字段为其属性，再⽤set和get⽅法这些属性再根据反射机制，对象是我们表的实例化对象，根据我传⼊⽅法的这个参数对象，获取其中的⽅法，属性，属性值，类型等⼀系列的东西，来实现⽅法的封装通⽤代码演⽰先演⽰⼀个查询：通过传⼊这个表的实体类，通过⼀系列的放射机制，对⽐拼装成⼀个查询⽅法public static List<Object> query(Class<?> obj) {Statement st=null;List<Object> list=new ArrayList<>();//数据库MySQL的地址String DBURL="jdbc:mysql://localhost:3306/lms_leave?useUnicode=true&characterEncoding=utf-8";String DBName="root"; //登⼊⽤户名String DBPwd="123456";//登⼊密码//加载驱动try {Class.forName("com.mysql.jdbc.Driver");//连接数据库Connection conn=DriverManager.getConnection(DBURL,DBName,DBPwd);//创建Statement对象st=conn.createStatement();ResultSet rs=st.executeQuery("select * from "+obj.getSimpleName());//获取传⼊类中的⽅法Method[] methods=obj.getMethods();//设置⼀个⽅法的list集合，下⾯将⽅法放⼊其中，以便调⽤List<Method> list_m= new ArrayList<>();//类中有许多⽅法，过滤⼀些⽅法，获取⾃⼰想要的⽅法for(int i=0;i<methods.length;i++){ //过滤⽅法//判断⽅法名字中是否有set这个提取if (methods[i].getName().contains("set")) {//将⽅法添加到list中list_m.add(methods[i]);}}//创建字符串string集合，获取下⾯的字段名存⼊List<String> fieldname=new ArrayList<>();//获取类中的属性，其属性对应数据库中的字段Field[] f=obj.getDeclaredFields();//循环将字段中的名字⾸个变⼤写for (int i = 0; i < f.length; i++) {//获取名字String field=f[i].getName();//变⼤⼩写，存⼊fieldname集合fieldname.add(upperCase(field));}//获取得到结果集(rs)的结构，⽐如字段数、字段名等。

连接MYSQL数据库的简单增删改查项目框架如图所示：所需工具：所需工具：所需工具：所需工具：程序代码：package er.action; import java.io.IOException;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import erBean;import erDao;public class InsertOrUpdateAction extends HttpServlet { /****/private static final long serialVersionUID = 1L;private UserDao userDao ;public void doGet(HttpServletRequest request, HttpServletResponse responsethrows ServletException, IOException {doPost(request, response;}public void doPost(HttpServletRequest request, HttpServletResponse responsethrows ServletException, IOException {request.setCharacterEncoding("utf-8";response.setCharacterEncoding("utf-8";userDao = new UserDao(;String str = request.getRequestURI(;str = str.substring(stIndexOf("/"+1;String yx = request.getParameter("yx";String zy = request.getParameter("zy";String age = request.getParameter("age";String dh = request.getParameter("dh"; String qq = request.getParameter("qq"; String sex = request.getParameter("sex"; UserBean userBean = new UserBean(; userBean.setYx(yx;userBean.setZy(zy;if(!"".equals(age&&age!=null{userBean.setAge(Integer.valueOf(age;}else{userBean.setAge(0;}userBean.setDh(dh;userBean.setQq(qq;userBean.setSex(sex;if("InsertUserAction".equals(str{if(userDao.insertUser(userBean{response.sendRedirect("SelectAllUser";}else{response.sendRedirect("SelectAllUser";}}else if("UpdateUserAction".equals(str{ String strId = request.getParameter("id"; if(!"".equals(strId&&strId!=null{ userBean.setId(Integer.valueOf(strId;}else{userBean.setId(-1;}if(userDao.updateUser(userBean{response.sendRedirect("SelectAllUser";}else{response.sendRedirect("SelectAllUser";}}}}package er.action;import java.io.IOException;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;public class LoginAction extends HttpServlet {/****/private static final long serialVersionUID = 1L;public void doGet(HttpServletRequest request, HttpServletResponse responsethrows ServletException, IOException {doPost(request, response;}public void doPost(HttpServletRequest request, HttpServletResponse responsethrows ServletException, IOException {String name= request.getParameter("name";String password = request.getParameter("password"; if("".equals(name||"".equals(password{response.sendRedirect("/javaWebTest/index.jsp";}else{if("123".equals(name&&"123".equals(password{response.sendRedirect("SelectAllUser";}else{response.sendRedirect("/javaWebTest/index.jsp";}}}}package er.action;import java.io.IOException;import java.util.List;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import erBean;import erDao;public class UserAction extends HttpServlet {/****/private static final long serialVersionUID = 1L;private UserDao userDao ;public void doGet(HttpServletRequest request, HttpServletResponse response throws ServletException, IOException {doPost(request, response;}public void doPost(HttpServletRequest request, HttpServletResponse response throws ServletException, IOException {request.setCharacterEncoding("utf-8";response.setCharacterEncoding("utf-8";userDao = new UserDao(;String str = request.getRequestURI(;str = str.substring(stIndexOf("/"+1;if("SelectAllUser".equals(str.trim({List list = userDao.getAllUser(;request.setAttribute("UserList", list;request.getRequestDispatcher("/userList.jsp".forward(request, response;}else if("SelectOneUser".equals(str{String strId = request.getParameter("id";int id = Integer.valueOf(strId;UserBean userBean = userDao.selectUserById(id;request.setAttribute("userBean", userBean;request.getRequestDispatcher("/updateUser.jsp".forward(request, response; }else if("DeleteUserById".equals(str{String strId = request.getParameter("id";int id = Integer.valueOf(strId;if(userDao.deleteUser(id{response.sendRedirect("SelectAllUser";}else{response.sendRedirect("SelectAllUser";}}}}package er.dao;import java.sql.ResultSet;import java.sql.SQLException;import java.util.ArrayList;import java.util.List;import erBean;import com.util.DBUtils;public class UserDao {private DBUtils dbUtil;/*** 查询所有的user* @return*/public List getAllUser({dbUtil = new DBUtils(;List list = new ArrayList (;String sql = "select * from user";ResultSet rs = dbUtil.exceteSQl(sql; try {while(rs.next({int i =1;UserBean userBean = new UserBean(; userBean.setId(rs.getInt(i++; userBean.setName(rs.getString(i++; userBean.setYx(rs.getString(i++; userBean.setZy(rs.getString(i++; userBean.setAge(rs.getInt(i++; userBean.setDh(rs.getString(i++; userBean.setQq(rs.getString(i++; userBean.setSex(rs.getString(i++;list.add(userBean;}} catch (SQLException e {e.printStackTrace(;}finally{dbUtil.close(;}return list;}/*** 根据id查询user* @param id* @return*/public UserBean selectUserById(int id{ dbUtil = new DBUtils(;UserBean userBean = new UserBean(;String sql = "select * from user where id = '"+id+"'";ResultSet rs = dbUtil.exceteSQl(sql;try {if(rs.next({int i =1;userBean.setId(rs.getInt(i++;userBean.setYx(rs.getString(i++;userBean.setZy(rs.getString(i++;userBean.setAge(rs.getInt(i++;userBean.setDh(rs.getString(i++;userBean.setQq(rs.getString(i++;userBean.setSex(rs.getString(i++;}} catch (SQLException e {e.printStackTrace(;}return userBean;}/*** 插入用户* @param userBean* @return*/public boolean insertUser(UserBean userBean{dbUtil = new DBUtils(;String sql = "insert into user (yx,zy,age,dh,qq,sex values(?,?,?,?,?,?"; int row = dbUtil.excete(sql, newObject[]{userBean.getYx(,userBean.getZy(,userBean.getAge(,userBean.getDh(,userBean.getQq(,userBean.getSex(};if(row>0{return true;}return false;}/*** 删除用户* @param id* @return*/public boolean deleteUser(int id{dbUtil = new DBUtils(;String sql = "delete from user where id = '"+id+ "'";int row = dbUtil.excete(sql;if(row>0{return true;}return false;}/*** 修改user* @param userBean* @return*/public boolean updateUser(UserBean userBean{dbUtil = new DBUtils(;String sql = "update user set yx =? ,zy=?,age=?,dh=?,qq=?,sex=? where id = ?";int row = dbUtil.excete(sql, newObject[]{userBean.getYx(,userBean.getZy(,userBean.getAge(,userBean.getD h(,userBean.getQq(,userBean.getSex(,userBean.getId(};if(row>0{return true;}return false;}}package er.bean;public class UserBean {private int id;private String name;//电话private String yx;//院系private String zy;//专业private int age;//年龄private String dh;private String qq;private String sex;public int getId( {return id;}public void setId(int id {this.id = id;}public String getName( {return name;}public void setName(String name { = name;public String getYx( {return yx;}public void setYx(String yx { this.yx = yx;}public String getZy( {return zy;}public void setZy(String zy { this.zy = zy;}public int getAge( {return age;}public void setAge(int age { this.age = age;}public String getDh( {return dh;}public void setDh(String dh { this.dh = dh;}public String getQq( {return qq;public void setQq(String qq { this.qq = qq;}public String getSex( {return sex;}public void setSex(String sex { this.sex = sex;}}package er.dao;import java.sql.ResultSet;import java.sql.SQLException;import java.util.ArrayList;import java.util.List;import erBean; import com.util.DBUtils;public class UserDao {private DBUtils dbUtil;/*** 查询所有的user* @return*/public List getAllUser({dbUtil = new DBUtils(;List list = new ArrayList (;String sql = "select * from user"; ResultSet rs = dbUtil.exceteSQl(sql; try {while(rs.next({int i =1;UserBean userBean = new UserBean(; userBean.setId(rs.getInt(i++; userBean.setName(rs.getString(i++; userBean.setYx(rs.getString(i++; userBean.setZy(rs.getString(i++; userBean.setAge(rs.getInt(i++; userBean.setDh(rs.getString(i++; userBean.setQq(rs.getString(i++; userBean.setSex(rs.getString(i++; list.add(userBean;}} catch (SQLException e {e.printStackTrace(;}finally{dbUtil.close(;}return list;/*** 根据id查询user* @param id* @return*/public UserBean selectUserById(int id{dbUtil = new DBUtils(;UserBean userBean = new UserBean(;String sql = "select * from user where id = '"+id+"'"; ResultSet rs = dbUtil.exceteSQl(sql;try {if(rs.next({int i =1;userBean.setId(rs.getInt(i++;userBean.setYx(rs.getString(i++;userBean.setZy(rs.getString(i++;userBean.setAge(rs.getInt(i++;userBean.setDh(rs.getString(i++;userBean.setQq(rs.getString(i++;userBean.setSex(rs.getString(i++;}} catch (SQLException e {e.printStackTrace(;return userBean;}/*** 插入用户* @param userBean* @return*/public boolean insertUser(UserBean userBean{dbUtil = new DBUtils(;String sql = "insert into user (yx,zy,age,dh,qq,sex values(?,?,?,?,?,?";int row = dbUtil.excete(sql, newObject[]{userBean.getYx(,userBean.getZy(,userBean.getAge(,userBean.getDh(,userBean .getQq(,userBean.getSex(};if(row>0{return true;}return false;}/*** 删除用户* @param id* @return*/public boolean deleteUser(int id{dbUtil = new DBUtils(;String sql = "delete from user where id = '"+id+ "'";int row = dbUtil.excete(sql;if(row>0{return true;}return false;}/*** 修改user* @param userBean* @return*/public boolean updateUser(UserBean userBean{dbUtil = new DBUtils(;String sql = "update user set yx =? ,zy=?,age=?,dh=?,qq=?,sex=? where id = ?";int row = dbUtil.excete(sql, newObject[]{userBean.getYx(,userBean.getZy(,userBean.getAge(,userBean.getDh(,userBean .getQq(,userBean.getSex(,userBean.getId(};if(row>0{return true;}return false;}}package com.util;import java.sql.Date;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import com.mysql.jdbc.Connection;import com.mysql.jdbc.Statement;public class DBUtils {private static Connection conn=null;private Statement st=null;private ResultSet rs = null;private PreparedStatement ps;static{try {Class.forName("com.mysql.jdbc.Driver";conn = (ConnectionDriverManager.getConnection("jdbc:mysql://localhost:3306/ygx?useUnicode=true&char acterEncoding=UTF-8","root" ,"123456" ;} catch (ClassNotFoundException e {e.printStackTrace(;} catch (SQLException e {e.printStackTrace(;}}/*** @Title: exceteSQl* @Description: TODO(执行不带参数的sql语句* @param sql* @return ResultSet* @throws*/public ResultSet exceteSQl(String sql{try {st =(Statement conn.createStatement(;rs = st.executeQuery(sql;} catch (SQLException e {e.printStackTrace(;}return rs;}/**** @Title: exceteSQl* @Description: TODO(执行带参数的sql语句* @param sql* @param obj* @return ResultSet* @throwspublic ResultSet exceteSQl(String sql, Object[] obj{int length = obj.length;try {ps = conn.prepareStatement(sql;preparStateSql(obj, length;rs = ps.executeQuery(;} catch (SQLException e {e.printStackTrace(;}return rs;}/**** @Title: excete* @Description: TODO(此方法适用于不带参数的修改，删除，增加* @param sql* @return int* @throws*/public int excete(String sql{int row =0;try {st = (Statement conn.createStatement(;row = st.executeUpdate(sql;} catch (SQLException e {e.printStackTrace(;}finally{close(;}return row;}/**** @Title: excete* @Description: TODO(此方法适用带参数的修改，删除，增加* @param sql* @param obj* @return int* @throws*/public int excete(String sql, Object[] obj{int row =0;int length = obj.length;try {ps = conn.prepareStatement(sql;preparStateSql(obj, length;row = ps.executeUpdate(;} catch (SQLException e {e.printStackTrace(;}finally{close(;}return row;}/**** @Title: preparStateSql* @Description: TODO(参数赋值* @param obj* @param length* @throws SQLException void* @throws*/private void preparStateSql(Object[] obj, int length throws SQLException { for(int i=0;i{if(obj[i].getClass(==String.class{ps.setString(i+1, obj[i].toString(;}else if(obj[i].getClass(==Integer.class{ps.setInt(i+1, (Integerobj[i];}else if(obj[i].getClass(==Double.class{ps.setDouble(i+1, (Doubleobj[i];}else if(obj[i].getClass(==Date.class//java.sql.Date {ps.setDate(i+1, (Dateobj[i];}}}/**** @Title: close* @Description: TODO(数据库连接关闭 void* @throws*/public void close({if(rs!=null{try {rs.close(;} catch (SQLException e {e.printStackTrace(;}}if(st!=null{try {st.close(;} catch (SQLException e {e.printStackTrace(;}}if(ps!=null{try {ps.close(;} catch (SQLException e {e.printStackTrace(;}}}public static void main(String[] args { DBUtils db = new DBUtils(;String sql = "select * from user "; ResultSet rr = db.exceteSQl(sql;try {while(rr.next({int i =1;System.out.print(rr.getInt(i+++" "; System.out.print(rr.getString(i+++" "; System.out.print(rr.getString(i+++" "; System.out.print(rr.getInt(i+++" "; System.out.print(rr.getString(i+++" "; System.out.print(rr.getString(i+++" "; System.out.println(rr.getString(i++;}} catch (SQLException e {// TODO Auto-generated catch blocke.printStackTrace(;}finally{db.close(;}//String sql = "insert into user (yx,zy,age,dh,qq,sex values(\"软件\",\"测试\",12,\"110\",\"123456789\",\"女\"";/* String sql = "insert into user (yx,zy,age,dh,qq,sexvalues(?,?,?,?,?,?";int row = db.excete(sql, new Object[]{"软件","测试",12,"110","123456789","女"};//int row = db.excete(sql;if(row>0{System.out.println("增加成功";}*//*String sql = "update user set yx=? where id =?";int row = db.excete(sql, new Object[]{"计通",3};if(row>0{System.out.println("修改成功";}*/}}所需要的驱动包：W eb.xml配置：xml version="1.0"encoding="UTF-8"?><web-app version="2.5"xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_2_5.xsd"><display-name> display-name><servlet><servlet-name>UserAction servlet-name><servlet-class>erAction servlet-class>servlet><servlet><servlet-name>InsertOrUpdateAction servlet-name><servlet-class>er.action.InsertOrUpdateAction servlet-class> servlet><servlet><servlet-name>LoginAction servlet-name><servlet-class>er.action.LoginAction servlet-class>servlet><servlet-mapping><servlet-name>UserAction servlet-name><url-pattern>/SelectAllUser url-pattern><url-pattern>/SelectOneUser url-pattern><url-pattern>/DeleteUserById url-pattern>servlet-mapping><servlet-mapping><servlet-name>InsertOrUpdateAction servlet-name><url-pattern>/InsertUserAction url-pattern><url-pattern>/UpdateUserAction url-pattern>servlet-mapping><servlet-mapping><servlet-name>LoginAction servlet-name><url-pattern>/LoginAction url-pattern>servlet-mapping><welcome-file-list><welcome-file>index.jsp welcome-file>welcome-file-list>web-app>J sp:<%@page language="java"import="java.util.*"pageEncoding="UTF-8"%> <%String path = request.getContextPath(;String basePath =request.getScheme(+"://"+request.getServerName(+":"+request.getServerPo rt(+path+"/";%>DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><base href="<%=basePath%>"><title>My JSP 'index.jsp' starting page title><meta http-equiv="pragma"content="no-cache"><meta http-equiv="cache-control"content="no-cache"><meta http-equiv="expires"content="0"><meta http-equiv="keywords"content="keyword1,keyword2,keyword3"><meta http-equiv="description"content="This is my page"><style type="text/css">.table1{margin:0 auto;border-collapse: collapse;}.table1td{padding: 0px;height:25px;border:1px solid #6AB6B6;text-align:center;font-family:"微软雅黑";font-size:12px;background-color:#EAFEFE;}.table1td.title{height:28px;color:#fff;background-color:#6AB6B6;font-weight:bold;font-size:20px;text-align: center;}.table1tr.colname{font-size: 14px;font-weight: bold;}* .nobd_table td{border: none;}style>head><body><div align="center"style="padding-top: 30px;" id = "add"> <form action="LoginAction"method="post"><table class="table1"width="50%"><tr><td class="title"colspan="2">欢迎你的登录!td>tr><tr><td>帐号td><td><input type="text"name="name">td>tr><tr><td>密码td><td><input type="password"name="password">td>tr><tr><td colspan="2"><input type="submit"value="登录"><inputtype="reset"value="重置"> td>tr>table>form>div>body>html><%@ page language="java"import="java.util.*,erBean" pageEncoding="utf-8"%><%@ taglib prefix="c"uri="/jsp/jstl/core"%><%String path = request.getContextPath(;String basePath =request.getScheme(+"://"+request.getServerName(+":"+request.getServerPo rt(+path+"/";%>DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><base href="<%=basePath%>"><title>My JSP 'userList.jsp' starting page title><meta http-equiv="pragma"content="no-cache"><meta http-equiv="cache-control"content="no-cache"><meta http-equiv="expires"content="0"><meta http-equiv="keywords"content="keyword1,keyword2,keyword3"> <meta http-equiv="description"content="This is my page"><style type="text/css">.table1{margin:0 auto;border-collapse: collapse;}.table1td{padding: 0px;height:25px;border:1px solid #6AB6B6;text-align:center;font-family:"微软雅黑";font-size:12px;background-color:#EAFEFE;}.table1td.title{height:28px;color:#fff;background-color:#6AB6B6;font-weight:bold;font-size:20px;text-align: center;}.table1tr.colname{font-size: 14px;font-weight: bold;* .nobd_table td{border: none;}style><script type="text/javascript">function goback({}script>head><body><div align="center"style="padding-top: 30px;" id="add"><form action="UpdateUserAction"method="post"><table class="table1"width="50%"><tr><td colspan="2"class="title">user信息填写td>tr><tr><td>院系td><td><input type="text"name="yx"id="yx"value="${userBean.yx }"><input type="hidden"name="id"value="${userBean.id }">td>tr><tr><td>专业td><td><input type="text"name="zy"id="zy"value="${userBean.zy }">td> tr><tr><td>年龄td><td><input type="text"name="age"id="age"value="${userBean.age }"> td><tr><td>电话td><td><input type="text"name="dh"id="dh"value="${userBean.dh }">td> tr><tr><td>QQ td><td><input type="text"name="qq"id="qq"value="${userBean.qq }">td> tr><tr><td>行别td><td><c:set value="男"var="sexs"> c:set><c:if test="${userBean.sex eq sexs }"><input type="radio"name="sex"value="男"checked="checked">男<input type="radio"name="sex"value="女">女c:if><c:if test="${userBean.sex ne sexs }"><input type="radio"name="sex"value="男">男<input type="radio"checked="checked"name="sex"value="女">女c:if>td>tr><tr><td colspan="2"><input type="submit"value="提交"><inputtype="reset"value="重置"><input type="button"value="返回"onclick="Javascript:window.history.go(-1;">td>tr>table>form>div>body>html><%@ page language="java"import="java.util.*,erBean" pageEncoding="utf-8"%><%@ taglib prefix="c"uri="/jsp/jstl/core"%><%String path = request.getContextPath(;String basePath =request.getScheme(+"://"+request.getServerName(+":"+request.getServerPo rt(+path+"/";%>DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><base href="<%=basePath%>"><title>My JSP 'userList.jsp' starting page title><meta http-equiv="pragma"content="no-cache"><meta http-equiv="cache-control"content="no-cache"><meta http-equiv="expires"content="0"><meta http-equiv="keywords"content="keyword1,keyword2,keyword3"><meta http-equiv="description"content="This is my page"><style type="text/css">.table1{margin:0 auto;border-collapse: collapse;}.table1td{padding: 0px;height:25px;border:1px solid #6AB6B6;text-align:center;font-family:"微软雅黑";font-size:12px;background-color:#EAFEFE;}.table1td.title{height:28px;color:#fff;background-color:#6AB6B6;font-weight:bold;font-size:20px;text-align: center;}.table1tr.colname{font-size: 14px;font-weight: bold;}* .nobd_table td{border: none;}style><script type="text/javascript">function viewList({document.getElementById('list'.style.display= ''; document.getElementById('add'.style.display= 'none'; }function viewAdd({document.getElementById('list'.style.display= 'none'; document.getElementById('add'.style.display= '';}script>head><body onload="viewList("><div align="center"style="padding-top: 30px;" id="list"><table width="70%"class="table1"><tr><td colspan="8"class="title">user表列表信息<input type="button" value="增加"onclick="viewAdd(">td>tr><tr><td>序号td><td>姓名td><td>院系td><td>专业td><td>年龄td><td>电话td><td>QQ td><td>性别td><td>操作td>tr><c:forEach var="bean"items="${UserList }" ><tr><td>${bean.id }td><td>${ }td><td>${bean.yx }td><td>${bean.zy }td><td>${bean.age }td><td>${bean.dh }td><td>${bean.qq }td><td>${bean.sex }td><td><a href="SelectOneUser?id=${bean.id}">修改a><a href="DeleteUserById?id=${bean.id}">删除a>td>tr>c:forEach>table>div><div align="center"style="padding-top: 30px;" id = "add"> <form action="InsertUserAction"method="post"><table class="table1"width="50%"><tr><td colspan="2"class="title">user信息填写td>tr><td>院系td><td><input type="text"name="yx"id="yx">td>tr><tr><td>姓名td><td><input type="text"name="yx"id="name">td>tr><tr><td>专业td><td><input type="text"name="zy"id="zy">td>tr><tr><td>年龄td><td><input type="text"name="age"id="age">td>tr><tr><td>电话td><td><input type="text"name="dh"id="dh">td>tr><tr><td>QQ td><td><input type="text"name="qq"id="qq">td>tr><tr><td>行别td><td><input type="radio"name="sex"value="男"checked="checked">男<input type="radio"name="sex"value="女">女td>。

JavaWeb下MySQL数据库的增删改查（⼀）以图书管理系统举例（jsp+servlet+bean）1.数据库的连接package db;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;public class DBUtil {private static String url = "jdbc:mysql://localhost:3306/book system?&useSSL=false&serverTimezone=UTC";//要连接的库名private static String user = "******";//数据库⽤户名private static String password = "******";//数据库密码private static String jdbcName="com.mysql.cj.jdbc.Driver";private Connection con=null;public static Connection getConnection() {Connection con=null;try {Class.forName(jdbcName);con=DriverManager.getConnection(url, user, password);//System.out.println("数据库连接成功");} catch (Exception e) {// TODO Auto-generated catch block//System.out.println("数据库连接失败");e.printStackTrace();}try {con = DriverManager.getConnection(url,user,password);System.out.println("连接成功");} catch (SQLException e) {// TODO: handle exceptione.printStackTrace();}return con;}public static void main(String[] args)throws SQLException { //测试数据表的连接Connection conn = getConnection();PreparedStatement pstmt = null;ResultSet rs = null;String sql ="select * from reader_information";pstmt = conn.prepareStatement(sql);rs = pstmt.executeQuery();System.out.println(getConnection());while(rs.next()){System.out.println("成功");}}// return con;public static void close(Connection con) {if(con!=null)try {con.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}public static void close(Statement state, Connection conn) {if(state!=null) {try {state.close();} catch (SQLException e) {e.printStackTrace();}}if(conn!=null) {try {conn.close();} catch (SQLException e) {e.printStackTrace();}}}public static void close(ResultSet rs, Statement state, Connection conn) { if(rs!=null) {try {rs.close();} catch (SQLException e) {e.printStackTrace();}}if(state!=null) {try {state.close();} catch (SQLException e) {e.printStackTrace();}}if(conn!=null) {try {conn.close();} catch (SQLException e) {e.printStackTrace();}}}}2.实体层package bean;public class Bean_book {private int id;private String name;private String writer;private String press;private int num;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public String getWriter() {return writer;}public void setWriter(String writer) {this.writer = writer;}public String getPress() {return press;}public void setPress(String press) {this.press = press;}public int getNum() {return num;}public void setNum(int num) {this.num = num;}public Bean_book(int id, String name, String writer, String press,int num) { this.id = id; = name;this.writer = writer;this.press = press;this.num = num;}public String toString() {return "Book{" +"id=" + id +", name='" + name + '\'' +", writer='" + writer + '\'' +", press='" + press + '\'' +", num=" + num +'}';}}package bean;import java.util.Date;public class Bean_borrowing {private int id;private String name;private String writer;private String press;private Date time;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public String getWriter() {return writer;}public void setWriter(String writer) {this.writer = writer;}public String getPress() {return press;}public void setPress(String press) {this.press = press;}public Date getTime() {return time;}public void setTime(Date time) {this.time = time;}public Bean_borrowing(int id, String name, String writer, String press,Date time) { this.id = id; = name;this.writer = writer;this.press = press;this.time = time;}public String toString() {return "Book{" +"id=" + id +", name='" + name + '\'' +", writer='" + writer + '\'' +", press='" + press + '\'' +", time=" + time +'}';}}package bean;public class Bean_reader {private int uid;private String name;private String sex;private String college;private String password;public int getUid() {return uid;}public void setUid(int uid) {this.uid = uid;}public String getName() {return name;}public void setName(String name) { = name;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public String getCollege() {return college;}public void setCollege(String college) {this.college = college;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public Bean_reader(int uid, String name, String sex, String college,String password) {this.uid = uid; = name;this.sex = sex;this.college = college;this.password = password;}public Bean_reader(int uid,String password) {this.uid = uid;this.password = password;}public String toString() {return "Reader{" +"uid=" + uid +", name='" + name + '\'' +", sex='" + sex + '\'' +", college='" + college + '\'' +", password=" + password +'}';}}3.Dao层数据访问，实现对数据的增、删、改、查package dao;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;import java.util.ArrayList;import java.util.List;import bean.Bean_reader;import bean.Bean_book;import bean.Bean_borrowing;import db.DBUtil;public class Dao {//dao层private DBUtil dbutil=new DBUtil();public Dao() {// TODO Auto-generated constructor stub}public boolean insert_reader(Bean_reader bean) {//插⼊读者数据的⽅法boolean f=false;String sql="insert into reader_information(uid,name,sex,college,password) values('"+bean.getUid()+"','"+bean.getName()+"','"+bean.getSex()+"','"+be an.getCollege()+"'+'"+bean.getPassword()+"')";Connection conn=DBUtil.getConnection();//数据库连接，加载驱动Statement state=null;try{state=conn.createStatement();//实例化Statement对象,⽅便对sql语句进⾏操作System.out.println(conn);state.executeUpdate(sql);f=true;//执⾏数据库更新操作⽤于执⾏INSERT、UPDATE或DELETE语句以及SQLDDL（数据定义语⾔）语句，//例如CREATETABLE和DROPTABLE,（创建表和删除表）}catch(Exception e)//当try语句中s出现异常时，会执⾏catch中的语句{e.printStackTrace();//捕获异常的语句}finally//finally作为异常处理的⼀部分，它只能⽤在try/catch语句中，并且附带⼀个语句块，表⽰这段语句最终⼀定会被执⾏（不管有没有抛出异常），经常被⽤在需要释放资源的情况下。

jdbc增删改查实验报告一、实验目的本次实验旨在通过使用Java Database Connectivity (JDBC)技术，掌握数据库的增删改查操作。

二、实验环境本次实验使用的开发工具为Eclipse，数据库管理系统为MySQL。

三、实验过程1. 数据库连接在Java中使用JDBC连接到数据库需要以下步骤：1）加载数据库驱动程序；2）获取数据库连接；3）创建Statement对象或PreparedStatement对象。

示例代码如下：Class.forName("com.mysql.jdbc.Driver");Connection conn = DriverManager.getConnection(url, username, password);Statement stmt = conn.createStatement();其中url是指要连接的数据库地址，username和password是登录数据库所需的用户名和密码。

2. 数据库查询操作查询操作可以使用Statement对象或PreparedStatement对象执行SQL语句。

PreparedStatement对象比Statement对象更安全，因为它可以防止SQL注入攻击。

示例代码如下：PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM users WHERE age > ?");pstmt.setInt(1, 18);ResultSet rs = pstmt.executeQuery();其中？表示占位符，可以通过setInt()等方法设置占位符的值。

3. 数据库插入操作插入操作需要使用PreparedStatement对象执行INSERT语句。

示例代码如下：PreparedStatement pstmt = conn.prepareStatement("INSERT INTO users(name, age) VALUES(?, ?)");pstmt.setString(1, "Tom");pstmt.setInt(2, 20);int rowsAffected = pstmt.executeUpdate();其中executeUpdate()方法返回受影响的行数。

Java基于jdbc实现的增删改查操作⽰例本⽂实例讲述了Java基于jdbc实现的增删改查操作。

分享给⼤家供⼤家参考，具体如下：增删改操作：package java_web;import java.sql.DriverManager;import java.sql.SQLException;import com.mysql.jdbc.Connection;import com.mysql.jdbc.Statement;/*** jdbc CURD* @author Administrator**/public class rbacDemo {public final static String URL="jdbc:mysql://localhost:3306/test";public final static String USERNAME="root";public final static String PASSWORD="";public final static String DRIVER="com.mysql.jdbc.Driver";/*** 插⼊*/public static void insert(){try {Class.forName(DRIVER);Connection conn = (Connection) DriverManager.getConnection(URL,USERNAME,PASSWORD);String sql = "insert into test(name,sex)values('fifi2',1),('fifi3',3)";Statement state = (Statement) conn.createStatement();int result=state.executeUpdate(sql);state.close();conn.close();System.out.println(result+"success");} catch (ClassNotFoundException e) {// TODO ⾃动⽣成的 catch 块e.printStackTrace();} catch (SQLException e) {// TODO ⾃动⽣成的 catch 块e.printStackTrace();}}public static void update(){try {Class.forName(DRIVER);Connection conn = (Connection) DriverManager.getConnection(URL,USERNAME,PASSWORD);String sql = "update test set name='fifi3aaa' where name='fifi3'";Statement state = (Statement) conn.createStatement();int result=state.executeUpdate(sql);state.close();conn.close();System.out.println(result+"success");} catch (ClassNotFoundException e) {// TODO ⾃动⽣成的 catch 块e.printStackTrace();} catch (SQLException e) {// TODO ⾃动⽣成的 catch 块e.printStackTrace();}}public static void delete(){try {Class.forName(DRIVER);Connection conn = (Connection) DriverManager.getConnection(URL,USERNAME,PASSWORD);String sql = "delete from test where name='fifi3aaa'";Statement state = (Statement) conn.createStatement();int result=state.executeUpdate(sql);state.close();conn.close();System.out.println(result+"success");} catch (ClassNotFoundException e) {// TODO ⾃动⽣成的 catch 块e.printStackTrace();} catch (SQLException e) {// TODO ⾃动⽣成的 catch 块e.printStackTrace();}}public static void main(String[] args){//insert();//update();delete();}}查询操作：package java_web;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.SQLException;import com.mysql.jdbc.Connection;import com.mysql.jdbc.Statement;public class jdbcQueryDemo {public final static String URL="jdbc:mysql://localhost:3306/test";public final static String USERNAME="root";public final static String PASSWORD="";public final static String DRIVER="com.mysql.jdbc.Driver";public static void query(){try {Class.forName(DRIVER);Connection conn = (Connection) DriverManager.getConnection(URL,USERNAME,PASSWORD);String sql = "select id,name,sex from test where id=3";Statement state = (Statement) conn.createStatement();ResultSet rs=state.executeQuery(sql);while(rs.next()){//rs.getInt("id");int id=rs.getInt(1);String name=rs.getString(2);int sex=rs.getInt(3);//String time=rs.getString("vtime");System.out.println(id+"=="+name+"=="+sex+"==");}rs.close();state.close();conn.close();} catch (ClassNotFoundException e) {// TODO ⾃动⽣成的 catch 块e.printStackTrace();} catch (SQLException e) {// TODO ⾃动⽣成的 catch 块e.printStackTrace();}}public static void main(String[] args) {// TODO ⾃动⽣成的⽅法存根query();}}更多关于java相关内容感兴趣的读者可查看本站专题：《》、《》、《》、《》、《》和《》希望本⽂所述对⼤家java程序设计有所帮助。

详解通过JDBC进⾏简单的增删改查（以MySQL为例）前⾔：什么是JDBCJava 数据库连接，（Java Database Connectivity，简称JDBC）是Java语⾔中⽤来规范客户端程序如何来访问数据库的应⽤程序接⼝，提供了诸如查询和更新数据库中数据的⽅法。

JDBC也是Sun Microsystems的商标。

它JDBC是⾯向关系型数据库的。

简单地说，就是⽤于执⾏SQL语句的⼀类Java API，通过JDBC使得我们可以直接使⽤Java编程来对关系数据库进⾏操作。

通过封装，可以使开发⼈员使⽤纯Java API完成SQL的执⾏。

⼀、准备⼯作（⼀）：MySQL安装配置和基础学习使⽤JDBC操作数据库之前，⾸先你需要有⼀个数据库。

这⾥提供了3个链接供读者⾃学，如果曾有过SQL语⾔的使⽤经历（包括在学校中的课堂学习），前两个链接⾜以上⼿。

建议边看⼊门教程，边练习，在练习insert、update、select、delete等基本操作的同时，将后⾯要⽤的表建好。

下图是我接下来⽤于演⽰的数据库的表。

⼆、准备⼯作（⼆）：下载数据库对应的jar包并导⼊使⽤JDBC需要在⼯程中导⼊对应的jar包。

数据库与JDBC包的对应关系可以参考各种数据库对应的jar包、驱动类名和URL格式。

在Eclipse下的导⼊⽅法：在⼯程的图标上右击，选择”Properties”，在”Java Bulid Path”中选择”Add External JARs…”，选择下载并解压后获得的jar包。

如果对MySQL进⾏操作，这时下⾯的import就不会报错了：import com.mysql.jdbc.Connection;import com.mysql.jdbc.PreparedStatement;除此以外，还需要JDBC的包，直接import即可。

import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.SQLException;三、JDBC基本操作为了简单起见，与数据库相关的操作、命令、参数都被硬编码了。

java项目中的增删改查方法在Java项目中，增删改查（CRUD）方法是非常常见且重要的。

无论是开发Web应用程序、移动应用程序还是其他类型的软件，都需要对数据进行增加、删除、修改和查询操作。

在Java中，通常会使用数据库来存储数据，并通过使用SQL语句来执行这些操作。

对于增删改查操作，Java项目通常会使用一些常见的技术和框架，比如JDBC、Hibernate、MyBatis等。

下面将分别介绍这些方法在Java项目中的应用。

1. 增加（Create），在Java项目中，增加数据通常是通过向数据库中插入新的记录来实现的。

开发人员可以使用SQL语句或者使用ORM框架（比如Hibernate或MyBatis）来执行插入操作。

在使用ORM框架的情况下，只需要创建一个实体对象并将其持久化到数据库中即可完成插入操作。

2. 删除（Delete），删除数据是指从数据库中移除记录。

在Java项目中，可以使用SQL语句的DELETE语句来执行删除操作，也可以通过ORM框架提供的方法来删除实体对象。

删除操作通常需要指定一个唯一的标识符来确定要删除的记录。

3. 修改（Update），修改数据是指更新数据库中已有的记录。

在Java项目中，可以使用SQL语句的UPDATE语句来执行更新操作，也可以通过ORM框架提供的方法来更新实体对象。

更新操作通常需要指定要更新的记录以及更新的字段和数值。

4. 查询（Read），查询数据是指从数据库中检索记录。

在Java项目中，可以使用SQL语句的SELECT语句来执行查询操作，也可以通过ORM框架提供的方法来查询实体对象。

查询操作通常需要指定查询条件，并可以返回满足条件的记录集合。

总之，在Java项目中，增删改查方法是非常基础且重要的操作，开发人员需要熟练掌握数据库操作和相应的技术和框架，以便能够高效地进行数据处理。

同时，也需要注意数据操作的安全性和性能，以确保项目的稳定和可靠。