SpringBoot整合

最新推荐文章于 2024-07-26 15:01:45 发布
最新推荐文章于 2024-07-26 15:01:45 发布
阅读量925 收藏 5
点赞数 1
分类专栏： Springboot 文章标签： SpringBoot Druid Mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/userlhj/article/details/89878660
版权

开发环境
开发工具：IntelliJ IDEA
框架：springboot、Maven、Mybatis（也可以用JPA）
JDK：1.8
一、首先你要知道什么是SpringBoot
在Spring框架这个大家族中，产生了很多衍生框架，比如 Spring、SpringMvc框架等，Spring的核心内容在于控制反转(IOC)和依赖注入(DI),所谓控制反转并非是一种技术，而是一种思想，在操作方面是指在spring配置文件中创建，依赖注入即为由spring容器为应用程序的某个对象提供资源，比如 引用对象、常量数据等。
SpringBoot是一个框架，一种全新的编程规范，他的产生简化了框架的使用，所谓简化是指简化了Spring众多框架中所需的大量且繁琐的配置文件，所以 SpringBoot是一个服务于框架的框架，服务范围是简化配置文件。
SpringBoot最明显的特点是，让文件配置变的相当简单、让应用部署变的简单（SpringBoot内置服务器，并装备启动类代码），可以快速开启一个Web容器进行开发。

二、IDEA 创建SpringBoot项目
1、打开idea→File→New→Project
在这里插入图片描述
2、Spring Initializr→选择Project SDK→Next
在这里插入图片描述
3、填写好内容后点击Next
在这里插入图片描述
4、点击Web→勾选Web→Next
在这里插入图片描述
5、点击Finish
在这里插入图片描述
6、首先我们需要依赖SpringBoot的父工程，这是每个项目都要有的
①

    <!-- SpringBoot父依赖 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/>
    </parent>
    <!-- JAVA版本与编码 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

②启动WEB模块要引入WEB模块的依赖

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
 </dependency>

③然后需要创建SpringBoot的启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@ComponentScan("com.quotation")
public class QuotationApplication {
    public static void main(String[] args) {
        SpringApplication.run(QuotationApplication.class, args);
    }

@SpringBootApplication是一个复合注解，包括@ComponentScan，和@SpringBootConfiguration，@EnableAutoConfiguration。

  1. @SpringBootConfiguration继承自@Configuration，二者功能也一致，标注当前类是配置类，并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到srping容器中，并且实例名就是方法名。
  2. @EnableAutoConfiguration的作用启动自动的配置，@EnableAutoConfiguration注解的意思就是Springboot根据你添加的jar包来配置你项目的默认配置，比如根据spring-boot-starter-web ，来判断你的项目是否需要添加了webmvc和tomcat，就会自动的帮你配置web项目中所需要的默认配置。在下面博客会具体分析这个注解，快速入门的demo实际没有用到该注解。
  3. @ComponentScan，扫描当前包及其子包下被@Component，@Controller，@Service，@Repository注解标记的类并纳入到spring容器中进行管理。是以前的context:component-scan（以前使用在xml中使用的标签，用来扫描包配置的平行支持）。所以本demo中的User为何会被spring容器管理。

然后需要配置application.yml（或者application.properties）

#设置端口号和context path
server:
  port: 8088
  servlet:
    context-path: /quotation
    
#使用thymeleaf
spring:
  thymeleaf:
    cache: false
    suffix: .html
    prefix: classpath:/templates/

（注意：使用thymeleaf，需要引入thymeleaf依赖，你也可以用Spring Boot支持的其他模板技术，具体请自行查找资料）

④创建Controller


@RestController
@RequestMapping("hello")
public class HelloController {

    @RequestMapping("helloworld")
    public String say(){
        return "hello world";
    }
    
    @RequestMapping("/test")
    public ModelAndView test(){
        return new ModelAndView("index");
    }

}

在这里插入图片描述
三、集成Mybatis
接下来我会集成logback（日志）和Druid（阿里开源的数据库连接池）
1、首先要引入jar包(数据库使用的是Oracle，若不用Oracle引入其它对应的依赖即可)

        <!--jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--SpringBoot MyBatis启动器-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.2.2</version>
        </dependency>
         <!--oracle-->
        <dependency>
            <groupId>ojdbc</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>11.2.0.3</version>
        </dependency>
     <!-- 数据库连接池 -->
       <!-- <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

2、使用logback日志
直接在resources目录下创建logback.xml文件。（也可以在application.yml中做普通的配置，关于日志文件的命名格式，可以百度下springboot所支持的日志命名格。）
logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
<!-- scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true -->
<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
<!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
<configuration>
    <contextName>logback</contextName>
    <!-- name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义变量后，可以使“${}”来使用变量。 -->
    <property name="log.path" value="../customlogs" />

    <!--输出到控制台-->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
           <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>

    <!--输出到文件-->
    <!-- 时间滚动输出 level为 DEBUG 日志 -->
    <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_debug.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志归档 -->
            <fileNamePattern>${log.path}/debug/log-debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录debug级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>debug</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 时间滚动输出 level为 INFO 日志 -->
    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_info.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 每天日志归档路径以及格式 -->
            <fileNamePattern>${log.path}/info/log-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录info级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>info</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 时间滚动输出 level为 WARN 日志 -->
    <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_warn.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/warn/log-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录warn级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>warn</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>


    <!-- 时间滚动输出 level为 ERROR 日志 -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_error.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/error/log-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录ERROR级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!--
        <logger>用来设置某一个包或者具体的某一个类的日志打印级别、
        以及指定<appender>。<logger>仅有一个name属性，
        一个可选的level和一个可选的addtivity属性。
        name:用来指定受此logger约束的某一个包或者具体的某一个类。
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
              还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。
              如果未设置此属性，那么当前logger将会继承上级的级别。
        addtivity:是否向上级logger传递打印信息。默认是true。
    -->
    <!--<logger name="org.springframework.web" level="info"/>-->
    <!--<logger name="org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor" level="INFO"/>-->
    <!--
        使用mybatis的时候，sql语句是debug下才会打印，而这里我们只配置了info，所以想要查看sql语句的话，有以下两种操作：
        第一种把<root level="info">改成<root level="DEBUG">这样就会打印sql，不过这样日志那边会出现很多其他消息
        第二种就是单独给dao下目录配置debug模式，代码如下，这样配置sql语句会打印，其他还是正常info级别：
     -->


    <!--
        root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
        不能设置为INHERITED或者同义词NULL。默认是DEBUG
        可以包含零个或多个元素，标识这个appender将会添加到这个logger。
    -->

    <root level="info">
        <appender-ref ref="CONSOLE" />
        <appender-ref ref="DEBUG_FILE" />
        <appender-ref ref="INFO_FILE" />
        <appender-ref ref="WARN_FILE" />
        <appender-ref ref="ERROR_FILE" />
    </root>
</configuration>

在application.yml中添加以下代码可以打印SQL语句

#打印SQL，把level下的路径换成你对应mapper包路径
logging:
  level:
    com:
      vtech:
        quotation:
          mapper: debug

控制台输出
（PS：解析一下为什么不需要引入jar包。因为springboot本身就内置了日志功能，springboot的pom文件都会引一个parent，里面就包含了日志包。）

3、使用Druid连接池
①application.yml加入以下配置

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    # 配置Druid的其他参数，以下配置必须增加一个配置文件才能有效
    # 初始化大小，最小，最大
    druid:
     url: jdbc:oracle:thin:#你oracle数据库系统的地址
     username: #数据库登录名
     password: #密码
     driver-class-name: oracle.jdbc.OracleDriver
     # 连接池配置
     initial-size: 1
     max-active: 20
     min-idle: 1
     max-wait: 10000
     pool-prepared-statements: true
     max-open-prepared-statements: 20
     validation-query: SELECT 1 FROM DUAL
     validation-query-timeout: 5000
     test-on-borrow: false
     test-on-return: false
     test-while-idle: true
     time-between-eviction-runs-millis: 60000
     min-evictable-idle-time-millis: 30000
     max-evictable-idle-time-millis: 60000
     removeAbandoned: true
     removeAbandonedTimeout: 1800
     connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
     max-pool-prepared-statement-per-connection-size: 20
     filters: stat,wall #filters: #配置多个英文逗号分隔(统计，sql注入，log4j过滤)

②创建DruidConfig.java
（其中@Slf4j是使用了lombok插件，详情请看lombok安装，使用了该注解输出日志直接log. 即可，替代了private static final Logger logger = LoggerFactory.getLogger(DruidConfig.class);）

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
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.util.HashMap;
import java.util.Map;

@Configuration
@Slf4j
public class DruidConfig {

    @Value("${spring.datasource.druid.url}")
    private String dbUrl;

    @Value("${spring.datasource.druid.username}")
    private String username;

    @Value("${spring.datasource.druid.password}")
    private String password;

    @Value("${spring.datasource.druid.driver-class-name}")
    private String driverClassName;

    @Value("${spring.datasource.druid.initial-size}")
    private int initialSize;

    @Value("${spring.datasource.druid.min-idle}")
    private int minIdle;

    @Value("${spring.datasource.druid.max-active}")
    private int maxActive;

    @Value("${spring.datasource.druid.max-wait}")
    private int maxWait;

    @Value("${spring.datasource.druid.time-between-eviction-runs-millis}")
    private int timeBetweenEvictionRunsMillis;

    @Value("${spring.datasource.druid.min-evictable-idle-time-millis}")
    private int minEvictableIdleTimeMillis;

    @Value("${spring.datasource.druid.validation-query}")
    private String validationQuery;

    @Value("${spring.datasource.druid.test-while-idle}")
    private boolean testWhileIdle;

    @Value("${spring.datasource.druid.test-on-borrow}")
    private boolean testOnBorrow;

    @Value("${spring.datasource.druid.test-on-return}")
    private boolean testOnReturn;

    @Value("${spring.datasource.druid.pool-prepared-statements}")
    private boolean poolPreparedStatements;

    @Value("${spring.datasource.druid.max-pool-prepared-statement-per-connection-size}")
    private int maxPoolPreparedStatementPerConnectionSize;

    @Value("${spring.datasource.druid.filters}")
    private String filters;

    @Value("{spring.datasource.druid.connection-properties}")
    private String connectionProperties;

    @Bean     //声明其为Bean实例
    @Primary  //在同样的DataSource中，首先使用被标注的DataSource
    public DataSource dataSource() {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(dbUrl);
        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.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        try {
            datasource.setFilters(filters);
        } catch (Exception e) {
            log.error("druid configuration initialization filter", e);
        }
        datasource.setConnectionProperties(connectionProperties);

        return datasource;
    }

    @Bean
    public ServletRegistrationBean druidServlet() {
        //logger.info("init Druid Servlet Configuration ");
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean();
        servletRegistrationBean.setServlet(new StatViewServlet());
        servletRegistrationBean.addUrlMappings("/druid/*");
        Map<String, String> initParameters = new HashMap<>();
        initParameters.put("loginUsername", "admin");// 用户名
        initParameters.put("loginPassword", "admin");// 密码
        //initParameters.put("resetEnable", "");// 禁用HTML页面上的“Reset All”功能
        initParameters.put("allow", ""); // IP白名单 (没有配置或者为空，则允许所有访问)
        //initParameters.put("deny", "192.168.20.38");// IP黑名单 (存在共同时，deny优先于allow)
        servletRegistrationBean.setInitParameters(initParameters);
        return servletRegistrationBean;
    }


    @Bean
    public FilterRegistrationBean druidWebStatViewFilter() {
        FilterRegistrationBean registrationBean = new FilterRegistrationBean(new WebStatFilter());
        registrationBean.addInitParameter("urlPatterns", "/*");
        registrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*");
        return registrationBean;
    }

}

4、集成mybatis
目录结构
①分别如图创建两个mapper文件夹，一个放interface（src/main/java），一个放xml(resources)

创建Users.java

@Data
public class Users {
    private BigDecimal userId;
    private String userName;
    private String password;
    }

创建UsersMapper.java
（@Repository 加上这个注解在使用@Autowired时就不会报错,@Mapper声明这是一个mapper）

@Mapper
@Repository
public interface UsersMapper {
    List<Users> findAll();
}

创建UsersMapper.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.vtech.quotation.mapper.UsersMapper">
    <resultMap id="BaseResultMap" type="com.vtech.quotation.pojo.Users">
        <id column="USER_ID" jdbcType="DECIMAL" property="userId"/>
        <result column="USER_NAME" jdbcType="VARCHAR" property="userName"/>
        <result column="PASSWORD" jdbcType="VARCHAR" property="password"/>
    </resultMap>
    <sql id="result_Internal_User">
        USER_ID, USER_NAME, FIRST_NAME, LAST_NAME, STATUS, EMAIL_ADDRESS, ISMANAGER,
        BU, CREATE_BY, CREATION_DATE, MODIFIED_BY,
        MODIFIED_DATE
    </sql>

    <select id="findAll" resultMap="BaseResultMap">
        select
        <include refid="result_Internal_User"/>
        from USERS
    </select>
</mapper>

②application.yml添加mybatis配置

mybatis:
  #config-location: classpath:mybatis-config.xml  # mybatis配置文件所在路径
  mapper-locations: classpath:mapper/*.xml   # 所有的mapper映射文件
  type-aliases-package: com.vtech.quotation.mapper # 定义所有操作类的别名所在包

③springboot启动类添加
@MapperScan(value = “com.vtech.quotation.mapper”)添加了这个注解就不用每个mapper类都添加@Mapper了
@ComponentScan(basePackages = “com.vtech”)

@SpringBootApplication
@MapperScan(value = "com.vtech.quotation.mapper")
@ComponentScan(basePackages = "com.vtech")
public class QuotationApplication {
    public static void main(String[] args) {
        SpringApplication.run(QuotationApplication.class, args);
    }

}

④测试HelloController .java

@RestController
@RequestMapping("hello")
@Slf4j
public class HelloController {
    @Autowired
    UsersMapper usersMapper；

    @RequestMapping("findAll")
    public JsonResult findall(){
        return new JsonResult(usersMapper.findAll());
    }

}

在这里插入图片描述
⑤测试Druid
在浏览其中输入http://localhost:端口号/你的context-path/druid 即可访问
例如：http://localhost:8088/quotation/druid
在这里插入图片描述
输入你配置的druid账号密码登录，即可查看监控。

在这里插入图片描述

jacksonjj
关注
专栏目录
springboot整合canal
02-23
SpringBoot整合Canal是将阿里巴巴开源的数据库实时变更数据订阅与推送组件Canal与SpringBoot框架结合，以实现高效的数据同步。Canal主要用于数据库的实时增量数据同步，它能够监听MySQL数据库的binlog事件，当数据库...
SpringBoot引入jieba分词
zhiyikeji的博客
11-17 1825
1.添加maven依赖 <!-- https://mvnrepository.com/artifact/com.huaban/jieba-analysis --> <dependency> <groupId>com.huaban</groupId> <artifactId>jieba-analysis</artifactId> <ve
Springboot项目整合jieba分词，实现语句最精确的切分
Hello World
08-05 2002
Springboot项目整合jieba分词，实现语句最精确的切分
Springboot 集成Mybatis
最新发布
lay_lu的博客
07-26 1649
MyBatis 是一个灵活且强大的数据持久化框架，它允许开发者控制 SQL 执行并提供了多种映射功能。与 Spring Boot 集成后，能够利用 Spring Boot 的自动配置和便利性，简化配置和开发过程。通过以上步骤，你可以快速地将 MyBatis 集成到 Spring Boot 项目中，充分发挥两者的优势，提高开发效率和系统的可维护性。
SpringBoot常用技术集成
陌殇殇的博客
06-09 857
核心配置文件 1. @ConfigurationProperties @ConfigurationProperties: 把配置文件的数据映射为java对象。属性：prefix 配置文件中的某些key的开头的内容。 application.properties 2. 集成Mybatis-Plus 1.导入依赖 2.核心配置文件 3.代码生成类 4.添加@Mapper或@MapperScan注解注意：自动生成的实体类中时间类型为 LocalDateTime，格式为年月日时分秒，为java8推荐使用，Local
springboot整合
m0_69521840的博客
04-13 376
Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程 . 理解:spring框架搭建的步骤:[1]依赖 [2]配置文件。使用springboot可以简化上面的两个步骤。（简称 MP）是一个的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。我们的愿景是成为 MyBatis 最好的搭档，就像魂斗罗中的 1P、2P，基友搭配，效率翻倍。
总结SpringBoot都整合了哪些资源
qq_43518557的博客
06-04 1608
总结SpringBoot都整合了哪些资源 学习了两天的SpringBoot,今天就先总结一下,SpringBoot整合了哪些 资源. 1.SpringBoot整合MyBatis 配置mybatis的启动器 <!--mybatis的启动器--> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artif
springboot整合Sentinel
02-21
SpringBoot整合Sentinel是将阿里巴巴开源的微服务流量控制组件Sentinel与SpringBoot应用相结合的过程。Sentinel是一款强大的流量控制、熔断降级、系统负载保护的工具，它旨在帮助开发者实现优雅的服务治理，保障系统...
springboot 整合grpc
09-04
SpringBoot 整合gRPC是一项将Google开发的高性能、开源的RPC框架gRPC与流行的Java微服务框架SpringBoot结合的技术实践。gRPC基于HTTP/2协议，使用Protocol Buffers（protobuf）作为数据交换格式，提供了强类型、高效...
Springboot整合Urule的方法步骤
08-25
Springboot整合Urule的方法步骤 本文主要介绍了Springboot整合Urule的方法步骤，通过引入Urule相关依赖和配置文件，实现了Urule-Serve端和Urule-Client端的分离部署。下面将详细介绍整合Urule的方法步骤。 一、...
springboot整合nacos完整代码
04-15
SpringBoot整合Nacos是现代Java微服务架构中常见的配置中心和发现服务的组合。Nacos作为阿里开源的一款轻量级的服务发现和配置管理工具，它提供了动态配置、服务发现、健康检查、命名空间隔离等功能，使得微服务环境...
springboot整合各大常用框架
08-24
整合了流行的auth2.0安全技术，redis缓存，rabbitmq消息中间件，mqtt协议，mybatis框架，以及linux服务运行脚本。
SpringBoot是什么？
热门推荐
记录并分享
02-10 2万+
SpringBoot是整合Spring技术栈的一站式框架，是简化Spring技术栈的快速开发脚手架，是一个能够快速构建生产级别的Spring应用的工具。
Spring Boot集成六大常用中间件，附集成源码，亲测有效
学Java，找哪吒
05-28 3358
华为OD机试 2023B卷题库疯狂收录中，刷题。
SpringBoot 的相关整合
等待のL先森的博客
05-20 304
SpringBoot 的相关整合 一， 前言： ssm 固然好用，但是由于spring的配置文件 ， mybatis 的配置文件 等 这些配置文件过多 。 而造成了开发者会有很多的时间放在配置文件的上面。 而基于此， 又发明了springBoot 框架 用来简化配置 ， 使开发人员可以把精力集中在业务代码的处理问题上 ； 所以 springBoot 也越来越多人使用 ； 二 ， springboot整合 2.1 添加依赖： <?xml version="1.0" encoding="UTF-
Springboot 多数据源整合的三种方式
阿远的博客
01-20 1744
Springboot+Mybatis多数据源配置的三种方式: 1. 使用Spring提供的AbstractRoutingDataSource. 2. 使用MyBatis注册多个SqlSessionFactory. 3. 使用dynamic-datasource框架
SpringBoot框架整合超详细
weixin_51539416的博客
11-16 4153
SpringBoot框架 1.什么是SpringBoot？ SpringBoot是一个框架，一种全新的编程规范，它的产生简化了框架的使用，所谓简化是指简化了Spring众多框架中所需的大量且繁琐的配置文件，所以SpringBoot是一个服务于框架的框架，服务范围是简化配置文件。 1.1 SpringBoot的优缺点。 SpringBoot的优点 约定优于配置思想 专注与业务逻辑之间思维切换 基于Spring的开发提供更快入门体验 开箱即用，没有代码生成，无需XML配置。 支持修改默认配置
一个 SpringBoot 项目该包含哪些？
程序员闪充宝
02-09 400
作者：不一样的科技宅juejin.im/post/6844904083942277127前言建立一个全新的项目，或者把旧的庞大的项目，进行拆分成多个项目。在建立新的项目中，经常需要做一些...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值