【ChatGPT自动生成系列】SpringBoot集成Mybatis_chatgpt 给个java类自动生成mapper

Spring Boot集成MyBatis

介绍

Spring Boot是一个用于快速构建独立、生产级别的Spring应用程序的框架。而MyBatis是一个开源的持久层框架，可以与Spring Boot无缝集成，提供强大的数据库访问能力。

本文将介绍如何在Spring Boot项目中集成MyBatis，并展示一些常用的操作示例。

步骤

步骤一：创建Spring Boot项目

首先，我们需要创建一个Spring Boot项目。你可以使用Spring Initializr（https://start.spring.io/）来快速生成一个基础的Spring Boot项目。

步骤二：添加依赖

在项目的pom.xml文件中添加以下依赖：

<dependencies>
    <!-- Spring Boot相关依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- MyBatis依赖 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.2.0</version>
    </dependency>
    
    <!-- 数据库驱动依赖，根据自己的数据库选择 -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
    
    <!-- 其他依赖... -->
</dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

步骤三：配置数据库连接

在application.properties（或application.yml）文件中配置数据库连接信息，例如：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
1
2
3
4

在application.properties（或application.yml）文件中配置Mapper文件路径，例如：

#不配置此项 会提示绑定失败！
mybatis.mapper-locations=classpath:mapping/*.xml
1
2

步骤四：创建实体类

创建一个实体类，用于映射数据库表的字段。例如，创建一个名为User的实体类：

public class User {
    private Long id;
    private String username;
    private String password;
    // 其他字段...
    
    // getter和setter方法...
}
1
2
3
4
5
6
7
8

步骤五：创建Mapper接口

创建一个Mapper接口，用于定义数据库操作的方法。例如，创建一个名为UserMapper的接口：

public interface UserMapper {
    void insert(User user);
    
    void update(User user);
    
    void delete(Long id);
    
    User findById(Long id);
    
    List<User> findAll();
}
1
2
3
4
5
6
7
8
9
10
11

步骤六：创建Mapper XML文件

在resources目录下创建一个与Mapper接口同名的XML文件，用于编写SQL语句。例如，创建一个名为UserMapper.xml的文件：

<mapper namespace="com.example.mapper.UserMapper">
    <insert id="insert" parameterType="com.example.entity.User">
        INSERT INTO user (username, password) VALUES (#{username}, #{password})
    </insert>
    
    <update id="update" parameterType="com.example.entity.User">
        UPDATE user SET username=#{username}, password=#{password} WHERE id=#{id}
    </update>
    
    <delete id="delete" parameterType="java.lang.Long">
        DELETE FROM user WHERE id=#{id}
    </delete>
    
    <select id="findById" parameterType="java.lang.Long" resultType="com.example.entity.User">
        SELECT * FROM user WHERE id=#{id}
    </select>
    
    <select id="findAll" resultType="com.example.entity.User">
        SELECT * FROM user
    </select>
</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

步骤七：编写Service层

创建一个Service接口和实现类，用于调用Mapper接口中的方法。例如，创建一个名为UserService的接口和实现类：

public interface UserService {
    void addUser(User user);
    
    void updateUser(User user);
    
    void deleteUser(Long id);
    
    User getUserById(Long id);
    
    List<User> getAllUsers();
}

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;
    
    @Override
    public void addUser(User user) {
        userMapper.insert(user);
    }
    
    @Override
    public void updateUser(User user) {
        userMapper.update(user);
    }
    
    @Override
    public void deleteUser(Long id) {
        userMapper.delete(id);
    }
    
    @Override
    public User getUserById(Long id) {
        return userMapper.findById(id);
    }
    
    @Override
    public List<User> getAllUsers() {
        return userMapper.findAll();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

步骤八：编写Controller层

创建一个Controller类，用于处理HTTP请求。例如，创建一个名为UserController的类：

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;
    
    @PostMapping
    public void addUser(@RequestBody User user) {
        userService.addUser(user);
    }
    
    @PutMapping("/{id}")
    public void updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        userService.updateUser(user);
    }
    
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
    
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }
    
    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

步骤九：运行项目

SpringBoot入口配置@MapperScan

package com.demo;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
// 配置MapperScan 避免找不到Bean的异常
@MapperScan("com.demo.dao")
@SpringBootApplication
public class DemoApplication {

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

}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

现在，你可以运行Spring Boot项目，并通过HTTP请求访问API接口了。

总结

本文介绍了如何在Spring Boot项目中集成MyBatis，并展示了一些常用的操作示例。希望对你有帮助。如果你有任何问题或建议，欢迎留言讨论！