mybatis连接数据库实现增删改查
时间: 2024-04-18 14:22:24 浏览: 17
MyBatis是一个开源的持久层框架,它可以帮助我们简化数据库操作的编写。下面是使用MyBatis连接数据库实现增删改查的步骤:
1. 配置数据库连接信息:在MyBatis的配置文件中,需要配置数据库的连接信息,包括数据库驱动、数据库URL、用户名和密码等。
2. 创建数据表对应的Java类:在Java中创建一个与数据库表对应的实体类,该类的属性与表的字段一一对应。
3. 创建Mapper接口:创建一个Mapper接口,用于定义数据库操作的方法。每个方法对应一种数据库操作,如增加、删除、修改、查询等。
4. 创建Mapper XML文件:在Mapper XML文件中,编写SQL语句,实现具体的数据库操作。通过MyBatis的标签和占位符,可以动态地拼接SQL语句。
5. 配置Mapper接口和Mapper XML文件的映射关系:在MyBatis的配置文件中,需要配置Mapper接口和Mapper XML文件的映射关系,告诉MyBatis哪个接口对应哪个XML文件。
6. 使用SqlSession进行数据库操作:通过SqlSession对象,可以调用Mapper接口中定义的方法,执行具体的数据库操作。SqlSession提供了多种方法,如insert、delete、update和select等。
7. 提交事务:在执行完一组数据库操作后,需要调用SqlSession的commit方法提交事务,以确保数据的一致性。
8. 关闭SqlSession:在数据库操作完成后,需要关闭SqlSession,释放资源。
相关问题
spring整合mybatis对数据库实现增删改查
好的,下面是一个简单的示例,演示如何使用Spring整合MyBatis对数据库进行增删改查操作:
1. 添加依赖
在 pom.xml 文件中添加以下依赖:
```xml
<dependencies>
<!-- Spring整合MyBatis依赖 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.4</version>
</dependency>
<!-- MySQL数据库驱动依赖 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.23</version>
</dependency>
</dependencies>
```
2. 配置数据源
在 application.properties 文件中添加以下配置:
```properties
# 数据库连接配置
spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# MyBatis配置
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.example.demo.entity
```
3. 创建实体类
创建一个实体类,例如:
```java
public class User {
private Integer id;
private String name;
private Integer age;
// 省略getter和setter方法
}
```
4. 创建Mapper接口
创建一个Mapper接口,例如:
```java
public interface UserMapper {
// 新增用户
int insert(User user);
// 删除用户
int deleteById(Integer id);
// 更新用户
int update(User user);
// 根据ID查询用户
User selectById(Integer id);
// 查询所有用户
List<User> selectAll();
}
```
5. 创建Mapper XML文件
在 resources/mapper 目录下创建 UserMapper.xml 文件,例如:
```xml
<mapper namespace="com.example.demo.mapper.UserMapper">
<!-- 新增用户 -->
<insert id="insert" parameterType="User">
insert into user(name, age) values(#{name}, #{age})
</insert>
<!-- 删除用户 -->
<delete id="deleteById" parameterType="java.lang.Integer">
delete from user where id = #{id}
</delete>
<!-- 更新用户 -->
<update id="update" parameterType="User">
update user set name = #{name}, age = #{age} where id = #{id}
</update>
<!-- 根据ID查询用户 -->
<select id="selectById" resultType="User" parameterType="java.lang.Integer">
select id, name, age from user where id = #{id}
</select>
<!-- 查询所有用户 -->
<select id="selectAll" resultType="User">
select id, name, age from user
</select>
</mapper>
```
6. 创建Service接口及实现类
创建一个Service接口及实现类,例如:
```java
public interface UserService {
// 新增用户
int addUser(User user);
// 删除用户
int deleteUserById(Integer id);
// 更新用户
int updateUser(User user);
// 根据ID查询用户
User getUserById(Integer id);
// 查询所有用户
List<User> getAllUsers();
}
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserMapper userMapper;
@Override
public int addUser(User user) {
return userMapper.insert(user);
}
@Override
public int deleteUserById(Integer id) {
return userMapper.deleteById(id);
}
@Override
public int updateUser(User user) {
return userMapper.update(user);
}
@Override
public User getUserById(Integer id) {
return userMapper.selectById(id);
}
@Override
public List<User> getAllUsers() {
return userMapper.selectAll();
}
}
```
7. 编写Controller
在Controller中注入UserService,并实现对应的增删改查接口即可。例如:
```java
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
@PostMapping("/add")
public int addUser(@RequestBody User user) {
return userService.addUser(user);
}
@DeleteMapping("/{id}")
public int deleteUserById(@PathVariable Integer id) {
return userService.deleteUserById(id);
}
@PutMapping("/update")
public int updateUser(@RequestBody User user) {
return userService.updateUser(user);
}
@GetMapping("/{id}")
public User getUserById(@PathVariable Integer id) {
return userService.getUserById(id);
}
@GetMapping("/all")
public List<User> getAllUsers() {
return userService.getAllUsers();
}
}
```
这样,我们就完成了Spring整合MyBatis对数据库实现增删改查的操作。
使用MyBatis对数据库进行增删改查
MyBatis是一种持久层框架,它可以帮助我们轻松地实现数据库操作。下面是使用MyBatis进行增删改查的基本步骤:
1. 配置MyBatis的XML文件(mybatis-config.xml)和映射文件(mapper.xml)。
2. 创建数据库连接,并将连接信息配置到mybatis-config.xml文件中。
3. 在mapper.xml文件中定义SQL语句,包括select、insert、update和delete等操作。
4. 在Java代码中使用SqlSessionFactoryBuilder构建SqlSessionFactory实例,并通过SqlSession获取Mapper实例。
5. 在Java代码中调用Mapper实例的方法执行SQL语句,完成增删改查操作。
下面是一个简单的示例代码:
1. 配置文件mybatis-config.xml
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/test"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="com/example/demo/mapper/UserMapper.xml"/>
</mappers>
</configuration>
```
2. 映射文件UserMapper.xml
```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.example.demo.mapper.UserMapper">
<resultMap id="userMap" type="com.example.demo.entity.User">
<id column="id" property="id"/>
<result column="name" property="name"/>
<result column="age" property="age"/>
</resultMap>
<select id="getUserById" parameterType="int" resultMap="userMap">
select id, name, age from user where id = #{id}
</select>
<select id="getAllUsers" resultMap="userMap">
select id, name, age from user
</select>
<insert id="insertUser" parameterType="com.example.demo.entity.User">
insert into user (name, age) values (#{name}, #{age})
</insert>
<update id="updateUser" parameterType="com.example.demo.entity.User">
update user set name=#{name}, age=#{age} where id=#{id}
</update>
<delete id="deleteUser" parameterType="int">
delete from user where id=#{id}
</delete>
</mapper>
```
3. Java代码
```java
public class UserMapperTest {
private static SqlSessionFactory sqlSessionFactory;
static {
try {
Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
} catch (Exception e) {
e.printStackTrace();
}
}
@Test
public void testGetUserById() {
SqlSession sqlSession = sqlSessionFactory.openSession();
try {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
User user = userMapper.getUserById(1);
System.out.println(user);
} finally {
sqlSession.close();
}
}
@Test
public void testGetAllUsers() {
SqlSession sqlSession = sqlSessionFactory.openSession();
try {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = userMapper.getAllUsers();
System.out.println(userList);
} finally {
sqlSession.close();
}
}
@Test
public void testInsertUser() {
SqlSession sqlSession = sqlSessionFactory.openSession();
try {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
User user = new User("张三", 20);
userMapper.insertUser(user);
sqlSession.commit();
System.out.println(user.getId());
} finally {
sqlSession.close();
}
}
@Test
public void testUpdateUser() {
SqlSession sqlSession = sqlSessionFactory.openSession();
try {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
User user = new User(1, "李四", 25);
userMapper.updateUser(user);
sqlSession.commit();
} finally {
sqlSession.close();
}
}
@Test
public void testDeleteUser() {
SqlSession sqlSession = sqlSessionFactory.openSession();
try {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
userMapper.deleteUser(1);
sqlSession.commit();
} finally {
sqlSession.close();
}
}
}
```
以上代码演示了通过MyBatis对数据库进行增删改查的基本操作。