前言

JDBC代表Java数据库连接。JDBC库中所包含的API通常与数据库使用于：连接到数据库创建SQL或MySQL语句，在数据库中执行SQL或MySQL，查看和修改数据库中的数据记录。

JDBC环境准备

• 普通Java项目，在lib中粘贴此包（在官网上下），版本无所谓

官网下载 系统选择platform那个

jar包存放位置，项目根目录下的lib文件夹

• 如果是Maven或者Gradle或者Spring项目。不需要引入上面的jar包，直接在依赖里面写（Maven为例）

	   <!--mysql驱动-->
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>8.0.27</version>
       </dependency>

除上述环境配置外，还需要建立一个数据库，我使用的是SQLyog，假设创建一个数据库：wzsxy，在这个数据库上创建一张表：tb_user，并输入两条起始数据。如图

基本操作

实现数据库的查询

新建Find类

import java.sql.*;

public class Find {
    public static void main(String[] args) throws SQLException, ClassNotFoundException {
        //1、加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2、创建连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/wzsxy","root","123456");
        //3、写SQL语句
        String sql="select * from tb_user";
        //4、获得statement对象
        PreparedStatement statement=connection.prepareStatement(sql);
        //5、执行SQL语句 得到结果集
        ResultSet resultSet = statement.executeQuery();
        //6、处理结果集
        while (resultSet.next()){
            System.out.println(resultSet.getInt(1));
            System.out.println(resultSet.getString(2));
            System.out.println(resultSet.getString(3));

        }
        //7、关闭资源
        resultSet.close();
        statement.close();
        connection.close();
    }
}

实现数据库的删除

新建Delete类

import java.sql.*;

public class Delete {
    public static void main(String[] args) throws SQLException, ClassNotFoundException {
        //1、加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2、创建连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/wzsxy","root","123456");
        //3、写SQL语句
        String sql="delete from tb_user where id=2";
        //4、获得statement对象
        PreparedStatement statement=connection.prepareStatement(sql);
        //5、执行SQL语句 得到结果集
        statement.executeUpdate();
        //6、处理结果集

        //7、关闭资源
        statement.close();
        connection.close();
    }
}

运行后在数据库中刷新表以后，发现id为“2”的用户被删除

实现数据库的增添

新建Add类，在SQL语句中输入要增加的信息

import java.sql.*;

public class Add {
    public static void main(String[] args) throws SQLException, ClassNotFoundException {
        //1、加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2、创建连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/wzsxy","root","123456");
        //3、写SQL语句
        String sql="INSERT INTO tb_user (username,PASSWORD) VALUES ('JinZiyi','123456')";
        //4、获得statement对象
        PreparedStatement statement=connection.prepareStatement(sql);
        //5、执行SQL语句 得到结果集
        statement.executeUpdate();
        //6、处理结果集

        //7、关闭资源
        statement.close();
        connection.close();
    }
}

运行打开数据库刷新，发现数据增加成功

实现数据库数据的修改

新建Update类

import java.sql.*;

public class Update {
    public static void main(String[] args) throws SQLException, ClassNotFoundException {
        //1、加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2、创建连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/wzsxy","root","123456");
        //3、写SQL语句
        String sql="UPDATE tb_user SET username='JinZiyi',PASSWORD='000000' WHERE id=2";
        //4、获得statement对象
        PreparedStatement statement=connection.prepareStatement(sql);
        //5、执行SQL语句 得到结果集
        statement.executeUpdate();
        //6、处理结果集

        //7、关闭资源
        statement.close();
        connection.close();
    }
}

刷新数据库后可见数据修改成功

整合增删改查的代码，封装为一个工具类

在util包下新建DBUtil类

将JDBC的基本步骤的1、2、7步放入DBUtil类中，代码中使用了try…catch，也可以直接idea自动生成抛出异常

package com.XuYijie.util;

import java.sql.*;

public class DBUtil {
    public static Connection getConnection(){
        //1、加载驱动
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //2、创建连接
        Connection connection = null;
        try {
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/wzsxy","root","123456");
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        System.out.println("创建连接成功");
        return connection;
    }
    //7、关闭资源
    public static void closeAll(ResultSet resultSet, Statement statement,Connection connection) throws SQLException {
        if (resultSet!=null){
            resultSet.close();
        }
        if (resultSet!=null){
            statement.close();
        }
        if (resultSet!=null){
            connection.close();
        }
    }
}

在bean包下新建User类

定义id、username、password，生成所有的get、set方法和构造方法，并重写toString

package com.XuYijie.bean;

public class User {
    public User() {
    }

    private int id;
    private String username;
    private String password;

    public User(int id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

在dao包下新建UserDao类

package com.XuYijie.dao;

import com.XuYijie.bean.User;
import com.XuYijie.util.DBUtil;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class UserDao {

    public List<User> findAll(){
        Connection connection= null;
        List<User> userList=new ArrayList<>();
        PreparedStatement statement=null;
        ResultSet resultSet =null;
        try {
            //2、创建连接
            connection = DBUtil.getConnection();
            //3.写sql语句
            String sql="select * from tb_user";
            //4.获得statement对象
            statement=connection.prepareStatement(sql);
            //5.执行sql 得到结果集
            resultSet = statement.executeQuery();
            //6.处理结果集
            while (resultSet.next()){
                User user=new User();
                user.setId(resultSet.getInt(1));
                user.setUsername(resultSet.getString(2));
                user.setPassword(resultSet.getString(3));
                userList.add(user);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            //7.关闭资源
            try {
                DBUtil.closeAll(resultSet,statement,connection);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        return userList;
    }

    public void deleteById(int id){
        Connection connection= null;
        PreparedStatement statement=null;
        try {
            //2、创建连接
            connection = DBUtil.getConnection();
            System.out.println("创建连接成功");
            //3.写sql语句
            String sql="delete from tb_user where id=5";
            //4.获得statement对象
            statement=connection.prepareStatement(sql);
            //5.执行sql 得到结果集
            statement.executeUpdate();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {

            try {
                DBUtil.closeAll(null,statement,connection);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

    public void add(User user){
        //2、创建连接
        Connection connection= null;
        PreparedStatement statement=null;
        try {
            connection = DBUtil.getConnection();
            System.out.println("创建连接成功");
            //3.写sql语句
            String sql="INSERT INTO tb_user (username,PASSWORD) VALUES (?,?)";
            //4.获得statement对象
            statement=connection.prepareStatement(sql);
            statement.setString(1,user.getUsername());
            statement.setString(2,user.getPassword());
            statement.executeUpdate();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            try {
                DBUtil.closeAll(null,statement,connection);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

    public void update(User user){
        //2、创建连接
        Connection connection= null;
        PreparedStatement statement=null;
        try {
            connection = DBUtil.getConnection();
            System.out.println("创建连接成功");
            //3.写sql语句
            String sql="UPDATE tb_user SET username=?,PASSWORD=? WHERE id=?";
            //4.获得statement对象
            statement=connection.prepareStatement(sql);
            statement.setString(1,user.getUsername());
            statement.setString(2,user.getPassword());
            statement.setInt(3,user.getId());
            //5.执行sql 得到结果集
            statement.executeUpdate();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            try {
                DBUtil.closeAll(null,statement,connection);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

    }
}

新建Test类

Test用来实现UserDao里面的方法

package com.XuYijie;

import com.XuYijie.bean.User;
import com.XuYijie.dao.UserDao;

import java.util.List;

public class Test {
    public static void main(String[] args) {
        UserDao userDao = new UserDao();
        //查询
        List<User> userList = userDao.findAll();
        System.out.println(userList);
        //删除
        userDao.deleteById(4);
        //增添
        User user = new User();
        user.setUsername("HeGuanghui");
        user.setPassword("123456");
        userDao.add(user);
        //修改
        user.setUsername("HeGuanghui");
        user.setPassword("654321");
        userDao.update(user);
    }
}
}

然后就可以自己运行试试啦

结语

JDBC在现在的正规项目中已经不使用了，但是初学者仍然要了解一些，另外JDBC可以在普通项目中作为临时连接数据库的方法使用，切换方便，非常灵活。

Spring和Maven操作数据的教程可以看我的传送门，可以在网页上展示数据，有源码，非常简单易懂

Maven工程实现前后端的数据展示与操作

使用idea，创建SpringBoot项目，详细介绍Java操作MongoDB的增删改查全过程。

目 录

1.安装MongoDB

2.idea创建SpringBoot项目

3.idea连接MongoDB

4.编写代码

4.1连接MongoDB配置文件

4.2实体代码

4.3dao代码

4.4service代码

4.5controller代码

4.6pom.xml

5.代码接口测试

详细分享如下：

1.安装MongoDB

这里略，详情请参考《window安装MongoDB详解》博客

2.idea创建SpringBoot项目

这里略，详情请参考《idea中基于MongoDB，创建SpringBoot项目》博客

3.idea连接MongoDB

这里略，详情请参考《idea安装Mongo Plugin插件，连接MongoDB_一火的专栏-CSDN博客》博客

4.编写代码

4.1连接MongoDB配置文件

spring.data.mongodb.host=127.0.0.1
spring.data.mongodb.port=27017
spring.data.mongodb.database=user

4.2实体代码

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

/**
 * 实体层
 */
@Document(collection="user")
public class User {

    @Id // 指定ID
    private String id;

    @Field("name") // 指定域名，覆盖默认
    private String name;

    @Field("password") // 指定域名，覆盖默认
    private String password;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

}

4.3dao代码

@Service
public class UserDao {
    @Autowired
    private MongoTemplate mongoTemplate;
    public User save(User user) {
        mongoTemplate.insert(user);
        return user;
    }
    public User getById(String id) {
        return mongoTemplate.findById(id, User.class);
    }
    public User deleteById(String id) {
        User user = mongoTemplate.findById(id, User.class);
        mongoTemplate.remove(user);
        return user;
    }

    public User update(User user) {
        mongoTemplate.save(user);
        return user;
    }

    public List<User> getAllUsers() {
        return mongoTemplate.findAll(User.class);
    }

    public Map<String, Object> query(String userName,  int page,  int size) {

        // 条件
        Criteria criteria1 = Criteria.where("name").is(userName);
        Query query = new Query();
        if (userName!= null) {
            query.addCriteria(criteria1);
        }

        // 数量
        long total = mongoTemplate.count(query, User.class);

        // 分页
        query.skip((page - 1) * size).limit(size);

        List<User> data = mongoTemplate.find(query, User.class);
        Map<String, Object> map = new HashMap<String, Object>();

        map.put("data", data);
        map.put("total", total);

        return map;
    }



}

4.4service代码

@Service
public class UserService {
    @Autowired
    private UserDao userDao;
    public User save(User user) {
        return userDao.save(user);
    }
    public User getById(String id) {
        return userDao.getById(id);
    }
    public User deleteById(String id) {
        return userDao.deleteById(id);
    }

    public User update(User user) {
        return userDao.update(user);
    }

    public List<User> getAllUsers() {
        return userDao.getAllUsers();
    }

    public Map<String, Object> query(String userName, int page, int size) {
        return userDao.query(userName,page,size);
    }
}

4.5controller代码

@RestController
@RequestMapping("/user")
@EnableSwagger2
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 增加
     * @param user
     * @return
     */
    @PostMapping("/insert")
    @ApiOperation (value = "insert",notes = "插入")
    public User insertUser(User user) {
        return userService.save(user);
    }

    /**
     * 查询
     * @param id
     * @return
     */
    @GetMapping("/get/{id}")
    @ApiOperation (value = "get",notes = "查询")
    public User getUserById(@PathVariable String id) {
        return userService.getById(id);
    }

    /**
     * 删除
     * @param id
     * @return
     */
    @DeleteMapping("/delete/{id}")
    @ApiOperation (value = "delete",notes = "删除")
    public User deleteUserById(@PathVariable String id) {
        return userService.deleteById(id);
    }

    /**
     * 修改
     * @param user
     * @return
     */
    @PutMapping("/update")
    @ApiOperation (value = "update",notes = "修改")
    public User updateUser(User user) {
        return userService.update(user);
    }

    /**
     * 查询所有的用户
     * @return
     */
    @GetMapping("/get/all")
    @ApiOperation (value = "getAll",notes = "获取所有")
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    /**
     * 分页查询用户
     * @param userName
     * @param page
     * @param size
     * @return
     */
    @GetMapping("/select/{page}/{size}")
    @ApiOperation (value = "select",notes = "分页查询")
    public Map<String, Object> selectUserByProperty(String userName, @PathVariable int page, @PathVariable int size) {
        return userService.query(userName,page,size);
    }
}

4.6pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.5.6</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example</groupId>
	<artifactId>mongodb</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>mongodb</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger2</artifactId>
			<version>2.9.2</version>
		</dependency>
		<!-- 接口API生成html文档 -->
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger-ui</artifactId>
			<version>2.6.1</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-mongodb</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>5.3.14</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>5.3.14</version>
		</dependency>
		
		
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

5.代码接口测试

访问​​​​​​http://localhost:8080/swagger-ui.html出现如下界面：

 下面使用新增接口举例说明，其他接口类似

完整项目地址 www.zrscsoft.com/sitepic/12146.html

springboot是java中最实用，当前也是最流行的框架，mybaits对应dao层。想要做项目springboot和mybaits是必须的。今天就教大家怎么简单搭建一个用springboot的增删改查项目。测试用postman实现。自己动手做的时候可能也会踩坑，后面把过程中踩坑，注意事项告诉大家。

数据库准备

create table student(
id int auto_increment PRIMARY KEY,
age int(20),
name varchar(20), 
sex varchar(20)
);

 我的项目目录是这样的大家可以参考一下，初学者springbootapplication的启动类位置放的不对也会报错。记住，要放在你的controller service entity repository 等目录的同一层

首先写好配置文件 application.properties

(1)

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboot
spring.datasource.username=root
spring.datasource.password=root


spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

mybatis.type-aliases-package=com.xue


mybatis.mapper-locations=classpath:mapper/*.xml

 配置文件优先级 properties大于yml 这点这点注意

（2）实体类，get set tostring 方法

public class Employee {

   private Integer id;
   private String  name;
   private String age;
   private String sex;


    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

(3)先写dao层（mapper层）

public interface EmployeeMapper {

    public List<Employee> EmployeeList();

     public int insert(Employee employee);

     public int deleteId(int id);

     public Employee getEmployee(int id);

     public int update (Employee employee);


}

（4）再写service层 service接口和service的继承类

public interface EmployeeService {


    public List<Employee> EmployeeList();

    public int insert(Employee employee);

    public int deleteId(int id);

    public Employee getEmployee(int id);

    public int update (Employee employee);

}

@Service
public class EmployeeServiceImpl implements EmployeeService {
    @Autowired
    private EmployeeMapper employeeMapper;

    @Override
    public List<Employee>  EmployeeList(){
        return employeeMapper.EmployeeList();

    }

    @Override
    public int insert(Employee employee) {
        int result = 0;
        try {
            result=employeeMapper.insert(employee);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;

    }

    @Override
    public int deleteId(int id) {
        int result = 0;
        try {
            result= employeeMapper.deleteId(id);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;


    }

    @Override
    public Employee getEmployee(int id) {
//            result = 0;
//        try {
//            result = employeeMapper.getEmployee(id);
//        } catch (Exception e) {
//            e.printStackTrace();
//        }

//        return result;
        return employeeMapper.getEmployee(id);
    }

    @Override
    public int update(Employee employee) {
       int  result =0;
        try {
            result =employeeMapper.update(employee);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;

    }


}

（5）再写comtroller层

@RestController
@RequestMapping("/emp")
public class EmployeeController {

    @Autowired
    private EmployeeService es;
    @RequestMapping("/list")

    public List<Employee>  EmployeeList(){
        return es.EmployeeList();


    }

    @PostMapping("/insert")

   public int insert(Employee employee){
        return es.insert(employee);


   }
   @PostMapping("/delete")

   public int deleteId(int id){
        return es.deleteId(id);


   }

   @GetMapping("/getemployee")

   public Employee getEmployee(int id){

        return es.getEmployee(id);


   }
   @PostMapping("/update")

   public int update(Employee employee){

        return  es.update(employee);
   }

（7）springboot启动类

@SpringBootApplication
@MapperScan("com.xue.repository.dao") //自动扫描com.xue.repository.dao下的文件
public class SpringbootLoginApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringbootLoginApplication.class, args);
	}

}

（6）编写 xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.xue.repository.dao.EmployeeMapper">

  <resultMap type="Employee" id="StudentWithAddressResult">
    <id property="id" column="id" />
    <result property="age" column="age" />
      <result property="name" column="name" />
      <result property="sex" column="sex" />
  </resultMap>
<!--  <select id="selectStudentWithAddress" parameterType="int"-->
<!--          resultMap="StudentWithAddressResult">select *  from student-->
<!--</select>-->
    <select id="EmployeeList" resultType="com.xue.entity.Employee">
  		select * from student
  	</select>


<!--<insert id="insert" parameterMap="com.xue.entity.Employee" >-->
<!--        insert into student (id,name,age,sex) values (#{id},#{name},#{age},#{sex});-->
<!--</insert>-->
<!--    <insert id="insert" parameterType="com.xue.entity.Employee"-->
<!--            useGeneratedKeys="true" keyProperty="id">-->
<!--  		insert into student (name,age,sex) values (#{name},#{age},#{sex});-->
<!--  	</insert>-->
    <insert id="insert" parameterType="com.xue.entity.Employee">

  		insert into student (name,age,sex) values (#{name},#{age},#{sex});
  	</insert>

    <delete id="deleteId"  parameterType="java.lang.Integer">
        delete from student where id= #{id};

    </delete>

    <select id="getEmployee" resultType="com.xue.entity.Employee">
  		select * from student where id = #{id}
  	</select>

    <update id="update" parameterType="com.xue.entity.Employee">
  		update student set
  		name= #{name},age=#{age},sex=#{sex}
  		where id= #{id}
  	</update>
</mapper>

基本完成，后面用postman 测试一下。或者浏览器也行。

源码更新后会上传 

源码： javaspringboot加mybaits简单增删改查案例，源码。-Java文档类资源-CSDN下载