Mybatis动态数据源-分库分表简单版实现

最新推荐文章于 2024-03-27 14:47:11 发布
最新推荐文章于 2024-03-27 14:47:11 发布
阅读量1.9k 收藏 9
点赞数 1
分类专栏： # Mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linkingfei/article/details/118256387
版权

1、动态数据源【分库】

分库有两种选择方案：

  • 用dao接口注解+切面实现动态数据源
  • 利用表字段分库策略实现

此处采用第一种方案，第二种方案我将在分表是实现；

1.1 环境搭建
  • 引入以下依赖
     <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
         <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
  • 启动类配置：
// 关闭数据源自动配置
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class DemoApplication {}

创建两个库， user_master\user_slave库，并在库中分表建立一个表：

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` int NOT NULL,
  `name` varchar(255) NULL DEFAULT NULL,
  `age` int NOT NULL DEFAULT 0 COMMENT '年龄',
  PRIMARY KEY (`id`),
  INDEX `c_index`(`name`)
) ENGINE = InnoDB CHARACTER SET = utf8mb4;
1.2 数据准备
  • 配置数据源
spring.datasource.master.jdbc-url = jdbc:mysql://localhost:3306/user_master?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
spring.datasource.master.username = ***
spring.datasource.master.password = ***
spring.datasource.master.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.slave.jdbc-url = jdbc:mysql://localhost:3306/user_slave?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
spring.datasource.slave.username = ***
spring.datasource.slave.password =***
spring.datasource.slave.driver-class-name=com.mysql.cj.jdbc.Driver
  • 自定义数据源
@Configuration
@MapperScan(basePackages = "com.lonk.demo.template.dao", sqlSessionFactoryRef = "SqlSessionFactory")
public class DynamicDataSourceConfig {

    @Bean
    public  org.apache.ibatis.session.Configuration configuration() {
        configuration.setMapUnderscoreToCamelCase(true);
        configuration.setLogImpl(StdOutImpl.class);
        configuration.setUseColumnLabel(true);
        return configuration;
    }


    @Bean(name = "master")
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource getDateSource1() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "slave")
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource getDateSource2() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "dynamicDataSource")
    public DynamicDataSource DataSource(@Qualifier("master") DataSource masterDataSource,
                                        @Qualifier("slave") DataSource slaveDataSource) {
        //这个地⽅是⽐较核⼼的targetDataSource 集合是我们数据库和名字之间的映射
        Map<Object, Object> targetDataSource = new HashMap<>();
        targetDataSource.put(DataSourceType.DataBaseType.Master, masterDataSource);
        targetDataSource.put(DataSourceType.DataBaseType.Slave, slaveDataSource);

        DynamicDataSource dataSource = new DynamicDataSource();
        dataSource.setTargetDataSources(targetDataSource);
        dataSource.setDefaultTargetDataSource(masterDataSource);
        return dataSource;
    }


    @Bean(name = "SqlSessionFactory")
    public SqlSessionFactory SqlSessionFactory(@Qualifier("dynamicDataSource") DataSource dynamicDataSource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        // jdbc数据源整合mybatis的SqlSessionFactory
        bean.setDataSource(dynamicDataSource);
        // 设置配置: 类似mybatis-config.xml
        bean.setConfiguration(configuration());
        bean.setTypeAliasesPackage("com.lonk.demo.template.entity");
        // bean.setPlugins();
        bean.setMapperLocations(
                new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));
        return bean.getObject();
    }

    @Bean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    @Bean
    public DataSourceTransactionManager transactionManager(@Qualifier("dynamicDataSource") DataSource dynamicDataSource){
        return new DataSourceTransactionManager(dynamicDataSource);
    }
}

public class DataSourceType {

    private static final ThreadLocal<DataBaseType> TYPE = new ThreadLocal<DataBaseType>();


    public static void setDataBaseType(DataBaseType dataBaseType) {
        if (dataBaseType == null) {
            throw new NullPointerException();
        }
        TYPE.set(dataBaseType);
    }

    public static DataBaseType getDataBaseType() {
        DataBaseType dataBaseType = TYPE.get() == null ? DataBaseType.Master : TYPE.get();
        return dataBaseType;
    }

    public static void clearDataBaseType() {
        TYPE.remove();
    }


    public enum DataBaseType {
        Master("master"),
        Slave("slave");

        private String name;

        private DataBaseType(String name) {
          this.name = name;
        }

        public String getName() {
          return name;
        }
    }
}
1.3 动态数据源

上面配置数据源默认为master, 如何实现动态切换数据源？
可以实现AbstractRoutingDataSource，确定数据源路由策略：

public class DynamicDataSource extends AbstractRoutingDataSource {
    
    @Override
    protected Object determineCurrentLookupKey() {
        DataSourceType.DataBaseType dataBaseType = DataSourceType.getDataBaseType();
        return dataBaseType;
    }
}

此处，采用注解+aop实现动态切换，配置不同的数据源调用不同的库：

@Target({ElementType.METHOD, ElementType.TYPE, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface SharedDataSource {

    String value() default "master";
}


@Aspect
@Component
public class DataSourceAop {


    @Before("@annotation(dataSource)")
    public void changeDataSource(JoinPoint point, SharedDataSource dataSource) {
        String type = dataSource.value();
        if (DataSourceType.DataBaseType.Master.getName().equals(type)){
            DataSourceType.setDataBaseType(DataSourceType.DataBaseType.Master);
        } else if (DataSourceType.DataBaseType.Slave.getName().equals(type)){
            DataSourceType.setDataBaseType(DataSourceType.DataBaseType.Slave);
        } else {
            DataSourceType.setDataBaseType(DataSourceType.DataBaseType.Master);
        }
    }

    @After("@annotation(dataSource)")
    public void restoreDataSource(JoinPoint point, SharedDataSource dataSource) {
    	// 注意清除，不影响其他使用默认数据源master
        DataSourceType.clearDataBaseType();
    }

}
1.4 示例
@RestController
@RequestMapping("/v1/api/user")
@Slf4j
public class UserController {

    @Resource
    private UserService userService;


    @GetMapping("/{id}")
    public User GetUser(@PathVariable("id") Integer id){
        User user = userService.getUserById(id);
        log.info("user: {}", user);
        return user;
    }
}

@Repository
public interface UserDao {

	 // 未配置默认为master
     @SharedDataSource("master")
     User getUserById(Integer id);
}

  <select id="getUserById" parameterType="java.lang.Integer" resultMap="UserMap">
        select * from user where id = #{id}
    </select>

在这里插入图片描述

2、分表的简单实现

在1的基础上我们来实现一个简单分表案例， 这里自定义mybatis插件，根据主键id实现分表查询：

2.1 数据表配置

在user_master、user_slave同时创建两张表：

CREATE TABLE `t_user_0`  (
  `id` int NOT NULL,
  `name` varchar(255) NULL DEFAULT NULL,
  `age` int NOT NULL DEFAULT 0 COMMENT '年龄',
  PRIMARY KEY (`id`),
  INDEX `c_index`(`name`)
) ENGINE = InnoDB CHARACTER SET = utf8mb4;

CREATE TABLE `t_user_1`  (
  `id` int NOT NULL,
  `name` varchar(255) NULL DEFAULT NULL,
  `age` int NOT NULL DEFAULT 0 COMMENT '年龄',
  PRIMARY KEY (`id`),
  INDEX `c_index`(`name`)
) ENGINE = InnoDB CHARACTER SET = utf8mb4;
2.2 自定义分表插件

这个我以简单id查询为例，对于对象类型需要使用时需修改：

@Intercepts(@Signature(
            type = StatementHandler.class,
            method = "prepare",
            args = {Connection.class, Integer.class}))
public class TableShardInterceptor implements Interceptor {

    private static final String logicTable = "user";
    private static final List<String> actualTable = new ArrayList();
    static {
        actualTable.add("t_user_0");
        actualTable.add("t_user_1");
    }

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
        MetaObject metaObject = MetaObject.forObject(statementHandler, SystemMetaObject.DEFAULT_OBJECT_FACTORY,
                SystemMetaObject.DEFAULT_OBJECT_WRAPPER_FACTORY, new DefaultReflectorFactory());

        MappedStatement mappedStatement = (MappedStatement) metaObject.getValue("delegate.mappedStatement");
        String statementId = mappedStatement.getId();

        String sql = (String) metaObject.getValue("delegate.boundSql.sql");

        ParameterHandler parameterHandler = (ParameterHandler) metaObject.getValue("delegate.parameterHandler");;
        // Object parameterObject1 = statementHandler.getBoundSql().getParameterObject();
        Object parameterObject = parameterHandler.getParameterObject();
        sql = replaceSql(logicTable, parameterObject, sql);

        metaObject.setValue("delegate.boundSql.sql", sql);
        return invocation.proceed();
    }

    private String replaceSql(String logic, Object parameterObject, String sql) {
        if (parameterObject instanceof Integer) {
            // 分表策略: 根据ID取模
            Integer index = (Integer) parameterObject % actualTable.size();
            String actual = "t_" + logic + "_" + index ;
            return sql.replaceAll(logic, actual);
        } else {
            // 默认表
            String actual = actualTable.get(0);
            return sql.replaceAll(logic, actual);
        }
    }

    // 复杂参数对象处理
    private void paramProcess() {
        // 配置分表字段
//        String sharedField = "id";
//        String sharedTable = "order";
//        if (parameterObject instanceof MapperMethod.ParamMap) {
//            MapperMethod.ParamMap parameterMap = (MapperMethod.ParamMap) parameterObject;
//            Object valueObject = parameterMap.get(sharedField);
//            if (valueObject == null) {
//                throw new RuntimeException(String.format("入参字段%s无匹配", sharedField));
//            }
//
//            replaceSql(sharedTable, valueObject, sql);
//        } else {
//            if (isBaseType(parameterObject)) {
//
//            }
//            if (parameterObject instanceof Map){
//                Map<String,Object>  parameterMap =  (Map<String,Object>)parameterObject;
//                Object valueObject = parameterMap.get(sharedField);
//
//                replaceSql(sharedTable, valueObject, sql);
//            } else {
//                //非基础类型对象
//                Class<?> parameterObjectClass = parameterObject.getClass();
//                Field declaredField = parameterObjectClass.getDeclaredField(sharedField);
//                declaredField.setAccessible(true);
//                Object valueObject = declaredField.get(parameterObject);
//                //替换sql
//                replaceSql(sharedTable, valueObject, sql);
//            }
//        }
    }

    private boolean isBaseType(Object object) {
        if (object.getClass().isPrimitive()
                || object instanceof String
                || object instanceof Integer
                || object instanceof Double
                || object instanceof Float
                || object instanceof Long
                || object instanceof Boolean
                || object instanceof Byte
                || object instanceof Short) {
            return true;
        } else {
            return false;
        }
    }


    public static Object getValueByReflect(Object model, String paraName) throws Exception {
        Object value = new Object();
        Field[] fields = model.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            if (field.getName().equals(paraName)) {
                value =  field.get(model);
                break;
            }
        }
        return value;
    }

}

将分表插件加到数据源：

修改DynamicDataSourceConfig的configuration

@Bean
    public  org.apache.ibatis.session.Configuration configuration() {
        TableShardInterceptor pagePlugin = new TableShardInterceptor();
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setMapUnderscoreToCamelCase(true);
        configuration.setLogImpl(StdOutImpl.class);
        configuration.setUseColumnLabel(true);
        configuration.addInterceptor(pagePlugin);
        return configuration;
    }

以上是根据表字段进行分表查询，类似也可实现分库查询，此处不再举例。

linkingfei
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
简单易懂的MyBatis分库分表方案分享
08-26
主要给大家介绍了关于MyBatis分库分表方案的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者使用MyBatis具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
SpringMVC + MyBatis分库分表方案
weixin_30940783的博客
06-11 572
　　mybatis作为流行的ORM框架，项目实际使用过程中可能会遇到分库分表的场景。mybatis在分表，甚至是同主机下的分库都可以说是完美支持的，只需要将表名或者库名作为动态参数组装sql就能够完成。但是多余分在不同主机上的库，就不太一样了，组装sql无法区分数据库主机。网上搜索了一下，对于此类情况，大都采用的动态数据源的概念，也即定义不同的数据源连接不同的主机数据库，在查询前通过动...
动态切换数据源原理详解，以及Spring Boot + MyBatis-Plus 在实际开发中的快速切换方法
最新发布
funnyCaoC的博客
03-27 999
在一个实际的企业工程项目当中，我们的数据往往会来源于不同的数据库服务器，所以在调用数据访问层或者业务层的方法时，我们要指定本次访问的数据来源于哪个数据源，最好的方式就是通过注解的方式，直接切换当前方法的数据来源。所幸的是，MyBatis Plus基于Spring Boot项目开发了一个能够快速切换数据源的注解，在介绍它之前，我们先来了解一下动态切换数据源的原理，同时也可以让没有导入Mybatis Plus的小伙伴也能通过注解实现数据源的切换。
一种简单易懂的 MyBatis 分库分表方案，送给大家
知识分享官
09-16 373
本文的分库分表方案基于 MyBatis 框架，但是又不同于市面上常用的方案，它们一般都是通过编写复杂的 MyBatis 插件来重写 SQL 语句，这样的插件代码会巨复杂无比，可能最终只有插件的原作者自己可以完全吃透相关代码，给项目的维护性带来一定问题。那么 post_0、post_4、post_8 等分配到 0 号库，post_1、post_5、post_9 等分配到 1 号库，post_2、post_6、post_10 等分配到 2 号库，post_3、post_5、post_11 等分配到 4 号库。
mybatis实现分表
zhiqiang_zhao
08-30 1972
mybatis动态拦截表，进行业务分年表
mybatis分库分表
菜蚜的专栏
04-19 166
精选30+云产品，助力企业轻松上云！>>> 分库分表...
SpringBoot集成Mybatis多数据源实现分表分库
zy_javaAndweb的博客
03-24 1002
SpringBoot实现分库分表
spring动态数据源+mybatis分库分表
03-08
spring动态数据源整合mybatis实现的分库分表操作。 分库分表对业务代码是透明的，只需要在配置文件分配分库模版即可动态的实现分库分表的增删改查操作。
基于yml 配置方式 ，实现springBoot+sharding-jdbc+mybatis-plus 实现分库分表，读写分离，以及全局表，子表的配置
10-26
1、基于yml 配置方式 ，实现springBoot+sharding-jdbc+mybatis-plus 实现分库分表，读写分离，以及全局表，子表的配置。 2、实现mybatis-plus 整合到springboot 详细使用请看 测试用例
SpringBoot 2.0 整合sharding-jdbc中间件实现数据分库分表
08-25
SpringBoot 2.0 整合sharding-jdbc中间件实现数据分库分表 SpringBoot 2.0 整合sharding-jdbc中间件实现数据分库分表是指在 Spring Boot 2.0 框架下使用 sharding-jdbc 中间件来实现数据分库分表的技术方案。在这个...
SpringBoot + ShardingSphere分库分表实战(附完整代码)
04-11
4. 集成Mybatis-Plus：配置Mybatis-Plus，编写Mapper接口及实体类，使用ShardingSphere提供的数据源和表名自动完成分库分表操作。 四、运行与测试 完成上述配置后，启动Spring Boot应用，通过HTTP请求测试分库分表...
来看下这篇文章，教你如何实现一个SpringBoot的Mybatis分库分表组件
Huangjiazhen711的博客
11-05 739
首页，我们上面说过要根据存入数据库的数据来计算将数据分配到哪个库哪张表里面。所以在定义这个注解的时候，我需要一个注解内的参数用来表明，根据哪个字段的数据计算所分配的库表。/*** 需要进行分表分库的字段* 通过此字段来计算分到哪个表哪个库* @return*/}复制代码因为当前这个注解的生命周期需要一直留，即使是在运行期，所以这里的Retention使用的是因为这次写的这个分库分表的组件是针对方法的，所以在这个Target使用的是ElementType.METHOD。
一种简单易懂的 MyBatis 分库分表方案
codehole_的博客
03-10 278
数据库分库分表除了使用中间件来代理请求分发之外，另外一种常见的方法就是在客户端层面来分库分表 —— 通过适当地包装客户端代码使得分库分表的数据库访问操作代码编写起来也很方...
基于mybatis的shard方案（分表分库、读写分离）
热门推荐
xingkong0128的专栏
01-14 1万+
m-shard是本人近日完成一个基于mybatis、spring的分表分库插件，以下将对该插件做详细说明。 MShard是什么 MShard是一个定位于orm层shard方案，支持分表分库（跨库分表）、读写分离，支持分布式事务，它是一个基于于mybatis3.x的扩展，依赖于spring。 功能要点 1、分库分表（跨库） 2、读取分享 3、事务控制 基于spring管理事
springboott整合mybatis-plus和sharding-jdbc实现分库分表和读写分离（含完整项目代码）
gorylee的博客
10-04 1994
springboott整合mybatis-plus和sharding-jdbc实现分库分表和读写分离（含完整项目代码） 一、整合sharding-jdbc 关于springboot整合sharding-jdbc官网有4种方式，而网上千篇一律都是用.properties文件。我在这里主要是用yml+bean两种方式结合，bean主要是为了实现分片键分片规则更灵活。 1.1引入maven依赖 这里有个小坑，我一开始引入是最新的sharding-jdbc和mybatis-plus的依赖，结果启动项目直接报错。所以
mybatis mysql 分表_利用mybatis插件实现数据库分表
weixin_39955953的博客
01-19 551
前言前面介绍了数据库【分库】相关技术的实现，包括：自定义注解完成数据库切库 和 多个数据源的轻松支持，再来看 面试中并发类问题的准备和学习 这边手记，高并发处理思路与手段里数据库部分还差一个【分表】，这篇手记主要就来说一下通过mybatis的插件【shardbatis2.0】来完成分表的实现。Java并发编程与高并发解决方案这门课程的学员需要特别注意，课程里高并发部分提到的【数据库分表】，可以参考...
mybatis+shardingJdbc实现数据库读写分离和分库分表
yx444535180的专栏
03-10 1850
一、原理介绍 下面这篇讲的很完整就不赘述了 MySQL数据库的读写分离、分库分表 二、环境准备 2.1 数据库环境 读写分离必须依赖数据的主从复制，这篇博客有详细的过程 mysql主从安装 2.2 开发环境 本案例使用springboot2.6.4+mybatis3.6.7+sharding-jdbc4.1.1 2.2.1 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.
mybatis同时insert多张表_基于spring 切面（AOP）实现动态多数据源切换，基于 MyBatis 插件方式实现动态分表查询
weixin_39607423的博客
12-05 2801
最新更新版本，请移步：基于spring 切面（AOP）实现动态多数据源切换，基于 MyBatis 插件方式实现动态分表查询这里不支持 markdown 格式，更新有点麻烦，有一点小遗憾~~基于spring 切面（AOP）实现动态多数据源切换；基于 MyBatis 插件方式实现动态分表查询。 来源于多个已上线项目实践，本项目有完整的测试示例。mybatis-plugin-shard基于spring ...
Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表功能实战代码
05-10
以下是 Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表的实战代码： 1. 添加依赖 在 `pom.xml` 文件中添加以下依赖： ```xml <dependencies> <!-- Sharding-JDBC --> <dependency> <groupId>io.shardingsphere</groupId> <artifactId>sharding-jdbc-core</artifactId> <version>4.1.1</version> </dependency> <!-- Mybatis-Plus --> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.4.3</version> </dependency> <!-- MySQL 驱动 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.24</version> </dependency> </dependencies> ``` 2. 配置数据源 在 `application.yml` 文件中配置数据源： ```yaml spring: datasource: # 主库 master: url: jdbc:mysql://localhost:3306/db_master?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai username: root password: root driver-class-name: com.mysql.cj.jdbc.Driver # 从库 slave: url: jdbc:mysql://localhost:3306/db_slave?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai username: root password: root driver-class-name: com.mysql.cj.jdbc.Driver ``` 3. 配置 Sharding-JDBC 在 `application.yml` 文件中配置 Sharding-JDBC： ```yaml spring: shardingsphere: datasource: names: master, slave # 数据源名称 master: type: com.zaxxer.hikari.HikariDataSource slave: type: com.zaxxer.hikari.HikariDataSource config: sharding: tables: user: actualDataNodes: master.user_$->{0..1} # 分表规则，user_0 和 user_1 表 tableStrategy: inline: shardingColumn: id algorithmExpression: user_$->{id % 2} # 分表规则，根据 id 取模 databaseStrategy: inline: shardingColumn: id algorithmExpression: master # 分库规则，根据 id 取模 bindingTables: - user # 绑定表，即需要进行分库分表的表 ``` 4. 配置 Mybatis-Plus 在 `application.yml` 文件中配置 Mybatis-Plus： ```yaml mybatis-plus: configuration: map-underscore-to-camel-case: true # 下划线转驼峰 ``` 5. 编写实体类 创建 `User` 实体类，用于映射数据库中的 `user` 表： ```java @Data public class User { private Long id; private String name; private Integer age; } ``` 6. 编写 Mapper 接口 创建 `UserMapper` 接口，用于定义操作 `user` 表的方法： ```java @Mapper public interface UserMapper extends BaseMapper<User> { } ``` 7. 编写 Service 类 创建 `UserService` 类，用于调用 `UserMapper` 接口中的方法： ```java @Service public class UserService { @Autowired private UserMapper userMapper; public User getById(Long id) { return userMapper.selectById(id); } public boolean save(User user) { return userMapper.insert(user) > 0; } public boolean updateById(User user) { return userMapper.updateById(user) > 0; } public boolean removeById(Long id) { return userMapper.deleteById(id) > 0; } } ``` 8. 测试 在 `UserController` 类中进行测试： ```java @RestController public class UserController { @Autowired private UserService userService; @GetMapping("/user") public User getUser(Long id) { return userService.getById(id); } @PostMapping("/user") public boolean addUser(@RequestBody User user) { return userService.save(user); } @PutMapping("/user") public boolean updateUser(@RequestBody User user) { return userService.updateById(user); } @DeleteMapping("/user") public boolean removeUser(Long id) { return userService.removeById(id); } } ``` 启动应用程序，访问 `http://localhost:8080/user?id=1` 可以得到 `id` 为 1 的用户信息。访问 `http://localhost:8080/user` 并传入用户信息，可以添加用户。访问 `http://localhost:8080/user` 并传入更新后的用户信息，可以更新用户信息。访问 `http://localhost:8080/user?id=1` 并使用 DELETE 方法，可以删除用户。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值