springboot（2.0.1） 整合mybatis

最新推荐文章于 2023-10-30 10:35:38 发布
最新推荐文章于 2023-10-30 10:35:38 发布
阅读量690 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zpengf/article/details/80167859
本文介绍了如何在SpringBoot 2.0.1项目中整合Mybatis，包括在pom.xml中添加依赖，配置Druid数据源和过滤器，以及设置dataresource。同时，提到了使用的开发工具有MySQL、Tomcat 3.3.9。内容涵盖了实体类、DAO接口以及应用的配置文件。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

综合：pom文件中加入

jpa，druid，jdbc，mybatis，mysql地址坐标

congfig中配置druid与filter,同时换药配置dataresource(数据源不能少，版本不同配置的方法不同)

开发工具：

MySQL，Tomcat3.3.9，springboot2.0.1

pom

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>cn.vp</groupId>
   <artifactId>ssb08</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>ssb08</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.0.1.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>



      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-data-jpa</artifactId>
      </dependency>
      <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
      <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>druid</artifactId>
         <version>1.1.9</version>
      </dependency>



      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-jdbc</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-thymeleaf</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.mybatis.spring.boot</groupId>
         <artifactId>mybatis-spring-boot-starter</artifactId>
         <version>1.3.2</version>
      </dependency>

      <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <scope>runtime</scope>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

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


</project>


1.实体类：

1.1Department.java

package cn.vp.entity;

public class Department {

   private Integer id;
   private String departmentName;

   public Department() {
   }
   
   public Department(int i, String string) {
      this.id = i;
      this.departmentName = string;
   }

   public Integer getId() {
      return id;
   }

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

   public String getDepartmentName() {
      return departmentName;
   }

   public void setDepartmentName(String departmentName) {
      this.departmentName = departmentName;
   }

   @Override
   public String toString() {
      return "Department [id=" + id + ", departmentName=" + departmentName + "]";
   }
   
}

1.2Employee.java

package cn.vp.entity;

import java.util.Date;

public class Employee {

   private Integer id;
    private String lastName;

    private String email;
    //1 male, 0 female
    private Integer gender;
    private Department department;
    private Date birth;

    public Integer getId() {
        return id;
    }

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

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Integer getGender() {
        return gender;
    }

    public void setGender(Integer gender) {
        this.gender = gender;
    }

    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }
    public Employee(Integer id, String lastName, String email, Integer gender,
                    Department department) {
        super();
        this.id = id;
        this.lastName = lastName;
        this.email = email;
        this.gender = gender;
        this.department = department;
        this.birth = new Date();
    }

    public Employee() {
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", lastName='" + lastName + '\'' +
                ", email='" + email + '\'' +
                ", gender=" + gender +
                ", department=" + department +
                ", birth=" + birth +
                '}';
    }
   
   
}

2.dao

DepartmentDao.java

package cn.vp.dao;

import cn.vp.entity.Department;
import org.apache.ibatis.annotations.*;

@Mapper
public interface DepartmentDao {

    @Insert("INSERT INTO `Department` (`departmentName`) VALUES (#{departmentName})")
    public int addDepartment(Department department);

    @Delete("DELETE FROM  department where id=#{id}")
    public int deleteById(Integer id);

    @Update("UPDATE `Department` SET `departmentName`=#{departmentName} WHERE (`id`=#{id})")
    public int updateDepartment(Department department);

    @Select("SELECT  * from department where id=#{id}")
    public Department queryById(@Param("id") Integer id);


}

3.config

DataSourcesConfig.java
package cn.vp.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class DataSourcesConfig {
以下是Springboot2.0.1版本的配置


    private static final String DB_PREFIX = "spring.datasource";


    /**
     * 配置druid后台管理的servlet
     *
     * @return
     */
    @Bean
    public ServletRegistrationBean druidServlet() {
        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
        Map<String, String> initParams = new HashMap<>();
        initParams.put("loginUsername", "admin");
        initParams.put("loginPassword", "admin");
        initParams.put("allow", "");//默认就是允许所有访问
        initParams.put("deny", "192.168.15.21");//禁止访问的ip
        bean.setInitParameters(initParams);
        return bean;
    }

    /**
     * 配置druid后台管理的filter
     *
     * @return
     */
    @Bean
    public FilterRegistrationBean druidFilter() {
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());
        Map<String, String> initParams = new HashMap<>();
        //设置不拦截的路径  *.cs *.js    /druid/*
        initParams.put("exclusions","*.js,*.css,/druid/*");
        bean.setInitParameters(initParams);
        //设置filter拦截 那些请求
        bean.setUrlPatterns(Arrays.asList("/*"));
        return bean;
    }



    //解决 spring.datasource.filters=stat,wall,log4j 无法正常注册进去
    @ConfigurationProperties(prefix = DB_PREFIX)
    class IDataSourceProperties {
        private String url;
        private String username;
        private String password;
        private String driverClassName;
        private int initialSize;
        private int minIdle;
        private int maxActive;
        private int maxWait;
        private int timeBetweenEvictionRunsMillis;
        private int minEvictableIdleTimeMillis;
        private String validationQuery;
        private boolean testWhileIdle;
        private boolean testOnBorrow;
        private boolean testOnReturn;
        private boolean poolPreparedStatements;
        private int maxPoolPreparedStatementPerConnectionSize;
        private boolean useGlobalDataSourceStat;
        private String filters;
        private String connectionProperties;

        @Bean     //声明其为Bean实例
        @Primary  //在同样的DataSource中，首先使用被标注的DataSource
        public DataSource dataSource() {
            DruidDataSource datasource = new DruidDataSource();
            datasource.setUrl(url);
            datasource.setUsername(username);
            datasource.setPassword(password);
            datasource.setDriverClassName(driverClassName);

            //configuration
            datasource.setInitialSize(initialSize);
            datasource.setMinIdle(minIdle);
            datasource.setMaxActive(maxActive);
            datasource.setMaxWait(maxWait);
            datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
            datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
            datasource.setValidationQuery(validationQuery);
            datasource.setTestWhileIdle(testWhileIdle);
            datasource.setTestOnBorrow(testOnBorrow);
            datasource.setTestOnReturn(testOnReturn);
            datasource.setPoolPreparedStatements(poolPreparedStatements);
            datasource.setUseGlobalDataSourceStat(useGlobalDataSourceStat);
            datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
            try {
                datasource.setFilters(filters);
            } catch (SQLException e) {
                System.err.println("druid configuration initialization filter: " + e);
            }
            datasource.setConnectionProperties(connectionProperties);
            return datasource;
        }

        public boolean isUseGlobalDataSourceStat() {
            return useGlobalDataSourceStat;
        }

        public void setUseGlobalDataSourceStat(boolean useGlobalDataSourceStat) {
            this.useGlobalDataSourceStat = useGlobalDataSourceStat;
        }

        public String getUrl() {
            return url;
        }

        public void setUrl(String url) {
            this.url = url;
        }

        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;
        }

        public String getDriverClassName() {
            return driverClassName;
        }

        public void setDriverClassName(String driverClassName) {
            this.driverClassName = driverClassName;
        }

        public int getInitialSize() {
            return initialSize;
        }

        public void setInitialSize(int initialSize) {
            this.initialSize = initialSize;
        }

        public int getMinIdle() {
            return minIdle;
        }

        public void setMinIdle(int minIdle) {
            this.minIdle = minIdle;
        }

        public int getMaxActive() {
            return maxActive;
        }

        public void setMaxActive(int maxActive) {
            this.maxActive = maxActive;
        }

        public int getMaxWait() {
            return maxWait;
        }

        public void setMaxWait(int maxWait) {
            this.maxWait = maxWait;
        }

        public int getTimeBetweenEvictionRunsMillis() {
            return timeBetweenEvictionRunsMillis;
        }

        public void setTimeBetweenEvictionRunsMillis(int timeBetweenEvictionRunsMillis) {
            this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
        }

        public int getMinEvictableIdleTimeMillis() {
            return minEvictableIdleTimeMillis;
        }

        public void setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis) {
            this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
        }

        public String getValidationQuery() {
            return validationQuery;
        }

        public void setValidationQuery(String validationQuery) {
            this.validationQuery = validationQuery;
        }

        public boolean isTestWhileIdle() {
            return testWhileIdle;
        }

        public void setTestWhileIdle(boolean testWhileIdle) {
            this.testWhileIdle = testWhileIdle;
        }

        public boolean isTestOnBorrow() {
            return testOnBorrow;
        }

        public void setTestOnBorrow(boolean testOnBorrow) {
            this.testOnBorrow = testOnBorrow;
        }

        public boolean isTestOnReturn() {
            return testOnReturn;
        }

        public void setTestOnReturn(boolean testOnReturn) {
            this.testOnReturn = testOnReturn;
        }

        public boolean isPoolPreparedStatements() {
            return poolPreparedStatements;
        }

        public void setPoolPreparedStatements(boolean poolPreparedStatements) {
            this.poolPreparedStatements = poolPreparedStatements;
        }

        public int getMaxPoolPreparedStatementPerConnectionSize() {
            return maxPoolPreparedStatementPerConnectionSize;
        }

        public void setMaxPoolPreparedStatementPerConnectionSize(int maxPoolPreparedStatementPerConnectionSize) {
            this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;
        }

        public String getFilters() {
            return filters;
        }

        public void setFilters(String filters) {
            this.filters = filters;
        }

        public String getConnectionProperties() {
            return connectionProperties;
        }

        public void setConnectionProperties(String connectionProperties) {
            this.connectionProperties = connectionProperties;
        }
    }
-------------------------------------------以下是springboot1.5.-版本的
 @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource getDataSources() {
        return new DruidDataSource();
    }


    /**
     * 配置druid后台管理的servlet
     *
     * @return
     */
    @Bean
    public ServletRegistrationBean druidServlet() {
        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
        Map<String, String> initParams = new HashMap<>();
        initParams.put("loginUsername", "admin");
        initParams.put("loginPassword", "admin");
        initParams.put("allow", "");//默认就是允许所有访问
        initParams.put("deny", "192.168.15.21");//禁止访问的ip
        bean.setInitParameters(initParams);
        return bean;
    }


    /**
     * 配置druid后台管理的filter
     *
     * @return
     */
    @Bean
    public FilterRegistrationBean druidFilter() {
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());
        Map<String, String> initParams = new HashMap<>();
        //设置不拦截的路径  *.cs *.js    /druid/*
        initParams.put("exclusions","*.js,*.css,/druid/*");
        bean.setInitParameters(initParams);
        //设置filter拦截 那些请求
        bean.setUrlPatterns(Arrays.asList("/*"));
        return bean;
    }
}




MyBatisConfig.java
package cn.vp.config;

import org.mybatis.spring.boot.autoconfigure.ConfigurationCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyBatisConfig {

    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        return new ConfigurationCustomizer() {
            @Override
            public void customize(org.apache.ibatis.session.Configuration configuration) {
                //-自动使用驼峰命名属性映射字段   userId    user_id
                configuration.setMapUnderscoreToCamelCase(true);
                //使用列别名替换列名 select user as User
                configuration.setUseColumnLabel(true);
            }
        };
    }


}
Ssb08Application.java
package cn.vp;

import cn.vp.dao.DepartmentDao;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;


@MapperScan(value = "cn.vp.dao")
@SpringBootApplication
public class Ssb08Application implements CommandLineRunner {

   private DepartmentDao departmentDao;

   public Ssb08Application (DepartmentDao departmentDao) {
      this.departmentDao = departmentDao;
   }


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

   @Override
   public void run(String... args) throws Exception {
      System.out.println(departmentDao.queryById(1));


   }
}

resources

application.yml

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
#   数据源其他配置
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
#   配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall,slf4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true       #配置
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

test

Ssb08ApplicationTests。java
package cn.vp;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

@RunWith(SpringRunner.class)
@SpringBootTest
public class Ssb08ApplicationTests {
   @Autowired
   private DataSource dataSource;

   @Test
   public void contextLoads() throws SQLException {
      System.out.println(dataSource.getClass());
      Connection connection = null;
      try {
         connection = dataSource.getConnection();
         System.err.println("---获取一个连接--");
      } catch (SQLException e) {
         e.printStackTrace();
      } finally {
         if (connection != null) connection.close();
      }


   }
}

dao

DepartmentDaoTest.java
package cn.vp.dao;

import cn.vp.entity.Department;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import static org.junit.Assert.*;
@RunWith(SpringRunner.class)
@SpringBootTest
public class DepartmentDaoTest {
@Autowired
    private DepartmentDao departmentDao;

    @Test
    public void queryById() {
        Department department = departmentDao.queryById(1);
        System.out.println(department);

    }
}




springboot实现快速整合mybatis+mysql
congge
08-24 9147
springboot 整合mysql和mybatis
Springboot整合myBatis（附加pagehelper分页插件）
weixin_43890267的博客
06-13 2918
Spring boot整合myBatis（附加pagehelper分页插件）前提第一步，创建spring boot，导入maven依赖第二步，进行appliction配置第三步，将springboot启动类进行扫描接口配置第四步创建三层架构项目第四步，运行项目，访问Controller接口分页插件pagehelper总结 前提 大家好，我在身边的人当着发现对spring boot整合mybatis...
springboot-2.0.1.RELEASE + mybatis整合
04-27
springboot-2.0.1.RELEASE + mybatis+mysql完整Demo带sql建表语句，适合刚接触springboot的程序员参考学习
spring boot 2.0.1整合MyBatis
ZuoZuoYin2005的博客
03-21 2360
1.导入依赖&lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-web&lt;/artifactId&gt; &lt;/dependency&gt; &lt;dependency&gt; &lt;g
springboot2.0.1（目前最新版本）整合redis集群和多索引库solr，同时将redis集群作mybatis的二级缓存
WoddenFish的博客
05-10 1797
springboot2.0.1版本相对之前的版本来说有较大的改动，所以在配置的时候不太一样。1.pom.xml&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-in...
spring boot 2.0.1中文文档.pdf
03-18
spring boot 2.0.1中文文档的副本可供您自己使用和分发给其他人, 前提是您不收取此类副本的任何费用, 并进一步规定每份副本都包含此版权声明, 无论是以印刷品或电子方式分发的。
Springboot2.0 + Mybatis组合搭建
LMC技术人生专栏
07-10 771
springBoot 选择2.0版本1、访问http://start.spring.io/打包下载，用maven 导入下载的项目 开发工具：Eclipse  Neon.1a Release (4.6.1)jdk：1.8.0_152maven:4.0.0  增加 两个插件  PageHelper 分页插件  mybatis generator 自动生成代码插件查看一下pom.xml  增加一些依赖包...
Springboot2.0.1整合Quartz动态定时任务
09-15
总结，通过SpringBoot 2.0.1整合Quartz，我们可以轻松地管理和执行定时任务。同时结合MyBatis-Plus，我们可以将任务信息存储在数据库中，实现任务的动态管理。这样的集成方案既灵活又实用，对于需要定时任务的Web...
SpringBoot 2.0 整合 Mybatis
浮游
07-25 3148
写在前言： 学习前后端分离也有一段时间了，基于Vue + Spring Boot + mybaits + webpack2 恰逢得知Spring Boot已经升级到2.0，闲来无事研究了下Spring Boot 2.0 整合了一个Spring Boot2.0 + Mybatis 的demo 并成功运行。 搭建期间也遇到很多坑，好在一一解决~ 本文主要分享 SpringBoot2.0 和...
SpringBoot整合Mybatis和Redis
yananye的博客
07-13 1372
Java配置的方式 Spring从开始出现到现在，共经历了5个大的版本，并依次推出了3种配置方式：XML配置，注解配置和Java配置。 实现Java配置方式 示例：创建一个userBean： public class User { private Integer userId; private String userName; public User() { } @Override public String toString() {
mybatis-spring-boot-starter-2.0.0.jar
02-18
mybatis mybatis-spring-boot-starter-2.0.0.jar下载
mybatis-spring-2.0.0.jar
01-08
mybatis-spring-2.0.0.jar
mybatis-spring-boot-starter-2.0.1.jar
01-10
mybatis-spring-boot-starter-2.0.1.jarmybatis-spring-boot-starter-2.0.1.jarmybatis-spring-boot-starter-2.0.1.jar
mybatis-spring.jar整合包(包含两个版本，有源码jar包)
11-29
包含mybatis-spring-1.2.3-javadoc.jar和mybatis-spring-1.2.3-sources.jar源码及文档包
springBoot(2.0.1.RELEASE)解读
最新发布
weixin_58491584的博客
10-30 282
springBoot(2.0.1.RELEASE)详细解读
springboot2.0+mybatis实现读写分离
xiaoxiaoxiao_Ming的博客
11-04 407
一、application.yml配置文件 server: port: 8080 servlet: context-path: /cm spring: datasource: type: com.alibaba.druid.pool.DruidDataSource druid: master: driver-class-name: com.mysql.cj.jdbc.Driver username: username
SpringBoot 2.0入门（1）
一个码农的博客
10-15 3948
1.在eclipse中创建一个Maven工程 创建名为”helloworld” 类型为Jar工程项目。 2.pom文件引入依赖 在pom中加入如下代码： &amp;amp;lt;parent&amp;amp;gt; &amp;amp;lt;groupId&amp;amp;gt;org.springframework.boot&amp;amp;lt;/groupId&amp;amp;gt; &amp;amp;lt;artifactId&
springboot2.0+版本创建dataSource时报异常
wade_2hou的博客
08-15 1105
今天使用springboot2.0.2版本的时候配置阿里的druid的数据库连接池时，出现下面的异常。 以前使用springboot1.5的时候从没有出现过，折腾了一个多小时终于找到问题了 在启动类中加上如下配置就可以使用了 ...
io.jsonwebtoken.UnsupportedJwtException: Signed Claims JWSs are not supported.
中二啊的博客
02-02 1572
解决方案 claims = Jwts.parser().setSigningKey(secret).parseClaimsJwt(token).getBody(); claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody(); 看出来这两个有什么不同吗？ 一个是parseClaimsJws(token)一个是parseClaimsJwt(token) 应该用第一个，真的离谱。 贴出国外的论坛上面的 https:
springboot2整合mybatis
06-02
好的，下面是Spring Boot 2整合MyBatis的步骤： 1. 首先，在pom.xml文件中添加以下依赖： ``` <groupId>org.springframework.boot <artifactId>spring-boot-starter-web <groupId>org.mybatis.spring....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值